Initial commit

Author: sdrazen

.gitignore

@@ -0,0 +1,2 @@
+# Dependency directories
+node_modules/

LICENSE.md

@@ -0,0 +1,20 @@
+Copyright (c) 2011-2017 GitHub Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -0,0 +1,97 @@
+# Astro Calculator
+
+This npm package performs astronomical calculations and conversions. If you are attempting to write an app which has to do with astronomy, this package can be of great help as you don't have to search for formulae or methods to perform a certain astronomical calculation or conversion.
+
+## Installing
+
+```bash
+npm install astro-calculator
+```
+
+## Getting started
+
+This package provides following functionalities (all parameters are of type `number`):
+
+- `getDaysFromJ2000`: calculates number of days from 2000-01-01 at noon until now
+  - `parameters`: year, month, day, hours, minutes
+  - `returns`: number
+- `getLocalSiderialTime`: calculates local siderial time
+  - `parameters`: year, month, day, hours, minutes, LON
+  - `returns`: number
+- `getHourAngle`: calculates hour angle
+  - `parameters`: localSiderialTime, RA
+  - `returns`: number
+- `getAltAz`: calculates altitude and azimuth
+  - `parameters`: RA, DEC, LAT, LON, year, month, day, hours, minutes (RA - hours decimal; DEC, LAT, LON - degrees decimal)
+  - `returns`: array of numbers - [Alt, Az] as degrees decimal
+- `isLeapYear`: determines if year is leap or not
+  - `parameters`: year
+  - `returns`: boolean
+- `convertToHours`: converts to hours
+  - `parameters`: hours, minutes, seconds
+  - `returns`: number
+- `convertToDegreesDecimal`: converts to degrees decimal
+  - `parameters`: degrees, minutes, seconds
+  - `returns`: number
+- `convertRAToDegreesDecimal`: converts RA to degrees decimmal
+  - `parameters`: RA
+  - `returns`: number
+- `convertDegreesToRadians`: converts degrees to radians
+  - `parameters`: degrees
+  - `returns`: number
+- `convertRadiansToDegrees`: converts radians to degrees
+  - `parameters`: radians
+  - `returns`: number
+- `convertDegreesDecimalToDegreesMinutesSeconds`: converts degrees decimal to degrees, minutes and seconds
+  - `parameters`: degrees
+  - `returns`: array of numbers - [deg, min, sec]
+
+## Usage
+
+Just import the package and use its functions with appropriate parameters, like so:
+
+```javascript
+const ac = require("../astro-calculator");
+
+let getDaysFromJ2000 = ac.getDaysFromJ2000(2022, 9, 16, 18, 32);
+let getLocalSiderialTime = ac.getLocalSiderialTime(2022, 9, 16, 18, 32, 16.03);
+let getHourAngle = ac.getHourAngle(8549.15, 6.45);
+let getAltAz = ac.getAltAz(6.45, 29, 45.81, 15.97, 2022, 9, 16, 17, 01);
+let isLeapYear = ac.isLeapYear(2022);
+let convertToHours = ac.convertToHours(18, 30, 21);
+let convertToDegreesDecimal = ac.convertToDegreesDecimal(123, 29, 33);
+let convertRAToDegreesDecimal = ac.convertRAToDegreesDecimal(6.45);
+let convertDegreesToRadians = ac.convertDegreesToRadians(36.87);
+let convertRadiansToDegrees = ac.convertRadiansToDegrees(0.6435);
+let convertDegreesDecimalToDegreesMinutesSeconds = ac.convertDegreesDecimalToDegreesMinutesSeconds(123.38);
+
+console.log("getDaysFromJ2000: " + getDaysFromJ2000);
+console.log("getLocalSiderialTime: " + getLocalSiderialTime);
+console.log("getHourAngle: " + getHourAngle);
+console.log("getAltAz: " + getAltAz);
+console.log("isLeapYear: " + isLeapYear);
+console.log("convertToHours: " + convertToHours);
+console.log("convertToDegreesDecimal: " + convertToDegreesDecimal);
+console.log("convertRAToDegreesDecimal: " + convertRAToDegreesDecimal);
+console.log("convertDegreesToRadians: " + convertDegreesToRadians);
+console.log("convertRadiansToDegrees: " + convertRadiansToDegrees);
+console.log("convertDegreesDecimalToDegreesMinutesSeconds: " + convertDegreesDecimalToDegreesMinutesSeconds);
+```
+
+and results look like this in the console:
+
+```
+getDaysFromJ2000: 8294.272222222222
+getLocalSiderialTime: 8569.714533016668
+getHourAngle: 8542.699999999999
+getAltAz: -14.650875603437063,351.0514900218268
+isLeapYear: false
+convertToHours: 18.50583333333333
+convertToDegreesDecimal: 123.4925
+convertRAToDegreesDecimal: 96.75
+convertDegreesToRadians: 0.6435028952103092
+convertRadiansToDegrees: 36.86983411666847
+convertDegreesDecimalToDegreesMinutesSeconds: 123,22,48
+```
+
+**Note**: When asked for time (hour and minues) in parameters of functions for example (`getAltAz`), remember to provide UTC time, not your local current time. This, of course, doesn't apply to the function `convertToHours` which will convert to hours any value of hours, minutes and seconds you provide it to convert - that's another story because it has nothing to do with calculating siderial time, hour angle or alt/az.

