@woosh/meep-engine 2.33.36 → 2.33.40

package/core/geom/3d/morton/v3_morton_encode_transformed.js

@@ -1,4 +1,5 @@
 import { mortonEncode_magicbits } from "./mortonEncode_magicbits.js";
+import { clamp } from "../../../math/clamp.js";
 
 /**
  * Assumes that coordinates will be mapped to -1..1 range after transform
@@ -16,18 +17,21 @@ export function v3_morton_encode_transformed(x, y, z, matrix) {
     const _z = matrix[2] * x + matrix[6] * y + matrix[10] * z + matrix[14];
     const _w = matrix[3] * x + matrix[7] * y + matrix[11] * z + matrix[15];
 
-    const d = 1 / _w;
+    const d = 511.5 / _w;
 
-    // apply perspective divide, values are now in Normalized Coordinate system (-1,1)
-    const px = _x * d;
-    const py = _y * d;
-    const pz = _z * d;
+    // apply perspective divide as well as scaling to 10 bits
+    const ndc_x = _x * d;
+    const ndc_y = _y * d;
+    const ndc_z = _z * d;
 
-    // scale each value up to 10 bits (for 10 bits, the multiplier = 1024. As we have -1,1 range, we do (v+1)/2. 1024/2 = 512)
+    // Normalize values (0,1023) and clamp to prevent wrapping
+    const px = clamp(ndc_x + 511.5, 0, 1023);
+    const py = clamp(ndc_y + 511.5, 0, 1023);
+    const pz = clamp(ndc_z + 511.5, 0, 1023);
 
-    const cx = ((px + 1) * 512) | 0;
-    const cy = ((py + 1) * 512) | 0;
-    const cz = ((pz + 1) * 512) | 0;
-
-    return mortonEncode_magicbits(cx, cy, cz);
+    return mortonEncode_magicbits(
+        Math.round(px),
+        Math.round(py),
+        Math.round(pz)
+    );
 }

package/core/geom/3d/plane/orient3d_fast.js

@@ -0,0 +1,51 @@
+/**
+ * Return a positive value if the point pd lies below the
+ * plane passing through pa, pb, and pc; "below" is defined so
+ * that pa, pb, and pc appear in counterclockwise order when
+ * viewed from above the plane.  Returns a negative value if
+ * pd lies above the plane.  Returns zero if the points are
+ * coplanar.  The result is also a rough approximation of six
+ * times the signed volume of the tetrahedron defined by the
+ * four points.
+ *
+ * NOTE: ported from http://www.cs.cmu.edu/afs/cs/project/quake/public/code/predicates.c
+ *
+ * @param {number[]} points
+ * @param {number} a index of point a
+ * @param {number} b index of point b
+ * @param {number} c index of point c
+ * @param {number} d index of point d
+ * @returns {number}
+ */
+export function orient3d_fast(points, a, b, c, d) {
+    const a3 = a * 3;
+    const d3 = d * 3;
+
+    const d_x = points[d3];
+
+    const adx = points[a3] - d_x;
+
+    const b3 = b * 3;
+
+    const bdx = points[b3] - d_x;
+
+    const c3 = c * 3;
+
+    const cdx = points[c3] - d_x;
+
+    const d_y = points[d3 + 1];
+
+    const ady = points[a3 + 1] - d_y;
+    const bdy = points[b3 + 1] - d_y;
+    const cdy = points[c3 + 1] - d_y;
+
+    const d_z = points[d3 + 2];
+
+    const adz = points[a3 + 2] - d_z;
+    const bdz = points[b3 + 2] - d_z;
+    const cdz = points[c3 + 2] - d_z;
+
+    return adx * (bdy * cdz - bdz * cdy)
+        + bdx * (cdy * adz - cdz * ady)
+        + cdx * (ady * bdz - adz * bdy);
+}

package/core/geom/3d/plane/plane_computeConvex3PlaneIntersection.js

