@woosh/meep-engine 2.49.8 → 2.50.0

package/src/core/geom/Quaternion.js

@@ -136,15 +136,16 @@ class Quaternion {
 
         up.crossVectors(forward, right);
 
-        var m00 = right.x;
-        var m01 = right.y;
-        var m02 = right.z;
-        var m10 = up.x;
-        var m11 = up.y;
-        var m12 = up.z;
-        var m20 = forward.x;
-        var m21 = forward.y;
-        var m22 = forward.z;
+        // construct partial transform matrix
+        const m00 = right.x;
+        const m01 = right.y;
+        const m02 = right.z;
+        const m10 = up.x;
+        const m11 = up.y;
+        const m12 = up.z;
+        const m20 = forward.x;
+        const m21 = forward.y;
+        const m22 = forward.z;
 
 
         const num8 = (m00 + m11) + m22;
@@ -159,22 +160,29 @@ class Quaternion {
             _y = (m20 - m02) * num;
             _z = (m01 - m10) * num;
         } else if ((m00 >= m11) && (m00 >= m22)) {
-            var num7 = Math.sqrt(((1 + m00) - m11) - m22);
-            var num4 = 0.5 / num7;
+
+            const num7 = Math.sqrt(((1 + m00) - m11) - m22);
+            const num4 = 0.5 / num7;
+
             _x = 0.5 * num7;
             _y = (m01 + m10) * num4;
             _z = (m02 + m20) * num4;
             _w = (m12 - m21) * num4;
+
         } else if (m11 > m22) {
-            var num6 = Math.sqrt(((1 + m11) - m00) - m22);
-            var num3 = 0.5 / num6;
+
+            const num6 = Math.sqrt(((1 + m11) - m00) - m22);
+            const num3 = 0.5 / num6;
+
             _x = (m10 + m01) * num3;
             _y = 0.5 * num6;
             _z = (m21 + m12) * num3;
             _w = (m20 - m02) * num3;
         } else {
-            var num5 = Math.sqrt(((1 + m22) - m00) - m11);
-            var num2 = 0.5 / num5;
+
+            const num5 = Math.sqrt(((1 + m22) - m00) - m11);
+            const num2 = 0.5 / num5;
+
             _x = (m20 + m02) * num2;
             _y = (m21 + m12) * num2;
             _z = 0.5 * num5;
@@ -359,9 +367,9 @@ class Quaternion {
     toAxisAngle(axis) {
         const rad = Math.acos(this.w) * 2.0;
 
-        const s = Math.sin(rad / 2.0);
+        const s = Math.sin(rad * 0.5);
 
-        if (s > EPSILON) {
+        if (Math.abs(s) > EPSILON) {
             axis.set(
                 this.x / s,
                 this.y / s,
@@ -378,7 +386,8 @@ class Quaternion {
         let l = this.length();
 
         if (l < EPSILON) {
-            // use identity
+            // Quaternion has close to 0 length
+            // use identity, avoid division by 0
             this.set(0, 0, 0, 1);
         } else {
             const m = 1 / l;
@@ -1131,17 +1140,17 @@ class Quaternion {
         m31, m32, m33
     ) {
 
-        assert.notNaN(m11,'m11');
-        assert.notNaN(m12,'m12');
-        assert.notNaN(m13,'m13');
+        assert.notNaN(m11, 'm11');
+        assert.notNaN(m12, 'm12');
+        assert.notNaN(m13, 'm13');
 
-        assert.notNaN(m21,'m21');
-        assert.notNaN(m22,'m22');
-        assert.notNaN(m23,'m23');
+        assert.notNaN(m21, 'm21');
+        assert.notNaN(m22, 'm22');
+        assert.notNaN(m23, 'm23');
 
-        assert.notNaN(m31,'m31');
-        assert.notNaN(m32,'m32');
-        assert.notNaN(m33,'m33');
+        assert.notNaN(m31, 'm31');
+        assert.notNaN(m32, 'm32');
+        assert.notNaN(m33, 'm33');
 
 
         const trace = m11 + m22 + m33;

package/src/core/geom/Quaternion.spec.js

@@ -1,5 +1,6 @@
 import Quaternion from "./Quaternion.js";
 import Vector3 from "./Vector3.js";
+import { decode_octahedron_to_unit } from "./3d/normal/octahedron/decode_octahedron_to_unit.js";
 
 /**
  *
@@ -260,3 +261,143 @@ test('computeTwistAngle', () => {
     expect(q.computeTwistAngle(Vector3.up)).toBeCloseTo(hp * 3);
 
 });
+
+test("numeric(array) accessors", () => {
+
+    const q = new Quaternion();
+
+    q[0] = 3;
+    q[1] = -7;
+    q[2] = 11;
+    q[3] = -13;
+
+    expect(q[0]).toEqual(3);
+    expect(q.x).toEqual(3);
+
+    expect(q[1]).toEqual(-7);
+    expect(q.y).toEqual(-7);
+
+    expect(q[2]).toEqual(11);
+    expect(q.z).toEqual(11);
+
+    expect(q[3]).toEqual(-13);
+    expect(q.w).toEqual(-13);
+});
+
+test("forward lookRotation produces identity quaternion ", () => {
+
+    const q = new Quaternion(1, 3, 4, -7);
+
+    q.lookRotation(Vector3.forward, Vector3.up);
+
+    expect(q.roughlyEquals(Quaternion.identity)).toBe(true);
+
+});
+
+test("lookRotation when FORWARD and UP are the same vectors ", () => {
+
+    const q = new Quaternion(1, 3, 4, -7);
+
+    q.lookRotation(Vector3.forward, Vector3.forward);
+
+    const vec = Vector3.forward.clone();
+
+    vec.applyQuaternion(q);
+
+    expect(vec.roughlyEquals(Vector3.forward, 0.001)).toBe(true);
+});
+
+test("check lookRotation rotations on octahedron points", () => {
+
+    const q = new Quaternion(1, 3, 4, -7);
+
+    const direction_vector_forward_array = [];
+
+    const direction_vector_forward = new Vector3();
+
+    const direction_vector_up_array = [];
+
+    const direction_vector_up = new Vector3();
+
+    const rotation_vector = new Vector3();
+
+    const GRID_SIZE = 9;
+
+    for (let i0 = 0; i0 < GRID_SIZE; i0++) {
+        for (let j0 = 0; j0 < GRID_SIZE; j0++) {
+
+            const u0 = i0 / (GRID_SIZE - 1);
+            const v0 = j0 / (GRID_SIZE - 1);
+
+            // sample direction for FORWARD vector
+            decode_octahedron_to_unit(direction_vector_forward_array, 0, u0, v0);
+            direction_vector_forward.readFromArray(direction_vector_forward_array);
+
+
+            for (let i1 = 0; i1 < GRID_SIZE; i1++) {
+                for (let j1 = 0; j1 < GRID_SIZE; j1++) {
+
+                    const u1 = i1 / (GRID_SIZE - 1);
+                    const v1 = j1 / (GRID_SIZE - 1);
+
+                    // sample direction for UP vector
+                    decode_octahedron_to_unit(direction_vector_up_array, 0, u1, v1);
+                    direction_vector_up.readFromArray(direction_vector_up_array);
+
+                    // obtain quaternion
+                    q.lookRotation(direction_vector_forward, direction_vector_up);
+
+                    // verify that a vector transformed via this quaternion would produce the same direction as the look direciton
+                    rotation_vector.copy(Vector3.forward);
+
+                    rotation_vector.applyQuaternion(q);
+
+                    expect(rotation_vector.roughlyEquals(direction_vector_forward, 0.001)).toBe(true);
+
+                }
+            }
+
+        }
+    }
+});
+
+test("random produces valid normalized quaternion", () => {
+
+    const q = new Quaternion();
+
+    q.random(() => 0);
+
+    expect(q.length()).toBeCloseTo(1);
+
+});
+
+test("toAxisAngle on identity", () => {
+    const q = new Quaternion();
+
+    const axis = new Vector3();
+
+    const angle = q.toAxisAngle(axis);
+
+    expect(angle).toBeCloseTo(0)
+});
+
+test("normalizing quaternion of 0 length produces non-NaN result", () => {
+    const q = new Quaternion(0, 0, 0, 0);
+
+    q.normalize();
+
+    expect(q.x).not.toBeNaN();
+    expect(q.y).not.toBeNaN();
+    expect(q.z).not.toBeNaN();
+    expect(q.w).not.toBeNaN();
+
+    expect(q.length()).toBeCloseTo(1);
+});
+
+test("angleTo between identical quaternions should be 0", () => {
+
+    const a = new Quaternion();
+    const b = new Quaternion();
+
+    expect(a.angleTo(b)).toBeCloseTo(0);
+});

package/src/core/geom/Vector2.d.ts

@@ -35,6 +35,10 @@ export default class Vector2 {
 
     clone(): Vector2
 
+    equals(other: Vector2): boolean
+
+    roughlyEquals(other: Vector2, tolerance?: number): boolean
+
     distanceTo(other: Vector2): number
 
     isZero(): boolean
@@ -43,5 +47,5 @@ export default class Vector2 {
 
     writeToArray(array: ArrayLike<number>, offset?: number): void
 
-    asArray():number[]
+    asArray(): number[]
 }

package/src/core/geom/Vector2.js

@@ -9,6 +9,8 @@ import { clamp } from "../math/clamp.js";
 import { lerp } from "../math/lerp.js";
 import { max2 } from "../math/max2.js";
 import { min2 } from "../math/min2.js";
+import { EPSILON } from "../math/EPSILON.js";
+import { epsilonEquals } from "../math/epsilonEquals.js";
 
 class Vector2 {
     /**
@@ -588,6 +590,28 @@ class Vector2 {
         return this.x === other.x && this.y === other.y;
     }
 
+    /**
+     *
+     * @param {Vector2} other
+     * @param {number} [tolerance]
+     * @return {boolean}
+     */
+    roughlyEquals(other, tolerance) {
+        return this._roughlyEquals(other.x, other.y,  tolerance);
+    }
+
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} [tolerance] acceptable deviation
+     * @return {boolean}
+     */
+    _roughlyEquals(x, y, tolerance = EPSILON) {
+        return epsilonEquals(this.x, x, tolerance)
+            && epsilonEquals(this.y, y, tolerance);
+    }
+
     get 0() {
         return this.x;
     }

package/src/core/geom/Vector3.d.ts

@@ -69,6 +69,10 @@ export default class Vector3 implements Vector3Like {
 
     clone(): Vector3
 
+    equals(other:Vector3Like):boolean
+
+    roughlyEquals(other:Vector3Like,tolerance?:number):boolean
+
     normalize(): void
 
     length(): number

package/src/core/geom/Vector3.spec.js

@@ -45,3 +45,63 @@ test('addVectors', () => {
     expect(ut.y).toBe(14);
     expect(ut.z).toBe(18);
 });
+
+test("equals", () => {
+    expect(new Vector3(1, -2, 3).equals(new Vector3(1, -2, 3)))
+        .toBe(true);
+
+    expect(new Vector3(1, -2, 3).equals(new Vector3(5, -2, 3)))
+        .toBe(false);
+
+    expect(new Vector3(1, -2, 3).equals(new Vector3(1, 5, 3)))
+        .toBe(false);
+
+    expect(new Vector3(1, -2, 3).equals(new Vector3(1, -2, 5)))
+        .toBe(false);
+});
+
+test("roughlyEquals", () => {
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(1, -2, 3), 0))
+        .toBe(true);
+
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(1, -2, 3), 0.1))
+        .toBe(true);
+
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(1.01, -2, 3), 0.1))
+        .toBe(true);
+
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(0.99, -2, 3), 0.1))
+        .toBe(true);
+
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(0.89, -2, 3), 0.1))
+        .toBe(false);
+
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(1.11, -2, 3), 0.1))
+        .toBe(false);
+
+    // Y
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(1, -2.01, 3), 0.1))
+        .toBe(true);
+
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(1, -1.99, 3), 0.1))
+        .toBe(true);
+
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(1, -2.11, 3), 0.1))
+        .toBe(false);
+
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(1, -1.89, 3), 0.1))
+        .toBe(false);
+
+    // Z
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(1, -2, 3.01), 0.1))
+        .toBe(true);
+
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(1, -2, 2.99), 0.1))
+        .toBe(true);
+
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(1, -2, 2.89), 0.1))
+        .toBe(false);
+
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(1, -2, 3.11), 0.1))
+        .toBe(false);
+});

