🥮 mooncakes.io

numbt

NumPy-style numerical computing library for MoonBit

numpy
numerical
blas
matrix
moon add mizchi/numbt@0.2.4
Download zip
Author
Version
0.2.4
License
Apache-2.0
Repository
Last updated
18 hours ago
Downloads
1K

Dependencies

README

#numbt

NumPy-style numerical computing library for MoonBit.

Built on BLAS (Apple Accelerate framework on macOS) for high-performance matrix operations.

#Features

  • Vec/Mat views over Float arrays (zero-copy)
  • BLAS-accelerated matrix multiplication (cblas_sgemm)
  • LAPACK SVD decomposition
  • Element-wise operations
  • Softmax, ReLU activation functions

#Requirements

  • MoonBit native backend
  • BLAS/LAPACK library:
    • macOS: Apple Accelerate (built-in)
    • Linux: OpenBLAS + LAPACK (sudo apt-get install libopenblas-dev liblapack-dev)

#Platform Configuration

Add the appropriate link flags to your package's moon.pkg:

macOS:
options(
  link: { "native": { "cc-link-flags": "-framework Accelerate" } },
)

Linux:
options(
  link: { "native": { "cc-link-flags": "-lopenblas -llapack -lm" } },
)

#Installation

Add to moon.mod.json:

{
  "deps": {
    "mizchi/numbt": "0.1.0"
  }
}

Then run:

moon update

#Usage

// Create views over arrays
let data : Array[Float] = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]
let mat = @numbt.mat_view(data, rows=2, cols=3)
let vec = @numbt.vec_view(data, offset=0, len=3)

// Matrix multiplication
let a = @numbt.mat_view([1.0, 2.0, 3.0, 4.0], 2, 2)
let b = @numbt.mat_view([5.0, 6.0, 7.0, 8.0], 2, 2)
let c = a.matmul(b)

// Softmax
let logits = @numbt.vec_view([1.0, 2.0, 3.0], 0, 3)
let probs = @numbt.vec_view(Array::make(3, 0.0), 0, 3)
@numbt.softmax_into(input=logits, output=probs)

#API

#Vec operations

  • vec_view(data, offset, len) - Create a view
  • vec_add_into(left, right, output~) - Element-wise addition
  • vec_sub_into(left, right, output~) - Element-wise subtraction
  • vec_mul_into(left, right, output~) - Element-wise multiplication
  • softmax_into(input~, output~) - Softmax activation
  • relu_into(input~, output~) - ReLU activation

#Mat operations

  • mat_view(data, rows, cols) - Create a view
  • mat_matmul(a, b) - Matrix multiplication
  • Mat::matmul(self, other) - Method syntax
  • matmul_vec_bias_into(weight, input, bias, output~) - Linear layer forward

#LAPACK (LapackMat)

LapackMat is the FixedArray[Byte]-backed matrix type. Its raw byte layout matches what BLAS / LAPACK / vDSP expect, so calls into the native side are zero-copy.

  • fmat_zeros(rows, cols) / fmat_eye(n) / fmat_randn(rows, cols) - constructors
  • fmat_from_mat(m) / fmat_to_mat(fm) - conversion to / from Mat
  • fmat_matmul(a, b) - BLAS sgemm (matrix multiply)
  • fmat_svd / fmat_eig / fmat_cholesky / fmat_qr / fmat_det / fmat_lstsq - LAPACK
  • fmat_inv / fmat_solve - LU-based linear solve

#LapackMat: Accelerate vDSP element-wise + reductions (SIMD)

Zero-copy SIMD via Apple Accelerate's vDSP. ~10-30x faster than the equivalent scalar implementation on the same storage:

  • fmat_add / fmat_sub / fmat_mul / fmat_div - element-wise binary ops
  • fmat_add_into / etc. - in-place variants (no allocation)
  • fmat_add_scalar / fmat_mul_scalar - broadcast scalar ops
  • fmat_sum / fmat_mean / fmat_max / fmat_min - reductions

Note: the equivalent ops on the Array[Float]-backed Vec / Mat types stay scalar by default. MoonBit's C FFI requires the buffer to be FixedArray[Byte], and the Array[Float] -> bytes round-trip cost erases the SIMD win even at N = 1M+. For hot inner loops, convert once with fmat_from_mat and stay on LapackMat.

#License

Apache-2.0

#
LapackMat