@@ -24,7 +24,12 @@ export function plane_three_computeConvex3PlaneIntersection(result, result_offse
 }
 
 /**
+ * Given 3 planes, compute point of their intersection.
+ * This only works when the planes are "convex", that is - no two planes are parallel.
+ * Simply put - intersection must exist to be found.
+ *
  * NOTE: Based on Intersection of 3 planes, Graphics Gems 1 pg 305
+ *
  * @param {Float32Array|number[]|vec3} result
  * @param {number} result_offset
  * @param {number} a_normal_x

package/core/geom/3d/tetrahedra/GetDepthForTetrahedronProbe.glsl

@@ -0,0 +1,43 @@
+// Sample triangular depth map
+// see CoD SIGGRAPH 2017 "Advances in Real-Time Graphics in Games" course
+float GetDepthForTetrahedronProbe(float2 bary, uint4 encodedDepth)
+{
+    float sampleY = floor(bary.y * 4.0f);
+    float sampleX = floor(bary.x * 4.0f);
+
+    int baseIndex = (int)(((11.0f - sampleY) * sampleY) * 0.5f + sampleX + 0.5f);
+    int lineLength = 5 - (int)sampleY;
+
+    float2 baseBary = float2(sampleX * 0.25f, sampleY * 0.25f);
+
+    int3 indices = int3(baseIndex + 1, baseIndex + lineLength, baseIndex);
+
+    float3 sampleBary;
+    sampleBary.x = (bary.x - baseBary.x) * 4.0f;
+    sampleBary.y = (bary.y - baseBary.y) * 4.0f;
+
+    if (sampleBary.x + sampleBary.y > 1.0f)
+    {
+        // above the diagonal
+        indices = int3(baseIndex + lineLength, baseIndex + 1, baseIndex + lineLength + 1);
+
+        float3 newSampleBary;
+        newSampleBary.x = -(sampleBary.y - 1.0f);
+        newSampleBary.y = -(sampleBary.x - 1.0f);
+        sampleBary = newSampleBary;
+    }
+
+    sampleBary.z = 1.0f - sampleBary.x - sampleBary.y;
+
+    float result = 0.0f;
+    for (int i=0; i<3; ++i)
+    {
+        uint currIndex = indices[i];
+        int intDepth = (encodedDepth[currIndex / 4] >> ((currIndex % 4) * 8)) & 0xFF;
+        float depth = (float)intDepth / 255.0f;
+
+        result += sampleBary[i] * depth;
+    }
+
+    return result;
+}

package/core/geom/3d/tetrahedra/compute_bounding_simplex_3d.js

@@ -0,0 +1,177 @@
+import { v3_dot } from "../../v3_dot.js";
+import { min2 } from "../../../math/min2.js";
+import { max2 } from "../../../math/max2.js";
+import { plane_computeConvex3PlaneIntersection } from "../plane/plane_computeConvex3PlaneIntersection.js";
+
+/**
+ * Planes used to bound the simplex
+ * NOTE: these might be computed for a given set of points instead, to produce a tighter fit, but this was good enough for my needs so far
+ *
+ * @readonly
+ * @type {Float32Array}
+ */
+const SIMPLEX_PROJECTION_AXES = new Float32Array([
+    Math.sqrt(8 / 9), 0, -1 / 3.,
+    -Math.sqrt(2 / 9), Math.sqrt(2 / 3), -1 / 3,
+    -Math.sqrt(2 / 9), -Math.sqrt(2 / 3), -1 / 3,
+    0, 0, 1
+]);
+
+/**
+ * Compute bounding tetrahedron (3d simplex) for a given set of input points
+ *
+ * @see https://github.com/bryanmcnett/aabo/blob/master/aabo.cpp
+ * @author Alexander Goldring (c) 2021
+ *
+ * @param {number[]|Float32Array|Float64Array} result
+ * @param {number} result_offset
+ * @param {number[]|Float32Array|Float64Array} input
+ * @param {number} input_count
+ * @param {number} padding Planar offset for each of the simple sides, positive padding value will create a larger simplex. Useful for ensuring that input points do not lie directly on the simplex planes
+ */
+export function compute_bounding_simplex_3d(
+    result,
+    result_offset,
+    input,
+    input_count,
+    padding
+) {
+    if (input_count <= 0) {
+        // no inputs
+        return;
+    }
+
+    // initialize
+    let x = input[0];
+    let y = input[1];
+    let z = input[2];
+
+    let a = v3_dot(
+        x,
+        y,
+        z,
+        SIMPLEX_PROJECTION_AXES[0],
+        SIMPLEX_PROJECTION_AXES[1],
+        SIMPLEX_PROJECTION_AXES[2],
+    );
+    let b = v3_dot(
+        x,
+        y,
+        z,
+        SIMPLEX_PROJECTION_AXES[3],
+        SIMPLEX_PROJECTION_AXES[4],
+        SIMPLEX_PROJECTION_AXES[5],
+    );
+    let c = v3_dot(
+        x,
+        y,
+        z,
+        SIMPLEX_PROJECTION_AXES[6],
+        SIMPLEX_PROJECTION_AXES[7],
+        SIMPLEX_PROJECTION_AXES[8],
+    );
+    let d = v3_dot(
+        x,
+        y,
+        z,
+        SIMPLEX_PROJECTION_AXES[9],
+        SIMPLEX_PROJECTION_AXES[10],
+        SIMPLEX_PROJECTION_AXES[11],
+    );
+
+    let min_a = a;
+    let min_b = b;
+    let min_c = c;
+    let min_d = d;
+
+    let max_a = a;
+    let max_b = b;
+    let max_c = c;
+    let max_d = d;
+
+    for (let i = 1; i < input_count; i++) {
+
+        const i3 = i * 3;
+
+        x = input[i3];
+        y = input[i3 + 1];
+        z = input[i3 + 2];
+
+        a = v3_dot(
+            x,
+            y,
+            z,
+            SIMPLEX_PROJECTION_AXES[0],
+            SIMPLEX_PROJECTION_AXES[1],
+            SIMPLEX_PROJECTION_AXES[2],
+        );
+        b = v3_dot(
+            x,
+            y,
+            z,
+            SIMPLEX_PROJECTION_AXES[3],
+            SIMPLEX_PROJECTION_AXES[4],
+            SIMPLEX_PROJECTION_AXES[5],
+        );
+        c = v3_dot(
+            x,
+            y,
+            z,
+            SIMPLEX_PROJECTION_AXES[6],
+            SIMPLEX_PROJECTION_AXES[7],
+            SIMPLEX_PROJECTION_AXES[8],
+        );
+        d = v3_dot(
+            x,
+            y,
+            z,
+            SIMPLEX_PROJECTION_AXES[9],
+            SIMPLEX_PROJECTION_AXES[10],
+            SIMPLEX_PROJECTION_AXES[11],
+        );
+
+        min_a = min2(min_a, a);
+        min_b = min2(min_b, b);
+        min_c = min2(min_c, c);
+        min_d = min2(min_d, d);
+
+        max_a = max2(max_a, a);
+        max_b = max2(max_b, b);
+        max_c = max2(max_c, c);
+        max_d = max2(max_d, d);
+    }
+
+    // we now have the planar offset for each projection axis
+
+    // apply padding offset
+    min_a -= padding;
+    min_b -= padding;
+    min_c -= padding;
+    min_d -= padding;
+
+    // lets compute intersection points for each tri-plane combination to find simplex corners
+    plane_computeConvex3PlaneIntersection(
+        result, result_offset,
+        SIMPLEX_PROJECTION_AXES[0], SIMPLEX_PROJECTION_AXES[1], SIMPLEX_PROJECTION_AXES[2], -min_a,
+        SIMPLEX_PROJECTION_AXES[3], SIMPLEX_PROJECTION_AXES[4], SIMPLEX_PROJECTION_AXES[5], -min_b,
+        SIMPLEX_PROJECTION_AXES[6], SIMPLEX_PROJECTION_AXES[7], SIMPLEX_PROJECTION_AXES[8], -min_c
+    );
+    plane_computeConvex3PlaneIntersection(
+        result, result_offset + 3,
+        SIMPLEX_PROJECTION_AXES[3], SIMPLEX_PROJECTION_AXES[4], SIMPLEX_PROJECTION_AXES[5], -min_b,
+        SIMPLEX_PROJECTION_AXES[6], SIMPLEX_PROJECTION_AXES[7], SIMPLEX_PROJECTION_AXES[8], -min_c,
+        SIMPLEX_PROJECTION_AXES[9], SIMPLEX_PROJECTION_AXES[10], SIMPLEX_PROJECTION_AXES[11], -min_d
+    );
+    plane_computeConvex3PlaneIntersection(
+        result, result_offset + 6,
+        SIMPLEX_PROJECTION_AXES[0], SIMPLEX_PROJECTION_AXES[1], SIMPLEX_PROJECTION_AXES[2], -min_a,
+        SIMPLEX_PROJECTION_AXES[3], SIMPLEX_PROJECTION_AXES[4], SIMPLEX_PROJECTION_AXES[5], -min_b,
+        SIMPLEX_PROJECTION_AXES[9], SIMPLEX_PROJECTION_AXES[10], SIMPLEX_PROJECTION_AXES[11], -min_d
+    );
+    plane_computeConvex3PlaneIntersection(
+        result, result_offset + 9,
+        SIMPLEX_PROJECTION_AXES[6], SIMPLEX_PROJECTION_AXES[7], SIMPLEX_PROJECTION_AXES[8], -min_c,
+        SIMPLEX_PROJECTION_AXES[0], SIMPLEX_PROJECTION_AXES[1], SIMPLEX_PROJECTION_AXES[2], -min_a,
+        SIMPLEX_PROJECTION_AXES[9], SIMPLEX_PROJECTION_AXES[10], SIMPLEX_PROJECTION_AXES[11], -min_d
+    );
+}

