#moonNum — NumPy for Moonbit

Multi-dimensional arrays, linear algebra, FFT, random numbers, polynomials, masked arrays, datetime — a complete reimplementation of NumPy 2.x public API surface in Moonbit.

#Overview

#Key Features

• NdArray — NumPy-compatible n-dimensional array backed by a contiguous byte buffer with dtype/shape/strides/offset metadata; supports zero-copy views (transpose / reshape / slice share the same buffer)
• Full dtype system — Bool / Int8–Int64 / Uint8–Uint64 / Float16–Float64 / Complex64 / Complex128 / Str_ / Datetime64 / TimeDelta64
• Element-wise ufuncs — add / subtract / multiply / divide / sin / cos / exp / log … 80+ functions with broadcasting
• Linear algebra — matmul / inv / solve / det / svd / qr / cholesky / eig / lstsq / norm …
• FFT — fft / ifft / rfft / irfft / fft2 / ifft2 / fftn / ifftn / hfft / ihfft / fftfreq / fftshift …
• Random numbers — MT19937 bit generator + uniform / normal / exponential / Poisson / binomial / gamma / beta / chi-square / Dirichlet and 30+ more distributions
• Polynomials — Polynomial / Chebyshev / Legendre / Hermite / HermiteE / Laguerre orthogonal basis classes with PolyBase trait, 2D/3D/ND evaluation, Vandermonde matrices, Gauss nodes, fitting, and root-finding
• Masked arrays — Full MaskedArray implementation with mask propagation, construction utilities, interval statistics, exception types, mvoid / mr_ indexer
• Character arrays — String element-wise operations: comparison / concatenation / case / split / replace / translate / classification …
• Date & time — datetime64 / timedelta64 (ISO 8601 parsing), business-day utilities (is_busday / busday_offset / busday_count / busdaycalendar)
• IO — .npy / .npz read-write, savez / loadz, in-memory serialization
• Type system — numpy.typing equivalents (ArrayLike / DTypeLike / NDArray) expressed as traits
• Matrix library — matrixlib.Matrix class (matrix multiply / inverse / transpose / flatten)

#Installation

{
  "import": {
    "amor2025/moonNum": {
      "path": "moonNum",
      "rev": "..."
    }
  }
}

moon add amor2025/moonNum

#Quick Start

#Creating Arrays

import @amor2025/moonNum/src/core
import @amor2025/moonNum/src/dtypes

// From a list
let a = @core.array(
  [Scalar::Int(1L), Scalar::Int(2L), Scalar::Int(3L)],
  [3],
)

// Zeros / identity
let z = @core.zeros([2, 3], dtype=@dtypes.float64)
let e = @core.eye(3, dtype=@dtypes.float64)

// Range sequences
let r = @core.arange_double(start=0.0, stop=1.0, step=0.25)  // [0.0, 0.25, 0.5, 0.75]
let l = @core.linspace(0.0, 1.0, num=5)                      // [0.0, 0.25, 0.5, 0.75, 1.0]

#Arithmetic & Broadcasting

let a = @core.array([Scalar::Float(1.0), Scalar::Float(2.0), Scalar::Float(3.0)], [3])
let b = @core.array([Scalar::Float(10.0), Scalar::Float(20.0), Scalar::Float(30.0)], [3])

let c = @core.add(a, b)       // [11.0, 22.0, 33.0]
let d = @core.multiply(a, b)  // [10.0, 40.0, 90.0]

// Broadcasting: scalar + array
let e = @core.add(a, @core.array([Scalar::Float(100.0)], [1]))  // [101.0, 102.0, 103.0]

#Linear Algebra

import @amor2025/moonNum/src/linalg

let m = @core.array(
  [Scalar::Float(1.0), Scalar::Float(2.0),
   Scalar::Float(3.0), Scalar::Float(4.0)],
  [2, 2],
)

let inv_m = @linalg.inv(m)           // matrix inverse
let det_m = @linalg.det(m)           // determinant
let matmul_m = @linalg.matmul(m, m)  // matrix multiplication

