@woosh/meep-engine 2.109.0 → 2.109.2

package/src/core/geom/vec3/v3_displace_in_direction.spec.js

@@ -0,0 +1,80 @@
+import Vector3 from "../Vector3.js";
+import { v3_displace_in_direction } from "./v3_displace_in_direction.js";
+
+test("zero distance", () => {
+
+    const r = new Vector3();
+
+    expect(v3_displace_in_direction(
+        r, 0,
+        0, 0, 0,
+        0, 0, 1
+    )).toBe(true);
+
+});
+
+test("direction magnitude is 0", () => {
+
+    const r = new Vector3();
+
+    expect(v3_displace_in_direction(
+        r, 1,
+        0, 0, 0,
+        0, 0, 0
+    )).toBe(false);
+
+});
+
+test("cardinal directions", () => {
+
+    const r = new Vector3();
+
+    expect(v3_displace_in_direction(
+        r, -3,
+        1, 2, 3,
+        0, 0, 1
+    )).toBe(true);
+
+    expect(r.asArray()).toEqual([1, 2, 0]);
+
+    expect(v3_displace_in_direction(
+        r, -3,
+        1, 2, 3,
+        0, 0, -1
+    )).toBe(true);
+
+    expect(r.asArray()).toEqual([1, 2, 6]);
+
+    expect(v3_displace_in_direction(
+        r, -3,
+        1, 2, 3,
+        0, 1, 0
+    )).toBe(true);
+
+    expect(r.asArray()).toEqual([1, -1, 3]);
+
+    expect(v3_displace_in_direction(
+        r, -3,
+        1, 2, 3,
+        0, -1, 0
+    )).toBe(true);
+
+    expect(r.asArray()).toEqual([1, 5, 3]);
+
+    expect(v3_displace_in_direction(
+        r, -3,
+        1, 2, 3,
+        1, 0, 0
+    )).toBe(true);
+
+    expect(r.asArray()).toEqual([-2, 2, 3]);
+
+    expect(v3_displace_in_direction(
+        r, -3,
+        1, 2, 3,
+        -1, 0, 0
+    )).toBe(true);
+
+    expect(r.asArray()).toEqual([4, 2, 3]);
+
+});

package/src/core/geom/vec3/v3_dot_array_array.js

@@ -18,3 +18,5 @@ export function v3_dot_array_array(a, a_offset, b, b_offset) {
 
     return a_x * b_x + a_y * b_y + a_z * b_z;
 }
+
+

package/src/core/geom/vec4/v4_length.d.ts

@@ -0,0 +1,10 @@
+/**
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number} w
+ * @returns {number}
+ */
+export function v4_length(x: number, y: number, z: number, w: number): number;
+//# sourceMappingURL=v4_length.d.ts.map

package/src/core/geom/vec4/v4_length.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v4_length.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec4/v4_length.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,6BANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAIlB"}

package/src/core/geom/vec4/v4_length.js

@@ -0,0 +1,13 @@
+import { v4_length_sqr } from "./v4_length_sqr.js";
+
+/**
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number} w
+ * @returns {number}
+ */
+export function v4_length(x, y, z, w) {
+    return Math.sqrt(v4_length_sqr(x, y, z, w));
+}

package/src/core/geom/vec4/v4_length_sqr.js

@@ -8,4 +8,5 @@
  */
 export function v4_length_sqr(x, y, z, w) {
     return x * x + y * y + z * z + w * w;
-}
+}
+

package/src/core/graph/eigen/matrix_eigenvalues_in_place.spec.js

@@ -10,7 +10,22 @@ function roughly_equal_array_vectors(actual, expected) {
     }
 }
 