source
pub struct LapackMat {
  data : FixedArray[Byte]
  rows : Int
  cols : Int
}

Matrix type optimized for LAPACK operations (SVD, eigenvalues, etc).

Uses FixedArray[Byte] for zero-copy interop with C LAPACK functions. Convert from Mat using fmat_from_mat, back to Mat using fmat_to_mat.

#
Mat

source
pub struct Mat {
  data : Array[Float]
  rows : Int
  cols : Int
}

impl Add for Mat
impl Div for Mat
impl Mul for Mat
impl Neg for Mat
impl Sub for Mat

#
Mat::matmul

source
fn Mat::matmul(self : Mat, other : Mat) -> Mat

Matrix multiplication method: self @ other

Example: let c = a.matmul(b) is equivalent to mat_matmul(a, b)

#
Vec

source
pub struct Vec {
  data : Array[Float]
  offset : Int
  len : Int
}

impl Add for Vec
impl Div for Vec
impl Mul for Vec
impl Neg for Vec
impl Sub for Vec

#
batch_matmul

source
fn batch_matmul(input : Array[Float], weight : Array[Float], out : Array[Float], batch : Int, in_dim : Int, out_dim : Int) -> Unit

Batch matrix multiply using BLAS sgemm: Out = Input @ Weight Input: batch x in_dim, Weight: in_dim x out_dim, Out: batch x out_dim

#
batch_matmul_bias

source
fn batch_matmul_bias(input : Array[Float], weight : Array[Float], bias : Array[Float], out : Array[Float], batch : Int, in_dim : Int, out_dim : Int) -> Unit

Batch matrix multiply + bias

#
batch_matmul_bias_relu

source
fn batch_matmul_bias_relu(input : Array[Float], weight : Array[Float], bias : Array[Float], out : Array[Float], batch : Int, in_dim : Int, out_dim : Int) -> Unit

Batch matrix multiply + bias + ReLU

#
cross_entropy_loss

source
fn cross_entropy_loss(probs : Vec, label : Int) -> Float

#
fmat_add

source
fn fmat_add(a : LapackMat, b : LapackMat) -> LapackMat

LapackMat add (C = A + B), backed by Accelerate vDSP_vadd. Zero-copy: FixedArray[Byte] storage is passed directly to the SIMD path.

#
fmat_add_into

source
fn fmat_add_into(a : LapackMat, b : LapackMat, out~ : LapackMat) -> Unit

In-place fmat add: out = a + b (zero allocation).

#
fmat_add_scalar

source
fn fmat_add_scalar(a : LapackMat, scalar : Float) -> LapackMat

Scalar add: out[i] = a[i] + scalar (Accelerate vDSP_vsadd).

#
fmat_cholesky

source
fn fmat_cholesky(a : LapackMat) -> LapackMat?

Cholesky decomposition: A = L @ L^T Returns lower triangular L or None if failed Note: input matrix must be symmetric positive definite

#
fmat_clone

source
fn fmat_clone(fm : LapackMat) -> LapackMat

#
fmat_cols

source
fn fmat_cols(fm : LapackMat) -> Int

#
fmat_det

source
fn fmat_det(a : LapackMat) -> Float?

Compute determinant of square matrix Returns determinant or None if failed

#
fmat_div

source
fn fmat_div(a : LapackMat, b : LapackMat) -> LapackMat

LapackMat element-wise div: C[i,j] = A[i,j] / B[i,j] (Accelerate vDSP_vdiv).

#
fmat_div_into

source
fn fmat_div_into(a : LapackMat, b : LapackMat, out~ : LapackMat) -> Unit

#
fmat_eig

source
fn fmat_eig(a : LapackMat) -> (Vec, LapackMat)?

Eigenvalue decomposition for symmetric matrix Returns (eigenvalues, eigenvectors) or None if failed Note: input matrix must be symmetric

#
fmat_eye

source
fn fmat_eye(n : Int) -> LapackMat

Create LapackMat identity matrix

#
fmat_from_mat

source
fn fmat_from_mat(m : Mat) -> LapackMat

#
fmat_inv

source
fn fmat_inv(fm : LapackMat) -> Bool

Matrix inverse on LapackMat (in-place, returns success)

#
fmat_lstsq

source
fn fmat_lstsq(a : LapackMat, b : Vec) -> Vec?

Least squares solution: minimize ||A @ x - b|| Returns solution x or None if failed

#
fmat_matmul

