@hoff97/tensor-js
Version:
PyTorch like deep learning inferrence library
1,671 lines • 185 kB
JavaScript
import * as wasm from './rust_wasm_tensor_bg.wasm';
const heap = new Array(32).fill(undefined);
heap.push(undefined, null, true, false);
function getObject(idx) { return heap[idx]; }
let heap_next = heap.length;
function dropObject(idx) {
if (idx < 36)
return;
heap[idx] = heap_next;
heap_next = idx;
}
function takeObject(idx) {
const ret = getObject(idx);
dropObject(idx);
return ret;
}
const lTextDecoder = typeof TextDecoder === 'undefined' ? (0, module.require)('util').TextDecoder : TextDecoder;
let cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true });
cachedTextDecoder.decode();
let cachegetUint8Memory0 = null;
function getUint8Memory0() {
if (cachegetUint8Memory0 === null || cachegetUint8Memory0.buffer !== wasm.memory.buffer) {
cachegetUint8Memory0 = new Uint8Array(wasm.memory.buffer);
}
return cachegetUint8Memory0;
}
function getStringFromWasm0(ptr, len) {
return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
}
function addHeapObject(obj) {
if (heap_next === heap.length)
heap.push(heap.length + 1);
const idx = heap_next;
heap_next = heap[idx];
heap[idx] = obj;
return idx;
}
function _assertClass(instance, klass) {
if (!(instance instanceof klass)) {
throw new Error(`expected instance of ${klass.name}`);
}
return instance.ptr;
}
/**
*/
export class TensorF32 {
static __wrap(ptr) {
const obj = Object.create(TensorF32.prototype);
obj.ptr = ptr;
return obj;
}
__destroy_into_raw() {
const ptr = this.ptr;
this.ptr = 0;
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_tensorf32_free(ptr);
}
/**
* @param {Uint32Array} shape
* @param {Float32Array} values
* @returns {TensorF32}
*/
static create(shape, values) {
var ret = wasm.tensorf32_create(addHeapObject(shape), addHeapObject(values));
return TensorF32.__wrap(ret);
}
/**
* @param {Uint32Array} shape
* @param {number} value
* @returns {TensorF32}
*/
static create_constant(shape, value) {
var ret = wasm.tensorf32_create_constant(addHeapObject(shape), value);
return TensorF32.__wrap(ret);
}
/**
* @returns {Float32Array}
*/
get_vals() {
var ret = wasm.tensorf32_get_vals(this.ptr);
return takeObject(ret);
}
/**
* @returns {Uint32Array}
*/
get_shape() {
var ret = wasm.tensorf32_get_shape(this.ptr);
return takeObject(ret);
}
/**
* @returns {TensorF32}
*/
exp() {
var ret = wasm.tensorf32_exp(this.ptr);
return TensorF32.__wrap(ret);
}
/**
* @returns {TensorF32}
*/
log() {
var ret = wasm.tensorf32_log(this.ptr);
return TensorF32.__wrap(ret);
}
/**
* @returns {TensorF32}
*/
sqrt() {
var ret = wasm.tensorf32_sqrt(this.ptr);
return TensorF32.__wrap(ret);
}
/**
* @returns {TensorF32}
*/
sin() {
var ret = wasm.tensorf32_sin(this.ptr);
return TensorF32.__wrap(ret);
}
/**
* @returns {TensorF32}
*/
cos() {
var ret = wasm.tensorf32_cos(this.ptr);
return TensorF32.__wrap(ret);
}
/**
* @returns {TensorF32}
*/
tan() {
var ret = wasm.tensorf32_tan(this.ptr);
return TensorF32.__wrap(ret);
}
/**
* @returns {TensorF32}
*/
asin() {
var ret = wasm.tensorf32_asin(this.ptr);
return TensorF32.__wrap(ret);
}
/**
* @returns {TensorF32}
*/
acos() {
var ret = wasm.tensorf32_acos(this.ptr);
return TensorF32.__wrap(ret);
}
/**
* @returns {TensorF32}
*/
atan() {
var ret = wasm.tensorf32_atan(this.ptr);
return TensorF32.__wrap(ret);
}
/**
* @returns {TensorF32}
*/
sinh() {
var ret = wasm.tensorf32_sinh(this.ptr);
return TensorF32.__wrap(ret);
}
/**
* @returns {TensorF32}
*/
cosh() {
var ret = wasm.tensorf32_cosh(this.ptr);
return TensorF32.__wrap(ret);
}
/**
* @returns {TensorF32}
*/
tanh() {
var ret = wasm.tensorf32_tanh(this.ptr);
return TensorF32.__wrap(ret);
}
/**
* @returns {TensorF32}
*/
asinh() {
var ret = wasm.tensorf32_asinh(this.ptr);
return TensorF32.__wrap(ret);
}
/**
* @returns {TensorF32}
*/
acosh() {
var ret = wasm.tensorf32_acosh(this.ptr);
return TensorF32.__wrap(ret);
}
/**
* @returns {TensorF32}
*/
atanh() {
var ret = wasm.tensorf32_atanh(this.ptr);
return TensorF32.__wrap(ret);
}
/**
* @returns {TensorF32}
*/
sigmoid() {
var ret = wasm.tensorf32_sigmoid(this.ptr);
return TensorF32.__wrap(ret);
}
/**
* @returns {TensorF32}
*/
floor() {
var ret = wasm.tensorf32_floor(this.ptr);
return TensorF32.__wrap(ret);
}
/**
* @returns {TensorF32}
*/
ceil() {
var ret = wasm.tensorf32_ceil(this.ptr);
return TensorF32.__wrap(ret);
}
/**
* @returns {TensorF32}
*/
round() {
var ret = wasm.tensorf32_round(this.ptr);
return TensorF32.__wrap(ret);
}
/**
* @param {number} power
* @param {number} factor
* @returns {TensorF32}
*/
power_scalar(power, factor) {
var ret = wasm.tensorf32_power_scalar(this.ptr, power, factor);
return TensorF32.__wrap(ret);
}
/**
* @param {number} alpha
* @param {number} beta
* @returns {TensorF32}
*/
hard_sigmoid(alpha, beta) {
var ret = wasm.tensorf32_hard_sigmoid(this.ptr, alpha, beta);
return TensorF32.__wrap(ret);
}
/**
* @returns {TensorF32}
*/
abs() {
var ret = wasm.tensorf32_abs(this.ptr);
return TensorF32.__wrap(ret);
}
/**
* @returns {TensorF32}
*/
sign() {
var ret = wasm.tensorf32_sign(this.ptr);
return TensorF32.__wrap(ret);
}
/**
* @returns {TensorF32}
*/
negate() {
var ret = wasm.tensorf32_negate(this.ptr);
return TensorF32.__wrap(ret);
}
/**
* @param {number} factor
* @param {number} add
* @returns {TensorF32}
*/
add_multiply_scalar(factor, add) {
var ret = wasm.tensorf32_add_multiply_scalar(this.ptr, factor, add);
return TensorF32.__wrap(ret);
}
/**
* @param {number} min
* @param {number} max
* @returns {TensorF32}
*/
clip(min, max) {
var ret = wasm.tensorf32_clip(this.ptr, min, max);
return TensorF32.__wrap(ret);
}
/**
* @param {number} min
* @returns {TensorF32}
*/
clip_min(min) {
var ret = wasm.tensorf32_clip_min(this.ptr, min);
return TensorF32.__wrap(ret);
}
/**
* @param {number} max
* @returns {TensorF32}
*/
clip_max(max) {
var ret = wasm.tensorf32_clip_max(this.ptr, max);
return TensorF32.__wrap(ret);
}
/**
* @param {TensorF32} other
* @returns {TensorF32}
*/
power(other) {
_assertClass(other, TensorF32);
var ret = wasm.tensorf32_power(this.ptr, other.ptr);
return TensorF32.__wrap(ret);
}
/**
* @param {TensorF32} other
* @returns {TensorF32}
*/
bce(other) {
_assertClass(other, TensorF32);
var ret = wasm.tensorf32_bce(this.ptr, other.ptr);
return TensorF32.__wrap(ret);
}
/**
* @param {TensorF32} other
* @returns {TensorF32}
*/
bce_back(other) {
_assertClass(other, TensorF32);
var ret = wasm.tensorf32_bce_back(this.ptr, other.ptr);
return TensorF32.__wrap(ret);
}
/**
* @param {TensorF32} other
* @param {number} alpha
* @param {number} beta
* @returns {TensorF32}
*/
addition(other, alpha, beta) {
_assertClass(other, TensorF32);
var ret = wasm.tensorf32_addition(this.ptr, other.ptr, alpha, beta);
return TensorF32.__wrap(ret);
}
/**
* @param {TensorF32} other
* @param {number} alpha
* @param {number} beta
* @returns {TensorF32}
*/
subtraction(other, alpha, beta) {
_assertClass(other, TensorF32);
var ret = wasm.tensorf32_subtraction(this.ptr, other.ptr, alpha, beta);
return TensorF32.__wrap(ret);
}
/**
* @param {TensorF32} other
* @param {number} alpha
* @returns {TensorF32}
*/
multiply(other, alpha) {
_assertClass(other, TensorF32);
var ret = wasm.tensorf32_multiply(this.ptr, other.ptr, alpha);
return TensorF32.__wrap(ret);
}
/**
* @param {TensorF32} other
* @param {number} alpha
* @returns {TensorF32}
*/
divide(other, alpha) {
_assertClass(other, TensorF32);
var ret = wasm.tensorf32_divide(this.ptr, other.ptr, alpha);
return TensorF32.__wrap(ret);
}
/**
* @param {number} min
* @param {number} max
* @param {TensorF32} grad
* @returns {TensorF32}
*/
clip_backward(min, max, grad) {
_assertClass(grad, TensorF32);
var ret = wasm.tensorf32_clip_backward(this.ptr, min, max, grad.ptr);
return TensorF32.__wrap(ret);
}
/**
* @param {number} min
* @param {TensorF32} grad
* @returns {TensorF32}
*/
clip_min_backward(min, grad) {
_assertClass(grad, TensorF32);
var ret = wasm.tensorf32_clip_min_backward(this.ptr, min, grad.ptr);
return TensorF32.__wrap(ret);
}
/**
* @param {number} max
* @param {TensorF32} grad
* @returns {TensorF32}
*/
clip_max_backward(max, grad) {
_assertClass(grad, TensorF32);
var ret = wasm.tensorf32_clip_max_backward(this.ptr, max, grad.ptr);
return TensorF32.__wrap(ret);
}
/**
* @param {Uint32Array} axes
* @param {boolean} keep_dims
* @returns {TensorF32}
*/
sum(axes, keep_dims) {
var ret = wasm.tensorf32_sum(this.ptr, addHeapObject(axes), keep_dims);
return TensorF32.__wrap(ret);
}
/**
* @param {Uint32Array} axes
* @param {boolean} keep_dims
* @returns {TensorF32}
*/
sum_square(axes, keep_dims) {
var ret = wasm.tensorf32_sum_square(this.ptr, addHeapObject(axes), keep_dims);
return TensorF32.__wrap(ret);
}
/**
* @param {Uint32Array} axes
* @param {boolean} keep_dims
* @returns {TensorF32}
*/
product(axes, keep_dims) {
var ret = wasm.tensorf32_product(this.ptr, addHeapObject(axes), keep_dims);
return TensorF32.__wrap(ret);
}
/**
* @param {Uint32Array} axes
* @param {boolean} keep_dims
* @returns {TensorF32}
*/
max(axes, keep_dims) {
var ret = wasm.tensorf32_max(this.ptr, addHeapObject(axes), keep_dims);
return TensorF32.__wrap(ret);
}
/**
* @param {Uint32Array} axes
* @param {boolean} keep_dims
* @returns {TensorF32}
*/
min(axes, keep_dims) {
var ret = wasm.tensorf32_min(this.ptr, addHeapObject(axes), keep_dims);
return TensorF32.__wrap(ret);
}
/**
* @param {Uint32Array} axes
* @param {boolean} keep_dims
* @returns {TensorF32}
*/
reduce_mean(axes, keep_dims) {
var ret = wasm.tensorf32_reduce_mean(this.ptr, addHeapObject(axes), keep_dims);
return TensorF32.__wrap(ret);
}
/**
* @param {Uint32Array} axes
* @param {boolean} keep_dims
* @returns {TensorF32}
*/
reduce_mean_square(axes, keep_dims) {
var ret = wasm.tensorf32_reduce_mean_square(this.ptr, addHeapObject(axes), keep_dims);
return TensorF32.__wrap(ret);
}
/**
* @param {Uint32Array} axes
* @param {boolean} keep_dims
* @returns {TensorF32}
*/
reduce_log_sum(axes, keep_dims) {
var ret = wasm.tensorf32_reduce_log_sum(this.ptr, addHeapObject(axes), keep_dims);
return TensorF32.__wrap(ret);
}
/**
* @param {Uint32Array} axes
* @param {boolean} keep_dims
* @returns {TensorF32}
*/
reduce_log_sum_exp(axes, keep_dims) {
var ret = wasm.tensorf32_reduce_log_sum_exp(this.ptr, addHeapObject(axes), keep_dims);
return TensorF32.__wrap(ret);
}
/**
* @param {TensorF32} kernel
* @param {Uint32Array} dilations
* @param {number} group
* @param {Uint32Array} pads
* @param {Uint32Array} strides
* @param {number} activation
* @returns {TensorF32}
*/
conv(kernel, dilations, group, pads, strides, activation) {
_assertClass(kernel, TensorF32);
var ret = wasm.tensorf32_conv(this.ptr, kernel.ptr, addHeapObject(dilations), group, addHeapObject(pads), addHeapObject(strides), activation);
return TensorF32.__wrap(ret);
}
/**
* @param {TensorF32} kernel
* @param {TensorF32} bias
* @param {Uint32Array} dilations
* @param {number} group
* @param {Uint32Array} pads
* @param {Uint32Array} strides
* @param {number} activation
* @returns {TensorF32}
*/
conv_with_bias(kernel, bias, dilations, group, pads, strides, activation) {
_assertClass(kernel, TensorF32);
_assertClass(bias, TensorF32);
var ret = wasm.tensorf32_conv_with_bias(this.ptr, kernel.ptr, bias.ptr, addHeapObject(dilations), group, addHeapObject(pads), addHeapObject(strides), activation);
return TensorF32.__wrap(ret);
}
/**
* @param {TensorF32} kernel
* @param {Uint32Array} dilations
* @param {number} group
* @param {Uint32Array} pads
* @param {Uint32Array} strides
* @returns {TensorF32}
*/
conv_transpose(kernel, dilations, group, pads, strides) {
_assertClass(kernel, TensorF32);
var ret = wasm.tensorf32_conv_transpose(this.ptr, kernel.ptr, addHeapObject(dilations), group, addHeapObject(pads), addHeapObject(strides));
return TensorF32.__wrap(ret);
}
/**
* @param {Uint32Array} kernel_shape
* @param {Uint32Array} pads
* @param {Uint32Array} strides
* @param {boolean} include_pad
* @returns {TensorF32}
*/
average_pool(kernel_shape, pads, strides, include_pad) {
var ret = wasm.tensorf32_average_pool(this.ptr, addHeapObject(kernel_shape), addHeapObject(pads), addHeapObject(strides), include_pad);
return TensorF32.__wrap(ret);
}
/**
* @param {Uint32Array} pads
* @param {number} mode
* @param {number} value
* @returns {TensorF32}
*/
pad(pads, mode, value) {
var ret = wasm.tensorf32_pad(this.ptr, addHeapObject(pads), mode, value);
return TensorF32.__wrap(ret);
}
/**
* @param {Float32Array} scales
* @returns {TensorF32}
*/
upsample(scales) {
var ret = wasm.tensorf32_upsample(this.ptr, addHeapObject(scales));
return TensorF32.__wrap(ret);
}
/**
* @param {TensorF32} mean
* @param {TensorF32} variance
* @param {number} epsilon
* @param {TensorF32} scale
* @param {TensorF32} bias
* @returns {TensorF32}
*/
normalize(mean, variance, epsilon, scale, bias) {
_assertClass(mean, TensorF32);
_assertClass(variance, TensorF32);
_assertClass(scale, TensorF32);
_assertClass(bias, TensorF32);
var ret = wasm.tensorf32_normalize(this.ptr, mean.ptr, variance.ptr, epsilon, scale.ptr, bias.ptr);
return TensorF32.__wrap(ret);
}
/**
* @param {TensorF32} other
* @returns {TensorF32}
*/
matmul(other) {
_assertClass(other, TensorF32);
var ret = wasm.tensorf32_matmul(this.ptr, other.ptr);
return TensorF32.__wrap(ret);
}
/**
* @param {TensorF32} other
* @param {boolean} a_transpose
* @param {boolean} b_transpose
* @param {number} alpha
* @returns {TensorF32}
*/
gemm(other, a_transpose, b_transpose, alpha) {
_assertClass(other, TensorF32);
var ret = wasm.tensorf32_gemm(this.ptr, other.ptr, a_transpose, b_transpose, alpha);
return TensorF32.__wrap(ret);
}
/**
* @param {TensorF32} other
* @param {boolean} a_transpose
* @param {boolean} b_transpose
* @param {number} alpha
* @param {TensorF32} c
* @param {number} beta
* @returns {TensorF32}
*/
gemm_with_c(other, a_transpose, b_transpose, alpha, c, beta) {
_assertClass(other, TensorF32);
_assertClass(c, TensorF32);
var ret = wasm.tensorf32_gemm_with_c(this.ptr, other.ptr, a_transpose, b_transpose, alpha, c.ptr, beta);
return TensorF32.__wrap(ret);
}
/**
* @param {TensorF32} values
* @param {Uint32Array} starts
* @returns {TensorF32}
*/
set_values(values, starts) {
_assertClass(values, TensorF32);
var ret = wasm.tensorf32_set_values(this.ptr, values.ptr, addHeapObject(starts));
return TensorF32.__wrap(ret);
}
/**
* @param {Uint32Array} shape
* @returns {TensorF32}
*/
reshape(shape) {
var ret = wasm.tensorf32_reshape(this.ptr, addHeapObject(shape));
return TensorF32.__wrap(ret);
}
/**
* @param {TensorF32} other
* @param {number} axes
* @returns {TensorF32}
*/
concat(other, axes) {
_assertClass(other, TensorF32);
var ret = wasm.tensorf32_concat(this.ptr, other.ptr, axes);
return TensorF32.__wrap(ret);
}
/**
* @param {Uint32Array} permutation
* @returns {TensorF32}
*/
transpose(permutation) {
var ret = wasm.tensorf32_transpose(this.ptr, addHeapObject(permutation));
return TensorF32.__wrap(ret);
}
/**
* @param {Uint32Array} repeats
* @returns {TensorF32}
*/
repeat(repeats) {
var ret = wasm.tensorf32_repeat(this.ptr, addHeapObject(repeats));
return TensorF32.__wrap(ret);
}
/**
* @param {Uint32Array} shape
* @returns {TensorF32}
*/
expand(shape) {
var ret = wasm.tensorf32_expand(this.ptr, addHeapObject(shape));
return TensorF32.__wrap(ret);
}
/**
* @returns {TensorF32}
*/
copy() {
var ret = wasm.tensorf32_copy(this.ptr);
return TensorF32.__wrap(ret);
}
/**
* @param {number} axis
* @param {Uint32Array} indices
* @param {Uint32Array} indice_shape
* @returns {TensorF32}
*/
gather(axis, indices, indice_shape) {
var ret = wasm.tensorf32_gather(this.ptr, axis, addHeapObject(indices), addHeapObject(indice_shape));
return TensorF32.__wrap(ret);
}
/**
* @param {Uint32Array} starts
* @param {Uint32Array} ends
* @param {Uint32Array} axis
* @param {Int32Array} steps
* @returns {TensorF32}
*/
slice(starts, ends, axis, steps) {
var ret = wasm.tensorf32_slice(this.ptr, addHeapObject(starts), addHeapObject(ends), addHeapObject(axis), addHeapObject(steps));
return TensorF32.__wrap(ret);
}
/**
* @param {TensorU32} indices
* @param {TensorF32} b
* @param {number} m
* @returns {TensorF32}
*/
matmul_sparse_dense(indices, b, m) {
_assertClass(indices, TensorU32);
_assertClass(b, TensorF32);
var ret = wasm.tensorf32_matmul_sparse_dense(this.ptr, indices.ptr, b.ptr, m);
return TensorF32.__wrap(ret);
}
/**
* @param {TensorU32} indices
* @param {TensorF32} b
* @param {Uint32Array} result_shape
* @param {number} alpha
* @param {number} beta
* @returns {TensorF32}
*/
add_sparse_dense(indices, b, result_shape, alpha, beta) {
_assertClass(indices, TensorU32);
_assertClass(b, TensorF32);
var ret = wasm.tensorf32_add_sparse_dense(this.ptr, indices.ptr, b.ptr, addHeapObject(result_shape), alpha, beta);
return TensorF32.__wrap(ret);
}
/**
* @param {TensorU32} indices
* @param {TensorF32} b
* @param {Uint32Array} result_shape
* @param {number} alpha
* @param {number} beta
* @returns {TensorF32}
*/
subtract_sparse_dense(indices, b, result_shape, alpha, beta) {
_assertClass(indices, TensorU32);
_assertClass(b, TensorF32);
var ret = wasm.tensorf32_subtract_sparse_dense(this.ptr, indices.ptr, b.ptr, addHeapObject(result_shape), alpha, beta);
return TensorF32.__wrap(ret);
}
/**
* @param {TensorU32} indices
* @param {TensorF32} b
* @param {Uint32Array} result_shape
* @param {number} alpha
* @returns {TensorF32}
*/
multiply_sparse_dense(indices, b, result_shape, alpha) {
_assertClass(indices, TensorU32);
_assertClass(b, TensorF32);
var ret = wasm.tensorf32_multiply_sparse_dense(this.ptr, indices.ptr, b.ptr, addHeapObject(result_shape), alpha);
return TensorF32.__wrap(ret);
}
/**
* @param {TensorU32} indices
* @param {TensorF32} b
* @param {Uint32Array} result_shape
* @param {number} alpha
* @returns {TensorF32}
*/
divide_sparse_dense(indices, b, result_shape, alpha) {
_assertClass(indices, TensorU32);
_assertClass(b, TensorF32);
var ret = wasm.tensorf32_divide_sparse_dense(this.ptr, indices.ptr, b.ptr, addHeapObject(result_shape), alpha);
return TensorF32.__wrap(ret);
}
/**
* @param {TensorU32} indices
* @param {TensorU32} b_indices
* @param {TensorF32} b_values
* @param {Uint32Array} result_shape
* @param {number} alpha
* @param {number} beta
* @returns {TensorF32}
*/
add_sparse_sparse(indices, b_indices, b_values, result_shape, alpha, beta) {
_assertClass(indices, TensorU32);
_assertClass(b_indices, TensorU32);
_assertClass(b_values, TensorF32);
var ret = wasm.tensorf32_add_sparse_sparse(this.ptr, indices.ptr, b_indices.ptr, b_values.ptr, addHeapObject(result_shape), alpha, beta);
return TensorF32.__wrap(ret);
}
/**
* @param {TensorU32} indices
* @param {TensorU32} b_indices
* @param {TensorF32} b_values
* @param {Uint32Array} result_shape
* @param {number} alpha
* @param {number} beta
* @returns {TensorF32}
*/
subtract_sparse_sparse(indices, b_indices, b_values, result_shape, alpha, beta) {
_assertClass(indices, TensorU32);
_assertClass(b_indices, TensorU32);
_assertClass(b_values, TensorF32);
var ret = wasm.tensorf32_subtract_sparse_sparse(this.ptr, indices.ptr, b_indices.ptr, b_values.ptr, addHeapObject(result_shape), alpha, beta);
return TensorF32.__wrap(ret);
}
/**
* @param {TensorU32} indices
* @param {TensorU32} b_indices
* @param {TensorF32} b_values
* @param {Uint32Array} result_shape
* @param {number} alpha
* @returns {TensorF32}
*/
divide_sparse_sparse(indices, b_indices, b_values, result_shape, alpha) {
_assertClass(indices, TensorU32);
_assertClass(b_indices, TensorU32);
_assertClass(b_values, TensorF32);
var ret = wasm.tensorf32_divide_sparse_sparse(this.ptr, indices.ptr, b_indices.ptr, b_values.ptr, addHeapObject(result_shape), alpha);
return TensorF32.__wrap(ret);
}
/**
* @param {TensorU32} indices
* @param {TensorU32} b_indices
* @param {TensorF32} b_values
* @param {Uint32Array} result_shape
* @param {number} alpha
* @returns {TensorF32}
*/
multiply_sparse_sparse(indices, b_indices, b_values, result_shape, alpha) {
_assertClass(indices, TensorU32);
_assertClass(b_indices, TensorU32);
_assertClass(b_values, TensorF32);
var ret = wasm.tensorf32_multiply_sparse_sparse(this.ptr, indices.ptr, b_indices.ptr, b_values.ptr, addHeapObject(result_shape), alpha);
return TensorF32.__wrap(ret);
}
/**
* @param {Uint32Array} shape
* @param {TensorU32} indices
* @param {Uint32Array} axes
* @param {boolean} keep_dims
* @returns {TensorF32}
*/
sum_sparse(shape, indices, axes, keep_dims) {
_assertClass(indices, TensorU32);
var ret = wasm.tensorf32_sum_sparse(this.ptr, addHeapObject(shape), indices.ptr, addHeapObject(axes), keep_dims);
return TensorF32.__wrap(ret);
}
/**
* @param {Uint32Array} shape
* @param {TensorU32} indices
* @param {Uint32Array} axes
* @param {boolean} keep_dims
* @returns {TensorF32}
*/
sum_square_sparse(shape, indices, axes, keep_dims) {
_assertClass(indices, TensorU32);
var ret = wasm.tensorf32_sum_square_sparse(this.ptr, addHeapObject(shape), indices.ptr, addHeapObject(axes), keep_dims);
return TensorF32.__wrap(ret);
}
/**
* @param {Uint32Array} shape
* @param {TensorU32} indices
* @param {Uint32Array} axes
* @param {boolean} keep_dims
* @returns {TensorF32}
*/
reduce_mean_sparse(shape, indices, axes, keep_dims) {
_assertClass(indices, TensorU32);
var ret = wasm.tensorf32_reduce_mean_sparse(this.ptr, addHeapObject(shape), indices.ptr, addHeapObject(axes), keep_dims);
return TensorF32.__wrap(ret);
}
/**
* @param {Uint32Array} shape
* @param {TensorU32} indices
* @param {Uint32Array} axes
* @param {boolean} keep_dims
* @returns {TensorF32}
*/
product_sparse(shape, indices, axes, keep_dims) {
_assertClass(indices, TensorU32);
var ret = wasm.tensorf32_product_sparse(this.ptr, addHeapObject(shape), indices.ptr, addHeapObject(axes), keep_dims);
return TensorF32.__wrap(ret);
}
/**
* @param {Uint32Array} shape
* @param {TensorU32} indices
* @param {Uint32Array} axes
* @param {boolean} keep_dims
* @returns {TensorF32}
*/
max_sparse(shape, indices, axes, keep_dims) {
_assertClass(indices, TensorU32);
var ret = wasm.tensorf32_max_sparse(this.ptr, addHeapObject(shape), indices.ptr, addHeapObject(axes), keep_dims);
return TensorF32.__wrap(ret);
}
/**
* @param {Uint32Array} shape
* @param {TensorU32} indices
* @param {Uint32Array} axes
* @param {boolean} keep_dims
* @returns {TensorF32}
*/
min_sparse(shape, indices, axes, keep_dims) {
_assertClass(indices, TensorU32);
var ret = wasm.tensorf32_min_sparse(this.ptr, addHeapObject(shape), indices.ptr, addHeapObject(axes), keep_dims);
return TensorF32.__wrap(ret);
}
/**
* @param {Uint32Array} shape
* @param {TensorU32} indices
* @param {Uint32Array} axes
* @param {boolean} keep_dims
* @returns {TensorF32}
*/
reduce_mean_squared_sparse(shape, indices, axes, keep_dims) {
_assertClass(indices, TensorU32);
var ret = wasm.tensorf32_reduce_mean_squared_sparse(this.ptr, addHeapObject(shape), indices.ptr, addHeapObject(axes), keep_dims);
return TensorF32.__wrap(ret);
}
/**
* @param {Uint32Array} shape
* @param {TensorU32} indices
* @param {Uint32Array} axes
* @param {boolean} keep_dims
* @returns {TensorF32}
*/
reduce_log_sum_sparse(shape, indices, axes, keep_dims) {
_assertClass(indices, TensorU32);
var ret = wasm.tensorf32_reduce_log_sum_sparse(this.ptr, addHeapObject(shape), indices.ptr, addHeapObject(axes), keep_dims);
return TensorF32.__wrap(ret);
}
/**
* @param {Uint32Array} shape
* @param {TensorU32} indices
* @param {Uint32Array} axes
* @param {boolean} keep_dims
* @returns {TensorF32}
*/
reduce_log_sum_exp_sparse(shape, indices, axes, keep_dims) {
_assertClass(indices, TensorU32);
var ret = wasm.tensorf32_reduce_log_sum_exp_sparse(this.ptr, addHeapObject(shape), indices.ptr, addHeapObject(axes), keep_dims);
return TensorF32.__wrap(ret);
}
}
/**
*/
export class TensorF64 {
static __wrap(ptr) {
const obj = Object.create(TensorF64.prototype);
obj.ptr = ptr;
return obj;
}
__destroy_into_raw() {
const ptr = this.ptr;
this.ptr = 0;
return ptr;
}
free() {
const ptr = this.__destroy_into_raw();
wasm.__wbg_tensorf64_free(ptr);
}
/**
* @param {Uint32Array} shape
* @param {Float64Array} values
* @returns {TensorF64}
*/
static create(shape, values) {
var ret = wasm.tensorf64_create(addHeapObject(shape), addHeapObject(values));
return TensorF64.__wrap(ret);
}
/**
* @param {Uint32Array} shape
* @param {number} value
* @returns {TensorF64}
*/
static create_constant(shape, value) {
var ret = wasm.tensorf64_create_constant(addHeapObject(shape), value);
return TensorF64.__wrap(ret);
}
/**
* @returns {Float64Array}
*/
get_vals() {
var ret = wasm.tensorf64_get_vals(this.ptr);
return takeObject(ret);
}
/**
* @returns {Uint32Array}
*/
get_shape() {
var ret = wasm.tensorf64_get_shape(this.ptr);
return takeObject(ret);
}
/**
* @returns {TensorF64}
*/
exp() {
var ret = wasm.tensorf64_exp(this.ptr);
return TensorF64.__wrap(ret);
}
/**
* @returns {TensorF64}
*/
log() {
var ret = wasm.tensorf64_log(this.ptr);
return TensorF64.__wrap(ret);
}
/**
* @returns {TensorF64}
*/
sqrt() {
var ret = wasm.tensorf64_sqrt(this.ptr);
return TensorF64.__wrap(ret);
}
/**
* @returns {TensorF64}
*/
sin() {
var ret = wasm.tensorf64_sin(this.ptr);
return TensorF64.__wrap(ret);
}
/**
* @returns {TensorF64}
*/
cos() {
var ret = wasm.tensorf64_cos(this.ptr);
return TensorF64.__wrap(ret);
}
/**
* @returns {TensorF64}
*/
tan() {
var ret = wasm.tensorf64_tan(this.ptr);
return TensorF64.__wrap(ret);
}
/**
* @returns {TensorF64}
*/
asin() {
var ret = wasm.tensorf64_asin(this.ptr);
return TensorF64.__wrap(ret);
}
/**
* @returns {TensorF64}
*/
acos() {
var ret = wasm.tensorf64_acos(this.ptr);
return TensorF64.__wrap(ret);
}
/**
* @returns {TensorF64}
*/
atan() {
var ret = wasm.tensorf64_atan(this.ptr);
return TensorF64.__wrap(ret);
}
/**
* @returns {TensorF64}
*/
sinh() {
var ret = wasm.tensorf64_sinh(this.ptr);
return TensorF64.__wrap(ret);
}
/**
* @returns {TensorF64}
*/
cosh() {
var ret = wasm.tensorf64_cosh(this.ptr);
return TensorF64.__wrap(ret);
}
/**
* @returns {TensorF64}
*/
tanh() {
var ret = wasm.tensorf64_tanh(this.ptr);
return TensorF64.__wrap(ret);
}
/**
* @returns {TensorF64}
*/
asinh() {
var ret = wasm.tensorf64_asinh(this.ptr);
return TensorF64.__wrap(ret);
}
/**
* @returns {TensorF64}
*/
acosh() {
var ret = wasm.tensorf64_acosh(this.ptr);
return TensorF64.__wrap(ret);
}
/**
* @returns {TensorF64}
*/
atanh() {
var ret = wasm.tensorf64_atanh(this.ptr);
return TensorF64.__wrap(ret);
}
/**
* @returns {TensorF64}
*/
sigmoid() {
var ret = wasm.tensorf64_sigmoid(this.ptr);
return TensorF64.__wrap(ret);
}
/**
* @returns {TensorF64}
*/
floor() {
var ret = wasm.tensorf64_floor(this.ptr);
return TensorF64.__wrap(ret);
}
/**
* @returns {TensorF64}
*/
ceil() {
var ret = wasm.tensorf64_ceil(this.ptr);
return TensorF64.__wrap(ret);
}
/**
* @returns {TensorF64}
*/
round() {
var ret = wasm.tensorf64_round(this.ptr);
return TensorF64.__wrap(ret);
}
/**
* @param {number} power
* @param {number} factor
* @returns {TensorF64}
*/
power_scalar(power, factor) {
var ret = wasm.tensorf64_power_scalar(this.ptr, power, factor);
return TensorF64.__wrap(ret);
}
/**
* @param {number} alpha
* @param {number} beta
* @returns {TensorF64}
*/
hard_sigmoid(alpha, beta) {
var ret = wasm.tensorf64_hard_sigmoid(this.ptr, alpha, beta);
return TensorF64.__wrap(ret);
}
/**
* @returns {TensorF64}
*/
abs() {
var ret = wasm.tensorf64_abs(this.ptr);
return TensorF64.__wrap(ret);
}
/**
* @returns {TensorF64}
*/
sign() {
var ret = wasm.tensorf64_sign(this.ptr);
return TensorF64.__wrap(ret);
}
/**
* @returns {TensorF64}
*/
negate() {
var ret = wasm.tensorf64_negate(this.ptr);
return TensorF64.__wrap(ret);
}
/**
* @param {number} factor
* @param {number} add
* @returns {TensorF64}
*/
add_multiply_scalar(factor, add) {
var ret = wasm.tensorf64_add_multiply_scalar(this.ptr, factor, add);
return TensorF64.__wrap(ret);
}
/**
* @param {number} min
* @param {number} max
* @returns {TensorF64}
*/
clip(min, max) {
var ret = wasm.tensorf64_clip(this.ptr, min, max);
return TensorF64.__wrap(ret);
}
/**
* @param {number} min
* @returns {TensorF64}
*/
clip_min(min) {
var ret = wasm.tensorf64_clip_min(this.ptr, min);
return TensorF64.__wrap(ret);
}
/**
* @param {number} max
* @returns {TensorF64}
*/
clip_max(max) {
var ret = wasm.tensorf64_clip_max(this.ptr, max);
return TensorF64.__wrap(ret);
}
/**
* @param {TensorF64} other
* @returns {TensorF64}
*/
power(other) {
_assertClass(other, TensorF64);
var ret = wasm.tensorf64_power(this.ptr, other.ptr);
return TensorF64.__wrap(ret);
}
/**
* @param {TensorF64} other
* @returns {TensorF64}
*/
bce(other) {
_assertClass(other, TensorF64);
var ret = wasm.tensorf64_bce(this.ptr, other.ptr);
return TensorF64.__wrap(ret);
}
/**
* @param {TensorF64} other
* @returns {TensorF64}
*/
bce_back(other) {
_assertClass(other, TensorF64);
var ret = wasm.tensorf64_bce_back(this.ptr, other.ptr);
return TensorF64.__wrap(ret);
}
/**
* @param {TensorF64} other
* @param {number} alpha
* @param {number} beta
* @returns {TensorF64}
*/
addition(other, alpha, beta) {
_assertClass(other, TensorF64);
var ret = wasm.tensorf64_addition(this.ptr, other.ptr, alpha, beta);
return TensorF64.__wrap(ret);
}
/**
* @param {TensorF64} other
* @param {number} alpha
* @param {number} beta
* @returns {TensorF64}
*/
subtraction(other, alpha, beta) {
_assertClass(other, TensorF64);
var ret = wasm.tensorf64_subtraction(this.ptr, other.ptr, alpha, beta);
return TensorF64.__wrap(ret);
}
/**
* @param {TensorF64} other
* @param {number} alpha
* @returns {TensorF64}
*/
multiply(other, alpha) {
_assertClass(other, TensorF64);
var ret = wasm.tensorf64_multiply(this.ptr, other.ptr, alpha);
return TensorF64.__wrap(ret);
}
/**
* @param {TensorF64} other
* @param {number} alpha
* @returns {TensorF64}
*/
divide(other, alpha) {
_assertClass(other, TensorF64);
var ret = wasm.tensorf64_divide(this.ptr, other.ptr, alpha);
return TensorF64.__wrap(ret);
}
/**
* @param {number} min
* @param {number} max
* @param {TensorF64} grad
* @returns {TensorF64}
*/
clip_backward(min, max, grad) {
_assertClass(grad, TensorF64);
var ret = wasm.tensorf64_clip_backward(this.ptr, min, max, grad.ptr);
return TensorF64.__wrap(ret);
}
/**
* @param {number} min
* @param {TensorF64} grad
* @returns {TensorF64}
*/
clip_min_backward(min, grad) {
_assertClass(grad, TensorF64);
var ret = wasm.tensorf64_clip_min_backward(this.ptr, min, grad.ptr);
return TensorF64.__wrap(ret);
}
/**
* @param {number} max
* @param {TensorF64} grad
* @returns {TensorF64}
*/
clip_max_backward(max, grad) {
_assertClass(grad, TensorF64);
var ret = wasm.tensorf64_clip_max_backward(this.ptr, max, grad.ptr);
return TensorF64.__wrap(ret);
}
/**
* @param {Uint32Array} axes
* @param {boolean} keep_dims
* @returns {TensorF64}
*/
sum(axes, keep_dims) {
var ret = wasm.tensorf64_sum(this.ptr, addHeapObject(axes), keep_dims);
return TensorF64.__wrap(ret);
}
/**
* @param {Uint32Array} axes
* @param {boolean} keep_dims
* @returns {TensorF64}
*/
sum_square(axes, keep_dims) {
var ret = wasm.tensorf64_sum_square(this.ptr, addHeapObject(axes), keep_dims);
return TensorF64.__wrap(ret);
}
/**
* @param {Uint32Array} axes
* @param {boolean} keep_dims
* @returns {TensorF64}
*/
product(axes, keep_dims) {
var ret = wasm.tensorf64_product(this.ptr, addHeapObject(axes), keep_dims);
return TensorF64.__wrap(ret);
}
/**
* @param {Uint32Array} axes
* @param {boolean} keep_dims
* @returns {TensorF64}
*/
max(axes, keep_dims) {
var ret = wasm.tensorf64_max(this.ptr, addHeapObject(axes), keep_dims);
return TensorF64.__wrap(ret);
}
/**
* @param {Uint32Array} axes
* @param {boolean} keep_dims
* @returns {TensorF64}
*/
min(axes, keep_dims) {
var ret = wasm.tensorf64_min(this.ptr, addHeapObject(axes), keep_dims);
return TensorF64.__wrap(ret);
}
/**
* @param {Uint32Array} axes
* @param {boolean} keep_dims
* @returns {TensorF64}
*/
reduce_mean(axes, keep_dims) {
var ret = wasm.tensorf64_reduce_mean(this.ptr, addHeapObject(axes), keep_dims);
return TensorF64.__wrap(ret);
}
/**
* @param {Uint32Array} axes
* @param {boolean} keep_dims
* @returns {TensorF64}
*/
reduce_mean_square(axes, keep_dims) {
var ret = wasm.tensorf64_reduce_mean_square(this.ptr, addHeapObject(axes), keep_dims);
return TensorF64.__wrap(ret);
}
/**
* @param {Uint32Array} axes
* @param {boolean} keep_dims
* @returns {TensorF64}
*/
reduce_log_sum(axes, keep_dims) {
var ret = wasm.tensorf64_reduce_log_sum(this.ptr, addHeapObject(axes), keep_dims);
return TensorF64.__wrap(ret);
}
/**
* @param {Uint32Array} axes
* @param {boolean} keep_dims
* @returns {TensorF64}
*/
reduce_log_sum_exp(axes, keep_dims) {
var ret = wasm.tensorf64_reduce_log_sum_exp(this.ptr, addHeapObject(axes), keep_dims);
return TensorF64.__wrap(ret);
}
/**
* @param {TensorF64} kernel
* @param {Uint32Array} dilations
* @param {number} group
* @param {Uint32Array} pads
* @param {Uint32Array} strides
* @param {number} activation
* @returns {TensorF64}
*/
conv(kernel, dilations, group, pads, strides, activation) {
_assertClass(kernel, TensorF64);
var ret = wasm.tensorf64_conv(this.ptr, kernel.ptr, addHeapObject(dilations), group, addHeapObject(pads), addHeapObject(strides), activation);
return TensorF64.__wrap(ret);
}
/**
* @param {TensorF64} kernel
* @param {TensorF64} bias
* @param {Uint32Array} dilations
* @param {number} group
* @param {Uint32Array} pads
* @param {Uint32Array} strides
* @param {number} activation
* @returns {TensorF64}
*/
conv_with_bias(kernel, bias, dilations, group, pads, strides, activation) {
_assertClass(kernel, TensorF64);
_assertClass(bias, TensorF64);
var ret = wasm.tensorf64_conv_with_bias(this.ptr, kernel.ptr, bias.ptr, addHeapObject(dilations), group, addHeapObject(pads), addHeapObject(strides), activation);
return TensorF64.__wrap(ret);
}
/**
* @param {TensorF64} kernel
* @param {Uint32Array} dilations
* @param {number} group
* @param {Uint32Array} pads
* @param {Uint32Array} strides
* @returns {TensorF64}
*/
conv_transpose(kernel, dilations, group, pads, strides) {
_assertClass(kernel, TensorF64);
var ret = wasm.tensorf64_conv_transpose(this.ptr, kernel.ptr, addHeapObject(dilations), group, addHeapObject(pads), addHeapObject(strides));
return TensorF64.__wrap(ret);
}
/**
* @param {Uint32Array} kernel_shape
* @param {Uint32Array} pads
* @param {Uint32Array} strides
* @param {boolean} include_pad
* @returns {TensorF64}
*/
average_pool(kernel_shape, pads, strides, include_pad) {
var ret = wasm.tensorf64_average_pool(this.ptr, addHeapObject(kernel_shape), addHeapObject(pads), addHeapObject(strides), include_pad);
return TensorF64.__wrap(ret);
}
/**
* @param {Uint32Array} pads
* @param {number} mode
* @param {number} value
* @returns {TensorF64}
*/
pad(pads, mode, value) {
var ret = wasm.tensorf64_pad(this.ptr, addHeapObject(pads), mode, value);
return TensorF64.__wrap(ret);
}
/**
* @param {Float32Array} scales
* @returns {TensorF64}
*/
upsample(scales) {
var ret = wasm.tensorf64_upsample(this.ptr, addHeapObject(scales));
return TensorF64.__wrap(ret);
}
/**
* @param {TensorF64} mean
* @param {TensorF64} variance
* @param {number} epsilon
* @param {TensorF64} scale
* @param {TensorF64} bias
* @returns {TensorF64}
*/
normalize(mean, variance, epsilon, scale, bias) {
_assertClass(mean, TensorF64);
_assertClass(variance, TensorF64);
_assertClass(scale, TensorF64);
_assertClass(bias, TensorF64);
var ret = wasm.tensorf64_normalize(this.ptr, mean.ptr, variance.ptr, epsilon, scale.ptr, bias.ptr);
return TensorF64.__wrap(ret);
}
/**
* @param {TensorF64} other
* @returns {TensorF64}
*/
matmul(other) {
_assertClass(other, TensorF64);
var ret = wasm.tensorf64_matmul(this.ptr, other.ptr);
return TensorF64.__wrap(ret);
}
/**
* @param {TensorF64} other
* @param {boolean} a_transpose
* @param {boolean} b_transpose
* @param {number} alpha
* @returns {TensorF64}
*/
gemm(other, a_transpose, b_transpose, alpha) {
_assertClass(other, TensorF64);
var ret = wasm.tensorf64_gemm(this.ptr, other.ptr, a_transpose, b_transpose, alpha);
return TensorF64.__wrap(ret);
}
/**
* @param {TensorF64} other
* @param {boolean} a_transpose
* @param {boolean} b_transpose
* @param {number} alpha
* @param {TensorF64} c
* @param {number} beta
* @returns {TensorF64}
*/
gemm_with_c(other, a_transpose, b_transpose, alpha, c, beta) {
_assertClass(other, TensorF64);
_assertClass(c, TensorF64);
var ret = wasm.tensorf64_gemm_with_c(this.ptr, other.ptr, a_transpose, b_transpose, alpha, c.ptr, beta);
return TensorF64.__wrap(ret);
}
/**
* @param {TensorF64} values
* @param {Uint32Array} starts
* @returns {TensorF64}
*/
set_values(values, starts) {
_assertClass(values, TensorF64);
var ret = wasm.tensorf64_set_values(this.ptr, values.ptr, addHeapObject(starts));
return TensorF64.__wrap(ret);
}
/**
* @param {Uint32Array} shape
* @returns {TensorF64}
*/
reshape(shape) {
var ret = wasm.tensorf64_reshape(this.ptr, addHeapObject(shape));
return TensorF64.__wrap(ret);
}
/**
* @param {TensorF64} other
* @param {number} axes
* @returns {TensorF64}
*/
concat(other, axes) {
_assertClass(other, TensorF64);
var ret = wasm.tensorf64_concat(this.ptr, other.ptr, axes);
return TensorF64.__wrap(ret);
}
/**
* @param {Uint32Array} permutation
* @returns {TensorF64}
*/
transpose(permutation) {
var ret = wasm.tensorf64_transpose(this.ptr, addHeapObject(permutation));
return TensorF64.__wrap(ret);
}
/**
* @param {Uint32Array} repeats
* @returns {TensorF64}
*/
repeat(repeats) {
var ret = wasm.tensorf64_repeat(this.ptr, addHeapObject(repeats));
return TensorF64.__wrap(ret);
}
/**
* @param {Uint32Array} shape
* @returns {TensorF64}
*/
expand(shape) {
var ret = wasm.tensorf64_expand(this.ptr, addHeapObject(shape));
return TensorF64.__wrap(ret);
}
/**
* @returns {TensorF64}
*/
copy() {
var ret = wasm.tensorf64_copy(this.ptr);
return TensorF64.__wrap(ret);
}
/**
* @param {number} axis
* @param {Uint32Array} indices
* @param {Uint32Array} indice_shape
* @returns {TensorF64}
*/
gather(axis, indices, indice_shape) {
var ret = wasm.tensorf64_gather(this.ptr, axis, addHeapObject(indices), addHeapObject(indice_shape));
return TensorF64.__wrap(ret);
}
/**
* @param {Uint32Array} starts
* @param {Uint32Array} ends
* @param {Uint32Array} axis
* @param {Int32Array} steps
* @returns {TensorF64}
*/
slice(starts, ends, axis, steps) {
var ret = wasm.tensorf64_slice(this.ptr, addHeapObject(starts), addHeapObject(ends), addHeapObject(axis), addHeapObject(steps));
return TensorF64.__wrap(ret);
}
/**
* @param {TensorU32} indices
* @param {TensorF64} b
* @param {number} m
* @returns {TensorF64}
*/
matmul_sparse_dense(indices, b, m) {
_assertClass(indices, TensorU32);
_assertClass(b, TensorF64);
var ret = wasm.tensorf64_matmul_sparse_dense(this.ptr, indices.ptr, b.ptr, m);
return TensorF64.__wrap(ret);
}
/**
* @param {TensorU32} indices
* @param {TensorF64} b
* @param {Uint32Array} result_shape
* @param {number} alpha
* @param {number} beta
* @returns {TensorF64}
*/
add_sparse_dense(indices, b, result_shape, alpha, beta) {
_assertClass(indices, TensorU32);
_assertClass(b, TensorF64);
var ret = wasm.tensorf64_add_sparse_dense(this.ptr, indices.ptr, b.ptr, addHeapObject(result_shape), alpha, beta);
return TensorF64.__wrap(ret);
}
/**
* @param {TensorU32} indices
* @param {TensorF64} b
* @param {Uint32Array} result_shape
* @param {number} alpha
* @param {number} beta
* @returns {TensorF64}
*/
subtract_sparse_dense(indices, b, result_shape, alpha, beta) {
_assertClass(indices, TensorU32);
_assertClass(b, TensorF64);
var ret = wasm.tensorf64_subtract_sparse_dense(this.ptr, indices.ptr, b.ptr, addHeapObject(result_shape), alpha, beta);
return TensorF64.__wrap(ret);
}
/**
* @param {TensorU32} indices
* @param {TensorF64} b
* @param {Uint32Array} result_shape
* @param {number} alpha
* @returns {TensorF64}
*/
multiply_sparse_dense(indices, b, result_shape, alpha) {
_assertClass(indices, TensorU32);
_assertClass(b, TensorF64);
var ret = wasm.tensorf64_multiply_sparse_dense(this.ptr, indices.ptr, b.ptr, addHeapObject(result_shape), alpha);
return TensorF64.__wrap(ret);
}
/**
* @param {TensorU32} indices
* @param {TensorF64} b
* @param {Uint32Array} result_shape
* @param {number} alpha
* @returns {TensorF64}
*/
divide_sparse_dense(indices, b, result_shape, alpha) {
_assertClass(indices, TensorU32);
_assertClass(b, TensorF64);
var ret = wasm.tensorf64_divide_sparse_dense(this.ptr, indices.ptr, b.ptr, addHeapObject(result_shape), alpha);
return TensorF64.__wrap(ret);
}
/**
* @param {TensorU32} indices
* @param {TensorU32} b_indices
* @param {TensorF64} b_values
* @param {Uint32Array} result_shape
* @param {number} alpha
* @param {number} beta
* @returns {TensorF64}
*/
add_sparse_sparse(indices, b_indices, b_values, result_shape, alpha, beta) {
_assertClass(indices, TensorU32);
_assertClass(b_indices, TensorU32);
_assertClass(b_values, TensorF64);
var ret = wasm.tensorf64_add_sparse_sparse(this.ptr, indices.ptr, b_indices.ptr, b_values.ptr, addHeapObject(result_shape), alpha, beta);
return TensorF64.__wrap(ret);
}
/**
* @param {TensorU32} indices
* @param {TensorU32} b_indices
* @param {TensorF64} b_values
* @param {Uint32Array} result_shape
* @param {number} alpha
* @param {number} beta
* @returns {TensorF64}
*/
subtract_sparse_sparse(indices, b_indices, b_values, result_shape, alpha, beta) {
_assertClass(indices, TensorU32);
_assertClass(b_indices, TensorU32);
_assertClass(b_values, TensorF64);
var ret = wasm.tensorf64_subtract_sparse_sparse(this.ptr, indices.ptr, b_indices.ptr, b_values.ptr, addHeapObject(result_shape), alpha, beta);
return TensorF64.__wrap(ret);
}
/**
* @param {TensorU32} indices
* @param {TensorU32} b_indices
* @param {TensorF64} b_values
* @param {Uint32Array} result_shape
* @param {number} alpha
* @returns {TensorF64}
*/
divide_sparse_sparse(indices, b_indices, b_values, result_shape, alpha) {
_assertClass(indices, TensorU32);
_assertClass(b_indices, TensorU32);
_assertClass(b_values, TensorF64);
var ret = wasm.tensorf64_divide_sparse_sparse(this.p