@danielsimonjr/mathts-wasm 0.1.1

package/build/mathts.js

@@ -0,0 +1,1484 @@
+async function instantiate(module, imports = {}) {
+  const adaptedImports = {
+    env: Object.assign(Object.create(globalThis), imports.env || {}, {
+      abort(message, fileName, lineNumber, columnNumber) {
+        // ~lib/builtins/abort(~lib/string/String | null?, ~lib/string/String | null?, u32?, u32?) => void
+        message = __liftString(message >>> 0);
+        fileName = __liftString(fileName >>> 0);
+        lineNumber = lineNumber >>> 0;
+        columnNumber = columnNumber >>> 0;
+        (() => {
+          // @external.js
+          throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);
+        })();
+      },
+    }),
+  };
+  const { exports } = await WebAssembly.instantiate(module, adaptedImports);
+  const memory = exports.memory || imports.env.memory;
+  const adaptedExports = Object.setPrototypeOf({
+    complex(re, im) {
+      // src/types/complex/complex(f64, f64) => src/types/complex/Complex
+      return __liftInternref(exports.complex(re, im) >>> 0);
+    },
+    complexFromPolar(r, theta) {
+      // src/types/complex/complexFromPolar(f64, f64) => src/types/complex/Complex
+      return __liftInternref(exports.complexFromPolar(r, theta) >>> 0);
+    },
+    isNaN_f64(a) {
+      // src/ops/scalar/isNaN_f64(f64) => bool
+      return exports.isNaN_f64(a) != 0;
+    },
+    isFinite_f64(a) {
+      // src/ops/scalar/isFinite_f64(f64) => bool
+      return exports.isFinite_f64(a) != 0;
+    },
+    array_sum(data) {
+      // src/ops/array/array_sum(~lib/typedarray/Float64Array) => f64
+      data = __lowerTypedArray(Float64Array, 5, 3, data) || __notnull();
+      return exports.array_sum(data);
+    },
+    array_product(data) {
+      // src/ops/array/array_product(~lib/typedarray/Float64Array) => f64
+      data = __lowerTypedArray(Float64Array, 5, 3, data) || __notnull();
+      return exports.array_product(data);
+    },
+    array_mean(data) {
+      // src/ops/array/array_mean(~lib/typedarray/Float64Array) => f64
+      data = __lowerTypedArray(Float64Array, 5, 3, data) || __notnull();
+      return exports.array_mean(data);
+    },
+    array_variance(data) {
+      // src/ops/array/array_variance(~lib/typedarray/Float64Array) => f64
+      data = __lowerTypedArray(Float64Array, 5, 3, data) || __notnull();
+      return exports.array_variance(data);
+    },
+    array_stddev(data) {
+      // src/ops/array/array_stddev(~lib/typedarray/Float64Array) => f64
+      data = __lowerTypedArray(Float64Array, 5, 3, data) || __notnull();
+      return exports.array_stddev(data);
+    },
+    array_min(data) {
+      // src/ops/array/array_min(~lib/typedarray/Float64Array) => f64
+      data = __lowerTypedArray(Float64Array, 5, 3, data) || __notnull();
+      return exports.array_min(data);
+    },
+    array_max(data) {
+      // src/ops/array/array_max(~lib/typedarray/Float64Array) => f64
+      data = __lowerTypedArray(Float64Array, 5, 3, data) || __notnull();
+      return exports.array_max(data);
+    },
+    array_argmin(data) {
+      // src/ops/array/array_argmin(~lib/typedarray/Float64Array) => i32
+      data = __lowerTypedArray(Float64Array, 5, 3, data) || __notnull();
+      return exports.array_argmin(data);
+    },
+    array_argmax(data) {
+      // src/ops/array/array_argmax(~lib/typedarray/Float64Array) => i32
+      data = __lowerTypedArray(Float64Array, 5, 3, data) || __notnull();
+      return exports.array_argmax(data);
+    },
+    array_norm(data) {
+      // src/ops/array/array_norm(~lib/typedarray/Float64Array) => f64
+      data = __lowerTypedArray(Float64Array, 5, 3, data) || __notnull();
+      return exports.array_norm(data);
+    },
+    array_norm_l1(data) {
+      // src/ops/array/array_norm_l1(~lib/typedarray/Float64Array) => f64
+      data = __lowerTypedArray(Float64Array, 5, 3, data) || __notnull();
+      return exports.array_norm_l1(data);
+    },
+    array_norm_linf(data) {
+      // src/ops/array/array_norm_linf(~lib/typedarray/Float64Array) => f64
+      data = __lowerTypedArray(Float64Array, 5, 3, data) || __notnull();
+      return exports.array_norm_linf(data);
+    },
+    array_dot(a, b) {
+      // src/ops/array/array_dot(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => f64
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      b = __lowerTypedArray(Float64Array, 5, 3, b) || __notnull();
+      try {
+        return exports.array_dot(a, b);
+      } finally {
+        __release(a);
+      }
+    },
+    array_add(a, b, result) {
+      // src/ops/array/array_add(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      b = __retain(__lowerTypedArray(Float64Array, 5, 3, b) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.array_add(a, b, result);
+      } finally {
+        __release(a);
+        __release(b);
+      }
+    },
+    array_sub(a, b, result) {
+      // src/ops/array/array_sub(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      b = __retain(__lowerTypedArray(Float64Array, 5, 3, b) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.array_sub(a, b, result);
+      } finally {
+        __release(a);
+        __release(b);
+      }
+    },
+    array_mul(a, b, result) {
+      // src/ops/array/array_mul(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      b = __retain(__lowerTypedArray(Float64Array, 5, 3, b) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.array_mul(a, b, result);
+      } finally {
+        __release(a);
+        __release(b);
+      }
+    },
+    array_div(a, b, result) {
+      // src/ops/array/array_div(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      b = __retain(__lowerTypedArray(Float64Array, 5, 3, b) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.array_div(a, b, result);
+      } finally {
+        __release(a);
+        __release(b);
+      }
+    },
+    array_scale(a, scalar, result) {
+      // src/ops/array/array_scale(~lib/typedarray/Float64Array, f64, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.array_scale(a, scalar, result);
+      } finally {
+        __release(a);
+      }
+    },
+    array_add_scalar(a, scalar, result) {
+      // src/ops/array/array_add_scalar(~lib/typedarray/Float64Array, f64, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.array_add_scalar(a, scalar, result);
+      } finally {
+        __release(a);
+      }
+    },
+    array_neg(a, result) {
+      // src/ops/array/array_neg(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.array_neg(a, result);
+      } finally {
+        __release(a);
+      }
+    },
+    array_abs(a, result) {
+      // src/ops/array/array_abs(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.array_abs(a, result);
+      } finally {
+        __release(a);
+      }
+    },
+    array_sqrt(a, result) {
+      // src/ops/array/array_sqrt(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.array_sqrt(a, result);
+      } finally {
+        __release(a);
+      }
+    },
+    array_square(a, result) {
+      // src/ops/array/array_square(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.array_square(a, result);
+      } finally {
+        __release(a);
+      }
+    },
+    array_exp(a, result) {
+      // src/ops/array/array_exp(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.array_exp(a, result);
+      } finally {
+        __release(a);
+      }
+    },
+    array_log(a, result) {
+      // src/ops/array/array_log(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.array_log(a, result);
+      } finally {
+        __release(a);
+      }
+    },
+    array_sin(a, result) {
+      // src/ops/array/array_sin(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.array_sin(a, result);
+      } finally {
+        __release(a);
+      }
+    },
+    array_cos(a, result) {
+      // src/ops/array/array_cos(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.array_cos(a, result);
+      } finally {
+        __release(a);
+      }
+    },
+    array_axpby(alpha, a, beta, b, result) {
+      // src/ops/array/array_axpby(f64, ~lib/typedarray/Float64Array, f64, ~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      b = __retain(__lowerTypedArray(Float64Array, 5, 3, b) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.array_axpby(alpha, a, beta, b, result);
+      } finally {
+        __release(a);
+        __release(b);
+      }
+    },
+    array_distance(a, b) {
+      // src/ops/array/array_distance(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => f64
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      b = __lowerTypedArray(Float64Array, 5, 3, b) || __notnull();
+      try {
+        return exports.array_distance(a, b);
+      } finally {
+        __release(a);
+      }
+    },
+    array_cosine_similarity(a, b) {
+      // src/ops/array/array_cosine_similarity(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => f64
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      b = __lowerTypedArray(Float64Array, 5, 3, b) || __notnull();
+      try {
+        return exports.array_cosine_similarity(a, b);
+      } finally {
+        __release(a);
+      }
+    },
+    array_scale_inplace(a, scalar) {
+      // src/ops/array/array_scale_inplace(~lib/typedarray/Float64Array, f64) => void
+      a = __lowerTypedArray(Float64Array, 5, 3, a) || __notnull();
+      exports.array_scale_inplace(a, scalar);
+    },
+    array_add_scalar_inplace(a, scalar) {
+      // src/ops/array/array_add_scalar_inplace(~lib/typedarray/Float64Array, f64) => void
+      a = __lowerTypedArray(Float64Array, 5, 3, a) || __notnull();
+      exports.array_add_scalar_inplace(a, scalar);
+    },
+    array_add_inplace(a, b) {
+      // src/ops/array/array_add_inplace(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      b = __lowerTypedArray(Float64Array, 5, 3, b) || __notnull();
+      try {
+        exports.array_add_inplace(a, b);
+      } finally {
+        __release(a);
+      }
+    },
+    array_clamp_inplace(a, lo, hi) {
+      // src/ops/array/array_clamp_inplace(~lib/typedarray/Float64Array, f64, f64) => void
+      a = __lowerTypedArray(Float64Array, 5, 3, a) || __notnull();
+      exports.array_clamp_inplace(a, lo, hi);
+    },
+    array_fill(a, value) {
+      // src/ops/array/array_fill(~lib/typedarray/Float64Array, f64) => void
+      a = __lowerTypedArray(Float64Array, 5, 3, a) || __notnull();
+      exports.array_fill(a, value);
+    },
+    array_copy(src, dst) {
+      // src/ops/array/array_copy(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      src = __retain(__lowerTypedArray(Float64Array, 5, 3, src) || __notnull());
+      dst = __lowerTypedArray(Float64Array, 5, 3, dst) || __notnull();
+      try {
+        exports.array_copy(src, dst);
+      } finally {
+        __release(src);
+      }
+    },
+    matrix_zeros(rows, cols) {
+      // src/ops/matrix/matrix_zeros(i32, i32) => ~lib/typedarray/Float64Array
+      return __liftTypedArray(Float64Array, exports.matrix_zeros(rows, cols) >>> 0);
+    },
+    matrix_ones(rows, cols) {
+      // src/ops/matrix/matrix_ones(i32, i32) => ~lib/typedarray/Float64Array
+      return __liftTypedArray(Float64Array, exports.matrix_ones(rows, cols) >>> 0);
+    },
+    matrix_fill(rows, cols, value) {
+      // src/ops/matrix/matrix_fill(i32, i32, f64) => ~lib/typedarray/Float64Array
+      return __liftTypedArray(Float64Array, exports.matrix_fill(rows, cols, value) >>> 0);
+    },
+    matrix_identity(n) {
+      // src/ops/matrix/matrix_identity(i32) => ~lib/typedarray/Float64Array
+      return __liftTypedArray(Float64Array, exports.matrix_identity(n) >>> 0);
+    },
+    matrix_diag(values) {
+      // src/ops/matrix/matrix_diag(~lib/typedarray/Float64Array) => ~lib/typedarray/Float64Array
+      values = __lowerTypedArray(Float64Array, 5, 3, values) || __notnull();
+      return __liftTypedArray(Float64Array, exports.matrix_diag(values) >>> 0);
+    },
+    matrix_get(data, cols, row, col) {
+      // src/ops/matrix/matrix_get(~lib/typedarray/Float64Array, i32, i32, i32) => f64
+      data = __lowerTypedArray(Float64Array, 5, 3, data) || __notnull();
+      return exports.matrix_get(data, cols, row, col);
+    },
+    matrix_set(data, cols, row, col, value) {
+      // src/ops/matrix/matrix_set(~lib/typedarray/Float64Array, i32, i32, i32, f64) => void
+      data = __lowerTypedArray(Float64Array, 5, 3, data) || __notnull();
+      exports.matrix_set(data, cols, row, col, value);
+    },
+    matrix_get_row(data, cols, row) {
+      // src/ops/matrix/matrix_get_row(~lib/typedarray/Float64Array, i32, i32) => ~lib/typedarray/Float64Array
+      data = __lowerTypedArray(Float64Array, 5, 3, data) || __notnull();
+      return __liftTypedArray(Float64Array, exports.matrix_get_row(data, cols, row) >>> 0);
+    },
+    matrix_get_col(data, rows, cols, col) {
+      // src/ops/matrix/matrix_get_col(~lib/typedarray/Float64Array, i32, i32, i32) => ~lib/typedarray/Float64Array
+      data = __lowerTypedArray(Float64Array, 5, 3, data) || __notnull();
+      return __liftTypedArray(Float64Array, exports.matrix_get_col(data, rows, cols, col) >>> 0);
+    },
+    matrix_get_diag(data, rows, cols) {
+      // src/ops/matrix/matrix_get_diag(~lib/typedarray/Float64Array, i32, i32) => ~lib/typedarray/Float64Array
+      data = __lowerTypedArray(Float64Array, 5, 3, data) || __notnull();
+      return __liftTypedArray(Float64Array, exports.matrix_get_diag(data, rows, cols) >>> 0);
+    },
+    matrix_add(a, b, result) {
+      // src/ops/matrix/matrix_add(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      b = __retain(__lowerTypedArray(Float64Array, 5, 3, b) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.matrix_add(a, b, result);
+      } finally {
+        __release(a);
+        __release(b);
+      }
+    },
+    matrix_sub(a, b, result) {
+      // src/ops/matrix/matrix_sub(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      b = __retain(__lowerTypedArray(Float64Array, 5, 3, b) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.matrix_sub(a, b, result);
+      } finally {
+        __release(a);
+        __release(b);
+      }
+    },
+    matrix_mul_elementwise(a, b, result) {
+      // src/ops/matrix/matrix_mul_elementwise(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      b = __retain(__lowerTypedArray(Float64Array, 5, 3, b) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.matrix_mul_elementwise(a, b, result);
+      } finally {
+        __release(a);
+        __release(b);
+      }
+    },
+    matrix_div_elementwise(a, b, result) {
+      // src/ops/matrix/matrix_div_elementwise(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      b = __retain(__lowerTypedArray(Float64Array, 5, 3, b) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.matrix_div_elementwise(a, b, result);
+      } finally {
+        __release(a);
+        __release(b);
+      }
+    },
+    matrix_scale(a, scalar, result) {
+      // src/ops/matrix/matrix_scale(~lib/typedarray/Float64Array, f64, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.matrix_scale(a, scalar, result);
+      } finally {
+        __release(a);
+      }
+    },
+    matrix_add_scalar(a, scalar, result) {
+      // src/ops/matrix/matrix_add_scalar(~lib/typedarray/Float64Array, f64, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.matrix_add_scalar(a, scalar, result);
+      } finally {
+        __release(a);
+      }
+    },
+    matrix_neg(a, result) {
+      // src/ops/matrix/matrix_neg(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.matrix_neg(a, result);
+      } finally {
+        __release(a);
+      }
+    },
+    matrix_multiply(a, aRows, aCols, b, bCols, result) {
+      // src/ops/matrix/matrix_multiply(~lib/typedarray/Float64Array, i32, i32, ~lib/typedarray/Float64Array, i32, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      b = __retain(__lowerTypedArray(Float64Array, 5, 3, b) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.matrix_multiply(a, aRows, aCols, b, bCols, result);
+      } finally {
+        __release(a);
+        __release(b);
+      }
+    },
+    matrix_vector_multiply(a, rows, cols, x, result) {
+      // src/ops/matrix/matrix_vector_multiply(~lib/typedarray/Float64Array, i32, i32, ~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      x = __retain(__lowerTypedArray(Float64Array, 5, 3, x) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.matrix_vector_multiply(a, rows, cols, x, result);
+      } finally {
+        __release(a);
+        __release(x);
+      }
+    },
+    vector_matrix_multiply(x, a, rows, cols, result) {
+      // src/ops/matrix/vector_matrix_multiply(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array, i32, i32, ~lib/typedarray/Float64Array) => void
+      x = __retain(__lowerTypedArray(Float64Array, 5, 3, x) || __notnull());
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.vector_matrix_multiply(x, a, rows, cols, result);
+      } finally {
+        __release(x);
+        __release(a);
+      }
+    },
+    matrix_outer(x, y, result) {
+      // src/ops/matrix/matrix_outer(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      x = __retain(__lowerTypedArray(Float64Array, 5, 3, x) || __notnull());
+      y = __retain(__lowerTypedArray(Float64Array, 5, 3, y) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.matrix_outer(x, y, result);
+      } finally {
+        __release(x);
+        __release(y);
+      }
+    },
+    matrix_transpose(a, rows, cols, result) {
+      // src/ops/matrix/matrix_transpose(~lib/typedarray/Float64Array, i32, i32, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.matrix_transpose(a, rows, cols, result);
+      } finally {
+        __release(a);
+      }
+    },
+    matrix_sum(data) {
+      // src/ops/matrix/matrix_sum(~lib/typedarray/Float64Array) => f64
+      data = __lowerTypedArray(Float64Array, 5, 3, data) || __notnull();
+      return exports.matrix_sum(data);
+    },
+    matrix_mean(data) {
+      // src/ops/matrix/matrix_mean(~lib/typedarray/Float64Array) => f64
+      data = __lowerTypedArray(Float64Array, 5, 3, data) || __notnull();
+      return exports.matrix_mean(data);
+    },
+    matrix_min(data) {
+      // src/ops/matrix/matrix_min(~lib/typedarray/Float64Array) => f64
+      data = __lowerTypedArray(Float64Array, 5, 3, data) || __notnull();
+      return exports.matrix_min(data);
+    },
+    matrix_max(data) {
+      // src/ops/matrix/matrix_max(~lib/typedarray/Float64Array) => f64
+      data = __lowerTypedArray(Float64Array, 5, 3, data) || __notnull();
+      return exports.matrix_max(data);
+    },
+    matrix_norm_frobenius(data) {
+      // src/ops/matrix/matrix_norm_frobenius(~lib/typedarray/Float64Array) => f64
+      data = __lowerTypedArray(Float64Array, 5, 3, data) || __notnull();
+      return exports.matrix_norm_frobenius(data);
+    },
+    matrix_trace(data, rows, cols) {
+      // src/ops/matrix/matrix_trace(~lib/typedarray/Float64Array, i32, i32) => f64
+      data = __lowerTypedArray(Float64Array, 5, 3, data) || __notnull();
+      return exports.matrix_trace(data, rows, cols);
+    },
+    matrix_sum_rows(data, rows, cols, result) {
+      // src/ops/matrix/matrix_sum_rows(~lib/typedarray/Float64Array, i32, i32, ~lib/typedarray/Float64Array) => void
+      data = __retain(__lowerTypedArray(Float64Array, 5, 3, data) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.matrix_sum_rows(data, rows, cols, result);
+      } finally {
+        __release(data);
+      }
+    },
+    matrix_sum_cols(data, rows, cols, result) {
+      // src/ops/matrix/matrix_sum_cols(~lib/typedarray/Float64Array, i32, i32, ~lib/typedarray/Float64Array) => void
+      data = __retain(__lowerTypedArray(Float64Array, 5, 3, data) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.matrix_sum_cols(data, rows, cols, result);
+      } finally {
+        __release(data);
+      }
+    },
+    matrix_is_square(rows, cols) {
+      // src/ops/matrix/matrix_is_square(i32, i32) => bool
+      return exports.matrix_is_square(rows, cols) != 0;
+    },
+    matrix_is_symmetric(data, rows, cols, tolerance) {
+      // src/ops/matrix/matrix_is_symmetric(~lib/typedarray/Float64Array, i32, i32, f64) => bool
+      data = __lowerTypedArray(Float64Array, 5, 3, data) || __notnull();
+      return exports.matrix_is_symmetric(data, rows, cols, tolerance) != 0;
+    },
+    matrix_is_diagonal(data, rows, cols, tolerance) {
+      // src/ops/matrix/matrix_is_diagonal(~lib/typedarray/Float64Array, i32, i32, f64) => bool
+      data = __lowerTypedArray(Float64Array, 5, 3, data) || __notnull();
+      return exports.matrix_is_diagonal(data, rows, cols, tolerance) != 0;
+    },
+    matrix_is_identity(data, rows, cols, tolerance) {
+      // src/ops/matrix/matrix_is_identity(~lib/typedarray/Float64Array, i32, i32, f64) => bool
+      data = __lowerTypedArray(Float64Array, 5, 3, data) || __notnull();
+      return exports.matrix_is_identity(data, rows, cols, tolerance) != 0;
+    },
+    matrix_scale_inplace(data, scalar) {
+      // src/ops/matrix/matrix_scale_inplace(~lib/typedarray/Float64Array, f64) => void
+      data = __lowerTypedArray(Float64Array, 5, 3, data) || __notnull();
+      exports.matrix_scale_inplace(data, scalar);
+    },
+    matrix_add_scalar_inplace(data, scalar) {
+      // src/ops/matrix/matrix_add_scalar_inplace(~lib/typedarray/Float64Array, f64) => void
+      data = __lowerTypedArray(Float64Array, 5, 3, data) || __notnull();
+      exports.matrix_add_scalar_inplace(data, scalar);
+    },
+    matrix_add_inplace(a, b) {
+      // src/ops/matrix/matrix_add_inplace(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      b = __lowerTypedArray(Float64Array, 5, 3, b) || __notnull();
+      try {
+        exports.matrix_add_inplace(a, b);
+      } finally {
+        __release(a);
+      }
+    },
+    matrix_copy(src, dst) {
+      // src/ops/matrix/matrix_copy(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      src = __retain(__lowerTypedArray(Float64Array, 5, 3, src) || __notnull());
+      dst = __lowerTypedArray(Float64Array, 5, 3, dst) || __notnull();
+      try {
+        exports.matrix_copy(src, dst);
+      } finally {
+        __release(src);
+      }
+    },
+    matrix_axpy(alpha, x, y) {
+      // src/ops/matrix/matrix_axpy(f64, ~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      x = __retain(__lowerTypedArray(Float64Array, 5, 3, x) || __notnull());
+      y = __lowerTypedArray(Float64Array, 5, 3, y) || __notnull();
+      try {
+        exports.matrix_axpy(alpha, x, y);
+      } finally {
+        __release(x);
+      }
+    },
+    matrix_gemm(alpha, a, m, k, b, n, beta, c) {
+      // src/ops/matrix/matrix_gemm(f64, ~lib/typedarray/Float64Array, i32, i32, ~lib/typedarray/Float64Array, i32, f64, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      b = __retain(__lowerTypedArray(Float64Array, 5, 3, b) || __notnull());
+      c = __lowerTypedArray(Float64Array, 5, 3, c) || __notnull();
+      try {
+        exports.matrix_gemm(alpha, a, m, k, b, n, beta, c);
+      } finally {
+        __release(a);
+        __release(b);
+      }
+    },
+    matrix_gemv(alpha, a, m, n, x, beta, y) {
+      // src/ops/matrix/matrix_gemv(f64, ~lib/typedarray/Float64Array, i32, i32, ~lib/typedarray/Float64Array, f64, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      x = __retain(__lowerTypedArray(Float64Array, 5, 3, x) || __notnull());
+      y = __lowerTypedArray(Float64Array, 5, 3, y) || __notnull();
+      try {
+        exports.matrix_gemv(alpha, a, m, n, x, beta, y);
+      } finally {
+        __release(a);
+        __release(x);
+      }
+    },
+    complex_add(a, b) {
+      // src/ops/complex-ops/complex_add(src/types/complex/Complex, src/types/complex/Complex) => src/types/complex/Complex
+      a = __retain(__lowerInternref(a) || __notnull());
+      b = __lowerInternref(b) || __notnull();
+      try {
+        return __liftInternref(exports.complex_add(a, b) >>> 0);
+      } finally {
+        __release(a);
+      }
+    },
+    complex_sub(a, b) {
+      // src/ops/complex-ops/complex_sub(src/types/complex/Complex, src/types/complex/Complex) => src/types/complex/Complex
+      a = __retain(__lowerInternref(a) || __notnull());
+      b = __lowerInternref(b) || __notnull();
+      try {
+        return __liftInternref(exports.complex_sub(a, b) >>> 0);
+      } finally {
+        __release(a);
+      }
+    },
+    complex_mul(a, b) {
+      // src/ops/complex-ops/complex_mul(src/types/complex/Complex, src/types/complex/Complex) => src/types/complex/Complex
+      a = __retain(__lowerInternref(a) || __notnull());
+      b = __lowerInternref(b) || __notnull();
+      try {
+        return __liftInternref(exports.complex_mul(a, b) >>> 0);
+      } finally {
+        __release(a);
+      }
+    },
+    complex_div(a, b) {
+      // src/ops/complex-ops/complex_div(src/types/complex/Complex, src/types/complex/Complex) => src/types/complex/Complex
+      a = __retain(__lowerInternref(a) || __notnull());
+      b = __lowerInternref(b) || __notnull();
+      try {
+        return __liftInternref(exports.complex_div(a, b) >>> 0);
+      } finally {
+        __release(a);
+      }
+    },
+    complex_neg(a) {
+      // src/ops/complex-ops/complex_neg(src/types/complex/Complex) => src/types/complex/Complex
+      a = __lowerInternref(a) || __notnull();
+      return __liftInternref(exports.complex_neg(a) >>> 0);
+    },
+    complex_conj(a) {
+      // src/ops/complex-ops/complex_conj(src/types/complex/Complex) => src/types/complex/Complex
+      a = __lowerInternref(a) || __notnull();
+      return __liftInternref(exports.complex_conj(a) >>> 0);
+    },
+    complex_reciprocal(a) {
+      // src/ops/complex-ops/complex_reciprocal(src/types/complex/Complex) => src/types/complex/Complex
+      a = __lowerInternref(a) || __notnull();
+      return __liftInternref(exports.complex_reciprocal(a) >>> 0);
+    },
+    complex_abs(a) {
+      // src/ops/complex-ops/complex_abs(src/types/complex/Complex) => f64
+      a = __lowerInternref(a) || __notnull();
+      return exports.complex_abs(a);
+    },
+    complex_arg(a) {
+      // src/ops/complex-ops/complex_arg(src/types/complex/Complex) => f64
+      a = __lowerInternref(a) || __notnull();
+      return exports.complex_arg(a);
+    },
+    complex_abs_squared(a) {
+      // src/ops/complex-ops/complex_abs_squared(src/types/complex/Complex) => f64
+      a = __lowerInternref(a) || __notnull();
+      return exports.complex_abs_squared(a);
+    },
+    complex_sqrt(a) {
+      // src/ops/complex-ops/complex_sqrt(src/types/complex/Complex) => src/types/complex/Complex
+      a = __lowerInternref(a) || __notnull();
+      return __liftInternref(exports.complex_sqrt(a) >>> 0);
+    },
+    complex_pow(a, n) {
+      // src/ops/complex-ops/complex_pow(src/types/complex/Complex, f64) => src/types/complex/Complex
+      a = __lowerInternref(a) || __notnull();
+      return __liftInternref(exports.complex_pow(a, n) >>> 0);
+    },
+    complex_cpow(a, b) {
+      // src/ops/complex-ops/complex_cpow(src/types/complex/Complex, src/types/complex/Complex) => src/types/complex/Complex
+      a = __retain(__lowerInternref(a) || __notnull());
+      b = __lowerInternref(b) || __notnull();
+      try {
+        return __liftInternref(exports.complex_cpow(a, b) >>> 0);
+      } finally {
+        __release(a);
+      }
+    },
+    complex_square(a) {
+      // src/ops/complex-ops/complex_square(src/types/complex/Complex) => src/types/complex/Complex
+      a = __lowerInternref(a) || __notnull();
+      return __liftInternref(exports.complex_square(a) >>> 0);
+    },
+    complex_cube(a) {
+      // src/ops/complex-ops/complex_cube(src/types/complex/Complex) => src/types/complex/Complex
+      a = __lowerInternref(a) || __notnull();
+      return __liftInternref(exports.complex_cube(a) >>> 0);
+    },
+    complex_exp(a) {
+      // src/ops/complex-ops/complex_exp(src/types/complex/Complex) => src/types/complex/Complex
+      a = __lowerInternref(a) || __notnull();
+      return __liftInternref(exports.complex_exp(a) >>> 0);
+    },
+    complex_log(a) {
+      // src/ops/complex-ops/complex_log(src/types/complex/Complex) => src/types/complex/Complex
+      a = __lowerInternref(a) || __notnull();
+      return __liftInternref(exports.complex_log(a) >>> 0);
+    },
+    complex_log10(a) {
+      // src/ops/complex-ops/complex_log10(src/types/complex/Complex) => src/types/complex/Complex
+      a = __lowerInternref(a) || __notnull();
+      return __liftInternref(exports.complex_log10(a) >>> 0);
+    },
+    complex_log2(a) {
+      // src/ops/complex-ops/complex_log2(src/types/complex/Complex) => src/types/complex/Complex
+      a = __lowerInternref(a) || __notnull();
+      return __liftInternref(exports.complex_log2(a) >>> 0);
+    },
+    complex_sin(a) {
+      // src/ops/complex-ops/complex_sin(src/types/complex/Complex) => src/types/complex/Complex
+      a = __lowerInternref(a) || __notnull();
+      return __liftInternref(exports.complex_sin(a) >>> 0);
+    },
+    complex_cos(a) {
+      // src/ops/complex-ops/complex_cos(src/types/complex/Complex) => src/types/complex/Complex
+      a = __lowerInternref(a) || __notnull();
+      return __liftInternref(exports.complex_cos(a) >>> 0);
+    },
+    complex_tan(a) {
+      // src/ops/complex-ops/complex_tan(src/types/complex/Complex) => src/types/complex/Complex
+      a = __lowerInternref(a) || __notnull();
+      return __liftInternref(exports.complex_tan(a) >>> 0);
+    },
+    complex_asin(a) {
+      // src/ops/complex-ops/complex_asin(src/types/complex/Complex) => src/types/complex/Complex
+      a = __lowerInternref(a) || __notnull();
+      return __liftInternref(exports.complex_asin(a) >>> 0);
+    },
+    complex_acos(a) {
+      // src/ops/complex-ops/complex_acos(src/types/complex/Complex) => src/types/complex/Complex
+      a = __lowerInternref(a) || __notnull();
+      return __liftInternref(exports.complex_acos(a) >>> 0);
+    },
+    complex_atan(a) {
+      // src/ops/complex-ops/complex_atan(src/types/complex/Complex) => src/types/complex/Complex
+      a = __lowerInternref(a) || __notnull();
+      return __liftInternref(exports.complex_atan(a) >>> 0);
+    },
+    complex_sinh(a) {
+      // src/ops/complex-ops/complex_sinh(src/types/complex/Complex) => src/types/complex/Complex
+      a = __lowerInternref(a) || __notnull();
+      return __liftInternref(exports.complex_sinh(a) >>> 0);
+    },
+    complex_cosh(a) {
+      // src/ops/complex-ops/complex_cosh(src/types/complex/Complex) => src/types/complex/Complex
+      a = __lowerInternref(a) || __notnull();
+      return __liftInternref(exports.complex_cosh(a) >>> 0);
+    },
+    complex_tanh(a) {
+      // src/ops/complex-ops/complex_tanh(src/types/complex/Complex) => src/types/complex/Complex
+      a = __lowerInternref(a) || __notnull();
+      return __liftInternref(exports.complex_tanh(a) >>> 0);
+    },
+    complex_asinh(a) {
+      // src/ops/complex-ops/complex_asinh(src/types/complex/Complex) => src/types/complex/Complex
+      a = __lowerInternref(a) || __notnull();
+      return __liftInternref(exports.complex_asinh(a) >>> 0);
+    },
+    complex_acosh(a) {
+      // src/ops/complex-ops/complex_acosh(src/types/complex/Complex) => src/types/complex/Complex
+      a = __lowerInternref(a) || __notnull();
+      return __liftInternref(exports.complex_acosh(a) >>> 0);
+    },
+    complex_atanh(a) {
+      // src/ops/complex-ops/complex_atanh(src/types/complex/Complex) => src/types/complex/Complex
+      a = __lowerInternref(a) || __notnull();
+      return __liftInternref(exports.complex_atanh(a) >>> 0);
+    },
+    complex_equals(a, b) {
+      // src/ops/complex-ops/complex_equals(src/types/complex/Complex, src/types/complex/Complex) => bool
+      a = __retain(__lowerInternref(a) || __notnull());
+      b = __lowerInternref(b) || __notnull();
+      try {
+        return exports.complex_equals(a, b) != 0;
+      } finally {
+        __release(a);
+      }
+    },
+    complex_approx_equals(a, b, tolerance) {
+      // src/ops/complex-ops/complex_approx_equals(src/types/complex/Complex, src/types/complex/Complex, f64) => bool
+      a = __retain(__lowerInternref(a) || __notnull());
+      b = __lowerInternref(b) || __notnull();
+      try {
+        return exports.complex_approx_equals(a, b, tolerance) != 0;
+      } finally {
+        __release(a);
+      }
+    },
+    complex_is_zero(a) {
+      // src/ops/complex-ops/complex_is_zero(src/types/complex/Complex) => bool
+      a = __lowerInternref(a) || __notnull();
+      return exports.complex_is_zero(a) != 0;
+    },
+    complex_is_real(a) {
+      // src/ops/complex-ops/complex_is_real(src/types/complex/Complex) => bool
+      a = __lowerInternref(a) || __notnull();
+      return exports.complex_is_real(a) != 0;
+    },
+    complex_is_imaginary(a) {
+      // src/ops/complex-ops/complex_is_imaginary(src/types/complex/Complex) => bool
+      a = __lowerInternref(a) || __notnull();
+      return exports.complex_is_imaginary(a) != 0;
+    },
+    complex_is_nan(a) {
+      // src/ops/complex-ops/complex_is_nan(src/types/complex/Complex) => bool
+      a = __lowerInternref(a) || __notnull();
+      return exports.complex_is_nan(a) != 0;
+    },
+    complex_is_finite(a) {
+      // src/ops/complex-ops/complex_is_finite(src/types/complex/Complex) => bool
+      a = __lowerInternref(a) || __notnull();
+      return exports.complex_is_finite(a) != 0;
+    },
+    complex_from_real(re) {
+      // src/ops/complex-ops/complex_from_real(f64) => src/types/complex/Complex
+      return __liftInternref(exports.complex_from_real(re) >>> 0);
+    },
+    complex_from_imag(im) {
+      // src/ops/complex-ops/complex_from_imag(f64) => src/types/complex/Complex
+      return __liftInternref(exports.complex_from_imag(im) >>> 0);
+    },
+    complex_from_polar(r, theta) {
+      // src/ops/complex-ops/complex_from_polar(f64, f64) => src/types/complex/Complex
+      return __liftInternref(exports.complex_from_polar(r, theta) >>> 0);
+    },
+    complex_to_polar(a) {
+      // src/ops/complex-ops/complex_to_polar(src/types/complex/Complex) => ~lib/typedarray/Float64Array
+      a = __lowerInternref(a) || __notnull();
+      return __liftTypedArray(Float64Array, exports.complex_to_polar(a) >>> 0);
+    },
+    complex_axpby(alpha, a, beta, b) {
+      // src/ops/complex-ops/complex_axpby(src/types/complex/Complex, src/types/complex/Complex, src/types/complex/Complex, src/types/complex/Complex) => src/types/complex/Complex
+      alpha = __retain(__lowerInternref(alpha) || __notnull());
+      a = __retain(__lowerInternref(a) || __notnull());
+      beta = __retain(__lowerInternref(beta) || __notnull());
+      b = __lowerInternref(b) || __notnull();
+      try {
+        return __liftInternref(exports.complex_axpby(alpha, a, beta, b) >>> 0);
+      } finally {
+        __release(alpha);
+        __release(a);
+        __release(beta);
+      }
+    },
+    complex_distance(a, b) {
+      // src/ops/complex-ops/complex_distance(src/types/complex/Complex, src/types/complex/Complex) => f64
+      a = __retain(__lowerInternref(a) || __notnull());
+      b = __lowerInternref(b) || __notnull();
+      try {
+        return exports.complex_distance(a, b);
+      } finally {
+        __release(a);
+      }
+    },
+    complex_array_zeros(n) {
+      // src/ops/complex-array/complex_array_zeros(i32) => ~lib/typedarray/Float64Array
+      return __liftTypedArray(Float64Array, exports.complex_array_zeros(n) >>> 0);
+    },
+    complex_array_ones(n) {
+      // src/ops/complex-array/complex_array_ones(i32) => ~lib/typedarray/Float64Array
+      return __liftTypedArray(Float64Array, exports.complex_array_ones(n) >>> 0);
+    },
+    complex_array_fill(n, re, im) {
+      // src/ops/complex-array/complex_array_fill(i32, f64, f64) => ~lib/typedarray/Float64Array
+      return __liftTypedArray(Float64Array, exports.complex_array_fill(n, re, im) >>> 0);
+    },
+    complex_array_get(data, index) {
+      // src/ops/complex-array/complex_array_get(~lib/typedarray/Float64Array, i32) => src/types/complex/Complex
+      data = __lowerTypedArray(Float64Array, 5, 3, data) || __notnull();
+      return __liftInternref(exports.complex_array_get(data, index) >>> 0);
+    },
+    complex_array_set(data, index, value) {
+      // src/ops/complex-array/complex_array_set(~lib/typedarray/Float64Array, i32, src/types/complex/Complex) => void
+      data = __retain(__lowerTypedArray(Float64Array, 5, 3, data) || __notnull());
+      value = __lowerInternref(value) || __notnull();
+      try {
+        exports.complex_array_set(data, index, value);
+      } finally {
+        __release(data);
+      }
+    },
+    complex_array_set_parts(data, index, re, im) {
+      // src/ops/complex-array/complex_array_set_parts(~lib/typedarray/Float64Array, i32, f64, f64) => void
+      data = __lowerTypedArray(Float64Array, 5, 3, data) || __notnull();
+      exports.complex_array_set_parts(data, index, re, im);
+    },
+    complex_array_get_re(data, index) {
+      // src/ops/complex-array/complex_array_get_re(~lib/typedarray/Float64Array, i32) => f64
+      data = __lowerTypedArray(Float64Array, 5, 3, data) || __notnull();
+      return exports.complex_array_get_re(data, index);
+    },
+    complex_array_get_im(data, index) {
+      // src/ops/complex-array/complex_array_get_im(~lib/typedarray/Float64Array, i32) => f64
+      data = __lowerTypedArray(Float64Array, 5, 3, data) || __notnull();
+      return exports.complex_array_get_im(data, index);
+    },
+    complex_array_length(data) {
+      // src/ops/complex-array/complex_array_length(~lib/typedarray/Float64Array) => i32
+      data = __lowerTypedArray(Float64Array, 5, 3, data) || __notnull();
+      return exports.complex_array_length(data);
+    },
+    complex_array_add(a, b, result) {
+      // src/ops/complex-array/complex_array_add(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      b = __retain(__lowerTypedArray(Float64Array, 5, 3, b) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.complex_array_add(a, b, result);
+      } finally {
+        __release(a);
+        __release(b);
+      }
+    },
+    complex_array_sub(a, b, result) {
+      // src/ops/complex-array/complex_array_sub(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      b = __retain(__lowerTypedArray(Float64Array, 5, 3, b) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.complex_array_sub(a, b, result);
+      } finally {
+        __release(a);
+        __release(b);
+      }
+    },
+    complex_array_mul(a, b, result) {
+      // src/ops/complex-array/complex_array_mul(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      b = __retain(__lowerTypedArray(Float64Array, 5, 3, b) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.complex_array_mul(a, b, result);
+      } finally {
+        __release(a);
+        __release(b);
+      }
+    },
+    complex_array_div(a, b, result) {
+      // src/ops/complex-array/complex_array_div(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      b = __retain(__lowerTypedArray(Float64Array, 5, 3, b) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.complex_array_div(a, b, result);
+      } finally {
+        __release(a);
+        __release(b);
+      }
+    },
+    complex_array_scale_real(a, scalar, result) {
+      // src/ops/complex-array/complex_array_scale_real(~lib/typedarray/Float64Array, f64, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.complex_array_scale_real(a, scalar, result);
+      } finally {
+        __release(a);
+      }
+    },
+    complex_array_scale_complex(a, re, im, result) {
+      // src/ops/complex-array/complex_array_scale_complex(~lib/typedarray/Float64Array, f64, f64, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.complex_array_scale_complex(a, re, im, result);
+      } finally {
+        __release(a);
+      }
+    },
+    complex_array_neg(a, result) {
+      // src/ops/complex-array/complex_array_neg(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.complex_array_neg(a, result);
+      } finally {
+        __release(a);
+      }
+    },
+    complex_array_conj(a, result) {
+      // src/ops/complex-array/complex_array_conj(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.complex_array_conj(a, result);
+      } finally {
+        __release(a);
+      }
+    },
+    complex_array_abs(a, result) {
+      // src/ops/complex-array/complex_array_abs(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.complex_array_abs(a, result);
+      } finally {
+        __release(a);
+      }
+    },
+    complex_array_arg(a, result) {
+      // src/ops/complex-array/complex_array_arg(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.complex_array_arg(a, result);
+      } finally {
+        __release(a);
+      }
+    },
+    complex_array_abs_squared(a, result) {
+      // src/ops/complex-array/complex_array_abs_squared(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.complex_array_abs_squared(a, result);
+      } finally {
+        __release(a);
+      }
+    },
+    complex_array_real(a, result) {
+      // src/ops/complex-array/complex_array_real(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.complex_array_real(a, result);
+      } finally {
+        __release(a);
+      }
+    },
+    complex_array_imag(a, result) {
+      // src/ops/complex-array/complex_array_imag(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.complex_array_imag(a, result);
+      } finally {
+        __release(a);
+      }
+    },
+    complex_array_exp(a, result) {
+      // src/ops/complex-array/complex_array_exp(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.complex_array_exp(a, result);
+      } finally {
+        __release(a);
+      }
+    },
+    complex_array_log(a, result) {
+      // src/ops/complex-array/complex_array_log(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.complex_array_log(a, result);
+      } finally {
+        __release(a);
+      }
+    },
+    complex_array_sqrt(a, result) {
+      // src/ops/complex-array/complex_array_sqrt(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      result = __lowerTypedArray(Float64Array, 5, 3, result) || __notnull();
+      try {
+        exports.complex_array_sqrt(a, result);
+      } finally {
+        __release(a);
+      }
+    },
+    complex_array_sum(a) {
+      // src/ops/complex-array/complex_array_sum(~lib/typedarray/Float64Array) => src/types/complex/Complex
+      a = __lowerTypedArray(Float64Array, 5, 3, a) || __notnull();
+      return __liftInternref(exports.complex_array_sum(a) >>> 0);
+    },
+    complex_array_mean(a) {
+      // src/ops/complex-array/complex_array_mean(~lib/typedarray/Float64Array) => src/types/complex/Complex
+      a = __lowerTypedArray(Float64Array, 5, 3, a) || __notnull();
+      return __liftInternref(exports.complex_array_mean(a) >>> 0);
+    },
+    complex_array_dot(a, b) {
+      // src/ops/complex-array/complex_array_dot(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => src/types/complex/Complex
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      b = __lowerTypedArray(Float64Array, 5, 3, b) || __notnull();
+      try {
+        return __liftInternref(exports.complex_array_dot(a, b) >>> 0);
+      } finally {
+        __release(a);
+      }
+    },
+    complex_array_norm(a) {
+      // src/ops/complex-array/complex_array_norm(~lib/typedarray/Float64Array) => f64
+      a = __lowerTypedArray(Float64Array, 5, 3, a) || __notnull();
+      return exports.complex_array_norm(a);
+    },
+    complex_array_scale_inplace(a, scalar) {
+      // src/ops/complex-array/complex_array_scale_inplace(~lib/typedarray/Float64Array, f64) => void
+      a = __lowerTypedArray(Float64Array, 5, 3, a) || __notnull();
+      exports.complex_array_scale_inplace(a, scalar);
+    },
+    complex_array_conj_inplace(a) {
+      // src/ops/complex-array/complex_array_conj_inplace(~lib/typedarray/Float64Array) => void
+      a = __lowerTypedArray(Float64Array, 5, 3, a) || __notnull();
+      exports.complex_array_conj_inplace(a);
+    },
+    complex_array_add_inplace(a, b) {
+      // src/ops/complex-array/complex_array_add_inplace(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      b = __lowerTypedArray(Float64Array, 5, 3, b) || __notnull();
+      try {
+        exports.complex_array_add_inplace(a, b);
+      } finally {
+        __release(a);
+      }
+    },
+    complex_array_copy(src, dst) {
+      // src/ops/complex-array/complex_array_copy(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => void
+      src = __retain(__lowerTypedArray(Float64Array, 5, 3, src) || __notnull());
+      dst = __lowerTypedArray(Float64Array, 5, 3, dst) || __notnull();
+      try {
+        exports.complex_array_copy(src, dst);
+      } finally {
+        __release(src);
+      }
+    },
+  }, exports);
+  function __liftString(pointer) {
+    if (!pointer) return null;
+    const
+      end = pointer + new Uint32Array(memory.buffer)[pointer - 4 >>> 2] >>> 1,
+      memoryU16 = new Uint16Array(memory.buffer);
+    let
+      start = pointer >>> 1,
+      string = "";
+    while (end - start > 1024) string += String.fromCharCode(...memoryU16.subarray(start, start += 1024));
+    return string + String.fromCharCode(...memoryU16.subarray(start, end));
+  }
+  function __liftTypedArray(constructor, pointer) {
+    if (!pointer) return null;
+    return new constructor(
+      memory.buffer,
+      __getU32(pointer + 4),
+      __dataview.getUint32(pointer + 8, true) / constructor.BYTES_PER_ELEMENT
+    ).slice();
+  }
+  function __lowerTypedArray(constructor, id, align, values) {
+    if (values == null) return 0;
+    const
+      length = values.length,
+      buffer = exports.__pin(exports.__new(length << align, 1)) >>> 0,
+      header = exports.__new(12, id) >>> 0;
+    __setU32(header + 0, buffer);
+    __dataview.setUint32(header + 4, buffer, true);
+    __dataview.setUint32(header + 8, length << align, true);
+    new constructor(memory.buffer, buffer, length).set(values);
+    exports.__unpin(buffer);
+    return header;
+  }
+  class Internref extends Number {}
+  const registry = new FinalizationRegistry(__release);
+  function __liftInternref(pointer) {
+    if (!pointer) return null;
+    const sentinel = new Internref(__retain(pointer));
+    registry.register(sentinel, pointer);
+    return sentinel;
+  }
+  function __lowerInternref(value) {
+    if (value == null) return 0;
+    if (value instanceof Internref) return value.valueOf();
+    throw TypeError("internref expected");
+  }
+  const refcounts = new Map();
+  function __retain(pointer) {
+    if (pointer) {
+      const refcount = refcounts.get(pointer);
+      if (refcount) refcounts.set(pointer, refcount + 1);
+      else refcounts.set(exports.__pin(pointer), 1);
+    }
+    return pointer;
+  }
+  function __release(pointer) {
+    if (pointer) {
+      const refcount = refcounts.get(pointer);
+      if (refcount === 1) exports.__unpin(pointer), refcounts.delete(pointer);
+      else if (refcount) refcounts.set(pointer, refcount - 1);
+      else throw Error(`invalid refcount '${refcount}' for reference '${pointer}'`);
+    }
+  }
+  function __notnull() {
+    throw TypeError("value must not be null");
+  }
+  let __dataview = new DataView(memory.buffer);
+  function __setU32(pointer, value) {
+    try {
+      __dataview.setUint32(pointer, value, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      __dataview.setUint32(pointer, value, true);
+    }
+  }
+  function __getU32(pointer) {
+    try {
+      return __dataview.getUint32(pointer, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      return __dataview.getUint32(pointer, true);
+    }
+  }
+  return adaptedExports;
+}
+export const {
+  memory,
+  __new,
+  __pin,
+  __unpin,
+  __collect,
+  __rtti_base,
+  complex,
+  complexFromPolar,
+  add_f64,
+  sub_f64,
+  mul_f64,
+  div_f64,
+  mod_f64,
+  neg_f64,
+  sqrt_f64,
+  pow_f64,
+  square_f64,
+  cube_f64,
+  cbrt_f64,
+  nthRoot_f64,
+  exp_f64,
+  expm1_f64,
+  log_f64,
+  log1p_f64,
+  log10_f64,
+  log2_f64,
+  sin_f64,
+  cos_f64,
+  tan_f64,
+  asin_f64,
+  acos_f64,
+  atan_f64,
+  atan2_f64,
+  sinh_f64,
+  cosh_f64,
+  tanh_f64,
+  asinh_f64,
+  acosh_f64,
+  atanh_f64,
+  abs_f64,
+  floor_f64,
+  ceil_f64,
+  round_f64,
+  trunc_f64,
+  sign_f64,
+  min_f64,
+  max_f64,
+  clamp_f64,
+  isNaN_f64,
+  isFinite_f64,
+  PI,
+  E,
+  PHI,
+  SQRT2,
+  SQRT1_2,
+  LN2,
+  LN10,
+  LOG2E,
+  LOG10E,
+  EPSILON,
+  array_sum,
+  array_product,
+  array_mean,
+  array_variance,
+  array_stddev,
+  array_min,
+  array_max,
+  array_argmin,
+  array_argmax,
+  array_norm,
+  array_norm_l1,
+  array_norm_linf,
+  array_dot,
+  array_add,
+  array_sub,
+  array_mul,
+  array_div,
+  array_scale,
+  array_add_scalar,
+  array_neg,
+  array_abs,
+  array_sqrt,
+  array_square,
+  array_exp,
+  array_log,
+  array_sin,
+  array_cos,
+  array_axpby,
+  array_distance,
+  array_cosine_similarity,
+  array_scale_inplace,
+  array_add_scalar_inplace,
+  array_add_inplace,
+  array_clamp_inplace,
+  array_fill,
+  array_copy,
+  matrix_zeros,
+  matrix_ones,
+  matrix_fill,
+  matrix_identity,
+  matrix_diag,
+  matrix_get,
+  matrix_set,
+  matrix_get_row,
+  matrix_get_col,
+  matrix_get_diag,
+  matrix_add,
+  matrix_sub,
+  matrix_mul_elementwise,
+  matrix_div_elementwise,
+  matrix_scale,
+  matrix_add_scalar,
+  matrix_neg,
+  matrix_multiply,
+  matrix_vector_multiply,
+  vector_matrix_multiply,
+  matrix_outer,
+  matrix_transpose,
+  matrix_sum,
+  matrix_mean,
+  matrix_min,
+  matrix_max,
+  matrix_norm_frobenius,
+  matrix_trace,
+  matrix_sum_rows,
+  matrix_sum_cols,
+  matrix_is_square,
+  matrix_is_symmetric,
+  matrix_is_diagonal,
+  matrix_is_identity,
+  matrix_scale_inplace,
+  matrix_add_scalar_inplace,
+  matrix_add_inplace,
+  matrix_copy,
+  matrix_axpy,
+  matrix_gemm,
+  matrix_gemv,
+  complex_add,
+  complex_sub,
+  complex_mul,
+  complex_div,
+  complex_neg,
+  complex_conj,
+  complex_reciprocal,
+  complex_abs,
+  complex_arg,
+  complex_abs_squared,
+  complex_sqrt,
+  complex_pow,
+  complex_cpow,
+  complex_square,
+  complex_cube,
+  complex_exp,
+  complex_log,
+  complex_log10,
+  complex_log2,
+  complex_sin,
+  complex_cos,
+  complex_tan,
+  complex_asin,
+  complex_acos,
+  complex_atan,
+  complex_sinh,
+  complex_cosh,
+  complex_tanh,
+  complex_asinh,
+  complex_acosh,
+  complex_atanh,
+  complex_equals,
+  complex_approx_equals,
+  complex_is_zero,
+  complex_is_real,
+  complex_is_imaginary,
+  complex_is_nan,
+  complex_is_finite,
+  complex_from_real,
+  complex_from_imag,
+  complex_from_polar,
+  complex_to_polar,
+  complex_axpby,
+  complex_distance,
+  complex_array_zeros,
+  complex_array_ones,
+  complex_array_fill,
+  complex_array_get,
+  complex_array_set,
+  complex_array_set_parts,
+  complex_array_get_re,
+  complex_array_get_im,
+  complex_array_length,
+  complex_array_add,
+  complex_array_sub,
+  complex_array_mul,
+  complex_array_div,
+  complex_array_scale_real,
+  complex_array_scale_complex,
+  complex_array_neg,
+  complex_array_conj,
+  complex_array_abs,
+  complex_array_arg,
+  complex_array_abs_squared,
+  complex_array_real,
+  complex_array_imag,
+  complex_array_exp,
+  complex_array_log,
+  complex_array_sqrt,
+  complex_array_sum,
+  complex_array_mean,
+  complex_array_dot,
+  complex_array_norm,
+  complex_array_scale_inplace,
+  complex_array_conj_inplace,
+  complex_array_add_inplace,
+  complex_array_copy,
+} = await (async url => instantiate(
+  await (async () => {
+    const isNodeOrBun = typeof process != "undefined" && process.versions != null && (process.versions.node != null || process.versions.bun != null);
+    if (isNodeOrBun) { return globalThis.WebAssembly.compile(await (await import("node:fs/promises")).readFile(url)); }
+    else { return await globalThis.WebAssembly.compileStreaming(globalThis.fetch(url)); }
+  })(), {
+  }
+))(new URL("mathts.wasm", import.meta.url));