#FFT

import @amor2025/moonNum/src/fft

let signal = @core.array(
  [Scalar::Float(1.0), Scalar::Float(0.0), Scalar::Float(0.0), Scalar::Float(0.0)],
  [4],
)

let spectrum = @fft.fft(signal)     // forward transform
let recovered = @fft.ifft(spectrum)  // inverse transform

#Random Numbers

import @amor2025/moonNum/src/random

let rng = @random.default_rng()                        // MT19937 generator
let uniform_samples = rng.uniform(0.0, 1.0, size=[5])  // 5 uniform [0,1) samples
let normal_samples = rng.normal(0.0, 1.0, size=[5])    // 5 standard normal samples

#Polynomials

import @amor2025/moonNum/src/polynomial

// Fit with Chebyshev polynomials
let x = @core.array([Scalar::Float(0.0), Scalar::Float(1.0), Scalar::Float(2.0)], [3])
let y = @core.array([Scalar::Float(1.0), Scalar::Float(3.0), Scalar::Float(7.0)], [3])
let p = @polynomial.Chebyshev::fit(x, y, 2)  // degree-2 Chebyshev fit

// Evaluate: call takes an NdArray
let eval_point = @core.array([Scalar::Float(0.5)], [1])
let val = p.call(eval_point)

#Masked Arrays

import @amor2025/moonNum/src/ma

let data = @core.array([Scalar::Float(1.0), Scalar::Float(2.0), Scalar::Float(3.0)], [3])
let mask = @core.array(
  [Scalar::Bool(false), Scalar::Bool(true), Scalar::Bool(false)], [3],
)
let masked = @ma.masked_array(data, mask=mask)

let total = @ma.sum(masked)  // 1.0 + 3.0 = 4.0 (skips masked elements)

#Module Reference

#Package Dependency Graph

dtypes (no deps)           constants (no deps)
    │                           │
    ├── core ───────────────────┤
    │     │                     │
    │     ├── linalg ───────────┤
    │     │     │               │
    │     │     ├── polynomial
    │     │     ├── ma
    │     │     └── matrixlib
    │     │                     │
    │     ├── fft               │
    │     ├── random            │
    │     ├── char              │
    │     ├── io                │
    │     ├── datetime          │
    │     ├── typing            │
    │     └── lib               │
    │                           │
    └── exceptions ─────────────┘

#Differences from NumPy

#Naming Differences

#Type System Differences

• No cross-package type aliases: Moonbit does not support cross-package type alias, so numpy.typing.ArrayLike / DTypeLike / NDArray are expressed as traits + conversion functions instead
• Dtype enum: NumPy's dynamic dtype system is represented as a Dtype enum in Moonbit (Bool / Int8 … / Float64 / Complex128 / Str_ / Datetime64 / TimeDelta64)
• Scalar type: NumPy scalars are carried as a Scalar enum in Moonbit (Int / Float / Complex / Bool / Str / …)

#Out of Scope

• numpy.f2py (Fortran-to-Python interface generator)
• numpy.ctypeslib (Python ctypes interop)
• numpy.matlib (deprecated)
• numpy.testing (pytest-style assertions; Moonbit has its own assert system)
• Python reflection/decorator APIs (frompyfunc / add_newdoc / info / NumpyVersion / Arrayterator)
• Python-side abstract base classes (recarray / record / void / character / flexible / inexact / number / generic)

#Testing

# Run all tests
moon test

# Generate coverage report
moon test --enable-coverage
moon coverage report -f summary

• Total tests: 3541
• Coverage: 91.31% (16959/18574 lines)
• moon check: 0 errors, 16 warnings

#Documentation

moon doc --target-dir docs

#Build

# Type check
moon check

# Build
moon build

# Run tests
moon test

#License

#Acknowledgments

• NumPy — The original project; all API design and algorithm implementations are based on it
• Moonbit — The implementation language for this library