@danielsimonjr/mathts-wasm 0.1.2 → 0.1.3

package/build/mathts.js

@@ -638,6 +638,298 @@ async function instantiate(module, imports = {}) {
         __release(x);
       }
     },
+    matrix_svd(a, m, n) {
+      // src/ops/svd/matrix_svd(~lib/typedarray/Float64Array, i32, i32) => ~lib/typedarray/Float64Array
+      a = __lowerTypedArray(Float64Array, 5, 3, a) || __notnull();
+      return __liftTypedArray(Float64Array, exports.matrix_svd(a, m, n) >>> 0);
+    },
+    matrix_singular_values(a, m, n) {
+      // src/ops/svd/matrix_singular_values(~lib/typedarray/Float64Array, i32, i32) => ~lib/typedarray/Float64Array
+      a = __lowerTypedArray(Float64Array, 5, 3, a) || __notnull();
+      return __liftTypedArray(Float64Array, exports.matrix_singular_values(a, m, n) >>> 0);
+    },
+    matrix_lu_decompose(a, n, l_out, u_out, perm_out) {
+      // src/algebra/decomposition/matrix_lu_decompose(~lib/typedarray/Float64Array, i32, ~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array, ~lib/typedarray/Int32Array) => i32
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      l_out = __retain(__lowerTypedArray(Float64Array, 5, 3, l_out) || __notnull());
+      u_out = __retain(__lowerTypedArray(Float64Array, 5, 3, u_out) || __notnull());
+      perm_out = __lowerTypedArray(Int32Array, 6, 2, perm_out) || __notnull();
+      try {
+        return exports.matrix_lu_decompose(a, n, l_out, u_out, perm_out);
+      } finally {
+        __release(a);
+        __release(l_out);
+        __release(u_out);
+      }
+    },
+    matrix_qr_decompose(a, m, n, q_out, r_out) {
+      // src/algebra/decomposition/matrix_qr_decompose(~lib/typedarray/Float64Array, i32, i32, ~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => i32
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      q_out = __retain(__lowerTypedArray(Float64Array, 5, 3, q_out) || __notnull());
+      r_out = __lowerTypedArray(Float64Array, 5, 3, r_out) || __notnull();
+      try {
+        return exports.matrix_qr_decompose(a, m, n, q_out, r_out);
+      } finally {
+        __release(a);
+        __release(q_out);
+      }
+    },
+    matrix_cholesky(a, n, l_out) {
+      // src/algebra/decomposition/matrix_cholesky(~lib/typedarray/Float64Array, i32, ~lib/typedarray/Float64Array) => i32
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      l_out = __lowerTypedArray(Float64Array, 5, 3, l_out) || __notnull();
+      try {
+        return exports.matrix_cholesky(a, n, l_out);
+      } finally {
+        __release(a);
+      }
+    },
+    matrix_inverse(a, n, result, work) {
+      // src/algebra/decomposition/matrix_inverse(~lib/typedarray/Float64Array, i32, ~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => i32
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      result = __retain(__lowerTypedArray(Float64Array, 5, 3, result) || __notnull());
+      work = __lowerTypedArray(Float64Array, 5, 3, work) || __notnull();
+      try {
+        return exports.matrix_inverse(a, n, result, work);
+      } finally {
+        __release(a);
+        __release(result);
+      }
+    },
+    matrix_determinant(a, n, work) {
+      // src/algebra/decomposition/matrix_determinant(~lib/typedarray/Float64Array, i32, ~lib/typedarray/Float64Array) => f64
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      work = __lowerTypedArray(Float64Array, 5, 3, work) || __notnull();
+      try {
+        return exports.matrix_determinant(a, n, work);
+      } finally {
+        __release(a);
+      }
+    },
+    primeFactors(n) {
+      // src/ops/number-theory/primeFactors(f64) => ~lib/typedarray/Float64Array
+      return __liftTypedArray(Float64Array, exports.primeFactors(n) >>> 0);
+    },
+    divisors(n) {
+      // src/ops/number-theory/divisors(f64) => ~lib/typedarray/Float64Array
+      return __liftTypedArray(Float64Array, exports.divisors(n) >>> 0);
+    },
+    integerDigits(n, base) {
+      // src/ops/number-theory/integerDigits(f64, f64) => ~lib/typedarray/Float64Array
+      return __liftTypedArray(Float64Array, exports.integerDigits(n, base) >>> 0);
+    },
+    chineseRemainder(rem, mods) {
+      // src/ops/number-theory/chineseRemainder(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => f64
+      rem = __retain(__lowerTypedArray(Float64Array, 5, 3, rem) || __notnull());
+      mods = __lowerTypedArray(Float64Array, 5, 3, mods) || __notnull();
+      try {
+        return exports.chineseRemainder(rem, mods);
+      } finally {
+        __release(rem);
+      }
+    },
+    polyadd(a, b) {
+      // src/ops/polynomial/polyadd(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => ~lib/typedarray/Float64Array
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      b = __lowerTypedArray(Float64Array, 5, 3, b) || __notnull();
+      try {
+        return __liftTypedArray(Float64Array, exports.polyadd(a, b) >>> 0);
+      } finally {
+        __release(a);
+      }
+    },
+    polynomialQuotient(a, b) {
+      // src/ops/polynomial/polynomialQuotient(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => ~lib/typedarray/Float64Array
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      b = __lowerTypedArray(Float64Array, 5, 3, b) || __notnull();
+      try {
+        return __liftTypedArray(Float64Array, exports.polynomialQuotient(a, b) >>> 0);
+      } finally {
+        __release(a);
+      }
+    },
+    polynomialRemainder(a, b) {
+      // src/ops/polynomial/polynomialRemainder(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => ~lib/typedarray/Float64Array
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      b = __lowerTypedArray(Float64Array, 5, 3, b) || __notnull();
+      try {
+        return __liftTypedArray(Float64Array, exports.polynomialRemainder(a, b) >>> 0);
+      } finally {
+        __release(a);
+      }
+    },
+    polynomialGCD(a, b) {
+      // src/ops/polynomial/polynomialGCD(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => ~lib/typedarray/Float64Array
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      b = __lowerTypedArray(Float64Array, 5, 3, b) || __notnull();
+      try {
+        return __liftTypedArray(Float64Array, exports.polynomialGCD(a, b) >>> 0);
+      } finally {
+        __release(a);
+      }
+    },
+    polynomialLCM(a, b) {
+      // src/ops/polynomial/polynomialLCM(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => ~lib/typedarray/Float64Array
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      b = __lowerTypedArray(Float64Array, 5, 3, b) || __notnull();
+      try {
+        return __liftTypedArray(Float64Array, exports.polynomialLCM(a, b) >>> 0);
+      } finally {
+        __release(a);
+      }
+    },
+    discriminant(coeffs) {
+      // src/ops/polynomial/discriminant(~lib/typedarray/Float64Array) => f64
+      coeffs = __lowerTypedArray(Float64Array, 5, 3, coeffs) || __notnull();
+      return exports.discriminant(coeffs);
+    },
+    resultant(p, q) {
+      // src/ops/polynomial/resultant(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => f64
+      p = __retain(__lowerTypedArray(Float64Array, 5, 3, p) || __notnull());
+      q = __lowerTypedArray(Float64Array, 5, 3, q) || __notnull();
+      try {
+        return exports.resultant(p, q);
+      } finally {
+        __release(p);
+      }
+    },
+    resample(x, newRate, oldRate) {
+      // src/ops/signal/resample(~lib/typedarray/Float64Array, f64, f64) => ~lib/typedarray/Float64Array
+      x = __lowerTypedArray(Float64Array, 5, 3, x) || __notnull();
+      return __liftTypedArray(Float64Array, exports.resample(x, newRate, oldRate) >>> 0);
+    },
+    medfilt(x, n) {
+      // src/ops/signal/medfilt(~lib/typedarray/Float64Array, i32) => ~lib/typedarray/Float64Array
+      x = __lowerTypedArray(Float64Array, 5, 3, x) || __notnull();
+      return __liftTypedArray(Float64Array, exports.medfilt(x, n) >>> 0);
+    },
+    windowFunction(n, windowType) {
+      // src/ops/signal/windowFunction(i32, i32) => ~lib/typedarray/Float64Array
+      return __liftTypedArray(Float64Array, exports.windowFunction(n, windowType) >>> 0);
+    },
+    apply_window_f64(samples, windowType) {
+      // src/signal/apply_window_f64(~lib/typedarray/Float64Array, i32) => i32
+      samples = __lowerTypedArray(Float64Array, 5, 3, samples) || __notnull();
+      return exports.apply_window_f64(samples, windowType);
+    },
+    welch_psd_f64(samples, frameLength, overlap, windowType) {
+      // src/signal/welch_psd_f64(~lib/typedarray/Float64Array, i32, i32, i32) => ~lib/typedarray/Float64Array
+      samples = __lowerTypedArray(Float64Array, 5, 3, samples) || __notnull();
+      return __liftTypedArray(Float64Array, exports.welch_psd_f64(samples, frameLength, overlap, windowType) >>> 0);
+    },
+    bartlett_psd_f64(samples, frameLength) {
+      // src/signal/bartlett_psd_f64(~lib/typedarray/Float64Array, i32) => ~lib/typedarray/Float64Array
+      samples = __lowerTypedArray(Float64Array, 5, 3, samples) || __notnull();
+      return __liftTypedArray(Float64Array, exports.bartlett_psd_f64(samples, frameLength) >>> 0);
+    },
+    goertzel_f64(samples, targetFreq, sampleRate) {
+      // src/signal/goertzel_f64(~lib/typedarray/Float64Array, f64, f64) => f64
+      samples = __lowerTypedArray(Float64Array, 5, 3, samples) || __notnull();
+      return exports.goertzel_f64(samples, targetFreq, sampleRate);
+    },
+    chirp_z_transform_f64(samples, m, phiStartRe, phiStartIm, phiStepRe, phiStepIm) {
+      // src/signal/chirp_z_transform_f64(~lib/typedarray/Float64Array, i32, f64, f64, f64, f64) => ~lib/typedarray/Float64Array
+      samples = __lowerTypedArray(Float64Array, 5, 3, samples) || __notnull();
+      return __liftTypedArray(Float64Array, exports.chirp_z_transform_f64(samples, m, phiStartRe, phiStartIm, phiStepRe, phiStepIm) >>> 0);
+    },
+    rowReduce(a, m, n, tol) {
+      // src/ops/linalg/rowReduce(~lib/typedarray/Float64Array, i32, i32, f64) => ~lib/typedarray/Float64Array
+      a = __lowerTypedArray(Float64Array, 5, 3, a) || __notnull();
+      return __liftTypedArray(Float64Array, exports.rowReduce(a, m, n, tol) >>> 0);
+    },
+    characteristicPolynomial(a, n) {
+      // src/ops/linalg/characteristicPolynomial(~lib/typedarray/Float64Array, i32) => ~lib/typedarray/Float64Array
+      a = __lowerTypedArray(Float64Array, 5, 3, a) || __notnull();
+      return __liftTypedArray(Float64Array, exports.characteristicPolynomial(a, n) >>> 0);
+    },
+    expfit(xs, ys) {
+      // src/ops/curvefit/expfit(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => ~lib/typedarray/Float64Array
+      xs = __retain(__lowerTypedArray(Float64Array, 5, 3, xs) || __notnull());
+      ys = __lowerTypedArray(Float64Array, 5, 3, ys) || __notnull();
+      try {
+        return __liftTypedArray(Float64Array, exports.expfit(xs, ys) >>> 0);
+      } finally {
+        __release(xs);
+      }
+    },
+    logfit(xs, ys) {
+      // src/ops/curvefit/logfit(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => ~lib/typedarray/Float64Array
+      xs = __retain(__lowerTypedArray(Float64Array, 5, 3, xs) || __notnull());
+      ys = __lowerTypedArray(Float64Array, 5, 3, ys) || __notnull();
+      try {
+        return __liftTypedArray(Float64Array, exports.logfit(xs, ys) >>> 0);
+      } finally {
+        __release(xs);
+      }
+    },
+    powerfit(xs, ys) {
+      // src/ops/curvefit/powerfit(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => ~lib/typedarray/Float64Array
+      xs = __retain(__lowerTypedArray(Float64Array, 5, 3, xs) || __notnull());
+      ys = __lowerTypedArray(Float64Array, 5, 3, ys) || __notnull();
+      try {
+        return __liftTypedArray(Float64Array, exports.powerfit(xs, ys) >>> 0);
+      } finally {
+        __release(xs);
+      }
+    },
+    quadprog(h, n, f, a, m, b) {
+      // src/ops/optimization/quadprog(~lib/typedarray/Float64Array, i32, ~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array, i32, ~lib/typedarray/Float64Array) => ~lib/typedarray/Float64Array
+      h = __retain(__lowerTypedArray(Float64Array, 5, 3, h) || __notnull());
+      f = __retain(__lowerTypedArray(Float64Array, 5, 3, f) || __notnull());
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      b = __lowerTypedArray(Float64Array, 5, 3, b) || __notnull();
+      try {
+        return __liftTypedArray(Float64Array, exports.quadprog(h, n, f, a, m, b) >>> 0);
+      } finally {
+        __release(h);
+        __release(f);
+        __release(a);
+      }
+    },
+    linprog(c, n, a, b, m) {
+      // src/ops/optimization/linprog(~lib/typedarray/Float64Array, i32, ~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array, i32) => ~lib/typedarray/Float64Array
+      c = __retain(__lowerTypedArray(Float64Array, 5, 3, c) || __notnull());
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      b = __lowerTypedArray(Float64Array, 5, 3, b) || __notnull();
+      try {
+        return __liftTypedArray(Float64Array, exports.linprog(c, n, a, b, m) >>> 0);
+      } finally {
+        __release(c);
+        __release(a);
+      }
+    },
+    nullspace(a, m, n) {
+      // src/ops/optimization/nullspace(~lib/typedarray/Float64Array, i32, i32) => ~lib/typedarray/Float64Array
+      a = __lowerTypedArray(Float64Array, 5, 3, a) || __notnull();
+      return __liftTypedArray(Float64Array, exports.nullspace(a, m, n) >>> 0);
+    },
+    residue(p, q) {
+      // src/ops/approx/residue(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => ~lib/typedarray/Float64Array
+      p = __retain(__lowerTypedArray(Float64Array, 5, 3, p) || __notnull());
+      q = __lowerTypedArray(Float64Array, 5, 3, q) || __notnull();
+      try {
+        return __liftTypedArray(Float64Array, exports.residue(p, q) >>> 0);
+      } finally {
+        __release(p);
+      }
+    },
+    padeApproximant(coeffs, m, n) {
+      // src/ops/approx/padeApproximant(~lib/typedarray/Float64Array, i32, i32) => ~lib/typedarray/Float64Array
+      coeffs = __lowerTypedArray(Float64Array, 5, 3, coeffs) || __notnull();
+      return __liftTypedArray(Float64Array, exports.padeApproximant(coeffs, m, n) >>> 0);
+    },
+    tensorTranspose(data, shape, perm) {
+      // src/ops/tensor/tensorTranspose(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => ~lib/typedarray/Float64Array
+      data = __retain(__lowerTypedArray(Float64Array, 5, 3, data) || __notnull());
+      shape = __retain(__lowerTypedArray(Float64Array, 5, 3, shape) || __notnull());
+      perm = __lowerTypedArray(Float64Array, 5, 3, perm) || __notnull();
+      try {
+        return __liftTypedArray(Float64Array, exports.tensorTranspose(data, shape, perm) >>> 0);
+      } finally {
+        __release(data);
+        __release(shape);
+      }
+    },
     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());
