Lib.rs

rust_decimal

Decimal number implementation written in pure Rust suitable for financial and fixed-precision calculations

num-bigint

Big integer implementation for Rust

bigdecimal

Arbitrary precision decimal numbers

statrs

Statistical computing library for Rust

uint

Large fixed-size integer arithmetic

kurbo

A 2D curves library

num-traits

Numeric traits for generic mathematics

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…

ruint

Unsigned integer type with const-generic bit length

rug

Arbitrary-precision integers, rational, floating-point and complex numbers based on GMP, MPFR and MPC

crypto-bigint

Pure Rust implementation of a big integer library which has been designed from the ground-up for use in cryptographic applications. Provides constant-time, no_std-friendly implementations…

nalgebra

General-purpose linear algebra library with transformations and statically-sized or dynamically-sized matrices

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.

euclid

Geometry primitives

roots

well known algorithms for numerical root finding

rapier3d

3-dimensional physics engine in Rust

lapack

The package provides wrappers for LAPACK (Fortran)

peroxide

Rust comprehensive scientific computation library contains linear algebra, numerical analysis, statistics and machine learning tools with farmiliar syntax

fend

Arbitrary-precision unit-aware calculator

num-bigint-dig

Big integer implementation for Rust

micromath

Embedded-friendly math library featuring fast floating point approximations (with small code size) for common arithmetic operations, trigonometry, 2D/3D vector types, statistical analysis…

mint

Math interoperability standard types

faer

linear algebra library

num-complex

Complex numbers implementation for Rust

yahoo_finance_api

adapter for the yahoo! finance API to fetch histories of market data quotes

biodivine-lib-bdd

thread-safe implementation of basic binary decision diagrams

num-dual

Generalized (hyper) dual numbers for the calculation of exact (partial) derivatives

common_traits

Traits to write generic functions on different numeric types, with atomic support, and other features

ultraviolet

do linear algebra, fast

russell_lab

Scientific laboratory for linear algebra and numerical mathematics

substrait

Cross-Language Serialization for Relational Algebra

argmin

Numerical optimization in pure Rust

num-modular

efficient integer division and modular arithmetic operations with generic number types. Supports various backends including num-bigint, etc

simba

SIMD algebra for Rust

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…

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

hexasphere

evenly tile hexagons on a sphere

lambdascript

Instructional program detailing the beta reduction of typed and untyped lambda terms

simple_moving_average

moving average (SMA) algorithms

parry3d-f64

3 dimensional collision detection library in Rust. 64-bits precision version.

ode_solvers

Numerical methods to solve ordinary differential equations (ODEs) in Rust

meshx

A mesh eXchange library with conversion utilities for popular mesh formats

substrate-fixed

Fixed-point numbers

sci-rs

Rust scientific analysis library similar to SciPy

plotpy

Rust plotting library using Python (Matplotlib)

gauss-quad

applying Gaussian quadrature to integrate a function

hexx

Hexagonal utilities

feos

framework for equations of state and classical density functional theory

enterpolation

creating and computing interpolations, extrapolations and smoothing of generic data points

feanor-math

number theory, providing implementations for arithmetic in various rings and algorithms working on them

russell_sparse

Solvers for large sparse linear systems (wraps MUMPS and UMFPACK)

real_time_fir_iir_filters

Real-time FIR and IIR filters designed for use with vst's

lambert_w

Fast and accurate evaluation of the Lambert W function by the method of T. Fukushima.

twenty-first

Collection of mathematics routines and cryptography for the twenty-first century

typed_floats

Types for handling floats with type checking at compile time

num

A collection of numeric types and traits for Rust, including bigint, complex, rational, range iterators, generic integers, and more!

glamour

Strongly typed linear algebra with glam

GSL

binding for the GSL (the GNU scientific library)

strict_types

Strict types: confined generalized algebraic data types (GADT)

skillratings

Calculate a player's skill rating using algorithms like Elo, Glicko, Glicko-2, TrueSkill and many more

