@openglobus/og 0.18.0 → 0.18.2

package/lib/js/math.d.ts

@@ -0,0 +1,266 @@
+import { Vec3 } from "./math/Vec3";
+/** @const */
+export declare const TWO_PI: number;
+/** @const */
+export declare const PI_TWO: number;
+export declare const X = 0;
+export declare const Y = 1;
+export declare const Z = 2;
+export declare const W = 3;
+export declare const MAX_FLOAT: number;
+/** @const */
+export declare const LOG2: number;
+/** @const */
+export declare const MAX32 = 2147483647;
+/** @const */
+export declare const MAX = 549755748352;
+/** @const */
+export declare const MIN: number;
+/** @const */
+export declare const RADIANS: number;
+/** @const */
+export declare const DEGREES: number;
+/** @const */
+export declare const DEGREES_DOUBLE: number;
+/** @const */
+export declare const RADIANS_HALF: number;
+/** @const */
+export declare const ARCSECONDS_TO_RADIANS = 0.00000484813681109536;
+/** @const */
+export declare const RADIANS_TO_HOURS = 3.819718634205488;
+/** @const */
+export declare const HOURS_TO_RADIANS = 0.26179938779914946;
+/** @const */
+export declare const HOURS_TO_DEGREES = 15;
+/** @const */
+export declare const DEGREES_TO_HOURS: number;
+/** @const */
+export declare const SQRT_HALF: number;
+export declare const EPS1 = 0.1;
+export declare const EPS2 = 0.01;
+export declare const EPS3 = 0.001;
+export declare const EPS4 = 0.0001;
+export declare const EPS5 = 0.00001;
+export declare const EPS6 = 0.000001;
+export declare const EPS7 = 1e-7;
+export declare const EPS8 = 1e-8;
+export declare const EPS9 = 1e-9;
+export declare const EPS10 = 1e-10;
+export declare const EPS11 = 1e-11;
+export declare const EPS12 = 1e-12;
+export declare const EPS13 = 1e-13;
+export declare const EPS14 = 1e-14;
+export declare const EPS15 = 1e-15;
+export declare const EPS16 = 1e-16;
+export declare const EPS17 = 1e-17;
+export declare const EPS18 = 1e-18;
+export declare const EPS19 = 1e-19;
+export declare const EPS20 = 1e-20;
+/**
+ * The log function returns the power to which the base value has to be raised to produce n.
+ * @function
+ * @param {number} n - Produce value.
+ * @param {number} base - Base value.
+ * @returns {number} -
+ * @example
+ * log(64, 2)
+ * //returns 6
+ */
+export declare function log(n: number, base: number): number;
+/**
+ * Clamp the number.
+ * @function
+ * @param {number} number - Input number.
+ * @param {number} min - Minimal edge.
+ * @param {number} max - Maximal edge.
+ * @returns {number} -
+ * @example
+ * clamp(12, 1, 5)
+ * //returns 5
+ */
+export declare function clamp(number: number, min: number, max: number): number;
+/**
+ * Converts degrees value to radians.
+ * @function
+ * @param {number} degrees - Degree value.
+ * @returns {number} -
+ */
+export declare function DEG2RAD(degrees: number): number;
+/**
+ * Converts radians value to degrees.
+ * @function
+ * @param {number} angle - Degree value.
+ * @returns {number} -
+ */
+export declare function RAD2DEG(angle: number): number;
+/**
+ * Check the number is a power of two.
+ * @function
+ * @param {number} x - Input value.
+ * @returns {boolean} -
+ */
+export declare function isPowerOfTwo(x: number): boolean;
+/**
+ * Returns next value that is power of two.
+ * @function
+ * @param {number} x - Input value.
+ * @param {number} [maxValue=4096] - Maximal value.
+ * @returns {number} -
+ */
+export declare function nextHighestPowerOfTwo(x: number, maxValue?: number): number;
+/**
+ * Returns random integer number within the bounds.
+ * @function
+ * @param {number} min - Minimal bound.
+ * @param {number} max - Maximal bound.
+ * @returns {number} -
+ */
+export declare function randomi(min?: number, max?: number): number;
+/**
+ * Returns random number within the bounds.
+ * @function
+ * @param {number} [min=0] - Minimal bound.
+ * @param {number} [max=1] - Maximal bound.
+ * @returns {number} -
+ */
+export declare function random(min?: number, max?: number): number;
+/**
+ * Converts degrees value to decimal.
+ * @function
+ * @param {number} d - Degrees.
+ * @param {number} m - Minutes.
+ * @param {number} s - Seconds.
+ * @param {boolean} [p] - Positive flag. False - default.
+ * @returns {number} -
+ **/
+export declare function degToDec(d: number, m: number, s: number, p: number): number;
+/**
+ * The modulo operation that also works for negative dividends.
+ * @function
+ * @param {number} m - The dividend.
+ * @param {number} n - The divisor.
+ * @returns {number} The remainder.
+ */
+export declare function mod(m: number, n: number): number;
+/**
+ * Returns an angle in the range 0 <= angle <= 2Pi which is equivalent to the provided angle.
+ * @function
+ * @param {number} a - Angle in radians
+ * @returns {number} -
+ */
+export declare function zeroTwoPI(a: number): number;
+/**
+ * Returns 0.0 if x is smaller than edge and otherwise 1.0.
+ * @function
+ * @param {number} edge -
+ * @param {number} x - Value to edge.
+ * @returns {number} -
+ */
+export declare function step(edge: number, x: number): number;
+/**
+ * The frac function returns the fractional part of x, i.e. x minus floor(x).
+ * @function
+ * @param {number} x - Input value.
+ * @returns {number} -
+ */
+export declare function frac(x: number): number;
+/**
+ * Returns Math.log(x) / Math.log(2)
+ * @function
+ * @param {number} x - Input value.
+ * @returns {number} -
+ */
+export declare function log2(x: number): number;
+/**
+ * Returns two power of n.
+ * @function
+ * @param {number} n - Power value.
+ * @returns {number} -
+ */
+export declare function exp2(n: number): number;
+/**
+ * Returns two power of integer n.
+ * @function
+ * @param {number} n - Integer power value.
+ * @returns {number} -
+ */
+export declare function pow2i(n: number): number;
+/**
+ * Returns a slice of linear interpolation t * (h1 - h0)
+ * @param {number} t - A value that linearly interpolates between the h0 parameter and the h1 parameter.
+ * @param {number} h1 - End value.
+ * @param {number} h0 - Start value.
+ * @returns {number} -
+ */
+export declare function slice(t: number, h1: number, h0: number): number;
+/**
+ * Performs a linear interpolation.
+ * @function
+ * @param {number} t - A value that linearly interpolates between the h0 parameter and the h1 parameter.
+ * @param {number} h1 - End value.
+ * @param {number} h0 - Start value.
+ * @returns {number} -
+ */
+export declare function lerp(t: number, h1: number, h0: number): number;
+export declare function cube(f: number): number;
+export declare function square(f: number): number;
+export declare function bezier1v(t: number, p0: number, p1: number, p2: number, p3: number): number;
+/**
+ * Performs a 3D bezier interpolation.
+ * @function
+ * @param {number} t - Interpolation value.
+ * @param {Vec3} p0 - First control point.
+ * @param {Vec3} p1 - Second control point.
+ * @param {Vec3} p2 - Third control point.
+ * @param {Vec3} p3 - Fourth control point.
+ * @returns {Vec3} -
+ */
+export declare function bezier3v(t: number, p0: Vec3, p1: Vec3, p2: Vec3, p3: Vec3): Vec3;
+/**
+ * Clamp angle value within 360.
+ * @function
+ * @param {number} x - Input angle.
+ * @returns {number} -
+ */
+export declare function rev(x: number): number;
+/**
+ * Clamp longitude within: -180 to +180 degrees.
+ * @function
+ * @param {number} lon - Longitude.
+ * @returns {number} -
+ */
+export declare function norm_lon(lon: number): number;
+/**
+ * Returns an angle in the range -Pi <= angle <= Pi which is equivalent to the provided angle.
+ * @function
+ * @param {number} a - Angle in radians.
+ * @returns {number} -
+ */
+export declare function negativePItoPI(a: number): number;
+/**
+ * Solve using iteration method and a fixed number of steps.
+ * @function
+ * @param {Function} f - Equation. Used in Euler's equation(see og.orbit) solving.
+ * @param {number} x0 - First approximation.
+ * @param {number} maxIter - Maximum iterations.
+ * @returns {number} -
+ */
+export declare function solve_iteration_fixed(f: (x: number) => number, x0: number, maxIter: number): number;
+/**
+ * Solve using iteration; terminate when error is below err or the maximum
+ * number of iterations is reached. Used in Euler's equation(see og.orbit) solving.
+ * @function
+ * @param {(x: number) => number} f - Equation.
+ * @param {number} x0 - First approximation.
+ * @param {number} err - Maximal accepted error value.
+ * @param {number} maxIter - Maximum iterations.
+ * @returns {number} -
+ */
+export declare function solve_iteration(f: (x: number) => number, x0: number, err: number, maxIter?: number): number;
+/**
+ * Returns angle between two azimuths
+ * @param {number} a - First azimuth angle
+ * @param {number} b - Second azimuth angle
+ * @returns {number}
+ */
+export declare function getAngleBetweenAzimuths(a: number, b: number): number;