-test("sample", () => {
+test("2x2 sample A", () => {
+
+
+    const t = new SquareMatrix(2, BinaryDataType.Float32);
+    t.fromArray([
+        1,-2,
+        5,-7
+    ]);
+
+    const eigen = matrix_eigenvalues_in_place(t);
+
+
+    roughly_equal_array_vectors(eigen, [-5.44949, -0.55051]);
+});
+
+test("3x3 sample A", () => {
 
 
     const t = new SquareMatrix(3, BinaryDataType.Float32);
@@ -25,3 +40,18 @@ test("sample", () => {
 
     roughly_equal_array_vectors(eigen, [9.62192181, -9.12030391, 3.4983821]);
 });
+test("3x3 sample B", () => {
+
+
+    const t = new SquareMatrix(3, BinaryDataType.Float32);
+    t.fromArray([
+        1, 2, 3,
+        4, 5, 6,
+        7, 8, 9
+    ]);
+
+    const eigen = matrix_eigenvalues_in_place(t);
+
+
+    roughly_equal_array_vectors(eigen, [16.1168, -1.11684, 0]);
+});

package/src/core/math/FLT_EPSILON_64.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Machine epsilon, 2^(-53)
+ * @type {number}
+ */
+export const FLT_EPSILON_64: number;
+//# sourceMappingURL=FLT_EPSILON_64.d.ts.map

package/src/core/math/FLT_EPSILON_64.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FLT_EPSILON_64.d.ts","sourceRoot":"","sources":["../../../../src/core/math/FLT_EPSILON_64.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH,6BAFU,MAAM,CAEqC"}

package/src/core/math/FLT_EPSILON_64.js

@@ -0,0 +1,5 @@
+/**
+ * Machine epsilon, 2^(-53)
+ * @type {number}
+ */
+export const FLT_EPSILON_64 = 1.1102230246251565e-16;

package/src/core/math/gaussian.d.ts

@@ -1,7 +1,7 @@
 /**
  *
- * @param {number} sigma
- * @param {number} v
+ * @param {number} sigma distance from mean
+ * @param {number} v Variance
  * @returns {number}
  */
 export function gaussian(sigma: number, v: number): number;

package/src/core/math/gaussian.js

@@ -1,7 +1,7 @@
 /**
  *
- * @param {number} sigma
- * @param {number} v
+ * @param {number} sigma distance from mean
+ * @param {number} v Variance
  * @returns {number}
  */
 export function gaussian(sigma, v) {

package/src/core/math/linalg/README.md

@@ -0,0 +1 @@
+Linear Argebra package

package/src/core/math/linalg/lu_factor_linear_system.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Factor linear equations Ax = b using LU decomposition A = LU where L is
+ * lower triangular matrix and U is upper triangular matrix. Input is
+ * square matrix A, integer array of pivot indices index[0->n-1], and size
+ * of square matrix n. Output factorization LU is in matrix A. If error is
+ * found, method returns 0.
+ * @param {number[]} A Square matrix, will be modified
+ * @param {number[]|Uint32Array} index will be written to
+ * @param {number} size Size of the matrix ( 4x4 matrix has size 4 )
+ * @returns {boolean}
+ */
+export function lu_factor_linear_system(A: number[], index: number[] | Uint32Array, size: number): boolean;
+//# sourceMappingURL=lu_factor_linear_system.d.ts.map

package/src/core/math/linalg/lu_factor_linear_system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lu_factor_linear_system.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/linalg/lu_factor_linear_system.js"],"names":[],"mappings":"AAOA;;;;;;;;;;GAUG;AACH,2CALW,MAAM,EAAE,SACR,MAAM,EAAE,GAAC,WAAW,QACpB,MAAM,GACJ,OAAO,CA+FnB"}

package/src/core/math/linalg/lu_factor_linear_system.js

@@ -0,0 +1,112 @@
+import { assert } from "../../assert.js";
+
+const SMALL_NUMBER = 1e-12;
+
+const SCRATCH_SIZE = 16;
+const scratch = new Float64Array(SCRATCH_SIZE);
+
+/**
+ * Factor linear equations Ax = b using LU decomposition A = LU where L is
+ * lower triangular matrix and U is upper triangular matrix. Input is
+ * square matrix A, integer array of pivot indices index[0->n-1], and size
+ * of square matrix n. Output factorization LU is in matrix A. If error is
+ * found, method returns 0.
+ * @param {number[]} A Square matrix, will be modified
+ * @param {number[]|Uint32Array} index will be written to
+ * @param {number} size Size of the matrix ( 4x4 matrix has size 4 )
+ * @returns {boolean}
+ */
+export function lu_factor_linear_system(A, index, size) {
+    assert.isNonNegativeInteger(size,'size');
+
+    // double scratch[10];
+    // double* scale = (size < 10 ? scratch : new double[size]);
+    //
+    // int i, j, k;
+    // int maxI = 0;
+    // double largest, temp1, temp2, sum;
+    //
+    // // Manage number of output warnings
+    // static int numWarns = 0;
+    //
+    // //
+
+    let i, j, k;
+    let maxI = 0;
+    let largest, temp1, temp2, sum;
+
+    const scale = size <= SCRATCH_SIZE ? scratch : new Float64Array(size);
+
+    // Loop over rows to get implicit scaling information
+    //
+    for (i = 0; i < size; ++i) {
+        for (largest = 0.0, j = 0; j < size; ++j) {
+            if ((temp2 = Math.abs(A[i * size + j])) > largest) {
+                largest = temp2;
+            }
+        }
+
+        if (largest === 0.0) {
+            // Unable to factor linear system
+
+            return false;
+        }
+        scale[i] = 1.0 / largest;
+    }
+    //
+    // Loop over all columns using Crout's method
+    //
+    for (j = 0; j < size; ++j) {
+        for (i = 0; i < j; ++i) {
+            sum = A[i * size + j];
+            for (k = 0; k < i; ++k) {
+                sum -= A[i * size + k] * A[k * size + j];
+            }
+            A[i * size + j] = sum;
+        }
+        //
+        // Begin search for largest pivot element
+        //
+        for (largest = 0.0, i = j; i < size; ++i) {
+            sum = A[i * size + j];
+            for (k = 0; k < j; ++k) {
+                sum -= A[i * size + k] * A[k * size + j];
+            }
+            A[i * size + j] = sum;
+
+            if ((temp1 = scale[i] * Math.abs(sum)) >= largest) {
+                largest = temp1;
+                maxI = i;
+            }
+        }
+        //
+        // Check for row interchange
+        //
+        if (j !== maxI) {
+            for (k = 0; k < size; ++k) {
+                temp1 = A[maxI * size + k];
+                A[maxI * size + k] = A[j * size + k];
+                A[j * size + k] = temp1;
+            }
+            scale[maxI] = scale[j];
+        }
+        //
+        // Divide by pivot element and perform elimination
+        //
+        index[j] = maxI;
+
+        if (Math.abs(A[j * size + j]) <= SMALL_NUMBER) {
+            // Unable to factor linear system
+            return false;
+        }
+
+        if (j !== (size - 1)) {
+            temp1 = 1.0 / A[j * size + j];
+            for (i = j + 1; i < size; ++i) {
+                A[i * size + j] *= temp1;
+            }
+        }
+    }
+
+    return true;
+}

package/src/core/math/linalg/lu_solve_linear_system.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Solve linear equations Ax = b using LU decomposition A = LU where L is
+ * lower triangular matrix and U is upper triangular matrix. Input is
+ * factored matrix A=LU, integer array of pivot indices index[0->n-1],
+ * load vector x[0->n-1], and size of square matrix n. Note that A=LU and
+ * index[] are generated from method LUFactorLinearSystem). Also, solution
+ * vector is written directly over input load vector.
+ * @param {number[]} A Square matrix
+ * @param {number[]|Uint32Array} index
+ * @param {number[]} x
+ * @param {number} size matrix size ( 4x4 matrix has size 4)
+ */
+export function lu_solve_linear_system(A: number[], index: number[] | Uint32Array, x: number[], size: number): void;
+//# sourceMappingURL=lu_solve_linear_system.d.ts.map

package/src/core/math/linalg/lu_solve_linear_system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lu_solve_linear_system.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/linalg/lu_solve_linear_system.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,0CALW,MAAM,EAAE,SACR,MAAM,EAAE,GAAC,WAAW,KACpB,MAAM,EAAE,QACR,MAAM,QAsChB"}

package/src/core/math/linalg/lu_solve_linear_system.js

@@ -0,0 +1,51 @@
+import { assert } from "../../assert.js";
+
+/**
+ * Solve linear equations Ax = b using LU decomposition A = LU where L is
+ * lower triangular matrix and U is upper triangular matrix. Input is
+ * factored matrix A=LU, integer array of pivot indices index[0->n-1],
+ * load vector x[0->n-1], and size of square matrix n. Note that A=LU and
+ * index[] are generated from method LUFactorLinearSystem). Also, solution
+ * vector is written directly over input load vector.
+ * @param {number[]} A Square matrix
+ * @param {number[]|Uint32Array} index
+ * @param {number[]} x
+ * @param {number} size matrix size ( 4x4 matrix has size 4)
+ */
+export function lu_solve_linear_system(A, index, x, size) {
+    assert.isNonNegativeInteger(size, 'size');
+
+    let i = 0, j, ii = -1;
+
+    let sum;
+
+    // Proceed with forward and back-substitution for L and U matrices.  First, forward substitution.
+    for (; i < size; ++i) {
+        const idx = index[i];
+        sum = x[idx];
+        x[idx] = x[i];
+
+        if (ii >= 0) {
+
+            for (j = ii; j <= i - 1; ++j) {
+                sum -= A[i * size + j] * x[j];
+            }
+
+        } else if (sum !== 0.0) {
+            ii = i;
+        }
+
+        x[i] = sum;
+    }
+
+    // Now, back substitution
+    for (i = size - 1; i >= 0; i--) {
+        sum = x[i];
+
+        for (j = i + 1; j < size; ++j) {
+            sum -= A[i * size + j] * x[j];
+        }
+
+        x[i] = sum / A[i * size + i];
+    }
+}

package/src/core/math/linalg/solve_linear_system.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Solve linear equations Ax = b using Crout's method. Input is square matrix A and load vector b.
+ * Solution x is written over load vector.
+ * The dimension of the matrix is specified in size. If error is found, method returns a 0.
+ *
+ * @see https://github.com/Kitware/VTK/blob/af928016f4041ad8a6a193d032355b909721fc95/Common/Core/vtkMath.cxx
+ *
+ * @param {number[]|Float32Array|Float64Array} A
+ * @param {number[]|Float32Array|Float64Array} x
+ * @param {number} size
+ * @returns {boolean} true if solution found, false if factorization fails
+ */
+export function solve_linear_system(A: number[] | Float32Array | Float64Array, x: number[] | Float32Array | Float64Array, size: number): boolean;
+//# sourceMappingURL=solve_linear_system.d.ts.map

package/src/core/math/linalg/solve_linear_system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solve_linear_system.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/linalg/solve_linear_system.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;GAWG;AACH,uCALW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAClC,MAAM,GACJ,OAAO,CAgCnB"}

package/src/core/math/linalg/solve_linear_system.js

@@ -0,0 +1,52 @@
+import { assert } from "../../assert.js";
+import { lu_factor_linear_system } from "./lu_factor_linear_system.js";
+import { lu_solve_linear_system } from "./lu_solve_linear_system.js";
+import { solve_linear_system_GEPP_2x2 } from "./solve_linear_system_GEPP_2x2.js";
+
+const SCRATCH_SIZE = 16;
+const scratch = new Uint32Array(SCRATCH_SIZE);
+
+/**
+ * Solve linear equations Ax = b using Crout's method. Input is square matrix A and load vector b.
+ * Solution x is written over load vector.
+ * The dimension of the matrix is specified in size. If error is found, method returns a 0.
+ *
+ * @see https://github.com/Kitware/VTK/blob/af928016f4041ad8a6a193d032355b909721fc95/Common/Core/vtkMath.cxx
+ *
+ * @param {number[]|Float32Array|Float64Array} A
+ * @param {number[]|Float32Array|Float64Array} x
+ * @param {number} size
+ * @returns {boolean} true if solution found, false if factorization fails
+ */
+export function solve_linear_system(A, x, size) {
+    assert.isNonNegativeInteger(size, 'size');
+    assert.defined(A, 'A');
+    assert.defined(x, 'x');
+
+    if (size === 1) {
+        if (A[0] === 0) {
+            // Unable to solve linear system
+            return false;
+        }
+
+        x[0] /= A[0];
+
+        return true;
+
+    } else if (size === 2) {
+
+        return solve_linear_system_GEPP_2x2(A, x, x);
+
+    }
+
+    const index = size <= SCRATCH_SIZE ? scratch : new Uint32Array(size);
+
+    if (lu_factor_linear_system(A, index, size) === false) {
+        return false;
+    }
+
+    lu_solve_linear_system(A, index, x, size);
+
+    return true;
+}
+

package/src/core/math/linalg/solve_linear_system.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=solve_linear_system.spec.d.ts.map

package/src/core/math/linalg/solve_linear_system.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solve_linear_system.spec.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/linalg/solve_linear_system.spec.js"],"names":[],"mappings":""}

package/src/core/math/linalg/solve_linear_system.spec.js

@@ -0,0 +1,70 @@
+import { solve_linear_system } from "./solve_linear_system.js";
+
+test("3 variables", () => {
+
+    /*
+
+    x + y + z = 6
+    2x - y - x = -3
+    3y - 2z = 0
+
+     */
+    const x = [6, -3, 0];
+
+    expect(solve_linear_system(
+        [
+            1, 1, 1,
+            2, -1, -1,
+            0, 3, -2
+        ],
+        x,
+        3
+    )).toBe(true);
+
+    expect(x).toEqual([1, 2, 3])
+
+});
+
+test("2 variables", () => {
+
+    /*
+
+    2x + 7y = 34
+    5x - 4y = -1
+
+     */
+    const x = [34, -1];
+
+    expect(solve_linear_system(
+        [
+            2,7,
+            5,-4
+        ],
+        x,
+        2
+    )).toBe(true);
+
+    expect(x).toEqual([3,4])
+
+});
+
+test("1 variable", () => {
+
+    /*
+
+    2x = -42
+
+     */
+    const x = [-42];
+
+    expect(solve_linear_system(
+        [
+            2
+        ],
+        x,
+        1
+    )).toBe(true);
+
+    expect(x).toEqual([-21])
+
+});

package/src/core/math/linalg/solve_linear_system_GEPP_2x2.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Solve linear equation Ax = b using Gaussian Elimination with Partial Pivoting for a 2x2 system.
+ * If the matrix is found to be singular within a small numerical tolerance close to machine precision then 0 is returned.
+ * @param {number[]} A
+ * @param {number[]} x
+ * @param {number[]} b
+ * @returns {boolean}
+ */
+export function solve_linear_system_GEPP_2x2(A: number[], x: number[], b: number[]): boolean;
+//# sourceMappingURL=solve_linear_system_GEPP_2x2.d.ts.map

package/src/core/math/linalg/solve_linear_system_GEPP_2x2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solve_linear_system_GEPP_2x2.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/linalg/solve_linear_system_GEPP_2x2.js"],"names":[],"mappings":"AAOA;;;;;;;GAOG;AACH,gDALW,MAAM,EAAE,KACR,MAAM,EAAE,KACR,MAAM,EAAE,GACN,OAAO,CA6EnB"}

package/src/core/math/linalg/solve_linear_system_GEPP_2x2.js

@@ -0,0 +1,91 @@
+import { array_swap_one } from "../../collection/array/array_swap_one.js";
+import { fabsf } from "../fabsf.js";
+import { FLT_EPSILON_64 } from "../FLT_EPSILON_64.js";
+
+// Note the choice of eps is reasonable but somewhat arbitrary.
+const epsilon = 256 * FLT_EPSILON_64;
+
+/**
+ * Solve linear equation Ax = b using Gaussian Elimination with Partial Pivoting for a 2x2 system.
+ * If the matrix is found to be singular within a small numerical tolerance close to machine precision then 0 is returned.
+ * @param {number[]} A
+ * @param {number[]} x
+ * @param {number[]} b
+ * @returns {boolean}
+ */
+export function solve_linear_system_GEPP_2x2(A, x, b) {
+
+    // Check if any of the matrix coefficients is zero.
+    // If so then swap rows/columns to form an upper triangular matrix without having to use GEPP.
+    let cols_swapped = false;
+    if (A[0] === 0 || A[1] === 0 || A[2] === 0 || A[3] === 0) {
+
+        // zero in either row of the 2nd column?
+        if (A[1] === 0 || A[3] === 0) {
+            // swap columns
+            array_swap_one(A, 0, 1);
+            array_swap_one(A, 2, 3);
+
+            cols_swapped = true;
+        }
+
+        // zero in a00?
+        if (A[0] === 0) {
+            // swap rows
+            array_swap_one(A, 0, 2);
+            array_swap_one(A, 1, 3);
+            array_swap_one(b, 0, 1);
+        }
+
+    } else {
+
+        // None of the matrix coefficients are exactly zero.
+        // Use GEPP to form upper triangular matrix, i.e. so that a10 == 0.
+        // Select pivot by looking at largest absolute value in a00, a10
+        if (fabsf(A[0]) < fabsf(A[2])) {
+            // swap rows so the largest coefficient in first column is in the first row
+            array_swap_one(A, 0, 2);
+            array_swap_one(A, 1, 3);
+            array_swap_one(b, 0, 1);
+        }
+
+        const f = -A[2] / A[0];
+
+        A[3] += A[1] * f;
+        b[1] += b[0] * f;
+
+    }
+
+    // Have now an exact zero in a10.
+    // Need to check for singularity by looking at a11.
+
+    if (fabsf(A[3]) < epsilon) {
+        // matrix is singular within small numerical tolerance
+        return false;
+    }
+
+    // Solve the triangular system
+    if (A[3] !== 0) {
+        x[1] = b[1] / A[3];
+    } else {
+        return false;
+    }
+
+    if (A[0] !== 0) {
+        x[0] = (b[0] - A[1] * x[1]) / A[0];
+    } else {
+        return false;
+    }
+
+    // other failures in solution?
+    if (!Number.isFinite(x[0]) || !Number.isFinite(x[1])) {
+        return false;
+    }
+
+    // If necessary swap solution vector rows.
+    if (cols_swapped) {
+        array_swap_one(x, 0, 1);
+    }
+
+    return true;
+}

package/src/core/math/solveQuadratic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"solveQuadratic.d.ts","sourceRoot":"","sources":["../../../../src/core/math/solveQuadratic.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,uCAJW,MAAM,EAAE,iBACR,MAAM,KAJN,MAAM,KACN,MAAM,KACN,MAAM,GAGJ,MAAM,CAqClB"}
+{"version":3,"file":"solveQuadratic.d.ts","sourceRoot":"","sources":["../../../../src/core/math/solveQuadratic.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,uCAJW,MAAM,EAAE,iBACR,MAAM,KAJN,MAAM,KACN,MAAM,KACN,MAAM,GAGJ,MAAM,CAuClB"}