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

axgeom

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

lambda_calculus

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

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…

vecmat

Lightweight low-dimensional vector and matrix library

ramp

A high-performance multiple-precision arithmetic library

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

eva

Calculator REPL similar to bc(1)

plane-split

Plane splitting

chfft

Fastest Fourier Transform library implemented with pure Rust

intel-mkl-src

Redistribution of Intel(R) MKL as a crate

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

fred-rs

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

GSL

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

optlib

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

discrete

Combinatorial phantom types for discrete mathematics

pihex

Arbitrary place hexadecimal digits viewer of pi written in Rust

bc

Use bc in the Rust Programming Language

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

nrfind

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

oars

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

gkquad

Numerical integration library for Rust

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²

pocket_prover

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

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…

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…

point_process

A crate for simulating random point processes

lua-src

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

myelin-geometry

Basic linear and vector geometry for two-dimensional Euclidean geometry

easy_complex

Complex numbers crate

blas-src

The package provides a BLAS source of choice

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

vector2math

Traits for doing 2D vector geometry operations using standard types

quaternion

A simple and type agnostic quaternion math library designed for reexporting

algebloat

Rust linear algebra library

nalgebra-spacetime

Spacetime Extension for nalgebra

coord

A simple, ergonomic vector mathematics crate

symbolic_polynomials

A library for manipulation of polynomials over the integers

prefix_num_ops

The num_traits API, but in prefix notation

fts_units

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

katex

Rust bindings to KaTeX

nalgebra-glm

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

num-primes

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

algebra

Abstract algebra for Rust

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

googleprojection

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

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

glm

GLSL mathematics for Rust

rect-iter

Iterator for 2D rectangle areas

rug-maths

rug wrapper implementing maths-traits

flag-algebra

An implementation of Razborov’s flag algebras

acm

Arithmetic congruence monoid implementation in Rust

primeval

A monstrosity of a prime number generator

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

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

factorial

Convenient methods to compute the factorial, optionally checked

gmp-mpfr-sys

Rust FFI bindings for GMP, MPFR and MPC

fitting

Pure Rust curve fitting library

rcalc_lib

Mathematical expression calculation library

cyclotomic

high-performance library for exact operations in cyclotomic fields

statistical

A simple statistics library

mazth

Matrix utilities

autd-geometry

Geometry of AUTD

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

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

primapalooza

prime number calculations implemented in rust

modtype

Macros that implement modular arithmetic integer types

fishers_exact

Fisher’s exact statistical test

nova-math

Vector and matrix math utilities for nova-engine

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).

vecmath

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

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

euler

Mathematics library for 3D computer graphics

ang

Angular types and common helper methods

math-concept

Common math concepts from Computer Science classes, implemented in Rust

luajit-src

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

num-rug-adapter

An adapter to use num crate where rug is needed

libpcp

A constraint solver supporting arithmetic constraints over integers

ode_solvers

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

mat32

matrix 3x2

postfix

Postfix expression evaluator

mech-math

Math library for the Mech language

eigenvalues

algorithms to compute eigenvalue/eigenvectors of symmetric matrices

differential-geometry

A library for differential-geometric calculations

geom

Simple 2D geometry library

gml

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

gut-derive

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

biodivine-lib-bdd

A simple thread-safe implementation of basic binary decision diagrams

ornstein-uhlenbeck

Ornstein–Uhlenbeck stochastic process

poly

Generic dense polynomials

pardiso-sys

The package provides bindings to PARDISO

blasoxide

BLAS implementation in rust

quat

quat

scalar

A trait for scalars (integers and floats)

icub3d_combinatorics

A collection of combinatorics utilities

rust-gmp-kzen

Rust bindings for GMP

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.

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

analit

Add another dimension to your Rust project with analog geometric literals

asprim

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

alga_derive

Derive attribute for implementing algebraic traits from the alga crate

llvmint

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

finitediff

Finite/numerical differentiation

yahoo-finance

An API to get financial data from Yahoo

isochronous_finite_fields

Isochronous implementation of GF(2^8) arithmetic

ripin

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

primal-check

Fast standalone primality testing

mish

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

definitive

The definitive and final vector & matrix library for Rust

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)

razor

razor is a command-line tool for constructing finite models for first-order theories

scirust

A scientific computing library

matriarch

A Linear Algebra and Matrix library written in Rust

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

googology

A crate for giving names to large numbers

fpa

Fixed point arithmetic

polynom

A simple library for handling polynomials

clamped

Simple clamping of numbers in Rust

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

piecewise-linear

A library for manipulating piecewise linear functions

numrs

A numerical computations library for Rust

mkl_link

Library for linking with MKL

cruncher

jit-compiled mathematical expression calculator

det

Calculate the determinant using a macro

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…

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

natural_constants

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

log_domain

Logarithmic representation of floats

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

cyclic

Simple, complete, and dependency-free modular arithmetic

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

everust

Evaluates rust code

fin_iex

The IEX provider for financial operations

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

planar

Strongly typed planar geometry

rsmath

An uncomplicated library for Mathematics written in Rust

elementwise

Elementwise operations implemented for standard Rust containers

math_traits

traits to simplify vectorized mathematics

doem-math

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

sna

Serial Number Arithmetic (RFC 1982) for Rust

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

ramp-primes

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

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

ludomath

A math library for 2D games and graphics

soy

Interpolation library

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)

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

geometric

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