grib

GRIB format parser for Rust

lin_alg

Vector, matrix, and quaternion operations for general purposes

russell_tensor

Tensor analysis, calculus, and functions for continuum mechanics

ark-test-curves

testing ark-ec & ark-poly

ibig

A big integer library with good performance

noisy_float

Contains floating point types that panic if they are set to an illegal value, such as NaN

blas-src

The package provides a BLAS source of choice

mahc

riichi mahjong calculator library and CLI

num-quaternion

Quaternion numbers implementation for Rust

varpro

A straightforward nonlinear least-squares fitting library which uses the Variable Projection algorithm

splines

Spline interpolation made easy

rebop

A fast stochastic simulator for chemical reaction networks

jlrs

bindings to the Julia C API that enable Julia code to be called from Rust and more

quantities

Unit-safe computations with quantities

microlp

A fast linear programming solver library

number_prefix

numeric prefixes (kilo, giga, kibi)

machine-prime

ne plus ultra primality testing for machine-sized integers

lambda_calculus

zero-dependency implementation of pure lambda calculus in Safe Rust

stacked_linear_algebra_graph

Embedded in-memory graph using sparse linear algebra

splr

A modern CDCL SAT solver in Rust

arpfloat

Arbitrary-precision floating point library

cgmath

A linear algebra and mathematics library for computer graphics

lp_parser_rs

parser for the LP file format

single-svdlib

port of LAS2 from SVDLIBC

i_float

This fixed float math library provides an efficient and deterministic solution for arithmetic and geometric operations

stv-rs

Single Transferable Vote implementation in Rust

lilt

running interruptable, transition based animations as a function of time

scientific

Arbitrary precision scientific number (no_std capable, in pure Rust)

geonum

geometric number library supporting unlimited dimensions with O(1) complexity

grb

API for Gurobi optimizer

ganesh

Function minimization in Rust, simplified

sliding_features

Modular sliding window with various signal processing functions and technical indicators

cubecl

Multi-platform high-performance compute language extension for Rust

malachite

Arbitrary-precision arithmetic, with efficient algorithms partially derived from GMP, FLINT, and MPFR

tagref

maintain cross-references in your code

adic

Arithmetic and rootfinding for p-adic numbers

joker_calculus

Joker Calculus in Rust

ndhistogram

multi-dimensional histogramming for Rust

mathru

Fundamental algorithms for scientific computing in Rust

satkit

Satellite Toolkit

quaternion-core

quaternion operations and interconversion with several attitude representations

scirs2-sparse

Sparse matrix module for SciRS2

icao-wgs84

performing geometric calculations on the WGS84 ellipsoid

fastnum

Fast decimal numbers library

hexgridspiral

Hexagonal Cube-Coordinate System with Spiralling Integer Tile Identifiers

bva

manipulating and doing arithmetics on bit vectors of fixed but arbitrary size

rust_eth_kzg

cryptography needed for EIP-7594

ndarray-conv

N-Dimension convolution (with FFT) lib for ndarray

mini-calc

A Fully-Featured Configurable (mini) Rust Calculator

chemfiles

Modern library for chemistry trajectories reading and writing

quaternion

type agnostic quaternion math library designed for reexporting

pathfinder_geometry

Basic SIMD-accelerated geometry/linear algebra

csgrs

Constructive solid geometry (CSG) on meshes using BSP trees in Rust

rsparse

solving sparse linear systems using direct methods

stlrs

Seasonal-trend decomposition for Rust

yume-pdq

Optimized kernels from hashing to vectorized or Vulkan shader-based exact matching for near real-time high-throughput high-recall PDQ-based image screening, including a hand-vectorized…

emath

Minimal 2D math library for GUI work

geo-aid

designed to generate geometrical figures based on given rules

rustalib

technical indicators for financial analysis, similar to TA-Lib

mel_spec

Mel spectrograms aligned to the results from the whisper.cpp, pytorch and librosa reference implementations and suited to streaming audio