source
fn fmat_matmul(a : LapackMat, b : LapackMat) -> LapackMat

#
fmat_max

source
fn fmat_max(a : LapackMat) -> Float

Max of all elements (Accelerate vDSP_maxv).

#
fmat_mean

source
fn fmat_mean(a : LapackMat) -> Float

Mean of all elements (Accelerate vDSP_meanv).

#
fmat_min

source
fn fmat_min(a : LapackMat) -> Float

Min of all elements (Accelerate vDSP_minv).

#
fmat_mul

source
fn fmat_mul(a : LapackMat, b : LapackMat) -> LapackMat

LapackMat element-wise mul: C[i,j] = A[i,j] * B[i,j] (Accelerate vDSP_vmul). Not matrix-matrix multiply; for that use fmat_matmul.

#
fmat_mul_into

source
fn fmat_mul_into(a : LapackMat, b : LapackMat, out~ : LapackMat) -> Unit

#
fmat_mul_scalar

source
fn fmat_mul_scalar(a : LapackMat, scalar : Float) -> LapackMat

Scalar mul: out[i] = a[i] * scalar (Accelerate vDSP_vsmul).

#
fmat_qr

source
fn fmat_qr(a : LapackMat) -> (LapackMat, LapackMat)?

QR decomposition: A = Q @ R Returns (Q, R) or None if failed

#
fmat_randn

source
fn fmat_randn(rows : Int, cols : Int) -> LapackMat

Create LapackMat from random values

#
fmat_rows

source
fn fmat_rows(fm : LapackMat) -> Int

#
fmat_solve

source
fn fmat_solve(a : LapackMat, b : FixedArray[Byte]) -> Bool

Solve A @ x = b on LapackMat (modifies both a and b in-place) After call, b contains solution x

#
fmat_sub

source
fn fmat_sub(a : LapackMat, b : LapackMat) -> LapackMat

LapackMat sub: C = A - B (Accelerate vDSP_vsub).

#
fmat_sub_into

source
fn fmat_sub_into(a : LapackMat, b : LapackMat, out~ : LapackMat) -> Unit

#
fmat_sum

source
fn fmat_sum(a : LapackMat) -> Float

Sum of all elements (Accelerate vDSP_sve).

#
fmat_svd

source
fn fmat_svd(a : LapackMat) -> (LapackMat, Vec, LapackMat)?

SVD decomposition: A = U @ diag(S) @ Vt Returns (U, S, Vt) or None if failed

#
fmat_to_mat

source
fn fmat_to_mat(fm : LapackMat) -> Mat

#
fmat_transpose

source
fn fmat_transpose(a : LapackMat) -> LapackMat

LapackMat transpose

#
fmat_zeros

source
fn fmat_zeros(rows : Int, cols : Int) -> LapackMat

#
mat_add

source
fn mat_add(a : Mat, b : Mat) -> Mat

#
mat_add_into

source
fn mat_add_into(a : Mat, b : Mat, output~ : Mat) -> Unit

Element-wise matrix addition: output[i,j] = a[i,j] + b[i,j]

#
mat_add_scalar

source
fn mat_add_scalar(mat : Mat, scalar : Float) -> Mat

#
mat_allclose

source
fn mat_allclose(a : Mat, b : Mat, atol : Float) -> Bool

Check if all elements are equal within tolerance

#
mat_at

source
fn mat_at(mat : Mat, row : Int, col : Int) -> Float

#
mat_clone

source
fn mat_clone(mat : Mat) -> Mat

#
mat_cols

source
fn mat_cols(mat : Mat) -> Int

#
mat_diag

source
fn mat_diag(m : Mat) -> Vec

Extract diagonal elements from matrix

#
mat_div

source
fn mat_div(a : Mat, b : Mat) -> Mat

#
mat_div_into

source
fn mat_div_into(a : Mat, b : Mat, output~ : Mat) -> Unit

Element-wise matrix division: output[i,j] = a[i,j] / b[i,j]

#
mat_div_scalar

source
fn mat_div_scalar(mat : Mat, scalar : Float) -> Mat

#
mat_eye

source
fn mat_eye(n : Int) -> Mat

#
mat_fill

source
fn mat_fill(mat : Mat, value : Float) -> Unit

@deprecated Use mat_fill_inplace instead.

#
mat_fill_inplace

source
fn mat_fill_inplace(mat : Mat, value : Float) -> Unit

