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