concrete-fft

pure Rust high performance fast Fourier transform library

fpdec

Decimal fixed-point arithmetic

RustedSciThe

RustedSciThe is a Rust library for symbolic and numerical computing: parse string expressions in symbolic representation/symbolic function and compute symbolic (analytical) derivatives…

engineering-repr

Numeric conversions for engineering notation (1.23k) and the RKM code variant (1k23)

metis

Idiomatic wrapper for METIS, the serial graph partitioner and fill-reducing matrix orderer

mzsignal

mass spectrometry signal processing

ndrustfft

N-dimensional FFT, real-to-complex FFT and real-to-real DCT

noether

Abstract algebraic structures for Rust

evar

Modern ergonomic math calculator inspired by eva

nextsv

Next semantic version calculator

diffusionx

random number/stochastic process simulation with high performance

honeycomb-core

Core structure implementation for combinatorial maps

clarabel

Conic Interior Point Solver for Rust / Python

cpc

evaluates math expressions, with support for units and conversion between units

calc_rational

CLI calculator for rational numbers

owens-t

Owen's T Function and Bivariate Normal CDF computations

naivesat

Few solvers that uses the Gate project

oxidd

A safe, concurrent, modular, and performant decision diagram framework

temp-converter

terminal temperature unit converter between Celsius, Fahrenheit and Kelvin

ncube

Generalized Hypercube Visualizer

rusty_neat

Pretty good NEAT implementation

maths-rs

A linear algebra library for gamedev and graphics

erydanos

Optimized routines for ARM NEON and SSE

num-prime

Generic and optimized primality test, factorization and various number theoretic functions with arbitrary precision based on num

RustQuant_autodiff

quantitative finance

num-bigfloat

Increased precision floating point numbers implemented purely in Rust

yata

Technical Analysis library. For rust now.

startin

A Delaunay triangulator for terrains

angle-sc

performing accurate and efficient trigonometry calculations

balanced-ternary

manipulate balanced ternary values

coin_cbc

Rust bindings to the CoinOR CBC MILP Solveur using the C API

polynomial-ring

A polynomial implementation

linfa-linalg

Pure-Rust implementation of linear algebra routines for ndarray

hooo

Propositional logic with exponentials

mosek

Rust API for MOSEK optimization tools

hexing

A basic Rust library to manipulate hexagonal grids

primitive_fixed_point_decimal

Primitive fixed-point decimal types

krnl

Safe, portable, high performance compute (GPGPU) kernels

parry3d

3 dimensional collision detection library in Rust

rational

Minimalistic library for rational numbers

lstsq

Return the least-squares solution to a linear matrix equation

microgemm

General matrix multiplication with custom configuration in Rust. Supports no_std and no_alloc environments

rapier3d-f64

3-dimensional physics engine in Rust

prima_datadog

An opinionated library to share code and approach to Datadog logging in prima.it

kalc-cli

kalc - quick basic math kalculator in cli

directx_math

translation of DirectXMath, a SIMD linear algebra library for use in games and graphics apps

easyfft

providing an easy FFT API for arrays and slices

rustitude

create and operate models for particle physics amplitude analyses

stats-ci

A pure Rust library for computing and working with confidence intervals on sample data

hyperdual

Fully-featured Dual Number implementation with features for automatic differentiation of multivariate vectorial functions

series

Laurent series in a single variable

mantaray

Ray-tracing solver for ocean surface gravity waves that integrates the wave ray equations over spatially varying currents and bathymetry

diffsol

solving ordinary differential equations (ODEs) in Rust

rita

2D and 3D Randomized Incremental Triangulation Algorithms

autodj

Automatic Differentiation Library

rustneuro

neural signal analysis and feature extraction for scientists who require fast computation

scirs2-integrate

Numerical integration module for SciRS2

kalker

A calculator that supports user-defined functions, variables and units, and can handle fairly ambiguous syntax

num-integer