Fill all elements with a constant value (in-place modification).

#
mat_flatten

source
fn mat_flatten(mat : Mat) -> Vec

Flatten mat to vec (row-major order)

#
mat_hstack

source
fn mat_hstack(mats : Array[Mat]) -> Mat

Horizontal stack: stack matrices along columns (axis=1)

#
mat_inv

source
fn mat_inv(m : Mat) -> Mat?

Matrix inverse using LAPACK sgetrf/sgetri Returns None if matrix is singular

#
mat_matmul

source
fn mat_matmul(a : Mat, b : Mat) -> Mat

Matrix multiplication using BLAS: C = A @ B

Equivalent to NumPy's @ operator or np.matmul. Requires: a.cols == b.rows

#
mat_max

source
fn mat_max(mat : Mat) -> Float

Max of all elements

#
mat_mean

source
fn mat_mean(mat : Mat) -> Float

Mean of all elements

#
mat_mean_axis0

source
fn mat_mean_axis0(mat : Mat) -> Vec

Mean along axis 0

#
mat_mean_axis1

source
fn mat_mean_axis1(mat : Mat) -> Vec

Mean along axis 1

#
mat_min

source
fn mat_min(mat : Mat) -> Float

Min of all elements

#
mat_mul

source
fn mat_mul(a : Mat, b : Mat) -> Mat

#
mat_mul_into

source
fn mat_mul_into(a : Mat, b : Mat, output~ : Mat) -> Unit

Element-wise matrix multiplication: output[i,j] = a[i,j] * b[i,j]

#
mat_mul_scalar

source
fn mat_mul_scalar(mat : Mat, scalar : Float) -> Mat

#
mat_neg

source
fn mat_neg(mat : Mat) -> Mat

#
mat_new

source
fn mat_new(rows : Int, cols : Int, value : Float) -> Mat

#
mat_ones

source
fn mat_ones(rows : Int, cols : Int) -> Mat

#
mat_rand

source
fn mat_rand(rows : Int, cols : Int) -> Mat

Generate matrix of uniform random values in [0, 1)

#
mat_randn

source
fn mat_randn(rows : Int, cols : Int) -> Mat

Generate matrix of standard normal random values

#
mat_row

source
fn mat_row(mat : Mat, row : Int) -> Vec

Get row as Vec (view into original data)

#
mat_rows

source
fn mat_rows(mat : Mat) -> Int

#
mat_scale_inplace

source
fn mat_scale_inplace(mat : Mat, scalar : Float) -> Unit

#
mat_set

source
fn mat_set(mat : Mat, row : Int, col : Int, value : Float) -> Unit

#
mat_solve

source
fn mat_solve(a : Mat, b : Vec) -> Vec?

Solve linear system A @ x = b using LAPACK sgesv Returns None if system is singular

#
mat_sub

source
fn mat_sub(a : Mat, b : Mat) -> Mat

#
mat_sub_into

source
fn mat_sub_into(a : Mat, b : Mat, output~ : Mat) -> Unit

Element-wise matrix subtraction: output[i,j] = a[i,j] - b[i,j]

#
mat_sub_scalar

source
fn mat_sub_scalar(mat : Mat, scalar : Float) -> Mat

#
mat_sum

source
fn mat_sum(mat : Mat) -> Float

Sum of all elements

#
mat_sum_axis0

source
fn mat_sum_axis0(mat : Mat) -> Vec

Sum along axis 0 (columns): result[j] = sum_i(mat[i,j])

#
mat_sum_axis1

source
fn mat_sum_axis1(mat : Mat) -> Vec

Sum along axis 1 (rows): result[i] = sum_j(mat[i,j])

#
mat_tile

source
fn mat_tile(m : Mat, rows_repeat : Int, cols_repeat : Int) -> Mat

Tile matrix: repeat along rows and columns

#
mat_to_array

source
fn mat_to_array(mat : Mat) -> Array[Float]

#
mat_trace

source
fn mat_trace(m : Mat) -> Float

Trace of matrix (sum of diagonal elements)

#
mat_transpose

source
fn mat_transpose(mat : Mat) -> Mat

Transpose matrix (creates new matrix)

#
mat_view

source
fn mat_view(data : Array[Float], rows : Int, cols : Int) -> Mat

#
mat_vstack

source
fn mat_vstack(mats : Array[Mat]) -> Mat

Vertical stack: stack matrices along rows (axis=0)

