Lib.rs

num-traits

Numeric traits for generic mathematics

nalgebra

Linear algebra library with transformations and statically-sized or dynamically-sized matrices

euclid

Geometry primitives

matrixmultiply

General matrix multiplication for f32 and f64 matrices. Operates on matrices with general layout (they can use arbitrary row and column stride). Detects and uses AVX or SSE2 on x86…

num-integer

Integer traits and functions

number_prefix

Library for numeric prefixes (kilo, giga, kibi)

statrs

Statistical computing library for Rust

rug

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

argmin

Mathematical optimization in pure Rust

mint

Math interoperability standard types

cgmath

A linear algebra and mathematics library for computer graphics

bigdecimal

Arbitrary percision decimal numbers

num-complex

Complex numbers implementation for Rust

nakadion

Types for interacting with the Nakadi Event Broker

fasteval

Fast evaluation of algebraic expressions

num-bigint-dig

Big integer implementation for Rust

lapack-src

The package provides a LAPACK source of choice

mathru

Mathematics library written in Rust

pathfinder_geometry

Basic SIMD-accelerated geometry/linear algebra

meval

A simple math expression parser and evaluator

geos

Rust bindings for GEOS C API

fixed

Fixed-point numbers

specialized-div-rem

specialized division algorithms for integer primitives

jlrs

jlrs is a library built around bindings to the Julia C API that enables Julia code to be called from Rust. jlrs can move many kinds of data from Rust to Julia and back, share n-dimensional…

ramp

A high-performance multiple-precision arithmetic library

vecmat

Lightweight low-dimensional vector and matrix library

lambda_calculus

A simple, zero-dependency implementation of pure lambda calculus in Safe Rust

axgeom

Library that provides ability to extract 1d ranges out of 2d objects

nalgebra-lapack

Linear algebra library with transformations and satically-sized or dynamically-sized matrices

openblas-src

The package provides a source of BLAS and LAPACK via OpenBLAS

num-rational

Rational numbers implementation for Rust

rulinalg

A linear algebra library

zeromq-src

Source code and logic to build ZeroMQ from source

series

Laurent series in a single variable

chfft

Fastest Fourier Transform library implemented with pure Rust

eva

Calculator REPL similar to bc(1)

plane-split

Plane splitting

intel-mkl-src

Redistribution of Intel(R) MKL as a crate

discrete

Combinatorial phantom types for discrete mathematics

cuba

A Rust wrapper for the C Cuba integration library

keyframe

A simple library for animation in Rust

aljabar

A super generic, super experimental linear algebra library

GSL

A rust binding for the GSL (the GNU scientific library)

vecmath

A simple and type agnostic library for vector math designed for reexporting

pihex

Arbitrary place hexadecimal digits viewer of pi written in Rust

optlib

The optimization algorithms realized in Rust. In given time realized genetic and particle swarm algorithms.

bc

Use bc in the Rust Programming Language

fred-rs

An interface for accessing the St. Louis Fed’s FRED API

pergola

abstract types for join-semilattices

rink

Unit conversion tool and library, similar to frink

maths-traits

A simple to use yet abstract system of mathematical traits for the Rust language

fwd_ad

Forward auto-differentiation, allowing its user to manage memory location and minimize copying

kissunits

Different units (like distances or coordinates), keeping it small and simple

oars

A library providing construction methods and utility functions for orthogonal arrays and strong orthogonal arrays

lua-src

Sources of Lua 5.1/5.2/5.3/5.4 and logic to build them

gkquad

Numerical integration library for Rust

commodity

A library for representing commodities/currencies, and exchange rates/conversions between them

primal-check

Fast standalone primality testing

viewp

A program is get any argument, that generates prime. it argument be number. This Program is Test Stage.

hektor

A library for hekkin vectors

lll-rs

Implementation of the LLL algorithm for lattice reduction and it’s improved version L²

beagle

A basic linear algebra library for computer graphics

matrixmultiply_mt

Multithreaded Fork of bluss’s matrixmultiply crate. General matrix multiplication of f32 and f64 matrices in Rust. Supports matrices with general strides. Uses a microkernel strategy…

point_process

A crate for simulating random point processes

myelin-geometry

Basic linear and vector geometry for two-dimensional Euclidean geometry

easy_complex

Complex numbers crate

vector2math

Traits for doing 2D vector geometry operations using standard types

blas-src

The package provides a BLAS source of choice

pocket_prover

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

gurufocus_api

A rust adapter to the GuruFocus API, a provider of financial data

angular-units

A library for representing, manipulating and converting between angular quantities in various units through a type-safe interace

langtons-termite

Implementation of Langton’s Ant that runs in a terminal window

algebloat

Rust linear algebra library

nalgebra-spacetime

Spacetime Extension for nalgebra

