-
num-traits
Numeric traits for generic mathematics
-
statrs
Statistical computing library for Rust
-
kurbo
A 2D curves library
-
euclid
Geometry primitives
-
matrixmultiply
General matrix multiplication for f32 and f64 matrices. Operates on matrices with general layout (they can use arbitrary row and column stride). Detects and uses AVX or SSE2 on x86…
-
bigdecimal
Arbitrary precision decimal numbers
-
num-bigint
Big integer implementation for Rust
-
nalgebra
General-purpose linear algebra library with transformations and statically-sized or dynamically-sized matrices
-
rug
Arbitrary-precision integers, rational, floating-point and complex numbers based on GMP, MPFR and MPC
-
ruint
Unsigned integer type with const-generic bit length
-
good_lp
Mixed Integer Linear Programming for Rust, with an user-friendly API. This crate allows modeling LP problems, and lets you solve them with various solvers.
-
uint
Large fixed-size integer arithmetic
-
bnum
Fixed-size integer types with generic signedness, bit width and overflow behaviour
-
mint
Math interoperability standard types
-
faer
linear algebra library
-
argmin
Numerical optimization in pure Rust
-
hexasphere
evenly tile hexagons on a sphere
-
parry3d-f64
3 dimensional collision detection library in Rust. 64-bits precision version.
-
kalc
a complex numbers, 2d/3d graphing, arbitrary precision, vector/matrix, cli calculator with real-time output and support for units
-
num-prime
Generic and optimized primality test, factorization and various number theoretic functions with arbitrary precision based on
num -
num-complex
Complex numbers implementation for Rust
-
rapier3d
3-dimensional physics engine in Rust
-
openblas-src
The package provides a source of BLAS and LAPACK via OpenBLAS
-
noisy_float
Contains floating point types that panic if they are set to an illegal value, such as NaN
-
num-dual
Generalized (hyper) dual numbers for the calculation of exact (partial) derivatives
-
common_traits
Traits to write generic functions on different numeric types, with atomic support, and other features
-
peroxide
Rust comprehensive scientific computation library contains linear algebra, numerical analysis, statistics and machine learning tools with farmiliar syntax
-
sguaba
Hard to misuse rigid body transforms (aka "spatial math") for engineers with other things to worry about than linear algebra
-
ark-poly
efficient polynomial arithmetic via FFTs over finite fields
-
russell_lab
Scientific laboratory for linear algebra and numerical mathematics
-
fastnum
Fast decimal numbers library
-
plotpy
Rust plotting library using Python (Matplotlib)
-
lambert_w
Fast and accurate evaluation of the Lambert W function by the method of T. Fukushima.
-
num-bigint-dig
Big integer implementation for Rust
-
gauss-quad
Integrate functions with Gaussian quadrature
-
simple_moving_average
moving average (SMA) algorithms
-
ode_solvers
Numerical methods to solve ordinary differential equations (ODEs) in Rust
-
russell_sparse
Solvers for large sparse linear systems (wraps MUMPS and UMFPACK)
-
scirs2-fft
Fast Fourier Transform module for SciRS2 (scirs2-fft)
-
lambdascript
Instructional program detailing the beta reduction of typed and untyped lambda terms
-
ndhistogram
multi-dimensional histogramming for Rust
-
oxiblas-ndarray
ndarray integration for OxiBLAS
-
feanor-math
number theory, providing implementations for arithmetic in various rings and algorithms working on them
-
ellip
Elliptic integrals for Rust
-
disintegrate
build event-sourced applications
-
num-rational
Rational numbers implementation for Rust
-
diffsol
solving ordinary differential equations (ODEs) in Rust
-
ezpz
A constraint solver for KCL and Zoo Design Studio
-
libcrux-hacl-rs
Formally verified Rust code extracted from HACL* - helper library
-
malachite
Arbitrary-precision arithmetic, with efficient algorithms partially derived from GMP, FLINT, and MPFR
-
mosekcomodel
Conic Optimization Modeling with Mosek
-
cubecl
Multi-platform high-performance compute language extension for Rust
-
decimal-rs
High precision decimal implementation for Rust
-
simba
SIMD algebra for Rust
-
arrow-arith
Arrow arithmetic kernels
-
lp_parser_rs
parser for the LP file format
-
ultraviolet
do linear algebra, fast
-
feos
framework for equations of state and classical density functional theory
-
puruspe
Pure Rust Special function library
-
lua-src
Sources of Lua 5.1-5.5 and logic to build them
-
factorion-bot-discord
factorion-bot (for factorials and related) on Discord
-
math-core
Convert LaTeX equations to MathML Core
-
dec
A decimal arithmetic library providing high-level, safe bindings to libdecnumber
-
csgrs
Constructive solid geometry (CSG) on meshes using BSP trees in Rust
-
lapack
The package provides wrappers for LAPACK (Fortran)
-
num-quaternion
Quaternion numbers implementation for Rust
-
rmpfit
Pure Rust implementation of the CMPFIT library
-
ndrustfft
N-dimensional FFT, real-to-complex FFT and real-to-real DCT
-
stlrs
Seasonal-trend decomposition for Rust
-
mathypad
A smart TUI calculator that understands units and makes complex calculations simple
-
primitive_fixed_point_decimal
Primitive fixed-point decimal types
-
krabmaga
A modern developing art for reliable and efficient Agent-based Model (ABM) simulation with the Rust language
-
wedged
A robust and generalized library for Geometric Algebra in Rust
-
maths-rs
A linear algebra library for gamedev and graphics
-
deno_graph
Module graph analysis for deno
-
nuts-rs
Sample from unnormalized densities using Hamiltonian MCMC
-
ganesh
Minimization and sampling in Rust, simplified
-
quantities
Unit-safe computations with quantities
-
adic
Arithmetic and rootfinding for p-adic numbers
-
cavalier_contours
2D polyline/shape library for offsetting, combining, etc
-
clarabel
Conic Interior Point Solver for Rust / Python
-
ruvector-solver
Sublinear-time solver for RuVector: O(log n) to O(√n) algorithms for sparse linear systems, PageRank, and spectral methods
-
f256
Octuple-precision floating-point arithmetic
-
seuif97
The high-speed IAPWS-IF97 package with C and Python bindings
-
kcl-lib
KittyCAD Language implementation and tools
-
scientific
Arbitrary precision scientific number (no_std capable, in pure Rust)
-
uniform-cubic-splines
uniform cubic spline evaluation and inversion
-
minmax-cli
programs computing min and max argument values
-
quaternion-core
quaternion operations and interconversion with several attitude representations
-
option-operations
Traits and auto-implementations to improve arithmetic operations usability when dealing with
Options -
w3f-pcs
Collection of tools for augmenting polynomial commitment schemes
-
mathlab
A Powerful Math Library for Rust
-
enneagram
A digital enneagram
-
cnfgen
Generate DIMACS CNF formula from operations
-
physics_in_parallel
High-performance infrastructure for numerical simulations in physics
-
angle-sc
performing accurate and efficient trigonometry calculations
-
logicaffeine-proof
Backward-chaining proof engine with Socratic hints
-
gf2
Working in bit-space a.k.a. GF(2)
-
mirl
Miners Rust Lib - A massive collection of ever growing and changing functions, structs, and enums. Check the description for compatibility and toggleable features! (Most of the lib…
-
ndarray-glm
Performs regression for generalized linear models using IRLS on data stored in arrays
-
rsparse
solving sparse linear systems using direct methods
-
sliding_features
Modular sliding window with various signal processing functions and technical indicators
-
fend
Arbitrary-precision unit-aware calculator
-
num-valid
robust numerical library providing validated types for real and complex numbers to prevent common floating-point errors like NaN propagation. Features a generic, layered architecture…
-
symbolica
A blazing fast computer algebra system
-
diffusionx
A multi-threaded crate for random number generation and stochastic process simulation, with optional GPU acceleration
-
pragmastat
Pragmatic Statistical Toolkit
-
i_float
This fixed float math library provides an efficient and deterministic solution for arithmetic and geometric operations
-
clock-curve-math
High-performance, constant-time, cryptography-grade number theory library for ClockCurve ecosystem
-
enterpolation
creating and computing interpolations, extrapolations and smoothing of generic data points
-
pathfinder_geometry
Basic SIMD-accelerated geometry/linear algebra
-
ripopt
A memory-safe interior point optimizer in Rust
-
mahc
riichi mahjong calculator library and CLI
-
dashu
set of big numbers
-
numeris
Pure-Rust numerical algorithms library — high performance with SIMD support while also supporting no-std for embedded and WASM targets
-
complex-bessel
Pure Rust implementation of complex Bessel functions (J, Y, I, K, H, Airy) based on Amos Algorithm 644
-
gemlab
Geometry and meshes laboratory for finite element analyses
-
microlp
A fast linear programming solver library
-
symjit
a lightweight just-in-time (JIT) optimizer compiler
-
rivrs-sparse
Sparse linear algebra solvers
-
twenty-first
Collection of mathematics routines and cryptography for the twenty-first century
-
axoproject
project detection logic for various axo.dev applications
-
russell_ode
Solvers for ordinary differential equations and differential algebraic equations
-
geonum
geometric number library supporting unlimited dimensions with O(1) complexity
-
light-curve-feature
Feature extractor from noisy time series
-
scirs2-interpolate
Interpolation module for SciRS2 (scirs2-interpolate)
-
rpn-cli
Command line reverse Polish notation calculator
-
waveasm
Assembler for the Wave2 CPU Architecture
-
qfall-math
Mathematical foundations for rapid prototyping of lattice-based cryptography
-
vectrix
A stack-allocated matrix type implemented with const generics
-
pxfm
Fast and accurate math
-
substrate-fixed
Fixed-point numbers
-
circom-witnesscalc
Witness calculator for Circom circuits
-
g_math
Multi-domain fixed-point arithmetic with geometric extension: Lie groups, manifolds, ODE solvers, tensors, fiber bundles — zero-float, 0 ULP transcendentals
-
feldera-fxp
Fixed-point decimal with fixed precision and scale
-
nyse-holiday-cal
NYSE holiday calendar library
-
echidna
A high-performance automatic differentiation library for Rust
-
unit-prefix
Format numbers with metric and binary unit prefixes
-
machine-prime
ne plus ultra primality testing for machine-sized integers
-
ninterp
Numerical interpolation for N-dimensional rectilinear grids
-
honeycomb-core
Core structure implementation for combinatorial maps
-
oxidd
A safe, concurrent, modular, and performant decision diagram framework
-
survival
A high-performance survival analysis library written in Rust with Python bindings
-
propagators-chirho
propagator networks for constraint propagation and bidirectional computation
-
const-primes
Work with prime numbers in const contexts. Prime generation, primality testing, prime counting, and more.
-
amari-enumerative
Enumerative geometry capabilities for the Amari library
-
mappers
Pure Rust geographical projections library
-
ndarray-interp
Interpolation package for ndarray
-
affn
Affine geometry primitives: strongly-typed coordinate systems, reference frames, and centers for scientific computing
-
tribev2
TRIBE v2 — multimodal fMRI brain encoding model inference in Rust
-
mathru
Fundamental algorithms for scientific computing in Rust
-
fluxdash
Geometry Dash bot for Fluxer! (WIP, contributions appreciated!)
-
hisab
Higher mathematics library — linear algebra, geometry, calculus, and numerical methods for Rust
-
ggmath
A linear algebra library for games and graphics with generic SIMD types
-
stv-rs
Single Transferable Vote implementation in Rust
-
glyph_brush_layout
Text layout for ab_glyph
-
serde-ndim
Serde support for n-dimensional arrays from self-describing formats
-
kzg-rs
KZG point evaluation
-
sankhya
— Ancient mathematical systems, historical calendars, and archaeoastronomy: 10+ calendar systems, 8 civilizations of mathematics, cross-civilizational epoch correlation
-
kz80_bc
Arbitrary-precision decimal arithmetic language and calculator for Z80
-
proj-core
Pure-Rust coordinate transformation library with no C dependencies
-
lstsq
Return the least-squares solution to a linear matrix equation
-
directx_math
translation of DirectXMath, a SIMD linear algebra library for use in games and graphics apps
-
russell_tensor
Tensor analysis, calculus, and functions for continuum mechanics
-
laddu
Amplitude analysis made short and sweet
-
runmat-hir
High-level IR for RunMat with type inference and lowering utilities
-
symb_anafis
Fast symbolic differentiation library for Rust
-
nm
Minimalistic high-performance metrics collection in highly concurrent environments
-
int_ratio
The type of ratios represented by two integers
-
algebraeon-nzq
natural numbers, integers and rationals for algebraeon
-
jlrs
bindings to the Julia C API that enable Julia code to be called from Rust and more
-
graphblas_sparse_linear_algebra
Wrapper for SuiteSparse:GraphBLAS
-
geoit
Exact geometric algebra with governed multivectors
-
hyperdual
Fully-featured Dual Number implementation with features for automatic differentiation of multivariate vectorial functions
-
kalker
A calculator that supports user-defined functions, variables and units, and can handle fairly ambiguous syntax
-
tracktor
Multi-target tracking with random finite sets
-
p3-miden-lifted-fri
Lifted FRI PCS (DEEP quotient + FRI)
-
pumpkin-solver
The Pumpkin combinatorial optimisation solver library
-
sci-rs
Rust scientific analysis library similar to SciPy
-
triton-vm
virtual machine that comes with Algebraic Execution Tables (AET) and Arithmetic Intermediate Representations (AIR) for use in combination with a STARK proof system to allow proving correct…
-
lawkit
Statistical law analysis CLI toolkit with international number support
-
u-analytics
Statistical process control, process capability, Weibull reliability, change-point detection, measurement system analysis (Gage R&R), correlation, regression, distribution analysis, and hypothesis testing
-
numr
High-performance numerical computing with multi-backend GPU acceleration (CPU/CUDA/WebGPU)
-
calc_rational
CLI calculator for rational numbers
-
morok-tensor
High-level lazy tensor API for the Morok ML compiler
-
splines
Spline interpolation made easy
-
mate-rs
lightweight arithmetic expression interpreter
-
nextsv
Next semantic version calculator
-
axb
A lightweight, zero-dependency linear algebra library with compile-time dimension checking
-
didp-yaml
YAML interface for Dynamic Programming Description Language (DyPDL) and DyPDL solvers
-
unit-sphere
performing geometric calculations on the surface of a sphere
-
talib-rs
Pure Rust technical analysis library — drop-in replacement for TA-Lib
-
mzsignal
mass spectrometry signal processing
-
gpu-fft
performing Fast Fourier Transform (FFT) and Inverse FFT using GPU acceleration
-
tukey_test
Statistical post-hoc tests: Tukey HSD, Games-Howell, Dunnett, one-way ANOVA, and studentized range critical values — pure Rust, zero required dependencies
-
spirix
Two's complement floating-point arithmetic library
-
sc_neurocore_engine
High-performance SIMD backend for SC-NeuroCore stochastic neuromorphic computing
-
pelt
Changepoint detection with Pruned Exact Linear Time
-
qsv-stats
Computing summary statistics on streams
-
intrval
Generic intervals (ranges) library
-
rint
A pure Rust library for the numerical integration of real or complex valued functions of real variables in multiple dimensions
-
la-stack
Fast, stack-allocated linear algebra for fixed dimensions
-
oxiblas-blas
BLAS operations for OxiBLAS - pure Rust implementation
-
bevy_autodiff
Automatic differentiation using Bevy ECS as computation graph
-
celestial-coords
Astronomical coordinate transformations
-
scirs2-signal
Signal processing module for SciRS2 (scirs2-signal)
-
nacfahi
Simpler, but less error-prone API for
levenberg-marquardtoptimization crate -
comp-cat-rs
Computational category theory in Rust: all constructions as Kan extensions
-
ndarrow
Zero-copy bridge between Apache Arrow and ndarray
-
zeromq-src
Source code and logic to build ZeroMQ from source
-
mech-math
Math library for the Mech language
-
polyfit
Because you don't need to be able to build a powerdrill to use one safely
-
splr
A modern CDCL SAT solver in Rust
-
tiny-solver
Factor graph solver
-
rusty_neat
Pretty good NEAT implementation
-
fingerprints
Property estimation from samples: fingerprints, entropy and support estimators
-
rene
Computational geometry
-
exg
EXG (EEG/ECG/EMG) preprocessing — native Rust DSP + FIF reader, numerical parity with MNE-Python
-
alu
Agent Logic Unit — deterministic math evaluation CLI for AI agents
-
ploot
A terminal plotting library
-
finmoney
Precise money library for Rust — currency-aware arithmetic, exchange-grade tick handling, configurable rounding. Built for trading systems.
-
KiThe
A numerical suite for chemical kinetics and thermodynamics, combustion, heat and mass transfer,chemical engeneering. Work in progress. Advices and contributions will be appreciated
-
constraint-solver
A small, generic nonlinear constraint solver with symbolic expressions, compilation, and a modified Newton-Raphson method
-
ryft-mlir
Ryft bindings for MLIR
-
jingle
SMT Modeling for Ghidra's PCODE
-
labassess
Score biomarkers against longevity-optimal ranges
-
rvmath
A comprehensive, lightweight, and type-safe mathematics library for Rust
-
anofox-forecast
Time series forecasting library
-
rust_physics_engine
A comprehensive, zero-dependency Rust library for physics, mathematics, and engineering computation — 1,600+ validated functions covering 50+ domains
-
amplify_num
Amplifying numeric types: big-sized and bit-sized integers
-
lair
Linear algebra in Rust
-
copp
Convex-objective path parameterization for robotic trajectory planning
-
matrix-sdk-qrcode
encode and decode QR codes for interactive verifications in Matrix land
-
math-bem
High-performance Boundary Element Method library for acoustic scattering
-
grb
API for Gurobi optimizer
-
mdarray
Multidimensional array for Rust
-
kryst
Krylov subspace and preconditioned iterative solvers for dense and sparse linear systems, with shared and distributed memory parallelism
-
rssn
A comprehensive scientific computing library for Rust, aiming for feature parity with NumPy and SymPy
-
tessellation
3d tessellation library
-
centerline
finding centerlines of 2D closed geometry
-
taceo-poseidon2
Poseidon2 permutation for BN254 curve
-
oxiblas-lapack
LAPACK operations for OxiBLAS - pure Rust implementation
-
balanced-ternary
manipulate balanced ternary values
-
bva
manipulating and doing arithmetics on bit vectors of fixed but arbitrary size
-
sanos
Smooth strictly Arbitrage-free Non-parametric Option Surfaces (Rust implementation)
-
yata
Technical Analysis library. For rust now.
-
linreg-core
Lightweight regression library (OLS, Ridge, Lasso, Elastic Net, WLS, LOESS, Polynomial) with 14 diagnostic tests, cross validation, and prediction intervals. Pure Rust - no external math dependencies…
-
ferray-ufunc
Universal functions and SIMD-accelerated elementwise operations for ferray
-
suma_core
A core library for suma_ulsa, used for academics methods and data processing
-
s2
S2 geometric library
-
runmat-ignition
Baseline interpreter for RunMat enabling instant startup and execution
-
aga8
GERG2008 equations of state
-
mosox
LP matrix generator for GMPL
-
hyperball
Hyperbolic geometry: Poincare ball, Lorentz model, Mobius operations
-
polyglot_interpreter
A cross-platform, cross-language interpreter of simple logical expressions
-
dproc
A basic CLI data processor, designed to be fed data and output data directly from the commandline
-
oxidiviner
A comprehensive Rust library for time series analysis and forecasting including moving average, exponential smoothing, autoregressive, and GARCH models
-
matio-rs
Rust wrapper to MATLAB MAT file I/O library
-
rawarray
file format for retrievably storing n-dimensional arrays
-
sciforge
A comprehensive scientific computing library in pure Rust with zero dependencies
-
interatomic
calculating inter-particle interactions
-
stft-rs
streaming-friendly, no_std compliant STFT implementation with mel spectrogram support
-
n_circular_array
An n-dimensional circular array
-
rational
Minimalistic library for rational numbers
-
boolean_function
Mathematical analysis of Boolean functions
-
optimizer
Bayesian and population-based optimization library with an Optuna-like API for hyperparameter tuning and black-box optimization
-
ramer_douglas_peucker
Ramer Douglas Peucker algorithm
-
nereids-fitting
Optimization engine for resonance fitting (LM, Poisson/BFGS)
-
startin
A Delaunay triangulator for terrains
-
graphembed
graph embedding
-
spinsat
A dynamic SAT solver based on digital memcomputing machines
-
math-fem
Multigrid FEM solver for the Helmholtz equation
-
owens-t
Owen's T Function and Bivariate Normal CDF computations
-
thermalcomfort
port of pythermalcomfort for thermal comfort calculations (no_std, WASM-compatible)
-
protocheck
✅ Validate protobuf messages using protobuf annotations
-
fib-rug
Basic fibonacci numbers calculator using the rug crate
-
path-kit
Rust path operations library based on Skia PathOps and PathKit - union, intersect, simplify, stroke, RRect
-
nabled
A linear algebra library written in Rust with an ndarray-first architecture
-
numbers_rus
Number-theory primitives and exact arithmetic for Rust — built for competitive programming, teaching, and recreational math. Miller-Rabin primality, sieves, factorization, modular arithmetic…
-
hekate-math
A high-performance, constant-time implementation of binary tower fields (F(2^k)) optimized for GKR-based provers, Virgo, and Binius protocols
-
ries
Find algebraic equations given their solution - Rust implementation
-
ibig
A big integer library with good performance
-
blas-src
The package provides a BLAS source of choice
-
arrow-ml-linalg
Linear algebra, reduction, reshaping, convolution, and pooling kernels operating on Apache Arrow arrays
-
erydanos
Optimized routines for ARM NEON and SSE
-
xad-rs
Exact automatic differentiation for Rust — forward-mode, reverse-mode, first- and second-order, with named variable support for ergonomic gradient readback
-
fib-rs
A highly optimized Fibonacci number calculator for Rust that efficiently computes arbitrarily large Fibonacci numbers
-
simd_vector
SIMD vector types (Vec4, Vec8) for x86-64 in pure stable Rust — SSE4.1, AVX2, FMA3
-
zelen
Direct MiniZinc to Selen Solver
-
trit-vsa
Balanced ternary arithmetic library with bitsliced storage and VSA operations
-
extended_matrix
A matrix calculation module
-
skillet
micro expression language (arithmetic, logical, functions, arrays, conditionals, excel formulas) made in Rust bin cli and server
-
lina
Linear algebra library with a focus on 3D applications like games (i.e. low-dimensional vectors and matrices)
-
dartunifrac
Ultra-fast approximate UniFrac via Weighted MinHash
-
bpa_rs
Ball Pivot Algorithm (BPA) for 3D point cloud data
-
mxpm
Maxima Package Manager
-
brainiac
— Brain MRI foundation model inference in Rust with Burn ML
-
unleash-yggdrasil
Unleash SDK domain logic extracted into a library to facilitate building your own Unleash SDKs in anything, anywhere
-
strange-attractors
Study into strange attractor visualization in a TUI
-
temp-converter
terminal temperature unit converter between Celsius, Fahrenheit and Kelvin
-
frinZ
fringe search for Yamaguchi Interferometer and Japanese VLBI Network
-
ax-int-ratio
The type of ratios represented by two integers
-
graphics-shapes
Shapes for graphics
-
matematika-rs
matematika sederhana untuk orang malas seperti saya
-
flaw
Embedded signal filtering, no-std and no-alloc compatible
-
bare_metal_modulo
ModNum is a highly ergonomic modular arithmetic struct intended for no_std use
-
transfinite
ordinal arithmetic library supporting ordinals up to epsilon-zero (ε₀) using Cantor Normal Form
-
math-solvers
High-performance linear solvers for BEM and FEM
-
mscore
providing core operations for computational mass spectrometry proteomics
-
mini-calc
A Fully-Featured Configurable (mini) Rust Calculator
-
rslife
A comprehensive Rust library for actuarial mortality table calculations and life insurance mathematics
-
clawgic
Logic engine for making, modifying, and evaluating expressions from sentential (propositional) logic. Support for predicate logic will be added later.
-
libmf
Large-scale sparse matrix factorization for Rust
-
wbprojection
Whitebox Projections is a map projection library for Rust, inspired by PROJ
-
frunk_laws
contains laws for algebras declared in Frunk
-
single_algebra
A linear algebra convenience library for the single-rust library. Can be used externally as well.
-
imagnum
providing versatile numeric types supporting integers and floats designed for the Lucia programming language
-
parry3d
3 dimensional collision detection library in Rust
-
differential-equations
solving differential equations
-
pointy
Minimal 2D geometry library
-
aprender-sparse
Sparse matrix formats and operations — CSR, COO, BSR with SIMD-accelerated SpMV/SpMM
-
ruvector-consciousness
SOTA consciousness metrics: IIT Φ computation, causal emergence, effective information with SIMD acceleration and sublinear approximations
-
fpdec
Decimal floating-point arithmetic
-
algexenotation
in Rust
-
rkf78
Runge-Kutta-Fehlberg 7(8) integrator for spacecraft trajectory propagation
-
mantaray
Ray-tracing solver for ocean surface gravity waves that integrates the wave ray equations over spatially varying currents and bathymetry
-
tetra3
Fast and robust star plate solver
-
tanmatra
— Atomic and subatomic physics: Standard Model, nuclear structure, radioactive decay, spectral lines
-
integrator
A math library
-
mstlo
online monitoring of Signal Temporal Logic (STL) specifications
-
rooc
A mixed integer linear programming modeling language to solve linear optimization models. Extensible, works in WASM and easy to use.
-
amari-relativistic
Relativistic physics using geometric algebra for charged particle simulations
-
fasteval2
Fast evaluation of algebraic expressions
-
special-fun
Special functions for Rust by binding to the Cephes library
-
RustedSciThe
Rust framework for symbolic and numerical computing written under the influence of SciPy and Sympy:symbolic calculations,nonlinear systems,IVP and BVP,optimization,fitting,etc
-
apex-solver
High-performance nonlinear least squares optimization with Lie group support for SLAM and bundle adjustment
-
ecolor
Color structs and color conversion utilities
-
mats
A lightweight, efficient, and easy-to-use Rust matrix library
-
markov-chain-monte-carlo
A composable Markov Chain Monte Carlo (MCMC) framework for arbitrary state spaces in Rust
-
lie-groups
Lie groups and Lie algebras for computational mathematics
-
plane-split
Plane splitting
-
fixed_analytics
Fixed-point mathematical functions. Accurate, deterministic, and panic free.
-
ndarray_cg
High-performance computer graphics mathematics library based on ndarray with vectors, matrices, and transformations
-
lux-rs
Pure Rust lighting and color science library inspired by LuxPy
-
powerlaw
command-line tool for analyzing power-law distributions in empirical data
-
minikanren_1bit_chirho
miniKanren as 1-bit matrix operations - hardware-accelerated logic programming with SIMD, GPU, and FPGA support. Includes Sudoku solver (14μs), N-Queens, constraint propagation.
-
mingot
Leptos UI library for applications demanding mathematical precision - u64+ integers, arbitrary-precision decimals, zero precision loss
-
hoomd-geometry
Construct and manipulate shapes in space. Compute their properties, sample points in them, and evaluate whether shapes intersect. Part of hoomd-rs.
-
conspire
interface to conspire
-
sounding-analysis
Types and functions for working with weather soundings
-
trig-const
Const trig functions in Rust
-
pupil
Arithmetic expression evaluator
-
thales
A comprehensive Computer Algebra System (CAS) library for symbolic mathematics, equation solving, calculus, and linear algebra
-
dda-rs
Rust interface for the run_DDA_AsciiEdf binary (Cosmopolitan Libc APE) for Delay Differential Analysis
-
lav
Lane-Associated Vector (LAV): Portable SIMD vector trait as GAT of SIMD lane trait
-
apiel-cli
Interactive REPL for apiel, a subset of the APL programming language implemented in Rust
-
rotamer
NERF-based sidechain coordinate placement for 29 amino acid types; build.rs bakes all bond geometry as f32 literals, custom libm-free sincosf/rsqrtf, #[repr(C)] stack-only output, zero heap, no-std
-
geo-aid
designed to generate geometrical figures based on given rules
-
flexfloat
arbitrary floating-point types with infinite exponent
-
glamour
Strongly typed linear algebra with glam
-
mosek
Rust API for MOSEK optimization tools
-
smallest-enclosing-circle
Iterative two-dimensional implementations of Welzl's algorithm for computing the smallest enclosing circle
-
theotui
A TUI to explore theoretical computer science topics
-
nauty-pet
Canonical graph labelling using nauty/Traces and petgraph
-
subsphere
Sphere tessellation toolkit
-
bellpepper
Gadgets for a SNARK Circuit library
-
metis
Idiomatic wrapper for METIS, the serial graph partitioner and fill-reducing matrix orderer
-
lin_algebra
A linear algebra package to compute image, kernel and rank of linear applications
-
quadprec
Software-emulated quad precision (f128) via double-double arithmetic — Cholesky, dot, gemv for ill-conditioned linear algebra
-
ratio-matrix
Ratio's matrix data library
-
pi_num_cmp
size int bigint float num cmp
-
nereids-io
Data I/O for TIFF stacks, NeXus files, and VENUS normalization
-
camera-intrinsic-model
Camera Intrinsic Models
-
slop-jagged
Jagged sparse-to-dense polynomial adapter for SLOP
-
xprec
Fast emulated quadruple (double-double) precision arithmetic
-
ark-feanor
Bridge between arkworks finite fields and feanor-math ring system
-
alum
Halfedge based polygon mesh library
-
naivesat
Few solvers that uses the Gate project
-
fastatomstruct
A Python package for the analysis of atomic structures and dynamics
-
factorion-bot-reddit
factorion-bot (for factorials and related) on Reddit
-
num-modular
efficient integer division and modular arithmetic operations with generic number types. Supports various backends including num-bigint, etc
-
voroxx
Voro++, a 3D cell-based Voronoi library
-
ommx
Open Mathematical prograMming eXchange (OMMX)
-
plonkish-cat
PLONKish circuit system built on comp-cat-rs: circuits as morphisms in a free category
-
glam_matrix_extras
Matrix types and utilities for Glam
-
faer-traits
linear algebra library
-
quadraturerules
quadrature rules library
-
specialized-div-rem
specialized division algorithms for integer primitives
-
flowmatch
Flow matching primitives (ndarray-first; backend-agnostic) with semidiscrete FM and RFM experiments
-
grid1d
A mathematically rigorous, type-safe Rust library for 1D grid operations and interval partitions, supporting both native and arbitrary-precision numerics
-
dsp_tools
Various useful tools for DSP
-
ring360
wrapper type for 64-bit floats representing degrees around a circle. It has operator overloads for addition and subtraction, calculates the shortest angles and implements the core trigonometric functions.
-
joker_calculus
Joker Calculus in Rust
-
fdars-core
Functional Data Analysis algorithms in Rust
-
wagyu-rs
Geometry boolean operations (union, intersection, difference, xor) - Rust port of Mapbox wagyu
-
xsf
Rust implementations and bindings for scipy.special functions
-
hooo
Propositional logic with exponentials
-
number-general
A generic number type for Rust which supports basic math and (de)serialization
-
atlas-embeddings
First-principles construction of exceptional Lie groups from the Atlas of Resonance Classes
-
num-t
Num<T>: Associate arbitrary types with numeric types
-
semdiff-differ-audio
Audio diff calculator and reporters for semdiff
-
cova
First principles, minimally dependent, geometric and topologically focused math library
-
sampling
Large-deviation Algorithms like Wang-Landau, Entropic sampling and Replica-Exchange Wang-Landau. Also contains Binning, Histograms, Heatmaps and bootstrap resampling. This is intended for scientific simulations
-
rstm
focuses on building concrete implementations for Turing Machines
-
taguchi
State-of-the-art orthogonal array (Taguchi) library for experimental design
-
katex
Rust bindings to KaTeX
-
marlu
Convenience Rust code that handles coordinate transformations, Jones matrices, I/O. for the Murchison Widefield Array (MWA) radio telescope. Previously known as mwa_rust_core
-
polynomial-ring
A polynomial implementation
-
set_theory
A comprehensive mathematical set theory library implementing standard set operations, multisets, and set laws verification
-
ry-science
Math, stats, and geometry for Ry-Dit — Bezier curves, statistics, optical illusions
-
fixed-math-taylor
High-performance fixed-point trigonometry library optimized for microcontrollers without FPU. 100% no_std.
-
num-integer
Integer traits and functions
-
clifford
Geometric Algebra (Clifford Algebra) for Rust: rotors, motors, PGA for 3D rotations and rigid transforms
-
quarks-zk
Quarks: Quadruple-efficient transparent zkSNARKs - Implementation of Kopis-PC, Dory-PC, and Lakonia/Kopis/Xiphos SNARKs
-
ruvector-verified
Formal verification layer for RuVector: proof-carrying vector operations with sub-microsecond overhead using lean-agentic dependent types
-
swfp
A soft-float library
-
rao
Robust and scalable Adaptive Optics tools
-
stock-trek
Stock Trek time-series analysis
-
csrk
Sparse Gaussian Process regression with compactly supported radial kernels
-
ppsd-rs
Seismic PPSD (Probabilistic Power Spectral Density) computation matching ObsPy output
-
geometry-rs
geometry utils
-
iridium-units
A high-performance runtime unit-of-measure library for Rust
-
pictex
CLI utility for converting LaTeX math expressions to PNG format
-
baa
BitVector and Array Arithmetic
-
mwa_hyperdrive
Calibration software for the Murchison Widefield Array (MWA) radio telescope
-
geo-cal
A cli tool to calcuate analytical geometry questions, like distances, circle, parabola and more with guided steps
-
taz
evaluate a mathematical expression
-
mangle-analysis
Mangle, a logic programming language
-
ruststat
working with many common random variables --- probability mass function (pmf), probability density function (pdf), cumulative distribution function (cdf), percentiles (inverse cdf), random number generation
-
lazyivy
Lazy Runge-Kutta integration for initial value problems
-
numrs2
inspired by NumPy for numerical computing (NumRS2)
-
hanfei-shu
术 — GPU-accelerated Multi-Scalar Multiplication for the Pallas elliptic curve. The first and only GPU MSM for the Halo2/Pasta ecosystem.
-
strict-num
A collection of bounded numeric types
-
scilib
A scientific library for the Rust programming language
-
lobatto-fft
High-order FFT on Gauss–Lobatto grids and corresponding high-order solver for Poisson problems
-
tang
Math library for physical reality — geometry, spatial algebra, tensor, training, GPU compute, and 3D gaussian splatting
-
malachite-q
The arbitrary-precision type Rational, with efficient algorithms partially derived from GMP and FLINT
-
capsula-orchestration
Orchestration logic for Capsula runs (shared by CLI, PyO3, etc.)
-
al-jabr
An n-dimensional linear algebra library
-
decaf377
A prime-order group designed for use in SNARKs over BLS12-377
-
calc
CLI calculator app
-
crackers
synthesizing Code Reuse Attacks (ROP chains) using Ghidra's p-code and Z3
-
zixy
Quantinuum's high performance Rust crate for the manipulation of Pauli strings and other quantum algebraic objects
-
convex-math
Mathematical utilities for the Convex fixed income analytics library
-
rlst
native linear algebra library
-
thermal_hydraulics_rs
A Thermal Hydraulics Library with some useful traits,enums and functions for heat transfer and fluid mechanics
-
big_num_math
Unostentatious library for computations on large numbers
-
triad-core
Pure deterministic claim verification logic for triad
-
amari-flynn
Probabilistic contracts and verification - named after Kevin Flynn's acceptance of spontaneous perfection
-
dsfb-add
Deterministic Algebraic Deterministic Dynamics (ADD) parameter sweeps for AET, TCP, RLT, and IWLT
-
panic-attacker
Universal stress testing and logic-based bug signature detection
-
num-bigfloat
Increased precision floating point numbers implemented purely in Rust
-
gspx
Sparse graph signal processing and spectral graph wavelets in Rust
-
bc
Use
bcin the Rust Programming Language -
russell_stat
Statistics calculations and (engineering) probability distributions
-
sq
A minimal client-server for phext hosting
-
noiz
configurable, blazingly fast noise library built for and with Bevy
-
linear_isomorphic
A set of traits to astract over linear-like types
-
ancdec
Fast, precise anchored decimal with independent integer/fraction fields (u64: 19+19, u128: 38+38 digits)
-
mlua-mathlib
Math library for mlua — RNG, distributions, hypothesis testing, ranking, information theory, and statistics
-
breprs
boundary representation (BRep) with API compatibility for CAD/CAE/CAM applications
-
rustex-cli
Convex to Rust code generation CLI for type-safe Rust clients
-
fey_math
Vectors, matrices, directions, and geometry
-
rita
2D and 3D Randomized Incremental Triangulation Algorithms
-
wifi-densepose-ruvector
RuVector v2.0.4 integration layer — ADR-017 signal processing and MAT ruvector integrations
-
gem_version
Ruby's Gem::Version comparison logic in Rust
-
floating-ui-core
Rust port of Floating UI. Positioning library for floating elements: tooltips, popovers, dropdowns, and more.
-
market_synth_nh1948
Content marketing synthesis engine combining math principles, ABAP architecture, and Rust new complementarity principle
-
logicaffeine-kernel
Pure Calculus of Constructions type theory - NO LEXICON
-
matrix_handler
Uma biblioteca leve e eficiente para manipulação, operações matemáticas e transformação de matrizes em Rust. Focada em performance e simplicidade de interface.
-
argentum_user_business
Business layer of user component
-
luacad-studio
A 3D CAD studio with Lua scripting and live preview
-
polyfit-residuals
Efficiently calculate the residual errors (in the least squares sense) of all polynomial models (up to some degree) for a given dataset and compute least-squares polynomial fits
-
minmath
A lightweight math library
-
fermat
A collection of math algorithms
-
vector-space
Generic vector space trait for compatibility across various libraries
-
bacon-sci
Scientific computing in Rust
-
pcb-toolkit
PCB design calculator library — impedance, current capacity, via properties, and more
-
tcalc-cli
A CLI for time arithmetic
-
provable-contracts-cli
CLI for provable-contracts — validate, scaffold, verify, status, audit
-
provable-contracts
Papers to Math to Contracts in Code — YAML contract parsing, validation, scaffold generation, and Kani harness codegen for provable Rust kernels
-
numby
A powerful natural language calculator with a terminal user interface
-
ratio-graph
Ratio's graph manipulation library
-
intel-mkl-src
Redistribution of Intel(R) MKL as a crate
-
eqsolver
that solves equations using numerical methods
-
trussx
designing and analyzing truss structures
-
pramana
— Statistics and probability: distributions, Bayesian inference, hypothesis testing, Monte Carlo, Markov chains
-
automesh
Automatic mesh generation
-
xmt-lib
A grounder for SMT solvers
-
damped-springs
damped springs for smooth and springy motion
-
rounded-div
Get rounded result of an integer division
-
flint3-sys
Rust bindings to the FLINT C library
-
pso-poseidon
Poseidon hash implementation compatible with Circom
-
cubes
Applications for determining how to put a cube together
-
libnoise
performant, and customizable procedural noise generation library
-
pearl-calculator
A Pearl Calculator for Minecraft
-
organicomplex
Interactive complex-valued cellular automaton on 2D and 3D grids in search of that stuff - emergence, open-endedness, organicity etc
-
runmat
High-performance MATLAB/Octave runtime with Jupyter kernel support
-
deep_causality_topology
Topological data structures for the DeepCausality project
-
vee
Vector Expression Emitter (VEE): Geometric Algebra Code Generator
-
ai-pxfm
A no_std fork of pxfm
-
poly-ring-xnp1
Polynomial ring Z[x]/(x^n+1) for lattice-based cryptography
-
xyzvec
Statically allocated fixed-size vectors for working in 2 and 3 dimensions
-
cartan-manifolds
Concrete Riemannian manifold implementations for cartan: Sphere, SO(n), SPD(n), Grassmann, Euclidean
-
emlmath
A scientific math library based on the paper All elementary functions from a single binary operator by Andrzej Odrzywołek
-
prime_factorization
Prime factorization up to 128 bit integers
-
prime-noise
Noise functions — Perlin, Simplex, FBM, Worley, curl
-
d3_delaunay_rs
A port of D3/d3-delauany
-
neco-cdt
2D Constrained Delaunay Triangulation with exact geometric predicates
-
twine-models
Domain-specific models and model-building tools for Twine
-
numina
Backend-agnostic array library for high-performance computing in Rust
-
miden-core-lib
Miden VM core library
-
ark-tom256
The Tom-256 curve
-
provekit-fp-rounding
Floating-point rounding utilities for BN254 arithmetic
-
easy_lambda_calculus
easy to write lambda calculus
-
circle-of-confusion
Calculator for Circle of Confusion (CoC) to calculate the size in pixels of an area, used for depth of field processing
-
longitude
Work with real world coordinates in Rust!
-
piecewise_polynomial
Fitting and interpolation with piecewise polynomials
-
cgt
Combinatorial Game Theory framework
-
tatam
Theory And Time Analysis Machine
-
amari-gpu
GPU acceleration for mathematical computations
-
regit-covariance
Covariance matrix denoising for financial risk validation. Marchenko-Pastur filtering, Ledoit-Wolf shrinkage, detoning.
-
xdl-matlab
Extended Data Language (XDL) - Rust implementation
-
bestagon
An engine for discrete stuff in hexagonal grids
-
numbat
A statically typed programming language for scientific computations with first class support for physical dimensions and units
-
turbodiff
Rust-powered DeepDiff core
-
bool-logic
manipulating and evaluating boolean expressions
-
anofox-statistics
A comprehensive statistical hypothesis testing library validated against R
-
spherical_geometry
A package for working with spherical geometry
-
fastmaths
High-performance no_std math routines targeting glibc parity and strict f64 accuracy
-
ecgen-rs
Enumerative Combinatoric Generation in Rust
-
fj
Early-stage b-rep CAD kernel
-
num-lazy
Number macros for generic-typed functions
-
numix
A fast, lightweight Rust library for math operations and numeric computations
-
music-comp-mt-cli
A music theory command-line tool
-
uzor-backend-vello-common
Shared utilities for vello-based backends
-
aprilgrid
Aprilgrid
-
lme-rs
Rust port of R's lme4: linear mixed-effects models with 1:1 numerical compatibility
-
tampines-steam-tables
Steam Tables for the TAMPINES Library
-
semicontinuous_models
Reusable models for semi-continuous outcomes (two-part, Tweedie, and log-normal)
-
vampire-prover
Safe Rust bindings to the Vampire theorem prover for first-order logic
-
simul
discrete-event simulation library aimed at high-level use-cases to quickly simulate real-world problems and run simulated experiments. Some example use cases might include simulating logistics or operations research…
-
libceed
High-level interface for libCEED - the efficient high-order discretization library developed by the ECP co-design center CEED
-
abaco
Math engine — expression evaluation, unit conversion, and numeric types for Rust
-
find_peaks
Find peaks that match criteria in 1D data
-
sundials
Suite of nonlinear and differential/algebraic equation solvers
-
typed-money
A type-safe money library for Rust that prevents currency mixing bugs at compile time
-
fixed-macro
Macros for creating fixed-point constants for types in the
fixedcrate -
qnect
⚛ Quantum computing in Rust: from Bell pairs to distributed quantum networks
-
legasea_line
Tools for working with lines
-
pumpkin-checker
A proof-checker for DRCP proofs generated for FlatZinc models
-
cellbook
Dynamic computational notebook environment in plain Rust
-
adhaan
An Islamic prayer time calculator
-
gmp-mpfr-sys
Rust FFI bindings for GMP, MPFR and MPC
-
moontool
John Walker's moontool.c astronomical calculation routines, extracted and ported to Rust
-
algebraeon
computational algebra library re-exports for all components
-
rgb-strict-types
Strict types: confined generalized algebraic data types (GADT)
-
single_rust
Single-cell analysis in Rust
-
bola
A lightweight native rust linear algebra library
-
aspirina
A modular neural network library with matrix operations and backpropagation
-
envisim_samplr
Sampling methods for balanced and spatially balanced sampling
-
ndimpoint
working with N-dimensional points in Rust
-
cblas-inject
CBLAS compatible interface backed by runtime-registered Fortran BLAS function pointers
-
rbx_types_ops
Adds operation methods to rbx_types
-
tempered
Signal and spatial processing primitives on n-dimensional arrays
-
malachite-base
A collection of utilities, including new arithmetic traits and iterators that generate all values of a type
-
qudit-tensor
Accelerated and Extensible Quantum Library
-
tekhsi_rs
High-performance client for Tektronix TekHSI enabled oscilloscopes
-
jedvek
Multidimensional Rust vectors with a 1D footprint
-
missile_guidance
Rust port of 'Tactical and Strategic Missile Guidance, 7th ed' MATLAB code
-
javelin-tui
Display and work with Lance matrices
-
kasane-logic
This is Kasane-logic
-
sparse-ir
SparseIR functionality
-
tensorlogic-scirs-backend
SciRS2-powered tensor execution backend for TensorLogic
-
gmac_rs
Blazingly fast geometry manipulation and creation library
-
oak-folding
Code folding logic and AST-based region detection for the Oak framework
-
voronota
Voronota-LT is an alternative version of Voronota for constructing tessellation-derived atomic contact areas and volumes
-
aprender-rand
Counter-based parallel RNG — Philox 4x32-10 with provable statistical properties
-
autodj
Automatic Differentiation Library
-
ilog
Base 10 and 2 logarithm functions for integer types
-
hyper-ta
Technical analysis indicators — RSI, MACD, Bollinger Bands, multi-timeframe
-
logicpearl-discovery
Artifact discovery and rule recovery from labeled LogicPearl decision traces
-
numquad
Numerical integration quadratures like Gauss-Legendre and Tanh-Sinh
-
vision-geometry
Shared geometric solvers: epipolar geometry, homography, triangulation, camera matrix
-
monolithium
Finding the Largest Minecraft Alpha Monoliths
-
remesh
Isotropic remeshing library
-
cga2d
2D Conformal Geometric Algebra primitives
-
anoma-rm-risc0
Anoma Resource Machine Implementation using RISC0 zkVM
-
surge-sparse
Sparse matrix infrastructure: KLU solver, COO-to-CSC conversion, complex sparse utilities
-
fasteval3
Fast evaluation of algebraic expressions
-
softposit
Posit numbers
-
lapack-src
The package provides a LAPACK source of choice
-
hexing
A basic Rust library to manipulate hexagonal grids
-
ldpc-toolbox
aid in LDPC code design
-
floccus
Formulae for air thermodynamic calculations
-
star-catalog
A star catalog library and tool with loadable catalogs that are searchable by geometry
-
neutron-diffusion-dd
A high-performance neutron transport solver using the S_N (Discrete Ordinates) method with domain decomposition. Solves the 1D neutron diffusion equation with automatic or manual configuration.
-
rink
Unit conversion tool, similar to frink
-
d4-oxide
wrapper around d4
-
binar
High-performance binary arithmetic
-
curve-sampling
Adaptive sampling of parametric
-
qfall-tools
Common sub-modules and procedures in lattice-based constructions
-
rcomb
Combinatorial objects, traits, collections
-
p-chan
Multimedia (Audio, Raster) Channel Newtypes and Conversions
-
prime-color
Color math — Oklab, sRGB, HSL/HSV, palette generation
-
skel
Topology/shape primitives
-
simplify-polyline
Simplify polylines using Douglas-Peucker and radial distance algorithms. Port of the simplify-js library.
-
conversions_rs
A comprehensive unit conversion library, CLI tool, and WebAssembly module with full SI (International System of Units) support
-
nc-polynomial
Polynomial arithmetic over Z_q[x] with NTT support and validated ring contexts
-
mrubyedge-math
mruby-math provides Math module for mruby/edge
-
ranch
Ranged integer types and math
-
lower
desugar math where the compiler wont
-
noether
Abstract algebraic structures for Rust
-
hct-cam16
CAM16 + HCT perceptual color math with sRGB/XYZ/L* conversions and a gamut-mapping solver. Deterministic ARGB-in/ARGB-out, no UI/engine dependencies.
-
bitnet-quantize
Microsoft BitNet b1.58 quantization and inference for Rust
-
sari
arithmetic expression evaluator
-
xraydb
X-ray reference data for the elements
-
globalsearch
A multistart framework for global optimization with scatter search and local NLP solvers written in Rust
-
lk_math
Collection of reusable mathematical tools
-
snap-coin-pay
way to handle deposits and withdrawals on the Snap Coin Network
-
numaxiom
Lightweight numeric marker traits for ranges/signs plus constants and ops; std by default, no_std optional
-
mobius-applicatio
A lean library for Möbius transformations on the complex plane
-
fast-powi
fast exponentiation for numeric types
-
area_crate
A comprehensive geometry calculation library for areas, perimeters, surface areas, and volumes
-
klippa
Geometry clipper using rectangular window
-
sgp
Simplified General Perturbations models (SGP8/SGP4) in Rust
-
symbit
Symbolic bitvector library with bitwise and integer arithmetic support
-
iterative-solvers
Iterative algorithms for solving linear systems
-
hierx
Hierarchical linear operators for efficient network approximations
-
oxidd-cli
Command line interface for OxiDD
-
folo_ffi
working with FFI logic; exists for internal use in Folo packages; no stable API surface
-
causal-hub
causal models, inference and discovery
-
iltcme
Inverse Laplace transform with concentrated matrix-exponential functions
-
calcinum
Calculator capable of handling arbitrarily large numbers
-
perfgate-scaling
Computational complexity validation and curve fitting for perfgate
-
cgpa-calculator
A lightweight Rust library for calculating GPA, CGPA, and SGPA. Supports 4.0 and 5.0 grading scales.
-
tesser-indicators
Technical indicators and signal helpers for Tesser strategies
-
geom3
3d geometry classes
-
geomorph
conversion between different coordinate systems
-
nabo
A fast K Nearest Neighbor (KNN) library for low-dimensional spaces
-
barnes_hut
Fast n-body simluation using the Barnes Hut algorithm
-
fixed-bigint
Fixed-size big integer implementation for Rust
-
tabulator
Grid-oriented tabulation with justification and anchors
-
bezier-rs
Computational geometry algorithms for Bézier segments and shapes useful in the context of 2D graphics
-
zima
An attempt to create a modern package for the needs of applied statistics
-
kll-rs
KLL quantiles sketch from Apache DataSketches for Rust
-
rstmt
A complete framework for computational music theory and composition based on topological and categorical methods
-
anthem
A command-line application for assisting in the verification of answer set programs
-
neco-modal
Modal extraction utilities for time-series vibration data
-
pid-lite
A small PID controller library
-
symbolic-mgu
Symbolic logic unification using Most General Unifiers (MGU). Implements Meredith's condensed detachment for exploring automated proof discovery.
-
tokmd-analysis
Analysis logic and enrichers for tokmd receipts
-
mathcore_nostd
Symbolic math library and computer algebra system for Rust. Forked to work in no_std environments.
-
pihex
Arbitrary place hexadecimal digits viewer of pi written in Rust
-
provekit-whir
WHIR polynomial commitment scheme
-
py-laddu-cpu
Python bindings for laddu
-
luna-rs
LUNA EEG Foundation Model — inference in Rust with Burn ML
-
symbolic_regression
Rust port of SymbolicRegression.jl
-
crustabri_ipafair
An IPAFAIR compatible library built upon the Scalop solver
-
re_int_histogram
A histogram with
i64keys andu32counts, supporting both sparse and dense uses -
cubek-quant
CubeK: Quantization Library
-
resonance-spectral-gap
Exact proof that the spectral gap of the 96-vertex Resonance Classes graph Laplacian is λ₁ = 1, via block tridiagonal decomposition into Q₄ hypercube blocks. Zero floating-point, zero unsafe code.
-
ziffle
Mental poker library implementing Bayer-Groth 2012 shuffle proofs for multi-party card shuffling without a trusted dealer
-
bsd4random
4.1BSD libc random number generator
-
schnorr_pok
Schnorr, Okamoto, Chaum-Pedersen protocols for proof of knowledge, equality and inequality of one or more discrete logs. Working in elliptic curve and pairing groups
-
moma
Moving Origin Modular Arithmetic (MOMA), a library for modeling complex systems
-
absolute_unit
A unit system for Rust's type system to catch unit errors in your physical calculations
-
dynamic_expressions
Fast batched evaluation + forward-mode derivatives for symbolic expressions (Rust port of DynamicExpressions.jl)
-
fidget_math
glam vector types for tree construction with fidget
-
theon
Abstraction of Euclidean spaces
-
bounded-counter
Generic Incremental Bounded Counter
-
interactors
Command pattern implementation for Rust
-
lox-core
Common data types and utilities for the Lox ecosystem
-
spargebra
SPARQL parser
-
roberts-sequence
The Roberts quasirandom sequence
-
runmat-thread-local
Cross-platform thread-local storage helpers for RunMat (native and wasm)
-
amd
Approximate Minimum Degree ordering
-
approx_det
Approximate floating point equality comparisons and assertions
-
spokes
A network and network flow library
-
num-order
Numerically consistent
Eq,OrdandHashimplementations for variousnumtypes (u32,f64,num_bigint::BigInt, etc.) -
simple_vector2
libary for generic vector manipulation that just works
-
space_engineers
Rust data structures and serialization for Space Engineers
-
yf-options
fast, reliable command-line tool for downloading options chain data from Yahoo Finance. Features include Black-Scholes Greeks calculation (Delta, Gamma, Theta, Vega, Rho), filtering by expiration date…
-
opengm_rts
GM/T 0005-2021 randomness test suits written in Rust
-
csc
Command Line Scientific Calculator
-
generic-interval
A generic closed interval library
-
nanogpt
Nanochat in Rust
-
deep_causality_multivector
Multivector and MultiField implementation for DeepCausality
-
honest
High-assurance Operations for Number-theoretic Extension Sets and Theorems (Galois Fields)
-
tritet
Triangle and tetrahedron mesh generators
-
powersasa
SASA and molecular volume computation using Power diagrams
-
manifold3d
Safe Rust bindings to manifold3d (facade crate — re-exports manifold-csg)
-
nexcore-softrender
Pure-Rust software rasterizer — first-principles rendering from math to pixels
-
eva
Calculator REPL similar to bc(1)
-
malachite-bigint
A drop-in num-bigint replacement based on malachite
-
cpa-cat
Carry-propagate adder built on comp-cat-rs and hdl-cat: parallel prefix networks as free category morphisms
-
historian
a high performance zero-config histogram implementation
-
petal-decomposition
Matrix decomposition algorithms including PCA (principal component analysis) and ICA (independent component analysis)
-
zfc
Trait that represents a set according to Zermelo–Fraenkel set theory with the axiom of choice (ZFC)
-
rotary-add
adds a few simple methods to the three lowest unsigned integer types, u8, u16 and u32 to allow cyclical addition and subtraction around the same 0 to (limit - 1) range or from 1 to a limit
-
algebraeon-groups
Algorithms in group theory
-
vector3
dealing with 3D mathematical vectors
-
honeycomb-kernels
Meshing kernel implementations using combinatorial maps
-
gategen
generate Gate circuits
-
incr_stats
Fast, scalable, incremental descriptive statistics in Rust
-
statify
A lightweight and minimal statistics library for Rust
-
rusticle
High-performance Rust library for numerical computing
-
openmaths
Powerful Maths Library for Graphical Applications in Rust and OpenGeometry
-
corner-calculator
Command line utility and lib to calculate new x+y coordinates for a window for a certain direction (=numpad key) based on existing based on given screen and window dimensions
-
castep_model_generator_backend
A rust-written backend lib for edit and generation of lattice 3D-models compatible with CASTEP and Materials Studio
-
coin_cbc
Rust bindings to the CoinOR CBC MILP Solveur using the C API
-
faer-svd
Basic linear algebra routines
-
ebi_arithmetic
Exact arithmetic for Ebi - a stochastic process mining utility
-
monstertruck
CAD kernel – B-rep modeling, NURBS, meshing, and GPU rendering
-
stwo
Core library implementing the Circle STARK prover and verifier
-
pymagba_binding
Rust-to-Python binding for PyMagba
-
latex2mathml
Convert LaTeX equations to MathML
-
figures
A math library specialized for 2d screen graphics
-
computable
real numbers with guaranteed correctness via interval refinement
-
taco-threshold-automaton
defining basic types for threshold automata and all of its building blocks. This crate is part of the TACO toolsuite.
-
harper-stats
The language checker for developers
-
myfav-output
Formatting and distribution logic for myfav
-
octad
puzzle generator and solver
-
zakat
A type-safe, comprehensive, and Fiqh-compliant Zakat calculation library. Supports Gold, Silver, Business, Agriculture, Livestock, Professional Income, and Modern Assets (Crypto/Stocks).
-
gollum-ast
Abstract-Syntax-Tree for the Gollum language
-
meshless_voronoi
Meshless Voronoi algorithm
-
hexgridspiral
Hexagonal Cube-Coordinate System with Spiralling Integer Tile Identifiers
-
zunei
A mathematical high performant- screen capture. written in rust
-
slop-algebra
Field algebra and univariate polynomials for SLOP, built on Plonky3
-
symdiff
Compile-time symbolic differentiation for Rust via a proc-macro attribute. Generates closed-form gradients at compile time.
-
hptt
Rust bindings for HPTT (High-Performance Tensor Transposition)
-
hyperprec
f128, f256, f512 in Rust — software-emulated extended precision via double-double and multi-limb arithmetic for ill-conditioned linear algebra
-
rust-rocket
A client implementation of GNU Rocket
-
nauty-Traces-sys
Low-level bindings for nauty and Traces
-
polysub
fast substitution of variables in polynomials
-
fhe-math
Mathematical utilities for the fhe.rs library
-
geodesic_destination
Compute the destination point for a bearing and distance on a spherical Earth
-
financial-calc
Financial calculation functions built on precision-core
-
projgeom-rs
Projective Geometry in Rust
-
anathema-geometry
Geometry, positions and sizes for Anathema
-
eml_sr
Symbolic regression via the EML operator — find the math formula hidden in your data
-
parry2d
2 dimensional collision detection library in Rust
-
lcmx
Calculate the least common multiple of multiple values
-
kalk
A math evaluator library that supports user-defined functions, variables and units, and can handle fairly ambiguous syntax
-
lean-decimal
Fast, fixed-precision, floating-point decimal types
-
soilrust
A geotechnical engineering library for soil mechanics calculations in Rust
-
arael-sym
Symbolic math library: expression trees, automatic differentiation, simplification, CSE, code generation
-
mappers_warp
Very simplistic tool for reprojecting maps, based on GdalWarp
-
neco-spline
zero dependency natural cubic spline interpolation
-
metallic
C math functions from scratch
-
ruv-neural-signal
rUv Neural — Signal processing: filtering, spectral analysis, artifact rejection for neural data
-
practicestuff
CLI trainer for improving calculation and memorisation skills
-
awint_ext
Externally allocating
awintfunctionality -
polynomial
manipulating polynomials
-
errorfunctions
Pure Rust package to compute the error function, Dawson's function, and Faddeeva's function for real and complex arguments
-
static-math
Fast mathematical operations with static arrays, without
unsafecode -
microgemm
General matrix multiplication with custom configuration in Rust. Supports no_std and no_alloc environments
-
hilbert_transform
Hilbert Transformation like Matlab/Octave hilbert function
-
foocalc
A command line RPN calculator with multiple precision and unit support
-
dv
Core Rust library for DimensionalVariable, a multi-language library for handling physical quantities with units
-
content_oracle
Content marketing oracle with entropy, prophecies and Bourbaki mathematics. Analyzes metrics, predicts the future, and sacrifices failed campaigns.
-
logician
Type-safe SMT solver driver with fluent Term API, multi-solver fallback, and process watchdog
-
bilby
A high-performance numerical quadrature (integration) library for Rust
-
sm_3d_camera_control
High-quality integration for https://supermaker.ai/blog/qwen-image-multiple-angles-3d-camera-alibabas-breakthrough-in-ai-camera-control/
-
Sph2-rs
An improved version of Sph-rs, that uses a mod to calculate the desired values
-
typub-adapters-core
Core adapter interface and types for typub
-
aspect360
This builds on the Ring360 to calculate aspect matches from target angles with orbs or an array of target aspect/orb pairs
-
xensieve
Xenakis Sieve, providing a Sieve from a string expression that filters integer sequences into iterators of integers, Boolean states, or interval widths. Sieves are built from Residuals…
-
crypto-ratio
Rational number arithmetic using crypto-bigint
-
smlm-renderer
Render a list of localisations with a gaussian based on the uncertainty
-
vema
Vector and Matrix types and associated operations
-
abhedya-chhandas
Sanskrit Metering (Chhandas) Logic for Abhedya PQC
-
rustplex
A linear programming solver based on the Simplex algorithm for Rust
-
cali
A terminal calculator with real-time evaluation, unit conversions, and natural language expressions
-
floatguard
checked floating-point arithmetic in Rust, safely elminating NaN and Infinity from floating-point computations
-
deep_causality_ethos
Programmable ethics for DeepCausality
-
ai-strict-num
A no_std fork of strict-num
-
single-utilities
provdes types, traits and utility functions to the single-rust ecosystem that can be universally used. You can also use it within your own ecosystem 👀
-
memory_size
ability to represent a number of bits or bytes, and apply arithmetic to the sizes
-
sparsers
sparerse-rs: sparse matrix computation written in rust
-
formualizer-workbook
Ergonomic workbook API over the Formualizer engine (sheets, loaders, staging, undo/redo)
-
oxicuda
Pure Rust CUDA replacement for the COOLJAPAN ecosystem (95% performance target)
-
reckoner
A high level arbitrary precision arithmetic library supporting integer and rational numbers
-
nice_and_easy
A minimalistic Rust library for smooth and effortless easing functions
-
fractal_finance
Enterprise-grade fractal analysis for quantitative finance applications
-
scuttle
A multi-objective MaxSAT solver
-
ferray-linalg
Linear algebra operations (decompositions, solvers, einsum) for ferray
-
sprs-superlu
The package provides a high level interface between SuperLU, sprs and ndarray
-
mech-matrix
Matrix library for the Mech language
-
cord-path
2 dimensional coordinate based path finder
-
hpn
Text-based RPN-style calculator in the HP Voyager tradition
-
stroke
Zero-allocation, const-generic implementations of Bézier and B-Spline curves in N-dimensional euclidean space
-
katex-gdef-v8
fast use of KaTeX via V8 engine
-
treemath
Arithmetics for perfect binary trees
-
snaphu-rs
SNAPHU C library
-
gooding-lambert
Gooding's method for solving Lambert's orbital boundary-value problem
-
min_err_per_step
Dear Dev, it's math lib for Rust to calc basic funcs w/ minimal error per step [kiss principle been at the very heart]
-
matamorph
Seamless conversions between Rust’s major matrix libraries: ndarray, faer, nalgebra, and mdarray
-
pell-equation
solve Pell's equation
-
strmath
Do math with your strings
-
ParserCalculator
In the parser, we will parse a mathematical expression into its main components: numbers, signs, brackets. The result of the parsing will be used to calculate the mathematical expression…
-
prime-dynamics
Dynamical systems — RK4/RK45, Lorenz, Duffing, L-systems, Newton-Raphson
-
string_calculator
A string calculator to compute formulas inside strings
-
ga2
Common types for 2D geometric algebra
-
decaf377_plus
A prime-order group designed for use in SNARKs over BLS12-377
-
yash-arith
POSIX shell arithmetic expansion
-
provekit-verifier
ProveKit verifier for zero-knowledge proofs
-
sym-adv-ring
Ring operations for algebraic cryptosystems over Z_m
-
decimal
floating point arithmetic for Rust
-
bones-triage
Prioritization and scoring engine for bones (PageRank, urgency, dependency-aware)
-
vecfit
Pure-Rust relaxed vector fitting for scalar, vector, matrix, and tensor-valued frequency responses
-
factorial
Convenient methods to compute the factorial, optionally checked
-
rubiks-cube-representation
A mathematical library for representing and analyzing Rubik's cubes using group theory and tile permutations
-
cobre-stochastic
Stochastic process models for power systems — PAR(p), scenario generation, correlated sampling
-
threecrate
A comprehensive 3D point cloud processing library for Rust - umbrella crate
-
foil_rs
Core airfoil geometry + panel-method solver for FoilRs (no Bevy dependency)
-
numint
ODE solvers and numerical integration in Rust
-
mathjax-svg-rs
Very thin wrapper around MathJax to render TeX to SVG, using QuickJS-ng as the JavaScript engine
-
rsc
A fast calculator for solving scientific and algebraic math equations in strings
-
semdiff-differ-json
JSON diff calculator and reporters for semdiff
-
howzat-kit
Backend spec parsing and high-performance runner API for howzat
-
fa_slow_ai
A slow AI implementation using fractal algebra
-
numtest
Unit testing for numerical methods
-
gatenative
execute natively Gate circuits
-
elicitation_kani
Kani model-checking proofs for elicitation contract types
-
fix-rat
A rational number type with fixed denominator
-
so-linalg
High-performance statistical computing library written in Rust, exposed to Python via PyO3
-
qhull
Rust bindings to Qhull
-
rapier3d-urdf
URDF file loader for the 3D rapier physics engine
-
eta-cli
CLI for the Eta calculus
-
rusty-wam
The Warren Abstract Machine in Rust
-
matrixable
Traits and structs extending capabilities of matrix-like structures
-
strict-num-extended
Type-safe finite floating-point types for Rust - eliminate NaN and infinity at compile time
-
algebraeon-sets
Algorithms in combinatorics
-
base_2
Exact fixed-point geometry. Float in, float out, zero drift inside.
-
qtty
Strongly typed physical and astronomical quantities
-
infomeasure
Information theory measures and entropy calculations for Rust
-
satgalaxy
satgalaxy-rs is a Rust library that provides Rust bindings for multiple popular SAT solvers
-
ha-ndarray
A hardware-accelerated n-dimensional array
-
neco-stencil
Finite-difference stencil operators on uniform 2D grids
-
series
Laurent series in a single variable
-
signal-gen-cjds66-lib
An unofficial support library which can fully remote control the inexpensive Koolertron DDS Signal Generator known as GH-CJDS66
-
simply_2dpga
A 2d vector math library using 2d projective geometric algebra! Designed to be programmer-friendly, specifically because I wanted to use PGA in game development. Development is ongoing.
-
vsepr-rs
A lightweight, high-performance molecular geometry optimizer based on VSEPR theory
-
twibint
arithmetic on arbitrarily large integers. Provides Python bindings as well.
-
radians
storing angles
-
intervalx
A strongly-typed generic interval algebra library for Rust
-
uncertain-rs
uncertainty-aware programming, implementing the approach from 'Uncertain<T>: A First-Order Type for Uncertain Data'
-
nalgebra-spacetime
Spacetime Extension for nalgebra
-
lococode
Location codes inspired by Google's Plus Codes (Open Location Code)
-
wigners
Compute Wigner 3j and Clebsch-Gordan coefficients in pure Rust
-
multiptr
Maximally convenient and efficient wrapper around a pointer to an element within a slice
-
quaternion
type agnostic quaternion math library designed for reexporting
-
brine-fp
192-bit fixed-point math library with logarithmic and exponential functions. Designed for blockchain, scientific, and financial applications.
-
rug_calc
A Rug-powered scientific computing engine featuring high-performance, arbitrary-precision numerical evaluation
-
swh_graph_topology
Collection of topology analysis utilities based on swh-graph
-
ternary_arithmetic
balanced ternary use array logic gate to arithmetic
-
bloomcalc
calculator for bloom filters
-
libdivide
Port of libdivide
-
rship-entities-external
External entities for rship
-
math-differential-evolution
Non linear optimisation library with own DE solvers and interface to NLOpt and MetaHeuristics
-
hilbert_2d
Functions for mapping between 1D and 2D space using the Hilbert curve, and its approximations
-
angle
wrapper to avoid ambiguous parameters + common operation over angles like wrapping, comparisons, arithmetic operations, trigonometric operations and conversions between rad and deg
-
lib-modulo
Fast modular arithmetics
-
isotopes
Variants of common types for enforcing invariance
-
rust-github-action-test-b76u22ivt4z3
四則演算を行うライブラリ
-
moving-average
moving average library
-
simple-arithmetic-coding
Arithmetic coding, directly derived from the well-known CACM87 C-language implementation
-
ndelement
Finite element definition library
-
cnfgen2
Generate DIMACS CNF formula from operations (second version)
-
power_house
deterministic sum-check proofs, finite-field arithmetic, transcript logging, and quorum ledger tooling for transparent verification in Rust
-
Neoprene_Byzantine
has two parts, Neoprene and Byzantine. Byzantine stores an equation and Neoprene computes and compares those equations with interval arithmetic on rationals.
-
dewiz-splitter
Trade splitting algorithms for the DeWiz Tycho solver
-
infinitable
Infinity for types without infinite values
-
compute
statistical computing
-
primal-check
Fast standalone primality testing
-
adlo
Adaptive LLL algorithm for solving SVP
-
signal-transforms
A comprehensive Rust library for discrete and wavelet transforms, including DCT, Dct_2d, DWT2, and more
-
noise-algebra
Easy manipulation of noise functions
-
raven-uxn
Uxn CPU interpreter
-
fixed_math
Some math traits and functions for
fixedpoint numbers -
kanaria
functions such as hiragana, katakana, half-width and full-width mutual conversion and discrimination
-
lidrs
reading and representing light intensity distributions via photometric webs
-
rosu_nps
analyzing note density and distribution in osu! beatmaps
-
lisudoku-solver
Solver for sudoku puzzles used by lisudoku
-
vil_obs
VIL built-in observability — trace spans, counters, latency histograms, lineage
-
aksel
handling scales and transformations
-
pdn-rs
Pure-Rust CBR 6960-U / 7226-U Debt Burden Ratio (PDN) calculator
-
daisycalc
A high-precision terminal scientific calculator
-
qt-artifacts
Infrastructure crate providing metadata and resolution logic for platform-specific Qt distributions
-
hercules
A Heuristics toolbox for QUBO in Rust
-
aliquot
Generating aliquot sequences
-
ruststartracker
Lightweight Star Tracker
-
ruint2
Unsigned integer type with cont-generic bit length
-
pol
An interactive Reverse Polish Notation (RPN) calculator
-
numbat-exchange-rates
fetch and parse currency exchange rates from the ECB
-
fast-graph
A fast, lightweight and extensible implementation of a graph data structure
-
CartesianTree
Build hierarchical Cartesian coordinate systems to easily transform poses
-
geo_distance
calculating distances between 2D points
-
arael-sketch
Interactive 2D sketch editor with real-time constraint solving
-
polyhedron
A half edge and radial edge implementation
-
savan
core library for answer set navigation
-
nndex
In-memory nearest neighbor search engine
-
RayBNN_DiffEq
Matrix Differential Equation Solver using GPUs, CPUs, and FPGAs via CUDA, OpenCL, and oneAPI
-
nereids-core
Core types, constants, and traits for NEREIDS neutron resonance imaging
-
bls12_381-bls
BLS signatures using the BLS12-381 curve
-
math_library
math library
-
doubled
Dekker arithmetic
-
correlation
A very simple crate that implements the calculation of correlation coefficients
-
mv-norm
Multivariate Normal Distribution functions, CDF etc
-
zetamac-rs
Zetamac timed arithmetic test and pratice
-
ekzg-polynomial
methods that are needed for Polynomial objects
-
fin_decimal
A high-performance decimal fixed-point arithmetic library for financial applications
-
hammer-and-sample
Simplistic MCMC ensemble sampler based on emcee, the MCMC hammer
-
oat_rust
User-friendly tools for applied topology
-
mutils
Mathematical-like utilities. Points, Sizes, Colours, maths operating on them. Things like that.
-
surge-opf
Surge OPF — Optimal Power Flow solvers (DC-OPF, AC-OPF, SCOPF)
-
math2
Geometry, layout and rasterization utilities powering the Grida canvas
-
shapers
fitting shapes and operations on geometrical objects
-
vectra
A multi-dimensional array library for Rust, similar to NumPy
-
prime-splines
Spline math — Bezier, Catmull-Rom, B-spline, slerp
-
burn_yono
YoNoSplat model pipeline and utilities for Burn
-
wrapping_in_range
Wrapping arithmetic for any range
-
num-ordinal
Ordinal number types
-
tafrah-math
Math primitives for the Tafrah PQC library (NTT, polynomial ring, modular arithmetic)
-
goad
Compute the single scattering properties of particles much larger than the wavelength of light with geometric optics and aperture diffraction theory
-
factorial_engine
producing factorials
-
measured-process
Linux process metrics for measured
-
sto-ns
A lightweight, pure Rust, no-std kernel for exact ns Slater-type orbital Coulomb integrals, optimized for both semi-empirical and ab initio methods
-
gstools-core
The core functions of GSTools
-
palmfft
Palm-sized Faster Fourier Transform
-
rpoly
algorithm for finding all roots of a real-coefficient univariate polynomial
-
liealg
lie group and lie algebra in rust
-
musclecalc
fitness: estimate the one repetition maximum (1RM)
-
patch-tracker
Patch tracker
-
prime-radiant
Universal coherence engine using sheaf Laplacian mathematics for AI safety, hallucination detection, and structural consistency verification in LLMs and distributed systems
-
turbocollatz-internal
that provides the algorithms and custom type aliases for turbocollatz
-
bitcalc
A calculator with bit operations
-
rcloc
Count, or compute differences of, lines of source code and comments
-
prime-interp
Interpolation — easing, lerp, smoothstep, smootherstep
-
flowstdlib
The standard library of functions and flows for 'flow' programs
-
comfy-bounded-ints
Bounded-integer types focused on ergonomics and safety. (See README.md)
-
tui-math
Render LaTeX math beautifully in terminal UIs with ratatui
-
anim8
Animation toolset
-
ccmath
doing math with complex numbers
-
mikino_api
induction and BMC engine
-
cova-algebra
Cova's algebraic library
-
gloss-geometry
Small library for geometry based utility functions in gloss
-
ntt
Fast NTT (number theoretic transform) for polynomial multiplcation for primes, prime power, and certain composite moduli
-
balanced-direction
manipulate directions with discrete logic
-
geometry-box
Point, Size and u128 boxes that are safe to pass over ffi
-
metatron-qso-rs
Metatron Quantum State Operator - A quantum computing framework based on 13-dimensional sacred geometry
-
irox-stats
Various mathematical and statistics utilities
-
t_convert
can take integer or floating point inputs, or parsed string inputs in order to convert temperature between the units of Celsius, Fahrenheit, and Kelvin
-
paraxis
rock-solid mathematics library
-
qvnt
Advanced quantum computation simulator
-
tfhe-ntt
pure Rust high performance number theoretic transform library
-
ddnnife_cli
d-DNNF toolkit
-
astro-float
Multiple precision floating-point numbers library
-
meansd
calculate mean and standard deviation
-
incerto
Monte carlo simulations
-
playit-agent-core
Contains the logic to create a playit.gg agent
-
smartcalc
Text based calculator for peoples
-
lightwalk
An experimental rust crate for defining signed distance functions in any dimension
-
ohsl
A collection of numerical routines and mathematical types for use in scientific computing
-
runmat-parser
Parser for RunMat (MATLAB/Octave) producing HIR from token streams
-
lean-agentic
Core library for Lean-Agentic: hash-consed dependent types with 150x faster equality
-
nalgebra_block_triangularization
Structural decomposition of sparse matrices into block triangular form using graph algorithms
-
intervals-general
enabling general representation of and operations on intervals over generic types (e.g. supporting units of measure or arbitrary built-in types, or any type with PartialOrd implementation).
-
kitten
light bdd framework for Rust and for those who don't like cucumber - cats don't like cucumbers, kittens are light cats
-
codenano
editing DNA molecular designs
-
growth-and-decay
literally thrown together to solve problems on a math paper
-
metacat
categorical theorem prover
-
hoomd-linear-algebra
Linear algebra types and routines optimized for small matrixes. Part of hoomd-rs.
-
provekit_acvm_blackbox_solver
A solver for the blackbox functions found in ACIR and Brillig
-
arranged
Statically bounds-checked (machine-word-abstracting? TBD) ranged types as zero or low-runtime overhead abstractions providing safe (no unintentional overflow) arithmetic
-
scirs2-linalg
Linear algebra module for SciRS2 (scirs2-linalg)
-
allan-tools
Package to compute statistics to study systems stability
-
logicpearl-ir
Inspectable intermediate representation for LogicPearl artifacts
-
mtxlib
work with matrices
-
clifford-codegen
Code generator for optimized geometric algebra types
-
landmark-common
Common utilities and types for Landmark navigation mesh generation
-
amari-dual
Dual number automatic differentiation
-
rstm-traits
focuses on building concrete implementations for Turing Machines
-
convex-spreads
Spread analytics for the Convex fixed income analytics library
-
rust_decimal_ext
Decimal number implementation written in pure Rust suitable for financial and fixed-precision calculations
-
unicode-math-class
Determine the Unicode class of a mathematical character
-
symtropy-math
N-dimensional geometric algebra: const-generic points, bivectors, rotors, and collision shapes (2D/3D/4D+). Stack-allocated, zero-heap physics primitives.
-
mematrica
An easy to use library for working with matrices
-
franken-decision
Decision Contract schema and runtime for FrankenSuite
-
mdarray-linalg
Linear algebra operations for mdarray, with multiple exchangeable backends
-
inari
interval arithmetic
-
nabled-linalg
Ndarray-native linear algebra algorithms for nabled
-
ga_generator
generating geometric algebra equations for any algebra and dimension
-
amari-calculus
Geometric calculus - unified differential and integral calculus using geometric algebra
-
math-symbols
Symbols for computer algebra
-
alloy-deploy-profile
Shared deployment-profile facade for the Alloy workspace
-
spynso3
Pyo3 bindings for spenso
-
clifford-3-even
even sub-algebra of 3-dimensional clifford algebra, specifically for qubit processing
-
goldenfloat-sys
FFI bindings to GoldenFloat C-ABI library (φ-optimized 16-bit floating point format)
-
cork
A command-line calculator for hex-lovers
-
qhull-enhanced
Rust bindings to Qhull
-
argentum_log_business
Business layer of encryption
-
mathlex-eval
Numerical evaluator for mathlex ASTs with broadcasting support
-
angulus
Unit agnostic angle
-
dynast
Feynman graph topology identification
-
quantogram
Approximate quantiles using histograms with logarithmically sized bins to guarantee worst case absolute relative error
-
gluex-lumi-py
Python bindings for the gluex-lumi Rust crate
-
tofas_extras
Translation of fundamental astronomical subroutines
-
tl_backend
GPU Backend Trait Definitions for TL
-
expression_engine_lts
An expression engine written in pure rust (LTS)
-
blas
The package provides wrappers for BLAS (Fortran)
-
plonky-cat-field
Field abstractions for plonky-cat: BabyBear, Goldilocks, Mersenne31
-
aljabr
A tiny computer algebra system
-
vecmat
Low-dimensional vector algebra with min_const_generics support
-
decimus
Decimal Floating-Point Math Library for Rust
-
csa-rhdl
Carry-save adder compressor trees composed via comp-cat-rs, with hdl-cat backend
-
ruqu-quantum-monitor
Anytime-Valid Quantum Kernel Coherence Monitor (AV-QKCM) - Sequential MMD testing with e-values for quantum syndrome distribution drift detection
-
stacked_linear_algebra_graph
Embedded in-memory graph using sparse linear algebra
-
mumps-src
Build Mumps as a crate
-
symexpr
A libray to build symbolic expression and evaluation
-
pigeons
writing VeriPB proofs
-
jpegxl-src
Source of libjxl and logic to build it
-
ramanujan
mathematical functions, linear algebra, stats etc
-
pandrs
A high-performance DataFrame library for Rust, providing pandas-like API with advanced features including SIMD optimization, parallel processing, and distributed computing capabilities
-
microcad-lang-base
µcad language basics
-
csta
Makes it somewhat easier to do metropolis and montecarlo stuff
-
equation
mathematical expression evaluation and simplification
-
yufmath
CAS Lib
-
dimensional_analyser
Runtime dimensional analysis and unit-aware quantities for Rust
-
gpca
'Async Hyper-Graph Cellular Automata' computational model
-
reference-interval
reference interval helpers a.k.a. reference range helpers.
-
kure2
Safe bindings for Kure2, a C library which provides manipulation of relations and operations of relation algebra
-
cas-rs
A CalcScript executor and REPL
-
gomez
Framework and implementation for mathematical optimization and solving non-linear systems of equations
-
rmathlib
Port of R's C Library of Special Functions
-
qox
Quantitative finance library for Rust (Alpha)
-
num-algebra
an algebra num type
-
num-iter
External iterators for generic mathematics
-
saturating_cast
saturating casts between integer primitives
-
fastcwt
Rust-lang Continuous Wavelet Transform(CWT) library inspired by fCWT
-
advanced-algorithms
A comprehensive library of advanced algorithms for numerical analysis, linear algebra, cryptography, optimization, and graph theory
-
proj5
Pure Rust, type-safe alternative to PROJ.4
-
sprs-ldl
Sparse cholesky factorization
-
sm-2
Spaced Repetition
-
ear-algae
Linear algebra featuring Vectors, Normal Vectors, Matrices, Rotors (Unit Quaternions) and Rigid Transforms (Rotation + Translation)
-
scirs2-integrate
Numerical integration module for SciRS2 (scirs2-integrate)
-
glamx
Extensions for glam: Pose2, Pose3, Rot2, and matrix utilities
-
minuit2
Pure Rust port of CERN Minuit2 parameter optimization engine
-
catapulte-domain
Core domain layer for catapulte - business logic and port traits
-
mazer-atog
lookup table for common mathematical symbols
-
quadratic_residues
calculating quadratic residues of integers
-
gasteiger-rs
A lightweight, zero-dependency Rust crate for Gasteiger-Marsili PEOE partial atomic charge assignment
-
csvbinmatrix
Binary matrix Compressed Sparse Vector
-
boolmesh
Robust 3D mesh boolean library
-
deep_causality_discovery
Causality discovery DSL for the DeepCausality project
-
prop
Propositional logic with types in Rust
-
koto_geometry
A Koto library with basic geometry types and operations
-
vector_2d_3d
small library for 2D and 3D vectors
-
shannon-nu-table
Nushell table printing
-
apex-camera-models
Camera projection models (pinhole, fisheye, omnidirectional) for bundle adjustment
-
coordinates
no nonsense, library for using two and three dimensonal coordinates in several systems
-
number-theory
Fast primality, factorization and elementary number theory for integer types
-
stochasta
stochastic analysis library
-
perfgate-stats
Statistical functions for benchmarking analysis
-
rfa
A port ERFA to Rust
-
un_algebra
implementations of selected abstract algebraic structures--including groups, rings, and fields. Intended for self-study of abstract algebra concepts and not for production use.
-
cubecl-common
Common crate for CubeCL
-
synerise/cleora
general-purpose model for efficient, scalable learning of stable and inductive entity embeddings for heterogeneous relational data
-
theseus-lua-src
Sources of Lua 5.1/5.2/5.3/5.4 and logic to build them. Fork with Factorio lua.
-
smtkit
Facade crate for SMT constraint IR + SMT-LIB backends
-
mangle-ast
Mangle, a logic programming language
-
rdsmath
Minimal math library for no_std environments - RedstoneOS
-
vision-mvg
Multiple-view geometry: epipolar geometry, triangulation, homography, robust estimation
-
logicaffeine-language
Natural language to first-order logic pipeline
-
mathematica-notebook-filter
mathematica-notebook-filterparses Mathematica notebook files and strips them of superfluous information so that they can be committed into version control systems more easily -
image_processing
This package provides tools for image processing with a focus on edge detection and morphological transformations
-
rx_core_observable_iterator_on_tick
iterator observable for rx_core, emitting on discrete ticks instead of immediately
-
matmul
Fast matrix multiplication in Rust with AVX2/AVX-512 SIMD, built from scratch
-
tilezz
work with perfect-precision polygonal tiles built on top of complex integer rings
-
cad-cs
Calculations on Coordinate Systems (2D/3D geometry, vectors, transformations)
-
fixed_trigonometry
Fixed point numerical approimations to trigonometric functions
-
simple_add
一个简单的两个数求和库
-
hfs
Hereditarily finite sets
-
molcrafts-molrs-cxxapi
CXX bridge for Atomiverse C++ integration
-
talos_common_utils
Common utilities used in Talos
-
math-core-cli
CLI for converting LaTeX equations to MathML Core
-
lib
LIB: Math and container utilities for Rust. Notice: study purpose, not production ready.
-
g3
Neat library for computer graphics based on geometric algebra
-
cliffy-core
Reactive UI framework with geometric algebra state management
-
descent
Modelling and automatic differentiation for constrained optimisation
-
arithmetic-parser
Parser for arithmetic expressions with flexible literals and type annotations
-
numbat-cli
A statically typed programming language for scientific computations with first class support for physical dimensions and units
-
gcdn
An algorithmically faster implementation of variadic GCD
-
optimization-solvers
Numerical optimization solvers for unconstrained and simple-bounds constrained convex optimization problems. Wasm compatible
-
qudit-expr
Accelerated and Extensible Quantum Library
-
anybase
High-performance arbitrary base integer conversion library
-
fromsoftware-shared
Helpers for dealing with pointers and other common stuff across games
-
vitin-calculator
calculator library
-
gananayantra-rusting
A professional-grade, multi-industry calculation library for Rust (Finance, Health, Energy, Geo, Space, Physics, Climate, Logistics)
-
mesh-graph
Fast halfedge triangle mesh graph in pure Rust
-
v_eval
Expression evaluator with context
-
ruma-push-gateway-api
Types for the endpoints in the Matrix push gateway API
-
mathhook
High-performance educational computer algebra system with ergonomic Rust macros
-
irox-units
Physical Quantities, Units, & Reference Frames Library
-
rust-poly
Numeric manipulation of real and complex polynomials
-
spora
A small utility crate that currently provides basic arithmetic helpers
-
codemem-engine
Domain logic engine for Codemem: indexing, hooks, watching, scoring, recall, consolidation
-
ffnt
Finite fields for number theory
-
chfft
Fastest Fourier Transform library implemented with pure Rust
-
ring-algorithm
algorithms on ring (Abstruct Algebra)
-
polars-python
Enable running Polars workloads in Python
-
faddeeva-sys
binding for The Faddeeva Package
-
math_calculator
a lib with math expr ast build and exec
-
hexga_typedef
Provide a common typedef for
float,intanduint. The precision can be changed with feature flags and can be easily shared across multiple crates. -
fwd_ad
Forward auto-differentiation, allowing its user to manage memory location and minimize copying
-
suitesparse_graphblas_sys
Rust bindings for SuiteSparse::GraphBLAS
-
polydf
Distance queries for parametric curves in 2D and 3D (nearest point, unsigned distance, early-out with speed bounds)
-
nalgebra-lapack
Matrix decompositions using nalgebra matrices and Lapack bindings
-
smartcalc-tauri
Text based calculator for peoples supported in Tauri
-
mbimap
Pooled bijective maps in Rust
-
intervals
A generic interval type with support for open/closed bounds
-
neco-sparse
Lightweight COO / CSR sparse matrix types
-
lcalc-cat
Limiting dilution analysis with maximum likelihood estimation, built on comp-cat-rs
-
candle-mps-flash-attention
MPS Flash Attention for candle - O(N) memory attention on Apple Silicon
-
inrust
Accumulate knowledge of my study on Rust language
-
autoeq-roomsim
Room acoustic simulator
-
bcurve
DLMM bonding curve
-
cruxi-retry
Retry logic with exponential backoff for the Cruxi framework
-
spm_core
Core business logic for spm-swift-package
-
ferray
A NumPy-equivalent library for Rust — N-dimensional arrays with SIMD acceleration
-
Cadrs
Cadsdk for rust
-
rpn-c
A calculator environment using Reverse Polish Notation and multiple precision numbers
-
aligrator
A lightweight numerical integration library
-
ParetoRs
Pareto-optimal cost engine for AI coding agents
-
eta-core
Eta calculus Core (no_std)
-
vec3-rs
minimal 3d vector implementation
-
fugue-ppl
Production-ready monadic PPL with numerically stable inference, comprehensive diagnostics, and memory optimization
-
nexsys
Solve nonlinear systems of equations using Newton's method
-
model2vec
H2CO3's & Narnium's Rust Implementation of Model2Vec
-
gaussian_kde
Multivariate kernel density estimation with Gaussian kernels and optionally weighed data points
-
kalkulator
A mathematical expression evaluation tool and library
-
trig
Complete set of trigonometric and hyperbolic functions in Rust
-
glpk-rust
Rust wrapper for GLPK (GNU Linear Programming Kit) with static linking
-
flavio
welcomes you
-
gd-death-counter
A death counter for Geometry Dash
-
nimber
calculating in Conway's nim-arithmetic
-
value-expr
easy expression
-
input_output
一个用于处理大数输入输出的 Rust 库
-
num-runtime-fmt
Format numbers according to a format spec determined at runtime
-
amari-tropical
Tropical (max-plus) algebra implementation
-
nbcs
checksum calculator for hexadecimal strings
-
compute-tau
designed for computing tau to millions of digits
-
algebraic_immunity
A package to compute the algebrac immunity of Boolean functions
-
pocket_prover
A fast, brute force, automatic theorem prover for first order logic
-
fastnum2
fork of Fast decimal numbers library
-
avila-linalg
Avila Linear Algebra - Álgebra linear genuína em Rust para o ecossistema Avila (vetores, matrizes, SVD, eigenvalues)
-
fenris
advanced finite element computations in Rust
-
feo-math
Math library for 3D transformation
-
oximedia-360
360° VR video processing — equirectangular/cubemap projections, stereo 3D, spatial metadata for OxiMedia
-
kaio-ops
Pre-built GPU operations for KAIO. Matrix multiplication, attention, auto-tuning.
-
vom_rs
Probabilistic Finite Automata
-
const_poly
Evaluate any multivariable equation or polynomial at compile time with high accuracy and zero runtime overhead
-
espada
Texas Hold'em poker odds evaluator
-
ravencol
Tabular data manipulation
-
speechbrain-fbank
SpeechBrain-style FBANK feature extraction in Rust
-
prime-osc
Oscillators — LFO shapes, ADSR envelope
-
dexterior
Discrete Exterior Calculus toolkit
-
aviation_calc_util
assist with aviation related calculations
-
bit-vec-omnitool
A vector of bits
-
sparse_complex
solver for complex sparse matrices
-
bt_math
Basic math expression evaluator library. Support basic math operators (+,-,*,/,^), parenthesis, and functions such as log10, ln, log2, exp, sin, cos, tan, asin, acos, atan, abs, sqrt…
-
math-rs
A basic mathematical engine
-
lobatto-spectral
High-order screened Poisson solvers on Gauss-Lobatto grids
-
rquant
A quantum computing library for qubit manipulation and observation
-
zagreb-lib
analyzing graph properties using the Zagreb index and Hamiltonian criteria
-
hastycalc
A fast and memory effencient calculator library
-
tauformer
A Transformer Architecture using arrowspace's taumode
-
lazy_simd
Trait based SIMD acceleration and safe abstraction
-
RustFrames
A blazing-fast, memory-safe alternative to NumPy + Pandas, written in Rust
-
dala
Dalia is a light weight formula language
-
similarity-least-squares
Least-squares estimation of transformation parameters between two point patterns
-
neco-nurbs
2D rational NURBS curves and region representation
-
prime-signal
Signal processing — smoothdamp, spring, low_pass, deadzone
-
grid-math
containing basic representation of Grid, Cell, and assosiated mathematical operations. Helpful in CLI-based gamedev.
-
cutup
A flexible and efficient allocation library for Rust, capable of distributing assets, resources, and other divisible entities
-
quaigh
Logic optimization library
-
unit-root
Unit root tests
-
rscopulas
Core Rust library for fitting, evaluating, and sampling copula models and vine copulas
-
malachite-nz
The bignum types Natural and Integer, with efficient algorithms partially derived from GMP and FLINT
-
rain_linalg
Linear algebra library for Rust
-
verifiable_encryption
Verifiable encryption schemes - Encryption of discrete log from DKG-in-the-head
-
dicoco_safe_math
simplified safe math operations
-
corevm-prime-sieve-bin
prime sieve program for CoreVM. Prebuilt binary.
-
curv-kzen
Curv contains an extremely simple interface to onboard new elliptic curves. Use this library for general purpose elliptic curve cryptography
-
my-rust-lib-1
High-quality integration for https://supermaker.ai/
-
ecoord
transforming between 3D coordinate frames
-
camera-intrinsic-calibration
Camera Intrinsic Calibration
-
point_process
simulating random point processes
-
vakint
Computation of single-scale vacuum integrals for High-Energy Physics
-
asset-importer-rs-scene
Scene module for asset-importer-rs
-
stensor
Cross-platform GPU tensor library with Slang and Rust
-
reduction-factor
type representing reduction factor
-
eenn
A hybrid neural-symbolic constraint solver with cognitive reasoning capabilities
-
envisim_estimate
Design-based estimation and variance estimation
-
spatial
An N-Dimensional R-tree family spatial tree implementations
-
rong_jscore
JavaScriptCore backend for RongJS
-
voxel-tiler-core
Convert point clouds to voxel data
-
lowbulls
lowbull is a Rust crate facilitating message handling and event monitoring
-
minimax-alpha-beta
Alpha-Beta Pruning + Minimax Algorithm for arbitrary two player minimax style games like Chess, Go, TicTacToe, etc
-
br-maths
maths
-
online-statistics
Blazingly fast, generic, and serializable online statistics
-
matrijs
A small 2D matrix library. There are many like it but this one is mine.
-
board-game-geom
Geometry library for board game
-
sparse21
Sparse Matrix Solver
-
tree-sitter-xdy
tree-sitter grammar for xDy dice expression language
-
rect-iter
Iterator for 2D rectangle areas
-
rmumps
Pure Rust multifrontal sparse symmetric indefinite solver
-
lie-rs
Lie series and Baker-Campbell-Hausdorff formula computations
-
sqpnp_simple
SQPnp camera pose estimation
-
amfnengine
Amortization Functions (AmFn) Engine
-
boolean-circuit
import, modify and export boolean circuits
-
cruxi-metrics
Metrics collection interface for the Cruxi framework
-
basic_stats
Lightweight library with basic statistical estimators and hypothesis tests
-
sophus
geometry for robotics and computer vision
-
kalman
filter
-
piecewise-linear
manipulating piecewise linear functions
-
goertzel_thd
A small no_std crate to compute THD using the Goertzel algorithm
-
kreise-engine-math
Krei.se Engine Rust Math-Package
-
guff
Implements Galois Fields for various natural sizes
-
div-pow10
Fast division by powers of 10
-
softfloat-wrapper
a safe wrapper of Berkeley SoftFloat based on softfloat-sys
-
jyafn
Computational graphs for Data Science that compile to machine code
-
saturation
Real-time saturation and clipping designed for use with vst's
-
robust-predicates
Robust predicates for computer geometry
-
replicante_logging
Replicante common logging logic
-
toto
conversion method between basic numerical types
-
luacad
A Lua-based CAD scripting engine built on CSG operations
-
xod
A tiny REPL for bitwise arithmetic and expression evaluation
-
lll-rs
LLL algorithm for lattice reduction and it's improved version L²
-
krnl
Safe, portable, high performance compute (GPGPU) kernels
-
ellp
Linear programming library that provides primal and dual simplex solvers
-
dual_balanced_ternary
Dual Balanced Ternary Arithmetic
-
bitsliced-op
exposes bitsliced operations that can be used in reduction functions for rainbow tables
-
abtz-adder
Add demo
-
augurs-outlier
Outlier detection for time series
-
hyperion
Generic LSystem implementation
-
polyhedron-ops
Conway/Hart Polyhedron Operations
-
blanko_quaternions
My personal library for (dual) quaternions and complex/dual numbers
-
divrem
Division and modulus variants
-
reda-geometry
geometry library
-
exo-manifold
Continuous embedding space with SIREN networks for smooth manifold deformation in cognitive AI
-
cardo
Frame-safe geometry with compile-time checking
-
frlearn_math
Fuzzy/rough math primitives and safe numeric transformations
-
ginger-rs
Parallel Bairstow Root-finding Method in Rust
-
gollum-query-planner
Query execution planner for the Gollum language
-
butterworth
filters
-
ironclad-nodes
Standard node pack for Ironclad (built-in nodes registered for ironclad-runtime)
-
neo-zkvm-cli
CLI for Neo zkVM script execution, proving, and verification
-
quad-rs
Adaptive Gauss-Kronrod Integration in Rust
-
rithmetic
An experimental math library
-
kifmm
Kernel-independent fast multipole method
-
stats-ci
A pure Rust library for computing and working with confidence intervals on sample data
-
bitgauss
A fast boolean linear algebra library
-
probability_cli
A command line interface for probability calculations using Bayesian probability
-
flag-algebra
Razborov's flag algebras
-
intervalsets
bounded and unbounded intervals implemented as sets with all the associated set operations
-
sr-rcd
Apply Refining-Cover-by-Defect algorithm to solve Sound Ranging problem in time-dependent-metric (and, in particular, (quasi-)metric) spaces
-
logic-eval-util
logic-eval
-
semolina
Optimized field arithmetic for Pasta moduli for x86-64 and aarch64
-
octonion
Minimal, dependency-free, no_std octonion algebra
-
rats-rs
Rapid Augmentations for Time Series
-
neco-dop853
Dormand-Prince 8(5,3) adaptive Runge-Kutta integrator
-
mstlo-macros
Procedural macros for the mstlo online Signal Temporal Logic (STL) monitoring library
-
nalgebra-sparse
Sparse matrix computation based on nalgebra
-
C4lc
help you perform mathematical calculations, including addition, subtraction, multiplication and division, others included
-
cheesecake
Math animation engine
-
aris
A mathematical computing library
-
geosets-rs
continuous set arithmetic
-
simp_linalg
A generically defined, light-weight linear algebra library for simple addition and multiplication of vectors and matrices
-
tl_cpu
CPU tensor backend for TL
-
cgmath
A linear algebra and mathematics library for computer graphics
-
collatz_rust
Code for testing an extention of the Collatz Conjecture
-
avr-q
Fixed point arithmetic for AVR
-
symbolic_math
performing symbolic mathematics. Supports basic arithmetic operations, expression simplification, and expansion, and evaluation.
-
slsqp-rssl
slsqp rust impl, ported from scipy Fortran impl
-
cyclotomic
high-performance library for exact operations in cyclotomic fields
-
tuppu-algebra
Geometric algebra with exact rational coefficients — vectors, bivectors, rotors, and more
-
rational_extensions
Extensions for rational numbers
-
nalgebra_latex
several robust formatters for nalgebra::Matrix, LaTeX environments, and more
-
opensrdk-linear-algebra
Standard linear algebra library using blas and lapack for OpenSRDK toolchain
-
incomplete-rexl
Pure-Rust modular arithmetic and NTT library with AVX-512 acceleration
-
monatq
Approximate quantile tracking for tensors using T-Digest, with element-wise parallel updates
-
kalc-lib
a complex numbers, 2d/3d graphing, arbitrary precision, vector/matrix, cli calculator with real-time output and support for units
-
libmat-rs
Rust bindings for libmat, an stb-style single-header linear algebra library in pure C
-
inari_wasm
A stripped-down version of Inari library (a Rust implementation of interval arithmetic) compatible with web assembly
-
tfhe-fft
pure Rust high performance fast Fourier transform library
-
advancedresearch-path_iter
A cocategory enumeration library based on path semantics
-
formally
the open-source formal methods toolchain
-
codd
minimal in-memory database with relational algebraic expressions as queries
-
ndfunctionspace
Finite element function spaces
-
fibonacci-numbers
The 186th Fibonacci number
-
dashu-int
A big integer library with good performance
-
parth10606_first_crate
A test lib for publishing
-
haje
A linear algebra library, developed by yours truly, and probably not that efficient
-
linalg-traits
Traits for generic linear algebra
-
argentum_event_business
Business layer of Event component
-
internal-russh-num-bigint
Big integer implementation for Rust
-
xdd
Decision diagrams including BDD, ZDD, MBDD, πDD and more for combinatorics
-
minifloat
Emulate various minifloats
-
connect-four-solver
A strong and perfect connect four solver in Rust
-
floco
validates floats against constraints
-
prime-spatial
Spatial queries — ray tests, AABB, frustum culling
-
vecs
Vector Math Crate
-
permu-rs
A collection of utilities for permutations. It contains useful tools to create, manage and experiment with permutations.
-
uzor-autodetect
GPU auto-detection for uzor applications
-
sym-adv-encoding
UTF-8 and byte encoders for ring-element payloads used in the symmetric-cryptography PhD artifacts
-
taco-smt-encoder
defining the SMT encodings of threshold automata components into SMT. This crate is part of the TACO toolsuite.
-
nibbler
A small utility for working with nibbles (half byte, 4-bits)
-
matrix_operations
perform matrix operations
-
gaussian_curve_fit
A
no_stdand noalloclibrary for gaussian curve coefficents calculation -
hmmmm
Performant and easy-to-use hidden Markov models
-
sylvan-sys
Bindings for the Sylvan parallel decision diagrams library
-
gmres
A sparse linear system solver using the GMRES iterative method
-
vectormatrix
Idiomatic Matrix and Vector types for Rust
-
modular_equations
Program to solve quadratic and linear modular equations
-
int-div-cum-error
Primitive integer division with rounding kind and cumulative error
-
optlib
The optimization algorithms realized in Rust. In given time realized genetic and particle swarm algorithms.
-
scivex-stats
Scivex — Statistical distributions, hypothesis tests, correlation, regression
-
fast-srgb8
Very fast conversions between linear float and 8-bit sRGB (with no_std support)
-
abstalg
Abstract algebraic structures for Rust
-
celestial-core
Core types and utilities for the Celestial astronomy library
-
mruby-math
Math module for mruby/edge
-
suma_ulsa
Sistema Universitario de Métodos Académicos (SUMA) - librería Rust con bindings Python
-
reikna
A work in progress math library
-
tinyfield
Small, finite fields
-
one-euro
Multidimensional implementation of 1€ Filter
-
math-xem-common
Common types and utilities for BEM/FEM room acoustics simulators
-
cobre-solver
LP/MIP solver abstraction layer with HiGHS backend for power system optimization
-
multi-skill
Skill estimation systems for multiplayer competitions
-
med-bed
Digital MedBed protocol - heal consciousness by replacing dissonant genes with resonant ones
-
interaction-calculus
A parallel model of computation
-
haxcel
Excel gateway to Haskell
-
decnumber-sys
Low-level bindings for libdecnumber
-
windowfunctions
Common window functions for apodization
-
clausen
functions
-
maths-traits
abstract system of mathematical traits for the Rust language
-
cubek-matmul
CubeK: Matrix Multiplication Kernels
-
hilbert-geometry
Hilbert-encoded geometries. Currently only supports lon/lat coordinates.
-
d4-arjun-sys
wrapper around Arjun for d4
-
oldies-cli
Interactive CLI for OldiesRules - Run legacy simulators with modern UX
-
wavegen
Wavefrom generator library
-
math-wave
Analytical solutions for wave and Helmholtz equations
-
wagyu-rs-cli
CLI for wagyu-rs geometry boolean operations
-
nexcore-registry
SQLite registry for Claude Code skills, agents, metrics, and KPIs
-
deterministic-trigonometry
Trigonometry without floating point variables to achieve deterministic results across hardware and compilers
-
yoda-calculator
command line app that acts as a scientific calculator, operating through commands instead of buttons
-
rma
Rare, high-performance mathematical algorithms for Rust
-
amari-network
Geometric network analysis using Clifford algebra and tropical algebra
-
mraphics-mobject
Built-in mobjects(math objects) of Mraphics
-
faer-entity
Basic linear algebra routines
-
fuzzy-logic_rs
fuzzy logic in rust!
-
parry2d-f64
2 dimensional collision detection library in Rust. 64-bit precision version.
-
cellular_raza-building-blocks
cellular_raza Building Blocks
-
vhe
ElGamal homomorphic encryption library with verifiable operations
-
neophyte-linalg
Linear algebra types for Neophyte
-
vedaksha-math
Numeric primitives for Vedākṣa: Chebyshev polynomials, angle arithmetic, interpolation, rotation matrices
-
basic_dsp
Digital signal processing based on real or complex vectors in time or frequency domain
-
polynomial_subspaces
general ways to deal with subspaces of the polynomial rings R[X] with R some ring
-
i48
working with 48-bit integers
-
mech-logic
Logic library for the Mech language
-
mermin
k-atic alignment analysis of fluorescence microscopy
-
ml-distance
Distance-based methods for vector comparison and analysis. (Porting of the JS/TS pkg
ml-distanceto Rust) -
simple-vectors
dimension generic vector math
-
iseven_api
wrapper for isEven API
-
pbrt
https://pbrt.org/
-
classgroup
class groups in Rust. Uses GMP for arithmetic.
-
tribev2-video
V-JEPA2 ViT-G video feature extraction for TRIBE v2 (burn backend)
-
zero-plonk
A pure-Rust implementation of the PLONK ZK-Proof algorithm
-
rug-maths
rug wrapper implementing maths-traits
-
gchemol
Graph-based CHEMical Objects Library
-
lox-math
Mathematical utilities for the Lox ecosystem
-
runmat-async
Shared async runtime error types and host I/O interaction primitives for RunMat
-
calculator-huggoxbyte
Uma biblioteca de calculadora com u32
-
munum
Micro 3D Math Library
-
lapack-inject
LAPACK compatible interface backed by runtime-registered Fortran LAPACK function pointers
-
isochronous_finite_fields
Isochronous implementation of GF(2^8) arithmetic
-
ty-math
Math types and utilities shared across all tyt crates
-
honeycomb-render
Visualization tool for combinatorial maps
-
chctools
a chc-tool for personal usage, simply parse the token and do small transportation
-
r-src
The package provides a source of BLAS and LAPACK via R
-
vectors
Sparse & dense vectors for use in high dimensional vector spaces
-
prime-sdf
Signed distance functions — 2D and 3D primitives, CSG operations, domain transforms
-
inovo-rs
API for intergrating inovo robot arm
-
jsi-rs
Rust bindings to JSI (JavaScript Interface) using cxx
-
rs-ml
ML crate including Gaussian Naive Bayesian classifier
-
markovgen
building markov chain graphs from text datasets and performantly generating text sequences by traversing them, includes an accompanying CLI application
-
polygon-offsetting
polygon offsetting crate
-
celestial-pointing
Telescope pointing model fitting and correction
-
measurements
Handle metric, imperial, and other measurements with ease! Types: Length, Temperature, Weight, Volume, Pressure
-
slop-dft
Discrete Fourier Transform operations for tensors in SLOP
-
resistor-tui
Program to calculate resistors
-
mini-matrix
A mini linear algebra library implemented in Rust
-
inexor-rgf-plugin-json
Inexor - Reactive Graph Flow - Plugin - JSON
-
tiny_vect
A minimal vector math library for 2D and 3D operations in Rust
-
exg-source
EEG source localization (MNE / dSPM / sLORETA / eLORETA) — pure Rust
-
kneasle_ringing_utils
'kitchen sink' utility library for my ringing projects
-
squiid-engine
Squiid Engine is an RPN mathematical engine written in Rust
-
root1d
One dimensional root finding algorithms
-
gauss_solver_3x3
Um solver determinístico e sem alocação em heap para sistemas lineares 3x3 usando Eliminação de Gauss
-
tablefi
table to store, manipulate and format tabular data
-
semdiff-differ-image
Image diff calculator and reporters for semdiff
-
YetAnotherGeometryLibrary
A geometry library. Includes computational geometry.
-
rusty_math
mathematical, statistical and machine learning operations
-
fpmath
A floating point math library
-
neco-radiation
Acoustic radiation power estimators for vibrating surfaces
-
fast_fp
Floating point fast-math optimizations
-
fenris-paradis
Parallel processing of disjoint indices for the fenris library
-
number_prefix
numeric prefixes (kilo, giga, kibi)
-
euca-math
SIMD-ready game math: Vec2/3/4, Quat, Mat4, Transform, AABB — zero deps beyond serde
-
scirs2-wasm
WebAssembly (WASM) bindings for SciRS2 - JavaScript/TypeScript interop for scientific computing
-
neco-gf256
zero dependency GF(2^8) finite field arithmetic
-
opensrdk-probability
Standard probability library for OpenSRDK toolchain
-
ogsolve
The program for solving octal games
-
shadermath
HLSL inspired mathematics library for Rust
-
aprender-simulate
Unified Simulation Engine for the Sovereign AI Stack
-
rough2
Find the nearest fraction for some number
-
collatz
Helper functions related to the Collatz conjecture
-
rustneuro
neural signal analysis and feature extraction for scientists who require fast computation
-
amari-info-geom
Information geometry and statistical manifolds
-
cliffy-test
Algebraic testing framework for Cliffy - tests as geometric invariants
-
ointer
Steal the high bits of a pointer to store an extra value
-
jito-grpc-client
Client to send transactions to a Jito blockengine node via gRPC connections
-
stacksdapp-scaffold
The asset provider and scaffolding engine containing the Next.js frontend templates and project initialization logic
-
fj-export
Early-stage b-rep CAD kernel
-
algebra
Abstract algebra for Rust
-
numerics-rs
Blazing fast numerical library written in pure Rust
-
ibdgen
Generate incomplete block designs for experiments with prohibited pairs
-
vil_duration
VIL Expression function — duration parsing and arithmetic
-
hexagon_tiles
that allows working with the hexagon shape and related math
-
plonky-cat-reduce
Core claim-reduction coalgebra unifying FRI and sumcheck
-
algebraeon-geometry
Algorithms for working with geometric shapes
-
circle
Definition of circle and ellipse
-
e9571_math_lib
high-precision numerical calculations and percentage comparisons
-
convex-curves
Term structure framework for yield curves, credit curves, and multi-curve environments
-
collatz_conjecture
A small project demonstrating the collatz conjecture, a maths problem
-
bellande_node_importance
calculating n-dimensional node importance via API or local executable
-
mathsharp
collection of mathematical functions and resources to assist in solving a wide range of topics
-
symbolic_regression_wasm
WASM bindings for symbolic_regression (browser-friendly wrapper via wasm-bindgen)
-
comodules
calculating Ext for coalgebra and comodules. Also does Finite Field linear algebra.
-
r_mathlib
A port of R’s
nmathstats module to Rust -
magnet_rs
User friendly magnetic field calculations in Rust
-
sum-calc
A sum calc
-
dfwasm
Main CLI for the dfwasm compiler
-
phyz-math
Spatial algebra and math primitives for phyz physics engine
-
calculator-danielgorgonha
u32 operations including power and logarithm
-
deepcorr-normalization
Lower level crate for DeepCorr which handles data normalization. Can be uses standalone too.
-
cadical
Rust bindings for the CaDiCaL SAT solver
-
cargo-cellbook
Cellbook project runner and command line utility
-
ramp
A high-performance multiple-precision arithmetic library
-
computorv1
An educational computor project solving polynomial equations
-
get-hash
Get hash of a string
-
math_matrix
highschool level matrix implementation
-
cp_sat
Rust bindings to the Google CP-SAT constraint programming solver
-
mangle-parse
Mangle, a logic programming language
-
ariprog
Need a powerful and simple library to work with arithmetic progressions in Rust? You should definitively try out ariprog!
-
vda5050-types
Types defined by the VDA5050 standard for AGV communication
-
polenta
A toy language about polynomials over finite-fields
-
boolean-logic
propositional logic evaluator that creates truth tables for propositional expressions
-
chrom
representing colours
-
sequential-integration
Lightweight library for sequential integration
-
sieve-of-eratosthenes
A standard implementation of the Sieve of Eratosthenes
-
lrk
learning rust
-
solver
Solve optimization problems
-
arith_wrappers
Rust’s
stdoffers theWrappingtype for “intentionally wrapping” arithmetic, but curiously does not provide analagous implementations for intentionally saturating… -
precision-core
Deterministic fixed-point arithmetic for financial computation
-
snafu-numbers
Special Numeral-Analogue Fuel Units
-
lnexp
Carefully evaluate compositions of log, exp, log1p and expm1
-
tfns
TranscendentalFunctions: a math tool
-
cayley
generic, stack-allocated linear algebra stuff, such as matrices
-
q-rust
A modular quantum transpiler and QASM 2.0 parser written in Rust
-
cvxrust
Disciplined Convex Programming
-
awint_dag
DAG
awintfunctionality -
gnc
Spacecraft GNC library with C/C++ and NASA F-Prime bindings
-
gwrs
studying data from ground-based gravitational-wave detectors
-
woxi
Interpreter for a subset of the Wolfram Language
-
map-range
map a value from a range to another range
-
fitme
CLI curve fitting tool. Parameterise an equation from a CSV dataset.
-
trueno-solve
Dense linear algebra solvers — LU, QR, SVD, Cholesky with provable contracts
-
project_euler_lib
project euler
-
xteur
Institutional-grade RWA infrastructure. Building secure settlement logic and liquidity mobility.
-
vax-floating
VAX floating-point types
-
pathwise-core
High-performance SDE simulation engine: Euler, Milstein, SRI (strong-order 1.5), CIR, Heston, correlated OU
-
microtensor
Automatic differentiation for tensor operations
-
convg
convert directed and undirected graphs from NAUTY and Traces into adjacency, dot, and net files
-
decimal64
Fast fixed point arithmetic that only uses u64 as internal representation
-
real_float
Floating point types that check for correctness and implement total ordering
-
strong-kleene
Strong Kleene logic in Rust
-
pz_spectra
ezpz fft
-
blazing_fibonacci
A fast Fibonacci number calculator using matrix exponentiation and fast doubling
-
zeuhl_sem
A sem (Simultaneous Equation Model) that has the ability to solve equations using Gaussian elimination or Jacobi methods
-
fermentation
The good kind of decay; forward decay
-
asmcahligzamaze
Schizm and amalgamation of adventurer's probability distribution across multiverse 2D maze on a single screen
-
discrete-logarithm
Fast discrete logarithm solver
-
type_eval
Type level evaluation and proof-carrying
-
chewy
A command-line RPN calculator
-
zero_based_index
Newtype offering some utility methods for zero-based indices
-
gecl
geometry types and a color type
-
rsl-interpolation
A re-write of GSL's Interpolation Routines in Rust
-
harness-algebra
algebraic structures
-
ekore
EKO expressions
-
cf_functions
has characteristic functions for a variety of distributions
-
fhe-util
fhe.rs library
-
mathcore
Symbolic math library and computer algebra system for Rust
-
laddu-extensions
Extensions to the laddu library
-
gsdesign
Group sequential design
-
bubblesort-ifyer
Sorts stuff using Bubblesort!
-
cas-compute
Tools for evaluation of CalcScript expressions
-
lemonmath
A math library
-
cas-unit-convert
Unit conversion library for CalcScript
-
dual_quaternion
A type-agnostic dual-quaternion math library
-
zeuhl_fraction
fraction used in matrix operations
-
qmat
2-dimensional matrices
-
zetik
Hub for personal code used on high side
-
antbox-geom
Two-dimensional logical grid coordinate utilities for
antbox -
mathie
math type library
-
brahe
modern satellite dynamics library for research and engineering applications designed to be easy-to-learn, high-performance, and quick-to-deploy. The north-star of the development is…
-
kalc-cli
kalc - quick basic math kalculator in cli
-
tilted
A toy mathematical interpreter written in Rust
-
pandas_rs
General Mathematics Library for Rust,Inspired by Python Pandas Library
-
autd3-core
AUTD3 core traits and types
-
system_solver
Find values of unknown parameters that satisfy a system of constraint equations and given parameter values
-
basemath
math, from the ground up
-
ctclib
A collection of utilities related to CTC, with the goal of being fast and highly flexible
-
bmi-calculator
BMI calculator for TI Nspire™, with data for Chinese
-
sloword2vec
A naive implementation of word2vec
-
fenx
parsing and handling FEN and algebraic chess notations
-
secrust
source-level verification using Weakest Precondition calculus
-
utils-box-bits
A toolbox of various small RUST utilities that make bit types handling easier
-
chains_f2vect
chain complexes and dg algebra manipulations
-
strata
A unique search technology
-
truncnorm
Normal and Truncated Normal distributions
-
pnets
A framework for Petri net manipulation
-
complex_numbers
muehehehhehee
-
flickers
calculating Allan-like deviations and other time and frequency stability statistics functions
-
risc0-circuit-bigint
RISC Zero Circuit for Big Integer Computation
-
rlu
Sparse LU Decomposition (Gilbert-Peierls)
-
bevy_autodiff_fit
Piecewise Chebyshev polynomial fitting for bevy_autodiff
-
calculator-washin
Biblioteca simples para operações com u32
-
warmup
Calculates the repetitions required for a warmup
-
lorust
Modern Rust utility library delivering modularity, performance & extras; or simply Rust version of Lodash
-
mraphics
A rendering engine for exploring interactive and intuitive math
-
b-spline
B-spline
-
bangle
Strongly-typed angles, specified in radians, degrees, rotations, or percentages
-
gorf-core
Lambda calulcus backend library
-
diffsquare
Fast and efficient Fermat factorization CLI
-
prime-diffusion
Diffusion systems — Gray-Scott reaction-diffusion, cellular automata
-
libpcp
A constraint solver supporting arithmetic constraints over integers
-
statrs-fork
Statistical computing library for Rust
-
numberlab
A collection of numerical algorithms
-
perplex_num
Perplex (hyperbolic or split-complex) numbers based on num-traits
-
linalgrs
Linear Algebra concept implementations from scratch!
-
ipopt_bindgen
Rust bindings to the C interface of Ipopt, a library for large-scale, constrained, nonlinear optimization
-
bignum-ig
Numbers from ± 10 ^ i64::MIN - 9.999.. * 10 ^ i64::MAX. The Primary Use of this is for Incremental Games.
-
gategen2
generate Gate circuits (second version)
-
ls_solver
linear system solution
-
calculator-thigon
Biblioteca simples para operações com u32
-
maxpre
Rust bindings for the (MO-)MaxSAT preprocessor MaxPre
-
plottery_editor
Graphical Editor of Plottery, a creative coding framework for generative vector graphics and pen plotting
-
scalars
Minimal numeric traits: Zero, One, Inv, Sqrt, Exp, Logarithm, Trigonometry, Real, Integer
-
rug-gmpmee
Rust FFI bindings for GMPMEE
-
rasters
Raster processing library
-
iter-rationals
A fixed size, linear time, no-std iterator over the rational numbers
-
scientific-cal
scientific cal
-
tensorite_math
Tensorite | Linear Algebra & Generic Math Library
-
atlas-token-confidential-transfer-ciphertext-arithmetic
Atlas Program Library Confidential Transfer Ciphertext Arithmetic
-
anoma-rm-risc0-test-app
An Anoma Resource Machine Test Application using RISC0 zkVM
-
numera
numbers
-
bunnies
A fast chess library for fast chess engines
-
calculatex
A pretty printing calculator with support for units
-
coral-aarch64
a pure-rust blas implementation for aarch64
-
temporal-attractor-studio
Temporal Attractor Studio - Real FTLE calculation and temporal dynamics prediction with VP-tree optimization
-
vector2math
Traits for doing 2D vector geometry operations using standard types
-
pulgamecanica_matrix
matrix operations and linear algebra
-
unicode_font
Convert unicode characters between fonts
-
perfgate-paired
Paired benchmarking statistics for A/B comparison
-
angular-units
representing, manipulating and converting between angular quantities in various units through a type-safe interace
-
butler-portugal
implementing the Butler-Portugal algorithm for tensor canonicalization
-
crates-testing-bilal
made with rust
-
aglet
Opinionated integer-based coordinates and directions and utilities
-
snaphu-sys
Low-level Rust bindings to the SNAPHU C library
-
algebraeon-rings
Algorithms in linear algebra, polynomials, and number theory
-
lobatto
Gauss–Lobatto quadrature and interpolation points, spectral finite-element lagrangian basis operations with efficient hardcoded versions for low order low dimensions cases
-
rivrs-linalg
Numerical linear algebra
-
padded-number
Work with numbers containing significant leading zeros
-
geph-nat
concurrent NAT thingy used throughout Geph
-
arithmetic-eval
interpreter for arithmetic expressions
-
metacat-cli
metacat: a categorical theorem prover
-
ecm
Lenstra's Elliptic Curve Factorization Implementation with Big Integers
-
puzzle-solver
Solve logic puzzles by describing their constraints. Suitable for puzzles such as Sudoku and Kakuro.
-
praxis-logic
Formal logic: propositional logic, predicates, truth tables, proof rules
-
arith_traits
Traits unifying types based on various supported arithmetic operations
-
calculator-denize
Primeira lib usando rust agora com mais um tipo de calculo
-
nakumar_color_utils
color mixing and basic arithmetic operations
-
zkpolynomial
polynomial operations, including addition, multiplication, evaluation, and Lagrange interpolation for univariate polynomials
-
vm-cat
Provable stack-machine VM built on machine-cat
-
r2rs-stats
Statistics programming for Rust based on R's stats package
-
eiche
tools for working with symbolic expressions
-
tessera
command line interface for calculating geometric error for 3D Tiles tilesets
-
distimate
providing probability distributions for estimation and risk analysis
-
x-math
fast math
-
stepwise
algorithms
-
oxygen_quark
Oxygen Quark is a maths library mainly developed for the Oxygen Game Engine
-
piss
PISS (Picture Secret Steganography) is a command line tool to encode/decode secrets into/from image files
-
alphamon-rs
interacting with Alpha Outback UPSes
-
Rustb
A package for calculating band, angle state, linear and nonlinear conductivities based on tight-binding models
-
discrete-gaussian
Gaussian sampling over discrete fields/rings/sets
-
ndarray-inverse
Pure Rust Inverse and Determinant trait for ndarray Array2
-
glar-gemm-f16
high performance cpu kernels
-
xxcalc
Embeddable or standalone robust floating-point polynomial calculator
-
universe_sync
Synchronizes the global state of the entire universe. Do not modify this crate unless you are the Prime Minister of England.
-
faasle
evaluating distances (metrics)
-
dice_forge
A small crate to preform basic math using dice notation for random numbers
-
roll-rs
Dice rolling library supporting full dice notation
-
geodesic
constructing and sampling 3D geometric scenes
-
ya_advent_lib
Advent of Code Library
-
gfx-maths
Implementations for the most essential Graphics Math operations
-
tcal_rs
Number theory functions library - Rust port of libqalculate number theory module
-
bonmin-src
Redistribution of Coin-OR Bonmin as a crate
-
corp-fin
A specialized library for corporate finance calculations, including Beta, Sharpe Ratio, and Risk Metrics
-
winpty-rs-windows-numerics
Windows numeric types
-
big_lehmer
framework to encode (compress) and decode large number sequences into lehmer codes
-
rlfsc
A checker for the LFSC proof language
-
feos-ad
Implicit automatic differentiation of equations of state and phase equilibria
-
tabularlib
Small library for abstract matrices stored in single linear vectors created as practice project
-
raekna
combines the other crates in the workspace to make a functional program
-
calcucalc
A general-purpose calculus library written in Rust
-
MathTriks
A single crate for every mathematical manipulation
-
jacderida-exp2-adder2
Little binary for experimenting with automated release workflows
-
ndgrid
n-dimensional grid library
-
commutator-rs
Commutator operations for non-commutative algebras
-
midpoint
Extension traits offering implementations of midpoint [currently, only for primitive integers]
-
variational-regression
Regression models trained using variational inference
-
lrslib-rs
Idiomatic Rust bindings around lrslib
-
boost
Rust wrapper for Boost Math
-
lowdim
two- to four-dimensional integer geometry
-
binary_matrix
Dense binary matrix operations
-
knife
An iterator that divides things evenly
-
surreal
that implements J. H. Conway's surreal numbers
-
linal
tiny linear algebra library without dependencies
-
cnetworks
A set of tools for creating and manipulating complex networks
-
smcprime
Ultra-fast primality testing with Montgomery arithmetic (32-bit and 64-bit)
-
ff_k_center
A linear-time k-center algorithm with fairness conditions and worst-case guarantees that is very fast in practice. Includes python bindings.
-
RayBNN_Sparse
Sparse Matrix Library for GPUs, CPUs, and FPGAs via CUDA, OpenCL, and oneAPI
-
cobre
Open infrastructure for power system computation — umbrella crate
-
matext4cgmath
Unofficial third-party cgmath extensions for calculate eigenvalues, operator norms and Iwasawa decomposition
-
oxiphysics
Unified physics engine - Bullet/OpenFOAM/LAMMPS/CalculiX replacement
-
function
A set of useful traits for your functional needs
-
fluxkit_math
Deterministic no_std math primitives for BLDC/PMSM field-oriented control
-
math_sdk
math SDK built for learning Rust packaging
-
rusymbols
symbolic mathematics. It aims to become a full-featured computer algebra system (CAS) while keeping the code as simple as possible in order to be comprehensible and easily extensible…
-
ndarray_einsum_beta
einsum function for the Rust ndarray crate. As popularized in numpy, einsum (Einstein summation) implements general multidimensional tensor contraction. Many linear algebra operations…
-
arael-sketch-solver
2D constraint-based sketch solver: entities, constraints, and optimization
-
arythemetic_expressions_parser_kharchenko_kma
My own parser for Rust course in KMA that parses simple arythemetic expressions
-
plonky-cat-hash
Arithmetization-friendly and generic hash functions
-
logicaffeine-lsp
Language Server Protocol implementation for LogicAffeine
-
logicpearl-solver
Internal solver backend abstraction for LogicPearl search and verification
-
diterator
range-based iteration in Rust
-
unitconv
Unit Converter
-
fftw-sys
unsafe wrapper of FFTW3
-
geomutil_triangulation
providing triangulation functions
-
quaternions
quaternion arithmetic with traits
-
kissunits
Different units (like distances or coordinates), keeping it small and simple
-
mathvites
An upcoming batteries included library for all things mathematics
-
progress-monitor
Track any progress
-
arith
containers with arithmetics
-
plonky-cat-transcript
Fiat-Shamir transcript as a natural transformation
-
openglm
sdk
-
job-runner
background job runner with configurable delays between job runs
-
dec64-rs
DEC64 decimal floating point with 16 digits of precision
-
rust_math
Math library written in Rust
-
ubiquity-kernel
Core kernel types and traits for Ubiquity consciousness-aware distributed intelligence systems
-
diving-decompression
Calculate required diving decompression procedures using the US Navy dive tables rev7
-
gwrizienn
Easy and fast modular arithmetic, polynomial quotient rings
-
nd_vec
A compile time n-dimensional vector library
-
nsys-math-utils
Math types and traits
-
irox
Tools & Libraries
-
ltrait-gen-calc
Calculator in LTrait
-
msg-tool-jpegxl-src
Source of libjxl and logic to build it
-
triangle_sides
calculating various properties of the triangle. Does not use points, but sides lengths for constructing a triangle
-
parity
is_even and is_odd methods for primitive numeric types
-
calculator-adrianovcar
calculator application
-
factorio-lua-src
Sources of Lua 5.1/5.2/5.3/5.4 and logic to build them. Fork with Factorio lua.
-
razor-chase
implements a variation of The Chase algorithm to find models for theories in geometric form
-
simple-cli-calculator
CLI Calculator
-
silico-calculator
A dead simple, Windows-like calculator available on all major operating systems and desktop environments
-
bitmath
Tools for arbitrary-sized bitwise arithmetic
-
qlora-gemm-common
Common utilities for qlora-gemm matrix multiplication - maintained fork using qlora-paste
-
memu
Implementations of memory units and working with them
-
hyperbolic_drawing
Manipulate and display elements of 2D hyperbolic space (ℍ²)
-
gac
Generic and Atomic Recipe Calculator for Factorio
-
calculadora
moderna feita com Iced
-
smart-adder
this is smart-adder crate
-
curve_similarities
Calculation of curve similarities for nd-array
-
bayes-rs
Bayesian inference with MCMC samplers
-
oxieml
EML operator: all elementary functions from exp(x) - ln(y)
-
minifb_geometry
meant to help draw shapes in the minifb window
-
hyperoperation
(sometimes known as Knuth's notation) calculation library for Rust
-
common_math
A collection of common math functions
-
dashu-float
A big float library supporting arbitrary precision, arbitrary base and arbitrary rounding mode
-
hilbert_index
D-dimensional Hilbert curve
-
libm-ext
An extension to libm providing essential mathematical special functions
-
openmesh
Vertex-face mesh validation library
-
easygradecalculator
easy grade calculator
-
logicpearl-verify
Solver-backed verification helpers for LogicPearl discovery and conformance
-
albert
A terminal calculator written in Rust with ❤️
-
topology-traits
Topological traits for generic mathematics in Rust
-
dices
calculate discrete probability distributions and statistics for combinations of dices
-
oint
oint ('optional int') provides total operations on arithmetic
-
wright_omega
Wright Omega function
-
nereids-physics
Cross-section calculation, broadening, and transmission forward model
-
akshually
Smart Boys
-
multifactorials
who allows you to use multi factorials
-
eng-units
Engineering unit coversions and calculations
-
lapack-sys
The package provides bindings to LAPACK (Fortran)
-
fishers_exact
Fisher's exact statistical test
-
playit-api-client
Contains the logic to create a playit.gg agent
-
hatree_fock
Hatree-Fock Method implemented in Rust
-
klownie_matrice
My personnel project on matrices
-
tfpc
Team Fortress Price Calculator
-
numerical_analysis
A collection of algorithms for numerical analysis
-
polycal
methods for fitting and using polynomial calibration functions following ISO/TS 28038
-
mathlogic
made by Faizan Faisal, Email: f.f.programmer@gmail.com, f.f.programmer@hotmail.com
-
gravyan
terminal-based gravity calculator
-
rubikmaster
Tools to implement Rubik's cube applications
-
factorize_rayon
Rayon find_map_any() demonstration program
-
dwbase-swarm
DWBase: agent-first immutable atom store, components, and tools
-
astronomical-quantities
Unit-safe computations with astronomical quantities
-
clair
Command-Line Arithmetic in Rust
-
pirox
building a calculator
-
reiterator
Lazy repeatable caching iterator that only ever calculates each element once
-
rlife
A life library written in Rust
-
lenia_ca
simulating the Lenia system of cellular automata
-
rust-freqdist
Frequency Distribution in Rust
-
tensor-calc
World's first Rust-based Einstein field equation solver with symbolic tensor calculus
-
eigs
Find Eigenvalues and Eigenvectors with Rust using UMFPACK + ARPACK
-
logicpearl-engine
Library-level execution facade for LogicPearl artifacts and pipelines
-
math-core-renderer-internal
Internal crate used by math-core
-
rust_decimal_cql
that wraps rust_decimal and implements (de)serialization support for ScyllaDB's native DECIMAL type
-
oxlex
lexer/tokenizer used in OxyScript
-
algebra_kit
An abstract algebra library for Rust
-
reefer
Optimizing proc-macro for geometric algebra
-
arithmetic_yukinari
arithmetic library
-
calculator-olivmath
calculator library
-
xfeval
the Excel-like formula calculator
-
fprice2
3자리 마다 콤마 찍어주는 api
-
ranked-pairs
A ranked pairs (Tideman method) election tallying library
-
summed-area
table for fast sums or averages of subsections of a 2d array or an image
-
geo-aid-figure
Definitions for Geo-AID's JSON export format
-
cronbach_alpha_lib
get cronbach alpha value to check your reliable question
-
h_math
advanced mathematical computations
-
wayllm-core
Core types and compositor discovery logic for wayllm
-
gendelbrot
A small, simplistic mandelbrot image generator
-
tclifford
Geometric algebra library
-
tg-sys
unsafe low-level bindings to the
tggeometry library -
next
trait to get the next sequential value
-
rusty-talib
using pure rust code for technical analysis
-
polynomials
Tools to perform polynomial arithmetic and evaluation
-
msgpass
Thin wrapper to a Message Passing Interface (MPI)
-
rusticg
Reverses possible internal seeds of an LCG using a system of inequalities on the output of random calls
-
csvx
Comma-Separated Values eXtended
-
det
Calculate the determinant using a macro
-
simple-geom
plane geometry
-
freude
An ODE library for ndarray providing some simple, fixed-step integrators
-
ezy
Easy to use tweening library
-
time_series_utils
handling time series data
-
segtrs
Miscellaneous functions such as numeric sequences and factorization
-
fib-sequence
retrieving fibonacci numbers in base 10
-
ga3
Common types for 3D geometric algebra
-
ctclib-pp
A collection of utilities related to CTC, with the goal of being fast and highly flexible, with perplexity scores for KenLMs models
-
nexcore-hash
Zero-dependency cryptographic hashing (SHA-256, HMAC-SHA256) for NexCore ecosystem
-
control-sys
A Control System library implemented in Rust to design and analyze control systems
-
fitting
Pure Rust curve fitting library
-
delaunay2d
compute Delaunay triangulations and Voronoi diagrams in 2D space
-
iomath
fast math rust-library
-
argentum_notification_business
Business layer of notification component
-
punc
Pun Calculus
-
statistical-tests-rs
Statistical Tests for Rust
-
operations_parser_kucherenko
A Rust-based parser for basic math operations with function support
-
beacon-calculator
calculating the glass colors needed to color a Minecraft beacon
-
physics2d
2D physics engine, but with Iron power
-
vec-utilities
A collection of methods that make working with Vecs of floats easier
-
kcl-ezpz
A constraint solver for KCL and Zoo Design Studio
-
unsigned-f64
A wrapper around f64 that guarantees that the value is always non-negative on the type level
-
rapier3d-meshloader
STL file loader for the 3D rapier physics engine
-
apbool
Just arbitrary precision boolean arithmetic for Rust
-
srmfpa-berkeley-softfloat-3
Wrapper of berkeley-softfloat-3 for srmfpa
-
graff
manipulating graphs
-
rust-cli-calculator
calculator written in Rust as a learning project
-
algeo
Computer algebra, algebraic geometry, and related math
-
nthD_Matrix
using matrixes of any arbitrary size and dimension
-
ulam
calculations
-
jakkunight-ali
CLI tool for matrix calculation
-
lottie-core
Core logic for Lottie animations
-
rival3
Real Computation via Interval Arithmetic
-
depends_core
Ergonomic, performant, incremental computation between arbitrary types
-
net_ensembles
Erdős-Rényi and small world ensembles. For simple sampling, Markov chains etc.
-
newton-sos
Damped Newton method to solve low-rank problems arising from KernelSOS and Sum-of-Squares relaxations
-
neco-edge-routing
necosystems series 2D edge routing primitives for node graphs
-
my-little-eval
A little library for evaluating mathematical expressions
-
smth
math library
-
iner-calc
A caculator of Arknights 2024 summer carnival's *Sargon Museum*
-
top-repos
THINGY
-
rpn_calc
RPN(Reverse Polish Notatio) library
-
rusttex
programmatically generating LaTeX documents
-
ruqu-qear
Quantum Echo-Attention Reservoir (QEAR) - Combining quantum reservoir computing with attention mechanisms for time series processing
-
turboplonk
App-specific TurboPlonK with various gadgets & primitives
-
scalar-field
Traits and structs which define arithmetic operators on scalar fields
-
lineas
A mathematical linear algebra library for Rust
-
si
IEC prefixes
-
nzscq
Core logic for NZSCQ
-
prime-voronoi
Voronoi / Delaunay — cellular noise, Lloyd relaxation
-
fuzzycomp
Comparison with margins
-
matriarch
A Linear Algebra and Matrix library written in Rust
-
seqnum
Serial number arithmetic (wrapping sequenec numbers) for rust
-
indicato_rs
common statistical market signals
-
u-numflow
Mathematical primitives for the U-Engine ecosystem: statistics, probability, random sampling, and collections
-
qudit-circuit
Accelerated and Extensible Quantum Library
-
yamlscript
Program in YAML — Code is Data
-
accelerate-src
The package provides a source of BLAS and LAPACK via the Accelerate framework
-
arithmetic-typing
Hindley-Milner type inference for arithmetic expressions
-
matrixa
Extremely optimized linear algebra - BLIS-style GEMM with AVX2/FMA SIMD
-
rs_handstrength
relative to board omaha hand strength calculator and equity on flop
-
q_rsqrt
fast inverse square root function from quake 3
-
calculator-albaxs
Lib calculator
-
break_infinity
larger numbers up to 1e9e15 in Rust for Incremental Games
-
cmath
一个新手的尝试
-
hypertask_engine
The core logic engine used to run hypertask
-
spatial-motion
Generic spatial transforms and movement, built on geometric algebra traits
-
choice
Similar to
eitherbut supports an unbounded number of variants -
sundials-sys
Bindings to the SUNDIALS suite of Nonlinear and DAE Solvers
-
int_math
Integer math
-
rusev
Fast implementation of SeqEval, a sequence evaluation framework
-
shigens
A math library for calculate quaternion
-
calculator_junin
Uma calculadora simples feita em Rust
-
nvblas-sys
This package provides linkage to NVBLAS
-
srmc
A Small Rust Math Crate
-
mathbox
A math toolbox
-
sparsela
Fast linear algebra on sparse matrices
-
alphabet
working with alphabets
-
sath
Toy math library
-
spfunc
numerical calculation of special functions
-
daft-algebra
Algebraic operations for the Daft project
-
trajgen
Minimum trajectory generator
-
cheque
Convenient checked math
-
ieee-apsqrt
Square root functions for IEEE floats using rustc_apfloat
-
cubecl-core
CubeCL core create
-
cheesecalc
Calculations for sodium citrate mac and cheese
-
tau
The important mathematical constant tau
-
millimeter
Primitive type with millimeter unit attached
-
termcalc
Terminal Calculator
-
dfa
A simple dfa
-
simple-bezier-easing
calculating cubic Bézier curves using De Casteljau's algorithm
-
land-calc
This app reads a list of mtg cards from 'list.txt', searches scryfall.com to validate them, and figures out how many lands you need
-
wave-file
Files are not for humans, but for waves - read any file as a phase matrix at different angles
-
quickcount
Sleek, minimal and blazingly fast word counter app
-
signum-sign
Adds the signum function to Rust
-
siiir_modular_power
A console app and library with function to quickly calculate k^n mod m
-
sprs_suitesparse_ldl
sprs bindings to the suitesparse ldl solver
-
maria-linalg
linear algebra processing package
-
kair
COnstraint Based Reconstruction and Analysis (COBRA) in Rust
-
ellip-rayon
Compute elliptic integrals in parallel
-
irox-fixedmath
Fixed Precision Math Primitives
-
mini-calc-lib
A Fully-Featured Configurable (mini) Rust Calculator
-
sphereql-core
Pure spherical math primitives for sphereQL
-
ewq
Small math library
-
psy-math
A fork of jet-proto-math. Helpful math utilities, used by PsyLend.
-
math_utils_70_codes
math library
-
sai_kt
math flow
-
wrapping_coords2d
Translate between 1D indices and 2D coordinates with wrapping
-
smt-lang
Sat Modulo Theory Language
-
calculator-catitodev
Biblioteca simples para operação com i32
-
approxeq
A trait for approximate equality of types
-
FEA_code
-
cellular_lib
simulation of cellular automata
-
tassl-src
Source of TASSL and logic to build it
-
rsmt2
Wrapper for SMT-LIB 2 compliant SMT solvers
-
simple-sum-average
An O(1) memory complexity temporal average helper
-
logic_gate
Logic Gates
-
memocalc
A useful tool for practicing mental mathematics
-
fft_sound_convolution
implementing sound convolution using RustFFT
-
core-math
API for CORE-MATH
-
dace
Rust wrapper of DACE, the Differential Algebra Computational Toolbox
-
xer_adder
Example crate with a dependency
-
cchmod
chmod calculator
-
semdiff-differ-binary
Binary diff calculator and reporters for semdiff
-
gollum-pddl
PDDL parser and AST for the Gollum logic engine
-
composite_modulus_proofs
Proofs about several propoerties of a composite modulus - square-free, product of 2 primes, a blum integer
-
mikino
induction and BMC engine
-
normal-form
A trait to easily find the canonical/normal form of graph structures
-
gradecalculators
grade calculators
-
spglib
Rust bindings to spglib
-
quad_gk
Pure rust numerical integration library based on Gauss Kronrod quadrature rule
-
mathio
A lightweight, simple and straight-forward opinionated library for math used in other projects
-
factorion-math
The math (factorials and related functions) used by factorion
-
pblib-rs
Rust safe bindings for pblib
-
fast-sde
High-performance Monte Carlo simulation for stochastic differential equations in quantitative finance
-
tscale_sequence
generating tscale sequences
-
dotbits
unsigned int <-> Vec<bool>, plus various helper functions
-
linfa-clustering
A collection of clustering algorithms
-
alpha_stable
Sample and generate probability distribution functions of Alpha-Stable distributions in Rust
-
smlm-frc
Fourier Ring Correlation (FRC) calculation for smlm
-
arithmetic-sign
Arithmetic
Sign(≈+1|-1) to/from arithmetic types such asf64,i32utility -
money2
For storing and asynchronously converting between (a subset of) ISO-4217 currencies
-
googology
giving names to large numbers
-
inta
Interval arithmetic in Rust
-
infinity-sampler
Deterministic reservoir sampling for Rust
-
not_copy
For when you need to trivially turn a Copy type into something that isn't Copy
-
ndvec
low-dimensional vectors
-
f128
Bindings to the gcc quadmath library
-
fend-core
Arbitrary-precision unit-aware calculator
-
ferric
A Probablistic Programming Language with a declarative syntax for random variables
-
my_lib_tuanla
Sample rust
-
cubeio
File io for Gaussian CUBE file format
-
strict_types
Strict types: confined generalized algebraic data types (GADT)
-
symengine
Unofficial Rust wrappers to the C++ library SymEngine, a fast C++ symbolic manipulation library
-
rfcalc
calculate things
-
braid-mvg
Braid's camera geometry and multi-view geometry (MVG) types and algorithms
-
math_repl
REPL for all different kinds of math
-
squiid-parser
The algebraic expression parser for Squiid Calculator
-
algebra-sparse
Efficient sparse linear algebra library built on nalgebra with CSR/CSC formats and block diagonal matrix support
-
veda12_cr5
math flow
-
base-converter
Convert a number in any base to any other base
-
ark-linear-sumcheck
efficient sumcheck protocols
-
index_key
lexicographic sort order encoding
-
noise_fn
Some simple noise functions and traits to allow easy integration with your own
-
tricolor
Color structs, color formats, and color conversions
-
buttery
smooth transformations with a nice API
-
lcpc-2d
polynomial commitment scheme from linear codes
-
pythagore_tina
Solve the Pythagorean Theorem
-
mini-math
Lightweight math routines for 3D graphics
-
finch-symbolic
Namesquatting for Rust port of Finch.jl
-
s5
equation solver written in Rust, built for solving some homework-style problems in orbital mechanics
-
amosaic
tools for generating and working with aperiodic tilings and mosaics, based on the hat monotile discovered by David Smith and inspired by the work of Craig S. Kaplan.
-
sdvrp
Rust binding of Alkaid-SDVRP: An Efficient Open-Source Solver for the Vehicle Routing Problem with Split Deliveries
-
lcpc-ligero-pc
polynomial commitment scheme from R-S codes, as in Ligero (CCS '17)
-
tinymath
Experimental routines for performing arithmetic on small data types
-
alco-rs
Tools for algebraic combinatorics in Rust, including the octonion algebra and octavian integer ring
-
exprtk_rs
Rust bindings to the ExprTk C++ library (http://www.partow.net/programming/exprtk)
-
plonky-cat-poly
Univariate and multilinear polynomial functors
-
groslicer
Slice gro files by processing a stream of lines
-
tokmd-analysis-util
Shared analysis utility math and normalization helpers
-
time-func
represents a set of data points as a function of time and performs various mathematical operations on the data
-
rapier3d-lijay
3-dimensional physics engine in Rust
-
simple_colatz
package to compute the colatz conjecture in rust
-
token_store
A token-based store for arbitrary values
-
clmul
Carry-less multiply for Rust, internally uses llvm or compiler intrinsics, with fallback if the CPU has no clmul instruction
-
rstmt-nrt
focuses on providing support for the neo-riemannian theory of music
-
galgebra
geometric algebra stuff (vectors)
-
cargo_calc
calculation lib
-
eight_module
Uma biblioteca para operações matemáticas simples. Ideal para quem busca facilidade e eficiência em cálculos básicos.
-
neco-ecc
necosystems series Reed-Solomon error correction over GF(2^8)
-
gs-rs
basic monocular SLAM (Simultaneous Localization and Mapping) Algorithm in pure Rust
-
polycool
Polynomial root-finding
-
fresnel
Special function for computing the Fresnel integrals (CEPHES translation)
-
subscript
reserved 👉 for the new compiler (and other infrastructure) see https://github.com/subscript-publishing 👉 We decided to move away from the old monolithic codebase and split everything…
-
mathengine-lexer
High-performance lexical analyzer for mathematical expressions with unit support
-
unifac
calculate non-ideal vapor-liquid equilibria using UNIFAC model
-
rstm-state
A generic state implementation and its supporting interfaces
-
graf-lang
An esolang based on graph theory
-
maths_function
Some maths fuctions
-
tribev2-audio
Wav2Vec-BERT 2.0 audio feature extraction for TRIBE v2 (burn backend)
-
tazor
implementing a calculator based on mathematical expression
-
box-algebra
Box Algebra. This crate defines the fundamental data structure, a mathematical box, and associated methods for doing basic algebraic operations.
-
machine-factor
constant factorisation for machine-size integers
-
markovian
Simulation of Markov Processes as stochastic processes
-
aws_volume_limit_calculator
copy of https://github.com/awslabs/aws-support-tools/blob/master/EBS/VolumeLimitCalculator/volume_Limit_calculator.sh
-
amfnwasm
Amortization Functions (AmFn) Web Assembly
-
tensorite_math_tensor
Tensorite Math Tensor | Tensor Implementation
-
mm0_util
MM0/MM1 language utilities
-
big_num
A big number implement in rust
-
structural-shapes
Common structural shapes
-
lexper
CLI calculator with a handwritten lexer and parser in Rust
-
RayBNN_DataLoader
Read CSV, numpy, and binary files to Rust vectors of f16, f32, f64, u8, u16, u32, u64, i8, i16, i32, i64
-
provekit_noirc_artifacts_info
The logic for
nargo infoandnargo-inspector -
mini-c-ares-src
Source of c-ares and logic to build it using cmake
-
faer-cholesky
Basic linear algebra routines
-
matrix-42
A linear algebra library written in Rust with basic matrix and vector operations
-
prime-formula
High-performance prime number generation and constellation finding using novel wheel factorization
-
antbox
A cellular automata & artificial life toy
-
query-curve
querying custom Bezier curves, compatible with curves created at https://querycurve.com
-
projective
The representation projective transformation
-
principia_optimization
A Numerical Optimization Library
-
ndarray-unit
A package providing a system of units to the ndarray type
-
wick-complex
Complex number support for wick expressions
-
c-prime
Convenience wrapper for machine-prime
-
mech-combinatorics
Combinatorics library for the Mech language
-
pcw_fn
Generic piecewise function trait and impls
-
ieee754
Low-level manipulations of IEEE754 floating-point numbers
-
macmahon
Calculate fast
-
argmin-math
argmin math abstractions
-
slice_math
A selection of useful math operations on slices
-
tsum_calc
command-line Triangle Sum Theorem calculator
-
py-laddu
Python bindings for laddu
-
mraphics-control
The interactive control module of Mraphics
-
standardform
Effortlessly operate on numbers like 2e19 or 2*10^4 and more with this Rust implementation of standard form. Simplify, convert, and manipulate large numerical expressions with ease.
-
rust-polynomial
A lib to operate polynomials
-
qc
An enhanced RPN cli tool for quick binary, octal, decimal, hexadecimal calcs
-
sci_task_io
Standard File IO Interface for Scientific Calculation
-
mpir
partial Rust porting of mpir multiple precision library based on gmp mpfr
-
modality-lang
Modality language lib
-
p3-miden-lmcs
Lifted Matrix Commitment Scheme (LMCS) for matrices with power-of-two heights
-
stitches
Search spaces to solve math problems fast
-
ark-mpc
Malicious-secure SPDZ style two party secure computation
-
is-prime-kien
Just Kien test
-
gali
untyped lambda caluculus, with some sugar for convenience
-
inexor-rgf-model-json
Inexor - Reactive Graph Flow - Model - JSON
-
amx-rs
High-level ergonomic API for AMX (Apple Matrix eXtensions) - matrix and vector operations
-
turtle-lang
A humble, fun, and friendly Lisp
-
combinatorial
tools, functions, and generators
-
periodic-table-rs
A chemistry library written in Rust
-
fastdivide
partial port of libdivide. It makes it possible to reduce the cost of divisions.
-
poset
posets
-
gatesim
The base library for the Gate Project
-
turing
hash function library
-
cubek-attention
CubeK: Attention Kernels
-
aoc
Advent of code helpers
-
zernike
Routines to compute the Zernike polynomials
-
nonconvex-opt
non-convex optimization algorithms
-
linear_algebra_42
A linear algebra library in Rust
-
num-primitive
Traits for primitive numeric types
-
multicalc
Rust scientific computing for single and multi-variable calculus
-
rustsat-tools
Tools and examples built on the RustSAT library
-
oxiblas
Pure Rust BLAS/LAPACK implementation for the scirs2 ecosystem
-
geomutil_util
providing basic geometric types
-
kalc-kman
Is a calculator for math
-
gam
Generalized penalized likelihood engine
-
matrixes
matrices up to and slightly beyond a highschool level. See README for details.
-
overflow-proof
Monadic checked arithmetic for Rust
-
omni-wave
Easy to use DWT (Discrete Wavelet Transform) library, no need to worry about padding, and a variety of wavelets are available
-
vecmate
Lightweight, zero-dependency, type-agnostic library for vector math
-
rxcalc
An expression calculator, originally written in Scratch
-
fuzzy_fraction
Struct for approximated human-readable fraction representation
-
rstm-actors
focuses on building concrete implementations for Turing Machines
-
mee6
calculate mee6 leveling data
-
standard_deviation
used to get the standard deviation from the cli
-
galois_field_2pm
Galois Field (2^M) arithmetic
-
idenso
Tensor identities for symbolica
-
symba
Computer Algebra System written in Rust
-
gollum-planner
Planner for execution of the Gollum language
-
miller_rabin
A multi-threaded, arbitrary precision implementation of the Miller-Rabin primality test
-
ajtai
A no-std implementation of the Ajtai commitment scheme
-
num-derive
Numeric syntax extensions
-
interva
A feature-rich crate for handling intervals
-
arpack-ng
Save interface to arpack-ng-sys
-
greentic-dw-core
Runtime operation model and transition logic for greentic-dw
-
vector-victor
linear algebra crate
-
myfav-core
Core domain models and repository logic for myfav
-
basic_stochastics
A small collection of utilities to make performing basic stochastic calculations more convenient
-
elic
A utilities library for Rust
-
polygon_clipping
An algorithm for computing boolean operations on polygons
-
calculator-beto
Biblioteca simples para operações com u32
-
libfive
Tools for solid modeling, especially suited for parametric and procedural design
-
metis-sys
Raw FFI to METIS, the serial graph partitioner and fill-reducing matrix orderer
-
lamcal
A lambda calculus parser and interpreter
-
compute-pi
designed for computing pi to millions of digits
-
hcomplex
Lightweight complex and hypercomplex algebra library
-
logsumexp
Numerically stable computation of log-sum-exp using a 1-pass algorithm
-
frfft1d
one dimensional discrete fractional fourier transform
-
troth
λ-Calculus Interpreter
-
arrow-ml-common
Shared error types and runtime backend plugin registry for arrow-ml
-
seismic-response
Seismic response analysis of a single particle system is performed using Newmark's beta method
-
pemel
Parsing and Evaluating of Math Expressions Library
-
navitools
A tiny tool set for navigation applications
-
dierckx-sys
Rust-wrapper for Dierckx' B-Splines Curve and Surface Fortran Library
-
nabo-pbc
A fast K Nearest Neighbor (KNN) library for low-dimensional spaces, now with support for periodic boundary conditions
-
oldies-core
Core types for legacy simulator revival - ODE systems, time series, ion channels
-
guff-ida
Information Dispersal Algorithm
-
glar-gemm-f32
high performance cpu kernels
-
runmat-time
Cross-platform time utilities for RunMat (monotonic + wall-clock helpers)
-
min_max_assign
Change min(max) implementation in Rust
-
orthos
High-performance linear algebra library written in Rust
-
dinglebit_combinatorics
A collection of combinatorics utilities
-
pdqhash
Perceptual Hashing, originally designed by Facebook. Identify the same image even after some modifications.
-
binary_polynomial_mod_algebra
Basic algebra on univariate binary polynomial
-
graph-cycles
Detect all cycles in a petgraph graph
-
swimos_algebra
SwimOS Algebraic Traits
-
ngeom
Geometry in N dimensions
-
acid2
2-adic double-precision floating-point implementation
-
mtrx
type-safe matrix operations using const generics
-
plonky-cat-merkle
Merkle tree over plonky-cat-hash
-
rsmonad
Haskell-style monads for idiomatic Rust
-
robust_scaler
A RobustScaler for Rust, compatible with scikit-learn's RobustScaler
-
lawkit-core
Core library for statistical law analysis with international number support
-
quad-to-quad-transformer
Translate 2d points from one quad to another
-
ndarray-rblas
rblasbindings forndarray -
checked_num
Overflow-checked numbers for safety without sacrificing ergonomics
-
curvature
estimation for point clouds
-
mosekcomodel_mosek
MOSEK backend for mosekcomodel
-
gy_r_number
handling rational numbers with high precision
-
vecxd
X-dimensional vector library
-
violet_interpolation
Adds audio sample interpolation to xpans Violet
-
pluto-src
Sources of Pluto (Lua 5.4 dialect) and logic to build it
-
const-trig
providing const trig functions
-
cartan-dec
Discrete exterior calculus on Riemannian manifolds: simplicial complexes, Hodge operators, and covariant differential operators built on cartan-core
-
evar
Modern ergonomic math calculator inspired by eva
-
padic
P-adic numbers in Rust
-
triangle
Struct for geometric triangles. Includes Barycentric-Cartesian transforms and stuff..
-
envisim_utils
methods for design-based sampling methods and estimation
-
feos-dft
Generic classical DFT implementations for the
feosproject -
nox
Tensor library that compiles to XLA (like JAX, but for Rust)
-
m61-modulus
Functions for performing arithmetic modulo the 61st Mersenne number. Aimed at testing bignum implementations.
-
rust-blas
BLAS bindings and wrappers, fork of rblas
-
rusty-compression
Low rank compression algorithms in Rust
-
rs-sci
the scientific library
-
math-in-rust-doc
Demo of add math to rust doc
-
nrfind
A set of useful mathematical functions for floating point numbers based on the Newton-Raphson method for finding roots
-
calculator-washinribeiro
Uma biblioteca simples para cálculos básicos
-
inner-space
dot product trait and auto implements the inner space trait, which contains a bunch of useful functions for working with vectors
-
mdarray-linalg-faer
Faer backend for mdarray-linalg
-
cf_dist_utils
has risk and distribution utilities
-
noxla
Rust bindings to XLA's C++ API
-
sukker
Linear Algebra and Matrices made easy!
-
mazer-core
A minimal, simple math markup language that compiles to HTML, written in Rust
-
cubature-sys
Bindings for cubature with support for Linux, macOS, and Windows
-
hwcalc
An arbitrary bit-width calculator
-
deep_causality_metric
Metric signature types and sign conventions for Clifford algebras and physics
-
nat_diff_geom
Natural Difference Geometry
-
rug-miller-rabin
A multi-threaded, arbitrary precision implementation of the Miller-Rabin primality test using rug (GMP)
-
siffra
parse and evaluate human-friendly mathematical and natural language expressions
-
lmonade-models
LLM model architectures and serving components for the Lmonade inference engine
-
taco-smt-model-checker
Model Checker encoding threshold automaton and a property into a single SMT query. This model checker is part of the TACO toolsuite.
-
perfgate-significance
Statistical significance testing for benchmarking
-
raster-tools
Raster processing tools
-
mangle-ir
Mangle, a logic programming language
-
oxiblas-sparse
Sparse matrix support for OxiBLAS
-
praxis-category
Category theory primitives — categories, functors, natural transformations, with property-based validation
-
periodic_date
Date arithmetic for periodic time series (monthly, quarterly, annual)
-
algebrix
Vectors, matrices, quaternions, and geometry for game engines; column vectors, optional SIMD
-
plonky-cat-code
Error-correcting codes: Reed-Solomon, tensor-RS, Reed-Muller
-
m4ri-rust
M4RI-based boolean linear algebra
-
cas-graph
A customizable graphing calculator for CalcScript
-
convolution-dsp
1-dimensional convolution library intended for use in DSP applications
-
ark-poly-commit
constructing polynomial commitment schemes for use in zkSNARKs
-
postfix
expression evaluator
-
clamped
clamping of numbers in Rust
-
math-comb
Math library for Combinatorics, Modular arithmetic & Number Theory utilities
-
super_fair_division
fair division algorithms
-
csg_surface_distance
A package for calculating distance along a given vector between a point and a constructive solid geometry surface
-
ndmath
Traits for doing vector geometry operations using built-in types
-
finitefields
Perform algebraic operations between integers over a finite field
-
wolfram-pest
Notedown Text parser
-
laplade
RPN(Reverse Polish Notatio) library
-
isodd
A blazingly fast Light Weight rust library for determining if numbers are odd
-
savage
A primitive computer algebra system (REPL)
-
nums
Number theoretic functions, such as primality testing and factorization, for BigUints
-
foras
First-Order Reasoner which uses the principles of predicate logic to derive new facts, verify statements, and prove theorems from an existing knowledge base
-
rbf3
Radial Basis Function multidimensional interpolation
-
cons-laws
Particle methods to solve 1D conservation laws
-
mermin-topo
Topological defect detection and persistent homology
-
blend-formula
macros for defining GPU blend modes from arbitrary formulae
-
meansd-cli
calculate mean and standard deviation (CLI)
-
deep-delta-learn
Deeep Delta Learning as in 2601.00417
-
rust_solar
Date-time solutions for hypothetical cosmic calendars
-
aprender-contracts
Papers to Math to Contracts in Code — YAML contract parsing, validation, scaffold generation, and Kani harness codegen for provable Rust kernels
-
rampart
determines how intervals relate to each other
-
steel-decimal
High-precision decimal arithmetic for Steel programming language
-
frank
Fetch and Rank adds bolt-on generic vector ranking and fetching features. Just use and let resultvec = vector.rank() or resultvec = vector.fetch(&my_picks_vec). Fun extras: sequence_sum_of_squares (by calculus…
-
feldera_rust_decimal
Decimal number implementation written in pure Rust suitable for financial and fixed-precision calculations
-
libsumi
The core mathematics and logic library for the GYOSHO graphics ecosystem
-
lapack-traits
Generic real/complex scalar trait wrappers for BLAS and LAPACK routines
-
wicker
Weighted probability picker for Rust
-
castep-model-core
The core module to parse, read, edit, and write 3D lattice models for castep and compatible with Materials Studio
-
matrix-basic
very basic matrix operations
-
mcdm
assist with solving Multiple-Criteria Decision Making (MCDM) problems
-
ancomplex
Package provides easy to use, begginer frendly and python like complex numbers
-
f3l_features
3D Point Cloud Library
-
logicaffeine-system
Platform IO and system services for LOGOS
-
exg-luna
LUNA seizure-detection preprocessing pipeline for EEG — built on exg
-
nnls
Non-Negative Least Squares (nnls)
-
green-kernels
Evaluation of Green's function kernels
-
linalgae-rs
lightweight, generic linear algebra library for Rust, with support for arithmetic operations and random initialization
-
lexlib
miscellaneous stuff
-
polygonical
2d polygon geometry and operations
-
categorical
combining categorical random distributions and computing exact probabilities
-
ct_ratio
Compile-time rational arithmetic for use in generics
-
phyz-regge
4D Regge calculus with U(1) gauge field for Einstein-Maxwell theory
-
hullabaloo
Backend-agnostic geometry construction utilities
-
cip_rust
Cubic Interpolation Pseudo-Particle (CIP) implementation in Rust. For more information, contact mgubolin at protonmail dot com or the original article in TAKEWAKI, Hrn; NISHIGUCHI, A…
-
const-modulo-ring
Z/mZ for const modulo m
-
vil_bench_llm
N04 — LLM Benchmark Suite: pluggable benchmarks with built-in math, logic, factual Q&A
-
pitch-pipe
Pitch Pipe is a method for automatically tuning a one euro filter
-
brevet
Evaluator for Ei calculus with dependent merges and first class environments
-
astro_nalgebra
astro-float for nalgebra
-
field-matrix-utils
working with matrices over finite fields
-
math_utils_BRH
math utility library
-
slop-pgspcs
Pretty Good Sparse Polynomial Commitment Scheme for SLOP
-
nalgebra-rand-mvn
Random multi-variate normal generation using nalgebra
-
rust-latex-doc-minimal-example
Minimal crate example for getting latex in docs
-
calculator-henriquecapi
Biblioteca simples para operações com u32
-
fffft
Number theoretic transform for PrimeField types (from ff crate)
-
formally-support
the open-source formal methods toolchain - basic support functionality
-
proof-cat
Sumcheck-based proving backend for plonkish-cat circuits
-
pnets_shrunk
A reducer for petri nets
-
volterra-dec
DEC physics layer: Q-tensor fields, Stokes solvers, BVH semi-Lagrangian advection, Helfrich energy, and variational integrators on triangle meshes
-
acm
Arithmetic congruence monoid implementation in Rust
-
concrete-ntt
pure Rust high performance number theoretic transform library
-
quaternion-wrapper
Operator overloading allows implementation similar to mathematical expressions
-
rssn-advanced
containing complex and delicate mathematical algorithms exspcialy heuristic one based on rssn
-
yttria-math
A DSP math library tailored for use with the yttria set of libraries
-
numru
A high-performance scientific computation library written in Rust
-
commuter
tooling to test diagrams for commutativity, allowing automated tests on algebraic systems
-
formally-smt
the open-source formal methods toolchain - SMT abstraction layer
-
epsilonz
Functional programming in Rust
-
hwcalc_lib
Backend for the hwcalc calculator
-
mermin-orient
Multiscale structure tensor and k-atic order parameter fields
-
gorf-kiselyov
Lambda calulcus backend library
-
crook_calculator
one function to compute mathematical equations from string slices
-
r2rs-nmath
Statistics programming for Rust based on R's nmath package
-
umath
ffast-math in rust
-
norman
Implementations of different norms for elements of vector spaces
-
trilean
Kleene's three-valued logic (boolean + unknown)
-
caso
Category Theory Solver for Commutative Diagrams
-
amari-dynamics
Dynamical systems analysis on geometric algebra spaces - stability, bifurcations, attractors, and Lyapunov exponents
-
stormath
A selction of math utility functionality
-
eigenvalues
algorithms to compute eigenvalue/eigenvectors of symmetric matrices
-
polydimensional_rust
Lightweight library for Rust created to make work with matrixes and vectors in 2D, 3D and 4D better and faster!
-
anoma-rm-risc0-test-witness
An Anoma Resource Machine Test Witness using RISC0 zkVM
-
kornia-linalg
Linear algebra operations for kornia
-
croot
finding real and complex roots
-
fractran_rs
A FRACTRAN interpreter
-
transfer_function
Transfer functions in s- and z-domain
-
wilson
Calculate Wilson confidence interval for binomial distribution using the formula from Wikipedia
-
mwa_hyperbeam
Primary beam code for the Murchison Widefield Array (MWA) radio telescope
-
npy-stream-writer
stream writer for numpy files
-
fj-window
Early-stage b-rep CAD kernel
-
roundable
Round numbers and durations to a given factor
-
extended
precision 80-bit floating-point numbers (f80)
-
factrs
Factor graph optimization for robotics
-
mathguru
An algebra system capable of mixed numeric and symbolic computation
-
curves
-
gaussfilt
Design and apply Gaussian filter for 1D data
-
bootstrap-ht
Bootstrap Hypothesis Testing
-
pawer
doc Calculus of Construction
-
options-common
working with financial options
-
pardiso-wrapper
Wrappers for MKL and Panua Pardiso dynamic libraries
-
qhull-sys-enhanced
Rust bindings to Qhull
-
qrotate
Quaternion library for 3D rotation of vectors
-
ffactor
A very minimal number theory utilities
-
laddu-python
Amplitude analysis made short and sweet
-
zeta-quantization
Advanced quantization engine for efficient LLM inference
-
rust-fixed-point-decimal
Decimal fixed-point arithmetic
-
mpdec
wrapper for libmpdec math library
-
pire-base
high performance cpu kernels
-
guff-matrix
Fast Galois Field matrix multiplication
-
alat
Automata Learning Toolkit
-
rbf-interp
Radial Basis Function multidimensional interpolation
-
cblas-sys
The package provides bindings to CBLAS (C)
-
nikisas
common mathematical functions with focus on speed and simplicity of implementation at the cost of precision, with support for
no_stdenvironments -
semdiff-differ-text
Text diff calculator and reporters for semdiff
-
vtrig
Hidden trigonometry functions with their derivates and integrals
-
biconnected-components
Find biconnected components in a graph
-
plonky-cat-fri
FRI as a ReductionFunctor implementation
-
big_complex
Complicated Arithmetic with Big Complex Numbers
-
praxis-ontology
Define, validate, and enforce domain ontologies — what exists, how things relate, and what rules govern them
-
rust-kepler-solver
Efficient solvers for the elliptical and hyperbolic Kepler equation
-
fem_2d
2D Finite Element Method Toolkit
-
bvrs
A lightweight rust library for BitVector Rank&Select operations, coupled with a generic Sparse Array implementation
-
bektor
vector, quaternion, geometry, and matrix library
-
quizx
Quantum Circuit Optimisation and Compilation using the ZX-calculus
-
basic_dsp_interop
Digital signal processing based on real or complex vectors in time or frequency domain
-
caliph
calibrate and convert pH measurements using a two point method
-
feval
clt for fast evaluations
-
oat_python
User-friendly tools for applied topology in Python
-
sofa-sys
Standards of Fundamental Astronomy (SOFA) Rust bindings
-
extended_matrix_float
Float trait for extended_matrix lib
-
xyz2stl
Convert a point cloud (.ply) file into a STL mesh
-
unifrac
working with normalized fractional values
-
multi_dim_point
multi-dimensional point
-
cenv_core
The internals for the cenv project, designed to be shared amongst different implementations
-
displayr-rustr
R integration
-
simplicial_topology
Represent, manipulate, combine and perform computations on simplicial complexes
-
galois_field
convenient operations on finite field, polynomials, and matrices over finite field
-
ipasir-sys
that contains FFI bindings for IPASIR-compatible SAT solvers
-
const_fixedp
A const type for fixed point arithmetic
-
risk-metrics
Risk metrics and calculations for DeFi applications
-
arthroprod
Clifford Algebra based computation for the theory of Absolute Relativity
-
rusty-cffi
Tools for interfacing with other languages via CFFI
-
mpmfnum
A numbers library in Rust
-
fractions
lightweight crate for fraction arithmetic
-
o2-deploy
Contract deployment logic for Fuel O2 exchange
-
digits_utils
converting numbers to digits
-
concrete-fft
pure Rust high performance fast Fourier transform library
-
amfnbatch
Amortization Functions (AmFn) Batch Process
-
matlab-sys
Rust bindings for the Matlab C API
-
stroemung
A Computational Fluid Dynamics (CFD) simulator in Rust
-
rust-gmp-kzen
Rust bindings for GMP
-
intel-mkl-tool
Seek Intel(R) MKL library from system
-
typed_floats
Types for handling floats with type checking at compile time
-
goniometry
module for working with trigonometric functions like sine, cosine, tangent and much more to come
-
kukan
powerful tool for mathematical interval
-
big-int
arbitrary-precision, arbitrary-base arithmetic, supporting arbitrarily large integers of any base from 2 to u64::MAX
-
pict-rs-formats
file codec and format logic for pict-rs
-
general-lotka-volterra-rs
High-performance vectorized Lotka-Volterra & Replicator type dynamics solver
-
matio-rs-sys
Rust binder to MATLAB MAT file I/O library
-
tuppu-scene
Scene graph with exact coordinates and motor transforms
-
logic-circus
Open source logic circuit simualtor written in Rust
-
sn_curv
Curv contains an extremely simple interface to onboard new elliptic curves. Use this library for general purpose elliptic curve cryptography
-
machine-cat
Generic AIR chip framework built on proof-cat
-
allen_interval_algebra
package for interval algebra for more information see https://en.wikipedia.org/wiki/Allen%27s_interval_algebra
-
vecto
vector2
-
sir_ddft
SIR-DDFT model
-
xdbuf
reusable multi-dimensional buffer
-
qudit-inst
Accelerated and Extensible Quantum Library
-
rpn_calc_53Tanuki
RPN(Reverse Polish Notatio) library
-
set-partitions
Represent and enumerate set partitions
-
base95
Textual representation of base 95 fractional numbers with arbitrary precision
-
array_math
A selection of useful math operations on arrays
-
kn0syseccrs
Intuitive library for elliptic curve cryptography tutorials
-
moo-math
math interpreter
-
cool_matrix
Extremely optimized linear algebra - BLIS-style GEMM with AVX2/FMA SIMD
-
dfkzr
Dezimalfestkommazahlrechnung - decimal fixed point arithmetic with up to 19 digits
-
plonky-cat-basefold
BaseFold as Interleave<BaseFoldAdapter>
-
complexible
A minimal and user-friendly Rust library complex-number operations, bringing the joy of complex mathematics to Rustaceans everywhere!
-
sleef-trig
Port of a few sleef.org trigonometric functions
-
temperature-convert
Temperature unit converter between Celsius, Fahrenheit and Kelvin
-
math-crate
A libary for doing simple calculations in Rust
-
num-ord
Numerically ordered wrapper type for cross-type comparisons
-
poulpy
Efficient & modular FHE library
-
radian
A normalized angle type
-
yaspar
SMT Parser, a SMTLib 2.7 compliant parsing library
-
klu-rs
Save bindings to SuiteSparse's KLU sparse matrix solver
-
arkley_traits
several traits for common mathematical operations
-
binpack
solve binpacking problems using Linear Programming
-
dioxus-katex
Render math with KaTeX in Dioxus!
-
ferray-random
Random number generation and distributions for ferray
-
goldilocks-ntt
fast NTTs over the Goldilocks prime field
-
GSL-sys
binding for the GSL (the GNU scientific library)
-
ark-ff-optimized
Optimized field implementations that outperform the generic field implementations in arkworks
-
arb-sys
Bindings to the Arb library
-
mdmath_core
Core multidimensional mathematics library with fundamental types, traits, and operations
-
rpni
A basic command-line RPN calculator
-
differential-geometry
differential-geometric calculations
-
signature-rs
High-performance log signature computation for paths and time series data
-
plonky-cat-sumcheck
Sumcheck as a ReductionFunctor implementation
-
safe-arithmetic
Traits for safe arithmetic operations in rust
-
laddu-amplitudes
Amplitudes for the laddu library
-
geomath
Stack-allocated maths for geometry, simulation and computer graphics
-
mesh_rasterization
A coverter from meshes to SDF
-
fasteval
Fast evaluation of algebraic expressions
-
signature-rs-bin
CLI Application that computes the log signature from path data
-
abstract-calculus
A programming language and model of computation that matches the abstract algorithm perfectly
-
chela
High-performance Machine Learning, Auto-Differentiation and Tensor Algebra crate for Rust
-
argentum_standard_business
The business layer of standard component
-
exponential-integral
The exponential integral function, a.k.a. Ei.
-
canrun
A logic programming library inspired by the *Kanren family of language DSLs
-
kolakoski
sequence iterator
-
test-fork-core
Core fork logic of test-fork
-
rust_estudo
Basic math operations
-
twoword
Construct bigger uints by combining two smaller ones into a two-word uint
-
float_extras
Extra floating-point math functions from C math library
-
vector-geometric-algebra
vector algebraic operations for 2d and 3d vector, as well as splines
-
last_order_logic
An experimental logical language
-
lager
A lightweight type-safe linear algebra library
-
lie
A numerical library for working with Lie Groups and Algebras
-
calib-targets-core
Core types and utilities for calibration target detection
-
logic-form
representing Cube, Clause, CNF and DNF
-
cubemoma
A multi-word modular arithmetic library based on CubeCL
-
xnn
A lightweight ML framework with GPU-first architecture
-
path_finder
Find non-looping paths in a graph
-
matx
A lightweight, rusty matrix library that allows for simple and fast matrix operations
-
dexterior-core
Core crate of dexterior, a Discrete Exterior Calculus toolkit
-
matrix
The package provides a matrix laboratory
-
peroxide-num
Numerical traits for Peroxide
-
fractionfree
Fraction-free linear algebra for ndarray
-
derangement
permutation with no fixed points, a derangement
-
hann-rs
Blazingly fast Rust Hann Window
-
calculi
used to apply calculus functions on equations in string form
-
ngau
Non-Generic Angle Units
-
scirs2
port of SciPy with AI/ML extensions - Scientific Computing and AI Library (scirs2)
-
divisors_fixed
A fixed & enhanced version of the divisors crate
-
min_max_traits
Traits for MIN and MAX associated constants
-
cartan-remesh
Adaptive remeshing primitives for triangle meshes on Riemannian manifolds
-
gmpmee-sys
Rust FFI bindings for GMPMEE
-
big_number
A scientific notation number type for idle/incremental games
-
vectorama
Very simple linear algebra library for Rust
-
curv-lsc
Curv contains an extremely simple interface to onboard new elliptic curves. Use this library for general purpose elliptic curve cryptography
-
pmsim
Porous media simulator
-
implicit3d
3d implicit geometry
-
converge-optimization
Optimization algorithms for converge.zone - Rust reimplementation of OR-Tools subset
-
qlora-gemm-f16
f16 matrix multiplication for qlora-gemm - maintained fork using qlora-paste
-
lcrs
A Lambda Calculus Interpreter written in Rust
-
symbolics_core
Core expression module for the symbolics computer algebra library
-
ringkernel-montecarlo
GPU-accelerated Monte Carlo primitives for variance reduction
-
oxiphysics-fem
Finite element method for the OxiPhysics engine
-
crate_crypto_internal_eth_kzg_polynomial
methods that are needed for Polynomial objects
-
gf2_192
Arithmetic operations and polynomial interpolation over Galois fields GF(2^192)
-
rug-polynomial
Polynomial arithmetic, built on Rug & FLINT
-
protocheck-core
⚙️ Core logic and validators for protocheck
-
rust-matrix
foundational matrix operations for matrices containing <f32>, <f64> or complex numbers built from those types
-
runmat-lexer
Lexer for the RunMat language (MATLAB/Octave syntax) built with logos
-
ashlang
A language for zero knowledge proofs
-
amari-fusion
Fusion system for combining algebraic structures
-
tensorlogic-infer
Execution and autodiff traits for TensorLogic inference engines
-
m2csmt
A solver for systems of non-linear (in)equations
-
nicolas
Computational Algebra Library
-
brik64-core
BRIK-64 Core Monomers — Digital Circuitality for Rust. 128 monomers (64 core + 64 extended) + EVA algebra composition.
-
stem-derive-core
Shared macro utilities for STEM derive macros — syn/quote/proc-macro2 helpers
-
cadrum
Rust CAD library powered by statically linked, headless OpenCASCADE (OCCT 8.0.0-rc5)
-
xmath
Rust port of Microsoft DirectXMath
-
sci-find-peaks
port of SciPy's find_peaks function, designed to match SciPy's behavior exactly
-
oxilean
Pure Rust theorem prover and dependent type checker inspired by Lean 4
-
noir-bignum-paramgen
command line tool to convert a modulus into bignum instance parameters for https://github.com/noir-lang/noir-bignum
-
lmaths
A short 2D Maths library
-
topological_peak_detection
A mostly efficient topological algorithm for finding all peaks in a 1-D signal
-
stcalc
Stack calculator
-
netlib-src
The package provides a source of BLAS and LAPACK via Netlib
-
large-primes
Package for Large Prime Number Analysis
-
rstm-rules
implements the core modules of the rstm sdk
-
complex_algebra
supporting complex number algebra
-
srmfpa
Floating-point's four arithmetic operations (including fused multiply-add) and square root with strict rounding mode
-
diffurch
Numerical solver for ordinary and delay differential equations
-
amari-topology
Topological tools for geometric structures - homology, persistent homology, Morse theory, and manifold analysis
-
arkley
several traits for common mathematical operations
-
rusoda
Pure rust and just need log dependencies implementation of odepack dlsoda
-
cli-calc-rs
A CLI calculator made in Rust
-
permutations
generating permutations
-
tl_cuda
CUDA GPU tensor library for TL
-
decimal-wad
Math for preserving precision floats up to 18 decimal places
-
akima_spline
A lightweight (only one dependency with 18 SLoC) implementation of a 1d Akima spline with optional smooth extrapolation and derivative calculation
-
malachite-float
The arbitrary-precision floating-point type Float, with efficient algorithms partially derived from MPFR
-
hundred-doors
calculating and visualizing the '100 Doors' problem
-
alpha_g_detector
handle the raw output of the ALPHA-g detectors
-
fcwt
Fast Continuous Wavelet Transforms
-
inexor-rgf-model-logical
Inexor - Reactive Graph Flow - Model - Logical
-
amari-automata
Cellular automata, inverse design, and self-assembly using geometric algebra
-
gchemol-readwrite
Reading/writing chemical objects for gchemol
-
libmat
tools for linear algebra
-
matrix_operations_cuda
perform matrix operations using cuda
-
csaps
Cubic spline approximation (smoothing)
-
binarybit
Boolean algebra operations in Rust
-
amari-functional
Functional analysis on multivector spaces - Hilbert spaces, linear operators, and spectral theory
-
sized_matrix
Sized matrices using const generics for better type checking and performance
-
const_ops
const-ready version of core::ops / std::ops arithmetic traits
-
magnesia
A math library for Rust
-
pythagorean-hodographs
Pythaogrean hodograph splines
-
dashu-base
Common trait definitions and tools for the
dashulibraries -
lineq
Linear algebra library
-
otter_sat
determining the satisfiability of boolean formulas written in conjunctive normal form, developed to support investigation into solvers by researchers, developers, or anyone curious
-
lyndon-rs
Lyndon words and Lyndon basis for free Lie algebras
-
bempp-octree
create Octrees
-
mat-rs
no_std implementation of mathematical matrix types
-
g_2_0_0
manipulate arbitrary object in the geometric algebra containing two perpendicular vectors that square to 1. Basically 2d VGA
-
astro-float-num
Multiple precision floating point numbers implemented purely in Rust
-
ldl
LDL factorisation for quasi-definite linear systems
-
rustcalc
a CLI calculator tool
-
scivex-optim
Scivex — Optimization, root finding, and numerical integration
-
test_gmp_mpir
test gmp mpir for Rust
-
nabled-core
Core ndarray-native types and shared utilities for nabled
-
neco-complex
Lightweight complex-number foundation for FFT and solver crates
-
polynomial-roots
Find the real roots of huge polynomials in milliseconds
-
fibs
Get a Fibonacci number or sequence
-
bose
mathematical and scientific formulas
-
polymath
Make math in Rust more powerful! (New math datatypes, traits, functions, etc...)
-
stats_traits
Traits for collection-like types to calculate statistics
-
temp-converter-lib
terminal temperature unit converter between Celsius, Fahrenheit and Kelvin
-
fibext
A versatile Fibonacci sequence generator for Rust, with support for large numbers and optional iterator interface
-
cassie
limited computer algebra system written for the fun of it
-
deft-quick-js
QuickJS Javascript engine wrapper
-
qudit-core
Accelerated and Extensible Quantum Library
-
vector_operations
A collection of vector operations for Rust
-
unit_system
Automatically derived typed unit systems
-
finitely
Arithemtic over finite polynomial rings
-
logicaffeine-data
WASM-safe data structures and CRDTs - NO IO
-
runmat-builtins
RunMat built-in functions and standard library components
-
mazer-cli
A minimal, simple math markup language that compiles to HTML, written in Rust
-
oxiphysics-core
Core types, traits, and abstractions for the OxiPhysics engine
-
blas-sys
The package provides bindings to BLAS (Fortran)
-
arkley_numerics
This module provides various number representations and calculations that represent several structs and enums that represent common mathematical numbers such as fractions, standard form, and decimals,
-
cubecl-matmul
CubeCL Matrix Multiplication Kernels Engine
-
logic-rs
representing logical formulas with support for temporal robustness semantics
-
lambert-bate
A fast solver for Lambert's problem
-
rustedbytes-pi
Computes digits of Pi using the Chudnovsky algorithm
-
plonky-cat-verifier
Verifier driver: catamorphism over ReductionFunctor
-
ipasir
Bindings for the IPASIR API to communicate with incremental SAT solvers
-
llml
basic math data types with high level frontend and low level backend
-
mathtomath
Convert mathematical expressions between different formats
-
line-graph
Construct the line graph of an undirected graph
-
robomath
A lightweight, efficient, and generic mathematics library for 3D applications, with a focus on robotics and simulation
-
num2phrase
Convert long number to a sequence of memorisable phrase with combination of short numbers
-
scirust
A scientific computing library
-
deep_core
deep prototype
-
quick_maths
low-dimensional linear algebra structures
-
infmachine
The Infinite Machine
-
Pedersen_hash_function
computes the pedersen hash of given inputs and modular arithmetic
-
klein
Bindings to the Klein PGA3D library
-
plonky-cat-plonk
PLONK arithmetization with custom gates
-
gcv_spline
fitting and evaluating GCV splines
-
fftw-src
Source of FFTW
-
sonnenbrille
8-bit CRC
-
rstm-tape
A generic state implementation and its supporting interfaces
-
scivex-sym
Scivex — Symbolic math, CAS, and expression simplification
-
rustitude-gluex
GlueX Amplitudes for Rustitude
-
fracints
Special case fractional-only fixed point numbers
-
normdecimal
Always normal decimal numbers
-
faer-evd
Basic linear algebra routines
-
scir-gpu
SciR GPU foundations: device arrays and CUDA (feature-gated) elementwise/FIR kernels with CPU parity
-
xbasic
that allows adding a scripting language onto your project with ease. This lets your users write their own arbitrary logic.
-
vector_space_study
Project created for rust study
-
oldies-gui
Modern GUI for OldiesRules - Real-time visualization with egui
-
ubiquity-hyperquiver
HyperQuiver extension: multilinear hyperedges for complex multi-input interactions in directed graph structures
-
claire_vector
claire is a rust lib for vector calculus
-
colamd
Column approximate minimum degree ordering algorithm
-
primal
primalputs raw power into prime numbers. This crates includes: optimised prime sieves, checking for primality, enumerating primes, factorising numbers, and state-of-the-art estimation of upper and… -
number-diff
number-based is an attempt of mine to make working with calculus easier
-
lambda-rt
Lambda calulcus backend library
-
scir-core
SciR core utilities: numeric tolerances, complex helpers, and shared test macros for the SciR ecosystem (SciPy rebuilt for Rust)
-
lamcal-repl
A lambda calculus command line repl
-
fixed-vectors
Lightweight library implementing fixed-length vectors for Rust applications not compiled with the standard library
-
nd_interpolate
1-10 dimensional linear and cubic spline interpolation implemented in Rust
-
matlabblas-src
Provide a source for MATLAB's BLAS library for use with the BLAS crates
-
glpk-api-sdk
Rust client SDK for GLPK REST API
-
yttria
that re-exports the other yttria sub-libraries for radio application development
-
swnb-complex
complex number lib
-
coheron
simulating and analyzing coherent wave phenomena
-
aberth
Aberth's method for finding the zeros of a polynomial
-
vincent_blur
My own implementaion of guassian blur using threads
-
lodestone_core
User friendly magnetic field calculations in Rust
-
smolmatrix
Small simple matrix library
-
num-absurd
A mathematical framework extending traditional field theory to allow division by zero in an algebraically consistent manner
-
vex
3D math library
-
usze
Sometimes you just need a calculator
-
saa-crypto
Cryprography related logic of smart account auth
-
avlsort
AVL tree holding the rank and the number of duplicates of elements
-
symmetric-interaction-calculus
A programming language and model of computation that matches the abstract algorithm perfectly
-
coin_cbc_sys
Rust bindings to the CoinOR CBC MILP Solveur using the C API
-
groebner
implementing Groebner basis algorithms
-
spdcalc
Spontaneous Parametric Downconversion Calculator
-
simplex-23d-rs
Simplex 2d/3d noise in Rust
-
fixp
Fixed-point numbers
-
lamb
Pure untyped lambda calculus in safe Rust
-
qalculate-rs
Safe Rust bindings for Qalculate library
-
vector-basis
Access components of generic vector types
-
carbon-simd
SIMD utilities written with Rust (fularuen project)
-
upcast-arithmetic
Arithmetic that is upcasted on overflow
-
fj-interop
Early-stage b-rep CAD kernel
-
qunit
Experimental uom-like library which enables compile-time verification of dimensional analysis, with support for statically-sized vectors and matrices
-
metamath-rs
manipulating Metamath databases, including a parallel and incremental verifier for Metamath databases
-
logicpearl-observer
Configurable native observers and phrase matching helpers for LogicPearl
-
dualquat
Quaternion and Dual Quaternion math library for high-precision physics simulation
-
algebr
Basic algebra
-
fancy_indexing
numpy's fancy-indexing for Rust linear algebra crates
-
nalgebra-numpy
conversions between nalgebra and numpy
-
ctm_demo
Demonstration of the Consistent Tangent Modulus in Computational Plasticity
-
nb2fr
Convert integer number to literal French text
-
faer-ext
faer API for interoperability with external libraries
-
natural_constants
Pre-defined constants from all disciplines (math, physics, ...)
-
igsolve
The program for solving impartial games
-
waker_protocol
using the crate waker_tables creating custom waker logic
-
operations
Basic algebraic and mathematical expressions for use with dynamic elements
-
ak_arith_crate
perform arithmetic operations on i32 data type instance
-
finitediff
Finite/numerical differentiation
-
damndiff
Numerical methods for ODE
-
ihateintegrals
A computer algebra library for solving integrals
-
itying-add-lib
adding numbers
-
softfloat-wrapper-riscv
a safe wrapper of Berkeley SoftFloat based on softfloat-sys for RISC-V based on https://github.com/dalance/softfloat-wrapper
-
modulo-n-tools
modulo tools
-
in_range
Returns true if a number is in range
-
jacc
Just another cli calculator: A maths interpreter for the command-line
-
scotch
Idiomatic wrapper for Scotch, the graph partitioner, graph clusterer and sparse matrix orderer
-
calcul8
calculator CLI
-
mdarray-linalg-lapack
LAPACK backend for mdarray-linalg
-
kalk_cli
A calculator that supports user-defined functions, variables and units, and can handle fairly ambiguous syntax
-
irox-geometry
2D and 3D Geometry Primitives
-
geo-aid-json
Support for JSON output from Geo-AID
-
simple_mod_int
modint library
-
flowscad
2D graphic and 3D object design with a Rustic functional approach. SVG and OpenSCAD output.
-
g_calc
A small utility for performing simple math calculations using infix expression
-
hypercpu
Distributed symbolic computation
-
anxious
panic-free dialect of Rust
-
pathwise-geo
Riemannian manifold SDE simulation (geodesic Euler/Milstein/SRI) on S^n, SO(n), SPD(n) via the cartan geometry library
-
ftl-numkernel
designed to provide numerical operations and error handling for both real and complex numbers, also supporting arbitrary precision types
-
ndarray-odeint
solve ODE using rust-ndarray
-
keystone-wasm
WASM bindings for Keystone financial computation
-
cadk
CAD kernel in pure Rust (B-Rep, CSG, tessellation)
-
avatar_graph
Avatar Graphs
-
bevy_hexasphere
A trimmed down and generic version of Hexasphere for bevy
-
dec-number
Decimal Floating Point Arithmetic for Rust
-
rustc_apfloat
Rust port of C++ llvm::APFloat library
-
scicalc-rs
parsing and doing calculations with measurements, typically used in scientific contexts
-
delaunay_creator
delaunay triangulation for 2D and 3D(not implemented yet)
-
arrow-ml-backend-metal
Metal GPU backend plugin for arrow-ml. Discovered at runtime by arrow-ml-common's backend registry.
-
stack-algebra
Stack-allocated lightweight algebra for bare-metal rust
-
fuelcheck-core
Core provider and reporting logic for fuelcheck
-
bens_number_theory
A sample Rust project for number theory stuff (I'm using this to learn Rust)
-
sp1-gpu-jagged-assist
GPU helper kernels for jagged polynomial operations
-
sph2mm
Add an AMR background to an existing SPH initial conditions file
-
sv4state
SystemVerilog 4-state value library
-
geom
2D geometry library
-
mraphics-native
The part of Mraphics that runs on native platforms
-
smt_sb-rs
SMT Simple Binding
-
primeval
A monstrosity of a prime number generator
-
avila-vec3d
3D math library - vectors, matrices, quaternions, AABB, ray casting - 100% Rust
-
cuba
wrapper for the C Cuba integration library
-
aljabar
A super generic, super experimental linear algebra library
-
type-proof
type-checked propositional logic proofs
-
clfft
Bindings for clFFT, a FFT library for OpenCL
-
rusty-psf
A comprehensive Point Spread Function (PSF) library for microscopy and optical systems
-
geometric_algebra
Generate(d) custom libraries for geometric algebras
-
leanr-rag-gateway
Multi-lane RAG gateway with cost routing and verified safety proofs using lean-agentic
-
aprender-solve
Dense linear algebra solvers — LU, QR, SVD, Cholesky with provable contracts
-
cinter
const usable bigints
-
accelerate-general
A general matrix and vector operations library using Apple's Accelerate framework
-
rml
A machine learning library in Rust
-
infmachine_examples
Examples for the Infinite Machine
-
tnt
runtime validated proofs in number theory
-
lettuces
A grid logic crate combining Hexx and custom logic for square and isometric grids to provide a unified grid logic crate
-
symbolics_calculus
Calculus module for the symbolics computer algebra library
-
mish
A proof of concept Rust libm like implementation with almost full coverage of libm
-
bigint-base10
Experimental API for dealing with big integers in base-ten
-
scir-fft
SciR FFT: parity-first FFT/RFFT/IRFFT with fixture-based testing and rustfft/realfft backends
-
bempp
Boundary element method library
-
formally-cli
the open-source formal methods toolchain - command-line interface
-
ark-test-curves
testing ark-ec & ark-poly
-
parabola
Representation of a parabola of the form
ax² + bx + c -
divisors
A blazing fast library to find all divisors of a natural number
-
makima_spline
modified akima spline interpolation
-
plonky-cat-tensor-pcs
Tensor polynomial commitment schemes: Ligero, Brakedown, Orion
-
quantrs2-symengine-pure
Pure Rust symbolic mathematics for quantum computing - a replacement for C++-based symengine
-
polynomial-over-finite-prime-field
polynomial over finite prime field
-
goertzel-nostd
An nostd implementation of Goertzel's Algoritm
-
log2fix
no_std fixed-point base 2, e and 10 logarithm algorithm implementation
-
qlora-gemm-f32
f32 matrix multiplication for qlora-gemm - maintained fork using qlora-paste
-
dec-number-sys
Rust bindings for The decNumber C library by IBM Fellow Mike Cowlishaw
-
lineic
Flexible linear interpolator for Rust
-
plonky-cat-prover
Prover driver: anamorphism over ReductionFunctor
-
moonalloy
The oxidized scientific computing library for the 21st century
-
haversine-redux
Haversine formular library to determine the distances between two coordinates on the earth
-
dess-examples
DESS examples
-
tuppu-scalar
Exact scalar arithmetic with rational numbers and uncertainty tracking for geometric algebra
-
reuler
Solutions to Project Euler in Rust
-
nonstdfloat
Floating point calculations for strafe
-
polynomials-ecc
operating on polynomials over the BLS12-381
-
vonkarman-fft
FFT backends for the vonkarman solver
-
rust-expression
Calculator and solver for linear equations
-
opensrdk-symbolic-computation
Standard automatic differential library for OpenSRDK toolchain
-
maph
Maths package for use with personal stuff, but like, you can totally use it! If you want! There's even some light documentation now!
-
alpha_g_physics
Data analysis library for the ALPHA-g experiment
-
tmn
Instrument for working with complex numbers and quaternions
-
rs-lambda
A lambda calculus interpreter written in rust
-
del-geo-core
2D/3D geometry utility codes
-
lsode
Solve systems of differntial equations using LSODE subroutine from ODEPACK written in Fortran
-
sophy
A lightweight, efficient mathematical library for numerical methods, functions, and utilities in pure Rust
-
rustnomial
working with polynomials
-
ruvector-graph-transformer-wasm
WASM bindings for ruvector-graph-transformer: proof-gated graph attention in the browser
-
simple_2d_vector
two-dimensional vectors in Rust
-
glar-gemm-c64
high performance cpu kernels
-
concrete-fftw
Safe wrapper around FFTW
-
bitslice
transpose bits into and out of bitslice format, and perform various operations on bitsliced data
-
vonkarman-io
HDF5 snapshots and I/O for the vonkarman solver
-
kingmaker
A modular, performant, social choice framework for the simulation, computation, and analysis of strategic voting
-
ft_lib
Manual implementation of some math functions
-
inexor-rgf-plugin-arithmetic
Inexor - Reactive Graph Flow - Plugin - Arithmetic
-
rstmt-traits
Various traits used to establish the foundation of the rstmt framework
-
dashu-ratio
A big rational library with good performance
-
cpntt
Number Theoretic Transform for competitive programming
-
volterra-fields
Tensor field types on Cartesian grids: Q-tensor, velocity, pressure, and scalar fields for 2D/3D active nematics
-
simplecalc
CLI calculator
-
rivrs
Symbolic compiler for Rust
-
ida
A pure Rust port of the Implicit Differential-Algebraic solver from the Sundials suite
-
max_len_base_10_as_usize
Trait offering constant maximum lengths of primitive integers as usize
-
rstm-programs
focuses on providing various structures and utilities for programs within rstm
-
oxicuda-solver
OxiCUDA Solver - GPU-accelerated matrix decompositions (cuSOLVER equivalent)
-
slvs
Rust wrapper for the SolveSpace constraint solver library
-
levitate
Just works solution to numbers, mainly aimed at floats and mathematical use cases
-
CLI_Project_Scott_Coakley
CLI Project in Rust
-
gap_solver
A solver for the generalized assignment problem
-
rmath-cli
cli calculator
-
path_semantics_std
type checked implementation of the standard dictionary of path semantics using constrained functions
-
plotters-fullerene
plotters fullerene and polyhedron for Rust
-
trueno-sparse
Sparse matrix formats and operations — CSR, COO, BSR with SIMD-accelerated SpMV/SpMM
-
oldies-copasi
COPASI/SBML biochemical network simulator revival in Rust
-
gorf-blc
Lambda calulcus backend library
-
adv_linalg_lib
Core library for Adv_LinAlg procedral macros
-
plummerprimes
Builds, Runs, and reports benchmarks from https://github.com/PlummersSoftwareLLC/Primes
-
rcalc_lib
Mathematical expression calculation library
-
antic-sys
Bindings to the Antic library
-
logicaffeine-verify
Z3-based static verification for Logicaffeine (requires Pro+ license)
-
awint_core
Core no-std and no-alloc
awintfunctionality -
oscirs_linalg
GPU accelerated linear algebra crate for scientific computing
-
flint-sys
Bindings to the FLINT C library
-
crum
Tensors, Matrices and Complex numbers for numerical analysis
-
generic_fixedpoint
Generic fixed-point numbers
-
qsim-solvers
Power flow solvers (DC, AC) for qsim
-
bacon-sci-1
Scientific computing in Rust
-
ubiquity-quiver
Directed graph structures (quivers) for neural network-inspired computation with nodes, arrows, weights, and activations
-
rgla
A linear algebra library for graphics that implements rotors instead of quaternions
-
vec_arith
Powerful vector/matrix arithmetic library written in Rust
-
exp_root_log
Fast and interpretable function approximation with exp-root-log basis
-
oxicuda-levelzero
OxiCUDA Level Zero — GPU compute via Intel oneAPI/Level Zero (pure Rust, libloading)
-
arithmetic_parser_kma
Arithmetic expression calculator parser
-
modtype
Macros that implement modular arithmetic integer types
-
dd_maths_traits
Strongly recommended to avoid using while in development. No semver guarantees.
-
matrix42
A linear algebra library developed as a project in the 42 ecosystem
-
lapacke
The package provides wrappers for LAPACKE (C)
-
symbolic_polynomials
manipulation of polynomials over the integers
-
sophus_lie
Lie groups in 2D and 3D: rotations, translations, etc
-
palb
A fast and exact method for solving least absolute deviations line problems (Affine-linear L1 regression)
-
gates
simulate logical gates
-
gaussiant
Gaussian integers
-
bignumber
arbitrary-precision decimal and non-decimal arithmetic
-
nalgebra-glm
A computer-graphics oriented API for nalgebra, inspired by the C++ GLM library
-
mixingcut
A program to solve the MAXCUT SDP Relaxation
-
conclave-room
Logic for a Conclave Room
-
ios_calculator
iOS calculator implementation
-
i_mth
A math library continuously under development made for use in particle and ridgid body dynamics and statics
-
mdarray-linalg-blas
BLAS backend for mdarray-linalg
-
euclidean
A collection of operations for euclidean geometry in three dimensions
-
miscmath
will be a collection of general math functions and linear algebra structures like vectors and matrices
-
solverforge-service
JVM lifecycle management for SolverForge
-
minroot-core
Pure Rust reference implementation of MinRoot VDF field arithmetic
-
sci_task_mgr
A Universal Scientific Calculation Task Manager
-
oxicuda-sparse
OxiCUDA Sparse - GPU-accelerated sparse matrix operations (cuSPARSE equivalent)
-
cheby
Chebyshev polynomial toolkit: node generation, coefficient fitting (DCT), and Clenshaw evaluation — generic over scalar type
-
linear_algebra
basic linear algebra operations in Rust
-
yttria-coding
A mathematical coding library tailored for use with the yttria set of libraries
-
sum_range
The sum of all consecutive numbers, both even and odd
-
gml
Graphics Math Library. Generic Vector and Matrix Math library targetting graphics applications.
-
lodestone_python
User friendly magnetic field calculations in Rust
-
facto
Integer factorization and prime certification
-
codebreaker-solver
A solver for codebreaker aka. bulls and cows. Generates guesses which will guess the code in at most 5 tries.
-
bigint-benchmark
Benchmarks for big integer implementations
-
closure_calculus
Closure Calculus
-
infmachine_gen
The Infinite Machine generator library
-
rust-miller-rabin
Miller-Rabin primality test
-
signed
working with signed numbers' absolute values avoiding confusion
-
algebrust
basic linear algebra operations
-
slop-multilinear
Multilinear polynomial extensions for SLOP
-
fenris-traits
Core traits used by fenris
-
alga
Abstract algebra for Rust
-
prime-data
Prime Number Data Library
-
oxicuda-fft
OxiCUDA FFT - GPU-accelerated FFT operations (cuFFT equivalent)
-
hop-mix
Batch polynomial mixers for hop-actions
-
microcheby
Single variable function approximation using Chebyshev polynomials. Embedded friendly and no_std compatible.
-
nut_sys
Wrapper for Number-Theory-Utils C library
-
fj-math
Early-stage b-rep CAD kernel
-
container-broadcast
analog of Julia's broadcast interface
-
glar-gemm-c32
high performance cpu kernels
-
hmath
Big Integers and Rational Numbers
-
rust-linear-algebra
A linear algebra library for Rust
-
dimensionals
Rust native generic, flexible n-dimensional array
-
predicatechecker
Check that a predicate is true if another is
-
transforms
A transform library to track reference frames and provide transforms between them
-
hebrides
Implementations for the real numbers, complex numbers, and basic linear algebra
-
analit
Add another dimension to your Rust project with analog geometric literals
-
oxigdal-analytics
Advanced geospatial analytics for OxiGDAL - Time series, clustering, hotspot analysis, and interpolation
-
runmat-static-analysis
Domain-specific static analysis passes for RunMat
-
const_num_bigint
const bigint
-
crlibm
Binding to CRlibm, a correctly rounded math lib
-
exact-conv
Exact conversions between integer and floating point types
-
ferray-ma
Masked arrays with mask propagation for ferray
-
computable-real
Computable real number
-
qlora-gemm-f64
f64 matrix multiplication for qlora-gemm - maintained fork using qlora-paste
-
xfft
Fast Fourier Transforms
-
pire-gemm-s8u8s32
high performance cpu kernels
-
hints
computing weighted threshold signatures
-
feos-core
Core traits and functionalities for the
feosproject -
inertia
Inertia
-
inexor-rgf-model-arithmetic
Inexor - Reactive Graph Flow - Model - Arithmetic
-
qcd-sme
numerical library for the screened massive expansion of QCD
-
simple_3d_vector
three-dimensional vectors in Rust
-
coral-blas
a pure-rust safe blas implementation
-
core-math-sys
Generate bindings to CORE-MATH
-
codemonk-primes-cli
A command-line utility for finding prime numbers
-
russell_nonlin
Numerical continuation methods to solve nonlinear systems of equations
-
faer-lu
Basic linear algebra routines
-
geo-aid-math
The mathematics engine for Geo-AID
-
nexcore-crystalbook
The Crystalbook — immutable, content-addressed scientific documents with Merkle integrity and cryptographic seal chains
-
ferrix
matrix library for Rust
-
matriz
Zero allocation Rust linear algebra library
-
gardiz
integer geometry on 2D planes, focused on games
-
tuppu-reactive
Reactive bindings for scene graph
-
kahan_pairs
Generate pairs of integers
-
ferray-stats
Statistical functions, reductions, sorting, and histograms for ferray
-
bicubic
A base for bicubic interpolation
-
argmin-observer-slog
slog logging observer for argmin
-
cartan-stochastic
Stochastic analysis on manifolds: orthonormal frame bundle, horizontal lift, Stratonovich development. Foundation for Eells-Elworthy-Malliavin Brownian motion and Bismut-Elworthy-Li Greeks.
-
deepcl-common
Common crate for DeepCL
-
irox-unsafe
irox (unsafe) Rust Tools & Libraries
-
oldies-modeldb
ModelDB model importer for legacy neural models in Rust
-
cblas
The package provides wrappers for CBLAS (C)
-
acgmath
A linear algebra and mathematics library for computer graphics. A fork of
cgmath. -
const-time-bignum
A constant time bignum library that operates fully on the stack, effectively eliminating the side channel attack vector
-
Gen_Prime
A way to transform a hash to a prime number
-
nice-numbers
Small library for number sequences
-
val_unc
A package for handling quantities with uncertainties
-
factordb
Rust wrapper for FactorDB API
-
logicaffeine-lexicon
English vocabulary types and compile-time lexicon lookup for logicaffeine
-
gorf-lcobj
Lambda calulcus backend library
-
bluebird
that defines common SKI combinators from Combinatory Logic
-
sphrs
Spherical harmonics and solid harmonics
-
math-fun
A package providing mathematical functions commonly used in science and engineering
-
crabsformer
fundamental library for scientific computing with Rust, highly inspired by NumPy
-
polyhedron-faces
polyhedron faces for Rust
-
avx-bignum
Big integer arithmetic (U1024, U2048, U4096, I4096)
-
find-real-roots-of-polynomial
find all real roots of a polynomial
-
min_infmachine_exec
The Minimalistic Infinite Machine Executor and Debugger
-
mermaid
Experimental Linear Algebra
-
quantique
Pragmatic geometric algebra core with runtime signatures
-
strafe-error
Error types for strafe
-
safe_decimal
that solves the recurring decimal problem with fractions
-
fibo
Compute the N-th Fibonacci number with arbitrary number precision
-
si_units
handling arithmetic with SI units
-
wgebra
Composable WGSL shaders for linear algebra
-
const-decimal
Integer-backed decimals with constant precision
-
linalg-rs
Linear algebra in Rust!
-
bempp-quadrature
Simplex quadrature rules and boundary element singular quadrature
-
primality-test
Primality Test crate
-
oxilean-std
OxiLean standard library
-
spaceform
A cross-platform SIMD-accelerated maths library for 3D graphics
-
geologic
Mathematical and geometrical abstractions with a focus on ergonomics
-
rufft
A pure rust FFT library !
-
vectorial
general-purpose vector math
-
mini-kanren
miniKANREN in Rust
-
infallible_tobigint
Infallible ToBigInt/ToBigUint conversion traits for num-bigint
-
fastfloat
Fast-math wrapper and convenient numeric functions for approximate floating point operations in Rust
-
elr_primes
prime number iterator and methods for basic calculations with prime numbers
-
xcomplex
A complex number library
-
diffusionx-cuda-kernel
cuda kernels for diffusionx
-
yttria-modulation
A communications library tailored for use with the yttria set of libraries
-
prime_finder_rust
A prime finder made in Rust (originally made in c++)
-
ffts
Rust binding for ffts (The Fastest Fourier Transform in the South)
-
rustyhdf5-py
Python bindings for rustyhdf5 — a pure-Rust HDF5 library
-
aprender-tensor
N-dimensional tensor contractions — Einstein summation via TTGT (cuTENSOR parity)
-
num_base
manipulating with numbers (integers) in different bases
-
mosekcomodel_highs
HIGHS backend for mosekcomodel
-
oxicuda-metal
OxiCUDA Metal - GPU compute via Apple Metal API (macOS only)
-
laddu-core
Core of the laddu library
-
bdrk_geometry
Geometry Helpers
-
primesieve_wrapper
Wrapper for Primesieve C library
-
junglefowl
Brutally murdering Rust's type system one proof at a time
-
primal-sieve
A high performance prime sieve
-
nano-gemm
Small matrix multiplication
-
nonscalar
Functions and types for operating on nonscalar values like vectors and complex numbers
-
math_vector
3D vector class
-
calculator_util
that helps you evaluating mathmatical expressions
-
totsu_f32cuda
CUDA linear algebra operations for
totsu/totsu_core -
cellular_raza-core
Cellular simulation tool
-
num-irrational
num-irrationalis based onnumand extends it with support for several kinds of irrational numbers -
temporal-lead-solver
Temporal computational lead via sublinear local solvers for diagonally dominant systems
-
rsl-polynomials
A re-write of GSL's Polynomials Routines in Rust
-
ring-math
Polynomial ring math over scalar finite fields
-
nano-gemm-codegen
Small matrix multiplication
-
gateutil
basic utilities for GateSim
-
calcifer-server
Backend logic for the Calcifer project
-
gf2poly
GF(2) polynomial arithmetic
-
num_vector
Enabling basic vector arithmetic operations
-
fpn
Fixed point number
-
polynomials_pro
pro-level polynomials
-
sylvan_number
My own big number implementation, just for my own uses
-
spsolve
Solve sparse systems of linear equations
-
gpurs
GPU acceleration/linear algebra crate for scientific computing
-
poly_interp
but powerful polynomial library focused on interpolation between points
-
oxicuda-vulkan
OxiCUDA Vulkan — GPU compute via Vulkan/SPIR-V (ash runtime loader, pure Rust)
-
faer-sparse
Basic linear algebra routines
-
modcholesky
Modified Cholesky decompositions
-
primerug
A prime k-tuple finder based on the rug crate
-
ema
using exponential moving averages
-
qlora-gemm-c32
c32 (complex f32) matrix multiplication for qlora-gemm - maintained fork using qlora-paste
-
math_rust
A Math library for vectors
-
russell_pde
Essential tools to solve partial differential equations; not a full-fledged PDE solver
-
versioned-feature-core
Minimal logic for versioned features
-
logicrs
logic expression
-
runmat-kernel
Jupyter kernel implementation for RunMat using ZeroMQ and the Jupyter protocol
-
strafe-type
Types for strafe
-
quantrs2-symengine
Symbolic Computation in Rust via SymEngine
-
slop-sumcheck
Sumcheck protocol implementation for multilinear polynomials
-
fj-app
Early-stage, next-generation, code-first CAD application. Because the world needs another CAD program.
-
num-rug-adapter
An adapter to use num crate where rug is needed
-
oxicuda-rocm
OxiCUDA ROCm — GPU compute via AMD HIP runtime (pure Rust, libloading)
-
cudd
Cudd Rust library
-
matrix-simp
A linear algebra package (WIP)
-
tuppu-command
Command system with undo/redo
-
sp2
2D spatial transforms and movement representations using geometric algebra
-
primenumbe-rs
Generate the nth prime number
-
propositional
Logic
-
faer-qr
Basic linear algebra routines
-
rustbot
My package for aimbot calculations / vector math
-
primality
Check if a number is prime
-
nalgebra-macros
Procedural macros for nalgebra
-
sort_rust
sort for Rust
-
scirs2-core
Core utilities and common functionality for SciRS2 (scirs2-core)
-
fuzzylogic
operations for fuzzy set theory
-
rstsr-linalg-traits
An n-Dimension Rust Tensor Toolkit
-
ark-vesta
The Vesta prime-order elliptic curve
-
guff-sharefiles
Package IDA-encoded data in a portable file format
-
nutils-poly
Low-level functions for evaluating and manipulating polynomials
-
polynom
handling polynomials
-
oldies-neuron
NEURON simulator revival in Rust - HOC and NMODL parsers for cable equation modeling
-
gorf-blc2
Lambda calulcus backend library