#
mat_zeros

source
fn mat_zeros(rows : Int, cols : Int) -> Mat

#
matmul_vec_bias_blas_into

source
fn matmul_vec_bias_blas_into(weight : Mat, input : Vec, bias : Vec, output~ : Vec) -> Unit

Matrix-vector multiply + bias using BLAS: output = weight^T @ input + bias

Uses Accelerate framework's BLAS for optimal performance.

#
matmul_vec_bias_into

source
fn matmul_vec_bias_into(weight : Mat, input : Vec, bias : Vec, output~ : Vec) -> Unit

Matrix-vector multiply with bias: output = weight^T @ input + bias

Parameters:
  • weight: Matrix of shape (in_dim, out_dim)
  • input: Input vector of length in_dim
  • bias: Bias vector of length out_dim
  • output: Output buffer of length out_dim

Computes: output[j] = bias[j] + sum_i(input[i] * weight[i, j])

#
matmul_vec_bias_relu_blas_into

source
fn matmul_vec_bias_relu_blas_into(weight : Mat, input : Vec, bias : Vec, output~ : Vec) -> Unit

Matrix-vector multiply + bias + ReLU using BLAS

Computes: output = relu(weight^T @ input + bias) Uses Accelerate framework's BLAS for optimal performance.

#
matmul_vec_bias_relu_into

source
fn matmul_vec_bias_relu_into(weight : Mat, input : Vec, bias : Vec, output~ : Vec) -> Unit

Matrix-vector multiply with bias and ReLU: output = relu(weight^T @ input + bias)

Parameters:
  • weight: Matrix of shape (in_dim, out_dim)
  • input: Input vector of length in_dim
  • bias: Bias vector of length out_dim
  • output: Output buffer of length out_dim

Computes: output[j] = max(0, bias[j] + sum_i(input[i] * weight[i, j]))

#
matmul_vec_blas_into

source
fn matmul_vec_blas_into(weight : Mat, input : Vec, output~ : Vec) -> Unit

Matrix-vector multiply using BLAS sgemv: output = weight^T @ input

Uses Accelerate framework's BLAS for optimal performance.

#
matmul_vec_into

source
fn matmul_vec_into(weight : Mat, input : Vec, output~ : Vec) -> Unit

Matrix-vector multiply: output = weight^T @ input

Parameters:
  • weight: Matrix of shape (in_dim, out_dim)
  • input: Input vector of length in_dim
  • output: Output buffer of length out_dim

Computes: output[j] = sum_i(input[i] * weight[i, j])

#
random_seed

source
fn random_seed(seed : Int) -> Unit

Set random seed

#
relu

source
fn relu(value : Float) -> Float

#
relu_grad

source
fn relu_grad(value : Float) -> Float

#
softmax_into

source
fn softmax_into(input~ : Vec, output~ : Vec) -> Unit

Compute softmax probabilities from logits (writes to output buffer).

Parameters:
  • input: Raw logits (unnormalized scores)
  • output: Output buffer for normalized probabilities (same length as input)

The softmax is computed with numerical stability (subtracting max). Result: output[i] = exp(input[i] - max) / sum(exp(input - max))

#
vec_abs

source
fn vec_abs(input : Vec) -> Vec

#
vec_abs_into

source
fn vec_abs_into(input : Vec, output~ : Vec) -> Unit

Element-wise absolute value: output[i] = |input[i]|

#
vec_add

source
fn vec_add(left : Vec, right : Vec) -> Vec

#
vec_add_into

source
fn vec_add_into(left : Vec, right : Vec, output~ : Vec) -> Unit

Element-wise addition: output[i] = left[i] + right[i]

#
vec_add_scalar

source
fn vec_add_scalar(vec : Vec, scalar : Float) -> Vec

Add scalar to all elements: out = vec + scalar

#
vec_add_scalar_inplace

source
fn vec_add_scalar_inplace(vec : Vec, scalar : Float) -> Unit

In-place add scalar: vec = vec + scalar

#
vec_all

source
fn vec_all(v : Vec) -> Bool

Returns true if all elements are non-zero (truthy)

#
vec_allclose

source
fn vec_allclose(a : Vec, b : Vec, atol : Float) -> Bool

Check if all elements are equal within tolerance

#
vec_any

source
fn vec_any(v : Vec) -> Bool

Returns true if any element is non-zero (truthy)

#
vec_arange