app.js

@@ -0,0 +1,138 @@
+function getDaysFromJ2000(year, month, day, hours, minutes) {
+
+    let daysFromJ2000 = 0;
+
+    const daysToBeginningOfMonth = [ [1, 0, 0], [2, 31, 31], [3, 59, 60], [4, 90, 91], [5, 120, 121], [6, 151, 152], [7, 181, 182], [8, 212, 213], [9, 243, 244], [10, 273, 274], [11, 304, 305], [12, 334, 335] ];
+    const daysSinceJ2000ToBeginningOfYear = [ [1998, -731.5], [1999, -366.5], [2000, -1.5], [2001, 364.5], [2002, 729.5], [2003, 1094.5], [2004, 1459.5], [2005, 1825.5], [2006, 2190.5], [2007, 2555.5], [2008, 2920.5], [2009, 3286.5], [2010, 3651.5], [2011, 4016.5], [2012, 4381.5], [2013, 4747.5], [2014, 5112.5], [2015, 5477.5], [2016, 5842.5], [2017, 6208.5], [2018, 6573.5], [2019, 6938.5], [2020, 7303.5], [2021, 7669.5], [2022, 8034.5], [2023, 8399.5], [2024, 8764.5], [2025, 9130.5], [2026, 9495.5], [2027, 9860.5], [2028, 10225.5] ];
+
+    // Calculate fraction of the day
+    let fractionOfDay = (hours + minutes / 60) / 24;
+
+    // Find number of days to the beginning of month
+    let numberOfDaysToBeginningOfMonth = 0;
+
+    daysToBeginningOfMonth.forEach(element => {
+        if (element[0] === month) {
+            if (this.isLeapYear(year)) {
+                numberOfDaysToBeginningOfMonth = element[2];
+            } else {
+                numberOfDaysToBeginningOfMonth = element[1];
+            }
+        }
+    })
+
+    // Find days since J2000.0 to the beginning of the year
+    let numberOfDaysSinceJ2000ToBeginningOfYear = 0;
+
+    daysSinceJ2000ToBeginningOfYear.forEach(element => {
+        if (element[0] === year) {
+            numberOfDaysSinceJ2000ToBeginningOfYear = element[1];
+        }
+    })
+
+    // Add these calculations to get daysFromJ2000
+    daysFromJ2000 = fractionOfDay + numberOfDaysToBeginningOfMonth + day + numberOfDaysSinceJ2000ToBeginningOfYear;
+
+    return daysFromJ2000;
+
+  }
+
+  function getLocalSiderialTime(year, month, day, hours, minutes, LON) {
+
+    let localSiderialTime = 0;
+
+    // Calculate fraction of the day
+    let UT = (hours + minutes / 60);
+
+    // Calculate days from J2000
+    let daysFromJ2000 = this.getDaysFromJ2000(year, month, day, hours, minutes);
+
+    // Calculate local siderial time, add 360 if negative
+    localSiderialTime = (100.46 + 0.985647 * daysFromJ2000 + LON + 15 * UT) < 0 ? ((100.46 + 0.985647 * daysFromJ2000 + LON + 15 * UT) + 360) : (100.46 + 0.985647 * daysFromJ2000 + LON + 15 * UT);
+
+    return localSiderialTime;
+
+  }
+
+  function getHourAngle(localSiderialTime, RA) {
+    return (localSiderialTime - RA) < 0 ? localSiderialTime - RA + 360 : localSiderialTime - RA;
+  }
+
+  function getAltAz(RA, DEC, LAT, LON, year, month, day, hours, minutes) {
+
+      // RA - hours decimal
+      // DEC, LAT, LON - degrees decimal
+      // Result - degrees decimal (array of two numbers, altitude and azimuth)
+
+      let AltAz = [];
+
+      let HA = this.getHourAngle(this.getLocalSiderialTime(year, month, day, hours, minutes, LON), this.convertRAToDegreesDecimal(RA));
+
+      let sinDEC = Math.sin(this.convertDegreesToRadians(DEC));
+      let sinLAT = Math.sin(this.convertDegreesToRadians(LAT));
+      let sinHA = Math.sin(this.convertDegreesToRadians(HA));
+      let cosDEC = Math.cos(this.convertDegreesToRadians(DEC));
+      let cosLAT = Math.cos(this.convertDegreesToRadians(LAT));
+      let cosHA = Math.cos(this.convertDegreesToRadians(HA));
+
+      let sinALT = sinDEC * sinLAT + cosDEC * cosLAT * cosHA;
+      let ALT = this.convertRadiansToDegrees(Math.asin(sinALT));
+      
+      let cosALT = Math.cos(this.convertDegreesToRadians(ALT));
+      let cosA = (sinDEC - sinALT * sinLAT) / (cosALT * cosLAT);
+      let A = this.convertRadiansToDegrees(Math.acos(cosA));
+
+      let AZ = (sinHA > 0 ? 360 - A : A);
+
+      AltAz = [ALT, AZ];
+
+      return AltAz;
+  }
+
+  function isLeapYear(year) {
+    return (year % 400) ? ((year % 100) ? ((year % 4) ? false : true) : false) : true;
+  }
+
+  function convertToHours(hours, minutes, seconds) {
+    return hours + minutes/60 + seconds/3600;
+  }
+
+  function convertToDegreesDecimal(degrees, minutes, seconds) {
+    return degrees < 0 ? -(Math.abs(degrees) + minutes/60 + seconds/3600) : degrees + minutes/60 + seconds/3600;
+  }
+
+  function convertRAToDegreesDecimal (RA) {
+      return RA * 15;
+  }
+
+  function convertDegreesToRadians(degrees) {
+      return degrees * Math.PI / 180;
+  }
+
+  function convertRadiansToDegrees(radians) {
+      return radians / (Math.PI / 180);
+  }
+
+  function convertDegreesDecimalToDegreesMinutesSeconds(degrees) {
+
+      let deg = parseInt(degrees.toString());
+      let fraction = Math.abs(degrees - deg);
+      let min = parseInt((fraction * 60).toString());
+      let sec = Math.round(fraction * 3600 - min * 60);
+
+      return [deg, min, sec];
+  }
+
+module.exports = {
+  getDaysFromJ2000,
+  getLocalSiderialTime,
+  getHourAngle,
+  getAltAz,
+  isLeapYear,
+  convertToHours,
+  convertToDegreesDecimal,
+  convertRAToDegreesDecimal,
+  convertDegreesToRadians,
+  convertRadiansToDegrees,
+  convertDegreesDecimalToDegreesMinutesSeconds
+}

package.json

@@ -0,0 +1,38 @@
+{
+  "name": "astro-calculator",
+  "version": "1.0.0",
+  "description": "Performs astronomical calculations and conversions",
+  "main": "app.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "astronomy",
+    "calculation",
+    "conversion",
+    "converter",
+    "coordinate",
+    "formulae",
+    "astro",
+    "right ascension",
+    "declination",
+    "degree",
+    "altitude",
+    "azimuth"
+  ],
+  "bugs": {
+    "url": "https://github.com/sdrazen/astro-calculator/issues",
+    "email": "sdrazen@yahoo.com"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sdrazen/astro-calculator"
+  },
+  "author": "Dražen Škrinjarić",
+  "license": "MIT",
+  "dependencies": {
+  }
+}