katex

Rust bindings to KaTeX

coord

A simple, ergonomic vector mathematics crate

prefix_num_ops

The num_traits API, but in prefix notation

symbolic_polynomials

A library for manipulation of polynomials over the integers

fts_units

fts_units is a library that enables compile-time type-safe mathematical operations using units of measurement

cryptominisat

Rust bindings for Cryptominisat, a boolean satisfiability solver

nalgebra-glm

A computer-graphics oriented API for nalgebra, inspired by the C++ GLM library

nrfind

A set of useful mathematical functions for floating point numbers based on the Newton-Raphson method for finding roots

num-primes

A Rust Library For Generating Large Prime and Composite Numbers using num with a simplistic interface

algebra

Abstract algebra for Rust

rawarray

simple file format for retrievably storing n-dimensional arrays

rust-latex-doc-minimal-example

Minimal crate example for getting latex in docs

un_algebra

Simple implementations of selected abstract algebraic structures–including groups, rings, and fields. Intended for self-study of abstract algebra concepts and not for production use.

kdbush

A very fast static spatial index for 2D points based on a flat KD-tree

wrapping_coords2d

Translate between 1D indices and 2D coordinates with wrapping

xmath

Rust port of Microsoft DirectXMath

surreal

A Rust library that implements J. H. Conway’s surreal numbers

fastcurve_3d

Library for 3D and 2D fast curve generation

canrun

A logic programming library inspired by the *Kanren family of language DSLs

mathrs

Scientific, numeric and symbolic mathematical crate for computing with Rust

geomath

Stack-allocated maths for geometry, simulation and computer graphics

classific

Classifications, comparator and equivalence class implementations

num-bigint

Big integer implementation for Rust

val_unc

A package for handling quantities with uncertainties

glm

GLSL mathematics for Rust

googleprojection

Project world- or screen-space coordinates for use in Google Maps tiles (WebMercator)

flag-algebra

An implementation of Razborov’s flag algebras

rug-maths

rug wrapper implementing maths-traits

acm

Arithmetic congruence monoid implementation in Rust

lamcal

A lambda calculus parser and interpreter

qualinvest_cli

Command line executable of the qualinvest project

ring-algorithm

algorithms on ring(Abstruct Algebra)

linxal

Linear Algebra package with rust-ndarray interface

rect-iter

Iterator for 2D rectangle areas

primeval

A monstrosity of a prime number generator

overflower_support

A bunch of specialized traits + impls to allow automated overflow handling without type inference. Nightly only

static-math

Fast mathematical operations with static arrays

matrixcompare

Tools for convenient comparison of matrices

math

optimath

Linear Algebra using const generics for no_std and specialization to enable SIMD

quick_maths

Simple low-dimensional linear algebra structures

inari

A Rust implementation of set-based interval arithmetic

gmp-mpfr-sys

Rust FFI bindings for GMP, MPFR and MPC

fitting

Pure Rust curve fitting library

autd-geometry

Geometry of AUTD

cyclotomic

high-performance library for exact operations in cyclotomic fields

statistical

A simple statistics library

mazth

Matrix utilities

factorial

Convenient methods to compute the factorial, optionally checked

bit-matrix

Library for bit matrices and vectors

rustyard

A Shunting Yard implementation and calculator. This crate is able to calculate basic math expressions passed to it as strings and return a 64-bit floating point return value.

lair

Linear algebra in Rust

opensrdk-linear-algebra

Standard linear algebra library using blas and lapack for OpenSRDK toolchain

cereal_lib

Does the cereal box problem in either single or multi-threaded mode

calculate

Rust library for parsing and processing arithmetic expressions

elr_primes

Provides a prime number iterator and methods for basic calculations with prime numbers

rust-gmp

Rust bindings for GMP

servo/pathfinder_geometry

Basic SIMD-accelerated geometry/linear algebra

spherical-cow

Spherical Cow: High volume fraction sphere packing in arbitrary geometries

financial

A collection of finance calculations mimicking some of Excel Financial Functions interface

zkp-primefield

A 251-bit prime field suitable for FFTs

duckduckgeo

2d geom library

quadrature

This provides several fast numerical integration methods. This library is pure safe rust, and cross-platform. The double exponential algorithm is naturally adaptive, and does not allocate.

finql

A quantitative finance toolbox

blasoxide

BLAS implementation in rust

primapalooza

prime number calculations implemented in rust

fishers_exact

Fisher’s exact statistical test

fpn

Fixed point number

intervals-general

intervals-general is a crate 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).

nova-math

Vector and matrix math utilities for nova-engine

pow_of_2

Integer-like types which can only represent powers of 2

tau

The important mathematical constant tau

mathematics_table

A rust library that will generate a math table of an integer given by the user

lapack-traits