source
fn vec_arange(start : Float, stop : Float, step : Float) -> Vec

Create vec like numpy.arange: [start, stop) with step

#
vec_argmax

source
fn vec_argmax(vec : Vec) -> Int

#
vec_argmin

source
fn vec_argmin(vec : Vec) -> Int

#
vec_argsort

source
fn vec_argsort(v : Vec) -> Array[Int]

Return indices that would sort the vector (ascending)

#
vec_argsort_desc

source
fn vec_argsort_desc(v : Vec) -> Array[Int]

Return indices that would sort the vector (descending)

#
vec_at

source
fn vec_at(vec : Vec, index : Int) -> Float

#
vec_axpy

source
fn vec_axpy(alpha : Float, x : Vec, y : Vec) -> Unit

AXPY: y = α*x + y

#
vec_ceil

source
fn vec_ceil(input : Vec) -> Vec

#
vec_ceil_into

source
fn vec_ceil_into(input : Vec, output~ : Vec) -> Unit

Element-wise ceiling: output[i] = ceil(input[i])

#
vec_clip

source
fn vec_clip(input : Vec, min : Float, max : Float) -> Vec

#
vec_clip_into

source
fn vec_clip_into(input : Vec, min : Float, max : Float, output~ : Vec) -> Unit

Clip values to [min, max] range: output[i] = clamp(input[i], min, max)

#
vec_concatenate

source
fn vec_concatenate(vecs : Array[Vec]) -> Vec

Concatenate multiple vectors into one

#
vec_cos

source
fn vec_cos(input : Vec) -> Vec

#
vec_cos_into

source
fn vec_cos_into(input : Vec, output~ : Vec) -> Unit

Element-wise cosine: output[i] = cos(input[i])

#
vec_cumprod

source
fn vec_cumprod(v : Vec) -> Vec

Cumulative product: out[i] = prod(v[0..i+1])

#
vec_cumsum

source
fn vec_cumsum(v : Vec) -> Vec

Cumulative sum: out[i] = sum(v[0..i+1])

#
vec_diag

source
fn vec_diag(v : Vec) -> Mat

Create diagonal matrix from vector

#
vec_diff

source
fn vec_diff(v : Vec) -> Vec

Difference between consecutive elements: out[i] = v[i+1] - v[i]

#
vec_div

source
fn vec_div(left : Vec, right : Vec) -> Vec

#
vec_div_into

source
fn vec_div_into(left : Vec, right : Vec, output~ : Vec) -> Unit

Element-wise division: output[i] = left[i] / right[i]

#
vec_div_scalar

source
fn vec_div_scalar(vec : Vec, scalar : Float) -> Vec

Divide all elements by scalar: out = vec / scalar

#
vec_div_scalar_inplace

source
fn vec_div_scalar_inplace(vec : Vec, scalar : Float) -> Unit

In-place div scalar: vec = vec / scalar

#
vec_dot

source
fn vec_dot(x : Vec, y : Vec) -> Float

Dot product: x · y

#
vec_exp

source
fn vec_exp(input : Vec) -> Vec

Uses vvexpf from Accelerate framework for optimal performance

#
vec_exp_into

source
fn vec_exp_into(output~ : Vec, input : Vec) -> Unit

Element-wise exponential: output[i] = exp(input[i])

Note: For BLAS-accelerated version, use vec_exp which uses vvexpf.

#
vec_fill

source
fn vec_fill(vec : Vec, value : Float) -> Unit

@deprecated Use vec_fill_inplace instead.

#
vec_fill_inplace

source
fn vec_fill_inplace(vec : Vec, value : Float) -> Unit

Fill all elements with a constant value (in-place modification).

Example: vec_fill_inplace(v, 0.0) sets all elements to zero.

#
vec_floor

source
fn vec_floor(input : Vec) -> Vec

#
vec_floor_into

source
fn vec_floor_into(input : Vec, output~ : Vec) -> Unit

Element-wise floor: output[i] = floor(input[i])

#
vec_from_array

source
fn vec_from_array(data : Array[Float]) -> Vec

#
vec_from_fn

source
fn vec_from_fn(len : Int, f : (Int) -> Float) -> Vec

Create vec from initializer function: out[i] = f(i)

#
vec_ge

source
fn vec_ge(v : Vec, threshold : Float) -> Vec

Element-wise greater than or equal

#
vec_gt