package/{src/math.ts → lib/js/math.js}

@@ -1,18 +1,12 @@
-import {Vec3} from "./math/Vec3";
-
 /** @const */
 export const TWO_PI = 2.0 * Math.PI;
-
 /** @const */
 export const PI_TWO = Math.PI / 2.0;
-
 export const X = 0;
 export const Y = 1;
 export const Z = 2;
 export const W = 3;
-
 export const MAX_FLOAT = Number.MAX_VALUE || 1.7976931348623157e308;
-
 /** @const */
 export const LOG2 = Math.log(2);
 /** @const */
@@ -21,17 +15,14 @@ export const MAX32 = 2147483647;
 export const MAX = 549755748352;
 /** @const */
 export const MIN = -MAX;
-
 /** @const */
 export const RADIANS = Math.PI / 180.0;
 /** @const */
 export const DEGREES = 180.0 / Math.PI;
-
 /** @const */
 export const DEGREES_DOUBLE = 2.0 * DEGREES;
 /** @const */
 export const RADIANS_HALF = 0.5 * RADIANS;
-
 /** @const */
 export const ARCSECONDS_TO_RADIANS = 0.00000484813681109536;
 /** @const */
@@ -42,10 +33,8 @@ export const HOURS_TO_RADIANS = 0.26179938779914943653855361527329;
 export const HOURS_TO_DEGREES = 15.0;
 /** @const */
 export const DEGREES_TO_HOURS = 1.0 / 15.0;
