UNPKG

10.6 kBJavaScriptView Raw
1'use strict';
2
3Object.defineProperty(exports, "__esModule", {
4 value: true
5});
6
7var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); /**
8 * @copyright 2013 Sonia Keys
9 * @copyright 2016 commenthol
10 * @license MIT
11 * @module line
12 */
13/**
14 * Line: Chapter 19, Bodies in Straight Line
15 */
16
17exports.time = time;
18exports.angle = angle;
19exports.error = error;
20exports.angleError = angleError;
21
22var _base = require('./base');
23
24var _base2 = _interopRequireDefault(_base);
25
26var _interpolation = require('./interpolation');
27
28var _interpolation2 = _interopRequireDefault(_interpolation);
29
30function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
31
32/**
33 * Time computes the time at which a moving body is on a straight line (great
34 * circle) between two fixed points, such as stars.
35 *
36 * Coordinates may be right ascensions and declinations or longitudes and
37 * latitudes. Fixed points are r1, d1, r2, d2. Moving body is an ephemeris
38 * of 5 rows, r3, d3, starting at time t1 and ending at time t5. Time scale
39 * is arbitrary.
40 *
41 * @throws Error
42 * @param {Number} r1 - right ascension Coordinate 1
43 * @param {Number} d1 - declination Coordinate 1
44 * @param {Number} r2 - right ascension Coordinate 2
45 * @param {Number} d2 - declination Coordinate 2
46 * @param {Number} r3 - right ascension Coordinate 3
47 * @param {Number} d2 - declination Coordinate 3
48 * @param {Array} d3 -
49 * @param {Array} t1 - time in Julian Days
50 * @param {Array} t5 - time in Julian Days
51 * @returns {Number} time of alignment in Julian Days
52 */
53function time(r1, d1, r2, d2, r3, d3, t1, t5) {
54 // (r1, d1, r2, d2 float64, r3, d3 []float64, t1, t5 float64) (float64, error)
55 if (r3.length !== 5 || d3.length !== 5) {
56 throw new Error('r3, d3 must be length 5');
57 }
58 var gc = new Array(5);
59 r3.forEach(function (r3i, i) {
60 // (19.1) p. 121
61 gc[i] = Math.tan(d1) * Math.sin(r2 - r3i) + Math.tan(d2) * Math.sin(r3i - r1) + Math.tan(d3[i]) * Math.sin(r1 - r2);
62 });
63 var l5 = new _interpolation2.default.Len5(t1, t5, gc);
64 return l5.zero(false);
65}
66
67/**
68 * Angle returns the angle between great circles defined by three points.
69 *
70 * Coordinates may be right ascensions and declinations or longitudes and
71 * latitudes. If r1, d1, r2, d2 defines one line and r2, d2, r3, d3 defines
72 * another, the result is the angle between the two lines.
73 *
74 * Algorithm by Meeus.
75 */
76function angle(r1, d1, r2, d2, r3, d3) {
77 // (r1, d1, r2, d2, r3, d3 float64) float64
78 var _base$sincos = _base2.default.sincos(d2),
79 _base$sincos2 = _slicedToArray(_base$sincos, 2),
80 sd2 = _base$sincos2[0],
81 cd2 = _base$sincos2[1];
82
83 var _base$sincos3 = _base2.default.sincos(r2 - r1),
84 _base$sincos4 = _slicedToArray(_base$sincos3, 2),
85 sr21 = _base$sincos4[0],
86 cr21 = _base$sincos4[1];
87
88 var _base$sincos5 = _base2.default.sincos(r3 - r2),
89 _base$sincos6 = _slicedToArray(_base$sincos5, 2),
90 sr32 = _base$sincos6[0],
91 cr32 = _base$sincos6[1];
92
93 var C1 = Math.atan2(sr21, cd2 * Math.tan(d1) - sd2 * cr21);
94 var C2 = Math.atan2(sr32, cd2 * Math.tan(d3) - sd2 * cr32);
95 return C1 + C2;
96}
97
98/**
99 * Error returns an error angle of three nearly co-linear points.
100 *
101 * For the line defined by r1, d1, r2, d2, the result is the anglular distance
102 * between that line and r0, d0.
103 *
104 * Algorithm by Meeus.
105 */
106function error(r1, d1, r2, d2, r0, d0) {
107 // (r1, d1, r2, d2, r0, d0 float64) float64
108 var _base$sincos7 = _base2.default.sincos(r1),
109 _base$sincos8 = _slicedToArray(_base$sincos7, 2),
110 sr1 = _base$sincos8[0],
111 cr1 = _base$sincos8[1];
112
113 var _base$sincos9 = _base2.default.sincos(d1),
114 _base$sincos10 = _slicedToArray(_base$sincos9, 2),
115 sd1 = _base$sincos10[0],
116 cd1 = _base$sincos10[1];
117
118 var _base$sincos11 = _base2.default.sincos(r2),
119 _base$sincos12 = _slicedToArray(_base$sincos11, 2),
120 sr2 = _base$sincos12[0],
121 cr2 = _base$sincos12[1];
122
123 var _base$sincos13 = _base2.default.sincos(d2),
124 _base$sincos14 = _slicedToArray(_base$sincos13, 2),
125 sd2 = _base$sincos14[0],
126 cd2 = _base$sincos14[1];
127
128 var X1 = cd1 * cr1;
129 var X2 = cd2 * cr2;
130 var Y1 = cd1 * sr1;
131 var Y2 = cd2 * sr2;
132 var Z1 = sd1;
133 var Z2 = sd2;
134 var A = Y1 * Z2 - Z1 * Y2;
135 var B = Z1 * X2 - X1 * Z2;
136 var C = X1 * Y2 - Y1 * X2;
137 var m = Math.tan(r0);
138 var n = Math.tan(d0) / Math.cos(r0);
139 return Math.asin((A + B * m + C * n) / (Math.sqrt(A * A + B * B + C * C) * Math.sqrt(1 + m * m + n * n)));
140}
141
142/**
143 * AngleError returns both an angle as in the function Angle, and an error
144 * as in the function Error.
145 *
146 * The algorithm is by B. Pessens.
147 *
148 * @returns {Number[]} [ψ, ω]
149 * {Number} ψ - angle between great circles defined by three points.
150 * {Number} ω - error angle of three nearly co-linear points
151 */
152function angleError(r1, d1, r2, d2, r3, d3) {
153 var _base$sincos15 = _base2.default.sincos(r1),
154 _base$sincos16 = _slicedToArray(_base$sincos15, 2),
155 sr1 = _base$sincos16[0],
156 cr1 = _base$sincos16[1];
157
158 var _base$sincos17 = _base2.default.sincos(d1),
159 _base$sincos18 = _slicedToArray(_base$sincos17, 2),
160 c1 = _base$sincos18[0],
161 cd1 = _base$sincos18[1];
162
163 var _base$sincos19 = _base2.default.sincos(r2),
164 _base$sincos20 = _slicedToArray(_base$sincos19, 2),
165 sr2 = _base$sincos20[0],
166 cr2 = _base$sincos20[1];
167
168 var _base$sincos21 = _base2.default.sincos(d2),
169 _base$sincos22 = _slicedToArray(_base$sincos21, 2),
170 c2 = _base$sincos22[0],
171 cd2 = _base$sincos22[1];
172
173 var _base$sincos23 = _base2.default.sincos(r3),
174 _base$sincos24 = _slicedToArray(_base$sincos23, 2),
175 sr3 = _base$sincos24[0],
176 cr3 = _base$sincos24[1];
177
178 var _base$sincos25 = _base2.default.sincos(d3),
179 _base$sincos26 = _slicedToArray(_base$sincos25, 2),
180 c3 = _base$sincos26[0],
181 cd3 = _base$sincos26[1];
182
183 var a1 = cd1 * cr1;
184 var a2 = cd2 * cr2;
185 var a3 = cd3 * cr3;
186 var b1 = cd1 * sr1;
187 var b2 = cd2 * sr2;
188 var b3 = cd3 * sr3;
189 var l1 = b1 * c2 - b2 * c1;
190 var l2 = b2 * c3 - b3 * c2;
191 var l3 = b1 * c3 - b3 * c1;
192 var m1 = c1 * a2 - c2 * a1;
193 var m2 = c2 * a3 - c3 * a2;
194 var m3 = c1 * a3 - c3 * a1;
195 var n1 = a1 * b2 - a2 * b1;
196 var n2 = a2 * b3 - a3 * b2;
197 var n3 = a1 * b3 - a3 * b1;
198 var ψ = Math.acos((l1 * l2 + m1 * m2 + n1 * n2) / (Math.sqrt(l1 * l1 + m1 * m1 + n1 * n1) * Math.sqrt(l2 * l2 + m2 * m2 + n2 * n2)));
199 var ω = Math.asin((a2 * l3 + b2 * m3 + c2 * n3) / (Math.sqrt(a2 * a2 + b2 * b2 + c2 * c2) * Math.sqrt(l3 * l3 + m3 * m3 + n3 * n3)));
200 return [ψ, ω];
201}
202
203exports.default = {
204 time: time,
205 angle: angle,
206 error: error,
207 angleError: angleError
208};
\No newline at end of file