source
fn vec_gt(v : Vec, threshold : Float) -> Vec

Element-wise greater than: out[i] = 1.0 if v[i] > threshold else 0.0

#
vec_has_inf

source
fn vec_has_inf(v : Vec) -> Bool

Check if any element is infinite

#
vec_has_nan

source
fn vec_has_nan(v : Vec) -> Bool

Check if any element is NaN

#
vec_le

source
fn vec_le(v : Vec, threshold : Float) -> Vec

Element-wise less than or equal

#
vec_len

source
fn vec_len(vec : Vec) -> Int

#
vec_linspace

source
fn vec_linspace(start : Float, stop : Float, num : Int) -> Vec

Create vec like numpy.linspace: num evenly spaced values in [start, stop]

#
vec_log

source
fn vec_log(input : Vec) -> Vec

#
vec_log_into

source
fn vec_log_into(output~ : Vec, input : Vec) -> Unit

Element-wise natural logarithm: output[i] = ln(input[i])

#
vec_lt

source
fn vec_lt(v : Vec, threshold : Float) -> Vec

Element-wise less than

#
vec_max

source
fn vec_max(vec : Vec) -> Float

#
vec_maximum

source
fn vec_maximum(a : Vec, b : Vec) -> Vec

#
vec_maximum_into

source
fn vec_maximum_into(a : Vec, b : Vec, output~ : Vec) -> Unit

Element-wise maximum of two vectors: output[i] = max(a[i], b[i])

#
vec_mean

source
fn vec_mean(vec : Vec) -> Float

#
vec_median

source
fn vec_median(v : Vec) -> Float

Median of vector elements

#
vec_min

source
fn vec_min(vec : Vec) -> Float

#
vec_minimum

source
fn vec_minimum(a : Vec, b : Vec) -> Vec

#
vec_minimum_into

source
fn vec_minimum_into(a : Vec, b : Vec, output~ : Vec) -> Unit

Element-wise minimum of two vectors: output[i] = min(a[i], b[i])

#
vec_mul

source
fn vec_mul(left : Vec, right : Vec) -> Vec

#
vec_mul_into

source
fn vec_mul_into(left : Vec, right : Vec, output~ : Vec) -> Unit

Element-wise multiplication: output[i] = left[i] * right[i]

#
vec_mul_scalar

source
fn vec_mul_scalar(vec : Vec, scalar : Float) -> Vec

Multiply all elements by scalar: out = vec * scalar

#
vec_mul_scalar_inplace

source
fn vec_mul_scalar_inplace(vec : Vec, scalar : Float) -> Unit

In-place mul scalar: vec = vec * scalar

#
vec_neg

source
fn vec_neg(input : Vec) -> Vec

Negate all elements: out = -input

#
vec_neg_inplace

source
fn vec_neg_inplace(vec : Vec) -> Unit

In-place negate: vec = -vec

#
vec_new

source
fn vec_new(len : Int, value : Float) -> Vec

#
vec_nonzero

source
fn vec_nonzero(v : Vec) -> Array[Int]

Return indices of non-zero elements

#
vec_nrm2

source
fn vec_nrm2(x : Vec) -> Float

L2 norm: ||x||_2

#
vec_ones

source
fn vec_ones(len : Int) -> Vec

#
vec_outer

source
fn vec_outer(a : Vec, b : Vec) -> Mat

Outer product: out[i,j] = a[i] * b[j] Uses BLAS sger from Accelerate framework for optimal performance

#
vec_percentile

source
fn vec_percentile(v : Vec, p : Float) -> Float

Percentile (0-100) of vector elements

#
vec_pow

source
fn vec_pow(input : Vec, exp : Float) -> Vec

#
vec_pow_into

source
fn vec_pow_into(input : Vec, exp : Float, output~ : Vec) -> Unit

Element-wise power: output[i] = input[i]^exp

#
vec_prod

source
fn vec_prod(vec : Vec) -> Float

Product of all elements

#
vec_quantile

source
fn vec_quantile(v : Vec, q : Float) -> Float

Quantile (0-1) of vector elements

#
vec_rand

source
fn vec_rand(n : Int) -> Vec

Generate vector of uniform random values in [0, 1)

#
vec_randn

source
fn vec_randn(n : Int) -> Vec

Generate vector of standard normal random values (mean=0, std=1)

#
vec_repeat

source
fn vec_repeat(v : Vec, n : Int) -> Vec