-
 /** @const */
 export const SQRT_HALF = Math.sqrt(0.5);
-
 export const EPS1 = 1e-1;
 export const EPS2 = 1e-2;
 export const EPS3 = 1e-3;
@@ -66,7 +55,6 @@ export const EPS17 = 1e-17;
 export const EPS18 = 1e-18;
 export const EPS19 = 1e-19;
 export const EPS20 = 1e-20;
-
 /**
  * The log function returns the power to which the base value has to be raised to produce n.
  * @function
@@ -77,10 +65,9 @@ export const EPS20 = 1e-20;
  * log(64, 2)
  * //returns 6
  */
-export function log(n: number, base: number): number {
+export function log(n, base) {
     return Math.log(n) / Math.log(base);
 }
-
 /**
  * Clamp the number.
  * @function
@@ -92,40 +79,36 @@ export function log(n: number, base: number): number {
  * clamp(12, 1, 5)
  * //returns 5
  */
-export function clamp(number: number, min: number, max: number): number {
+export function clamp(number, min, max) {
     return Math.max(min, Math.min(number, max));
 }
-
 /**
  * Converts degrees value to radians.
  * @function
  * @param {number} degrees - Degree value.
  * @returns {number} -
  */
-export function DEG2RAD(degrees: number): number {
+export function DEG2RAD(degrees) {
     return degrees * RADIANS;
 }
-
 /**
  * Converts radians value to degrees.
  * @function
  * @param {number} angle - Degree value.
  * @returns {number} -
  */
-export function RAD2DEG(angle: number): number {
+export function RAD2DEG(angle) {
     return angle * DEGREES;
 }
-
 /**
  * Check the number is a power of two.
  * @function
  * @param {number} x - Input value.
  * @returns {boolean} -
  */
-export function isPowerOfTwo(x: number): boolean {
+export function isPowerOfTwo(x) {
     return (x & (x - 1)) === 0;
 }
-
 /**
  * Returns next value that is power of two.
  * @function
@@ -133,14 +116,13 @@ export function isPowerOfTwo(x: number): boolean {
  * @param {number} [maxValue=4096] - Maximal value.
  * @returns {number} -
  */
-export function nextHighestPowerOfTwo(x: number, maxValue: number = 4096): number {
+export function nextHighestPowerOfTwo(x, maxValue = 4096) {
     --x;
     for (let i = 1; i < 32; i <<= 1) {
         x = x | (x >> i);
     }
-    return (x + 1) > maxValue ? maxValue : x + 1
+    return (x + 1) > maxValue ? maxValue : x + 1;
 }
-
 /**
  * Returns random integer number within the bounds.
  * @function
@@ -148,10 +130,9 @@ export function nextHighestPowerOfTwo(x: number, maxValue: number = 4096): numbe
  * @param {number} max - Maximal bound.
  * @returns {number} -
  */
-export function randomi(min: number = 0, max: number = 1): number {
+export function randomi(min = 0, max = 1) {
     return Math.floor(Math.random() * (max - min)) + min;
 }
-
 /**
  * Returns random number within the bounds.
  * @function
@@ -159,10 +140,9 @@ export function randomi(min: number = 0, max: number = 1): number {
  * @param {number} [max=1] - Maximal bound.
  * @returns {number} -
  */
-export function random(min: number = 0, max: number = 1): number {
+export function random(min = 0, max = 1) {
     return Math.random() * (max - min) + min;
 }
-
 /**
  * Converts degrees value to decimal.
  * @function
@@ -172,14 +152,14 @@ export function random(min: number = 0, max: number = 1): number {
  * @param {boolean} [p] - Positive flag. False - default.
  * @returns {number} -
  **/
-export function degToDec(d: number, m: number, s: number, p: number): number {
+export function degToDec(d, m, s, p) {
     if (p) {
         return d + m / 60.0 + s / 3600.0;
-    } else {
+    }
+    else {
         return -d - m / 60.0 - s / 3600.0;
     }
 }
-
 /**
  * The modulo operation that also works for negative dividends.
  * @function
@@ -187,24 +167,22 @@ export function degToDec(d: number, m: number, s: number, p: number): number {
  * @param {number} n - The divisor.
  * @returns {number} The remainder.
  */
-export function mod(m: number, n: number): number {
+export function mod(m, n) {
     return ((m % n) + n) % n;
 }
-
 /**
  * Returns an angle in the range 0 <= angle <= 2Pi which is equivalent to the provided angle.
  * @function
  * @param {number} a - Angle in radians
  * @returns {number} -
  */
-export function zeroTwoPI(a: number): number {
+export function zeroTwoPI(a) {
     const res = mod(a, TWO_PI);
     if (Math.abs(res) < EPS14 && Math.abs(a) > EPS14) {
         return TWO_PI;
     }
     return res;
 }
-
 /**
  * Returns 0.0 if x is smaller than edge and otherwise 1.0.
  * @function
@@ -212,51 +190,46 @@ export function zeroTwoPI(a: number): number {
  * @param {number} x - Value to edge.
  * @returns {number} -
  */
-export function step(edge: number, x: number): number {
+export function step(edge, x) {
     return x < edge ? 0.0 : 1.0;
 }
-
 /**
  * The frac function returns the fractional part of x, i.e. x minus floor(x).
  * @function
  * @param {number} x - Input value.
  * @returns {number} -
  */
-export function frac(x: number): number {
-    const mx = Math.abs(x)
+export function frac(x) {
+    const mx = Math.abs(x);
     return mx - Math.floor(mx);
 }
-
 /**
  * Returns Math.log(x) / Math.log(2)
  * @function
  * @param {number} x - Input value.
  * @returns {number} -
  */
-export function log2(x: number): number {
+export function log2(x) {
     return Math.log(x) / LOG2;
 }
-
 /**
  * Returns two power of n.
  * @function
  * @param {number} n - Power value.
  * @returns {number} -
  */
-export function exp2(n: number): number {
+export function exp2(n) {
     return Math.pow(2, n);
 }
-
 /**
  * Returns two power of integer n.
  * @function
  * @param {number} n - Integer power value.
  * @returns {number} -
  */
-export function pow2i(n: number): number {
+export function pow2i(n) {
     return 2 << (n - 1);
 }
-
 /**
  * Returns a slice of linear interpolation t * (h1 - h0)
  * @param {number} t - A value that linearly interpolates between the h0 parameter and the h1 parameter.
@@ -264,10 +237,9 @@ export function pow2i(n: number): number {
  * @param {number} h0 - Start value.
  * @returns {number} -
  */
-export function slice(t: number, h1: number, h0: number): number {
+export function slice(t, h1, h0) {
     return t * (h1 - h0);
 }
-
 /**
  * Performs a linear interpolation.
  * @function
@@ -276,24 +248,18 @@ export function slice(t: number, h1: number, h0: number): number {
  * @param {number} h0 - Start value.
  * @returns {number} -
  */
-export function lerp(t: number, h1: number, h0: number): number {
+export function lerp(t, h1, h0) {
     return h0 + t * (h1 - h0);
 }
-
-export function cube(f: number): number {
+export function cube(f) {
     return f * f * f;
 }
-
-export function square(f: number): number {
+export function square(f) {
     return f * f;
 }
-
-export function bezier1v(t: number, p0: number, p1: number, p2: number, p3: number): number {
-    return (
-        cube(1 - t) * p0 + 3 * square(1 - t) * t * p1 + 3 * (1 - t) * square(t) * p2 + cube(t) * p3
-    );
+export function bezier1v(t, p0, p1, p2, p3) {
+    return (cube(1 - t) * p0 + 3 * square(1 - t) * t * p1 + 3 * (1 - t) * square(t) * p2 + cube(t) * p3);
 }
-
 /**
  * Performs a 3D bezier interpolation.
  * @function
@@ -304,50 +270,44 @@ export function bezier1v(t: number, p0: number, p1: number, p2: number, p3: numb
  * @param {Vec3} p3 - Fourth control point.
  * @returns {Vec3} -
  */
-export function bezier3v(t: number, p0: Vec3, p1: Vec3, p2: Vec3, p3: Vec3): Vec3 {
-
+export function bezier3v(t, p0, p1, p2, p3) {
     let u = 1 - t;
     let tt = t * t;
     let uu = u * u;
     let uuu = uu * u;
     let ttt = tt * t;
-
     return p0.scaleTo(uuu)
         .addA(p1.scaleTo(3 * uu * t))
         .addA(p2.scaleTo(3 * u * tt))
         .addA(p3.scaleTo(ttt));
 }
-
 /**
  * Clamp angle value within 360.
  * @function
  * @param {number} x - Input angle.
  * @returns {number} -
  */
-export function rev(x: number): number {
+export function rev(x) {
     return x - Math.floor(x / 360.0) * 360.0;
 }
-
 /**
  * Clamp longitude within: -180 to +180 degrees.
  * @function
  * @param {number} lon - Longitude.
  * @returns {number} -
  */
-export function norm_lon(lon: number): number {
+export function norm_lon(lon) {
     return lon > 180 ? ((lon + 180) % 360) - 180 : lon < -180 ? ((lon - 180) % 360) + 180 : lon;
 }
-
 /**
  * Returns an angle in the range -Pi <= angle <= Pi which is equivalent to the provided angle.
  * @function
  * @param {number} a - Angle in radians.
  * @returns {number} -
  */
-export function negativePItoPI(a: number): number {
+export function negativePItoPI(a) {
     return zeroTwoPI(a + Math.PI) - Math.PI;
 }
-
 /**
  * Solve using iteration method and a fixed number of steps.
  * @function
@@ -356,7 +316,7 @@ export function negativePItoPI(a: number): number {
  * @param {number} maxIter - Maximum iterations.
  * @returns {number} -
  */
-export function solve_iteration_fixed(f: (x: number) => number, x0: number, maxIter: number): number {
+export function solve_iteration_fixed(f, x0, maxIter) {
     let x = 0;
     let x2 = x0;
     for (let i = 0; i < maxIter; i++) {
@@ -365,7 +325,6 @@ export function solve_iteration_fixed(f: (x: number) => number, x0: number, maxI
     }
     return x2;
 }
-
 /**
  * Solve using iteration; terminate when error is below err or the maximum
  * number of iterations is reached. Used in Euler's equation(see og.orbit) solving.
@@ -376,7 +335,7 @@ export function solve_iteration_fixed(f: (x: number) => number, x0: number, maxI
  * @param {number} maxIter - Maximum iterations.
  * @returns {number} -
  */
-export function solve_iteration(f: (x: number) => number, x0: number, err: number, maxIter: number = 50): number {
+export function solve_iteration(f, x0, err, maxIter = 50) {
     let x = 0;
     let x2 = x0;
     for (let i = 0; i < maxIter; i++) {
@@ -388,40 +347,33 @@ export function solve_iteration(f: (x: number) => number, x0: number, err: numbe
     }
     return x2;
 }
-
 /**
  * Equation function.
  * @callback equationCallback
  * @param {number} x - Equation variable.
  */
-
 /**
  *
  * @param a - First bearing angle
  * @param b - Second bearing angle
  * @returns {number}
  */
-function getAngleDirection(a: number, b: number): number {
-    let a_y = Math.cos(a),
-        a_x = Math.sin(a),
-        b_y = Math.cos(b),
-        b_x = Math.sin(b);
-    let c = a_y * b_x - b_y * a_x,
-        d = a_x * b_x + a_y * b_y;
+function getAngleDirection(a, b) {
+    let a_y = Math.cos(a), a_x = Math.sin(a), b_y = Math.cos(b), b_x = Math.sin(b);
+    let c = a_y * b_x - b_y * a_x, d = a_x * b_x + a_y * b_y;
     if (c > 0.0) {
         return Math.acos(d);
     }
     return -Math.acos(d);
 }
-
 /**
  * Returns angle between two azimuths
  * @param {number} a - First azimuth angle
  * @param {number} b - Second azimuth angle
  * @returns {number}
  */
-export function getAngleBetweenAzimuths(a: number, b: number): number {
+export function getAngleBetweenAzimuths(a, b) {
     a = zeroTwoPI(a);
     b = zeroTwoPI(b);
     return ((((a - b) % 360) + 360 + 180) % 360) - 180;
-}
+}