-
num-bigint
Big integer implementation for Rust
-
statrs
Statistical computing library for Rust
-
kurbo
A 2D curves library
-
rug
Arbitrary-precision integers, rational, floating-point and complex numbers based on GMP, MPFR and MPC
-
bigdecimal
Arbitrary precision decimal numbers
-
euclid
Geometry primitives
-
nalgebra
General-purpose linear algebra library with transformations and statically-sized or dynamically-sized matrices
-
num-traits
Numeric traits for generic mathematics
-
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
-
ruint
Unsigned integer type with const-generic bit length
-
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…
-
rapier3d
3-dimensional physics engine in Rust
-
faer
linear algebra library
-
argmin
Numerical optimization in pure Rust
-
hexasphere
evenly tile hexagons on a sphere
-
mint
Math interoperability standard types
-
kalc
a complex numbers, 2d/3d graphing, arbitrary precision, vector/matrix, cli calculator with real-time output and support for units
-
noisy_float
Contains floating point types that panic if they are set to an illegal value, such as NaN
-
ark-poly
efficient polynomial arithmetic via FFTs over finite fields
-
parry3d
3 dimensional collision detection library in Rust
-
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
-
openblas-src
The package provides a source of BLAS and LAPACK via OpenBLAS
-
num-dual
Generalized (hyper) dual numbers for the calculation of exact (partial) derivatives
-
peroxide
Rust comprehensive scientific computation library contains linear algebra, numerical analysis, statistics and machine learning tools with farmiliar syntax
-
lambert_w
Fast and accurate evaluation of the Lambert W function by the method of T. Fukushima.
-
bnum
Arbitrary, fixed size numeric types that extend the functionality of primitive numeric types
-
simple_moving_average
moving average (SMA) algorithms
-
malachite
Arbitrary-precision arithmetic, with efficient algorithms partially derived from GMP, FLINT, and MPFR
-
ode_solvers
Numerical methods to solve ordinary differential equations (ODEs) in Rust
-
plotpy
Rust plotting library using Python (Matplotlib)
-
scirs2-fft
Fast Fourier Transform module for SciRS2 (scirs2-fft)
-
lambdascript
Instructional program detailing the beta reduction of typed and untyped lambda terms
-
fastnum
Fast decimal numbers library
-
puruspe
Pure Rust Special function library
-
gauss-quad
applying Gaussian quadrature to integrate a function
-
clarabel
Conic Interior Point Solver for Rust / Python
-
feanor-math
number theory, providing implementations for arithmetic in various rings and algorithms working on them
-
sguaba
Hard to misuse rigid body transforms (aka "spatial math") for engineers with other things to worry about than linear algebra
-
common_traits
Traits to write generic functions on different numeric types, with atomic support, and other features
-
ellip
Elliptic integrals for Rust
-
num-rational
Rational numbers implementation for Rust
-
feos
framework for equations of state and classical density functional theory
-
gemlab
Geometry and meshes laboratory for finite element analyses
-
mosekcomodel
Conic Optimization Modeling with Mosek
-
cubecl
Multi-platform high-performance compute language extension for Rust
-
disintegrate
build event-sourced applications
-
lapack
The package provides wrappers for LAPACK (Fortran)
-
factorion-bot-discord
factorion-bot (for factorials and related) on Discord
-
pxfm
Fast and accurate math
-
lua-src
Sources of Lua 5.1-5.5 and logic to build them
-
ultraviolet
do linear algebra, fast
-
num-bigint-dig
Big integer implementation for Rust
-
lp_parser_rs
parser for the LP file format
-
math-core
Convert LaTeX equations to MathML Core
-
dec
A decimal arithmetic library providing high-level, safe bindings to libdecnumber
-
trueno
High-performance SIMD compute library with GPU support for matrix operations
-
mathypad
A smart TUI calculator that understands units and makes complex calculations simple
-
libcrux-hacl-rs
Formally verified Rust code extracted from HACL* - helper library
-
wedged
A robust and generalized library for Geometric Algebra in Rust
-
deno_graph
Module graph analysis for deno
-
ndrustfft
N-dimensional FFT, real-to-complex FFT and real-to-real DCT
-
num-quaternion
Quaternion numbers implementation for Rust
-
quantities
Unit-safe computations with quantities
-
kcl-ezpz
A constraint solver for KCL and Zoo Design Studio
-
russell_lab
Scientific laboratory for linear algebra and numerical mathematics
-
csgrs
Constructive solid geometry (CSG) on meshes using BSP trees in Rust
-
rsparse
solving sparse linear systems using direct methods
-
scientific
Arbitrary precision scientific number (no_std capable, in pure Rust)
-
adic
Arithmetic and rootfinding for p-adic numbers
-
cavalier_contours
2D polyline/shape library for offsetting, combining, etc
-
krabmaga
A modern developing art for reliable and efficient Agent-based Model (ABM) simulation with the Rust language
-
f256
Octuple-precision floating-point arithmetic
-
fend
Arbitrary-precision unit-aware calculator
-
logicaffeine-kernel
Pure Calculus of Constructions type theory - NO LEXICON
-
light-curve-feature
Feature extractor from noisy time series
-
ganesh
Function minimization in Rust, simplified
-
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…
-
machine-prime
ne plus ultra primality testing for machine-sized integers
-
minmax-cli
programs computing min and max argument values
-
option-operations
Traits and auto-implementations to improve arithmetic operations usability when dealing with
Options -
twenty-first
Collection of mathematics routines and cryptography for the twenty-first century
-
numeris
Pure-Rust numerical algorithms library — high performance with SIMD support while also supporting no-std for embedded and WASM targets
-
substrate-fixed
Fixed-point numbers
-
mathlab
A Powerful Math Library for Rust
-
quaternion-core
quaternion operations and interconversion with several attitude representations
-
uniform-cubic-splines
uniform cubic spline evaluation and inversion
-
maths-rs
A linear algebra library for gamedev and graphics
-
parry2d
2 dimensional collision detection library in Rust
-
clipper2-rust
Pure Rust port of the Clipper2 polygon clipping and offsetting library
-
nuts-rs
Sample from unnormalized densities using Hamiltonian MCMC
-
angle-sc
performing accurate and efficient trigonometry calculations
-
scirs2-linalg
Linear algebra module for SciRS2 (scirs2-linalg)
-
num-modular
efficient integer division and modular arithmetic operations with generic number types. Supports various backends including num-bigint, etc
-
simba
SIMD algebra for Rust
-
ndarray-glm
Performs regression for generalized linear models using IRLS on data stored in arrays
-
sliding_features
Modular sliding window with various signal processing functions and technical indicators
-
pragmastat
Pragmatic Statistical Toolkit
-
const-primes
Work with prime numbers in const contexts. Prime generation, primality testing, prime counting, and more.
-
oxidd
A safe, concurrent, modular, and performant decision diagram framework
-
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…
-
enterpolation
creating and computing interpolations, extrapolations and smoothing of generic data points
-
rivrs-sparse
Sparse linear algebra solvers
-
symbolica
A blazing fast computer algebra system
-
clock-curve-math
High-performance, constant-time, cryptography-grade number theory library for ClockCurve ecosystem
-
russell_sparse
Solvers for large sparse linear systems (wraps MUMPS and UMFPACK)
-
i_float
This fixed float math library provides an efficient and deterministic solution for arithmetic and geometric operations
-
ninterp
Numerical interpolation for N-dimensional rectilinear grids
-
circom-witnesscalc
Witness calculator for Circom circuits
-
mahc
riichi mahjong calculator library and CLI
-
complex-bessel
Pure Rust implementation of complex Bessel functions (J, Y, I, K, H, Airy) based on Amos Algorithm 644
-
microlp
A fast linear programming solver library
-
diffsol
solving ordinary differential equations (ODEs) in Rust
-
waveasm
Assembler for the Wave2 CPU Architecture
-
kzg-rs
KZG point evaluation
-
oxiblas-blas
BLAS operations for OxiBLAS - pure Rust implementation
-
mathru
Fundamental algorithms for scientific computing in Rust
-
qfall-math
Mathematical foundations for rapid prototyping of lattice-based cryptography
-
kz80_bc
Arbitrary-precision decimal arithmetic language and calculator for Z80
-
stv-rs
Single Transferable Vote implementation in Rust
-
propagators-chirho
propagator networks for constraint propagation and bidirectional computation
-
feldera-fxp
Fixed-point decimal with fixed precision and scale
-
vectrix
A stack-allocated matrix type implemented with const generics
-
geonum
geometric number library supporting unlimited dimensions with O(1) complexity
-
ruvector-solver
Sublinear-time solver for RuVector: O(log n) to O(√n) algorithms for sparse linear systems, PageRank, and spectral methods
-
problemreductions-cli
CLI tool for exploring NP-hard problem reductions
-
lstsq
Return the least-squares solution to a linear matrix equation
-
amari-enumerative
Enumerative geometry capabilities for the Amari library
-
primitive_fixed_point_decimal
Primitive fixed-point decimal types
-
glyph_brush_layout
Text layout for ab_glyph
-
honeycomb-core
Core structure implementation for combinatorial maps
-
axoproject
project detection logic for various axo.dev applications
-
pathfinder_geometry
Basic SIMD-accelerated geometry/linear algebra
-
nextsv
Next semantic version calculator
-
rusty_neat
Pretty good NEAT implementation
-
survival
A high-performance survival analysis library written in Rust with Python bindings
-
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…
-
calc_rational
CLI calculator for rational numbers
-
g_math
Multi-domain fixed-point arithmetic library with 18 transcendental functions
-
celestial-coords
Astronomical coordinate transformations
-
ndarray-interp
Interpolation package for ndarray
-
symb_anafis
Fast symbolic differentiation library for Rust
-
nyse-holiday-cal
NYSE holiday calendar library
-
echidna
A high-performance automatic differentiation library for Rust
-
splines
Spline interpolation made easy
-
graphblas_sparse_linear_algebra
Wrapper for SuiteSparse:GraphBLAS
-
unit-prefix
Format numbers with metric and binary unit prefixes
-
algebraeon-nzq
natural numbers, integers and rationals for algebraeon
-
ploot
A terminal plotting library
-
balanced-ternary
manipulate balanced ternary values
-
hyperdual
Fully-featured Dual Number implementation with features for automatic differentiation of multivariate vectorial functions
-
tiny-solver
Factor graph solver
-
rssn
A comprehensive scientific computing library for Rust, aiming for feature parity with NumPy and SymPy
-
kalker
A calculator that supports user-defined functions, variables and units, and can handle fairly ambiguous syntax
-
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…
-
ryft-mlir
Ryft bindings for MLIR
-
ibig
A big integer library with good performance
-
bevy_autodiff
Automatic differentiation using Bevy ECS as computation graph
-
bva
manipulating and doing arithmetics on bit vectors of fixed but arbitrary size
-
mate-rs
lightweight arithmetic expression interpreter
-
pumpkin-solver
The Pumpkin combinatorial optimisation solver library
-
tracktor
Multi-target tracking with random finite sets
-
boolean_function
Mathematical analysis of Boolean functions
-
affn
Affine geometry primitives: strongly-typed coordinate systems, reference frames, and centers for scientific computing
-
directx_math
translation of DirectXMath, a SIMD linear algebra library for use in games and graphics apps
-
axb
A lightweight, zero-dependency linear algebra library with compile-time dimension checking
-
nm
Minimalistic high-performance metrics collection in highly concurrent environments
-
owens-t
Owen's T Function and Bivariate Normal CDF computations
-
math-bem
High-performance Boundary Element Method library for acoustic scattering
-
jlrs
bindings to the Julia C API that enable Julia code to be called from Rust and more
-
anofox-forecast
Time series forecasting library - Rust port of anofox-time
-
tukey_test
Statistical post-hoc tests: Tukey HSD, Games-Howell, Dunnett, one-way ANOVA, and studentized range critical values — pure Rust, zero required dependencies
-
mappers
Pure Rust geographical projections library
-
oxidiviner
A comprehensive Rust library for time series analysis and forecasting including moving average, exponential smoothing, autoregressive, and GARCH models
-
mosek
Rust API for MOSEK optimization tools
-
ndarrow
Zero-copy bridge between Apache Arrow and ndarray
-
arrow-arith
Arrow arithmetic kernels
-
optimizer
Bayesian and population-based optimization library with an Optuna-like API for hyperparameter tuning and black-box optimization
-
kryst
Krylov subspace and preconditioned iterative solvers for dense and sparse linear systems, with shared and distributed memory parallelism
-
num-bigfloat
Increased precision floating point numbers implemented purely in Rust
-
tetra3
Fast and robust star plate solver
-
mzsignal
mass spectrometry signal processing
-
splr
A modern CDCL SAT solver in Rust
-
grb
API for Gurobi optimizer
-
nacfahi
Simpler, but less error-prone API for
levenberg-marquardtoptimization crate -
qsv-stats
Computing summary statistics on streams
-
lawkit
Statistical law analysis CLI toolkit with international number support
-
gpu-fft
performing Fast Fourier Transform (FFT) and Inverse FFT using GPU acceleration
-
nabled
A linear algebra library written in Rust with an ndarray-first architecture
-
yata
Technical Analysis library. For rust now.
-
physics_in_parallel
High-performance infrastructure for numerical simulations in physics
-
mosox
LP matrix generator for GMPL
-
zeromq-src
Source code and logic to build ZeroMQ from source
-
quantedge-ta
A streaming technical analysis library for Rust
-
mech-math
Math library for the Mech language
-
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
-
constraint-solver
A small, generic nonlinear constraint solver with symbolic expressions, compilation, and a modified Newton-Raphson method
-
suma_core
A core library for suma_ulsa, used for academics methods and data processing
-
unleash-yggdrasil
Unleash SDK domain logic extracted into a library to facilitate building your own Unleash SDKs in anything, anywhere
-
rpn-cli
Command line reverse Polish notation calculator
-
fingerprints
Property estimation from samples: fingerprints, entropy/support estimators, and (future) support reconstruction
-
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
-
dproc
A basic CLI data processor, designed to be fed data and output data directly from the commandline
-
intrval
Generic intervals (ranges) library
-
algexenotation
in Rust
-
skillet
micro expression language (arithmetic, logical, functions, arrays, conditionals, excel formulas) made in Rust bin cli and server
-
decimal-rs
High precision decimal implementation for Rust
-
matrix-sdk-qrcode
encode and decode QR codes for interactive verifications in Matrix land
-
centerline
finding centerlines of 2D closed geometry
-
jingle
SMT Modeling for Ghidra's PCODE
-
gf2
Working in bit-space a.k.a. GF(2)
-
ruvector-verified
Formal verification layer for RuVector: proof-carrying vector operations with sub-microsecond overhead using lean-agentic dependent types
-
s2
S2 geometric library
-
la-stack
Fast, stack-allocated linear algebra for fixed dimensions
-
thermalcomfort
port of pythermalcomfort for thermal comfort calculations (no_std, WASM-compatible)
-
naivesat
Few solvers that uses the Gate project
-
w3f-pcs
Collection of tools for augmenting polynomial commitment schemes
-
unit-sphere
performing geometric calculations on the surface of a sphere
-
polyglot_interpreter
A cross-platform, cross-language interpreter of simple logical expressions
-
lair
Linear algebra in Rust
-
protocheck
✅ Validate protobuf messages using protobuf annotations
-
interatomic
calculating inter-particle interactions
-
mdarray
Multidimensional array for Rust
-
rawarray
file format for retrievably storing n-dimensional arrays
-
matio-rs
Rust wrapper to MATLAB MAT file I/O library
-
flaw
Embedded signal filtering, no-std and no-alloc compatible
-
rational
Minimalistic library for rational numbers
-
n_circular_array
An n-dimensional circular array
-
scirs2-interpolate
Interpolation module for SciRS2 (scirs2-interpolate)
-
glamour
Strongly typed linear algebra with glam
-
startin
A Delaunay triangulator for terrains
-
graphembed
graph embedding
-
runmat
High-performance MATLAB/Octave runtime with Jupyter kernel support
-
polyfit
Because you don't need to be able to build a powerdrill to use one safely
-
taceo-poseidon2
Poseidon2 permutation for BN254 curve
-
temp-converter
terminal temperature unit converter between Celsius, Fahrenheit and Kelvin
-
scilib
A scientific library for the Rust programming language
-
anathema-geometry
Geometry, positions and sizes for Anathema
-
imagnum
providing versatile numeric types supporting integers and floats designed for the Lucia programming language
-
dartunifrac
Ultra-fast approximate UniFrac via Weighted MinHash
-
numr
High-performance numerical computing with multi-backend GPU acceleration (CPU/CUDA/WebGPU)
-
zelen
Direct MiniZinc to Selen Solver
-
math-fem
Multigrid FEM solver for the Helmholtz equation
-
trit-vsa
Balanced ternary arithmetic library with bitsliced storage and VSA operations
-
metis
Idiomatic wrapper for METIS, the serial graph partitioner and fill-reducing matrix orderer
-
fib-rug
Basic fibonacci numbers calculator using the rug crate
-
oxiblas-lapack
LAPACK operations for OxiBLAS - pure Rust implementation
-
pi_num_cmp
size int bigint float num cmp
-
mantaray
Ray-tracing solver for ocean surface gravity waves that integrates the wave ray equations over spatially varying currents and bathymetry
-
strange-attractors
Study into strange attractor visualization in a TUI
-
serde-ndim
Serde support for n-dimensional arrays from self-describing formats
-
stft-rs
streaming-friendly, no_std compliant STFT implementation with mel spectrogram support
-
ark-feanor
Bridge between arkworks finite fields and feanor-math ring system
-
extended_matrix
A matrix calculation module
-
blas-src
The package provides a BLAS source of choice
-
apex-solver
High-performance nonlinear least squares optimization with Lie group support for SLAM and bundle adjustment
-
lina
Linear algebra library with a focus on 3D applications like games (i.e. low-dimensional vectors and matrices)
-
fib-rs
A highly optimized Fibonacci number calculator for Rust that efficiently computes arbitrarily large Fibonacci numbers
-
erydanos
Optimized routines for ARM NEON and SSE
-
aga8
GERG2008 equations of state
-
quadprec
Software-emulated quad precision (f128) via double-double arithmetic — Cholesky, dot, gemv for ill-conditioned linear algebra
-
formulac
A complex-number and extensible function supported math expression parser for Rust
-
smallest-enclosing-circle
Iterative two-dimensional implementations of Welzl's algorithm for computing the smallest enclosing circle
-
frinZ
fringe search for Yamaguchi Interferometer and Japanese VLBI Network
-
slop-jagged
Jagged sparse-to-dense polynomial adapter for SLOP
-
diffusionx
A multi-threaded crate for random number generation and stochastic process simulation, with optional GPU acceleration
-
geo-aid
designed to generate geometrical figures based on given rules
-
transfinite
ordinal arithmetic library supporting ordinals up to epsilon-zero (ε₀) using Cantor Normal Form
-
matematika-rs
matematika sederhana untuk orang malas seperti saya
-
graphics-shapes
Shapes for graphics
-
laddu
Amplitude analysis made short and sweet
-
russell_ode
Solvers for ordinary differential equations and differential algebraic equations
-
p3-miden-lifted-fri
Lifted FRI PCS (DEEP quotient + FRI)
-
trig-const
Const trig functions in Rust
-
uzor-backend-vello-common
Shared utilities for vello-based backends
-
bare_metal_modulo
ModNum is a highly ergonomic modular arithmetic struct intended for no_std use
-
assay-policy
Policy types and compilation logic for Assay
-
camera-intrinsic-model
Camera Intrinsic Models
-
hooo
Propositional logic with exponentials
-
microcad-syntax
µcad: A CAD system for the 21st century
-
pointy
Minimal 2D geometry library
-
ndhistogram
multi-dimensional histogramming for Rust
-
rslife
A comprehensive Rust library for actuarial mortality table calculations and life insurance mathematics
-
ndarray_cg
High-performance computer graphics mathematics library based on ndarray with vectors, matrices, and transformations
-
mscore
providing core operations for computational mass spectrometry proteomics
-
amari-relativistic
Relativistic physics using geometric algebra for charged particle simulations
-
csrk
Sparse Gaussian Process regression with compactly supported radial kernels
-
mini-calc
A Fully-Featured Configurable (mini) Rust Calculator
-
fdars-core
Functional Data Analysis algorithms in Rust
-
sanos
Smooth strictly Arbitrage-free Non-parametric Option Surfaces (Rust implementation)
-
sc_neurocore_engine
High-performance SIMD backend for SC-NeuroCore stochastic neuromorphic computing
-
rkf78
Runge-Kutta-Fehlberg 7(8) integrator for spacecraft trajectory propagation
-
finmoney
A precise, panic-free money library for Rust with currency-aware values, configurable rounding, and exchange-grade tick handling
-
ramer_douglas_peucker
Ramer Douglas Peucker algorithm
-
spirix
Two's complement floating-point arithmetic library
-
polynomial-ring
A polynomial implementation
-
set_theory
A comprehensive mathematical set theory library implementing standard set operations, multisets, and set laws verification
-
luacad-studio
A 3D CAD studio with Lua scripting and live preview
-
bacon-sci
Scientific computing in Rust
-
wagyu-rs
Geometry boolean operations (union, intersection, difference, xor) - Rust port of Mapbox wagyu
-
russell_tensor
Tensor analysis, calculus, and functions for continuum mechanics
-
clawgic
Logic engine for making, modifying, and evaluating expressions from sentential (propositional) logic. Support for predicate logic will be added later.
-
integrator
A math library
-
rooc
A mixed integer linear programming modeling language to solve linear optimization models. Extensible, works in WASM and easy to use.
-
subsphere
Sphere tessellation toolkit
-
powerlaw
command-line tool for analyzing power-law distributions in empirical data
-
fasteval2
Fast evaluation of algebraic expressions
-
quadraturerules
quadrature rules library
-
mats
A lightweight, efficient, and easy-to-use Rust matrix library
-
vampire-prover
Safe Rust bindings to the Vampire theorem prover for first-order logic
-
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.
-
bellpepper
Gadgets for a SNARK Circuit library
-
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
-
flexfloat
arbitrary floating-point types with infinite exponent
-
dda-rs
Rust interface for the run_DDA_AsciiEdf binary (Cosmopolitan Libc APE) for Delay Differential Analysis
-
sounding-analysis
Types and functions for working with weather soundings
-
pupil
Arithmetic expression evaluator
-
flowmatch
Flow matching primitives (ndarray-first; backend-agnostic) with semidiscrete FM and RFM experiments
-
al-jabr
An n-dimensional linear algebra library
-
lav
Lane-Associated Vector (LAV): Portable SIMD vector trait as GAT of SIMD lane trait
-
tang
Math library for physical reality — geometry, spatial algebra, tensor, training, GPU compute, and 3D gaussian splatting
-
atlas-embeddings
First-principles construction of exceptional Lie groups from the Atlas of Resonance Classes
-
conspire
interface to conspire
-
mingot
Leptos UI library for applications demanding mathematical precision - u64+ integers, arbitrary-precision decimals, zero precision loss
-
numbat-cli
A statically typed programming language for scientific computations with first class support for physical dimensions and units
-
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.
-
calc
CLI calculator app
-
nauty-pet
Canonical graph labelling using nauty/Traces and petgraph
-
wifi-densepose-ruvector
RuVector v2.0.4 integration layer — ADR-017 signal processing and MAT ruvector integrations
-
lie-groups
Lie groups and Lie algebras for computational mathematics
-
simd_vector
SIMD vector types (Vec4, Vec8) for x86-64 in pure stable Rust — SSE4.1, AVX2, FMA3
-
sp1-gpu-jagged-assist
GPU helper kernels for jagged polynomial operations
-
fastatomstruct
A Python package for the analysis of atomic structures and dynamics
-
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
-
int_ratio
The type of ratios represented by two integers
-
fpdec
Decimal floating-point arithmetic
-
nc-polynomial
Polynomial arithmetic over Z_q[x] with NTT support and validated ring contexts
-
differential-equations
solving differential equations
-
grid1d
A mathematically rigorous, type-safe Rust library for 1D grid operations and interval partitions, supporting both native and arbitrary-precision numerics
-
voroxx
Voro++, a 3D cell-based Voronoi library
-
numina
Backend-agnostic array library for high-performance computing in Rust
-
crackers
synthesizing Code Reuse Attacks (ROP chains) using Ghidra's p-code and Z3
-
number-general
A generic number type for Rust which supports basic math and (de)serialization
-
market_synth_nh1948
Content marketing synthesis engine combining math principles, ABAP architecture, and Rust new complementarity principle
-
organicomplex
Interactive complex-valued cellular automaton on 2D and 3D grids in search of that stuff - emergence, open-endedness, organicity etc
-
ommx
Open Mathematical prograMming eXchange (OMMX)
-
pcb-toolkit
PCB design calculator library — impedance, current capacity, via properties, and more
-
ecolor
Color structs and color conversion utilities
-
p3-miden-lmcs
Lifted Matrix Commitment Scheme (LMCS) for matrices with power-of-two heights
-
automesh
Automatic mesh generation
-
glam_matrix_extras
Matrix types and utilities for Glam
-
baa
BitVector and Array Arithmetic
-
factorion-bot-reddit
factorion-bot (for factorials and related) on Reddit
-
single_algebra
A linear algebra convenience library for the single-rust library. Can be used externally as well.
-
cova
First principles, minimally dependent, geometric and topologically focused math library
-
semdiff-differ-audio
Audio diff calculator and reporters for semdiff
-
taguchi
State-of-the-art orthogonal array (Taguchi) library for experimental design
-
snap-coin-pay
way to handle deposits and withdrawals on the Snap Coin Network
-
mathcore_nostd
Symbolic math library and computer algebra system for Rust. Forked to work in no_std environments.
-
ldpc-toolbox
aid in LDPC code design
-
d3_delaunay_rs
A port of D3/d3-delauany
-
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
-
thermal_hydraulics_rs
A Thermal Hydraulics Library with some useful traits,enums and functions for heat transfer and fluid mechanics
-
alum
Halfedge based polygon mesh library
-
ezpz
A constraint solver for KCL and Zoo Design Studio
-
missile_guidance
Rust port of 'Tactical and Strategic Missile Guidance, 7th ed' MATLAB code
-
faer-traits
linear algebra library
-
ilog
Base 10 and 2 logarithm functions for integer types
-
pictex
CLI utility for converting LaTeX math expressions to PNG format
-
quarks-zk
Quarks: Quadruple-efficient transparent zkSNARKs - Implementation of Kopis-PC, Dory-PC, and Lakonia/Kopis/Xiphos SNARKs
-
clifford
Geometric Algebra (Clifford Algebra) for Rust: rotors, motors, PGA for 3D rotations and rigid transforms
-
geo-cal
A cli tool to calcuate analytical geometry questions, like distances, circle, parabola and more with guided steps
-
nndex
In-memory nearest neighbor search engine
-
rita
2D and 3D Randomized Incremental Triangulation Algorithms
-
stlrs
Seasonal-trend decomposition for Rust
-
specialized-div-rem
specialized division algorithms for integer primitives
-
twine-models
Domain-specific models and model-building tools for Twine
-
rao
Robust and scalable Adaptive Optics tools
-
logicaffeine-language
Natural language to first-order logic pipeline
-
num-integer
Integer traits and functions
-
mwa_hyperdrive
Calibration software for the Murchison Widefield Array (MWA) radio telescope
-
libnoise
performant, and customizable procedural noise generation library
-
big_num_math
computations on large numbers
-
taz
evaluate a mathematical expression
-
joker_calculus
Joker Calculus in Rust
-
math-differential-evolution
Non linear optimisation library with own DE solvers and interface to NLOpt and MetaHeuristics
-
minuit2
Pure Rust port of CERN Minuit2 parameter optimization engine
-
panic-attacker
Universal stress testing and logic-based bug signature detection
-
decaf377
A prime-order group designed for use in SNARKs over BLS12-377
-
curve-sampling
Adaptive sampling of parametric
-
pumpkin-checker
A proof-checker for DRCP proofs generated for FlatZinc models
-
ppsd-rs
Seismic PPSD (Probabilistic Power Spectral Density) computation matching ObsPy output
-
trussx
designing and analyzing truss structures
-
fermat
A collection of math algorithms
-
semicontinuous_models
Reusable models for semi-continuous outcomes (two-part, Tweedie, and log-normal)
-
num-t
Num<T>: Associate arbitrary types with numeric types
-
strict-num
A collection of bounded numeric types
-
u-analytics
Statistical process control, process capability analysis, Weibull reliability, and change-point detection
-
bitcalc
A calculator with bit operations
-
plane-split
Plane splitting
-
miden-core-lib
Miden VM core library
-
turbodiff
Rust-powered DeepDiff core
-
noiz
configurable, blazingly fast noise library built for and with Bevy
-
sparsers
sparerse-rs: sparse matrix computation written in rust
-
rlst
native linear algebra library
-
ratio-matrix
Ratio's matrix data library
-
theon
Abstraction of Euclidean spaces
-
integrate
Small, lightweight Rust library for performing numerical integration
-
seuif97
The high-speed IAPWS-IF97 package with C and Python binding
-
lazyivy
Lazy Runge-Kutta integration for initial value problems
-
fey_math
Vectors, matrices, directions, and geometry
-
xsf
Rust implementations and bindings for scipy.special functions
-
bitnet-quantize
Microsoft BitNet b1.58 quantization and inference for Rust
-
xdl-matlab
Extended Data Language (XDL) - Rust implementation
-
piecewise_polynomial
Fitting and interpolation with piecewise polynomials
-
convex-math
Mathematical utilities for the Convex fixed income analytics library
-
spherical_geometry
A package for working with spherical geometry
-
numix
A fast, lightweight Rust library for math operations and numeric computations
-
bc
Use
bcin the Rust Programming Language -
pso-poseidon
Poseidon hash implementation compatible with Circom
-
globalsearch
A multistart framework for global optimization with scatter search and local NLP solvers written in Rust
-
gmac_rs
Blazingly fast geometry manipulation and creation library
-
moontool
John Walker's moontool.c astronomical calculation routines, extracted and ported to Rust
-
pymagba_binding
Rust-to-Python binding for PyMagba
-
dsfb-add
Deterministic Algebraic Deterministic Dynamics (ADD) parameter sweeps for AET, TCP, RLT, and IWLT
-
fixed_analytics
Fixed-point mathematical functions using the CORDIC algorithm
-
prime_factorization
Prime factorization up to 128 bit integers
-
minmath
A lightweight math library
-
ranch
Ranged integer types and math
-
ancdec
Fast, precise anchored decimal with independent integer/fraction fields (u64: 19+19, u128: 38+38 digits)
-
cgt
Combinatorial Game Theory framework
-
geom3
3d geometry classes
-
bevy_autodiff_fit
Piecewise Chebyshev polynomial fitting for bevy_autodiff
-
argentum_user_business
Business layer of user component
-
vector-space
Generic vector space trait for compatibility across various libraries
-
numquad
Numerical integration quadratures like Gauss-Legendre and Tanh-Sinh
-
threecrate
A comprehensive 3D point cloud processing library for Rust - umbrella crate
-
numby
A powerful natural language calculator with a terminal user interface
-
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…
-
star-catalog
A star catalog library and tool with loadable catalogs that are searchable by geometry
-
fj
Early-stage b-rep CAD kernel
-
parry3d-f64
3 dimensional collision detection library in Rust. 64-bits precision version.
-
qudit-tensor
Accelerated and Extensible Quantum Library
-
eqsolver
that solves equations using numerical methods
-
geometry-rs
geometry utils
-
qnect
⚛ Quantum computing in Rust: from Bell pairs to distributed quantum networks
-
cblas-inject
CBLAS compatible interface backed by runtime-registered Fortran BLAS function pointers
-
ratio-graph
Ratio's graph manipulation library
-
flint3-sys
Rust bindings to the FLINT C library
-
xraydb
X-ray reference data for the elements
-
typed-money
A type-safe money library for Rust that prevents currency mixing bugs at compile time
-
stroke
Zero-allocation, const-generic implementations of Bézier and B-Spline curves in N-dimensional euclidean space
-
damped-springs
damped springs for smooth and springy motion
-
anthem
A command-line application for assisting in the verification of answer set programs
-
aspirina
A modular neural network library with matrix operations and backpropagation
-
fastmaths
High-performance no_std math routines targeting glibc parity and strict f64 accuracy
-
gspx
Sparse graph signal processing and spectral graph wavelets in Rust
-
longitude
Work with real world coordinates in Rust!
-
deep_causality_topology
Topological data structures for the DeepCausality project
-
malachite-base
A collection of utilities, including new arithmetic traits and iterators that generate all values of a type
-
vee
Vector Expression Emitter (VEE): Geometric Algebra Code Generator
-
xyzvec
Statically allocated fixed-size vectors for working in 2 and 3 dimensions
-
intel-mkl-src
Redistribution of Intel(R) MKL as a crate
-
circle-of-confusion
Calculator for Circle of Confusion (CoC) to calculate the size in pixels of an area, used for depth of field processing
-
algebraeon
computational algebra library re-exports for all components
-
easy_lambda_calculus
easy to write lambda calculus
-
tcalc-cli
A CLI for time arithmetic
-
bsd4random
4.1BSD libc random number generator
-
floccus
Formulae for air thermodynamic calculations
-
incerto
Monte carlo simulations
-
tatam
Theory And Time Analysis Machine
-
anoma-rm-risc0
Anoma Resource Machine Implementation using RISC0 zkVM
-
qfall-tools
Common sub-modules and procedures in lattice-based constructions
-
metallic
C math functions from scratch
-
mrubyedge-math
mruby-math provides Math module for mruby/edge
-
bestagon
An engine for discrete stuff in hexagonal grids
-
taco-threshold-automaton
defining basic types for threshold automata and all of its building blocks. This crate is part of the TACO toolsuite.
-
bool-logic
manipulating and evaluating boolean expressions
-
javelin-tui
Display and work with Lance matrices
-
floating-ui-core
Rust port of Floating UI. Positioning library for floating elements: tooltips, popovers, dropdowns, and more.
-
monolithium
Finding the Largest Minecraft Alpha Monoliths
-
ecgen-rs
Enumerative Combinatoric Generation in Rust
-
tampines-steam-tables
Steam Tables for the TAMPINES Library
-
zunei
A mathematical high performant- screen capture. written in rust
-
kasane-logic
This is Kasane-logic
-
linear_isomorphic
A set of traits to astract over linear-like types
-
skel
Topology/shape primitives
-
bezier-rs
Computational geometry algorithms for Bézier segments and shapes useful in the context of 2D graphics
-
find_peaks
Find peaks that match criteria in 1D data
-
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…
-
sundials
Suite of nonlinear and differential/algebraic equation solvers
-
roberts-sequence
The Roberts quasirandom sequence
-
libceed
High-level interface for libCEED - the efficient high-order discretization library developed by the ECP co-design center CEED
-
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.
-
tritet
Triangle and tetrahedron mesh generators
-
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.
-
conversions_rs
A comprehensive unit conversion library, CLI tool, and WebAssembly module with full SI (International System of Units) support
-
statify
A lightweight and minimal statistics library for Rust
-
bola
A lightweight native rust linear algebra library
-
hexing
A basic Rust library to manipulate hexagonal grids
-
p-chan
Multimedia (Audio, Raster) Channel Newtypes and Conversions
-
single_rust
Single-cell analysis in Rust
-
monstertruck
CAD kernel – B-rep modeling, NURBS, meshing, and GPU rendering
-
xprec
Fast emulated quadruple (double-double) precision arithmetic
-
ndimpoint
working with N-dimensional points in Rust
-
ziffle
Mental poker library implementing Bayer-Groth 2012 shuffle proofs for multi-party card shuffling without a trusted dealer
-
kll-rs
KLL quantiles sketch from Apache DataSketches for Rust
-
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.
-
anofox-statistics
A comprehensive statistical hypothesis testing library validated against R
-
lme-rs
Rust port of R's lme4: linear mixed-effects models with 1:1 numerical compatibility
-
remesh
Isotropic remeshing library
-
thales
A comprehensive Computer Algebra System (CAS) library for symbolic mathematics, equation solving, calculus, and linear algebra
-
harper-stats
The language checker for developers
-
pol
An interactive Reverse Polish Notation (RPN) calculator
-
noether
Abstract algebraic structures for Rust
-
sari
arithmetic expression evaluator
-
gmp-mpfr-sys
Rust FFI bindings for GMP, MPFR and MPC
-
honest
High-assurance Operations for Number-theoretic Extension Sets and Theorems (Galois Fields)
-
legasea_line
Tools for working with lines
-
barnes_hut
Fast n-body simluation using the Barnes Hut algorithm
-
tekhsi_rs
High-performance client for Tektronix TekHSI enabled oscilloscopes
-
num-lazy
Number macros for generic-typed functions
-
rounded-div
Get rounded result of an integer division
-
iltcme
Inverse Laplace transform with concentrated matrix-exponential functions
-
area_crate
A comprehensive geometry calculation library for areas, perimeters, surface areas, and volumes
-
fixed-macro
Macros for creating fixed-point constants for types in the
fixedcrate -
geomorph
conversion between different coordinate systems
-
aprilgrid
Aprilgrid
-
tabulator
Grid-oriented tabulation with justification and anchors
-
envisim_samplr
Sampling methods for balanced and spatially balanced sampling
-
voronota
Voronota-LT is an alternative version of Voronota for constructing tessellation-derived atomic contact areas and volumes
-
ha-ndarray
A hardware-accelerated n-dimensional array
-
softposit
Posit numbers
-
autodj
Automatic Differentiation Library
-
symbolic-mgu
Symbolic logic unification using Most General Unifiers (MGU). Implements Meredith's condensed detachment for exploring automated proof discovery.
-
vectra
A multi-dimensional array library for Rust, similar to NumPy
-
computable
real numbers with guaranteed correctness via interval refinement
-
iterative-solvers
Iterative algorithms for solving linear systems
-
polysub
fast substitution of variables in polynomials
-
amari-dual
Dual number automatic differentiation
-
re_int_histogram
A histogram with
i64keys andu32counts, supporting both sparse and dense uses -
fasteval3
Fast evaluation of algebraic expressions
-
cnfgen2
Generate DIMACS CNF formula from operations (second version)
-
oak-folding
Code folding logic and AST-based region detection for the Oak framework
-
cellbook
Dynamic computational notebook environment in plain Rust
-
fixed_trigonometry
Fixed point numerical approimations to trigonometric functions
-
d4-oxide
wrapper around d4
-
uv-pep508
internal component crate of uv
-
nanogpt
Nanochat in Rust
-
rstmt
A complete framework for computational music theory and composition based on topological and categorical methods
-
lapack-src
The package provides a LAPACK source of choice
-
cmn
accessing a collection of mathematical and cryptographic constants
-
powersasa
SASA and molecular volume computation using Power diagrams
-
simplify-polyline
Simplify polylines using Douglas-Peucker and radial distance algorithms. Port of the simplify-js library.
-
cga2d
2D Conformal Geometric Algebra primitives
-
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
-
mobius-applicatio
A lean library for Möbius transformations on the complex plane
-
tensorlogic-infer
Execution and autodiff traits for TensorLogic inference engines
-
content_oracle
Content marketing oracle with entropy, prophecies and Bourbaki mathematics. Analyzes metrics, predicts the future, and sacrifices failed campaigns.
-
ekzg-polynomial
methods that are needed for Polynomial objects
-
lower
desugar math where the compiler wont
-
zakat
A type-safe, comprehensive, and Fiqh-compliant Zakat calculation library. Supports Gold, Silver, Business, Agriculture, Livestock, Professional Income, and Modern Assets (Crypto/Stocks).
-
sgp
Simplified General Perturbations models (SGP8/SGP4) in Rust
-
vsepr-rs
A lightweight, high-performance molecular geometry optimizer based on VSEPR theory
-
pihex
Arbitrary place hexadecimal digits viewer of pi written in Rust
-
lk_math
Collection of reusable mathematical tools
-
causal-hub
causal models, inference and discovery
-
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
-
klippa
Geometry clipper using rectangular window
-
nalgebra_block_triangularization
Structural decomposition of sparse matrices into block triangular form using graph algorithms
-
oxidd-cli
Command line interface for OxiDD
-
numint
ODE solvers and numerical integration in Rust
-
decimus
Decimal Floating-Point Math Library for Rust
-
lcdm-lss
Large Scale Structure (LSS) growth and power spectrum for ΛCDM
-
interactors
Command pattern implementation for Rust
-
ferray
A NumPy-equivalent library for Rust — N-dimensional arrays with SIMD acceleration
-
lin_algebra
A linear algebra package to compute image, kernel and rank of linear applications
-
zima
An attempt to create a modern package for the needs of applied statistics
-
csc
Command Line Scientific Calculator
-
sparse-ir
SparseIR functionality
-
dashu
set of big numbers
-
foocalc
A command line RPN calculator with multiple precision and unit support
-
numaxiom
Lightweight numeric marker traits for ranges/signs plus constants and ops; std by default, no_std optional
-
symbit
Symbolic bitvector library with bitwise and integer arithmetic support
-
hyperprec
f128, f256, f512 in Rust — software-emulated extended precision via double-double and multi-limb arithmetic for ill-conditioned linear algebra
-
nereids-physics
Cross-section calculation, broadening, and transmission forward model
-
hexgridspiral
Hexagonal Cube-Coordinate System with Spiralling Integer Tile Identifiers
-
rink
Unit conversion tool, similar to frink
-
mutils
Mathematical-like utilities. Points, Sizes, Colours, maths operating on them. Things like that.
-
symbolic_regression
Rust port of SymbolicRegression.jl
-
crustabri_ipafair
An IPAFAIR compatible library built upon the Scalop solver
-
rong_jscore
JavaScriptCore backend for RongJS
-
approx_det
Approximate floating point equality comparisons and assertions
-
microgemm
General matrix multiplication with custom configuration in Rust. Supports no_std and no_alloc environments
-
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
-
rosu_nps
analyzing note density and distribution in osu! beatmaps
-
vecfit
Pure-Rust relaxed vector fitting for scalar, vector, matrix, and tensor-valued frequency responses
-
rgb-strict-types
Strict types: confined generalized algebraic data types (GADT)
-
moma
Moving Origin Modular Arithmetic (MOMA), a library for modeling complex systems
-
vector3
dealing with 3D mathematical vectors
-
absolute_unit
A unit system for Rust's type system to catch unit errors in your physical calculations
-
fixed-bigint
Fixed-size big integer implementation for Rust
-
frunk_laws
contains laws for algebras declared in Frunk
-
fidget_math
glam vector types for tree construction with fidget
-
bounded-counter
Generic Incremental Bounded Counter
-
octad
puzzle generator and solver
-
floatguard
checked floating-point arithmetic in Rust, safely elminating NaN and Infinity from floating-point computations
-
pid-lite
A small PID controller library
-
elicitation_kani
Kani model-checking proofs for elicitation contract types
-
cubes
Applications for determining how to put a cube together
-
scirs2-special
Special functions module for SciRS2 (scirs2-special)
-
spokes
A network and network flow library
-
simple_vector2
libary for generic vector manipulation that just works
-
bpa_rs
Ball Pivot Algorithm (BPA) for 3D point cloud data
-
infomeasure
Information theory measures and entropy calculations for Rust
-
malachite-q
The arbitrary-precision type Rational, with efficient algorithms partially derived from GMP and FLINT
-
opengm_rts
GM/T 0005-2021 randomness test suits written in Rust
-
dynamic_expressions
Fast batched evaluation + forward-mode derivatives for symbolic expressions (Rust port of DynamicExpressions.jl)
-
intervalx
A strongly-typed generic interval algebra library for Rust
-
generic-interval
A generic closed interval library
-
cali
A terminal calculator with real-time evaluation, unit conversions, and natural language expressions
-
num-order
Numerically consistent
Eq,OrdandHashimplementations for variousnumtypes (u32,f64,num_bigint::BigInt, etc.) -
simular
Unified Simulation Engine for the Sovereign AI Stack
-
uncertain-rs
uncertainty-aware programming, implementing the approach from 'Uncertain<T>: A First-Order Type for Uncertain Data'
-
pell-equation
solve Pell's equation
-
oxiblas-ndarray
ndarray integration for OxiBLAS
-
rcomb
Combinatorial objects, traits, collections
-
binar
High-performance binary arithmetic
-
snaphu-rs
SNAPHU C library
-
deep_causality_multivector
Multivector and MultiField implementation for DeepCausality
-
howzat-kit
Backend spec parsing and high-performance runner API for howzat
-
amd
Approximate Minimum Degree ordering
-
spargebra
SPARQL parser
-
vema
Vector and Matrix types and associated operations
-
eva
Calculator REPL similar to bc(1)
-
bls12_381-bls
BLS signatures using the BLS12-381 curve
-
gategen
generate Gate circuits
-
ruqu-quantum-monitor
Anytime-Valid Quantum Kernel Coherence Monitor (AV-QKCM) - Sequential MMD testing with e-values for quantum syndrome distribution drift detection
-
cord-path
2 dimensional coordinate based path finder
-
celestial-core
Core types and utilities for the Celestial astronomy library
-
string_calculator
A string calculator to compute formulas inside strings
-
amari-fusion
Fusion system for combining algebraic structures
-
epics-calc-rs
EPICS calc expression engine in Rust — thin wrapper over epics-base-rs
-
petal-decomposition
Matrix decomposition algorithms including PCA (principal component analysis) and ICA (independent component analysis)
-
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…
-
logician
Type-safe SMT solver driver with fluent Term API, multi-solver fallback, and process watchdog
-
algebraeon-groups
Algorithms in group theory
-
libdivide
Port of libdivide
-
rug_calc
A Rug-powered scientific computing engine featuring high-performance, arbitrary-precision numerical evaluation
-
faer-entity
Basic linear algebra routines
-
matrixable
Traits and structs extending capabilities of matrix-like structures
-
coin_cbc
Rust bindings to the CoinOR CBC MILP Solveur using the C API
-
zfc
Trait that represents a set according to Zermelo–Fraenkel set theory with the axiom of choice (ZFC)
-
twibint
arithmetic on arbitrarily large integers. Provides Python bindings as well.
-
awint_ext
Externally allocating
awintfunctionality -
tui-math
Render LaTeX math beautifully in terminal UIs with ratatui
-
bones-triage
Prioritization and scoring engine for bones (PageRank, urgency, dependency-aware)
-
figures
A math library specialized for 2d screen graphics
-
aspect360
This builds on the Ring360 to calculate aspect matches from target angles with orbs or an array of target aspect/orb pairs
-
gananayantra-rusting
A professional-grade, multi-industry calculation library for Rust (Finance, Health, Energy, Geo, Space, Physics, Climate, Logistics)
-
meshless_voronoi
Meshless Voronoi algorithm
-
rusticle
High-performance Rust library for numerical computing
-
geodesic_destination
Compute the destination point for a bearing and distance on a spherical Earth
-
lococode
Location codes inspired by Google's Plus Codes (Open Location Code)
-
projgeom-rs
Projective Geometry in Rust
-
decaf377_plus
A prime-order group designed for use in SNARKs over BLS12-377
-
incr_stats
Fast, scalable, incremental descriptive statistics in Rust
-
rust-rocket
A client implementation of GNU Rocket
-
dynast
Feynman graph topology identification
-
nauty-Traces-sys
Low-level bindings for nauty and Traces
-
fhe-math
Mathematical utilities for the fhe.rs library
-
reckoner
A high level arbitrary precision arithmetic library supporting integer and rational numbers
-
scirs2-integrate
Numerical integration module for SciRS2 (scirs2-integrate)
-
honeycomb-kernels
Meshing kernel implementations using combinatorial maps
-
folo_ffi
working with FFI logic; exists for internal use in Folo packages; no stable API surface
-
compute
statistical computing
-
rubiks-cube-representation
A mathematical library for representing and analyzing Rubik's cubes using group theory and tile permutations
-
sprs-superlu
The package provides a high level interface between SuperLU, sprs and ndarray
-
practicestuff
CLI trainer for improving calculation and memorisation skills
-
malachite-bigint
A drop-in num-bigint replacement based on malachite
-
lox-core
Common data types and utilities for the Lox ecosystem
-
mappers_warp
Very simplistic tool for reprojecting maps, based on GdalWarp
-
strmath
Do math with your strings
-
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
-
katex-gdef-v8
fast use of KaTeX via V8 engine
-
soilrust
A geotechnical engineering library for soil mechanics calculations in Rust
-
crypto-ratio
Rational number arithmetic using crypto-bigint
-
fix-rat
A rational number type with fixed denominator
-
errorfunctions
Pure Rust package to compute the error function, Dawson's function, and Faddeeva's function for real and complex arguments
-
spacetimedb_math
Common math types and SpacetimeDB integrations for server-side Rust modules
-
polynomial
manipulating polynomials
-
kanaria
functions such as hiragana, katakana, half-width and full-width mutual conversion and discrimination
-
mv-norm
Multivariate Normal Distribution functions, CDF etc
-
qtty
Strongly typed physical and astronomical quantities
-
castep_model_generator_backend
A rust-written backend lib for edit and generation of lattice 3D-models compatible with CASTEP and Materials Studio
-
sm_3d_camera_control
High-quality integration for https://supermaker.ai/blog/qwen-image-multiple-angles-3d-camera-alibabas-breakthrough-in-ai-camera-control/
-
memory_size
ability to represent a number of bits or bytes, and apply arithmetic to the sizes
-
amplify_num
Amplifying numeric types: big-sized and bit-sized integers
-
Sph2-rs
An improved version of Sph-rs, that uses a mod to calculate the desired values
-
abhedya-chhandas
Sanskrit Metering (Chhandas) Logic for Abhedya PQC
-
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…
-
rsc
A fast calculator for solving scientific and algebraic math equations in strings
-
fin_decimal
A high-performance decimal fixed-point arithmetic library for financial applications
-
satgalaxy
satgalaxy-rs is a Rust library that provides Rust bindings for multiple popular SAT solvers
-
fractal_finance
Enterprise-grade fractal analysis for quantitative finance applications
-
smlm-renderer
Render a list of localisations with a gaussian based on the uncertainty
-
numbat
A statically typed programming language for scientific computations with first class support for physical dimensions and units
-
math2
Geometry, layout and rasterization utilities powering the Grida canvas
-
aksel
handling scales and transformations
-
rustplex
A linear programming solver based on the Simplex algorithm for Rust
-
openmaths
Powerful Maths Library for Graphical Applications in Rust and OpenGeometry
-
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
-
power_house
deterministic sum-check proofs, finite-field arithmetic, transcript logging, and quorum ledger tooling for transparent verification in Rust
-
ebi_arithmetic
Exact arithmetic for Ebi - a stochastic process mining utility
-
factorial
Convenient methods to compute the factorial, optionally checked
-
balanced-direction
manipulate directions with discrete logic
-
treemath
Arithmetics for perfect binary trees
-
qhull
Rust bindings to Qhull
-
nice_and_easy
A minimalistic Rust library for smooth and effortless easing functions
-
bloomcalc
calculator for bloom filters
-
factorial_engine
producing factorials
-
hpn
Text-based RPN-style calculator in the HP Voyager tradition
-
strict-num-extended
Type-safe finite floating-point types for Rust - eliminate NaN and infinity at compile time
-
hercules
A Heuristics toolbox for QUBO in Rust
-
tfhe-fft
pure Rust high performance fast Fourier transform library
-
correlation
A very simple crate that implements the calculation of correlation coefficients
-
mech-matrix
Matrix library for the Mech language
-
prime-radiant
Universal coherence engine using sheaf Laplacian mathematics for AI safety, hallucination detection, and structural consistency verification in LLMs and distributed systems
-
simple-arithmetic-coding
Arithmetic coding, directly derived from the well-known CACM87 C-language implementation
-
fpmath
A floating point math library
-
compute-tau
designed for computing tau to millions of digits
-
matamorph
Seamless conversions between Rust’s major matrix libraries: ndarray, faer, nalgebra, and mdarray
-
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]
-
palmfft
Palm-sized Faster Fourier Transform
-
signal-gen-cjds66-lib
An unofficial support library which can fully remote control the inexpensive Koolertron DDS Signal Generator known as GH-CJDS66
-
oat_rust
User-friendly tools for applied topology
-
deep_causality_ethos
Programmable ethics for DeepCausality
-
static-math
Fast mathematical operations with static arrays, without
unsafecode -
expression_engine
An expression engine written in pure rust
-
tuppu-algebra
Geometric algebra with exact rational coefficients — vectors, bivectors, rotors, and more
-
ohsl
A collection of numerical routines and mathematical types for use in scientific computing
-
provable-contracts
Papers to Math to Contracts in Code — YAML contract parsing, validation, scaffold generation, and Kani harness codegen for provable Rust kernels
-
financial-calc
Financial calculation functions built on precision-core
-
CartesianTree
Build hierarchical Cartesian coordinate systems to easily transform poses
-
special-fun
Special functions for Rust by binding to the Cephes library
-
ternary_arithmetic
balanced ternary use array logic gate to arithmetic
-
cas-rs
A CalcScript executor and REPL
-
decimal
floating point arithmetic for Rust
-
foil_rs
Core airfoil geometry + panel-method solver for FoilRs (no Bevy dependency)
-
gomez
Framework and implementation for mathematical optimization and solving non-linear systems of equations
-
RustFrames
A blazing-fast, memory-safe alternative to NumPy + Pandas, written in Rust
-
rapier3d-urdf
URDF file loader for the 3D rapier physics engine
-
so-linalg
High-performance statistical computing library written in Rust, exposed to Python via PyO3
-
candle-mps-flash-attention
MPS Flash Attention for candle - O(N) memory attention on Apple Silicon
-
rusty-wam
The Warren Abstract Machine in Rust
-
burn_yono
YoNoSplat model pipeline and utilities for Burn
-
similarity-least-squares
Least-squares estimation of transformation parameters between two point patterns
-
runmat-lexer
Lexer for the RunMat language (MATLAB/Octave syntax) built with logos
-
qt-artifacts
Infrastructure crate providing metadata and resolution logic for platform-specific Qt distributions
-
algebraeon-sets
Algorithms in combinatorics
-
rpoly
algorithm for finding all roots of a real-coefficient univariate polynomial
-
metatron-qso-rs
Metatron Quantum State Operator - A quantum computing framework based on 13-dimensional sacred geometry
-
eta-cli
CLI for the Eta calculus
-
dimensional_analyser
Runtime dimensional analysis and unit-aware quantities for Rust
-
fast-graph
A fast, lightweight and extensible implementation of a graph data structure
-
gstools-core
The core functions of GSTools
-
sgrust
A sparse grid library written in Rust
-
series
Laurent series in a single variable
-
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.
-
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.
-
tafrah-math
Math primitives for the Tafrah PQC library (NTT, polynomial ring, modular arithmetic)
-
yash-arith
POSIX shell arithmetic expansion
-
moving-average
moving average library
-
wigners
Compute Wigner 3j and Clebsch-Gordan coefficients in pure Rust
-
cgmath
A linear algebra and mathematics library for computer graphics
-
stwo
Core library implementing the Circle STARK prover and verifier
-
amari-network
Geometric network analysis using Clifford algebra and tropical algebra
-
mdarray-linalg
Linear algebra operations for mdarray, with multiple exchangeable backends
-
rbx_types_ops
Adds operation methods to rbx_types
-
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 👀
-
fast-srgb8
Very fast conversions between linear float and 8-bit sRGB (with no_std support)
-
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
-
radians
storing angles
-
csvbinmatrix
Binary matrix Compressed Sparse Vector
-
multiptr
Maximally convenient and efficient wrapper around a pointer to an element within a slice
-
nym-dkg
Nym's Distributed Key Generation functionality
-
isotopes
Variants of common types for enforcing invariance
-
rust-github-action-test-b76u22ivt4z3
四則演算を行うライブラリ
-
eqlog-eqlog
Datalog with equality
-
qhull-enhanced
Rust bindings to Qhull
-
tensorlogic-scirs-backend
SciRS2-powered tensor execution backend for TensorLogic
-
lean-agentic
Core library for Lean-Agentic: hash-consed dependent types with 150x faster equality
-
daisycalc
A high-precision terminal scientific calculator
-
adlo
Adaptive LLL algorithm for solving SVP
-
infinitable
Infinity for types without infinite values
-
kifmm
Kernel-independent fast multipole method
-
gasteiger-rs
A lightweight, zero-dependency Rust crate for Gasteiger-Marsili PEOE partial atomic charge assignment
-
tl_cpu
CPU tensor backend for TL
-
int-div-cum-error
Primitive integer division with rounding kind and cumulative error
-
signal-transforms
A comprehensive Rust library for discrete and wavelet transforms, including DCT, Dct_2d, DWT2, and more
-
csta
Makes it somewhat easier to do metropolis and montecarlo stuff
-
noise-algebra
Easy manipulation of noise functions
-
rfa
A port ERFA to Rust
-
fixed_math
Some math traits and functions for
fixedpoint numbers -
dewiz-splitter
Trade splitting algorithms for the DeWiz Tycho solver
-
ruststartracker
Lightweight Star Tracker
-
ruint2
Unsigned integer type with cont-generic bit length
-
zetamac-rs
Zetamac timed arithmetic test and pratice
-
growth-and-decay
literally thrown together to solve problems on a math paper
-
lisudoku-solver
Solver for sudoku puzzles used by lisudoku
-
clifford-3-even
even sub-algebra of 3-dimensional clifford algebra, specifically for qubit processing
-
aliquot
Generating aliquot sequences
-
lidrs
reading and representing light intensity distributions via photometric webs
-
polyhedron
A half edge and radial edge implementation
-
angle
wrapper to avoid ambiguous parameters + common operation over angles like wrapping, comparisons, arithmetic operations, trigonometric operations and conversions between rad and deg
-
Neoprene_Byzantine
has two parts, Neoprene and Byzantine. Byzantine stores an equation and Neoprene computes and compares those equations with interval arithmetic on rationals.
-
numbat-exchange-rates
fetch and parse currency exchange rates from the ECB
-
arithmetic-parser
Parser for arithmetic expressions with flexible literals and type annotations
-
mikino_api
induction and BMC engine
-
historian
a high performance zero-config histogram implementation
-
savan
core library for answer set navigation
-
scuttle
A multi-objective MaxSAT solver
-
convex-spreads
Spread analytics for the Convex fixed income analytics library
-
RayBNN_DiffEq
Matrix Differential Equation Solver using GPUs, CPUs, and FPGAs via CUDA, OpenCL, and oneAPI
-
libmat-rs
Rust bindings for libmat, an stb-style single-header linear algebra library in pure C
-
py-laddu-cpu
Python bindings for laddu
-
krnl
Safe, portable, high performance compute (GPGPU) kernels
-
luacad
A Lua-based CAD scripting engine built on CSG operations
-
amari-gpu
GPU acceleration for mathematical computations
-
cubek-quant
CubeK: Quantization Library
-
ortools-sys
FFI bindings to Google OR-Tools C++ library
-
ntt
Fast NTT (number theoretic transform) for polynomial multiplcation for primes, prime power, and certain composite moduli
-
num-ordinal
Ordinal number types
-
butler-portugal
implementing the Butler-Portugal algorithm for tensor canonicalization
-
fa_slow_ai
A slow AI implementation using fractal algebra
-
franken-decision
Decision Contract schema and runtime for FrankenSuite
-
ffnt
Finite fields for number theory
-
math_library
math library
-
wrapping_in_range
Wrapping arithmetic for any range
-
shapers
fitting shapes and operations on geometrical objects
-
expression_engine_lts
An expression engine written in pure rust (LTS)
-
mangle-ast
Mangle, a logic programming language
-
vakint
Computation of single-scale vacuum integrals for High-Energy Physics
-
dexterior
Discrete Exterior Calculus toolkit
-
liealg
lie group and lie algebra in rust
-
corevm-prime-sieve-bin
prime sieve program for CoreVM. Prebuilt binary.
-
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).
-
qox
Quantitative finance library for Rust (Alpha)
-
smtkit
Facade crate for SMT constraint IR + SMT-LIB backends
-
musclecalc
fitness: estimate the one repetition maximum (1RM)
-
quadratic_residues
calculating quadratic residues of integers
-
semdiff-differ-image
Image diff calculator and reporters for semdiff
-
pigeons
writing VeriPB proofs
-
amari-flynn
Probabilistic contracts and verification - named after Kevin Flynn's acceptance of spontaneous perfection
-
doubled
Dekker arithmetic
-
measured-process
Linux process metrics for measured
-
mumps-src
Build Mumps as a crate
-
rcloc
Count, or compute differences of, lines of source code and comments
-
comfy-bounded-ints
Bounded-integer types focused on ergonomics and safety. (See README.md)
-
tokmd-analysis
Analysis logic and enrichers for tokmd receipts
-
flowstdlib
The standard library of functions and flows for 'flow' programs
-
cova-algebra
Cova's algebraic library
-
sm-2
Spaced Repetition
-
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
-
chfft
Fastest Fourier Transform library implemented with pure Rust
-
clmul
Carry-less multiply for Rust, internally uses llvm or compiler intrinsics, with fallback if the CPU has no clmul instruction
-
nalgebra-spacetime
Spacetime Extension for nalgebra
-
anim8
Animation toolset
-
ccmath
doing math with complex numbers
-
rdsmath
Minimal math library for no_std environments - RedstoneOS
-
turbocollatz-internal
that provides the algorithms and custom type aliases for turbocollatz
-
gloss-geometry
Small library for geometry based utility functions in gloss
-
metacat
categorical theorem prover
-
hammer-and-sample
Simplistic MCMC ensemble sampler based on emcee, the MCMC hammer
-
oldies-brian
Brian spiking neural network simulator revival in Rust
-
goad
Compute the single scattering properties of particles much larger than the wavelength of light with geometric optics and aperture diffraction theory
-
fastcwt
Rust-lang Continuous Wavelet Transform(CWT) library inspired by fCWT
-
phyz-math
Spatial algebra and math primitives for phyz physics engine
-
poly-ring-xnp1
Polynomial ring Z[x]/(x^n+1) for lattice-based cryptography
-
qvnt
Advanced quantum computation simulator
-
gaussian_kde
Multivariate kernel density estimation with Gaussian kernels and optionally weighed data points
-
latex2mathml
Convert LaTeX equations to MathML
-
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…
-
irox-stats
Various mathematical and statistics utilities
-
playit-agent-core
Contains the logic to create a playit.gg agent
-
eenn
A hybrid neural-symbolic constraint solver with cognitive reasoning capabilities
-
ddnnife_cli
d-DNNF toolkit
-
libmf
Large-scale sparse matrix factorization for Rust
-
smartcalc
Text based calculator for peoples
-
lightwalk
An experimental rust crate for defining signed distance functions in any dimension
-
num-runtime-fmt
Format numbers according to a format spec determined at runtime
-
fenris
advanced finite element computations in Rust
-
symexpr
A libray to build symbolic expression and evaluation
-
ecoord
transforming between 3D coordinate frames
-
stacked_linear_algebra_graph
Embedded in-memory graph using sparse linear algebra
-
quad-rs
Adaptive Gauss-Kronrod Integration in Rust
-
gpca
'Async Hyper-Graph Cellular Automata' computational model
-
boolmesh
Robust 3D mesh boolean library
-
yufmath
CAS Lib
-
goertzel_thd
A small no_std crate to compute THD using the Goertzel algorithm
-
polydf
Distance queries for parametric curves in 2D and 3D (nearest point, unsigned distance, early-out with speed bounds)
-
kitten
light bdd framework for Rust and for those who don't like cucumber - cats don't like cucumbers, kittens are light cats
-
russell_stat
Statistics calculations and (engineering) probability distributions
-
allan-tools
Package to compute statistics to study systems stability
-
linalgae-rs
lightweight, generic linear algebra library for Rust, with support for arithmetic operations and random initialization
-
blas
The package provides wrappers for BLAS (Fortran)
-
codenano
editing DNA molecular designs
-
reference-interval
reference interval helpers a.k.a. reference range helpers.
-
aligrator
A lightweight numerical integration library
-
math-wave
Analytical solutions for wave and Helmholtz equations
-
meansd
calculate mean and standard deviation
-
cobre-stochastic
Stochastic process models for power systems — PAR(p), scenario generation, correlated sampling
-
arranged
Statically bounds-checked (machine-word-abstracting? TBD) ranged types as zero or low-runtime overhead abstractions providing safe (no unintentional overflow) arithmetic
-
rstm-traits
focuses on building concrete implementations for Turing Machines
-
clifford-codegen
Code generator for optimized geometric algebra types
-
rx_core_observable_iterator_on_tick
iterator observable for rx_core, emitting on discrete ticks instead of immediately
-
rmathlib
Port of R's C Library of Special Functions
-
lib
LIB: Math and container utilities for Rust. Notice: study purpose, not production ready.
-
spynso3
Pyo3 bindings for spenso
-
saturation
Real-time saturation and clipping designed for use with vst's
-
ear-algae
Linear algebra featuring Vectors, Normal Vectors, Matrices, Rotors (Unit Quaternions) and Rigid Transforms (Rotation + Translation)
-
mathhook
High-performance educational computer algebra system with ergonomic Rust macros
-
neo-zkvm-cli
CLI for Neo zkVM script execution, proving, and verification
-
mematrica
An easy to use library for working with matrices
-
ga_generator
generating geometric algebra equations for any algebra and dimension
-
aljabr
A tiny computer algebra system
-
nabled-linalg
Ndarray-native linear algebra algorithms for nabled
-
inari
interval arithmetic
-
bcurve
DLMM bonding curve
-
kure2
Safe bindings for Kure2, a C library which provides manipulation of relations and operations of relation algebra
-
astro-float
Multiple precision floating-point numbers library
-
lazy_simd
Trait based SIMD acceleration and safe abstraction
-
spora
A small utility crate that currently provides basic arithmetic helpers
-
troth
λ-Calculus Interpreter
-
vectormatrix
Idiomatic Matrix and Vector types for Rust
-
cork
A command-line calculator for hex-lovers
-
cubecl-common
Common crate for CubeCL
-
argentum_log_business
Business layer of encryption
-
angulus
Unit agnostic angle
-
gatenative
execute natively Gate circuits
-
logicaffeine-lsp
Language Server Protocol implementation for LogicAffeine
-
proj5
Pure Rust, type-safe alternative to PROJ.4
-
tfhe-ntt
pure Rust high performance number theoretic transform library
-
quantogram
Approximate quantiles using histograms with logarithmically sized bins to guarantee worst case absolute relative error
-
tofas_extras
Translation of fundamental astronomical subroutines
-
tilezz
work with perfect-precision polygonal tiles built on top of complex integer rings
-
formualizer-workbook
Ergonomic workbook API over the Formualizer engine (sheets, loaders, staging, undo/redo)
-
rpn-c
A calculator environment using Reverse Polish Notation and multiple precision numbers
-
mbimap
Pooled bijective maps in Rust
-
hierx
Hierarchical linear operators for efficient network approximations
-
vhe
ElGamal homomorphic encryption library with verifiable operations
-
mangle-analysis
Mangle, a logic programming language
-
xod
A tiny REPL for bitwise arithmetic and expression evaluation
-
number-theory
Fast primality, factorization and elementary number theory for integer types
-
jpegxl-src
Source of libjxl and logic to build it
-
math-optimisation
Non linear optimisation library with own DE solvers and interface to NLOpt and MetaHeuristics
-
ramanujan
mathematical functions, linear algebra, stats etc
-
coordinates
no nonsense, library for using two and three dimensonal coordinates in several systems
-
equation
mathematical expression evaluation and simplification
-
polars-python
Enable running Polars workloads in Python
-
aviation_calc_util
assist with aviation related calculations
-
newnum
traits for number API and hierarchy
-
deep_causality_discovery
Causality discovery DSL for the DeepCausality project
-
fastnum2
fork of Fast decimal numbers library
-
tesser-indicators
Technical indicators and signal helpers for Tesser strategies
-
avila-linalg
Avila Linear Algebra - Álgebra linear genuína em Rust para o ecossistema Avila (vetores, matrizes, SVD, eigenvalues)
-
irox-units
Physical Quantities, Units, & Reference Frames Library
-
resistor-tui
Program to calculate resistors
-
cardo
Frame-safe geometry with compile-time checking
-
faddeeva-sys
binding for The Faddeeva Package
-
hilbert_2d
Functions for mapping between 1D and 2D space using the Hilbert curve, and its approximations
-
saturating_cast
saturating casts between integer primitives
-
nalgebra-sparse
Sparse matrix computation based on nalgebra
-
model2vec
H2CO3's & Narnium's Rust Implementation of Model2Vec
-
sprs-ldl
Sparse cholesky factorization
-
root1d
One dimensional root finding algorithms
-
num-algebra
an algebra num type
-
slop-dft
Discrete Fourier Transform operations for tensors in SLOP
-
stensor
Cross-platform GPU tensor library with Slang and Rust
-
optimization-solvers
Numerical optimization solvers for unconstrained and simple-bounds constrained convex optimization problems. Wasm compatible
-
katex
Rust bindings to KaTeX
-
vector_2d_3d
small library for 2D and 3D vectors
-
num-iter
External iterators for generic mathematics
-
prop
Propositional logic with types in Rust
-
koto_geometry
A Koto library with basic geometry types and operations
-
landmark-common
Common utilities and types for Landmark navigation mesh generation
-
nimber
calculating in Conway's nim-arithmetic
-
ranvier-std
Standard Module Library for Ranvier
-
rust-poly
Numeric manipulation of real and complex polynomials
-
gcdn
An algorithmically faster implementation of variadic GCD
-
inner-space
dot product trait and auto implements the inner space trait, which contains a bunch of useful functions for working with vectors
-
sqpnp_simple
SQPnp camera pose estimation
-
divrem
Division and modulus variants
-
gd-death-counter
A death counter for Geometry Dash
-
brik64-core
BRIK-64 Core Monomers — Digital Circuitality for Rust. 64 formally verified atomic operations + EVA algebra composition.
-
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. -
stochasta
stochastic analysis library
-
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.
-
zero-plonk
A pure-Rust implementation of the PLONK ZK-Proof algorithm
-
snaphu-sys
Low-level Rust bindings to the SNAPHU C library
-
hfs
Hereditarily finite sets
-
rquant
A quantum computing library for qubit manipulation and observation
-
theseus-lua-src
Sources of Lua 5.1/5.2/5.3/5.4 and logic to build them. Fork with Factorio lua.
-
zagreb-lib
analyzing graph properties using the Zagreb index and Hamiltonian criteria
-
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 -
exo-manifold
Continuous embedding space with SIREN networks for smooth manifold deformation in cognitive AI
-
cliffy-core
Reactive UI framework with geometric algebra state management
-
image_processing
This package provides tools for image processing with a focus on edge detection and morphological transformations
-
gmres
A sparse linear system solver using the GMRES iterative method
-
vecmat
Low-dimensional vector algebra with min_const_generics support
-
mazer-atog
lookup table for common mathematical symbols
-
simple_add
一个简单的两个数求和库
-
sophus
geometry for robotics and computer vision
-
avr-q
Fixed point arithmetic for AVR
-
suma_ulsa
Sistema Universitario de Métodos Académicos (SUMA) - librería Rust con bindings Python
-
rstm-actors
focuses on building concrete implementations for Turing Machines
-
toto
conversion method between basic numerical types
-
geosets-rs
continuous set arithmetic
-
frlearn_math
Fuzzy/rough math primitives and safe numeric transformations
-
talos_common_utils
Common utilities used in Talos
-
g3
Neat library for computer graphics based on geometric algebra
-
vom_rs
Probabilistic Finite Automata
-
advanced-algorithms
A comprehensive library of advanced algorithms for numerical analysis, linear algebra, cryptography, optimization, and graph theory
-
math_calculator
a lib with math expr ast build and exec
-
one-euro
Multidimensional implementation of 1€ Filter
-
windowfunctions
Common window functions for apodization
-
math-symbols
Symbols for computer algebra
-
ccstat-pricing
Pricing fetcher and cost calculator for ccstat
-
anybase
High-performance arbitrary base integer conversion library
-
intervals
A generic interval type with support for open/closed bounds
-
br-maths
maths
-
didp-yaml
YAML interface for Dynamic Programming Description Language (DyPDL) and DyPDL solvers
-
npy-stream-writer
stream writer for numpy files
-
algebraic_immunity
A package to compute the algebrac immunity of Boolean functions
-
ginger-rs
Parallel Bairstow Root-finding Method in Rust
-
slsqp-rssl
slsqp rust impl, ported from scipy Fortran impl
-
verifiable_encryption
Verifiable encryption schemes - Encryption of discrete log from DKG-in-the-head
-
amari-info-geom
Information geometry and statistical manifolds
-
pocket_prover
A fast, brute force, automatic theorem prover for first order logic
-
primal-check
Fast standalone primality testing
-
boolean-circuit
import, modify and export boolean circuits
-
formally
the open-source formal methods toolchain
-
fwd_ad
Forward auto-differentiation, allowing its user to manage memory location and minimize copying
-
suitesparse_graphblas_sys
Rust bindings for SuiteSparse::GraphBLAS
-
rough2
Find the nearest fraction for some number
-
stwo-vm-runner
VM runner for executing Cairo programs with STWO proving support
-
v_eval
Expression evaluator with context
-
augurs-outlier
Outlier detection for time series
-
voxel-tiler-core
Convert point clouds to voxel data
-
smartcalc-tauri
Text based calculator for peoples supported in Tauri
-
rustpython-format
Format helpers for RustPython
-
anchor2d
anchoring library
-
envisim_estimate
Design-based estimation and variance estimation
-
asset-importer-rs-scene
Scene module for asset-importer-rs
-
inrust
Accumulate knowledge of my study on Rust language
-
fibonacci-numbers
The 186th Fibonacci number
-
vec3-rs
minimal 3d vector implementation
-
zeuhl_fraction
fraction used in matrix operations
-
tauformer
A Transformer Architecture using arrowspace's taumode
-
codemem-engine
Domain logic engine for Codemem: indexing, hooks, watching, scoring, recall, consolidation
-
stats-ci
A pure Rust library for computing and working with confidence intervals on sample data
-
lowbulls
lowbull is a Rust crate facilitating message handling and event monitoring
-
rattler_build_variant_config
Variant configuration system for rattler-build
-
alpha-blend
Alpha blending and compositing
-
point_process
simulating random point processes
-
qudit-circuit
Accelerated and Extensible Quantum Library
-
corp-fin
A specialized library for corporate finance calculations, including Beta, Sharpe Ratio, and Risk Metrics
-
fugue-ppl
Production-ready monadic PPL with numerically stable inference, comprehensive diagnostics, and memory optimization
-
ekore
EKO expressions
-
nexsys
Solve nonlinear systems of equations using Newton's method
-
octonion
Minimal, dependency-free, no_std octonion algebra
-
kalkulator
A mathematical expression evaluation tool and library
-
h_math
advanced mathematical computations
-
descent
Modelling and automatic differentiation for constrained optimisation
-
flavio
welcomes you
-
bit-vec-omnitool
A vector of bits
-
rsl-interpolation
A re-write of GSL's Interpolation Routines in Rust
-
simple-vectors
dimension generic vector math
-
nbcs
checksum calculator for hexadecimal strings
-
rustneuro
neural signal analysis and feature extraction for scientists who require fast computation
-
numerics-rs
Blazing fast numerical library written in pure Rust
-
quaigh
Logic optimization library
-
const_poly
Evaluate any multivariable equation or polynomial at compile time with high accuracy and zero runtime overhead
-
scirs2-signal
Signal processing module for SciRS2 (scirs2-signal)
-
feo-math
Math library for 3D transformation
-
ring-algorithm
algorithms on ring (Abstruct Algebra)
-
espada
Texas Hold'em poker odds evaluator
-
complex_numbers
muehehehhehee
-
ravencol
Tabular data manipulation
-
unicode-math-class
Determine the Unicode class of a mathematical character
-
sparse_complex
solver for complex sparse matrices
-
grid-math
containing basic representation of Grid, Cell, and assosiated mathematical operations. Helpful in CLI-based gamedev.
-
my-rust-lib-1
High-quality integration for https://supermaker.ai/
-
math-rs
A basic mathematical engine
-
parth10606_first_crate
A test lib for publishing
-
pz_spectra
ezpz fft
-
gategen2
generate Gate circuits (second version)
-
hastycalc
A fast and memory effencient calculator library
-
semdiff-differ-json
JSON diff calculator and reporters for semdiff
-
cnfgen
Generate DIMACS CNF formula from operations
-
vecs
Vector Math Crate
-
softfloat-wrapper
a safe wrapper of Berkeley SoftFloat based on softfloat-sys
-
abstalg
Abstract algebraic structures for Rust
-
fast_fp
Floating point fast-math optimizations
-
munum
Micro 3D Math Library
-
mruby-math
Math module for mruby/edge
-
dala
Dalia is a light weight formula language
-
vax-floating
VAX floating-point types
-
matrix_operations
perform matrix operations
-
geodesic
constructing and sampling 3D geometric scenes
-
math-core-cli
CLI for converting LaTeX equations to MathML Core
-
rithmetic
An experimental math library
-
taco-smt-encoder
defining the SMT encodings of threshold automata components into SMT. This crate is part of the TACO toolsuite.
-
simtrial
Clinical trial simulation
-
cutup
A flexible and efficient allocation library for Rust, capable of distributing assets, resources, and other divisible entities
-
unit-root
Unit root tests
-
fj-export
Early-stage b-rep CAD kernel
-
minifloat
Emulate various minifloats
-
bubblesort-ifyer
Sorts stuff using Bubblesort!
-
rain_linalg
Linear algebra library for Rust
-
dicoco_safe_math
simplified safe math operations
-
camera-intrinsic-calibration
Camera Intrinsic Calibration
-
input_output
一个用于处理大数输入输出的 Rust 库
-
chains_f2vect
chain complexes and dg algebra manipulations
-
rene
Computational geometry
-
rsmt2
Wrapper for SMT-LIB 2 compliant SMT solvers
-
reduction-factor
type representing reduction factor
-
antbox-geom
Two-dimensional logical grid coordinate utilities for
antbox -
tiny_vect
A minimal vector math library for 2D and 3D operations in Rust
-
floco
validates floats against constraints
-
rma
Rare, high-performance mathematical algorithms for Rust
-
spatial
An N-Dimensional R-tree family spatial tree implementations
-
ointer
Steal the high bits of a pointer to store an extra value
-
blanko_quaternions
My personal library for (dual) quaternions and complex/dual numbers
-
med-bed
Digital MedBed protocol - heal consciousness by replacing dissonant genes with resonant ones
-
numberlab
A collection of numerical algorithms
-
atlas-token-confidential-transfer-ciphertext-arithmetic
Atlas Program Library Confidential Transfer Ciphertext Arithmetic
-
glpk-rust
Rust wrapper for GLPK (GNU Linear Programming Kit) with static linking
-
connect-four-solver
A strong and perfect connect four solver in Rust
-
minimax-alpha-beta
Alpha-Beta Pruning + Minimax Algorithm for arbitrary two player minimax style games like Chess, Go, TicTacToe, etc
-
piecewise-linear
manipulating piecewise linear functions
-
matrijs
A small 2D matrix library. There are many like it but this one is mine.
-
board-game-geom
Geometry library for board game
-
gluex-lumi-py
Python bindings for the gluex-lumi Rust crate
-
sparse21
Sparse Matrix Solver
-
cheesecake
Math animation engine
-
rect-iter
Iterator for 2D rectangle areas
-
sr-rcd
Apply Refining-Cover-by-Defect algorithm to solve Sound Ranging problem in time-dependent-metric (and, in particular, (quasi-)metric) spaces
-
curv-kzen
Curv contains an extremely simple interface to onboard new elliptic curves. Use this library for general purpose elliptic curve cryptography
-
C4lc
help you perform mathematical calculations, including addition, subtraction, multiplication and division, others included
-
value-expr
easy expression
-
amfnengine
Amortization Functions (AmFn) Engine
-
basic_stats
Lightweight library with basic statistical estimators and hypothesis tests
-
kalc-lib
a complex numbers, 2d/3d graphing, arbitrary precision, vector/matrix, cli calculator with real-time output and support for units
-
kalman
filter
-
guff
Implements Galois Fields for various natural sizes
-
jyafn
Computational graphs for Data Science that compile to machine code
-
robust-predicates
Robust predicates for computer geometry
-
r2rs-stats
Statistics programming for Rust based on R's stats package
-
replicante_logging
Replicante common logging logic
-
cyclotomic
high-performance library for exact operations in cyclotomic fields
-
bangle
Strongly-typed angles, specified in radians, degrees, rotations, or percentages
-
online-statistics
Blazingly fast, generic, and serializable online statistics
-
butterworth
filters
-
celestial-pointing
Telescope pointing model fitting and correction
-
lll-rs
LLL algorithm for lattice reduction and it's improved version L²
-
wagyu-rs-cli
CLI for wagyu-rs geometry boolean operations
-
markovgen
building markov chain graphs from text datasets and performantly generating text sequences by traversing them, includes an accompanying CLI application
-
abtz-adder
Add demo
-
hyperion
Generic LSystem implementation
-
wavegen
Wavefrom generator library
-
deterministic-trigonometry
Trigonometry without floating point variables to achieve deterministic results across hardware and compilers
-
smcprime
Ultra-fast primality testing with Montgomery arithmetic (32-bit and 64-bit)
-
ralix
type-safe, tree walking interpreter
-
yoda-calculator
command line app that acts as a scientific calculator, operating through commands instead of buttons
-
strong-kleene
Strong Kleene logic in Rust
-
fhe-util
fhe.rs library
-
fuzzy-logic_rs
fuzzy logic in rust!
-
tinyfield
Small, finite fields
-
dual_balanced_ternary
Dual Balanced Ternary Arithmetic
-
bitgauss
A fast boolean linear algebra library
-
discrete-logarithm
Fast discrete logarithm solver
-
r-src
The package provides a source of BLAS and LAPACK via R
-
wick-complex
Complex number support for wick expressions
-
faer-ext
faer API for interoperability with external libraries
-
dfwasm
Main CLI for the dfwasm compiler
-
probability_cli
A command line interface for probability calculations using Bayesian probability
-
squiid-engine
Squiid Engine is an RPN mathematical engine written in Rust
-
intervalsets
bounded and unbounded intervals implemented as sets with all the associated set operations
-
logic-eval-util
logic-eval
-
get-hash
Get hash of a string
-
ty-math
Math types and utilities shared across all tyt crates
-
rats-rs
Rapid Augmentations for Time Series
-
sylvan-sys
Bindings for the Sylvan parallel decision diagrams library
-
aris
A mathematical computing library
-
modular_equations
Program to solve quadratic and linear modular equations
-
simp_linalg
A generically defined, light-weight linear algebra library for simple addition and multiplication of vectors and matrices
-
dashu-int
A big integer library with good performance
-
reda-geometry
geometry library
-
collatz_rust
Code for testing an extention of the Collatz Conjecture
-
math_sdk
math SDK built for learning Rust packaging
-
tachyon-zcash
Proof-carrying data (PCD) framework for Rust
-
kreise-engine-math
Krei.se Engine Rust Math-Package
-
symbolic_math
performing symbolic mathematics. Supports basic arithmetic operations, expression simplification, and expansion, and evaluation.
-
arith_traits
Traits unifying types based on various supported arithmetic operations
-
codd
minimal in-memory database with relational algebraic expressions as queries
-
rational_extensions
Extensions for rational numbers
-
antbox
A cellular automata & artificial life toy
-
nalgebra_latex
several robust formatters for nalgebra::Matrix, LaTeX environments, and more
-
multi-skill
Skill estimation systems for multiplayer competitions
-
avila-id
AVL Platform unique ID generator - replacement for uuid
-
paraxis
rock-solid mathematics library
-
fenris-paradis
Parallel processing of disjoint indices for the fenris library
-
lapack-inject
LAPACK compatible interface backed by runtime-registered Fortran LAPACK function pointers
-
inari_wasm
A stripped-down version of Inari library (a Rust implementation of interval arithmetic) compatible with web assembly
-
simple-cli-calculator
CLI Calculator
-
commutator-rs
Commutator operations for non-commutative algebras
-
ironclad-nodes
Standard node pack for Ironclad (built-in nodes registered for ironclad-runtime)
-
tutti-daemon
Daemon for Tutti
-
bignum-ig
Numbers from ± 10 ^ i64::MIN - 9.999.. * 10 ^ i64::MAX. The Primary Use of this is for Incremental Games.
-
curve_similarities
Calculation of curve similarities for nd-array
-
hilbert-geometry
Hilbert-encoded geometries. Currently only supports lon/lat coordinates.
-
Rustb
A package for calculating band, angle state, linear and nonlinear conductivities based on tight-binding models
-
isochronous_finite_fields
Isochronous implementation of GF(2^8) arithmetic
-
argentum_event_business
Business layer of Event component
-
maths-traits
abstract system of mathematical traits for the Rust language
-
b-spline
B-spline
-
fast-sde
High-performance Monte Carlo simulation for stochastic differential equations in quantitative finance
-
rs-ml
ML crate including Gaussian Naive Bayesian classifier
-
zkpolynomial
polynomial operations, including addition, multiplication, evaluation, and Lagrange interpolation for univariate polynomials
-
anoma-rm-risc0-test-witness
An Anoma Resource Machine Test Witness using RISC0 zkVM
-
lie-rs
Lie series and Baker-Campbell-Hausdorff formula computations
-
runmat-kernel
Jupyter kernel implementation for RunMat using ZeroMQ and the Jupyter protocol
-
scientific-cal
scientific cal
-
microtensor
Automatic differentiation for tensor operations
-
permu-rs
A collection of utilities for permutations. It contains useful tools to create, manage and experiment with permutations.
-
basic_dsp
Digital signal processing based on real or complex vectors in time or frequency domain
-
ogsolve
The program for solving octal games
-
tensor-calc
World's first Rust-based Einstein field equation solver with symbolic tensor calculus
-
nibbler
A small utility for working with nibbles (half byte, 4-bits)
-
e9571_math_lib
high-precision numerical calculations and percentage comparisons
-
gaussian_curve_fit
A
no_stdand noalloclibrary for gaussian curve coefficents calculation -
hmmmm
Performant and easy-to-use hidden Markov models
-
optlib
The optimization algorithms realized in Rust. In given time realized genetic and particle swarm algorithms.
-
convex-curves
Term structure framework for yield curves, credit curves, and multi-curve environments
-
ellp
Linear programming library that provides primal and dual simplex solvers
-
opensrdk-probability
Standard probability library for OpenSRDK toolchain
-
ml-distance
Distance-based methods for vector comparison and analysis. (Porting of the JS/TS pkg
ml-distanceto Rust) -
ipopt_bindgen
Rust bindings to the C interface of Ipopt, a library for large-scale, constrained, nonlinear optimization
-
bellande_node_importance
calculating n-dimensional node importance via API or local executable
-
nsys-math-utils
Math types and traits
-
reefer
Optimizing proc-macro for geometric algebra
-
gchemol
Graph-based CHEMical Objects Library
-
mathengine-lexer
High-performance lexical analyzer for mathematical expressions with unit support
-
gwrizienn
Easy and fast modular arithmetic, polynomial quotient rings
-
reikna
A work in progress math library
-
libfive
Tools for solid modeling, especially suited for parametric and procedural design
-
fitme
CLI curve fitting tool. Parameterise an equation from a CSV dataset.
-
honeycomb-render
Visualization tool for combinatorial maps
-
semolina
Optimized field arithmetic for Pasta moduli for x86-64 and aarch64
-
nalgebra-lapack
Matrix decompositions using nalgebra matrices and Lapack bindings
-
haxcel
Excel gateway to Haskell
-
decnumber-sys
Low-level bindings for libdecnumber
-
clausen
functions
-
opensrdk-linear-algebra
Standard linear algebra library using blas and lapack for OpenSRDK toolchain
-
d4-arjun-sys
wrapper around Arjun for d4
-
flag-algebra
Razborov's flag algebras
-
cvxrust
Disciplined Convex Programming
-
distimate
providing probability distributions for estimation and risk analysis
-
cellular_raza-building-blocks
cellular_raza Building Blocks
-
comodules
calculating Ext for coalgebra and comodules. Also does Finite Field linear algebra.
-
mraphics-mobject
Built-in mobjects(math objects) of Mraphics
-
gwrs
studying data from ground-based gravitational-wave detectors
-
decimal64
Fast fixed point arithmetic that only uses u64 as internal representation
-
gorf-core
Lambda calulcus backend library
-
cubemoma
A multi-word modular arithmetic library based on CubeCL
-
rug-polynomial
Polynomial arithmetic, built on Rug & FLINT
-
mathcore
Symbolic math library and computer algebra system for Rust
-
risc0-circuit-bigint
RISC Zero Circuit for Big Integer Computation
-
malachite-nz
The bignum types Natural and Integer, with efficient algorithms partially derived from GMP and FLINT
-
i48
working with 48-bit integers
-
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…
-
iseven_api
wrapper for isEven API
-
rug-maths
rug wrapper implementing maths-traits
-
interaction-calculus
A parallel model of computation
-
chctools
a chc-tool for personal usage, simply parse the token and do small transportation
-
classgroup
class groups in Rust. Uses GMP for arithmetic.
-
mech-logic
Logic library for the Mech language
-
sparse_matrix
do linear algebra with sparse matrix
-
cliffy-test
Algebraic testing framework for Cliffy - tests as geometric invariants
-
advancedresearch-path_iter
A cocategory enumeration library based on path semantics
-
ruqu-qear
Quantum Echo-Attention Reservoir (QEAR) - Combining quantum reservoir computing with attention mechanisms for time series processing
-
kneasle_ringing_utils
'kitchen sink' utility library for my ringing projects
-
calculator-huggoxbyte
Uma biblioteca de calculadora com u32
-
parry2d-f64
2 dimensional collision detection library in Rust. 64-bit precision version.
-
sieve-of-eratosthenes
A standard implementation of the Sieve of Eratosthenes
-
fitting
Pure Rust curve fitting library
-
xdd
Decision diagrams including BDD, ZDD, MBDD, πDD and more for combinatorics
-
inovo-rs
API for intergrating inovo robot arm
-
coral-aarch64
a pure-rust blas implementation for aarch64
-
dec64-rs
DEC64 decimal floating point with 16 digits of precision
-
vectors
Sparse & dense vectors for use in high dimensional vector spaces
-
mini-matrix
A mini linear algebra library implemented in Rust
-
math-solvers
High-performance linear solvers for BEM and FEM
-
tessera
command line interface for calculating geometric error for 3D Tiles tilesets
-
pandrs
A high-performance DataFrame library for Rust, providing pandas-like API with advanced features including SIMD optimization, parallel processing, and distributed computing capabilities
-
mathsharp
collection of mathematical functions and resources to assist in solving a wide range of topics
-
polygon-offsetting
polygon offsetting crate
-
blazing_fibonacci
A fast Fibonacci number calculator using matrix exponentiation and fast doubling
-
lowdim
two- to four-dimensional integer geometry
-
inexor-rgf-plugin-json
Inexor - Reactive Graph Flow - Plugin - JSON
-
symbolic_regression_wasm
WASM bindings for symbolic_regression (browser-friendly wrapper via wasm-bindgen)
-
cubek-attention
CubeK: Attention Kernels
-
tilted
A toy mathematical interpreter written in Rust
-
rivrs-linalg
Numerical linear algebra
-
lnexp
Carefully evaluate compositions of log, exp, log1p and expm1
-
amari-calculus
Geometric calculus - unified differential and integral calculus using geometric algebra
-
tablefi
table to store, manipulate and format tabular data
-
angular-units
representing, manipulating and converting between angular quantities in various units through a type-safe interace
-
bayes-rs
Bayesian inference with MCMC samplers
-
YetAnotherGeometryLibrary
A geometry library. Includes computational geometry.
-
tl_backend
GPU Backend Trait Definitions for TL
-
rusty_math
mathematical, statistical and machine learning operations
-
number_prefix
numeric prefixes (kilo, giga, kibi)
-
precision-core
Deterministic fixed-point arithmetic for financial computation
-
cargo-cellbook
Cellbook project runner and command line utility
-
gecl
geometry types and a color type
-
shadermath
HLSL inspired mathematics library for Rust
-
libpcp
A constraint solver supporting arithmetic constraints over integers
-
dual_quaternion
A type-agnostic dual-quaternion math library
-
cas-compute
Tools for evaluation of CalcScript expressions
-
linalgrs
Linear Algebra concept implementations from scratch!
-
ndelement
n-dimensional finite element definition library
-
woxi
Interpreter for a subset of the Wolfram Language
-
secrust
source-level verification using Weakest Precondition calculus
-
stroemung
A Computational Fluid Dynamics (CFD) simulator in Rust
-
collatz
Helper functions related to the Collatz conjecture
-
arithmetic-eval
interpreter for arithmetic expressions
-
jito-grpc-client
Client to send transactions to a Jito blockengine node via gRPC connections
-
algebra
Abstract algebra for Rust
-
sci_task_io
Standard File IO Interface for Scientific Calculation
-
measurements
Handle metric, imperial, and other measurements with ease! Types: Length, Temperature, Weight, Volume, Pressure
-
hexagon_tiles
that allows working with the hexagon shape and related math
-
algebraeon-geometry
Algorithms for working with geometric shapes
-
maxpre
Rust bindings for the (MO-)MaxSAT preprocessor MaxPre
-
circle
Definition of circle and ellipse
-
plottery_editor
Graphical Editor of Plottery, a creative coding framework for generative vector graphics and pen plotting
-
collatz_conjecture
A small project demonstrating the collatz conjecture, a maths problem
-
ramp
A high-performance multiple-precision arithmetic library
-
computorv1
An educational computor project solving polynomial equations
-
magnet_rs
User friendly magnetic field calculations in Rust
-
zeuhl_sem
A sem (Simultaneous Equation Model) that has the ability to solve equations using Gaussian elimination or Jacobi methods
-
rust_decimal_cql
that wraps rust_decimal and implements (de)serialization support for ScyllaDB's native DECIMAL type
-
numrs2
inspired by NumPy for numerical computing (NumRS2)
-
map-range
map a value from a range to another range
-
jsi-rs
Rust bindings to JSI (JavaScript Interface) using cxx
-
utils-box-bits
A toolbox of various small RUST utilities that make bit types handling easier
-
calculator-danielgorgonha
u32 operations including power and logarithm
-
eng-units
Engineering unit coversions and calculations
-
glamx
Extensions for glam: Pose2, Pose3, Rot2, and matrix utilities
-
truncnorm
Normal and Truncated Normal distributions
-
oint
oint ('optional int') provides total operations on arithmetic
-
numera
numbers
-
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.
-
sum-calc
A sum calc
-
fftw-sys
unsafe wrapper of FFTW3
-
unitconv
Unit Converter
-
math_matrix
highschool level matrix implementation
-
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
-
boolean-logic
propositional logic evaluator that creates truth tables for propositional expressions
-
chrom
representing colours
-
rlu
Sparse LU Decomposition (Gilbert-Peierls)
-
solver
Solve optimization problems
-
lrk
learning rust
-
math-comb
Math library for Combinatorics, Modular arithmetic & Number Theory utilities
-
arith_wrappers
Rust’s
stdoffers theWrappingtype for “intentionally wrapping” arithmetic, but curiously does not provide analagous implementations for intentionally saturating… -
temporal-attractor-studio
Temporal Attractor Studio - Real FTLE calculation and temporal dynamics prediction with VP-tree optimization
-
snafu-numbers
Special Numeral-Analogue Fuel Units
-
tfns
TranscendentalFunctions: a math tool
-
statrs-fork
Statistical computing library for Rust
-
cayley
generic, stack-allocated linear algebra stuff, such as matrices
-
q-rust
A modular quantum transpiler and QASM 2.0 parser written in Rust
-
algebraeon-rings
Algorithms in linear algebra, polynomials, and number theory
-
mem7-dedup
Memory deduplication logic for the mem7 memory engine
-
project_euler_lib
project euler
-
qlora-gemm-common
Common utilities for qlora-gemm matrix multiplication - maintained fork using qlora-paste
-
ya_advent_lib
Advent of Code Library
-
ieee754
Low-level manipulations of IEEE754 floating-point numbers
-
convg
convert directed and undirected graphs from NAUTY and Traces into adjacency, dot, and net files
-
ltrait-gen-calc
Calculator in LTrait
-
diffsquare
Fast and efficient Fermat factorization CLI
-
r_mathlib
A port of R’s
nmathstats module to Rust -
fermentation
The good kind of decay; forward decay
-
real_float
Floating point types that check for correctness and implement total ordering
-
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
-
cf_functions
has characteristic functions for a variety of distributions
-
pandas_rs
General Mathematics Library for Rust,Inspired by Python Pandas Library
-
periodic_date
Date arithmetic for periodic time series (monthly, quarterly, annual)
-
faasle
evaluating distances (metrics)
-
lemonmath
A math library
-
rug-gmpmee
Rust FFI bindings for GMPMEE
-
geomutil_util
providing basic geometric types
-
awint_dag
DAG
awintfunctionality -
cadical
Rust bindings for the CaDiCaL SAT solver
-
ctclib
A collection of utilities related to CTC, with the goal of being fast and highly flexible
-
u-numflow
Mathematical primitives for the U-Engine ecosystem: statistics, probability, random sampling, and collections
-
cas-unit-convert
Unit conversion library for CalcScript
-
multicalc
Rust scientific computing for single and multi-variable calculus
-
tokmd-analysis-util
Shared analysis utility math and normalization helpers
-
aglet
Opinionated integer-based coordinates and directions and utilities
-
libm-ext
An extension to libm providing essential mathematical special functions
-
qmat
2-dimensional matrices
-
mraphics
A rendering engine for exploring interactive and intuitive math
-
core-math
API for CORE-MATH
-
zetik
Hub for personal code used on high side
-
mathie
math type library
-
kalc-cli
kalc - quick basic math kalculator in cli
-
autd3-core
AUTD3 core traits and types
-
sequential-integration
Lightweight library for sequential integration
-
basemath
math, from the ground up
-
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
-
rust_math
Math library written in Rust
-
winpty-rs-windows-numerics
Windows numeric types
-
algebra-sparse
Efficient sparse linear algebra library built on nalgebra with CSR/CSC formats and block diagonal matrix support
-
strata
A unique search technology
-
linal
tiny linear algebra library without dependencies
-
xteur
Institutional-grade RWA infrastructure. Building secure settlement logic and liquidity mobility.
-
deno_cache_dir
Cache directory logic used in Deno
-
diterator
range-based iteration in Rust
-
pnets
A framework for Petri net manipulation
-
warmup
Calculates the repetitions required for a warmup
-
cubecl-core
CubeCL core create
-
calculator-washin
Biblioteca simples para operações com u32
-
lorust
Modern Rust utility library delivering modularity, performance & extras; or simply Rust version of Lodash
-
calcucalc
A general-purpose calculus library written in Rust
-
sophi
Math Physics library in rust
-
nabo
A fast K Nearest Neighbor (KNN) library for low-dimensional spaces
-
ecm
Lenstra's Elliptic Curve Factorization Implementation with Big Integers
-
indicato_rs
common statistical market signals
-
hyperbolic_drawing
Manipulate and display elements of 2D hyperbolic space (ℍ²)
-
alphamon-rs
interacting with Alpha Outback UPSes
-
perplex_num
Perplex (hyperbolic or split-complex) numbers based on num-traits
-
ls_solver
linear system solution
-
calculator-thigon
Biblioteca simples para operações com u32
-
boost
Rust wrapper for Boost Math
-
rasters
Raster processing library
-
metacat-cli
metacat: a categorical theorem prover
-
discrete-gaussian
Gaussian sampling over discrete fields/rings/sets
-
lox-math
Mathematical utilities for the Lox ecosystem
-
iter-rationals
A fixed size, linear time, no-std iterator over the rational numbers
-
RayBNN_Sparse
Sparse Matrix Library for GPUs, CPUs, and FPGAs via CUDA, OpenCL, and oneAPI
-
bunnies
A fast chess library for fast chess engines
-
sparsela
Fast linear algebra on sparse matrices
-
tree-sitter-xdy
tree-sitter grammar for xDy dice expression language
-
quickcount
Sleek, minimal and blazingly fast word counter app
-
prime-formula
High-performance prime number generation and constellation finding using novel wheel factorization
-
pulgamecanica_matrix
matrix operations and linear algebra
-
unicode_font
Convert unicode characters between fonts
-
logicaffeine-proof
Backward-chaining proof engine with Socratic hints
-
hilbert_index
D-dimensional Hilbert curve
-
crates-testing-bilal
made with rust
-
variational-regression
Regression models trained using variational inference
-
polyhedron-ops
Conway/Hart Polyhedron Operations
-
factorio-lua-src
Sources of Lua 5.1/5.2/5.3/5.4 and logic to build them. Fork with Factorio lua.
-
rusttex
programmatically generating LaTeX documents
-
quad_gk
Pure rust numerical integration library based on Gauss Kronrod quadrature rule
-
padded-number
Work with numbers containing significant leading zeros
-
geph-nat
concurrent NAT thingy used throughout Geph
-
feos-ad
Implicit automatic differentiation of equations of state and phase equilibria
-
RayBNN_DataLoader
Read CSV, numpy, and binary files to Rust vectors of f16, f32, f64, u8, u16, u32, u64, i8, i16, i32, i64
-
si
IEC prefixes
-
puzzle-solver
Solve logic puzzles by describing their constraints. Suitable for puzzles such as Sudoku and Kakuro.
-
calculator-denize
Primeira lib usando rust agora com mais um tipo de calculo
-
flickers
calculating Allan-like deviations and other time and frequency stability statistics functions
-
simple-bezier-easing
calculating cubic Bézier curves using De Casteljau's algorithm
-
ieee-apsqrt
Square root functions for IEEE floats using rustc_apfloat
-
eiche
tools for working with symbolic expressions
-
topology-traits
Topological traits for generic mathematics in Rust
-
polycal
methods for fitting and using polynomial calibration functions following ISO/TS 28038
-
piss
PISS (Picture Secret Steganography) is a command line tool to encode/decode secrets into/from image files
-
sprs_suitesparse_ldl
sprs bindings to the suitesparse ldl solver
-
vector2math
Traits for doing 2D vector geometry operations using standard types
-
oxygen_quark
Oxygen Quark is a maths library mainly developed for the Oxygen Game Engine
-
lottie-core
Core logic for Lottie animations
-
kissunits
Different units (like distances or coordinates), keeping it small and simple
-
frfft1d
one dimensional discrete fractional fourier transform
-
cobre-solver
LP/MIP solver abstraction layer with HiGHS backend for power system optimization
-
orthos
High-performance linear algebra library written in Rust
-
ndarray-inverse
Pure Rust Inverse and Determinant trait for ndarray Array2
-
glar-gemm-f16
high performance cpu kernels
-
universe_sync
Synchronizes the global state of the entire universe. Do not modify this crate unless you are the Prime Minister of England.
-
xxcalc
Embeddable or standalone robust floating-point polynomial calculator
-
rival3
Real Computation via Interval Arithmetic
-
digits_utils
converting numbers to digits
-
calculatex
A pretty printing calculator with support for units
-
roll-rs
Dice rolling library supporting full dice notation
-
gfx-maths
Implementations for the most essential Graphics Math operations
-
bonmin-src
Redistribution of Coin-OR Bonmin as a crate
-
dashu-float
A big float library supporting arbitrary precision, arbitrary base and arbitrary rounding mode
-
rlfsc
A checker for the LFSC proof language
-
big_lehmer
framework to encode (compress) and decode large number sequences into lehmer codes
-
raekna
combines the other crates in the workspace to make a functional program
-
tabularlib
Small library for abstract matrices stored in single linear vectors created as practice project
-
MathTriks
A single crate for every mathematical manipulation
-
jacderida-exp2-adder2
Little binary for experimenting with automated release workflows
-
dice_forge
A small crate to preform basic math using dice notation for random numbers
-
midpoint
Extension traits offering implementations of midpoint [currently, only for primitive integers]
-
radian
A normalized angle type
-
playit-api-client
Contains the logic to create a playit.gg agent
-
spfunc
numerical calculation of special functions
-
polycool
Polynomial root-finding
-
binary_matrix
Dense binary matrix operations
-
knife
An iterator that divides things evenly
-
seqnum
Serial number arithmetic (wrapping sequenec numbers) for rust
-
dices
calculate discrete probability distributions and statistics for combinations of dices
-
surreal
that implements J. H. Conway's surreal numbers
-
freude
An ODE library for ndarray providing some simple, fixed-step integrators
-
cnetworks
A set of tools for creating and manipulating complex networks
-
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.
-
arythemetic_expressions_parser_kharchenko_kma
My own parser for Rust course in KMA that parses simple arythemetic expressions
-
matext4cgmath
Unofficial third-party cgmath extensions for calculate eigenvalues, operator norms and Iwasawa decomposition
-
oldies-copasi
COPASI/SBML biochemical network simulator revival in Rust
-
rust-freqdist
Frequency Distribution in Rust
-
function
A set of useful traits for your functional needs
-
amari-tropical
Tropical (max-plus) algebra implementation
-
x-math
fast math
-
beacon-calculator
calculating the glass colors needed to color a Minecraft beacon
-
asmcahligzamaze
Schizm and amalgamation of adventurer's probability distribution across multiverse 2D maze on a single screen
-
logic_gate
Logic Gates
-
calib-targets-core
Core types and utilities for calibration target detection
-
quaternions
quaternion arithmetic with traits
-
alco-rs
Tools for algebraic combinatorics in Rust, including the octonion algebra and octavian integer ring
-
mathvites
An upcoming batteries included library for all things mathematics
-
gendelbrot
A small, simplistic mandelbrot image generator
-
progress-monitor
Track any progress
-
lapack-sys
The package provides bindings to LAPACK (Fortran)
-
ibdgen
Generate incomplete block designs for experiments with prohibited pairs
-
job-runner
background job runner with configurable delays between job runs
-
openglm
sdk
-
ark-linear-sumcheck
efficient sumcheck protocols
-
manifold3d
Bindings for Manifold - a Geometry library for topological robustness
-
pythagore_tina
Solve the Pythagorean Theorem
-
diving-decompression
Calculate required diving decompression procedures using the US Navy dive tables rev7
-
multifactorials
who allows you to use multi factorials
-
arith
containers with arithmetics
-
const-modulo-ring
Z/mZ for const modulo m
-
choice
Similar to
eitherbut supports an unbounded number of variants -
nd_vec
A compile time n-dimensional vector library
-
irox
Tools & Libraries
-
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
-
sundials-sys
Bindings to the SUNDIALS suite of Nonlinear and DAE Solvers
-
parity
is_even and is_odd methods for primitive numeric types
-
calculator-adrianovcar
calculator application
-
py-laddu
Python bindings for laddu
-
lrslib-rs
Idiomatic Rust bindings around lrslib
-
razor-chase
implements a variation of The Chase algorithm to find models for theories in geometric form
-
rlife
A life library written in Rust
-
rapier3d-meshloader
STL file loader for the 3D rapier physics engine
-
dace
Rust wrapper of DACE, the Differential Algebra Computational Toolbox
-
silico-calculator
A dead simple, Windows-like calculator available on all major operating systems and desktop environments
-
bitmath
Tools for arbitrary-sized bitwise arithmetic
-
memu
Implementations of memory units and working with them
-
slop-algebra
Field algebra and univariate polynomials for SLOP, built on Plonky3
-
lexper
CLI calculator with a handwritten lexer and parser in Rust
-
gac
Generic and Atomic Recipe Calculator for Factorio
-
calculadora
moderna feita com Iced
-
smart-adder
this is smart-adder crate
-
galois_field_2pm
Galois Field (2^M) arithmetic
-
minifb_geometry
meant to help draw shapes in the minifb window
-
msgpass
Thin wrapper to a Message Passing Interface (MPI)
-
statistical-tests-rs
Statistical Tests for Rust
-
hyperoperation
(sometimes known as Knuth's notation) calculation library for Rust
-
nthD_Matrix
using matrixes of any arbitrary size and dimension
-
common_math
A collection of common math functions
-
ulam
calculations
-
idenso
Tensor identities for symbolica
-
easygradecalculator
easy grade calculator
-
mini-calc-lib
A Fully-Featured Configurable (mini) Rust Calculator
-
time_series_utils
handling time series data
-
albert
A terminal calculator written in Rust with ❤️
-
daft-algebra
Algebraic operations for the Daft project
-
punc
Pun Calculus
-
feos-dft
Generic classical DFT implementations for the
feosproject -
rusev
Fast implementation of SeqEval, a sequence evaluation framework
-
delaunay2d
compute Delaunay triangulations and Voronoi diagrams in 2D space
-
akshually
Smart Boys
-
fishers_exact
Fisher's exact statistical test
-
physics2d
2D physics engine, but with Iron power
-
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
-
matrix-42
A linear algebra library written in Rust with basic matrix and vector operations
-
mathlogic
made by Faizan Faisal, Email: f.f.programmer@gmail.com, f.f.programmer@hotmail.com
-
termcalc
Terminal Calculator
-
calculator-beto
Biblioteca simples para operações com u32
-
jakkunight-ali
CLI tool for matrix calculation
-
ellip-rayon
Compute elliptic integrals in parallel
-
lcpc-2d
polynomial commitment scheme from linear codes
-
gravyan
terminal-based gravity calculator
-
qudit-expr
Accelerated and Extensible Quantum Library
-
math_repl
REPL for all different kinds of math
-
rubikmaster
Tools to implement Rubik's cube applications
-
ubiquity-kernel
Core kernel types and traits for Ubiquity consciousness-aware distributed intelligence systems
-
factorize_rayon
Rayon find_map_any() demonstration program
-
tuppu-scalar
Exact scalar arithmetic with rational numbers and uncertainty tracking for geometric algebra
-
astronomical-quantities
Unit-safe computations with astronomical quantities
-
clair
Command-Line Arithmetic in Rust
-
is-prime-kien
Just Kien test
-
pirox
building a calculator
-
money2
For storing and asynchronously converting between (a subset of) ISO-4217 currencies
-
quad-to-quad-transformer
Translate 2d points from one quad to another
-
algebra_kit
An abstract algebra library for Rust
-
reiterator
Lazy repeatable caching iterator that only ever calculates each element once
-
lenia_ca
simulating the Lenia system of cellular automata
-
eigs
Find Eigenvalues and Eigenvectors with Rust using UMFPACK + ARPACK
-
oxlex
lexer/tokenizer used in OxyScript
-
wrapping_coords2d
Translate between 1D indices and 2D coordinates with wrapping
-
arithmetic_yukinari
arithmetic library
-
calculator-olivmath
calculator library
-
fprice2
3자리 마다 콤마 찍어주는 api
-
gf2_192
Arithmetic operations and polynomial interpolation over Galois fields GF(2^192)
-
wave-file
Files are not for humans, but for waves - read any file as a phase matrix at different angles
-
ranked-pairs
A ranked pairs (Tideman method) election tallying library
-
geo-aid-figure
Definitions for Geo-AID's JSON export format
-
deep_causality_metric
Metric signature types and sign conventions for Clifford algebras and physics
-
eta-core
Eta calculus Core (no_std)
-
cronbach_alpha_lib
get cronbach alpha value to check your reliable question
-
rusty-talib
using pure rust code for technical analysis
-
next
trait to get the next sequential value
-
tg-sys
unsafe low-level bindings to the
tggeometry library -
polynomials
Tools to perform polynomial arithmetic and evaluation
-
box-algebra
Box Algebra. This crate defines the fundamental data structure, a mathematical box, and associated methods for doing basic algebraic operations.
-
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
-
linear_algebra_42
A linear algebra library in Rust
-
rfcalc
calculate things
-
ezy
Easy to use tweening library
-
newton-sos
Damped Newton method to solve low-rank problems arising from KernelSOS and Sum-of-Squares relaxations
-
fib-sequence
retrieving fibonacci numbers in base 10
-
hilbert_transform
Hilbert Transformation like Matlab/Octave hilbert function
-
test_gmp_mpir
test gmp mpir for Rust
-
ctclib-pp
A collection of utilities related to CTC, with the goal of being fast and highly flexible, with perplexity scores for KenLMs models
-
dierckx-sys
Rust-wrapper for Dierckx' B-Splines Curve and Surface Fortran Library
-
control-sys
A Control System library implemented in Rust to design and analyze control systems
-
query-curve
querying custom Bezier curves, compatible with curves created at https://querycurve.com
-
break_infinity
larger numbers up to 1e9e15 in Rust for Incremental Games
-
iomath
fast math rust-library
-
int_math
Integer math
-
argentum_notification_business
Business layer of notification component
-
operations_parser_kucherenko
A Rust-based parser for basic math operations with function support
-
uzor-cursor
Cursor management for uzor
-
vec-utilities
A collection of methods that make working with Vecs of floats easier
-
unsigned-f64
A wrapper around f64 that guarantees that the value is always non-negative on the type level
-
nym-topology
Nym's topology crate
-
apbool
Just arbitrary precision boolean arithmetic for Rust
-
cobre
Open infrastructure for power system computation — umbrella crate
-
macmahon
Calculate fast
-
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
-
net_ensembles
Erdős-Rényi and small world ensembles. For simple sampling, Markov chains etc.
-
ferray-ufunc
Universal functions and SIMD-accelerated elementwise operations for ferray
-
c-prime
Convenience wrapper for machine-prime
-
math-core-renderer-internal
Internal crate used by math-core
-
depends_core
Ergonomic, performant, incremental computation between arbitrary types
-
nox
Tensor library that compiles to XLA (like JAX, but for Rust)
-
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*
-
wright_omega
Wright Omega function
-
top-repos
THINGY
-
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…
-
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
-
lcpc-ligero-pc
polynomial commitment scheme from R-S codes, as in Ligero (CCS '17)
-
omni-wave
Easy to use DWT (Discrete Wavelet Transform) library, no need to worry about padding, and a variety of wavelets are available
-
nzscq
Core logic for NZSCQ
-
smt-lang
Sat Modulo Theory Language
-
fuzzycomp
Comparison with margins
-
matriarch
A Linear Algebra and Matrix library written in Rust
-
faer-svd
Basic linear algebra routines
-
mini-math
Lightweight math routines for 3D graphics
-
yamlscript
Program in YAML — Code is Data
-
rapier3d-lijay
3-dimensional physics engine in Rust
-
simple-sum-average
An O(1) memory complexity temporal average helper
-
scirs2-wasm
WebAssembly (WASM) bindings for SciRS2 - JavaScript/TypeScript interop for scientific computing
-
arithmetic-typing
Hindley-Milner type inference for arithmetic expressions
-
rs_handstrength
relative to board omaha hand strength calculator and equity on flop
-
q_rsqrt
fast inverse square root function from quake 3
-
smlm-frc
Fourier Ring Correlation (FRC) calculation for smlm
-
summed-area
table for fast sums or averages of subsections of a 2d array or an image
-
calculator-albaxs
Lib calculator
-
base-converter
Convert a number in any base to any other base
-
xfeval
the Excel-like formula calculator
-
cmath
一个新手的尝试
-
hypertask_engine
The core logic engine used to run hypertask
-
mathio
A lightweight, simple and straight-forward opinionated library for math used in other projects
-
irox-fixedmath
Fixed Precision Math Primitives
-
ferric
A Probablistic Programming Language with a declarative syntax for random variables
-
symengine
Unofficial Rust wrappers to the C++ library SymEngine, a fast C++ symbolic manipulation library
-
m4ri-rust
M4RI-based boolean linear algebra
-
shigens
A math library for calculate quaternion
-
simple-geom
plane geometry
-
calculator_junin
Uma calculadora simples feita em Rust
-
nvblas-sys
This package provides linkage to NVBLAS
-
buttery
smooth transformations with a nice API
-
srmc
A Small Rust Math Crate
-
mathbox
A math toolbox
-
alphabet
working with alphabets
-
lexlib
miscellaneous stuff
-
sath
Toy math library
-
combinatorial
tools, functions, and generators
-
noise_fn
Some simple noise functions and traits to allow easy integration with your own
-
trajgen
Minimum trajectory generator
-
cheque
Convenient checked math
-
cheesecalc
Calculations for sodium citrate mac and cheese
-
tau
The important mathematical constant tau
-
millimeter
Primitive type with millimeter unit attached
-
cubeio
File io for Gaussian CUBE file format
-
sdvrp
Rust binding of Alkaid-SDVRP: An Efficient Open-Source Solver for the Vehicle Routing Problem with Split Deliveries
-
dfa
A simple dfa
-
nonconvex-opt
non-convex optimization algorithms
-
tazor
implementing a calculator based on mathematical expression
-
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
-
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
-
maria-linalg
linear algebra processing package
-
vecmate
Lightweight, zero-dependency, type-agnostic library for vector math
-
finch-symbolic
Namesquatting for Rust port of Finch.jl
-
kair
COnstraint Based Reconstruction and Analysis (COBRA) in Rust
-
ewq
Small math library
-
psy-math
A fork of jet-proto-math. Helpful math utilities, used by PsyLend.
-
ringkernel-montecarlo
GPU-accelerated Monte Carlo primitives for variance reduction
-
math_utils_70_codes
math library
-
cinter
const usable bigints
-
rpn_calc
RPN(Reverse Polish Notatio) library
-
sai_kt
math flow
-
bektor
vector, quaternion, geometry, and matrix library
-
argmin-math
argmin math abstractions
-
gy_r_number
handling rational numbers with high precision
-
turtle-lang
A humble, fun, and friendly Lisp
-
mangle-ir
Mangle, a logic programming language
-
calculator-catitodev
Biblioteca simples para operação com i32
-
semdiff-differ-binary
Binary diff calculator and reporters for semdiff
-
approxeq
A trait for approximate equality of types
-
arithmetic-sign
Arithmetic
Sign(≈+1|-1) to/from arithmetic types such asf64,i32utility -
xnn
A lightweight ML framework with GPU-first architecture
-
FEA_code
-
galgebra
geometric algebra stuff (vectors)
-
cargo_calc
calculation lib
-
f3l_features
3D Point Cloud Library
-
cellular_lib
simulation of cellular automata
-
tassl-src
Source of TASSL and logic to build it
-
mm0_util
MM0/MM1 language utilities
-
quantrs2-symengine-pure
Pure Rust symbolic mathematics for quantum computing - a replacement for C++-based symengine
-
epsilonz
Functional programming in Rust
-
fft_sound_convolution
implementing sound convolution using RustFFT
-
principia_optimization
A Numerical Optimization Library
-
segtrs
Miscellaneous functions such as numeric sequences and factorization
-
xer_adder
Example crate with a dependency
-
cchmod
chmod calculator
-
composite_modulus_proofs
Proofs about several propoerties of a composite modulus - square-free, product of 2 primes, a blum integer
-
memocalc
A useful tool for practicing mental mathematics
-
neophyte-linalg
Linear algebra types for Neophyte
-
slice_math
A selection of useful math operations on slices
-
aoc
Advent of code helpers
-
strict_types
Strict types: confined generalized algebraic data types (GADT)
-
geomutil_triangulation
providing triangulation functions
-
gradecalculators
grade calculators
-
spglib
Rust bindings to spglib
-
rs-sci
the scientific library
-
pblib-rs
Rust safe bindings for pblib
-
fj-window
Early-stage b-rep CAD kernel
-
tscale_sequence
generating tscale sequences
-
unifac
calculate non-ideal vapor-liquid equilibria using UNIFAC model
-
miller_rabin
A multi-threaded, arbitrary precision implementation of the Miller-Rabin primality test
-
dotbits
unsigned int <-> Vec<bool>, plus various helper functions
-
cronus_cli
The CLI for cronus
-
system_solver
Find values of unknown parameters that satisfy a system of constraint equations and given parameter values
-
alpha_stable
Sample and generate probability distribution functions of Alpha-Stable distributions in Rust
-
ark-mpc
Malicious-secure SPDZ style two party secure computation
-
big_num
A big number implement in rust
-
nabo-pbc
A fast K Nearest Neighbor (KNN) library for low-dimensional spaces, now with support for periodic boundary conditions
-
googology
giving names to large numbers
-
inta
Interval arithmetic in Rust
-
turing
hash function library
-
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
-
my_lib_tuanla
Sample rust
-
braid-mvg
Braid's camera geometry and multi-view geometry (MVG) types and algorithms
-
squiid-parser
The algebraic expression parser for Squiid Calculator
-
linfa-clustering
A collection of clustering algorithms
-
graf-lang
An esolang based on graph theory
-
amfnwasm
Amortization Functions (AmFn) Web Assembly
-
markovian
Simulation of Markov Processes as stochastic processes
-
veda12_cr5
math flow
-
lmonade-models
LLM model architectures and serving components for the Lmonade inference engine
-
index_key
lexicographic sort order encoding
-
tricolor
Color structs, color formats, and color conversions
-
matrixes
matrices up to and slightly beyond a highschool level. See README for details.
-
compute-pi
designed for computing pi to millions of digits
-
pluto-src
Sources of Pluto (Lua 5.4 dialect) and logic to build it
-
accelerate-src
The package provides a source of BLAS and LAPACK via the Accelerate framework
-
nnls
Non-Negative Least Squares (nnls)
-
swimos_algebra
SwimOS Algebraic Traits
-
zernike
Routines to compute the Zernike polynomials
-
modality-lang
Modality language lib
-
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.
-
tinymath
Experimental routines for performing arithmetic on small data types
-
trianglo
Stupidly Fast And LightWeight Crate To Calculate Square Root & Logarithm
-
projective
The representation projective transformation
-
quake-inverse-sqrt
Quake Inverse Square root alghorithm
-
exprtk_rs
Rust bindings to the ExprTk C++ library (http://www.partow.net/programming/exprtk)
-
libbytestat
Randomness analyzer
-
math-shop
mathematical tools in pure Rust
-
matrix-math
Mathematical matrices
-
zeck
compressing and decompressing data using the Zeckendorf representation algorithm
-
mc-core
MinecraftRS - Minimal core implementation of Minecraft backend
-
rubiks-moves
focusing on processing moves for 3x3 Rubiks cube
-
amortize-rs
A loan amortization calculator library
-
floorAndCeiling
Tiny crate that contains floor and ceiling functions
-
groslicer
Slice gro files by processing a stream of lines
-
circomspect-circom-algebra
Support crate for the Circomspect static analyzer
-
gsdesign
Group sequential design
-
time-func
represents a set of data points as a function of time and performs various mathematical operations on the data
-
rustsat-tools
Tools and examples built on the RustSAT library
-
simple_colatz
package to compute the colatz conjecture in rust
-
luludada-s-library
A small utility library for demonstration
-
fractran
execute Fractran programs
-
rstmt-nrt
focuses on providing support for the neo-riemannian theory of music
-
calculations_demo
containing many different useful math functions
-
sb-math
math library
-
robust_scaler
A RobustScaler for Rust, compatible with scikit-learn's RobustScaler
-
infinity-euler
These are my solutions to Project Euler implemented in Rust
-
yestack
Tools from me
-
gs-rs
basic monocular SLAM (Simultaneous Localization and Mapping) Algorithm in pure Rust
-
ndarray-unit
A package providing a system of units to the ndarray type
-
crate-paths-cli-core
Core library for crate-paths-cli
-
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…
-
camctrl
Camera control math
-
lamcal
A lambda calculus parser and interpreter
-
planar
Strongly typed planar geometry
-
mdbook-mathpunc
An mdbook preprocessor that prevents line breaks between inline math blocks and punctuation marks when using katex
-
factorion-math
The math (factorials and related functions) used by factorion
-
cubature-sys
Bindings for cubature with support for Linux, macOS, and Windows
-
simple_calculator
First Library
-
nat_diff_geom
Natural Difference Geometry
-
main_test_123
Online store library
-
rxcalc
An expression calculator, originally written in Scratch
-
envisim_utils
methods for design-based sampling methods and estimation
-
calculatorgpweins
calculator library
-
guff-matrix
Fast Galois Field matrix multiplication
-
autopp_inc
example package
-
maths_function
Some maths fuctions
-
cheby
Chebyshev polynomial toolkit: node generation, coefficient fitting (DCT), and Clenshaw evaluation — generic over scalar type
-
graph-cycles
Detect all cycles in a petgraph graph
-
fixed-exp
Exponentiation for fixed-point numbers
-
hc
Handy calculator for haxor calculations
-
libprimesieve
Access to the C function primesieve_generate_primes
-
pokereval
evaluating poker hands with 5 or 7 cards
-
genpet
Generate petgraph graphs with geng
-
concrete-fft
pure Rust high performance fast Fourier transform library
-
multidigraph
extraction multi digraph from a Vec of Paths
-
periodic-table-rs
A chemistry library written in Rust
-
demo_crate_dia
Calculator
-
tclifford
Geometric algebra library
-
qc
An enhanced RPN cli tool for quick binary, octal, decimal, hexadecimal calcs
-
aws_volume_limit_calculator
copy of https://github.com/awslabs/aws-support-tools/blob/master/EBS/VolumeLimitCalculator/volume_Limit_calculator.sh
-
categories
Category theory in Rust
-
sturdy-couscous
URI redirect in rust business logic repo
-
hcode_functions_danielly
Biblioteca de funções da Hcode
-
structural-shapes
Common structural shapes
-
fastdivide
partial port of libdivide. It makes it possible to reduce the cost of divisions.
-
module-publish
module publish test
-
savage
A primitive computer algebra system (REPL)
-
rust-strictmath
Rust portable strict math implemention
-
ruclif-core
Ruclif component containing core logic and common/shared entities
-
mini-c-ares-src
Source of c-ares and logic to build it using cmake
-
sin_cos_ln_sqrt
ITN crate containing math functions
-
andre_wronscki_functions
Andre Wronscki package functions
-
deltav_calc
Allows you to generate a graph representing a delta'v map used in the game Kerbal Space Program
-
square_calculator
Square Calculator
-
math-kit
Math Library for Rust 🦀
-
radix-tools
Tools for computing powers or decomposing numbers by radix
-
vajra
-
acm_dependent
Project dependent on the arithmetic_congruence_monoid library for working with arithmetic congruence monoids (ACM)
-
gd-levels
(WIP) Geometry Dash level strings in rust
-
linearkalman
Linear Kalman filtering and smoothing
-
symjit
a lightweight just-in-time (JIT) optimizer compiler
-
rbf3
Radial Basis Function multidimensional interpolation
-
math_l
Math Functions for LeetCode
-
extended
precision 80-bit floating-point numbers (f80)
-
neogeo
Experimental geography library
-
green-kernels
Evaluation of Green's function kernels
-
adder_test_1129
adder
-
runmat-repl
Interactive RunMat REPL with line editing and Jupyter kernel integration
-
lua-decompile
a lua bytecode decompiler library
-
stepwise
algorithms
-
adder_trial
has a function
-
normal-form
A trait to easily find the canonical/normal form of graph structures
-
y_conbinator
Y conbinator demonstration
-
mazer-core
A minimal, simple math markup language that compiles to HTML, written in Rust
-
noctua
symbolic algebra library
-
mink
(WIP) Portable and modular scripting language for all
-
logik
Calculator for propositional logic formulas
-
pcw_fn
Generic piecewise function trait and impls
-
token_store
A token-based store for arbitrary values
-
fresnel
Special function for computing the Fresnel integrals (CEPHES translation)
-
matchmaker
fairly match students to categories
-
pemel
Parsing and Evaluating of Math Expressions Library
-
const-trig
providing const trig functions
-
gabadder
une description
-
navitools
A tiny tool set for navigation applications
-
rssn-advanced
containing complex and delicate mathematical algorithms exspcialy heuristic one based on rssn
-
tsum_calc
command-line Triangle Sum Theorem calculator
-
amalie
Mathmatical library written for rust and python
-
fuzzy_fraction
Struct for approximated human-readable fraction representation
-
concrete-ntt
pure Rust high performance number theoretic transform library
-
double-pendulum
A mathematical model for double pendulums
-
elic
A utilities library for Rust
-
rust-polynomial
A lib to operate polynomials
-
rlwe
Arithmetic in RLWE rings
-
rustplexity
bigram-based perplexity calculator, useful for filtering out boilerplate or other abnormal text
-
rascal-scheme
Rascal Scheme
-
mangle-parse
Mangle, a logic programming language
-
logic_trioxide
Logic Gate simulating Library
-
zonne
Mr.Z's Rust Open Source Library
-
temperature_calculator
A temperature calculator
-
machine-factor
constant factorisation for machine-size integers
-
emath
Minimal 2D math library for GUI work
-
pdqhash
Perceptual Hashing, originally designed by Facebook. Identify the same image even after some modifications.
-
AddNumber
Add a one number to another number. Made this for class if you use this just why
-
blob-stream
Blob transfer over chunks (datagrams)
-
gem_version
Ruby's Gem::Version comparison logic in Rust
-
array_math
A selection of useful math operations on arrays
-
gali
untyped lambda caluculus, with some sugar for convenience
-
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
-
inexor-rgf-model-json
Inexor - Reactive Graph Flow - Model - JSON
-
mathoxide
A Math Crate Built for Rust
-
nums
Number theoretic functions, such as primality testing and factorization, for BigUints
-
mech-combinatorics
Combinatorics library for the Mech language
-
dimensions
Struct(s) for handling dimensions
-
vector-victor
linear algebra crate
-
vecxd
X-dimensional vector library
-
oxilean
Pure Rust theorem prover and dependent type checker inspired by Lean 4
-
deep-delta-learn
Deeep Delta Learning as in 2601.00417
-
basic_stochastics
A small collection of utilities to make performing basic stochastic calculations more convenient
-
linalgz
linear algebra library for Rust
-
rsfrac
The Terminal-Based Fractal Explorer. Rsfrac is your terminal gateway to Mandelbrot, Burning Ship, and Julia.
-
mraphics-control
The interactive control module of Mraphics
-
love_equinox
calculating your Love Equinox
-
ralgebra
Roy's algebra library
-
m61-modulus
Functions for performing arithmetic modulo the 61st Mersenne number. Aimed at testing bignum implementations.
-
poset
posets
-
smartcalc-tui
Terminal UI for erhanbaris/smartcalc
-
auto_regressive
constructing AR(p) models using the Yule-Walker equations
-
fffft
Number theoretic transform for PrimeField types (from ff crate)
-
binary_polynomial_mod_algebra
Basic algebra on univariate binary polynomial
-
triangle
Struct for geometric triangles. Includes Barycentric-Cartesian transforms and stuff..
-
math-in-rust-doc
Demo of add math to rust doc
-
hcomplex
Lightweight complex and hypercomplex algebra library
-
pitch-pipe
Pitch Pipe is a method for automatically tuning a one euro filter
-
electro
A small toolkit for computational electromagnetics, including FD, MM, and FEM. Unstable till 1.0.
-
evar
Modern ergonomic math calculator inspired by eva
-
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…
-
min_max_assign
Change min(max) implementation in Rust
-
cli-calc-rs
A CLI calculator made in Rust
-
nrfind
A set of useful mathematical functions for floating point numbers based on the Newton-Raphson method for finding roots
-
harness-algebra
algebraic structures
-
ngeom
Geometry in N dimensions
-
calculator_wbarroz
Simplistic library for u32
-
curvature
estimation for point clouds
-
ux-indicators
Technical Analysis Function Library
-
siffra
parse and evaluate human-friendly mathematical and natural language expressions
-
functions_shared
Test deply crates.io
-
mdarray-linalg-faer
Faer backend for mdarray-linalg
-
log_domain
Logarithmic representation of floats
-
stitches
Search spaces to solve math problems fast
-
my_math_demo
A test demo
-
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.
-
ndarray-rblas
rblasbindings forndarray -
symba
Computer Algebra System written in Rust
-
interva
A feature-rich crate for handling intervals
-
xing/recrep
Generate crash reports with ease 👌
-
cons-laws
Particle methods to solve 1D conservation laws
-
eight_module
Uma biblioteca para operações matemáticas simples. Ideal para quem busca facilidade e eficiência em cálculos básicos.
-
polygon_clipping
An algorithm for computing boolean operations on polygons
-
ark-poly-commit
constructing polynomial commitment schemes for use in zkSNARKs
-
pga2d
tools for 2 dimensional projective geometric algebra
-
convolution-dsp
1-dimensional convolution library intended for use in DSP applications
-
pow_of_2
Integer-like types which can only represent powers of 2
-
rsmonad
Haskell-style monads for idiomatic Rust
-
extra-math
Accidentally published
-
rug-miller-rabin
A multi-threaded, arbitrary precision implementation of the Miller-Rabin primality test using rug (GMP)
-
bvrs
A lightweight rust library for BitVector Rank&Select operations, coupled with a generic Sparse Array implementation
-
sci-find-peaks
port of SciPy's find_peaks function, designed to match SciPy's behavior exactly
-
logsumexp
Numerically stable computation of log-sum-exp using a 1-pass algorithm
-
yuescript-src
Sources of Yuescript and logic to build them
-
seismic-response
Seismic response analysis of a single particle system is performed using Newmark's beta method
-
temperature-convert
Temperature unit converter between Celsius, Fahrenheit and Kelvin
-
r2rs-nmath
Statistics programming for Rust based on R's nmath package
-
basic_math_operation
can be used to perform basic operations like Addition, Subtraction, Multiplication and Division
-
guff-ida
Information Dispersal Algorithm
-
lambda-rt
Lambda calulcus backend library
-
cas-graph
A customizable graphing calculator for CalcScript
-
num-derive
Numeric syntax extensions
-
mikino
induction and BMC engine
-
cubek-random
CubeK: Random Number Generation
-
overflow-proof
Monadic checked arithmetic for Rust
-
categorical
combining categorical random distributions and computing exact probabilities
-
matrix-basic
very basic matrix operations
-
tl_cuda
CUDA GPU tensor library for TL
-
rbf-interp
Radial Basis Function multidimensional interpolation
-
mee6
calculate mee6 leveling data
-
anoma-rm-risc0-test-app
An Anoma Resource Machine Test Application using RISC0 zkVM
-
quizx
Quantum Circuit Optimisation and Compilation using the ZX-calculus
-
feldera_rust_decimal
Decimal number implementation written in pure Rust suitable for financial and fixed-precision calculations
-
rust_solar
Date-time solutions for hypothetical cosmic calendars
-
vector-basis
Access components of generic vector types
-
oxiblas-sparse
Sparse matrix support for OxiBLAS
-
arpack-ng
Save interface to arpack-ng-sys
-
cf_dist_utils
has risk and distribution utilities
-
formally-cli
the open-source formal methods toolchain - command-line interface
-
numru
A high-performance scientific computation library written in Rust
-
noxla
Rust bindings to XLA's C++ API
-
kalc-kman
Is a calculator for math
-
sir_ddft
SIR-DDFT model
-
glar-gemm-f32
high performance cpu kernels
-
monkeysort
Sorts stuff using Bubblesort!
-
real_interval
Continuous interval arithmetic library
-
mtrx
type-safe matrix operations using const generics
-
standard_deviation
used to get the standard deviation from the cli
-
rstm-rules
implements the core modules of the rstm sdk
-
oxiblas
Pure Rust BLAS/LAPACK implementation for the scirs2 ecosystem
-
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…
-
finitefields
Perform algebraic operations between integers over a finite field
-
mop-common
Common definitions for MOP crates
-
acm
Arithmetic congruence monoid implementation in Rust
-
gated-development
Pedagogical implementation of command line calculator using basic logic gates
-
options-common
working with financial options
-
matrix_algebra
supporting matrix algebra
-
csg_surface_distance
A package for calculating distance along a given vector between a point and a constructive solid geometry surface
-
quaternion-wrapper
Operator overloading allows implementation similar to mathematical expressions
-
hipparchus-az
angle representation, conversion and calculations
-
fractran_rs
A FRACTRAN interpreter
-
bezier1
rust bezier 1d functions
-
rusty-compression
Low rank compression algorithms in Rust
-
basic_dsp_interop
Digital signal processing based on real or complex vectors in time or frequency domain
-
laddu-amplitudes
Amplitudes for the laddu library
-
unit4
whp-unit4
-
falcon-z3
Rust bindings for z3 and Falcon
-
isodd
A blazingly fast Light Weight rust library for determining if numbers are odd
-
calculator-washinribeiro
Uma biblioteca simples para cálculos básicos
-
sleef-trig
Port of a few sleef.org trigonometric functions
-
palb
A fast and exact method for solving least absolute deviations line problems (Affine-linear L1 regression)
-
steel-decimal
High-precision decimal arithmetic for Steel programming language
-
multi_compare
Macro for comparing multiple values in a concise way. (a < b < c)
-
blend-formula
macros for defining GPU blend modes from arbitrary formulae
-
autoeq-roomsim
Room acoustic simulator
-
hullabaloo
Backend-agnostic geometry construction utilities
-
fibonacci_sequence
A module
-
polydimensional_rust
Lightweight library for Rust created to make work with matrixes and vectors in 2D, 3D and 4D better and faster!
-
field-matrix-utils
working with matrices over finite fields
-
hwcalc
An arbitrary bit-width calculator
-
mosekcomodel_mosek
MOSEK backend for mosekcomodel
-
checked_num
Overflow-checked numbers for safety without sacrificing ergonomics
-
data-pipeline
A functional and extensible library for organized lazy processing of data with minimal overhead
-
dinglebit_combinatorics
A collection of combinatorics utilities
-
hann-rs
Blazingly fast Rust Hann Window
-
goldilocks-ntt
fast NTTs over the Goldilocks prime field
-
unifrac
working with normalized fractional values
-
patch-tracker
Patch tracker
-
wicker
Weighted probability picker for Rust
-
mcdm
assist with solving Multiple-Criteria Decision Making (MCDM) problems
-
superset_map
Map that stores distinct supersets based on the total order defined
-
yttria-math
A DSP math library tailored for use with the yttria set of libraries
-
algebrix
Vectors, matrices, quaternions, and geometry for game engines; column vectors, optional SIMD
-
brevet
Evaluator for Ei calculus with dependent merges and first class environments
-
stormath
A selction of math utility functionality
-
libsumi
The core mathematics and logic library for the GYOSHO graphics ecosystem
-
super_fair_division
fair division algorithms
-
m2csmt
A solver for systems of non-linear (in)equations
-
intfinity
An abstraction over numeric types with infinity implemented
-
alat
Automata Learning Toolkit
-
simple_math
lib to do some mathematical manipulation
-
castep-model-core
The core module to parse, read, edit, and write 3D lattice models for castep and compatible with Materials Studio
-
hdrhist
Small footprint hdr histogram
-
ndmath
Traits for doing vector geometry operations using built-in types
-
polygonical
2d polygon geometry and operations
-
pflow-solver
ODE solvers for Petri net simulation using mass-action kinetics
-
flint-sys
Bindings to the FLINT C library
-
general-lotka-volterra-rs
High-performance vectorized Lotka-Volterra & Replicator type dynamics solver
-
tokmd-analysis-derived
Derived analytics computation used by tokmd analysis
-
toronto
Tools from me
-
sukker
Linear Algebra and Matrices made easy!
-
pawer
doc Calculus of Construction
-
crate2up
lib for the purpose of learning
-
meansd-cli
calculate mean and standard deviation (CLI)
-
qhull-sys-enhanced
Rust bindings to Qhull
-
transfer_function
Transfer functions in s- and z-domain
-
raster-tools
Raster processing tools
-
matlab-sys
Rust bindings for the Matlab C API
-
mpmfnum
A numbers library in Rust
-
vtrig
Hidden trigonometry functions with their derivates and integrals
-
gatesim
The base library for the Gate Project
-
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…
-
rampart
determines how intervals relate to each other
-
phyz-regge
4D Regge calculus with U(1) gauge field for Einstein-Maxwell theory
-
rust-latex-doc-minimal-example
Minimal crate example for getting latex in docs
-
mathguru
An algebra system capable of mixed numeric and symbolic computation
-
mdmath_core
Core multidimensional mathematics library with fundamental types, traits, and operations
-
gaussfilt
Design and apply Gaussian filter for 1D data
-
astro_nalgebra
astro-float for nalgebra
-
mecha10-behavior-runtime
Behavior tree runtime for Mecha10 - unified AI and logic composition system
-
lapack-traits
Generic real/complex scalar trait wrappers for BLAS and LAPACK routines
-
oat_python
User-friendly tools for applied topology in Python
-
mtl
Matrix template library. Dense2D matrix, SparseMatrix.
-
ancomplex
Package provides easy to use, begginer frendly and python like complex numbers
-
calculator-henriquecapi
Biblioteca simples para operações com u32
-
clamped
clamping of numbers in Rust
-
matio-rs-sys
Rust binder to MATLAB MAT file I/O library
-
padic
P-adic numbers in Rust
-
logicaffeine-system
Platform IO and system services for LOGOS
-
rstm-state
A generic state implementation and its supporting interfaces
-
scir-gpu
SciR GPU foundations: device arrays and CUDA (feature-gated) elementwise/FIR kernels with CPU parity
-
laplade
RPN(Reverse Polish Notatio) library
-
sophy
A lightweight, efficient mathematical library for numerical methods, functions, and utilities in pure Rust
-
crook_calculator
one function to compute mathematical equations from string slices
-
ipasir-sys
that contains FFI bindings for IPASIR-compatible SAT solvers
-
postfix
expression evaluator
-
pardiso-wrapper
Wrappers for MKL and Panua Pardiso dynamic libraries
-
calc_mjp
calc simple library
-
ezcgmath
Easy linear algebra Math library for use with computer graphics
-
zeta-quantization
Advanced quantization engine for efficient LLM inference
-
acid2
2-adic double-precision floating-point implementation
-
bootstrap-ht
Bootstrap Hypothesis Testing
-
hwcalc_lib
Backend for the hwcalc calculator
-
doem-math
Const generic linear algebra math crate for 3D applications, made in conjunction with doem
-
avila-vec3d
3D math library - vectors, matrices, quaternions, AABB, ray casting - 100% Rust
-
trilean
Kleene's three-valued logic (boolean + unknown)
-
umath
ffast-math in rust
-
iter_num_tools
Create simple iterators over non integer ranges. itertools + num = iter_num_tools
-
math_utils_BRH
math utility library
-
lawkit-core
Core library for statistical law analysis with international number support
-
crate_crypto_internal_eth_kzg_polynomial
methods that are needed for Polynomial objects
-
runmat-builtins
RunMat built-in functions and standard library components
-
nalgebra-rand-mvn
Random multi-variate normal generation using nalgebra
-
calculator-fcosuport01
Blibioteca para operações com u32
-
netlib-src
The package provides a source of BLAS and LAPACK via Netlib
-
qrotate
Quaternion library for 3D rotation of vectors
-
wilson
Calculate Wilson confidence interval for binomial distribution using the formula from Wikipedia
-
curves
-
num-primitive
Traits for primitive numeric types
-
pnets_shrunk
A reducer for petri nets
-
ranged_type
providing ranged numeric types
-
IsmailTestrustLib
Sample library in rust
-
multi_dim_point
multi-dimensional point
-
ga2
Common types for 2D geometric algebra
-
galois_field
convenient operations on finite field, polynomials, and matrices over finite field
-
rust-fixed-point-decimal
Decimal fixed-point arithmetic
-
poulpy
Efficient & modular FHE library
-
alpha_g_detector
handle the raw output of the ALPHA-g detectors
-
stcalc
Stack calculator
-
ffactor
A very minimal number theory utilities
-
wolfram-pest
Notedown Text parser
-
amari-dynamics
Dynamical systems analysis on geometric algebra spaces - stability, bifurcations, attractors, and Lyapunov exponents
-
typed_floats
Types for handling floats with type checking at compile time
-
ct_ratio
Compile-time rational arithmetic for use in generics
-
vector-geometric-algebra
vector algebraic operations for 2d and 3d vector, as well as splines
-
norman
Implementations of different norms for elements of vector spaces
-
fem_2d
2D Finite Element Method Toolkit
-
nikisas
common mathematical functions with focus on speed and simplicity of implementation at the cost of precision, with support for
no_stdenvironments -
ark-ff-optimized
Optimized field implementations that outperform the generic field implementations in arkworks
-
oldies-auto
AUTO continuation algorithm revival in Rust - Numerical bifurcation analysis
-
caso
Category Theory Solver for Commutative Diagrams
-
goniometry
module for working with trigonometric functions like sine, cosine, tangent and much more to come
-
kn0syseccrs
Intuitive library for elliptic curve cryptography tutorials
-
cenv_core
The internals for the cenv project, designed to be shared amongst different implementations
-
dexterior-core
Core crate of dexterior, a Discrete Exterior Calculus toolkit
-
eigenvalues
algorithms to compute eigenvalue/eigenvectors of symmetric matrices
-
bsplines
N-dimensional B-spline curves and their derivatives built on top of nalgebra
-
rust-kepler-solver
Efficient solvers for the elliptical and hyperbolic Kepler equation
-
croot
finding real and complex roots
-
implicit3d
3d implicit geometry
-
mwa_hyperbeam
Primary beam code for the Murchison Widefield Array (MWA) radio telescope
-
qlora-gemm-f16
f16 matrix multiplication for qlora-gemm - maintained fork using qlora-paste
-
xyz2stl
Convert a point cloud (.ply) file into a STL mesh
-
rpn_calc_empty
RPN(Reverse polish Notatio) library
-
arkley_traits
several traits for common mathematical operations
-
test-fork-core
Core fork logic of test-fork
-
roundable
Round numbers and durations to a given factor
-
moo-math
math interpreter
-
float_extras
Extra floating-point math functions from C math library
-
caliph
calibrate and convert pH measurements using a two point method
-
lento-libquickjs-sys
QuickJS Javascript Engine FFI bindings
-
math_utils_aelsakka
math utility library
-
simplicial_topology
Represent, manipulate, combine and perform computations on simplicial complexes
-
const_fixedp
A const type for fixed point arithmetic
-
ajtai
A no-std implementation of the Ajtai commitment scheme
-
semdiff-differ-text
Text diff calculator and reporters for semdiff
-
signature-rs-bin
CLI Application that computes the log signature from path data
-
mpdec
wrapper for libmpdec math library
-
cblas-sys
The package provides bindings to CBLAS (C)
-
pire-base
high performance cpu kernels
-
topological_peak_detection
A mostly efficient topological algorithm for finding all peaks in a 1-D signal
-
risk-metrics
Risk metrics and calculations for DeFi applications
-
pict-rs-formats
file codec and format logic for pict-rs
-
peroxide-num
Numerical traits for Peroxide
-
dfkzr
Dezimalfestkommazahlrechnung - decimal fixed point arithmetic with up to 19 digits
-
math-xem-common
Common types and utilities for BEM/FEM room acoustics simulators
-
xdbuf
reusable multi-dimensional buffer
-
rpn_calc_53Tanuki
RPN(Reverse Polish Notatio) library
-
yaspar
SMT Parser, a SMTLib 2.7 compliant parsing library
-
thue_morse
generating Thue-Morse number sequences for different bases. You can also specifically create evil numbers and odious numbers.
-
geomath
Stack-allocated maths for geometry, simulation and computer graphics
-
csaps
Cubic spline approximation (smoothing)
-
miden-field
A unified field element type for on-chain and off-chain Miden Rust code
-
feval
clt for fast evaluations
-
sofa-sys
Standards of Fundamental Astronomy (SOFA) Rust bindings
-
extended_matrix_float
Float trait for extended_matrix lib
-
srmfpa
Floating-point's four arithmetic operations (including fused multiply-add) and square root with strict rounding mode
-
glpk-api-sdk
Rust client SDK for GLPK REST API
-
mesh_rasterization
A coverter from meshes to SDF
-
qudit-inst
Accelerated and Extensible Quantum Library
-
min_max_traits
Traits for MIN and MAX associated constants
-
dioxus-katex
Render math with KaTeX in Dioxus!
-
formally-support
the open-source formal methods toolchain - basic support functionality
-
fcwt
Fast Continuous Wavelet Transforms
-
biconnected-components
Find biconnected components in a graph
-
arthroprod
Clifford Algebra based computation for the theory of Absolute Relativity
-
rusty-cffi
Tools for interfacing with other languages via CFFI
-
laddu-extensions
Extensions to the laddu library
-
matx
A lightweight, rusty matrix library that allows for simple and fast matrix operations
-
big_complex
Complicated Arithmetic with Big Complex Numbers
-
canrun
A logic programming library inspired by the *Kanren family of language DSLs
-
rust-blas
BLAS bindings and wrappers, fork of rblas
-
fractions
lightweight crate for fraction arithmetic
-
ngau
Non-Generic Angle Units
-
amfnbatch
Amortization Functions (AmFn) Batch Process
-
calclib
A calculator framework designed to be modular
-
diffurch
Numerical solver for ordinary and delay differential equations
-
splinosaurus
flexible spline and surface library
-
arb-sys
Bindings to the Arb library
-
math-crate
A libary for doing simple calculations in Rust
-
sp2
2D spatial transforms and movement representations using geometric algebra
-
coheron
simulating and analyzing coherent wave phenomena
-
binary-space-partition
Abstract BSP tree
-
differential-geometry
differential-geometric calculations
-
kukan
powerful tool for mathematical interval
-
scotch
Idiomatic wrapper for Scotch, the graph partitioner, graph clusterer and sparse matrix orderer
-
large-primes
Package for Large Prime Number Analysis
-
logic-circus
Open source logic circuit simualtor written in Rust
-
allen_interval_algebra
package for interval algebra for more information see https://en.wikipedia.org/wiki/Allen%27s_interval_algebra
-
spv-rs
Math utility for astronomical data
-
vecto
vector2
-
big_number
A scientific notation number type for idle/incremental games
-
rust-gmp-kzen
Rust bindings for GMP
-
protocheck-core
⚙️ Core logic and validators for protocheck
-
rusoda
Pure rust and just need log dependencies implementation of odepack dlsoda
-
lager
A lightweight type-safe linear algebra library
-
set-partitions
Represent and enumerate set partitions
-
boostvoronoi_core
Boost voronoi private workspace (this workspace will be re-integrated in the main crate in next release)
-
signature-rs
High-performance log signature computation for paths and time series data
-
base95
Textual representation of base 95 fractional numbers with arbitrary precision
-
smolmatrix
Small simple matrix library
-
intel-mkl-tool
Seek Intel(R) MKL library from system
-
sqrt-rs
Stupidly Fast And LightWeight Crate To Calculate Square/Cubic Root In Different Ways
-
ubiquity-quiver
Directed graph structures (quivers) for neural network-inspired computation with nodes, arrows, weights, and activations
-
shape-triangulation
The representation of delaunay triangulation
-
fractionfree
Fraction-free linear algebra for ndarray
-
lie
A numerical library for working with Lie Groups and Algebras
-
matrix_operations_cuda
perform matrix operations using cuda
-
big-int
arbitrary-precision, arbitrary-base arithmetic, supporting arbitrarily large integers of any base from 2 to u64::MAX
-
complexible
A minimal and user-friendly Rust library complex-number operations, bringing the joy of complex mathematics to Rustaceans everywhere!
-
sn_curv
Curv contains an extremely simple interface to onboard new elliptic curves. Use this library for general purpose elliptic curve cryptography
-
pmsim
Porous media simulator
-
lcrs
A Lambda Calculus Interpreter written in Rust
-
num-ord
Numerically ordered wrapper type for cross-type comparisons
-
ubiquity-hyperquiver
HyperQuiver extension: multilinear hyperedges for complex multi-input interactions in directed graph structures
-
coral-blas
a pure-rust safe blas implementation
-
commuter
tooling to test diagrams for commutativity, allowing automated tests on algebraic systems
-
binpack
solve binpacking problems using Linear Programming
-
bempp
Boundary element method library
-
displayr-rustr
R integration
-
akima_spline
A lightweight (only one dependency with 18 SLoC) implementation of a 1d Akima spline with optional smooth extrapolation and derivative calculation
-
arkley
several traits for common mathematical operations
-
GSL-sys
binding for the GSL (the GNU scientific library)
-
vectorama
Very simple linear algebra library for Rust
-
safe-arithmetic
Traits for safe arithmetic operations in rust
-
lyndon-rs
Lyndon words and Lyndon basis for free Lie algebras
-
expr-solver-bin
Binary using the expr-solver-lib to solve math expressions from command line
-
canada
Tools from me
-
robomath
A lightweight, efficient, and generic mathematics library for 3D applications, with a focus on robotics and simulation
-
tuppu-scene
Scene graph with exact coordinates and motor transforms
-
nicolas
Computational Algebra Library
-
fibext
A versatile Fibonacci sequence generator for Rust, with support for large numbers and optional iterator interface
-
symbolics_core
Core expression module for the symbolics computer algebra library
-
yz-curvep-exs
examples of curve paramterizations
-
lmaths
A short 2D Maths library
-
xmath
Rust port of Microsoft DirectXMath
-
binarybit
Boolean algebra operations in Rust
-
mpir
partial Rust porting of mpir multiple precision library based on gmp mpfr
-
chela
High-performance Machine Learning, Auto-Differentiation and Tensor Algebra crate for Rust
-
argentum_standard_business
The business layer of standard component
-
const_ops
const-ready version of core::ops / std::ops arithmetic traits
-
qmu
Quigly's Math Utility
-
slop-pgspcs
Pretty Good Sparse Polynomial Commitment Scheme for SLOP
-
divisors_fixed
A fixed & enhanced version of the divisors crate
-
polynomial-roots
Find the real roots of huge polynomials in milliseconds
-
rust_estudo
Basic math operations
-
logic-rs
representing logical formulas with support for temporal robustness semantics
-
twoword
Construct bigger uints by combining two smaller ones into a two-word uint
-
natural_constants
Pre-defined constants from all disciplines (math, physics, ...)
-
remsol
Electromagnetic mode solver for 1D multilayer structures
-
vector_space_study
Project created for rust study
-
last_order_logic
An experimental logical language
-
logicrs
logic expression
-
ashlang
A language for zero knowledge proofs
-
rpni
A basic command-line RPN calculator
-
converge-optimization
Optimization algorithms for converge.zone - Rust reimplementation of OR-Tools subset
-
damndiff
Numerical methods for ODE
-
vector_operations
A collection of vector operations for Rust
-
abstract-calculus
A programming language and model of computation that matches the abstract algorithm perfectly
-
spdcalc
Spontaneous Parametric Downconversion Calculator
-
derangement
permutation with no fixed points, a derangement
-
calculi
used to apply calculus functions on equations in string form
-
stats_traits
Traits for collection-like types to calculate statistics
-
rpn_calc_uc_sample
RPN sample library
-
divisor_networks
Discrete Graphs for Indiscrete Researchers - Networks with Grothendieck Topology
-
exponential-integral
The exponential integral function, a.k.a. Ei.
-
datafusion-statrs
bindings to expose statrs functions in datafusion
-
klu-rs
Save bindings to SuiteSparse's KLU sparse matrix solver
-
nabled-core
Core ndarray-native types and shared utilities for nabled
-
curv-lsc
Curv contains an extremely simple interface to onboard new elliptic curves. Use this library for general purpose elliptic curve cryptography
-
ruint-macro
The
uint!macro forUintandBitsliterals -
amari-topology
Topological tools for geometric structures - homology, persistent homology, Morse theory, and manifold analysis
-
polymath
Make math in Rust more powerful! (New math datatypes, traits, functions, etc...)
-
finitediff
Finite/numerical differentiation
-
fj-interop
Early-stage b-rep CAD kernel
-
hundred-doors
calculating and visualizing the '100 Doors' problem
-
intervals-good
An interval arithmetic library with support for many functions and which tracks when domain errors may occur or are guaranteed to occur
-
xrust_calclib
calculator library with floating‐point arithmetic and error handling
-
fasteval
Fast evaluation of algebraic expressions
-
ludomath
A math library for 2D games and graphics
-
mulberry
Coordinate transformation tree with a focus on efficiency
-
logic-form
representing Cube, Clause, CNF and DNF
-
formally-smt
the open-source formal methods toolchain - SMT abstraction layer
-
path_finder
Find non-looping paths in a graph
-
llml
basic math data types with high level frontend and low level backend
-
gcv_spline
fitting and evaluating GCV splines
-
redc
Unsigned integer types which are constrained within a modular field using montgomery multiplication, never overflowing or exceeding the modulo
-
cadk
CAD kernel in pure Rust (B-Rep, CSG, tessellation)
-
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
-
ipasir
Bindings for the IPASIR API to communicate with incremental SAT solvers
-
waker_protocol
using the crate waker_tables creating custom waker logic
-
rpn_calc_perl
RPN library for Perl
-
mat-rs
no_std implementation of mathematical matrix types
-
polynomial-over-finite-prime-field
polynomial over finite prime field
-
rustcalc
a CLI calculator tool
-
bose
mathematical and scientific formulas
-
sonnenbrille
8-bit CRC
-
pythagorean-hodographs
Pythaogrean hodograph splines
-
polynomials-ecc
operating on polynomials over the BLS12-381
-
temp-converter-lib
terminal temperature unit converter between Celsius, Fahrenheit and Kelvin
-
gmpmee-sys
Rust FFI bindings for GMPMEE
-
rust-matrix
foundational matrix operations for matrices containing <f32>, <f64> or complex numbers built from those types
-
cubecl-matmul
CubeCL Matrix Multiplication Kernels Engine
-
mazer-cli
A minimal, simple math markup language that compiles to HTML, written in Rust
-
ipasir-loading
Load shared libraries of IPASIR compatible SAT solvers
-
kolakoski
sequence iterator
-
permutations
generating permutations
-
cassie
limited computer algebra system written for the fun of it
-
num-absurd
A mathematical framework extending traditional field theory to allow division by zero in an algebraically consistent manner
-
calculator_jean
Biblioteca simples para operações com u32
-
matrix
The package provides a matrix laboratory
-
nd_interpolate
1-10 dimensional linear and cubic spline interpolation implemented in Rust
-
infmachine
The Infinite Machine
-
noir-bignum-paramgen
command line tool to convert a modulus into bignum instance parameters for https://github.com/noir-lang/noir-bignum
-
g_2_0_0
manipulate arbitrary object in the geometric algebra containing two perpendicular vectors that square to 1. Basically 2d VGA
-
flowscad
2D graphic and 3D object design with a Rustic functional approach. SVG and OpenSCAD output.
-
decimal-wad
Math for preserving precision floats up to 18 decimal places
-
inexor-rgf-model-logical
Inexor - Reactive Graph Flow - Model - Logical
-
gorf-kiselyov
Lambda calulcus backend library
-
libmat
tools for linear algebra
-
dashu-base
Common trait definitions and tools for the
dashulibraries -
complex_algebra
supporting complex number algebra
-
matlabblas-src
Provide a source for MATLAB's BLAS library for use with the BLAS crates
-
clipcalc
calculator that reads from the clipboard and writes the result back to the clipboard
-
amari-functional
Functional analysis on multivector spaces - Hilbert spaces, linear operators, and spectral theory
-
lucky
A program to test the probability of winning a prize
-
makepad-geometry
Geometry tools
-
groebner
implementing Groebner basis algorithms
-
sized_matrix
Sized matrices using const generics for better type checking and performance
-
ctm_demo
Demonstration of the Consistent Tangent Modulus in Computational Plasticity
-
qalculate-rs
Safe Rust bindings for Qalculate library
-
finitely
Arithemtic over finite polynomial rings
-
malachite-float
The arbitrary-precision floating-point type Float, with efficient algorithms partially derived from MPFR
-
simple-interpreter
interpreter based on reverse poland notation
-
vex
3D math library
-
carbon-simd
SIMD utilities written with Rust (fularuen project)
-
faer-evd
Basic linear algebra routines
-
fixp
Fixed-point numbers
-
scirust
A scientific computing library
-
qudit-core
Accelerated and Extensible Quantum Library
-
lamcal-repl
A lambda calculus command line repl
-
bempp-octree
create Octrees
-
lamb
Pure untyped lambda calculus in safe Rust
-
deft-quick-js
QuickJS Javascript engine wrapper
-
astro-float-num
Multiple precision floating point numbers implemented purely in Rust
-
subsphere-render
Rendering tool for the subsphere crate
-
unit_system
Automatically derived typed unit systems
-
claire_vector
claire is a rust lib for vector calculus
-
dualquat
Quaternion and Dual Quaternion math library for high-precision physics simulation
-
fracints
Special case fractional-only fixed point numbers
-
magnesia
A math library for Rust
-
yttria
that re-exports the other yttria sub-libraries for radio application development
-
geometric_algebra
Generate(d) custom libraries for geometric algebras
-
lineq
Linear algebra library
-
multrix
matrix multiplication and manipulation library with multithreading support
-
laddu-python
Amplitude analysis made short and sweet
-
quantrs2-symengine
Symbolic Computation in Rust via SymEngine
-
mathtomath
Convert mathematical expressions between different formats
-
ldl
LDL factorisation for quasi-definite linear systems
-
dimensional
Functions, structs, and reference data for working with dimensional values, such as '1 second' and '3 miles per hour'
-
type-proof
type-checked propositional logic proofs
-
algebr
Basic algebra
-
xbasic
that allows adding a scripting language onto your project with ease. This lets your users write their own arbitrary logic.
-
sph2mm
Add an AMR background to an existing SPH initial conditions file
-
msfs
Rust bindings for the MSFS SDK
-
lambert-bate
A fast solver for Lambert's problem
-
scirs2
port of SciPy with AI/ML extensions - Scientific Computing and AI Library (scirs2)
-
metal-matrix
High-performance linear algebra library with Metal GPU acceleration
-
fixed-vectors
Lightweight library implementing fixed-length vectors for Rust applications not compiled with the standard library
-
bevy_hexasphere
A trimmed down and generic version of Hexasphere for bevy
-
slvs
Rust wrapper for the SolveSpace constraint solver library
-
small_matrix
matrix library made in Rust
-
upcast-arithmetic
Arithmetic that is upcasted on overflow
-
aberth
Aberth's method for finding the zeros of a polynomial
-
mathcalculate
My first Rust library
-
num2phrase
Convert long number to a sequence of memorisable phrase with combination of short numbers
-
number-diff
number-based is an attempt of mine to make working with calculus easier
-
oxigdal-analytics
Advanced geospatial analytics for OxiGDAL - Time series, clustering, hotspot analysis, and interpolation
-
cuba
wrapper for the C Cuba integration library
-
deep_core
deep prototype
-
Pedersen_hash_function
computes the pedersen hash of given inputs and modular arithmetic
-
makima_spline
modified akima spline interpolation
-
clfft
Bindings for clFFT, a FFT library for OpenCL
-
colamd
Column approximate minimum degree ordering algorithm
-
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,
-
rustedbytes-pi
Computes digits of Pi using the Chudnovsky algorithm
-
fibs
Get a Fibonacci number or sequence
-
goertzel-nostd
An nostd implementation of Goertzel's Algoritm
-
opensrdk-symbolic-computation
Standard automatic differential library for OpenSRDK toolchain
-
anxious
panic-free dialect of Rust
-
amari-automata
Cellular automata, inverse design, and self-assembly using geometric algebra
-
primeval
A monstrosity of a prime number generator
-
usze
Sometimes you just need a calculator
-
logicaffeine-data
WASM-safe data structures and CRDTs - NO IO
-
jacc
Just another cli calculator: A maths interpreter for the command-line
-
simplex-23d-rs
Simplex 2d/3d noise in Rust
-
ferray-stats
Statistical functions, reductions, sorting, and histograms for ferray
-
normdecimal
Always normal decimal numbers
-
ak_arith_crate
perform arithmetic operations on i32 data type instance
-
lambash
A λ-calculus POSIX-like shell
-
line-graph
Construct the line graph of an undirected graph
-
float_approx_math
A math library for compile-time floating-point approximations (sqrt, sin, cos, etc...)
-
rusty-psf
A comprehensive Point Spread Function (PSF) library for microscopy and optical systems
-
quick_maths
low-dimensional linear algebra structures
-
gpwgpu
intended to make it easier to do general purpose GPU programming (GPGPU) in wgpu
-
delaunay_creator
delaunay triangulation for 2D and 3D(not implemented yet)
-
erosbag-core
Core primitives and operations for processing ROS2 bags
-
vincent_blur
My own implementaion of guassian blur using threads
-
ndarray-odeint
solve ODE using rust-ndarray
-
deepcl-common
Common crate for DeepCL
-
saa-crypto
Cryprography related logic of smart account auth
-
hcode_rust
Biblioteca de funções
-
softfloat-wrapper-riscv
a safe wrapper of Berkeley SoftFloat based on softfloat-sys for RISC-V based on https://github.com/dalance/softfloat-wrapper
-
strcov
math operations
-
alpha_g_physics
Data analysis library for the ALPHA-g experiment
-
mathew
Mathematical expression evaluator with context
-
coin_cbc_sys
Rust bindings to the CoinOR CBC MILP Solveur using the C API
-
scicalc-rs
parsing and doing calculations with measurements, typically used in scientific contexts
-
rustc_apfloat
Rust port of C++ llvm::APFloat library
-
metamath-rs
manipulating Metamath databases, including a parallel and incremental verifier for Metamath databases
-
qunit
Experimental uom-like library which enables compile-time verification of dimensional analysis, with support for statically-sized vectors and matrices
-
calculator_jpguizel
Biblioteca simples para operação com u32
-
scir-fft
SciR FFT: parity-first FFT/RFFT/IRFFT with fixture-based testing and rustfft/realfft backends
-
in_range
Returns true if a number is in range
-
rustitude-gluex
GlueX Amplitudes for Rustitude
-
irox-geometry
2D and 3D Geometry Primitives
-
state-space
equations in rust
-
signal_processing
A signal processing library
-
oldies-core
Core types for legacy simulator revival - ODE systems, time series, ion channels
-
extended-euclidean-algorithm
computes the greatest common divisor of 2 natural numbers and 2 additional numbers such that gcd(a,b)=s·a+t·b holds
-
avlsort
AVL tree holding the rank and the number of duplicates of elements
-
nonstdfloat
Floating point calculations for strafe
-
calcul8
calculator CLI
-
igsolve
The program for solving impartial games
-
nb2fr
Convert integer number to literal French text
-
polynomial_subspaces
general ways to deal with subspaces of the polynomial rings R[X] with R some ring
-
floatd
just num_traits::Float + Debug + Display
-
lodestone_core
User friendly magnetic field calculations in Rust
-
swnb-complex
complex number lib
-
faer-cholesky
Basic linear algebra routines
-
operations
Basic algebraic and mathematical expressions for use with dynamic elements
-
rust-linear-algebra
A linear algebra library for Rust
-
symmetric-interaction-calculus
A programming language and model of computation that matches the abstract algorithm perfectly
-
rml
A machine learning library in Rust
-
raekna-compute
allows evaluating expressions into literals
-
mish
A proof of concept Rust libm like implementation with almost full coverage of libm
-
lucent
toy programming language based on the calculus of constructions
-
modutil
Provide the methods supports modular arithmetic
-
g_calc
A small utility for performing simple math calculations using infix expression
-
equationx
parsing and evaluating simple mathematical expressions/equations
-
leanr-rag-gateway
Multi-lane RAG gateway with cost routing and verified safety proofs using lean-agentic
-
aljabar
A super generic, super experimental linear algebra library
-
modulo-n-tools
modulo tools
-
kingmaker
A modular, performant, social choice framework for the simulation, computation, and analysis of strategic voting
-
rust_decimal_ext
Decimal number implementation written in pure Rust suitable for financial and fixed-precision calculations
-
klein
Bindings to the Klein PGA3D library
-
qlora-gemm-c64
c64 (complex f64) matrix multiplication for qlora-gemm - maintained fork using qlora-paste
-
lettuces
A grid logic crate combining Hexx and custom logic for square and isometric grids to provide a unified grid logic crate
-
piston3d-construct
higher order functional programming with homotopy maps to construct 3D geometry
-
fastnd
A numpy alternative made in rust, for rust
-
nalgebra-numpy
conversions between nalgebra and numpy
-
ryft-pjrt
Ryft bindings for PJRT
-
kalk_cli
A calculator that supports user-defined functions, variables and units, and can handle fairly ambiguous syntax
-
geom
2D geometry library
-
simple_mod_int
modint library
-
hypercpu
Distributed symbolic computation
-
precise-calc
A high precision calculator library and command line tool
-
sv4state
SystemVerilog 4-state value library
-
cpntt
Number Theoretic Transform for competitive programming
-
rustnomial
working with polynomials
-
infmachine_gen
The Infinite Machine generator library
-
avatar_graph
Avatar Graphs
-
treerite
Rust binding for treelite runtime (https://github.com/dmlc/treelite)
-
avx-bignum
Big integer arithmetic (U1024, U2048, U4096, I4096)
-
matrix-calc
matrix addition, subtraction and multiplication library
-
fancy_indexing
numpy's fancy-indexing for Rust linear algebra crates
-
mdarray-linalg-lapack
LAPACK backend for mdarray-linalg
-
symbolics_calculus
Calculus module for the symbolics computer algebra library
-
concrete-fftw
Safe wrapper around FFTW
-
geo-aid-json
Support for JSON output from Geo-AID
-
simplecalc
CLI calculator
-
lineic
Flexible linear interpolator for Rust
-
ark-test-curves
testing ark-ec & ark-poly
-
ndutest
the first test
-
blas-sys
The package provides bindings to BLAS (Fortran)
-
ihateintegrals
A computer algebra library for solving integrals
-
rivrs
Symbolic compiler for Rust
-
ftl-numkernel
designed to provide numerical operations and error handling for both real and complex numbers, also supporting arbitrary precision types
-
tnt
runtime validated proofs in number theory
-
scir-core
SciR core utilities: numeric tolerances, complex helpers, and shared test macros for the SciR ecosystem (SciPy rebuilt for Rust)
-
haversine-redux
Haversine formular library to determine the distances between two coordinates on the earth
-
dec-number
Decimal Floating Point Arithmetic for Rust
-
itying-add-lib
adding numbers
-
keystone-wasm
WASM bindings for Keystone financial computation
-
moonalloy
The oxidized scientific computing library for the 21st century
-
ruvector-graph-transformer-wasm
WASM bindings for ruvector-graph-transformer: proof-gated graph attention in the browser
-
calculator_alexandregomes3112
Lib test to calculator tests
-
rust_combinatorics
Combinatoric utilities and functions for rust
-
mraphics-native
The part of Mraphics that runs on native platforms
-
most_used_functions
most used fuctions such as input , mathematical operations
-
rs-lambda
A lambda calculus interpreter written in rust
-
bacon-sci-1
Scientific computing in Rust
-
bigint-base10
Experimental API for dealing with big integers in base-ten
-
diffusionx-cuda-kernel
cuda kernels for diffusionx
-
log2fix
no_std fixed-point base 2, e and 10 logarithm algorithm implementation
-
bitslice
transpose bits into and out of bitslice format, and perform various operations on bitsliced data
-
ospf-rust-math
A math utils for ospf-rust
-
dess-examples
DESS examples
-
gates
simulate logical gates
-
lagrange-interpolation
Lagrange's Interpolation Formula
-
rstm-programs
focuses on providing various structures and utilities for programs within rstm
-
stack-algebra
Stack-allocated lightweight algebra for bare-metal rust
-
plummerprimes
Builds, Runs, and reports benchmarks from https://github.com/PlummersSoftwareLLC/Primes
-
rstmt-traits
Various traits used to establish the foundation of the rstmt framework
-
rust-expression
Calculator and solver for linear equations
-
container-broadcast
analog of Julia's broadcast interface
-
rufft
A pure rust FFT library !
-
crum
Tensors, Matrices and Complex numbers for numerical analysis
-
bens_number_theory
A sample Rust project for number theory stuff (I'm using this to learn Rust)
-
raa_tt
Proves sentences of propositional calculus
-
lsode
Solve systems of differntial equations using LSODE subroutine from ODEPACK written in Fortran
-
ft_lib
Manual implementation of some math functions
-
transforms
A transform library to track reference frames and provide transforms between them
-
dec-number-sys
Rust bindings for The decNumber C library by IBM Fellow Mike Cowlishaw
-
tuppu-expr
Symbolic expression system for Tuppu Nabu
-
smt_sb-rs
SMT Simple Binding
-
gorf-blc2
Lambda calulcus backend library
-
nostdhf
Polyfills the missing methods on f32 and f64 in no_std environments
-
accelerate-general
A general matrix and vector operations library using Apple's Accelerate framework
-
qcd-sme
numerical library for the screened massive expansion of QCD
-
oscirs_linalg
GPU accelerated linear algebra crate for scientific computing
-
simple_2d_vector
two-dimensional vectors in Rust
-
unitdc
A dc-like arbitrary precision quantity calculator
-
bigraph
Different representations with implemented operations on bigraphs
-
rstm-tape
A generic state implementation and its supporting interfaces
-
plotters-fullerene
plotters fullerene and polyhedron for Rust
-
inertia
Inertia
-
symbolic_polynomials
manipulation of polynomials over the integers
-
dashu-ratio
A big rational library with good performance
-
mathematics_table
that will generate a math table of an integer given by the user
-
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!
-
icub3d_combinatorics
A collection of combinatorics utilities
-
glar-gemm-c64
high performance cpu kernels
-
onlinecode
"Online Codes", a type of Fountain Code
-
arithmetic_parser_kma
Arithmetic expression calculator parser
-
dd_maths_traits
Strongly recommended to avoid using while in development. No semver guarantees.
-
wmathrs
mathematical crate
-
CLI_Project_Scott_Coakley
CLI Project in Rust
-
mixingcut
A program to solve the MAXCUT SDP Relaxation
-
max_len_base_10_as_usize
Trait offering constant maximum lengths of primitive integers as usize
-
divisors
A blazing fast library to find all divisors of a natural number
-
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… -
caliphui
calibrate and convert pH measurements using a two point method
-
path_semantics_std
type checked implementation of the standard dictionary of path semantics using constrained functions
-
bubblemath
A collection of mathematical algorithms in pure Rust
-
del-geo-core
2D/3D geometry utility codes
-
tmn
Instrument for working with complex numbers and quaternions
-
fj-math
Early-stage b-rep CAD kernel
-
ida
A pure Rust port of the Implicit Differential-Algebraic solver from the Sundials suite
-
rmath-cli
cli calculator
-
exp_root_log
Fast and interpretable function approximation with exp-root-log basis
-
cli_calculator
A basic cli calcuator
-
adv_linalg_lib
Core library for Adv_LinAlg procedral macros
-
lapacke
The package provides wrappers for LAPACKE (C)
-
generic_fixedpoint
Generic fixed-point numbers
-
nut_sys
Wrapper for Number-Theory-Utils C library
-
inexor-rgf-plugin-arithmetic
Inexor - Reactive Graph Flow - Plugin - Arithmetic
-
dimensionals
Rust native generic, flexible n-dimensional array
-
numerous
A set of tools to finding and classifying special numbers
-
complex-number
A basic implementation of complex numbers in rust
-
awint_core
Core no-std and no-alloc
awintfunctionality -
sophus_lie
Lie groups in 2D and 3D: rotations, translations, etc
-
crlibm
Binding to CRlibm, a correctly rounded math lib
-
ec_core
utils library for working with with ellipitic curves (in short words, implements the modular math used in elliptic curve operations)
-
ga3
Common types for 3D geometric algebra
-
fenris-traits
Core traits used by fenris
-
reuler
Solutions to Project Euler in Rust
-
solverforge-service
JVM lifecycle management for SolverForge
-
i_mth
A math library continuously under development made for use in particle and ridgid body dynamics and statics
-
metis-sys
Raw FFI to METIS, the serial graph partitioner and fill-reducing matrix orderer
-
core-math-sys
Generate bindings to CORE-MATH
-
linear_algebra
basic linear algebra operations in Rust
-
conclave-room
Logic for a Conclave Room
-
min_infmachine_exec
The Minimalistic Infinite Machine Executor and Debugger
-
gluex-lumi
calculate luminosity data for the GlueX experiment
-
osqp-rust-sys
c2rust(osqp-sys)
-
gap_solver
A solver for the generalized assignment problem
-
qsim-solvers
Power flow solvers (DC, AC) for qsim
-
bempp-quadrature
Simplex quadrature rules and boundary element singular quadrature
-
modtype
Macros that implement modular arithmetic integer types
-
ext-ops
General purpose arithmetic operator traits which are missing from the standard library
-
hypersphere
4D primitives for rotation and projection
-
sphrs
Spherical harmonics and solid harmonics
-
gaussiant
Gaussian integers
-
facto
Integer factorization and prime certification
-
matrix42
A linear algebra library developed as a project in the 42 ecosystem
-
xfft
Fast Fourier Transforms
-
yttria-coding
A mathematical coding library tailored for use with the yttria set of libraries
-
oldies-xppaut
XPPAUT bifurcation analysis revival in Rust - Hopf detection, phase portraits
-
microcheby
Single variable function approximation using Chebyshev polynomials. Embedded friendly and no_std compatible.
-
hop-mix
Batch polynomial mixers for hop-actions
-
prime-data
Prime Number Data Library
-
polar
A command-line calculator that can also convert between units
-
rlst-proc-macro
Proc macros for a Rust native linear algebra library
-
algebrust
basic linear algebra operations
-
levitate
Just works solution to numbers, mainly aimed at floats and mathematical use cases
-
nalgebra-glm
A computer-graphics oriented API for nalgebra, inspired by the C++ GLM library
-
gml
Graphics Math Library. Generic Vector and Matrix Math library targetting graphics applications.
-
infmachine_examples
Examples for the Infinite Machine
-
rgla
A linear algebra library for graphics that implements rotors instead of quaternions
-
slop-sumcheck
Sumcheck protocol implementation for multilinear polynomials
-
rcalc_lib
Mathematical expression calculation library
-
mathhook-core
Core mathematical engine for MathHook - expressions, algebra, and solving
-
bigint-benchmark
Benchmarks for big integer implementations
-
ferray-polynomial
Polynomial operations (evaluation, fitting, roots, arithmetic) for ferray
-
predicatechecker
Check that a predicate is true if another is
-
feos-core
Core traits and functionalities for the
feosproject -
rust-miller-rabin
Miller-Rabin primality test
-
bignumber
arbitrary-precision decimal and non-decimal arithmetic
-
rs-math
math library, a math library written in Rust. Write in a native way as much as possible in this math library, reducing the use of third-party libraries. There may be some errors in this math library…
-
const_num_bigint
const bigint
-
miscmath
will be a collection of general math functions and linear algebra structures like vectors and matrices
-
mpdec-sys
FFI bindings for libmpdec
-
vec_arith
Powerful vector/matrix arithmetic library written in Rust
-
acme-tensor
A comprehensive tensor library for Rust with support for automatic-differentiation
-
closure_calculus
Closure Calculus
-
ffts
Rust binding for ffts (The Fastest Fourier Transform in the South)
-
kolakoski_algorithms
Efficient algorithms for the Kolakoski sequence
-
calculator_101
contains modules to perform basic arithmetic operation
-
exact-conv
Exact conversions between integer and floating point types
-
euclidean
A collection of operations for euclidean geometry in three dimensions
-
mdarray-linalg-blas
BLAS backend for mdarray-linalg
-
oxiblas-ffi
C FFI bindings for OxiBLAS - a pure Rust BLAS/LAPACK library
-
codebreaker-solver
A solver for codebreaker aka. bulls and cows. Generates guesses which will guess the code in at most 5 tries.
-
logicaffeine-lexicon
English vocabulary types and compile-time lexicon lookup for logicaffeine
-
ducc0
Wrapping ducc, the Distinctly Useful Code Collection
-
bicubic
A base for bicubic interpolation
-
oxilean-std
OxiLean standard library
-
lodestone_python
User friendly magnetic field calculations in Rust
-
analit
Add another dimension to your Rust project with analog geometric literals
-
codemonk-primes-cli
A command-line utility for finding prime numbers
-
argmin-observer-slog
slog logging observer for argmin
-
hmath
Big Integers and Rational Numbers
-
hints
computing weighted threshold signatures
-
is_signed_trait
Trait for IS_SIGNED associated constant
-
polyhedron-faces
polyhedron faces for Rust
-
quantique
Pragmatic geometric algebra core with runtime signatures
-
ios_calculator
iOS calculator implementation
-
si_units
handling arithmetic with SI units
-
oxiz-math
Mathematical foundations for OxiZ SMT solver
-
rsl-polynomials
A re-write of GSL's Polynomials Routines in Rust
-
swh_graph_topology
Collection of topology analysis utilities based on swh-graph
-
hampel
Sequential outlier detection and removal using Hampel identifiers
-
glar-gemm-c32
high performance cpu kernels
-
alga
Abstract algebra for Rust
-
qlora-gemm-f32
f32 matrix multiplication for qlora-gemm - maintained fork using qlora-paste
-
sum_range
The sum of all consecutive numbers, both even and odd
-
gpurs
GPU acceleration/linear algebra crate for scientific computing
-
unsafe_math_trait
unsafe_math trait
-
Gen_Prime
A way to transform a hash to a prime number
-
usagi
Common algorithms and utilities library for Rust
-
simple_3d_vector
three-dimensional vectors in Rust
-
corries
Library/framework for 1D-hydrodynamics simulations using Riemann solvers
-
russell_nonlin
Numerical continuation methods to solve nonlinear systems of equations
-
strafe-error
Error types for strafe
-
acgmath
A linear algebra and mathematics library for computer graphics. A fork of
cgmath. -
rustyhdf5-py
Python bindings for rustyhdf5 — a pure-Rust HDF5 library
-
vec3D
A minimal 3D Vector library in Rust
-
temporal-lead-solver
Temporal computational lead via sublinear local solvers for diagonally dominant systems
-
signed
working with signed numbers' absolute values avoiding confusion
-
val_unc
A package for handling quantities with uncertainties
-
vectorial
general-purpose vector math
-
factordb
Rust wrapper for FactorDB API
-
rustitude-core
create and operate models for particle physics amplitude analyses
-
gorf-lcobj
Lambda calulcus backend library
-
cellular_raza-core
Cellular simulation tool
-
hebrides
Implementations for the real numbers, complex numbers, and basic linear algebra
-
faer-sparse
Basic linear algebra routines
-
matriz
Zero allocation Rust linear algebra library
-
pire-gemm-s8u8s32
high performance cpu kernels
-
tuppu-render
Rendering backends for scene visualization
-
tblis
wrapper in Rust
-
complex-plane
complex numbers and their associated operations in the complex plane
-
inexor-rgf-model-arithmetic
Inexor - Reactive Graph Flow - Model - Arithmetic
-
bluebird
that defines common SKI combinators from Combinatory Logic
-
math-fun
A package providing mathematical functions commonly used in science and engineering
-
irox-unsafe
irox (unsafe) Rust Tools & Libraries
-
gardiz
integer geometry on 2D planes, focused on games
-
spaceform
A cross-platform SIMD-accelerated maths library for 3D graphics
-
geo-aid-math
The mathematics engine for Geo-AID
-
antic-sys
Bindings to the Antic library
-
cblas
The package provides wrappers for CBLAS (C)
-
bdrk_geometry
Geometry Helpers
-
fastfloat
Fast-math wrapper and convenient numeric functions for approximate floating point operations in Rust
-
ferrix
matrix library for Rust
-
find-real-roots-of-polynomial
find all real roots of a polynomial
-
primesieve_wrapper
Wrapper for Primesieve C library
-
poly_interp
but powerful polynomial library focused on interpolation between points
-
calcium-oxide
Calc-ium Oxide, a simple stack based command line calculator written in rust
-
computable-real
Computable real number
-
calculat0r
Cli calculator app
-
const-decimal
Integer-backed decimals with constant precision
-
ring-math
Polynomial ring math over scalar finite fields
-
graph_gen
Generate pseudo-random graphs based on the Erdos-Renyi G(n,p) model
-
kahan_pairs
Generate pairs of integers
-
mini-kanren
miniKANREN in Rust
-
crabsformer
fundamental library for scientific computing with Rust, highly inspired by NumPy
-
primality-test
Primality Test crate
-
const-time-bignum
A constant time bignum library that operates fully on the stack, effectively eliminating the side channel attack vector
-
geologic
Mathematical and geometrical abstractions with a focus on ergonomics
-
elr_primes
prime number iterator and methods for basic calculations with prime numbers
-
rapier2d
2-dimensional physics engine in Rust
-
primeutils
A collection of tools for working with prime numbers
-
calcifer-server
Backend logic for the Calcifer project
-
wgebra
Composable WGSL shaders for linear algebra
-
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++)
-
hekate-math
A high-performance, constant-time implementation of binary tower fields (F(2^k)) optimized for GKR-based provers, Virgo, and Binius protocols
-
spsolve
Solve sparse systems of linear equations
-
mermaid
Experimental Linear Algebra
-
junglefowl
Brutally murdering Rust's type system one proof at a time
-
gf2poly
GF(2) polynomial arithmetic
-
infallible_tobigint
Infallible ToBigInt/ToBigUint conversion traits for num-bigint
-
big-num-manager
Rust big num manager
-
primal-sieve
A high performance prime sieve
-
ferray-fft
FFT operations (fft, ifft, rfft, fftfreq, plan caching) for ferray
-
nonscalar
Functions and types for operating on nonscalar values like vectors and complex numbers
-
fj-app
Early-stage, next-generation, code-first CAD application. Because the world needs another CAD program.
-
polynomials_pro
pro-level polynomials
-
nice-numbers
Small library for number sequences
-
math_vector
3D vector class
-
totsu_f32cuda
CUDA linear algebra operations for
totsu/totsu_core -
qty-macros
Macros supporting the implementation of quantities
-
oldies-modeldb
ModelDB model importer for legacy neural models in Rust
-
linalg-rs
Linear algebra in Rust!
-
fibo
Compute the N-th Fibonacci number with arbitrary number precision
-
strafe-type
Types for strafe
-
versioned-feature-core
Minimal logic for versioned features
-
primerug
A prime k-tuple finder based on the rug crate
-
rstsr-linalg-traits
An n-Dimension Rust Tensor Toolkit
-
safe_decimal
that solves the recurring decimal problem with fractions
-
sort_rust
sort for Rust
-
num_vector
Enabling basic vector arithmetic operations
-
propositional
Logic
-
ema
using exponential moving averages
-
rustbot
My package for aimbot calculations / vector math
-
nano-gemm
Small matrix multiplication
-
num_base
manipulating with numbers (integers) in different bases
-
slop-basefold
BaseFold polynomial commitment scheme for SLOP
-
nano-gemm-codegen
Small matrix multiplication
-
next_prime
A function that returns the next prime greater than or equal to its argument
-
qlora-gemm-c32
c32 (complex f32) matrix multiplication for qlora-gemm - maintained fork using qlora-paste
-
gateutil
basic utilities for GateSim
-
nalgebra-macros
Procedural macros for nalgebra
-
xcomplex
A complex number library
-
cudd
Cudd Rust library
-
num-irrational
num-irrationalis based onnumand extends it with support for several kinds of irrational numbers -
geometric
A very simple vector and matrix library built on the vecmath crate
-
math_rust
A Math library for vectors
-
mkl-rs-sys
MKL bindings for Rust
-
glucose
multipurpose math and physics crate for my projects
-
num-rug-adapter
An adapter to use num crate where rug is needed
-
russell_pde
Essential tools to solve partial differential equations; not a full-fledged PDE solver
-
chikasolver
Chika Solver
-
calculator_util
that helps you evaluating mathmatical expressions
-
nova-math
Vector and matrix math utilities for nova-engine
-
vsop87
Pure Rust VSOP87 algorithm implementation. Includes all VSOP87 algorith versions: VSOP87, VSOP87A, VSOP87B, VSOP87C, VSOP87D and VSOP87E. VSOP87 are a family of algorithms used to predict the position of planets in the…
-
fuzzylogic
operations for fuzzy set theory
-
sylvan_number
My own big number implementation, just for my own uses
-
guff-sharefiles
Package IDA-encoded data in a portable file format
-
erosion
plot fourier curves and functions
-
nutils-poly
Low-level functions for evaluating and manipulating polynomials
-
sciport-rs
Rust port of scipy
-
polynom
handling polynomials
-
mathhook-macros
Procedural macros for MathHook - expr!, symbol!, symbols!, function!
-
faer-lu
Basic linear algebra routines
-
gorf-blc
Lambda calulcus backend library
-
irox-dot
DOT Graph Description Language writer, compatible with GraphViz
-
ark-vesta
The Vesta prime-order elliptic curve
-
numrs
A numerical computations library for Rust
-
yali
LargeInt Library
-
fpn
Fixed point number
-
rust-gmp
Rust bindings for GMP
-
matrix-simp
A linear algebra package (WIP)
-
horner
Evaluate polynomials using Horner's method
-
faer-qr
Basic linear algebra routines
-
euphony-mix
mixing logic for euphony compositions
-
primenumbe-rs
Generate the nth prime number
-
tuppu-reactive
Reactive bindings for scene graph
-
mosekcomodel-optserver
MOSEK OptServer backend for mosekcomodel
-
conum
big numbers, specified by arbitrary digit widths
-
polynomical
tiny polynomial manipulation library
-
primality
Check if a number is prime
-
shanksbot-rs
ShanksBot shown by Matt Parker in https://www.youtube.com/watch?v=DmfxIhmGPP4
-
factor-rs
A command-line program for listing the prime factors of a number or fraction
-
viewp
A program is get any argument, that generates prime. it argument be number. This Program is Test Stage.
-
laddu-core
Core of the laddu library
-
ferray-linalg
Linear algebra operations (decompositions, solvers, einsum) for ferray
-
inti25_rust_lib1
Rust example by inti25
-
exponent-time-curve
Time-based AMM curve
-
cellular_raza
Cellular Agent-based Modeling from a Clean Slate
-
fj-operations
Early-stage, next-generation, code-first CAD application. Because the world needs another CAD program.
-
melius-vectors
2-4 dimensional vectors that can be easily created and manipulated
-
mosekcomodel_highs
HIGHS backend for mosekcomodel
-
fftw3
Bindings to FFTW3: the Fastest Fourier Transform in the West. This library aims to expose the full power of FFTW3 in high-performance, safe and idiomatic manner. NB. FFTW3 is licensed GPLv2 (or later)…
-
glar-base
high performance cpu kernels
-
logic-long
Supercell's Logic Long implemented in Rust
-
horner-eval
A macro for evaluating polynomials via Horner's rule
-
fdecimal
Arbitrary precision fast decimal numbers
-
primeshor
project to explore prime numbers and factorization
-
rprime
useful functions for prime numbers
-
prime_tools
Generate primes, get prime factors, check primality, and other useful prime-related utilities
-
rstmt-core
the core modules for the rstmt framework
-
lapacke-sys
The package provides bindings to LAPACKE (C)
-
oldies-gui
Modern GUI for OldiesRules - Real-time visualization with egui
-
quantrs2-symengine-sys
Low level bindings to the symengine library (fixed for macOS)
-
cnfgen-nand-opt
Generate CNF for circuits