package/core/geom/3d/tetrahedra/compute_bounding_simplex_3d.spec.js

@@ -0,0 +1,66 @@
+import { compute_bounding_simplex_3d } from "./compute_bounding_simplex_3d.js";
+import { v3_distance } from "../../v3_distance.js";
+import { orient3d_fast } from "../plane/orient3d_fast.js";
+
+test('one point', () => {
+    const r = [];
+    compute_bounding_simplex_3d(r, 0, [1, 2, 3], 1, 0);
+
+    for (let i = 0; i < 4; i++) {
+        const i3 = i * 3;
+
+        expect(r[i3]).toBeCloseTo(1);
+        expect(r[i3 + 1]).toBeCloseTo(2);
+        expect(r[i3 + 2]).toBeCloseTo(3);
+    }
+});
+
+test('planar containment, one point', () => {
+    const r = [];
+
+    compute_bounding_simplex_3d(r, 0, [0, 0, 0], 1, 1);
+
+    r.push(0, 0, 0);
+
+    expect(orient3d_fast(r, 1, 3, 2, 4)).toBeLessThan(0);
+    expect(orient3d_fast(r, 2, 3, 0, 4)).toBeLessThan(0);
+    expect(orient3d_fast(r, 3, 1, 0, 4)).toBeLessThan(0);
+    expect(orient3d_fast(r, 0, 1, 2, 4)).toBeLessThan(0);
+});
+
+test('positive padding results in larger simplex', () => {
+    const r_0 = [];
+    const r_n = [];
+    const r_p = [];
+
+    const volume = [
+        -100, 0, 0,
+        100, 0, 0,
+        0, -100, 0,
+        0, 100, 0,
+        0, 0, -100,
+        0, 0, 100,
+    ];
+
+    compute_bounding_simplex_3d(r_0, 0, volume, 6, 0);
+    compute_bounding_simplex_3d(r_n, 0, volume, 6, -1);
+    compute_bounding_simplex_3d(r_p, 0, volume, 6, 1);
+
+    function compute_distance_sum(ref, points, point_count) {
+        let r = 0;
+        for (let i = 0; i < point_count; i++) {
+            const i3 = i * 3;
+
+            r += v3_distance(points[i3], points[i3 + 1], points[i3 + 2], ref[0], ref[1], ref[2]);
+        }
+
+        return r;
+    }
+
+    const d_0 = compute_distance_sum([0, 0, 0], r_0, 4);
+    const d_n = compute_distance_sum([0, 0, 0], r_n, 4);
+    const d_p = compute_distance_sum([0, 0, 0], r_p, 4);
+
+    expect(d_0).toBeLessThan(d_p);
+    expect(d_0).toBeGreaterThan(d_n);
+});