Integer traits and functions

float_next_after

A trait for native rust f64/f32 nextafter

honeycomb-kernels

Meshing kernel implementations using combinatorial maps

serde-ndim

Serde support for n-dimensional arrays from self-describing formats

const-primes

Work with prime numbers in const contexts. Prime generation, primality testing, prime counting, and more.

figures

A math library specialized for 2d screen graphics

pihex

Arbitrary place hexadecimal digits viewer of pi written in Rust

shor

Shor's factoring algorithm written in rust

ggmath

optimized generic-graphics-math

vector2math

Traits for doing 2D vector geometry operations using standard types

mappers

Pure Rust geographical projections library

matrix-sdk-qrcode

encode and decode QR codes for interactive verifications in Matrix land

numbat

A statically typed programming language for scientific computations with first class support for physical dimensions and units

nalgebra-spacetime

Spacetime Extension for nalgebra

tiny-solver

Factor graph solver

csc

Command Line Scientific Calculator

russell_stat

Statistics calculations and (engineering) probability distributions

flavio

welcomes you

libnoise

performant, and customizable procedural noise generation library

harness-algebra

algebraic structures

inari

interval arithmetic

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…

subsphere

Sphere tessellation toolkit

null-kane

currency crate with the option to add your own currency localization logic

p3-keccak-air

Plonky3 is a toolkit for implementing polynomial IOPs (PIOPs), such as PLONK and STARKs

d3_delaunay_rs

A port of D3/d3-delauany

reckoner

A high level arbitrary precision arithmetic library supporting integer and rational numbers

bigraph

Different representations with implemented operations on bigraphs

graphics-shapes

Shapes for graphics

cli-calc-rs

A CLI calculator made in Rust

json-e

A data-structure parameterization system for embedding context in JSON objects

mech-math

Math library for the Mech language

fib-rs

A fast Fibonacci number calculator

noiz

configurable, blazingly fast noise library built for and with Bevy

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.

fasteval

Fast evaluation of algebraic expressions

lean-sys

Bindings to Lean 4's C API

exp-rs

no_std expression parser, compiler, and evaluation engine for math expressions designed for embedded, with qemu examples

graphrs

package for the creation, manipulation and analysis of graphs

russell_ode

Solvers for ordinary differential equations and differential algebraic equations

logru

A small, embeddable and fast interpreter for a subset of Prolog

arithmetic-eval

interpreter for arithmetic expressions

uniform-cubic-splines

uniform cubic spline evaluation and inversion

swift_vec

A convenient and comfortable vector maths crate that supports 2D, 3D, and 4D matrices and vectors - along with additional scalar math

rink

Unit conversion tool, similar to frink

cube3d

A GUI-based 3D cube rotation demo

hakari

Manage workspace-hack packages that do feature unification inside workspaces

amplify_num

Amplifying numeric types: big-sized and bit-sized integers

rugfield

generating Gaussian Random Fields using the circulant embedding method

faer-entity

Basic linear algebra routines

zagreb-lib

analyzing graph properties using the Zagreb index and Hamiltonian criteria

graphblas_sparse_linear_algebra

Wrapper for SuiteSparse:GraphBLAS

number-general

A generic number type for Rust which supports basic math and (de)serialization

single_algebra

A linear algebra convenience library for the single-rust library. Can be used externally as well.

bc

Use bc in the Rust Programming Language

yoda-calculator

command line app that acts as a scientific calculator, operating through commands instead of buttons

starnav

A comprehensive navigation system for celestial navigation in Star Citizen

metallic

C math functions from scratch

cnfgen

Generate DIMACS CNF formula from operations

nacfahi

Simpler, but less error-prone API for levenberg-marquardt optimization crate

rewriter

rewriting files

moontool

John Walker's moontool.c astronomical calculation routines, extracted and ported to Rust

popgetter-cli

CLI for popgetter

cjseq

Create/process/modify CityJSONSeq

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

gemlab