package/src/core/graph/GraphUtils.js

@@ -3,7 +3,9 @@
  */
 
 
-import { computeLine2Intersection } from "../geom/2d/LineSegment2.js";
+import {
+    line_segment_compute_line_segment_intersection_vectors_array_2d
+} from "../geom/2d/line/line_segment_compute_line_segment_intersection_vectors_array_2d.js";
 
 const Utils = {};
 
@@ -155,7 +157,7 @@ function graph2paths(graph, thickness) {
         const l = edges.length;
         for (; i < l; i++) {
             const edge = edges[i];
-            if (computeLine2Intersection(from, to, edge.first, edge.second)) {
+            if (line_segment_compute_line_segment_intersection_vectors_array_2d(from, to, edge.first, edge.second)) {
                 return true;
             }
         }

package/src/core/graph/layout/CircleLayout.js

@@ -6,7 +6,6 @@
 import { assert } from "../../assert.js";
 import Circle from "../../geom/2d/circle/Circle.js";
 import AABB2 from "../../geom/2d/aabb/AABB2.js";
-import { line2SegmentsIntersect } from "../../geom/2d/LineSegment2.js";
 import Vector2, { v2_distance } from "../../geom/Vector2.js";
 import { max2 } from "../../math/max2.js";
 import { min2 } from "../../math/min2.js";
@@ -14,6 +13,9 @@ import { computeDisconnectedSubGraphs } from "./computeDisconnectedSubGraphs.js"
 import { Connection } from "./Connection.js";
 import { resolveAABB2Overlap } from "./box/resolveAABB2Overlap.js";
 import { applyCentralGravityAABB2 } from "./box/applyCentralGravityAABB2.js";
+import {
+    line_segment_line_segment_intersection_exists_2d
+} from "../../geom/2d/line/line_segment_line_segment_intersection_exists_2d.js";
 
 
 /**
@@ -364,7 +366,7 @@ function computeNumberOfCrossOvers(edges, numEdges) {
             const b0 = e1.source;
             const b1 = e1.target;
 
-            if (line2SegmentsIntersect(
+            if (line_segment_line_segment_intersection_exists_2d(
                 a0.x, a0.y,
                 a1.x, a1.y,
                 b0.x, b0.y,

package/src/core/math/bessel_i0.spec.js

@@ -0,0 +1,43 @@
+import { bessel_j0 } from "./bessel_j0.js";
+
+test("sanity", () => {
+    const v = bessel_j0(0);
+
+    expect(typeof v).toBe("number");
+    expect(v).not.toBeNaN();
+
+});
+
+test("sweep through low positive values", () => {
+    // https://www.wolframalpha.com/input?i=besselj%5B0%2Cx%5D
+
+    expect(bessel_j0(0)).toBeCloseTo(1, 1);
+    expect(bessel_j0(0.1)).toBeCloseTo(0.997, 1);
+    expect(bessel_j0(0.2)).toBeCloseTo(0.990, 1);
+    expect(bessel_j0(0.3)).toBeCloseTo(0.977, 1);
+    expect(bessel_j0(0.4)).toBeCloseTo(0.960, 1);
+    expect(bessel_j0(0.5)).toBeCloseTo(0.938, 1);
+    expect(bessel_j0(0.6)).toBeCloseTo(0.912, 1);
+    expect(bessel_j0(0.7)).toBeCloseTo(0.881, 1);
+    expect(bessel_j0(0.8)).toBeCloseTo(0.846, 1);
+    expect(bessel_j0(0.9)).toBeCloseTo(0.807, 1);
+    expect(bessel_j0(1)).toBeCloseTo(0.765, 1);
+    expect(bessel_j0(2)).toBeCloseTo(0.223, 1);
+
+});
+
+test("roots", () => {
+
+    expect(bessel_j0(2.40482555769577)).toBeCloseTo(0, 1);
+    expect(bessel_j0(-2.40482555769577)).toBeCloseTo(0, 1);
+
+    expect(bessel_j0(5.52007811028631)).toBeCloseTo(0, 1);
+    expect(bessel_j0(-5.52007811028631)).toBeCloseTo(0, 1);
+
+    expect(bessel_j0(8.65372791291101)).toBeCloseTo(0, 1);
+    expect(bessel_j0(-8.65372791291101)).toBeCloseTo(0, 1);
+
+    expect(bessel_j0(11.7915344390143)).toBeCloseTo(0, 1);
+    expect(bessel_j0(-11.7915344390143)).toBeCloseTo(0, 1);
+
+});

package/src/core/math/bessel_j0.js

@@ -0,0 +1,30 @@
+import { assert } from "../assert.js";
+
+const q = 0.7172491568;
+const p0 = 0.6312725339;
+const ps0 = 0.4308049446;
+const p1 = 0.3500347951;
+const ps1 = 0.4678202347;
+const p2 = -0.06207747907;
+const ps2 = 0.04253832927;
+// const lamb4 = (lamb * lamb) * (lamb * lamb);
+const lamb4 = 0.559840650625;
+
+/**
+ * Bessel first order function of zeroth order
+ * @see https://link.springer.com/article/10.1007/s40314-020-01238-z
+ * @see https://www.shadertoy.com/view/Wt3czM
+ * @param {number} x
+ * @return {number}
+ */
+export function bessel_j0(x) {
+    assert.notNaN(x, 'x');
+
+    const xx = x * x;
+
+    const t0 = Math.sqrt(1.0 + lamb4 * xx);
+    const t1 = Math.sqrt(t0);
+
+    return xx === 0.0 ? 1.0 : 1.0 / (t1 * (1.0 + q * xx)) * ((p0 + p1 * xx + p2 * t0) * Math.cos(x) + ((ps0 + ps1 * xx) * t0 + ps2 * xx) * (Math.sin(x) / x));
+
+}

package/src/core/math/hash/murmur3_32.spec.js

@@ -0,0 +1,8 @@
+import { murmur3_32 } from "./murmur3_32.js";
+
+test("hashing [0] with 0 seed", () => {
+    const hash = murmur3_32(new Uint32Array([0]), 0);
+    expect(typeof hash).toBe("number");
+    expect(Number.isInteger(hash)).toBe(true);
+    expect(hash).not.toBeNaN();
+});

package/src/core/math/hash/squirrel3.spec.js

@@ -0,0 +1,16 @@
+import { squirrel3 } from "./squirrel3.js";
+
+function expect_integer(v) {
+
+    expect(typeof v).toBe("number");
+    expect(Number.isInteger(v)).toBe(true);
+    expect(v).not.toBeNaN();
+}
+
+test("sanity check", () => {
+    expect_integer(squirrel3(0));
+    expect_integer(squirrel3(1));
+    expect_integer(squirrel3(-1));
+
+    expect(squirrel3(0)).not.toEqual(squirrel3(1));
+});

package/src/core/math/interval/NumericInterval.js

@@ -111,6 +111,7 @@ export class NumericInterval {
 
     /**
      * Whether min and max are the same
+     * In other words if span is 0
      * @returns {boolean}
      */
     isExact() {

package/src/core/math/{bessel_i0.js → modified_bessel_i0.js}

@@ -1,14 +1,16 @@
 import { assert } from "../assert.js";
 
+// const lamb = 0.865;
+
 /**
- * Modified bessel function of the first kind
+ * Modified bessel function of the first kind zeroth order
  * @see https://mathworld.wolfram.com/ModifiedBesselFunctionoftheFirstKind.html
  * @see https://computergraphics.stackexchange.com/questions/6393/kaiser-windowed-sinc-filter-for-mip-mapping
  * @see https://github.com/terifan/ImageResampler/blob/dbc212ce6aaa769bf3c9623cb6ead58ffd51d76c/src/org/terifan/image_resampler/FilterFactory.java
  * @param {number} x
  * @returns {number}
  */
-export function bessel_i0(x) {
+export function modified_bessel_i0(x) {
     assert.notNaN(x, 'x');
 
     let sum = 1.0;
@@ -24,3 +26,4 @@ export function bessel_i0(x) {
 
     return sum;
 }
+

package/src/core/math/noise/{create_noise_2d.js → create_simplex_noise_2d.js}

@@ -58,9 +58,9 @@ const grad4 = /*#__PURE__*/ new Float64Array([0, 1, 1, 1, 0, 1, 1, -1, 0, 1, -1,
 /**
  * Creates a 2D noise function
  * @param random the random function that will be used to build the permutation table
- * @returns {function(x:number, y:number):number}
+ * @returns {function(x:number, y:number):number} producing values in range -1 .. 1
  */
-export function createNoise2D(random = Math.random) {
+export function create_simplex_noise_2d(random = Math.random) {
     // allocate continuous chunk of memory
     const buffer = new ArrayBuffer(512 * 2);
 

package/src/core/math/noise/create_simplex_noise_2d.spec.js

@@ -0,0 +1,21 @@
+import { create_simplex_noise_2d } from "./create_simplex_noise_2d.js";
+
+test("sample 10 points in 0..1 range", () => {
+    const noise2d = create_simplex_noise_2d(() => 0);
+
+    const COUNT = 10;
+    for (let i = 0; i < COUNT; i++) {
+        const u = i / (COUNT - 1);
+        for (let j = 0; j < COUNT; j++) {
+            const v = j / (COUNT - 1);
+
+            const value = noise2d(u, v);
+
+            expect(typeof value).toBe('number');
+            expect(value).not.toBeNaN();
+
+            expect(value).toBeGreaterThanOrEqual(-1);
+            expect(value).toBeLessThanOrEqual(1);
+        }
+    }
+});

package/src/core/math/physics/irradiance/interpolate_irradiance_linear.spec.js

@@ -0,0 +1,20 @@
+import { interpolate_irradiance_linear } from "./interpolate_irradiance_linear.js";
+
+test("sanity check", () => {
+
+    expect(interpolate_irradiance_linear(3, 3, 3)).toBe(1);
+
+    expect(interpolate_irradiance_linear(3, 3, 7)).toBe(1);
+
+    expect(interpolate_irradiance_linear(7, 3, 7)).toBe(0);
+
+    expect(interpolate_irradiance_linear(0, 3, 7)).toBe(1);
+
+    expect(interpolate_irradiance_linear(11, 3, 7)).toBe(0);
+
+    const mid = interpolate_irradiance_linear(5, 3, 7);
+
+    expect(mid).toBeGreaterThan(0);
+    expect(mid).toBeLessThan(1);
+
+});

package/src/core/math/physics/irradiance/interpolate_irradiance_lograrithmic.js

@@ -1,19 +1,19 @@
 import { inverseLerp } from "../../inverseLerp.js";
 
 /**
- *
+ * Approximates logarithmic decay, except it goes to 0 at max
+ * Estimation is done using a 5th degree polynomial
  * @param {number} distance
  * @param {number} min
  * @param {number} max
  * @return {number}
  */
 export function interpolate_irradiance_lograrithmic(distance, min, max) {
-    if (distance >= max) {
-        return 0;
-    }
 
     if (distance <= min) {
         return 1;
+    } else if (distance >= max) {
+        return 0;
     }
 
     const x = inverseLerp(min, max, distance);

package/src/core/math/physics/irradiance/interpolate_irradiance_lograrithmic.spec.js

@@ -0,0 +1,18 @@
+import { interpolate_irradiance_lograrithmic } from "./interpolate_irradiance_lograrithmic.js";
+
+test("sanity check", () => {
+    expect(interpolate_irradiance_lograrithmic(3, 3, 3)).toBe(1);
+
+    expect(interpolate_irradiance_lograrithmic(3, 3, 7)).toBe(1);
+
+    expect(interpolate_irradiance_lograrithmic(7, 3, 7)).toBe(0);
+
+    expect(interpolate_irradiance_lograrithmic(0, 3, 7)).toBe(1);
+
+    expect(interpolate_irradiance_lograrithmic(11, 3, 7)).toBe(0);
+
+    const mid = interpolate_irradiance_lograrithmic(5, 3, 7);
+
+    expect(mid).toBeGreaterThan(0);
+    expect(mid).toBeLessThan(1);
+});