package/core/geom/3d/tetrahedra/compute_circumsphere.js

@@ -0,0 +1,271 @@
+import { array_copy } from "../../../collection/array/copyArray.js";
+import { v3_dot } from "../../v3_dot.js";
+
+const MAX_FLOAT32 = 3.4028234663852886e+38;
+const SMALL_NUMBER = 1e-12;
+const VTK_MAX_WARNS = 3;
+
+/**
+ * Compute the circumcenter (center[3]) and radius squared (method
+ * return value) of a tetrahedron defined by the four points x1, x2,
+ * x3, and x4.
+ *
+ * @see https://github.com/Kitware/VTK/blob/ac3fd8005bce7b3da4423c305f61ffd9df9695ef/Common/DataModel/vtkTetra.cxx
+ * @param {number[]} result [center_x, center_y, center_z, radius_squared]
+ * @param {number[]} points
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @param {number} d
+ */
+export function compute_circumsphere(
+    result,
+    points,
+    a, b, c, d
+) {
+    const n12 = [];
+    const n13 = [];
+    const n14 = [];
+
+    const x12 = [];
+    const x13 = [];
+    const x14 = [];
+
+    //  calculate normals and intersection points of bisecting planes.
+    for (let i = 0; i < 3; i++) {
+        const v_a = points[a * 3 + i];
+
+        const v_b = points[b * 3 + i];
+        n12[i] = v_b - v_a;
+        const v_c = points[c * 3 + i];
+        n13[i] = v_c - v_a;
+        const v_d = points[d * 3 + i];
+        n14[i] = v_d - v_a;
+
+        x12[i] = (v_b + v_a) * 0.5;
+        x13[i] = (v_c + v_a) * 0.5;
+        x14[i] = (v_d + v_a) * 0.5;
+    }
+
+    const A = [];
+
+    array_copy(n12, 0, A, 0, 3);
+    array_copy(n13, 0, A, 3, 3);
+    array_copy(n14, 0, A, 6, 3);
+
+    const rhs = [];
+
+    rhs[0] = v3_dot(n12[0], n12[1], n12[2], x12[0], x12[1], x12[2]);
+    rhs[1] = v3_dot(n13[0], n13[1], n13[2], x13[0], x13[1], x13[2]);
+    rhs[2] = v3_dot(n14[0], n14[1], n14[2], x14[0], x14[1], x14[2]);
+
+    // Solve system of equations
+    if (solve_linear_system(A, rhs, 3) === false) {
+        // failed to solve, fall-back to infinitely-sized sphere centered around origin
+        result[0] = result[1] = result[2] = 0;
+        result[3] = MAX_FLOAT32;
+        return;
+    } else {
+        result[0] = rhs[0];
+        result[1] = rhs[1];
+        result[2] = rhs[2];
+    }
+
+    let sum = 0;
+    let diff;
+
+    for (let i = 0; i < 3; i++) {
+        const rhs_offset = rhs[i];
+
+        diff = points[a * 3 + i] - rhs_offset;
+        sum += diff * diff;
+        diff = points[b * 3 + i] - rhs_offset;
+        sum += diff * diff;
+        diff = points[c * 3 + i] - rhs_offset;
+        sum += diff * diff;
+        diff = points[d * 3 + i] - rhs_offset;
+        sum += diff * diff;
+    }
+
+    // divide
+    sum *= 0.25;
+
+    if (sum >= MAX_FLOAT32) {
+        result[3] = MAX_FLOAT32;
+    } else {
+        result[3] = sum;
+    }
+}
+
+/**
+ * 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[]} A
+ * @param {number[]} x
+ * @param {number} size
+ * @returns {boolean}
+ */
+function solve_linear_system(A, x, size) {
+    const index = [];
+
+    if (luf_factor_linear_system(A, index, size) === 0) {
+        return false;
+    }
+
+    luf_solve_linear_system(A, index, x, size);
+
+    return true;
+}
+
+
+/**
+ * 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
+ * @param {number[]} index
+ * @param {number} size
+ */
+function luf_factor_linear_system(A, index, size) {
+    const scale = [];
+
+    // 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 numWarns = 0;
+    let i, j, k;
+    let maxI = 0;
+    let largest, temp1, temp2, sum;
+    // 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 && numWarns++ < VTK_MAX_WARNS) {
+            // vtkGenericWarningMacro(<< "Unable to factor linear system");
+            return 0;
+        }
+        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 && numWarns++ < VTK_MAX_WARNS) {
+            //vtkGenericWarningMacro(<< "Unable to factor linear system");
+            return 0;
+        }
+
+        if (j !== (size - 1)) {
+            temp1 = 1.0 / A[j * size + j];
+            for (i = j + 1; i < size; ++i) {
+                A[i * size + j] *= temp1;
+            }
+        }
+    }
+
+    return 1;
+}
+
+/**
+ * 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
+ * @param {number[]} index
+ * @param {number[]} x
+ * @param {number} size
+ */
+function luf_solve_linear_system(A, index, x, size) {
+    let i, j, ii, idx;
+    let sum;
+    //
+    // Proceed with forward and backsubstitution for L and U
+    // matrices.  First, forward substitution.
+    //
+    for (ii = -1, i = 0; i < size; ++i) {
+        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];
+    }
+}