Geometry and meshes laboratory for finite element analyses

quadraturerules

quadrature rules library

raa_tt

Proves sentences of propositional calculus

datas

data structures and algorithms and data analisys

boostvoronoi

Boost voronoi ported to 100% rust

matrixable

Traits and structs extending capabilities of matrix-like structures

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.

camera-intrinsic-model

Camera Intrinsic Models

fractions-rs

Fractions numbers implementation for Rust

wartcl

A minimal embeddable Tcl-like language

cubecl-reduce

CubeCL Reduce Algorithms

kzg-rs

KZG point evaluation

area_crate

A comprehensive geometry calculation library for areas, perimeters, surface areas, and volumes

linfa-clustering

A collection of clustering algorithms

krabmaga

A modern developing art for reliable and efficient Agent-based Model (ABM) simulation with the Rust language

twibint

arithmetic on arbitrarily large integers. Provides Python bindings as well.

sobol_burley

A seedable Owen-scrambled Sobol sequence

Rust_Simple_DNN

making optimized modular neural networks in rust

numerics-rs

Blazing fast numerical library written in pure Rust

calculator-backend

calculator backend in Rust

al-jabr

An n-dimensional linear algebra library

fasteval2

Fast evaluation of algebraic expressions

prime_factorization

Prime factorization up to 128 bit integers

blas

The package provides wrappers for BLAS (Fortran)

tilezz

work with perfect-precision polygonal tiles built on top of complex integer rings

taz

evaluate a mathematical expression

rocm-rs

Rust bindings for AMD ROCm libraries

list_math

doing math on a list including average, smallest, largest, and standard deviation

reference-interval

reference interval helpers a.k.a. reference range helpers.

geo-nd

Traits and types particularly for 2D and 3D geometry with implementations for [float] and optionally SIMD

prime-factor

A prime number factorizer written in Rust

gf2_192

Arithmetic operations and polynomial interpolation over Galois fields GF(2^192)

kifmm

Kernel-independent fast multipole method

multicalc

Rust scientific computing for single and multi-variable calculus

irox

Tools & Libraries

ecolor

Color structs and color conversion utilities

cmn

accessing a collection of mathematical and cryptographic constants

pccc

Parallel-concatenated convolutional code

get-hash

Get hash of a string

ndarray_cg

Math for computer graphics based on ndarray. The approach used in ndarray for computer graphics math is highly flexible and performant, even though there are many specialized crates…

bare_metal_modulo

ModNum is a highly ergonomic modular arithmetic struct intended for no_std use

intel-mkl-src

Redistribution of Intel(R) MKL as a crate

volute

Boolean functions implementation, represented as lookup tables (LUT) or sum-of-products (SOP)

mwa_hyperdrive

Calibration software for the Murchison Widefield Array (MWA) radio telescope

RayBNN_DiffEq

Matrix Differential Equation Solver using GPUs, CPUs, and FPGAs via CUDA, OpenCL, and oneAPI

graph-cycles

Detect all cycles in a petgraph graph

ninterp

Numerical interpolation for N-dimensional rectilinear grids

const-fnv1a-hash

A #![no_std] crate for performing FNV1A-16/32/64/128 hashing on Rust stable at compile time

n_circular_array

An n-dimensional circular array

specialized-div-rem

specialized division algorithms for integer primitives

mutils

Mathematical-like utilities. Points, Sizes, Colours, maths operating on them. Things like that.

frunk_laws

contains laws for algebras declared in Frunk

symbolica

A blazing fast computer algebra system

iter_num_tools

Create simple iterators over non integer ranges. itertools + num = iter_num_tools

lex_sleuther

Sleuth out script languages by lexing

aspect360

This builds on the Ring360 to calculate aspect matches from target angles with orbs or an array of target aspect/orb pairs

linear_isomorphic

A set of traits to astract over linear-like types

rfa

A port ERFA to Rust

ellip

Elliptic integrals for Rust

strict-num

A collection of bounded numeric types