Generic real/complex scalar trait wrappers for BLAS and LAPACK routines

modtype

Macros that implement modular arithmetic integer types

euler

Mathematics library for 3D computer graphics

fuzzycomp

Comparison with margins

luajit-src

Sources of LuaJIT 2.1 (OpenResty’s branch) and logic to build it

ang

Angular types and common helper methods

math-concept

Common math concepts from Computer Science classes, implemented in Rust

num-rug-adapter

An adapter to use num crate where rug is needed

libpcp

A constraint solver supporting arithmetic constraints over integers

ndarray-rblas

rblas bindings for ndarray

ode_solvers

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

eigenvalues

algorithms to compute eigenvalue/eigenvectors of symmetric matrices

quaternion

A simple and type agnostic quaternion math library designed for reexporting

mech-math

Math library for the Mech language

sainte_lague

Sainte-Laguë method for seat distribution used in multiple parliamentary elections all over the world

geom

Simple 2D geometry library

gml

Graphics Math Library. Generic Vector and Matrix Math library targetting graphics applications.

rcalc_lib

Mathematical expression calculation library

gut-derive

Derive macros for (gut)[https://crates.io/crates/gut]

ornstein-uhlenbeck

Ornstein–Uhlenbeck stochastic process

pardiso-sys

The package provides bindings to PARDISO

postfix

Postfix expression evaluator

biodivine-lib-bdd

A simple thread-safe implementation of basic binary decision diagrams

quat

quat

scalar

A trait for scalars (integers and floats)

differential-geometry

A library for differential-geometric calculations

poly

Generic dense polynomials

solovay_strassen

A multi-threaded, arbitrary precision implementation of the Solovay-Strassen primality test

razor-chase

razor-chase implements a variation of The Chase algorithm to find models for theories in geometric form

icub3d_combinatorics

A collection of combinatorics utilities

acgmath

A linear algebra and mathematics library for computer graphics. A fork of cgmath.

polynomial-ring

polynomial on field

basic_stochastics

A small collection of utilities to make performing basic stochastic calculations more convenient

algebloat_macros

RustAlgebloat utility macros

pofu

Mathematical series as a Rust library

vectors

Sparse & dense vectors for use in high dimensional vector spaces

primal

primal puts 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…

analit

Add another dimension to your Rust project with analog geometric literals

alga_derive

Derive attribute for implementing algebraic traits from the alga crate

llvmint

Bindings to (almost) all LLVM intrinsics, for all platforms

antic

bindings for the antic C library for algebraic number theory

rust-gmp-kzen

Rust bindings for GMP

ripin

A library that handle Reverse Polish notated expressions, compiles, and evaluate them

mish

A proof of concept Rust libm like implementation with almost full coverage of libm

natural_constants

Pre-defined constants from all disciplines (math, physics, …)

definitive

The definitive and final vector & matrix library for Rust

finitediff

Finite/numerical differentiation

isochronous_finite_fields

Isochronous implementation of GF(2^8) arithmetic

exprtk_rs

Rust bindings to the ExprTk C++ library (http://www.partow.net/programming/exprtk)

cgmatrix

Simple matrix library for computer graphics in Rust

ida

A pure Rust port of the Implicit Differential-Algebraic solver from the Sundials suite

quaternion_averager

A library to average quaternions

trilean

Kleene’s three-valued logic (boolean + unknown)

gmath

math for graphics and games

asprim

Cast any primitive numeric type to any other using as with the AsPrim trait

modpow

I published this before I realized that modpow was already implemented by num, lol. Contact me if you’d like to use this crate name.

scirust

A scientific computing library

matriarch

A Linear Algebra and Matrix library written in Rust

yahoo-finance

An API to get financial data from Yahoo

tinyspline-sys

FFI bindings for Tinyspline

m

A C free / pure Rust mathematical library (“libm”) for no_std code

prime_tools

Generate primes, get prime factors, check primality, and other useful prime-related utilities

is-odd

Returns true if the given number is odd

lars

A library for basic linear algebra

polynom

A simple library for handling polynomials

googology

A crate for giving names to large numbers

float_extras

Extra floating-point math functions from C math library

cassie

A simple, limited computer algebra system written for the fun of it

lapack

The package provides wrappers for LAPACK (Fortran)

compound

A crate that calculates the value of the initial investment based on rates of return (daily, monthly, semi-annual, annual…)

linal

tiny linear algebra library without dependencies

Math_module

Maths functions

piecewise-linear

A library for manipulating piecewise linear functions

numrs

A numerical computations library for Rust

mat32

matrix 3x2

cruncher

jit-compiled mathematical expression calculator

dumbmath

A pretty dumb math library oriented towards computer graphics

det

Calculate the determinant using a macro

closed01

Provides checked floating point operations within the range [0,1]

rustproof-libsmt

Rust bindings for z3 as utilized by RustProof

x_math_lib

a tony crate for personal use

reikna

A work in progress math library

frank

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…

newtonmath

Wrapper for the Newton API (https://newton.now.sh)

nicolas

Computational Algebra Library

differential-dataflow

An incremental data-parallel dataflow platform

spatial

An N-Dimensional R-tree family spatial tree implementations

mkl_link

Library for linking with MKL

is-even

Returns true if the given number is odd

framp

Fork of James Miller’s Ramp, a high-performance multiple-precision arithmetic library

integrators

Generic traits to allow easy plugging of different numerical integration algorithms, and wrappers for the Cuba and GSL integrators

log_domain

Logarithmic representation of floats

rcomplex

A simple class for manipulating complex numbers. This project is mainly for educational purposes, and I reccomend using other more complete packages for complex math.

angular

Angular types and common helper methods

mindtree_utils

Miscellaneous utilities from the sleeve of mindtree

fpa

Fixed point arithmetic

planar

Strongly typed planar geometry

rsmath

An uncomplicated library for Mathematics written in Rust

math_traits

traits to simplify vectorized mathematics

doem-math

Const generic linear algebra math crate for 3D applications, made in conjunction with doem

yahoo_finance_api

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

quadratic

Computes the Legendre and Jacobi symbols for integers using the quadratic reciprocity law

clamped

Simple clamping of numbers in Rust

ramp-primes

A Rust Library For Generating Large Prime and Composite Numbers using ramp with a simplistic interface

primal-crossbeam

An interface to primal using crossbeam’s channels. This allows the worker thread to stop once the receiver is dropped, for example.

elementwise

Elementwise operations implemented for standard Rust containers

mathew

Mathematical expression evaluator with context

outline_2d

2D euclide polygon outline tools

mm_math

Mathematics library

advancedresearch/piston-math_notation

Bootstrapped meta rules for mathematical notation

tinyexpr

Tiny recursive descent expression parser, compiler, and evaluation engine for math expressions. A work in progress port of TinyExpr library to Rust.

rust-GSL

A rust binding for the GSL (the GNU scientific library)

geometric

A very simple vector and matrix library built on the vecmath crate

integer_set

A library providing a high-performance integer set

lerp

Generic linear interpolation and extrapolation, automatically implemented for a variety of numeric types

usagi

Common algorithms and utilities library for Rust

binomial-iter

Provides tools to iteratively compute the binomial coefficient

fibbox

A small utility for dealing with Pythagorean triples

soy

Interpolation library

cgmath-culling

Small Frustum Culling crate meant to be used alongside cgmath

physsol

Lightweight 2d and 3d physics library

struct_math

Math function with struct

ludomath

A math library for 2D games and graphics

quasi-rd

Generate quasirandom Rd sequences

epsilonz

Functional programming in Rust

jl-sys

jl-sys contains the generated bindings for the Julia C API used by jlrs

euphoria

A math lib for Computer Graphics

modtype_derive

Macros that implement modular arithmetic integer types

matrust

A simple and small generic matrix lib

math_interval

A library to make checking numbers for membership in an interval easy

const-linear

A Rust linear algebra library based on const generics

safeeft

Safe and branchless error-free transformation algorithms for floating point numbers

pardiso

The package provides wrappers for PARDISO

simba

SIMD algebra for Rust

ca

Arbitrary precision calculator REPL

miller_rabin

A multi-threaded, arbitrary precision implementation of the Miller-Rabin primality test

half_matrix

A Half Matrix implementation. Used mostly to represent many to many boolean representations. For example, if you have A, B, C. You can say (B, A) = true and the rest = false. See the docs…

diffeq

Differential Equations in rust

spherical_voronoi

Generate Voronoi diagrams on a sphere

advanedresearch-trinoise

A mathematical noise pattern of 3 values based on Number Theory and Set Theory

hilbert_curve

A simple implementation of Hilbert curve mapping algorithms in Rust

ocl-algebra

low level Linear Algebra library for OpenCL

tcorp_math_mods

This will be a growing collection of helpful math functions and algorythems all of which will be abstracted into generic types

simplex

Simplex linear programing algorithm

math-lib

Basic Math Functionality: Sum,Add,Multiply,Divide,Reminder

modint

Modular arithmetic integer

free-algebra

Types for constructing free algebras over sets

mentat

A Rust library for scientific computing

avapi

Crate for consuming the Alpha Vantage financial data API as a client

rustogram

A rust port of HdrHistogram

oxygen_quark_derive

Oxygen Quark Derive is a library for deriving traits implemented in Oxygen Quark

play-rsa

implementation of RSA cryptography in Rust for pedagogical use

matrixstack

A simple pushdown matrix stack using cgmath matrices