@@ -904,6 +1196,312 @@ async function instantiate(module, imports = {}) {
         __release(a);
       }
     },
+    bitAnd_i32_array(a, b, result) {
+      // src/ops/bitwise/bitAnd_i32_array(~lib/typedarray/Int32Array, ~lib/typedarray/Int32Array, ~lib/typedarray/Int32Array) => void
+      a = __retain(__lowerTypedArray(Int32Array, 6, 2, a) || __notnull());
+      b = __retain(__lowerTypedArray(Int32Array, 6, 2, b) || __notnull());
+      result = __lowerTypedArray(Int32Array, 6, 2, result) || __notnull();
+      try {
+        exports.bitAnd_i32_array(a, b, result);
+      } finally {
+        __release(a);
+        __release(b);
+      }
+    },
+    bitOr_i32_array(a, b, result) {
+      // src/ops/bitwise/bitOr_i32_array(~lib/typedarray/Int32Array, ~lib/typedarray/Int32Array, ~lib/typedarray/Int32Array) => void
+      a = __retain(__lowerTypedArray(Int32Array, 6, 2, a) || __notnull());
+      b = __retain(__lowerTypedArray(Int32Array, 6, 2, b) || __notnull());
+      result = __lowerTypedArray(Int32Array, 6, 2, result) || __notnull();
+      try {
+        exports.bitOr_i32_array(a, b, result);
+      } finally {
+        __release(a);
+        __release(b);
+      }
+    },
+    bitXor_i32_array(a, b, result) {
+      // src/ops/bitwise/bitXor_i32_array(~lib/typedarray/Int32Array, ~lib/typedarray/Int32Array, ~lib/typedarray/Int32Array) => void
+      a = __retain(__lowerTypedArray(Int32Array, 6, 2, a) || __notnull());
+      b = __retain(__lowerTypedArray(Int32Array, 6, 2, b) || __notnull());
+      result = __lowerTypedArray(Int32Array, 6, 2, result) || __notnull();
+      try {
+        exports.bitXor_i32_array(a, b, result);
+      } finally {
+        __release(a);
+        __release(b);
+      }
+    },
+    bitNot_i32_array(a, result) {
+      // src/ops/bitwise/bitNot_i32_array(~lib/typedarray/Int32Array, ~lib/typedarray/Int32Array) => void
+      a = __retain(__lowerTypedArray(Int32Array, 6, 2, a) || __notnull());
+      result = __lowerTypedArray(Int32Array, 6, 2, result) || __notnull();
+      try {
+        exports.bitNot_i32_array(a, result);
+      } finally {
+        __release(a);
+      }
+    },
+    leftShift_i32_array(a, b, result) {
+      // src/ops/bitwise/leftShift_i32_array(~lib/typedarray/Int32Array, ~lib/typedarray/Int32Array, ~lib/typedarray/Int32Array) => void
+      a = __retain(__lowerTypedArray(Int32Array, 6, 2, a) || __notnull());
+      b = __retain(__lowerTypedArray(Int32Array, 6, 2, b) || __notnull());
+      result = __lowerTypedArray(Int32Array, 6, 2, result) || __notnull();
+      try {
+        exports.leftShift_i32_array(a, b, result);
+      } finally {
+        __release(a);
+        __release(b);
+      }
+    },
+    rightArithShift_i32_array(a, b, result) {
+      // src/ops/bitwise/rightArithShift_i32_array(~lib/typedarray/Int32Array, ~lib/typedarray/Int32Array, ~lib/typedarray/Int32Array) => void
+      a = __retain(__lowerTypedArray(Int32Array, 6, 2, a) || __notnull());
+      b = __retain(__lowerTypedArray(Int32Array, 6, 2, b) || __notnull());
+      result = __lowerTypedArray(Int32Array, 6, 2, result) || __notnull();
+      try {
+        exports.rightArithShift_i32_array(a, b, result);
+      } finally {
+        __release(a);
+        __release(b);
+      }
+    },
+    rightLogShift_i32_array(a, b, result) {
+      // src/ops/bitwise/rightLogShift_i32_array(~lib/typedarray/Int32Array, ~lib/typedarray/Int32Array, ~lib/typedarray/Int32Array) => void
+      a = __retain(__lowerTypedArray(Int32Array, 6, 2, a) || __notnull());
+      b = __retain(__lowerTypedArray(Int32Array, 6, 2, b) || __notnull());
+      result = __lowerTypedArray(Int32Array, 6, 2, result) || __notnull();
+      try {
+        exports.rightLogShift_i32_array(a, b, result);
+      } finally {
+        __release(a);
+        __release(b);
+      }
+    },
+    poly_mul_f64(a, b) {
+      // src/poly/poly_mul_f64(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => ~lib/typedarray/Float64Array
+      a = __retain(__lowerTypedArray(Float64Array, 5, 3, a) || __notnull());
+      b = __lowerTypedArray(Float64Array, 5, 3, b) || __notnull();
+      try {
+        return __liftTypedArray(Float64Array, exports.poly_mul_f64(a, b) >>> 0);
+      } finally {
+        __release(a);
+      }
+    },
+    poly_div_mod_f64(num, den) {
+      // src/poly/poly_div_mod_f64(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => ~lib/typedarray/Float64Array
+      num = __retain(__lowerTypedArray(Float64Array, 5, 3, num) || __notnull());
+      den = __lowerTypedArray(Float64Array, 5, 3, den) || __notnull();
+      try {
+        return __liftTypedArray(Float64Array, exports.poly_div_mod_f64(num, den) >>> 0);
+      } finally {
+        __release(num);
+      }
+    },
+    poly_fit_f64(xs, ys, degree) {
+      // src/poly/poly_fit_f64(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array, i32) => ~lib/typedarray/Float64Array
+      xs = __retain(__lowerTypedArray(Float64Array, 5, 3, xs) || __notnull());
+      ys = __lowerTypedArray(Float64Array, 5, 3, ys) || __notnull();
+      try {
+        return __liftTypedArray(Float64Array, exports.poly_fit_f64(xs, ys, degree) >>> 0);
+      } finally {
+        __release(xs);
+      }
+    },
+    cheb_fit_f64(xs, ys, degree) {
+      // src/poly/cheb_fit_f64(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array, i32) => ~lib/typedarray/Float64Array
+      xs = __retain(__lowerTypedArray(Float64Array, 5, 3, xs) || __notnull());
+      ys = __lowerTypedArray(Float64Array, 5, 3, ys) || __notnull();
+      try {
+        return __liftTypedArray(Float64Array, exports.cheb_fit_f64(xs, ys, degree) >>> 0);
+      } finally {
+        __release(xs);
+      }
+    },
+    legendre_fit_f64(xs, ys, degree) {
+      // src/poly/legendre_fit_f64(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array, i32) => ~lib/typedarray/Float64Array
+      xs = __retain(__lowerTypedArray(Float64Array, 5, 3, xs) || __notnull());
+      ys = __lowerTypedArray(Float64Array, 5, 3, ys) || __notnull();
+      try {
+        return __liftTypedArray(Float64Array, exports.legendre_fit_f64(xs, ys, degree) >>> 0);
+      } finally {
+        __release(xs);
+      }
+    },
+    tridiag_solve_f64(diag, lower, upper, rhs) {
+      // src/tridiag/tridiag_solve_f64(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => ~lib/typedarray/Float64Array
+      diag = __retain(__lowerTypedArray(Float64Array, 5, 3, diag) || __notnull());
+      lower = __retain(__lowerTypedArray(Float64Array, 5, 3, lower) || __notnull());
+      upper = __retain(__lowerTypedArray(Float64Array, 5, 3, upper) || __notnull());
+      rhs = __lowerTypedArray(Float64Array, 5, 3, rhs) || __notnull();
+      try {
+        return __liftTypedArray(Float64Array, exports.tridiag_solve_f64(diag, lower, upper, rhs) >>> 0);
+      } finally {
+        __release(diag);
+        __release(lower);
+        __release(upper);
+      }
+    },
+    divided_difference_f64(xs, ys) {
+      // src/tridiag/divided_difference_f64(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => ~lib/typedarray/Float64Array
+      xs = __retain(__lowerTypedArray(Float64Array, 5, 3, xs) || __notnull());
+      ys = __lowerTypedArray(Float64Array, 5, 3, ys) || __notnull();
+      try {
+        return __liftTypedArray(Float64Array, exports.divided_difference_f64(xs, ys) >>> 0);
+      } finally {
+        __release(xs);
+      }
+    },
+    bessel_j0_f64(xs) {
+      // src/special/bessel_j0_f64(~lib/typedarray/Float64Array) => ~lib/typedarray/Float64Array
+      xs = __lowerTypedArray(Float64Array, 5, 3, xs) || __notnull();
+      return __liftTypedArray(Float64Array, exports.bessel_j0_f64(xs) >>> 0);
+    },
+    bessel_j1_f64(xs) {
+      // src/special/bessel_j1_f64(~lib/typedarray/Float64Array) => ~lib/typedarray/Float64Array
+      xs = __lowerTypedArray(Float64Array, 5, 3, xs) || __notnull();
+      return __liftTypedArray(Float64Array, exports.bessel_j1_f64(xs) >>> 0);
+    },
+    bessel_jn_f64(n, xs) {
+      // src/special/bessel_jn_f64(i32, ~lib/typedarray/Float64Array) => ~lib/typedarray/Float64Array
+      xs = __lowerTypedArray(Float64Array, 5, 3, xs) || __notnull();
+      return __liftTypedArray(Float64Array, exports.bessel_jn_f64(n, xs) >>> 0);
+    },
+    bessel_y0_f64(xs) {
+      // src/special/bessel_y0_f64(~lib/typedarray/Float64Array) => ~lib/typedarray/Float64Array
+      xs = __lowerTypedArray(Float64Array, 5, 3, xs) || __notnull();
+      return __liftTypedArray(Float64Array, exports.bessel_y0_f64(xs) >>> 0);
+    },
+    bessel_y1_f64(xs) {
+      // src/special/bessel_y1_f64(~lib/typedarray/Float64Array) => ~lib/typedarray/Float64Array
+      xs = __lowerTypedArray(Float64Array, 5, 3, xs) || __notnull();
+      return __liftTypedArray(Float64Array, exports.bessel_y1_f64(xs) >>> 0);
+    },
+    bessel_yn_f64(n, xs) {
+      // src/special/bessel_yn_f64(i32, ~lib/typedarray/Float64Array) => ~lib/typedarray/Float64Array
+      xs = __lowerTypedArray(Float64Array, 5, 3, xs) || __notnull();
+      return __liftTypedArray(Float64Array, exports.bessel_yn_f64(n, xs) >>> 0);
+    },
+    airy_ai_f64(xs) {
+      // src/special/airy_ai_f64(~lib/typedarray/Float64Array) => ~lib/typedarray/Float64Array
+      xs = __lowerTypedArray(Float64Array, 5, 3, xs) || __notnull();
+      return __liftTypedArray(Float64Array, exports.airy_ai_f64(xs) >>> 0);
+    },
+    airy_bi_f64(xs) {
+      // src/special/airy_bi_f64(~lib/typedarray/Float64Array) => ~lib/typedarray/Float64Array
+      xs = __lowerTypedArray(Float64Array, 5, 3, xs) || __notnull();
+      return __liftTypedArray(Float64Array, exports.airy_bi_f64(xs) >>> 0);
+    },
+    elliptic_k_f64(ms) {
+      // src/special/elliptic_k_f64(~lib/typedarray/Float64Array) => ~lib/typedarray/Float64Array
+      ms = __lowerTypedArray(Float64Array, 5, 3, ms) || __notnull();
+      return __liftTypedArray(Float64Array, exports.elliptic_k_f64(ms) >>> 0);
+    },
+    elliptic_e_f64(ms) {
+      // src/special/elliptic_e_f64(~lib/typedarray/Float64Array) => ~lib/typedarray/Float64Array
+      ms = __lowerTypedArray(Float64Array, 5, 3, ms) || __notnull();
+      return __liftTypedArray(Float64Array, exports.elliptic_e_f64(ms) >>> 0);
+    },
+    lgamma_f64(xs) {
+      // src/special/lgamma_f64(~lib/typedarray/Float64Array) => ~lib/typedarray/Float64Array
+      xs = __lowerTypedArray(Float64Array, 5, 3, xs) || __notnull();
+      return __liftTypedArray(Float64Array, exports.lgamma_f64(xs) >>> 0);
+    },
+    carlson_rc_f64(xs, ys) {
+      // src/special/carlson_rc_f64(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => ~lib/typedarray/Float64Array
+      xs = __retain(__lowerTypedArray(Float64Array, 5, 3, xs) || __notnull());
+      ys = __lowerTypedArray(Float64Array, 5, 3, ys) || __notnull();
+      try {
+        return __liftTypedArray(Float64Array, exports.carlson_rc_f64(xs, ys) >>> 0);
+      } finally {
+        __release(xs);
+      }
+    },
+    carlson_rf_f64(xs, ys, zs) {
+      // src/special/carlson_rf_f64(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => ~lib/typedarray/Float64Array
+      xs = __retain(__lowerTypedArray(Float64Array, 5, 3, xs) || __notnull());
+      ys = __retain(__lowerTypedArray(Float64Array, 5, 3, ys) || __notnull());
+      zs = __lowerTypedArray(Float64Array, 5, 3, zs) || __notnull();
+      try {
+        return __liftTypedArray(Float64Array, exports.carlson_rf_f64(xs, ys, zs) >>> 0);
+      } finally {
+        __release(xs);
+        __release(ys);
+      }
+    },
+    carlson_rd_f64(xs, ys, zs) {
+      // src/special/carlson_rd_f64(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => ~lib/typedarray/Float64Array
+      xs = __retain(__lowerTypedArray(Float64Array, 5, 3, xs) || __notnull());
+      ys = __retain(__lowerTypedArray(Float64Array, 5, 3, ys) || __notnull());
+      zs = __lowerTypedArray(Float64Array, 5, 3, zs) || __notnull();
+      try {
+        return __liftTypedArray(Float64Array, exports.carlson_rd_f64(xs, ys, zs) >>> 0);
+      } finally {
+        __release(xs);
+        __release(ys);
+      }
+    },
+    carlson_rj_f64(xs, ys, zs, ps) {
+      // src/special/carlson_rj_f64(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => ~lib/typedarray/Float64Array
+      xs = __retain(__lowerTypedArray(Float64Array, 5, 3, xs) || __notnull());
+      ys = __retain(__lowerTypedArray(Float64Array, 5, 3, ys) || __notnull());
+      zs = __retain(__lowerTypedArray(Float64Array, 5, 3, zs) || __notnull());
+      ps = __lowerTypedArray(Float64Array, 5, 3, ps) || __notnull();
+      try {
+        return __liftTypedArray(Float64Array, exports.carlson_rj_f64(xs, ys, zs, ps) >>> 0);
+      } finally {
+        __release(xs);
+        __release(ys);
+        __release(zs);
+      }
+    },
+    elliptic_f_incomplete_f64(phis, ms) {
+      // src/special/elliptic_f_incomplete_f64(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => ~lib/typedarray/Float64Array
+      phis = __retain(__lowerTypedArray(Float64Array, 5, 3, phis) || __notnull());
+      ms = __lowerTypedArray(Float64Array, 5, 3, ms) || __notnull();
+      try {
+        return __liftTypedArray(Float64Array, exports.elliptic_f_incomplete_f64(phis, ms) >>> 0);
+      } finally {
+        __release(phis);
+      }
+    },
+    elliptic_e_incomplete_f64(phis, ms) {
+      // src/special/elliptic_e_incomplete_f64(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => ~lib/typedarray/Float64Array
+      phis = __retain(__lowerTypedArray(Float64Array, 5, 3, phis) || __notnull());
+      ms = __lowerTypedArray(Float64Array, 5, 3, ms) || __notnull();
+      try {
+        return __liftTypedArray(Float64Array, exports.elliptic_e_incomplete_f64(phis, ms) >>> 0);
+      } finally {
+        __release(phis);
+      }
+    },
+    elliptic_pi_incomplete_f64(ns, phis, ms) {
+      // src/special/elliptic_pi_incomplete_f64(~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array, ~lib/typedarray/Float64Array) => ~lib/typedarray/Float64Array
+      ns = __retain(__lowerTypedArray(Float64Array, 5, 3, ns) || __notnull());
+      phis = __retain(__lowerTypedArray(Float64Array, 5, 3, phis) || __notnull());
+      ms = __lowerTypedArray(Float64Array, 5, 3, ms) || __notnull();
+      try {
+        return __liftTypedArray(Float64Array, exports.elliptic_pi_incomplete_f64(ns, phis, ms) >>> 0);
+      } finally {
+        __release(ns);
+        __release(phis);
+      }
+    },
+    sort_f64(data) {
+      // src/sort/sort_f64(~lib/typedarray/Float64Array) => ~lib/typedarray/Float64Array
+      data = __lowerTypedArray(Float64Array, 5, 3, data) || __notnull();
+      return __liftTypedArray(Float64Array, exports.sort_f64(data) >>> 0);
+    },
+    argsort_f64(data) {
+      // src/sort/argsort_f64(~lib/typedarray/Float64Array) => ~lib/typedarray/Int32Array
+      data = __lowerTypedArray(Float64Array, 5, 3, data) || __notnull();
+      return __liftTypedArray(Int32Array, exports.argsort_f64(data) >>> 0);
+    },
+    rank_f64(data) {
+      // src/sort/rank_f64(~lib/typedarray/Float64Array) => ~lib/typedarray/Int32Array
+      data = __lowerTypedArray(Float64Array, 5, 3, data) || __notnull();
+      return __liftTypedArray(Int32Array, exports.rank_f64(data) >>> 0);
+    },
     complex_array_zeros(n) {
       // src/ops/complex-array/complex_array_zeros(i32) => ~lib/typedarray/Float64Array
       return __liftTypedArray(Float64Array, exports.complex_array_zeros(n) >>> 0);
@@ -1397,6 +1995,59 @@ export const {
   matrix_axpy,
   matrix_gemm,
   matrix_gemv,
+  matrix_svd,
+  matrix_singular_values,
+  matrix_lu_decompose,
+  matrix_qr_decompose,
+  matrix_cholesky,
+  matrix_inverse,
+  matrix_determinant,
+  chebyshevT,
+  hermiteH,
+  laguerreL,
+  legendreP,
+  erfi,
+  expIntegralEi,
+  sinIntegral,
+  cosIntegral,
+  logIntegral,
+  eulerPhi,
+  divisorSigma,
+  moebiusMu,
+  carmichaelLambda,
+  jacobiSymbol,
+  harmonicNumber,
+  partitions,
+  primeFactors,
+  divisors,
+  integerDigits,
+  chineseRemainder,
+  polyadd,
+  polynomialQuotient,
+  polynomialRemainder,
+  polynomialGCD,
+  polynomialLCM,
+  discriminant,
+  resultant,
+  resample,
+  medfilt,
+  windowFunction,
+  apply_window_f64,
+  welch_psd_f64,
+  bartlett_psd_f64,
+  goertzel_f64,
+  chirp_z_transform_f64,
+  rowReduce,
+  characteristicPolynomial,
+  expfit,
+  logfit,
+  powerfit,
+  quadprog,
+  linprog,
+  nullspace,
+  residue,
+  padeApproximant,
+  tensorTranspose,
   complex_add,
   complex_sub,
   complex_mul,
@@ -1441,6 +2092,41 @@ export const {
   complex_to_polar,
   complex_axpby,
   complex_distance,
+  bitAnd_i32_array,
+  bitOr_i32_array,
+  bitXor_i32_array,
+  bitNot_i32_array,
+  leftShift_i32_array,
+  rightArithShift_i32_array,
+  rightLogShift_i32_array,
+  poly_mul_f64,
+  poly_div_mod_f64,
+  poly_fit_f64,
+  cheb_fit_f64,
+  legendre_fit_f64,
+  tridiag_solve_f64,
+  divided_difference_f64,
+  bessel_j0_f64,
+  bessel_j1_f64,
+  bessel_jn_f64,
+  bessel_y0_f64,
+  bessel_y1_f64,
+  bessel_yn_f64,
+  airy_ai_f64,
+  airy_bi_f64,
+  elliptic_k_f64,
+  elliptic_e_f64,
+  lgamma_f64,
+  carlson_rc_f64,
+  carlson_rf_f64,
+  carlson_rd_f64,
+  carlson_rj_f64,
+  elliptic_f_incomplete_f64,
+  elliptic_e_incomplete_f64,
+  elliptic_pi_incomplete_f64,
+  sort_f64,
+  argsort_f64,
+  rank_f64,
   complex_array_zeros,
   complex_array_ones,
   complex_array_fill,