f256

Octuple-precision floating-point arithmetic

tensorrs

Tensors is a lightweight machine learning library in Rust

mathx

A mathematics library designed to work with no_std

rquant

A quantum computing library for qubit manipulation and observation

geom3

3d geometry classes

calc

CLI calculator app

flashlight_tensor

tensor library focused around matrix operations, *not* abandoned

bacon-sci

Scientific computing in Rust

rose-bitsets

Small, fixed-size bitsets for storing integers/indices

matrix_lib

easy to use library to operate on matrices

piecewise_polynomial

Fitting and interpolation with piecewise polynomials

string_calculator

A string calculator to compute formulas inside strings

pvz_interception_calculator

rewrite of the original PVZ Interception Calculator that calculates precise imp movement

ldpc-toolbox

aid in LDPC code design

kornia-imgproc

Image processing operations in Rust

vector3

dealing with 3D mathematical vectors

plane-split

Plane splitting

rmatrix_ks

matrix and some algebra in Rust

qhull

Rust bindings to Qhull

floccus

Formulae for air thermodynamic calculations

growth-and-decay

literally thrown together to solve problems on a math paper

anthem

A command-line application for assisting in the verification of answer set programs

laddu

Amplitude analysis made short and sweet

ballpark

Approximate comparisons for floating-point numbers

re_arrow_util

Helpers for working with arrow

pocket_prover

A fast, brute force, automatic theorem prover for first order logic

lair

Linear algebra in Rust

comfy-bounded-ints

Bounded-integer types focused on ergonomics and safety. (See README.md)

scirs2-signal

Signal processing module for SciRS2

simplify-polyline

Simplify polylines using Douglas-Peucker and radial distance algorithms. Port of the simplify-js library.

pointy

Minimal 2D geometry library

openblas-src

The package provides a source of BLAS and LAPACK via OpenBLAS

fj-export

Early-stage b-rep CAD kernel

tex2typst-rs

Converts LaTeX math to Typst math

dcim

dc improved - Expanded rewrite of a classic RPN calculator / esoteric programming language

robomath

A lightweight, efficient, and generic mathematics library for 3D applications, with a focus on robotics and simulation

integrator

A math library

rstm

focuses on building concrete implementations for Turing Machines

new_york_calculate_core

calculation some things

aprilgrid

Aprilgrid

Sph2-rs

An improved version of Sph-rs, that uses a mod to calculate the desired values

find_peaks

Find peaks that match criteria in 1D data

malachite-bigint

A drop-in num-bigint replacement based on malachite

lox-math

Mathematical utilities for the Lox ecosystem

skeid

a linear algebra library for game graphics and physics

ssimulacra2

metric

gamesman-nova

Research system generating datasets of sequential game states and associated features

malachite-base

A collection of utilities, including new arithmetic traits and iterators that generate all values of a type

katex-gdef-v8

fast use of KaTeX via V8 engine

iron-shapes

Basic data types and routines for computational geometry focused on VLSI chip design

rusttex

programmatically generating LaTeX documents

acme

Acme aims to provide a solid foundation for developing robust machine-learning systems in Rust

aviation_calc_util

assist with aviation related calculations

soilrust

A geotechnical engineering library for soil mechanics calculations in Rust

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

big_num_math

computations on large numbers

castep_model_generator_backend

A rust-written backend lib for edit and generation of lattice 3D-models compatible with CASTEP and Materials Studio

ratio-matrix

Ratio's matrix data library

root1d

One dimensional root finding algorithms

windows-numerics

Windows numeric types

colpetto

Async libinput wrapper

mindus

working with mindustry data formats (eg schematics and maps) (fork of plandustry)

oxidd-cli

Command line interface for OxiDD

single_rust

Single-cell analysis in Rust

dual_balanced_ternary

Dual Balanced Ternary Arithmetic

microcli

Bunch of random unrelated CLI tools

mdarray

Multidimensional array for Rust

reductionist