1 | ;
|
2 |
|
3 | Object.defineProperty(exports, "__esModule", {
|
4 | value: true
|
5 | });
|
6 |
|
7 | var _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 |
|
17 | exports.time = time;
|
18 | exports.angle = angle;
|
19 | exports.error = error;
|
20 | exports.angleError = angleError;
|
21 |
|
22 | var _base = require('./base');
|
23 |
|
24 | var _base2 = _interopRequireDefault(_base);
|
25 |
|
26 | var _interpolation = require('./interpolation');
|
27 |
|
28 | var _interpolation2 = _interopRequireDefault(_interpolation);
|
29 |
|
30 | function _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 | */
|
53 | function 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 | */
|
76 | function 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 | */
|
106 | function 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 | */
|
152 | function 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 |
|
203 | exports.default = {
|
204 | time: time,
|
205 | angle: angle,
|
206 | error: error,
|
207 | angleError: angleError
|
208 | }; |
\ | No newline at end of file |