Repeat vector n times

#
vec_reshape

source
fn vec_reshape(v : Vec, rows : Int, cols : Int) -> Mat

Reshape vec to mat (must have matching element count)

#
vec_round

source
fn vec_round(input : Vec) -> Vec

#
vec_round_into

source
fn vec_round_into(input : Vec, output~ : Vec) -> Unit

Element-wise rounding: output[i] = round(input[i])

#
vec_scale_inplace

source
fn vec_scale_inplace(vec : Vec, scale : Float) -> Unit

Multiply all elements by a scalar (in-place modification).

Example: vec_scale_inplace(v, 2.0) doubles all elements.

#
vec_searchsorted

source
fn vec_searchsorted(sorted : Vec, value : Float) -> Int

Binary search: find insertion point for value in sorted vector Returns index where value should be inserted to maintain sorted order

#
vec_searchsorted_right

source
fn vec_searchsorted_right(sorted : Vec, value : Float) -> Int

Binary search (right): find rightmost insertion point

#
vec_set

source
fn vec_set(vec : Vec, index : Int, value : Float) -> Unit

#
vec_shuffle

source
fn vec_shuffle(v : Vec) -> Vec

Shuffle vector elements in place

#
vec_sign

source
fn vec_sign(input : Vec) -> Vec

#
vec_sign_into

source
fn vec_sign_into(input : Vec, output~ : Vec) -> Unit

Element-wise sign: -1 for negative, 0 for zero, 1 for positive

#
vec_sin

source
fn vec_sin(input : Vec) -> Vec

#
vec_sin_into

source
fn vec_sin_into(input : Vec, output~ : Vec) -> Unit

Element-wise sine: output[i] = sin(input[i])

#
vec_slice

source
fn vec_slice(v : Vec, start : Int, end : Int) -> Vec

Create a slice of vec [start, end)

#
vec_sort

source
fn vec_sort(v : Vec) -> Vec

Sort vector in ascending order (returns new vector) Uses vDSP_vsort from Accelerate framework for optimal performance

#
vec_sort_desc

source
fn vec_sort_desc(v : Vec) -> Vec

Sort vector in descending order (returns new vector) Uses vDSP_vsort from Accelerate framework for optimal performance

#
vec_sqrt

source
fn vec_sqrt(input : Vec) -> Vec

#
vec_sqrt_into

source
fn vec_sqrt_into(input : Vec, output~ : Vec) -> Unit

Element-wise square root: output[i] = sqrt(input[i])

#
vec_std

source
fn vec_std(vec : Vec) -> Float

Standard deviation: sqrt(variance)

#
vec_sub

source
fn vec_sub(left : Vec, right : Vec) -> Vec

#
vec_sub_into

source
fn vec_sub_into(left : Vec, right : Vec, output~ : Vec) -> Unit

Element-wise subtraction: output[i] = left[i] - right[i]

#
vec_sub_scalar

source
fn vec_sub_scalar(vec : Vec, scalar : Float) -> Vec

Subtract scalar from all elements: out = vec - scalar

#
vec_sub_scalar_inplace

source
fn vec_sub_scalar_inplace(vec : Vec, scalar : Float) -> Unit

In-place sub scalar: vec = vec - scalar

#
vec_sum

source
fn vec_sum(vec : Vec) -> Float

#
vec_tanh

source
fn vec_tanh(input : Vec) -> Vec

#
vec_tanh_into

source
fn vec_tanh_into(input : Vec, output~ : Vec) -> Unit

Element-wise hyperbolic tangent: output[i] = tanh(input[i])

#
vec_to_array

source
fn vec_to_array(vec : Vec) -> Array[Float]

#
vec_unique

source
fn vec_unique(v : Vec) -> Vec

Return sorted unique elements

#
vec_var

source
fn vec_var(vec : Vec) -> Float

Variance: E[(X - mean)^2]

#
vec_view

source
fn vec_view(data : Array[Float], offset : Int, len : Int) -> Vec

#
vec_where

source
fn vec_where(mask : Vec, x : Vec, y : Vec) -> Vec

Select elements based on mask: out[i] = x[i] if mask[i] > 0 else y[i]

#
vec_where_scalar

source
fn vec_where_scalar(mask : Vec, x : Vec, y : Float) -> Vec

Select elements based on mask with scalar fallback

#
vec_zeros

source
fn vec_zeros(len : Int) -> Vec

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io