-
num-bigint
Big integer implementation for Rust
-
bigdecimal
Arbitrary precision decimal numbers
-
rust_decimal
Decimal number implementation written in pure Rust suitable for financial and fixed-precision calculations
-
statrs
Statistical computing library for Rust
-
nalgebra
General-purpose linear algebra library with transformations and statically-sized or dynamically-sized matrices
-
rug
Arbitrary-precision integers, rational, floating-point and complex numbers based on GMP, MPFR and MPC
-
kurbo
A 2D curves library
-
sprs
A sparse matrix library
-
uint
Large fixed-size integer arithmetic
-
num-traits
Numeric traits for generic mathematics
-
ruint
Unsigned integer type with const-generic bit length
-
euclid
Geometry primitives
-
ark-poly
efficient polynomial arithmetic via FFTs over finite fields
-
ultraviolet
do linear algebra, fast
-
peroxide
Rust comprehensive scientific computation library contains linear algebra, numerical analysis, statistics and machine learning tools with farmiliar syntax
-
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…
-
fend
Arbitrary-precision unit-aware calculator
-
roots
well known algorithms for numerical root finding
-
num-bigint-dig
Big integer implementation for Rust
-
daggy
A directed acyclic graph data structure library. It is Implemented on top of petgraph's Graph data structure and attempts to follow similar conventions where suitable.
-
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.
-
lapack
The package provides wrappers for LAPACK (Fortran)
-
faer
linear algebra library
-
i_overlay
Boolean Operations for 2D Polygons: Supports intersection, union, difference, xor, and self-intersections for all polygon varieties
-
mint
Math interoperability standard types
-
yahoo_finance_api
adapter for the yahoo! finance API to fetch histories of market data quotes
-
kalc
a complex numbers, 2d/3d graphing, arbitrary precision, vector/matrix, cli calculator with real-time output and support for units
-
simba
SIMD algebra for Rust
-
parry3d
3 dimensional collision detection library in Rust
-
russell_lab
Scientific laboratory for linear algebra and numerical mathematics
-
num-complex
Complex numbers implementation for Rust
-
medians
Median, Statistical Measures, Mathematics, Statistics
-
num-modular
efficient integer division and modular arithmetic operations with generic number types. Supports various backends including num-bigint, etc
-
bnum
Arbitrary, fixed size numeric types that extend the functionality of primitive numeric types
-
num-dual
Generalized (hyper) dual numbers for the calculation of exact (partial) derivatives
-
biodivine-lib-bdd
thread-safe implementation of basic binary decision diagrams
-
argmin
Numerical optimization in pure 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…
-
common_traits
Traits to write generic functions on different numeric types, with atomic support, and other features
-
hexasphere
evenly tile hexagons on a sphere
-
plotpy
Rust plotting library using Python (Matplotlib)
-
simple_moving_average
moving average (SMA) algorithms
-
ode_solvers
Numerical methods to solve ordinary differential equations (ODEs) in Rust
-
twenty-first
Collection of mathematics routines and cryptography for the twenty-first century
-
hexx
Hexagonal utilities
-
russell_sparse
Solvers for large sparse linear systems (wraps MUMPS and UMFPACK)
-
sci-rs
Rust scientific analysis library similar to SciPy
-
feanor-math
number theory, providing implementations for arithmetic in various rings and algorithms working on them
-
GSL
binding for the GSL (the GNU scientific library)
-
arrow-arith
Arrow arithmetic kernels
-
rapier3d
3-dimensional physics engine in Rust
-
exmex
fast, simple, and extendable mathematical expression evaluator able to compute partial derivatives
-
ibig
A big integer library with good performance
-
openblas-src
The package provides a source of BLAS and LAPACK via OpenBLAS
-
typed_floats
Types for handling floats with type checking at compile time
-
lin_alg
Vector, matrix, and quaternion operations for general purposes
-
noisy_float
Contains floating point types that panic if they are set to an illegal value, such as NaN
-
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…
-
skillratings
Calculate a player's skill rating using algorithms like Elo, Glicko, Glicko-2, TrueSkill and many more
-
number_prefix
numeric prefixes (kilo, giga, kibi)
-
lambdascript
Instructional program detailing the beta reduction of typed and untyped lambda terms
-
lambda_calculus
zero-dependency implementation of pure lambda calculus in Safe Rust
-
cgmath
A linear algebra and mathematics library for computer graphics
-
glamour
Strongly typed linear algebra with glam
-
gauss-quad
applying Gaussian quadrature to integrate a function
-
microlp
A fast linear programming solver library
-
lambert_w
Fast and accurate evaluation of the Lambert W function by the method of T. Fukushima.
-
splr
A modern CDCL SAT solver in Rust
-
quaternion
type agnostic quaternion math library designed for reexporting
-
jlrs
bindings to the Julia C API that enable Julia code to be called from Rust and more
-
oxidd-cli
Command line interface for OxiDD
-
quaternion-core
quaternion operations and interconversion with several attitude representations
-
splines
Spline interpolation made easy
-
rps_paijo
My first project of a simple Rock, Paper, Scissors game in Rust
-
num
A collection of numeric types and traits for Rust, including bigint, complex, rational, range iterators, generic integers, and more!
-
stv-rs
Single Transferable Vote implementation in Rust
-
sliding_features
Modular sliding window with various signal processing functions and technical indicators
-
gemm
Playground for matrix multiplication algorithms
-
lp_parser_rs
parser for the LP file format
-
scientific
Arbitrary precision scientific number (no_std capable, in pure Rust)
-
ndhistogram
multi-dimensional histogramming for Rust
-
machine-prime
ne plus ultra primality testing for machine-sized integers
-
i_float
This fixed float math library provides an efficient and deterministic solution for arithmetic and geometric operations
-
mathru
Fundamental algorithms for scientific computing in Rust
-
malachite
Arbitrary-precision arithmetic, with efficient algorithms partially derived from GMP, FLINT, and MPFR
-
linestring
line string toolbox
-
nextsv
Next semantic version calculator
-
cubecl-reduce
CubeCL Reduce Algorithms
-
naivesat
Few solvers that uses the Gate project
-
glyph_brush_layout
Text layout for ab_glyph
-
cpc
evaluates math expressions, with support for units and conversion between units
-
joker_calculus
Joker Calculus in Rust
-
z3
High-level rust bindings for the Z3 SMT solver from Microsoft Research
-
quantities
Unit-safe computations with quantities
-
russell_tensor
Tensor analysis, calculus, and functions for continuum mechanics
-
bva
manipulating and doing arithmetics on bit vectors of fixed but arbitrary size
-
num-quaternion
Quaternion numbers implementation for Rust
-
mini-calc
A Fully-Featured Configurable (mini) Rust Calculator
-
pathfinder_geometry
Basic SIMD-accelerated geometry/linear algebra
-
russell_ode
Solvers for ordinary differential equations and differential algebraic equations
-
maths-rs
A linear algebra library for gamedev and graphics
-
concrete-fft
pure Rust high performance fast Fourier transform library
-
idsp
DSP algorithms for embedded, mostly integer math
-
ganesh
Function minimization in Rust, simplified
-
core_maths
Extension trait for full float functionality in
#[no_std]backed bylibm -
num-rational
Rational numbers implementation for Rust
-
rl_ball_sym
Rocket League's ball physics
-
rsparse
solving sparse linear systems using direct methods
-
balanced-ternary
manipulate balanced ternary values
-
light-curve-feature
Feature extractor from noisy time series
-
auto-palette
🎨 A Rust library that extracts prominent color palettes from images automatically
-
creusot-contracts
contracts and logic helpers for Creusot
-
big_num_math
computations on large numbers
-
ndrustfft
N-dimensional FFT, real-to-complex FFT and real-to-real DCT
-
distrs
PDF, CDF, and percent-point/quantile functions for the normal and Student’s t distributions
-
clarabel
Conic Interior Point Solver for Rust / Python
-
enterpolation
creating and computing interpolations, extrapolations and smoothing of generic data points
-
stacked_linear_algebra_graph
Embedded in-memory graph using sparse linear algebra
-
meshx
A mesh eXchange library with conversion utilities for popular mesh formats
-
mzsignal
mass spectrometry signal processing
-
metis
Idiomatic wrapper for METIS, the serial graph partitioner and fill-reducing matrix orderer
-
yata
Technical Analysis library. For rust now.
-
parry3d-f64
3 dimensional collision detection library in Rust. 64-bits precision version.
-
hexgridspiral
Hexagonal Cube-Coordinate System with Spiralling Integer Tile Identifiers
-
oxidd
A safe, concurrent, modular, and performant decision diagram framework
-
stlrs
Seasonal-trend decomposition for Rust
-
icao-wgs84
performing geometric calculations on the WGS84 ellipsoid
-
bit-matrix
bit matrices and vectors
-
honeycomb-core
Core structure implementation for combinatorial maps
-
mahc
cli riichi mahjong calculator, which spits out yaku and fu for a given hand
-
hyperdual
Fully-featured Dual Number implementation with features for automatic differentiation of multivariate vectorial functions
-
adic
Arithmetic and rootfinding for p-adic numbers
-
rsc
A fast calculator for solving scientific and algebraic math equations in strings
-
stats-ci
A pure Rust library for computing and working with confidence intervals on sample data
-
RustQuant_autodiff
quantitative finance
-
dec
A decimal arithmetic library providing high-level, safe bindings to libdecnumber
-
skeid
a linear algebra library for game graphics and physics
-
calc_rational
CLI calculator for rational numbers
-
erydanos
Optimized routines for ARM NEON and SSE
-
kcl-lib
KittyCAD Language implementation and tools
-
temp-converter
terminal temperature unit converter between Celsius, Fahrenheit and Kelvin
-
fastnum
Fast decimal numbers library
-
graph-cycles
Detect all cycles in a petgraph graph
-
didppy
Python interface for Dynamic Programming Description Language (DyPDL) and DyPDL solvers
-
geo-aid
designed to generate geometrical figures based on given rules
-
cubecl
Multi-platform high-performance compute language extension for Rust
-
jubjub-schnorr
A pure-Rust implementation of Schnorr signatures with a PLONK circuit module additionally
-
const-primes
Work with prime numbers in const contexts. Prime generation, primality testing, prime counting, and more.
-
diffsol
solving ordinary differential equations (ODEs) in Rust
-
krnl
Safe, portable, high performance compute (GPGPU) kernels
-
starnav
A comprehensive navigation system for celestial navigation in Star Citizen
-
tyche
Dice rolling and dice expression (with a syntax similar to FoundryVTT) parsing library
-
arrayfire
high performance software library for parallel computing with an easy-to-use API. Its array based function set makes parallel programming simple. ArrayFire's multiple backends (CUDA…
-
num-order
Numerically consistent
Eq,OrdandHashimplementations for variousnumtypes (u32,f64,num_bigint::BigInt, etc.) -
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
-
lstsq
Return the least-squares solution to a linear matrix equation
-
hooo
Propositional logic with exponentials
-
rebop
A fast stochastic simulator for chemical reaction networks
-
vector-traits
Rust traits for 2D and 3D vector types
-
tiny-solver
Factor graph solver
-
libspecr
standard library for specr lang
-
engineering-repr
Numeric conversions for engineering notation (1.23k) and the RKM code variant (1k23)
-
rocketsim_rs
Rust bindings for the RocketSim project
-
rpn-cli
Command line reverse Polish notation calculator
-
blas-src
The package provides a BLAS source of choice
-
nalgebra-spacetime
Spacetime Extension for nalgebra
-
figures
A math library specialized for 2d screen graphics
-
angle-sc
performing accurate and efficient trigonometry calculations
-
easyfft
providing an easy FFT API for arrays and slices
-
numbat
A statically typed programming language for scientific computations with first class support for physical dimensions and units
-
hexing
A basic Rust library to manipulate hexagonal grids
-
coin_cbc
Rust bindings to the CoinOR CBC MILP Solveur using the C API
-
inari
interval arithmetic
-
reckoner
A high level arbitrary precision arithmetic library supporting integer and rational numbers
-
rhai-loco
Rhai scripting engine integration for Loco
-
csgrs
Constructive solid geometry on meshes using BSP trees in Rust
-
zagreb-lib
analyzing graph properties using the Zagreb index and Hamiltonian criteria
-
microgemm
General matrix multiplication with custom configuration in Rust. Supports no_std and no_alloc environments
-
serde-ndim
Serde support for n-dimensional arrays from self-describing formats
-
jexl-eval
A JEXL evaluator written in Rust
-
p3-dft
Plonky3 is a toolkit for implementing polynomial IOPs (PIOPs), such as PLONK and STARKs
-
number-general
A generic number type for Rust which supports basic math and (de)serialization
-
kalker
A calculator that supports user-defined functions, variables and units, and can handle fairly ambiguous syntax
-
series
Laurent series in a single variable
-
ncube
Generalized Hypercube Visualizer
-
mappers
Pure Rust geographical projections library
-
centerline
finding centerlines of 2D closed geometry
-
directx_math
translation of DirectXMath, a SIMD linear algebra library for use in games and graphics apps
-
rust_intervals
Intervals arithmetic with any combination of open, closed or infinite bounds, along with operations like intersection, convex hull, union, difference,
-
num-bigfloat
Increased precision floating point numbers implemented purely in Rust
-
superset_map
Map that stores distinct supersets based on the total order defined
-
thermal_hydraulics_rs
A Thermal Hydraulics Library with some useful traits,enums and functions for heat transfer and fluid mechanics
-
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.
-
ring-algorithm
algorithms on ring (Abstruct Algebra)
-
moontool
John Walker's moontool.c astronomical calculation routines, extracted and ported to Rust
-
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…
-
geom3
3d geometry classes
-
stroemung
A Computational Fluid Dynamics (CFD) simulator in Rust
-
bigraph
Different representations with implemented operations on bigraphs
-
swift_vec
A convenient and comfortable vector maths crate that supports 2D, 3D, and 4D matrices and vectors - along with additional scalar math
-
honeycomb-kernels
Meshing kernel implementations using combinatorial maps
-
autodj
Automatic Differentiation Library
-
graphics-shapes
Shapes for graphics
-
twibint
arithmetic on arbitrarily large integers. Provides Python bindings as well.
-
n_circular_array
An n-dimensional circular array
-
num-prime
Generic and optimized primality test, factorization and various number theoretic functions with arbitrary precision based on
num -
logru
A small, embeddable and fast interpreter for a subset of Prolog
-
ninterp
Numerical interpolation for N-dimensional rectilinear grids
-
transforms
A transform library to track reference frames and provide transforms between them
-
seuif97
The high-speed IAPWS-IF97 package with C and Python binding
-
robomath
A lightweight, efficient, and generic mathematics library for 3D applications, with a focus on robotics and simulation
-
qcalc
but effective terminal calculator for quick access and ease of use. It supports history of expressions, built-in functions and stored variables
-
pihex
Arbitrary place hexadecimal digits viewer of pi written in Rust
-
ecolor
Color structs and color conversion utilities
-
krabmaga
A modern developing art for reliable and efficient Agent-based Model (ABM) simulation with the Rust language
-
russell_stat
Statistics calculations and (engineering) probability distributions
-
plane-split
Plane splitting
-
amplify_num
Amplifying numeric types: big-sized and bit-sized integers
-
cmn
accessing a collection of mathematical and cryptographic constants
-
startin
A Delaunay triangulator for terrains
-
ggmath
optimized generic-graphics-math
-
kifmm
Kernel-independent fast multipole method
-
uniform-cubic-splines
uniform cubic spline evaluation and inversion
-
get-hash
Get hash of a string
-
pocket_prover
A fast, brute force, automatic theorem prover for first order logic
-
graphrs
package for the creation, manipulation and analysis of graphs
-
arithmetic-parser
Parser for arithmetic expressions with flexible literals and type annotations
-
intel-mkl-src
Redistribution of Intel(R) MKL as a crate
-
metallic
C math functions from scratch
-
qsv-stats
Computing summary statistics on streams
-
csvbinmatrix
Binary matrix Compressed Sparse Vector
-
bare_metal_modulo
ModNum is a highly ergonomic modular arithmetic struct intended for no_std use
-
conspire
c o n s p i r e
-
tuple
Element-wise operations on tuples
-
polynomial
manipulating polynomials
-
datas
data structures and algorithms and data analisys
-
int_ratio
The type of ratios represented by two integers
-
wartcl
A minimal embeddable Tcl-like language
-
rational
Minimalistic library for rational numbers
-
yoda-calculator
command line app that acts as a scientific calculator, operating through commands instead of buttons
-
balanced-direction
manipulate directions with discrete logic
-
matrixable
Traits and structs extending capabilities of matrix-like structures
-
ellip
Elliptic integrals for Rust
-
string_calculator
A string calculator to compute formulas inside strings
-
irox
Tools & Libraries
-
lair
Linear algebra in Rust
-
simplify-polyline
Simplify polylines using Douglas-Peucker and radial distance algorithms. Port of the simplify-js library.
-
f256
Octuple-precision floating-point arithmetic
-
newton_rootfinder
Newton based methods for root finding
-
numerics-rs
Blazing fast numerical library written in pure Rust
-
squiid-engine
Squiid Engine is an RPN mathematical engine written in Rust
-
RayBNN_DiffEq
Matrix Differential Equation Solver using GPUs, CPUs, and FPGAs via CUDA, OpenCL, and oneAPI
-
makepad-math
Makepad math functions
-
graphblas_sparse_linear_algebra
Wrapper for SuiteSparse:GraphBLAS
-
gemlab
Geometry and meshes laboratory for finite element analyses
-
ndarray-interp
Interpolation package for ndarray
-
mech-math
Math library for the Mech language
-
crc32c-cli
CLI wrapper for the crc32c crate
-
agb_fixnum
abstracting over fixed precision numbers. Designed for use with the agb library for the Game Boy Advance
-
nabo
A fast K Nearest Neighbor (KNN) library for low-dimensional spaces
-
fasteval
Fast evaluation of algebraic expressions
-
moyo
Crystal Symmetry in Rust
-
list_math
doing math on a list including average, smallest, largest, and standard deviation
-
pointy
Minimal 2D geometry library
-
rust-cli-calculator
calculator written in Rust as a learning project
-
iter_num_tools
Create simple iterators over non integer ranges. itertools + num = iter_num_tools
-
shor
Shor's factoring algorithm written in rust
-
relative-duration
Duration with negative capabilities
-
volute
Boolean functions implementation, represented as lookup tables (LUT) or sum-of-products (SOP)
-
brillig_vm
The virtual machine that processes Brillig bytecode, used to introduce non-determinism to the ACVM
-
symbolica
A blazing fast computer algebra system
-
tilezz
work with perfect-precision polygonal tiles built on top of complex integer rings
-
find_peaks
Find peaks that match criteria in 1D data
-
spec_math
implementations of special mathematical functions. Includes re-implementation of the CEPHES math library for gamma functions, error functions, elliptic integrals, sine and cosine integrals…
-
cnfgen
Generate DIMACS CNF formula from operations
-
neophyte-linalg
Linear algebra types for Neophyte
-
comfy-bounded-ints
Bounded-integer types focused on ergonomics and safety. (See README.md)
-
realistic
Towards an API for the Real Numbers
-
mutils
Mathematical-like utilities. Points, Sizes, Colours, maths operating on them. Things like that.
-
rgeometry
High-Level Computational Geometry
-
raa_tt
Proves sentences of propositional calculus
-
ulam
calculations
-
simplecalc
CLI calculator
-
multicalc
Rust scientific computing for single and multi-variable calculus
-
syunit
A small library that contains some basic units to help structuring kinematics and robotic programming in rust
-
camera-intrinsic-calibration
Camera Intrinsic Calibration
-
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
-
del-geo
2D/3D geometry utility codes
-
promquery
Query and visualize Prometheus metrics from the command-line
-
p-chan
Multimedia (Audio, Raster) Channel Newtypes and Conversions
-
awint
Arbitrary width integers
-
strict-num
A collection of bounded numeric types
-
ascent_base
support library for the ascent package
-
csc
Command Line Scientific Calculator
-
reso
visual pixel-art logic-circuit design language
-
truck-modeling
integrated modeling algorithms by geometry and topology
-
bc
Use
bcin the Rust Programming Language -
rstm
focuses on building concrete implementations for Turing Machines
-
graphalgs
Graph algorithms based on the Rust 'petgraph' library
-
nauty-pet
Canonical graph labelling using nauty/Traces and petgraph
-
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
-
jagua-rs
A fast and fearless Collision Detection Engine for 2D irregular Cutting and Packing problems
-
spherical_geometry
A package for working with spherical geometry
-
d3_delaunay_rs
A port of D3/d3-delauany
-
iron-shapes
Basic data types and routines for computational geometry focused on VLSI chip design
-
binary_polynomial_mod_algebra
Basic algebra on univariate binary polynomial
-
cfsem
Quasi-steady electromagnetics including filamentized approximations, Biot-Savart, and Grad-Shafranov
-
castep_model_generator_backend
A rust-written backend lib for edit and generation of lattice 3D-models compatible with CASTEP and Materials Studio
-
mosek
Rust API for MOSEK optimization tools
-
qhull
Rust bindings to Qhull
-
Sph2-rs
An improved version of Sph-rs, that uses a mod to calculate the desired values
-
ogsolve
The program for solving octal games
-
prime_factorization
Prime factorization up to 128 bit integers
-
gendelbrot
A small, simplistic mandelbrot image generator
-
null-kane
currency crate with the option to add your own currency localization logic
-
libfive
Tools for solid modeling, especially suited for parametric and procedural design
-
quadraturerules
quadrature rules library
-
biometrics
provide the vitals of a process in the form of counters, gauges, moments, and T-digests
-
fasteval2
Fast evaluation of algebraic expressions
-
fast-srgb8
Very fast conversions between linear float and 8-bit sRGB (with no_std support)
-
rooc
A mixed integer linear programming modeling language to solve linear optimization models. Extensible, works in WASM and easy to use.
-
eng-units
Engineering unit coversions and calculations
-
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
-
integrate
Small, lightweight Rust library for performing numerical integration
-
lox-math
Mathematical utilities for the Lox ecosystem
-
cli_calculator
A basic cli calcuator
-
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
-
aprilgrid
Aprilgrid
-
calc
CLI calculator app
-
crater-rs
solid modeling primitives and operations
-
matrixcompare
Tools for convenient comparison of matrices
-
rsfrac
The Terminal-Based Fractal Explorer. Rsfrac is your terminal gateway to Mandelbrot, Burning Ship, and Julia.
-
mdarray
Multidimensional array for Rust
-
numdiff
Numerical differentiation via forward-mode automatic differentiation and finite difference approximations
-
axgeom
that provides ability to extract 1d ranges out of 2d objects
-
libceed
High-level interface for libCEED - the efficient high-order discretization library developed by the ECP co-design center CEED
-
geogram_predicates
Rust bindings to the Geogram library's predicates module
-
mcdm
assist with solving Multiple-Criteria Decision Making (MCDM) problems
-
al-jabr
An n-dimensional linear algebra library
-
safe_math
Math without overflow, creates an enum and a macro to help mitigate any overflow while multiplying and adding
-
ruint2
Unsigned integer type with cont-generic bit length
-
lerp
Generic linear interpolation and extrapolation, automatically implemented for a variety of numeric types
-
ldpc-toolbox
aid in LDPC code design
-
meshless_voronoi
Meshless Voronoi algorithm
-
floco
validates floats against constraints
-
pvz_interception_calculator
rewrite of the original PVZ Interception Calculator that calculates precise imp movement
-
cavalier_contours
2D polyline/shape library for offsetting, combining, etc
-
theon
Abstraction of Euclidean spaces
-
scorch
A straightforward and customizable neural network crate, built for machine learning tasks
-
fastcwt
Rust-lang Continuous Wavelet Transform(CWT) library inspired by fCWT
-
vector2math
Traits for doing 2D vector geometry operations using standard types
-
softposit
Posit numbers
-
rink
Unit conversion tool, similar to frink
-
rosu_nps
analyzing note density and distribution in osu! beatmaps
-
rust-poly
Numeric manipulation of real and complex polynomials
-
rapier2d
2-dimensional physics engine in Rust
-
padded-number
Work with numbers containing significant leading zeros
-
saikoro
Parser and evaluator for doing math with dice notation expressions
-
nacfahi
Simpler, but less error-prone API for
levenberg-marquardtoptimization crate -
nanvm
NaN VM
-
lazyivy
Lazy Runge-Kutta integration for initial value problems
-
r-src
The package provides a source of BLAS and LAPACK via R
-
stochasta
stochastic analysis library
-
twistrs
An asynchronous domain name permutation and enumeration library
-
dual_balanced_ternary
Dual Balanced Ternary Arithmetic
-
fpmath
A floating point math library
-
del-ls
sparse solver library for research prototyping
-
scouter
logic
-
daisycalc
A high-precision terminal scientific calculator
-
imgdd
Performance-first perceptual hashing library; perfect for handling large datasets. Designed to quickly process nested folder structures, commonly found in image datasets
-
faer_gmres
GMRES implementation using faer
-
permutohedron
Generate permutations of sequences. Either lexicographical order permutations, or a minimal swaps permutation sequence implemented using Heap's algorithm.
-
b10
Lossless handling of decimal numbers at maximum performance
-
basic_dsp_vector
Digital signal processing based on real or complex vectors in time or frequency domain
-
hfs
Hereditarily finite sets
-
substrate-fixed
Fixed-point numbers
-
floccus
Formulae for air thermodynamic calculations
-
entropy
Calculates the Shannon entropy of arrays of bytes and strings
-
coordinates
no nonsense, library for using two and three dimensonal coordinates in several systems
-
matrix_lib
easy to use library to operate on matrices
-
gpu-fft
performing Fast Fourier Transform (FFT) and Inverse FFT using GPU acceleration
-
mate-rs
lightweight arithmetic expression interpreter
-
proteogenomics
protein genomics analyzers
-
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…
-
eqsolver
that solves equations using numerical methods
-
rpoly
algorithm for finding all roots of a real-coefficient univariate polynomial
-
geometry-rs
geometry utils
-
mod3d
3D Models for Gl processing
-
smooth-operator
Procedural macro that transforms regular infix arithmetic expressions into checked arithmetic expressions
-
linear_isomorphic
A set of traits to astract over linear-like types
-
alum
Halfedge based polygon mesh library
-
rustpython-format
Format helpers for RustPython
-
algori
Rust Algorithms
-
nice_and_easy
A minimalistic Rust library for smooth and effortless easing functions
-
orbweaver
designed for effortless construction and analysis of graph data structures
-
integrator
A math library
-
baa
BitVector and Array Arithmetic
-
sig_fig_histogram
histogram type that is exponentially distributed and human-friendly
-
practicestuff
CLI trainer for improving calculation and memorisation skills
-
rmatrix_ks
matrix and some algebra in Rust
-
bezier-rs
Computational geometry algorithms for Bézier segments and shapes useful in the context of 2D graphics
-
csta
A personal statistics library
-
prime-forge
Forged in Lost Lands is a simple game engine built in Rust that focuses on data control and ease of use
-
whittaker-eilers
A sparse matrix implementation of Whittaker-Eilers smoothing and interpolation
-
stylish-style
Internal implementation details of
stylish-core -
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.
-
voxel-tiler-core
Convert point clouds to voxel data
-
sparsetools
2-D sparse matrix package for numeric data
-
infinitable
Infinity for types without infinite values
-
chemp
chemical formulas parser
-
bestagon
An engine for discrete stuff in hexagonal grids
-
boostvoronoi
Boost voronoi ported to 100% rust
-
aviation_calc_util
assist with aviation related calculations
-
ml-distance
Distance-based methods for vector comparison and analysis. (Porting of the JS/TS pkg
ml-distanceto Rust) -
microcli
Bunch of random unrelated CLI tools
-
scalarff
A minimal, opinionated, library for working with scalar finite fields
-
secrust
source-level verification using Weakest Precondition calculus
-
ncollide3d-updated
2 and 3-dimensional collision detection library in Rust. Will be superseded by the parry3d crate.
-
tclifford
Geometric algebra library
-
amd
Approximate Minimum Degree ordering
-
mortgauge
calculator for figuring out how much you can offer for a house in the UK
-
sparse_matrix
do linear algebra with sparse matrix
-
imlet
A lightweight engine for implicit modeling
-
liealg
lie group and lie algebra in rust
-
hyperion
Generic LSystem implementation
-
rlst
native linear algebra library
-
heapless_matrix
efficient implementation of a matrix data structure in Rust. It offers functionality for creating, manipulating, and performing operations on matrices, such as transposition, summation, and multiplication.
-
laddu
Amplitude analysis made short and sweet
-
itertools-num
Numerical iterator tools. Extra iterators and iterator methods and functions.
-
sylow
BLS signature scheme using the alt-bn128 curve
-
petal-decomposition
Matrix decomposition algorithms including PCA (principal component analysis) and ICA (independent component analysis)
-
mats
handling matrices and vectors
-
rustitude-gluex
GlueX Amplitudes for Rustitude
-
faer-entity
Basic linear algebra routines
-
all-is-cubes-base
Helper library for all-is-cubes. Do not use directly.
-
cgt
Combinatorial Game Theory framework
-
single_algebra
A linear algebra convenience library for the single-rust library. Can be used externally as well.
-
jakkunight-ali
CLI tool for matrix calculation
-
hammer-and-sample
Simplistic MCMC ensemble sampler based on emcee, the MCMC hammer
-
aspect360
This builds on the Ring360 to calculate aspect matches from target angles with orbs or an array of target aspect/orb pairs
-
algebraeon
computational algebra library re-exports for all components
-
lookup-tables
High performance & compile-time customizable lookup tables
-
vectrix
A stack-allocated matrix type implemented with const generics
-
bunnies
A fast chess library for chess engines
-
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… -
vector-victor
linear algebra crate
-
palmfft
Palm-sized Faster Fourier Transform
-
mosekcomodel
Conic Optimization Modeling with Mosek
-
scurve_motion
S-Curve motion planning library
-
cashmoney
safe monetary calculations
-
warmup
Calculates the repetitions required for a warmup
-
randperm-crt
Small library for generating random permutations
-
calcucalc
A general-purpose calculus library written in Rust
-
chemrust-core
The core modules defining the flow and structs of data in computational chemistry routines
-
lean-sys
Bindings to Lean 4's C API
-
rs-math3d
Rust 3D Math (no dependency on std)
-
ha-ndarray
A hardware-accelerated n-dimensional array
-
multidigraph
extraction multi digraph from a Vec of Paths
-
stroke
zero-allocation library providing const-generic implementations of Bézier curves, B-Spline curves and specialized implementations of up to cubic Bézier…
-
quaigh
Logic optimization library
-
vector3
dealing with 3D mathematical vectors
-
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…
-
minitt
Mini-TT, a dependently-typed lambda calculus, extended and (re)implemented in Rust
-
kneed
Pure rust implementation of Knee-point detection
-
ratio-matrix
Ratio's matrix data library
-
soilrust
A geotechnical engineering library for soil mechanics calculations in Rust
-
mago-trinary
implementing three-valued logical operations (true, false, maybe) to handle complex logical reasoning scenarios
-
vom_rs
Probabilistic Finite Automata
-
decimal-percentage
Percentage type with rust_decimal
-
errorfunctions
Pure Rust package to compute the error function, Dawson's function, and Faddeeva's function for real and complex arguments
-
image_processing
This package provides tools for image processing with a focus on edge detection and morphological transformations
-
rootfinder
Root-finding methods for both univariate, scalar-valued functions and multivariate, vector-valued functions
-
concrete-ntt
pure Rust high performance number theoretic transform library
-
lowdim
two- to four-dimensional integer geometry
-
conformal_core
Code shared between wrappers in conformal framework
-
int_math
Integer math
-
new_york_calculate_core
calculation some things
-
bacon-sci
Scientific computing in Rust
-
pergola
abstract types for join-semilattices
-
suitesparse_sys
sys crate for suitesparse library
-
distimate
providing probability distributions for estimation and risk analysis
-
array_math
A selection of useful math operations on arrays
-
rxcalc
An expression calculator, originally written in Scratch
-
yume-pdq
An optimized implementation of the PDQ hash function for high-throughput screening
-
fast-boolean-anf-transform
Fast implementation of the boolean Algebraic Normal Form (ANF) transform
-
pid-lite
A small PID controller library
-
cellular_raza
Cellular Agent-based Modeling from a Clean Slate
-
RustQuant_ml
quantitative finance
-
xprs
flexible and extensible mathematical expression parser and evaluator for Rust, designed for simplicity and ease of use
-
dleq
single and cross-curve Discrete Log Equality proofs
-
fixed_math
Some math traits and functions for
fixedpoint numbers -
tritet
Triangle and tetrahedron mesh generators
-
beetle-collatz
A collection of functions relating to the Collatz conjecture
-
complex-bessel-rs
compute Bessel functions
-
lk_math
Collection of reusable mathematical tools
-
specialized-div-rem
specialized division algorithms for integer primitives
-
static-math
Fast mathematical operations with static arrays, without
unsafecode -
chfft
Fastest Fourier Transform library implemented with pure Rust
-
musclecalc
fitness: estimate the one repetition maximum (1RM)
-
sum-calc
A sum calc
-
combination
A lib to do math jobs like permutate and combinate data from vec
-
gpca
'Async Hyper-Graph Cellular Automata' computational model
-
trs-dataframe
Dataframe library for Teiresias
-
special-fun
Special functions for Rust by binding to the Cephes library
-
bls12_381-bls
BLS signatures using the BLS12-381 curve
-
shape-core
Definition of geometry shapes
-
lav
Lane-Associated Vector (LAV): Portable SIMD vector trait as GAT of SIMD lane trait
-
polygon-offsetting
polygon offsetting crate
-
mscore
providing core operations for computational mass spectrometry proteomics
-
cutup
A flexible and efficient allocation library for Rust, capable of distributing assets, resources, and other divisible entities
-
poly_it
A no-std library for manipulating polynomials with slice support and minimal allocation
-
lower
desugar math where the compiler wont
-
cubes
Applications for determining how to put a cube together
-
dmntk-model-evaluator
DMNTK | DMN model evaluator
-
reals
Computable and unified real numbers
-
malachite-bigint
A drop-in num-bigint replacement based on malachite
-
sddrs
Bottom-up Sentential Decision Diagram compiler library
-
sgrust
A sparse grid library written in Rust
-
sigma-types
Types checked for an invariant
-
signal-gen-cjds66-lib
An unofficial support library which can fully remote control the inexpensive Koolertron DDS Signal Generator known as GH-CJDS66
-
fidget_math
glam vector types for tree construction with fidget
-
osi-src
Redistribution of Coin-OR Osi as a crate
-
checked_num
Overflow-checked numbers for safety without sacrificing ergonomics
-
hilbert_2d
Functions for mapping between 1D and 2D space using the Hilbert curve, and its approximations
-
fasteval3
Fast evaluation of algebraic expressions
-
type-fn
Allows for simpler coding of type-level logic, e.g. for type-number systems.
-
vax-floating
VAX floating-point types
-
sprs-superlu
The package provides a high level interface between SuperLU, sprs and ndarray
-
collatz_rust
Code for testing an extention of the Collatz Conjecture
-
type_eval
Type level evaluation and proof-carrying
-
termcalc
Terminal Calculator
-
datetime
date and time formatting and arithmetic
-
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…
-
lucky
A program to test the probability of winning a prize
-
uint256
A light-weight implementation of 256-bit unsigned integers type with semantic API
-
control-sys
A Control System library implemented in Rust to design and analyze control systems
-
unit-sphere
performing geometric calculations on the surface of a sphere
-
i24
working with 24-bit integers
-
simple-bezier-easing
calculating cubic Bézier curves using De Casteljau's algorithm
-
ratio-graph
Ratio's graph manipulation library
-
rumoca
A Modelica translator with focus on Casadi, Sympy, JAX, and Collimator generation
-
simple_vector2
libary for generic vector manipulation that just works
-
circle
Definition of circle and ellipse
-
blas
The package provides wrappers for BLAS (Fortran)
-
octad
puzzle generator and solver
-
compute-pi
designed for computing pi to millions of digits
-
rusev
Fast implementation of SeqEval, a sequence evaluation framework
-
vecmat
Low-dimensional vector algebra with min_const_generics support
-
p256k1
Rust wrappers around libsecp256k1 which expose internal scalar and point APIs
-
tabularlib
Small library for abstract matrices stored in single linear vectors created as practice project
-
acme
Acme aims to provide a solid foundation for developing robust machine-learning systems in Rust
-
zkpolynomial
polynomial operations, including addition, multiplication, evaluation, and Lagrange interpolation for univariate polynomials
-
standard_card
A Lightweight Library for Efficient Card Representation
-
quad-rs
Adaptive Gauss-Kronrod Integration in Rust
-
feldera_rust_decimal
Decimal number implementation written in pure Rust suitable for financial and fixed-precision calculations
-
schnapsen-rs
Schnapsen implementation in Rust
-
hardcore_equitizer
calculate the equity of a poker hand against a range of hands
-
boolean_function
Mathematical analysis of Boolean functions
-
deterministic-trigonometry
Trigonometry without floating point variables to achieve deterministic results across hardware and compilers
-
blazing_fibonacci
A fast Fibonacci number calculator using matrix exponentiation and fast doubling
-
x-math
fast math
-
ffactor
A very minimal number theory utilities
-
silico-calculator
A dead simple, Windows-like calculator available on all major operating systems and desktop environments
-
rusty-wam
The Warren Abstract Machine in Rust
-
jonswap
CLI for JONSWAP wave model
-
patronus
Hardware bug-finding toolkit
-
combinatorial
tools, functions, and generators
-
lcmx
Calculate the least common multiple of multiple values
-
sleef
Math functions for SIMD vectors
-
p3-circle
Plonky3 is a toolkit for implementing polynomial IOPs (PIOPs), such as PLONK and STARKs
-
tfhe-fft
pure Rust high performance fast Fourier transform library
-
opengm_rts
GM/T 0005-2021 randomness test suits written in Rust
-
wigners
Compute Wigner 3j and Clebsch-Gordan coefficients in pure Rust
-
augurs-outlier
Outlier detection for time series
-
vectorial
general-purpose vector math
-
schlandals
probabilistic inference by projected weighted model counting
-
intfinity
An abstraction over numeric types with infinity implemented
-
advancedresearch-toy_model_of_physical_seshatic_identity
toy model for physical Seshatic identity that satisfies the holographic principle
-
adlo
Adaptive LLL algorithm for solving SVP
-
qvnt
Advanced quantum computation simulator
-
scilib
A scientific library for the Rust programming language
-
RayBNN_Sparse
Sparse Matrix Library for GPUs, CPUs, and FPGAs via CUDA, OpenCL, and oneAPI
-
ointer
Steal the high bits of a pointer to store an extra value
-
incr_stats
Fast, scalable, incremental descriptive statistics in Rust
-
noise-algebra
Easy manipulation of noise functions
-
function
A set of useful traits for your functional needs
-
windowfunctions
Common window functions for apodization
-
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…
-
br-maths
maths
-
instant-glicko-2
Glicko-2 rating system that allows for instant feedback after games, not just once a rating period closes
-
gaussian_curve_fit
A
no_stdand noalloclibrary for gaussian curve coefficents calculation -
y_conbinator
Y conbinator demonstration
-
re_arrow_util
Helpers for working with arrow
-
fj-interop
Early-stage b-rep CAD kernel
-
newnum
traits for number API and hierarchy
-
latex2mathml
Convert LaTeX equations to MathML
-
punc
Pun Calculus
-
rust-matrix
foundational matrix operations for matrices containing <f32>, <f64> or complex numbers built from those types
-
fixed-bigint
Fixed-size big integer implementation for Rust
-
matio-rs
Rust wrapper to MATLAB MAT file I/O library
-
vectora
A vector computation library
-
polycal
methods for fitting and using polynomial calibration functions following ISO/TS 28038
-
dotzilla
Native Rust implementation of efficient basic linear algebra routines
-
mikino_api
induction and BMC engine
-
num-integer
Integer traits and functions
-
thue_morse
generating Thue-Morse number sequences for different bases. You can also specifically create evil numbers and odious numbers.
-
bounded-counter
Generic Incremental Bounded Counter
-
zfc
Trait that represents a set according to Zermelo–Fraenkel set theory with the axiom of choice (ZFC)
-
pythagorean-hodographs
Pythaogrean hodograph splines
-
proj5
Pure Rust, type-safe alternative to PROJ.4
-
arcflash
Arc flash calculations according to IEEE 1584
-
jacderida-exp2-adder2
Little binary for experimenting with automated release workflows
-
sauss-cramer
es una librería que ayuda a resolver sistemas 2x2 y 3x3 de ecuaciones lineales, usando el método de reducción de Crammer
-
generic-interval
A generic closed interval library
-
hyper-static
A static file handler for Rust/Hyper with minimal logic
-
flavio
welcomes you
-
quad-to-quad-transformer
Translate 2d points from one quad to another
-
vector_operations
A collection of vector operations for Rust
-
delaunay_creator
delaunay triangulation for 2D and 3D(not implemented yet)
-
angle
wrapper to avoid ambiguous parameters + common operation over angles like wrapping, comparisons, arithmetic operations, trigonometric operations and conversions between rad and deg
-
albert
A terminal calculator written in Rust with ❤️
-
mathfun
high-performance math functions
-
longitude
Work with real world coordinates in Rust!
-
hmath
Big Integers and Rational Numbers
-
message_segment_calculator
package to calculate SMS message segments
-
number-theory
Fast primality, factorization and elementary number theory for integer types
-
ruri
Calculates the CRC-32 of files and checks them against their filename
-
break_infinity
larger numbers up to 1e9e15 in Rust for Incremental Games
-
factorial
Convenient methods to compute the factorial, optionally checked
-
generic_fixedpoint
Generic fixed-point numbers
-
nauty-Traces-sys
Low-level bindings for nauty and Traces
-
malachite-q
The arbitrary-precision type Rational, with efficient algorithms partially derived from GMP and FLINT
-
rust_ev_system_library
E-Voting system library functionalities for the Verifier
-
strmath
Do math with your strings
-
arranged
Statically bounds-checked (machine-word-abstracting? TBD) ranged types as zero or low-runtime overhead abstractions providing safe (no unintentional overflow) arithmetic
-
eva
Calculator REPL similar to bc(1)
-
gfxmath-vec2
2D math library
-
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 -
prime_finder_rust
A prime finder made in Rust (originally made in c++)
-
lina
Linear algebra library with a focus on 3D applications like games (i.e. low-dimensional vectors and matrices)
-
rcgal
Rust Computational Geometry Algorithms Library
-
binarybit
Boolean algebra operations in Rust
-
logaddexp
stable implementations of logaddexp and logsumexp
-
num-lazy
Number macros for generic-typed functions
-
pi_densevec
重定向映射表，一个使用usize作为key的映射表
-
sandrs
Falling Pink Sand
-
RustGraphix
Rust-Graphix is a Rust library for mathematics. It includes support for matrices, both two-dimensional and three-dimensional, along with various matrix operations and methods.
-
malachite-base
A collection of utilities, including new arithmetic traits and iterators that generate all values of a type
-
Rustb
A package for calculating band, angle state, linear and nonlinear conductivities based on tight-binding models
-
cork
A command-line calculator for hex-lovers
-
celleste
A flexible 2D cellular automaton
-
spiro
Raph Levien's C implementation of Spiro in pure Rust, transpiled by C2Rust and then heavily edited
-
erfars
Safe Rust bindings to the Essential Routines for Fundamental Astronomy (ERFA) C library
-
lox-earth
Tools for Earth-based astrodynamics for the Lox ecosystem
-
intervalsets
bounded and unbounded intervals implemented as sets with all the associated set operations
-
opensrdk-probability
Standard probability library for OpenSRDK toolchain
-
matrix_kit
An abstract linear algebra library for Rust
-
chikage
easy to understand and barebones math library for game and graphics development
-
easy-signed-distance-field
pure rust signed distance field renderer
-
commander-core
used by commander-rust only. Please don't use it!
-
crum
Tensors, Matrices and Complex numbers for numerical analysis
-
firmath
Math Library for Graphics
-
vf2
VF2 subgraph isomorphism algorithm in Rust
-
bounds
interact with bounded and unbounded ranges
-
mapping-algorithms
A collection of pure-rust algorithms, for spatial and SLAM purposes
-
is_prime
Fast arbitrary length prime number checker using the Miller-Rabin primality test algorithm
-
cubature-sys
Bindings for cubature with support for Linux, macOS, and Windows
-
pccc
Parallel-concatenated convolutional code
-
compute-tau
designed for computing tau to millions of digits
-
cube-rotations
Models the rotations that can happen on a cube without changing the set of planes to which its faces are parallel
-
espada
Texas Hold'em poker odds evaluator
-
rust-snap7
rust bindings for snap7, similar like python-snap7
-
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).
-
betting
manage twitch-style bets (aka 'Parimutuel betting')
-
modular_math
modular arithmetic crate for U256
-
multi_compare
Macro for comparing multiple values in a concise way. (a < b < c)
-
pitch-pipe
Pitch Pipe is a method for automatically tuning a one euro filter
-
rpn-c
A calculator environment using Reverse Polish Notation and multiple precision numbers
-
discrete-gaussian
Gaussian sampling over discrete fields/rings/sets
-
categorical
combining categorical random distributions and computing exact probabilities
-
rusty_math
mathematical, statistical and machine learning operations
-
unifrac
working with normalized fractional values
-
csvtool
deal with CSV files
-
fast_fp
Floating point fast-math optimizations
-
sharks
Fast, small and secure Shamir's Secret Sharing library crate
-
vecs
Vector Math Crate
-
primal-check
Fast standalone primality testing
-
narr
Numeric Calc
-
gchemol
Graph-based CHEMical Objects Library
-
pmm_math
Version of PMM Mathematical Formula Library
-
root1d
One dimensional root finding algorithms
-
isodd
A blazingly fast Light Weight rust library for determining if numbers are odd
-
kalman-rust
Dead simple implementation of Discrete Kalman filter for object tracking purposes
-
multibody_dynamics
Multibody dynamics algorithms in Rust
-
munum
Micro 3D Math Library
-
auto_regressive
constructing AR(p) models using the Yule-Walker equations
-
umt_rust
UMT is a collection of useful functions that I personally created
-
zzz_lib
a test crates
-
treevolution
A simulation of the evolution of treelike structures in a cellular automata
-
vector-geometric-algebra
vector algebraic operations for 2d and 3d vector, as well as splines
-
num-ordinal
Ordinal number types
-
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…
-
costoflife
The CostOf.Life Calculator
-
num_bound
Add bounds fn to anything implementing
Ordthat bounds a number to a range -
is-even-u16
Specialized is-even checking for u16 numbers
-
linalg-traits
Traits for generic linear algebra
-
algebra_kit
An abstract algebra library for Rust
-
linear_algebra
basic linear algebra operations in Rust
-
tea-dtype
provide datatype and useful traits for datatype
-
analog_literals
Multi-Dimensional Analog Literals in Rust
-
num-runtime-fmt
Format numbers according to a format spec determined at runtime
-
softfloat-wrapper
a safe wrapper of Berkeley SoftFloat based on softfloat-sys
-
cubic_spline
Function that calculates curve points for cubic spline
-
starstuff-types
star catalog parser and primitive types for star coordinates and astronomical times
-
logic-form
representing Cube, Clause, CNF and DNF
-
gw_signal
Package with signal processing tools for graviational waves studies
-
fwd_ad
Forward auto-differentiation, allowing its user to manage memory location and minimize copying
-
module-lwe
Implements the module learning-with-errors public key encrpytion scheme
-
fuzzy-logic_rs
fuzzy logic in rust!
-
sqpnp_simple
SQPnp camera pose estimation
-
divrem
Division and modulus variants
-
noether
Abstract algebraic structures for Rust
-
libmf
Large-scale sparse matrix factorization for Rust
-
csd-rs
Canonical Signed Digit Conversion in Rust
-
composite_modulus_proofs
Proofs about several propoerties of a composite modulus - square-free, product of 2 primes, a blum integer
-
slice_math
A selection of useful math operations on slices
-
micro_ndarray
Very small multi-dimensional-array implementation
-
fahrenheit_to_celsius
Convert any number from fahrenheit to celsius with a simple CLI tool
-
kapacitor-multi-indicator-batch-udf
A multi-indicator batch UDF for Kapacitor
-
unit-prefix
Format numbers with metric and binary unit prefixes
-
taz
evaluate a mathematical expression
-
vctr2
2d vector library
-
aegir
Strongly-typed, reverse-mode autodiff library in Rust
-
rust_decimal_ext
Decimal number implementation written in pure Rust suitable for financial and fixed-precision calculations
-
alemat
type-safe building of MathML
-
rmpfit
Pure Rust implementation of the CMPFIT library
-
mm0_util
MM0/MM1 language utilities
-
angulus
Unit agnostic angle
-
blis-src
Rust native linking for BLIS library
-
net_promoter_score
calculating Net Promoter Score (NPS) from survey responses
-
fibonacci-numbers
The 59th Fibonacci number
-
manifold3d
Bindings for Manifold - a Geometry library for topological robustness
-
langtons-termite
Langton's Ant that runs in a terminal window
-
algebraeon-nzq
natural numbers, integers and rationals for algebraeon
-
mini-matrix
A mini linear algebra library implemented in Rust
-
rfcalc
calculate things
-
gemm-benchmark
BLAS [sd]gemm benchmark
-
connect-four-solver
A strong and perfect connect four solver in Rust
-
eca
A cli tool to run elementary cellular automatons
-
rao
Robust and scalable Adaptive Optics tools
-
topology-traits
Topological traits for generic mathematics in Rust
-
g_2_0_0
manipulate arbitrary object in the geometric algebra containing two perpendicular vectors that square to 1. Basically 2d VGA
-
extended_matrix
A matrix calculation module
-
quaternion-wrapper
Operator overloading allows implementation similar to mathematical expressions
-
easy_complex
Complex numbers crate
-
urs
Rust utility library
-
flag-algebra
Razborov's flag algebras
-
aberth
Aberth's method for finding the zeros of a polynomial
-
xfeval
the Excel-like formula calculator
-
fugue-bv
A binary analysis framework written in Rust
-
wedged
A robust and generalized library for Geometric Algebra in Rust
-
qc
An enhanced RPN cli tool for quick binary, octal, decimal, hexadecimal calcs
-
pemel
Parsing and Evaluating of Math Expressions Library
-
un_algebra
implementations of selected abstract algebraic structures--including groups, rings, and fields. Intended for self-study of abstract algebra concepts and not for production use.
-
oat_python
User-friendly tools for applied topology in Python
-
numint
ODE solvers and numerical integration in Rust
-
fractions-rs
Fractions numbers implementation for Rust
-
rusty-talib
using pure rust code for technical analysis
-
static_aabb2d_index
Fast static spatial index data structure for 2D axis aligned bounding boxes
-
compute
statistical computing
-
round-to
Round floating point to integer
-
v_eval
Expression evaluator with context
-
arithmetic_yukinari
arithmetic library
-
rene
Computational geometry
-
spalinalg
Sparse Linear Algebra Library
-
g3
Neat library for computer graphics based on geometric algebra
-
numberlab
A collection of numerical algorithms
-
ravencol
Tabular data manipulation
-
eiche
tools for working with symbolic expressions
-
simple_rpn_calc
RPN Calculator
-
meos-src
static library build for meos-sys
-
opensrdk-linear-algebra
Standard linear algebra library using blas and lapack for OpenSRDK toolchain
-
zoc
Z-order curve based multidimensional range search
-
rlu
Sparse LU Decomposition (Gilbert-Peierls)
-
owa4x
Idiomatic wrapper around the owa4x-sys crate
-
reltester
Automatically verify the correctness of [Partial]Eq/Ord implementations
-
rust-blas
BLAS bindings and wrappers, fork of rblas
-
seismic-response
Seismic response analysis of a single particle system is performed using Newmark's beta method
-
clp-src
Redistribution of Coin-OR Clp as a crate
-
algexenotation
in Rust
-
project_euler_lib
project euler
-
diman
Zero-cost compile-time dimensional analysis
-
simple_qp
Allows formulating Quadratic Programming problems in a symbolic way
-
rugfield
generating Gaussian Random Fields using the circulant embedding method
-
ecoord-cli
CLI tool for transforming between 3D coordinate frames
-
gctree
cache-friendly, graph-like, arena-allocated datastructures
-
ieee754
Low-level manipulations of IEEE754 floating-point numbers
-
green-kernels
Evaluation of Green's function kernels
-
min_max_assign
Change min(max) implementation in Rust
-
rust-github-action-test-b76u22ivt4z3
四則演算を行うライブラリ
-
my_math_demo
A test demo
-
sundials-sys
Bindings to the SUNDIALS suite of Nonlinear and DAE Solvers
-
lib_rapid
LibRapid - a library specifically built for mathematical calculations and scientific applications
-
metal-matrix
High-performance linear algebra library with Metal GPU acceleration
-
mech-logic
Logic library for the Mech language
-
honeycomb-render
Visualization tool for combinatorial maps
-
scad
generating OpenSCAD models using rust
-
sum_range
The sum of all consecutive numbers, both even and odd
-
gmp-mpfr-sys
Rust FFI bindings for GMP, MPFR and MPC
-
py-laddu-mpi
Python bindings for laddu (with MPI support)
-
sr-rcd
Apply Refining-Cover-by-Defect algorithm to solve Sound Ranging problem in time-dependent-metric (and, in particular, (quasi-)metric) spaces
-
spherical-cow
Spherical Cow: High volume fraction sphere packing in arbitrary geometries
-
generic-matrix
Manipulations and data types that represent 2d matrix
-
nalgebra_latex
several robust formatters for nalgebra::Matrix, LaTeX environments, and more
-
convolution-dsp
1-dimensional convolution library intended for use in DSP applications
-
funspace
N-dimensional function spaces and transforms
-
inrust
Accumulate knowledge of my study on Rust language
-
rita
Randomized Incremental Triangulation Algorithms
-
fastapprox
Fast approximate versions of certain functions that arise in machine learning
-
ndarray-glm
Performs regression for generalized linear models using IRLS on data stored in arrays
-
linearalgebra
Test project to learn Rust and implement a small library for linear algebra
-
arithmetic_congruence_monoid
Реализует арифметические конгруэнтные моноиды (ACM) в проекте на основе YAML
-
math-comb
Math library for Combinatorics, Modular arithmetic & Number Theory utilities
-
computable-real
Computable real number
-
baiser
Curves manipulation library
-
arithmetic-eval
interpreter for arithmetic expressions
-
modular_equations
Program to solve quadratic and linear modular equations
-
aisth
A toy ray tracer
-
lnexp
Carefully evaluate compositions of log, exp, log1p and expm1
-
hax-diagnostics
hax diagnostics helper crate
-
traitgraph-tsplib-io
Functions to read and write graphs in TSPLIB format
-
meansd
calculate mean and standard deviation
-
nexsys
Solve nonlinear systems of equations using Newton's method
-
scuttle
A multi-objective MaxSAT solver
-
symbolic_math
performing symbolic mathematics. Supports basic arithmetic operations, expression simplification, and expansion, and evaluation.
-
rssat
that provides Rust bindings for multiple popular SAT solvers
-
spin4
esoteric programming language that uses 4D rotations for computations
-
swf-fixed
SWF fixed-point numbers for Rust
-
dicoco_safe_math
simplified safe math operations
-
xenn_simple-math
math library
-
numbat-cli
A statically typed programming language for scientific computations with first class support for physical dimensions and units
-
arpack-ng
Save interface to arpack-ng-sys
-
euc_lib
Easy to use implementation of extended and normanl Euclidean algorithm
-
ariprog
Need a powerful and simple library to work with arithmetic progressions in Rust? You should definitively try out ariprog!
-
kn0syseccrs
Intuitive library for elliptic curve cryptography tutorials
-
automesh
Automatic mesh generation
-
fitme
CLI curve fitting tool. Parameterise an equation from a CSV dataset.
-
yarer
(Yet Another Rust Expression Resolver) is a library for resolving mathematical expressions. Internally it uses the shunting yard algorithm.
-
stcalc
Stack calculator
-
iner-calc
A caculator of Arknights 2024 summer carnival's *Sargon Museum*
-
hpn
Text-based RPN-style calculator in the HP Voyager tradition
-
didp-yaml
YAML interface for Dynamic Programming Description Language (DyPDL) and DyPDL solvers
-
signum-sign
Adds the signum function to Rust
-
numb_rs
An experimental numeric package
-
big-rational-str
Format and parse BigRationals to/from decimal numbers
-
feo-math
Math library for 3D transformation
-
gedent
A command-line interface to generate computational chemistry inputs
-
aws-smt-ir
Intermediate representation for SMT problems
-
linal
tiny linear algebra library without dependencies
-
abstalg
Abstract algebraic structures for Rust
-
ecoord
transforming between 3D coordinate frames
-
unicode-math-class
Determine the Unicode class of a mathematical character
-
rapier3d-f64
3-dimensional physics engine in Rust
-
ommx
Open Mathematical prograMming eXchange (OMMX)
-
math-rs
A basic mathematical engine
-
reikna
A work in progress math library
-
wavegen
Wavefrom generator library
-
mfem
A high-level Rust wrapper for MFEM
-
guff-matrix
Fast Galois Field matrix multiplication
-
rapier3d-urdf
URDF file loader for the 3D rapier physics engine
-
image-recovery
Image recovery algorithms, implemented in Rust
-
mathcalculate
My first Rust library
-
gorf-core
Lambda calulcus backend library
-
primitive_fixed_point_decimal
Primitive fixed-point decimal types
-
fang_oost_option
implementing Fang and Oosterlee's algorithm for option pricing
-
aglet
Opinionated integer-based coordinates and directions and utilities
-
interva
A feature-rich crate for handling intervals
-
px4sim
A wrapper to simplify creating a custom PX4 SITL simulator
-
guff
Implements Galois Fields for various natural sizes
-
frac
Rational Number Data Type
-
minllm
minimalist LLM framework implemented in Rust with Python bindings
-
kissunits
Different units (like distances or coordinates), keeping it small and simple
-
oint
oint ('optional int') provides total operations on arithmetic
-
fixed-exp2
Exponentiation for fixed-point numbers (forked, see README)
-
parry2d
2 dimensional collision detection library in Rust
-
minimax-alpha-beta
Alpha-Beta Pruning + Minimax Algorithm for arbitrary two player minimax style games like Chess, Go, TicTacToe, etc
-
complex-number
A basic implementation of complex numbers in rust
-
gmres
A sparse linear system solver using the GMRES iterative method
-
prime-checker
hold sample functions to check the prime-ness of a given unsigned, 64-bit integer
-
padic
P-adic numbers in Rust
-
robust-predicates
Robust predicates for computer geometry
-
gfx-maths
Implementations for the most essential Graphics Math operations
-
ibdgen
Generate incomplete block designs for experiments with prohibited pairs
-
matrijs
A small 2D matrix library. There are many like it but this one is mine.
-
algebloat
Rust linear algebra library
-
euler
Mathematics library for 3D computer graphics
-
mod3d-shapes
3D Models for Gl processing
-
grambulate
grambulation for positive integers in Rust
-
patch-tracker
Patch tracker
-
perplex_num
Perplex (hyperbolic or split-complex) numbers based on num-traits
-
f128
Bindings to the gcc quadmath library
-
nibbler
A small utility for working with nibbles (half byte, 4-bits)
-
fibext
A versatile Fibonacci sequence generator for Rust, with support for large numbers and optional iterator interface
-
linxal
Linear Algebra package with rust-ndarray interface
-
nml-matrix
A small library to work with matrices
-
feos-ad
Implicit automatic differentiation of equations of state and phase equilibria
-
elementary-cellular-automaton
that handles Elementary Cellular Automata
-
uscope
Cytogon GUI
-
ffnt
Finite fields for number theory
-
distributed_control
Create, analyze and simulate multi-agent, distributed control systems
-
easing-fixed
easing iterators using fixed-point math
-
lineic
Flexible linear interpolator for Rust
-
concision-data
Concision is a complete data-science toolkit written in Rust
-
lll-rs
LLL algorithm for lattice reduction and it's improved version L²
-
my3
My3
-
kaede
adalah rust library untuk operasi matematika sederhana
-
argentum_game_coordinate_system
Argentum: Coordinate System
-
rust_solar
Date-time solutions for hypothetical cosmic calendars
-
lamcal
A lambda calculus parser and interpreter
-
xmath
Rust port of Microsoft DirectXMath
-
raddy-ad
An automatic differentiation system for geometry and simulation
-
simple_ml
Functions required for data analysis and machine learning tasks
-
katex
Rust bindings to KaTeX
-
rusty_library123456
maths library
-
mathio
A lightweight, simple and straight-forward opinionated library for math used in other projects
-
multi-skill
Skill estimation systems for multiplayer competitions
-
ang
Angular types and common helper methods
-
babushka
bin packing and nesting library
-
minvect
A mini vector library
-
board-game-geom
Geometry library for board game
-
herta-lib
Backend library for herta-bin
-
rust_math
Math library written in Rust
-
speedicycle
locating fixed-length circuits in undirected graphs, built atop petgraph
-
clausen
functions
-
rect-iter
Iterator for 2D rectangle areas
-
polar
A command-line calculator that can also convert between units
-
allan-tools
Package to compute statistics to study systems stability
-
hmmmm
Performant and easy-to-use hidden Markov models
-
openblas-build
The package provides a build helper for OpenBLAS
-
nonzero_lit
Easy, safe, and fully zero-cost NonZero constants and literals
-
dala
Dalia is a light weight formula language
-
appro-eq
Approximately equal traits and assertion
-
dimensionals
Rust native generic, flexible n-dimensional array
-
pire-base
high performance cpu kernels
-
autopp_inc
example package
-
nalgebra-glm
A computer-graphics oriented API for nalgebra, inspired by the C++ GLM library
-
algebraeon-sets
Algorithms in combinatorics
-
maths-traits
abstract system of mathematical traits for the Rust language
-
t4t
Tit-for-tat: a game theory toolbox
-
rbop
Rust framework for writing mathematical expression editors
-
octoon-math
Graphics utilities for Rust
-
irox-units
Physical Quantities, Units, & Reference Frames Library
-
dana
Compile-time dimensional analysis via generic types
-
lipmaa-link
A function to calculate lipmaa sequence numbers
-
ramp
A high-performance multiple-precision arithmetic library
-
dcc-tiler
CLI for counting / rendering tilings of various shapes
-
saturating_cast
saturating casts between integer primitives
-
mymatrix
My simple matrix library that can perform fraction operations
-
jyafn
Computational graphs for Data Science that compile to machine code
-
miniball
Minimum enclosing ball
-
linreg
Calculates linear regresssions of two-dimensional data. Does not use stdlib, only depends on numeric traits.
-
num_parser
A math interpreter and evaluator
-
xdd
Decision diagrams including BDD, ZDD, MBDD, πDD and more for combinatorics
-
rustrix
Supports macro and basic operations for matrix
-
iascar
incremental answer set count with anytime refinement
-
gchemol-graph
Networkx-like API wrapper around petgraph
-
q-num
Q notation for fixed-point numbers via a proc_macro
-
repunit
Generation Library for Rust
-
ga2
Common types for 2D geometric algebra
-
CLI_Project_Scott_Coakley
CLI Project in Rust
-
fhe-math
Mathematical utilities for the fhe.rs library
-
popgetter-core
Core library for popgetter
-
permu-rs
A collection of utilities for permutations. It contains useful tools to create, manage and experiment with permutations.
-
adic-shape
Visualizing p-adic numbers
-
simp_linalg
A generically defined, light-weight linear algebra library for simple addition and multiplication of vectors and matrices
-
quantogram
Approximate quantiles using histograms with logarithmically sized bins to guarantee worst case absolute relative error
-
vectormatrix
Idiomatic Matrix and Vector types for Rust
-
finitely
Arithemtic over finite polynomial rings
-
xcov
Knuth's Algorithm X (featuring dancing links) for solving exact cover problems
-
yices2
Rust bindings to the Yices 2 SMT solver
-
hasty
interface to system BLAS libraries for fast linear algebra operations
-
gateconvert_exec
The program to convert Gate circuit from/to foreign logic format
-
poe-superfilter
Extended syntax compiler for Path of Exile loot filters
-
probability_cli
A command line interface for probability calculations using Bayesian probability
-
comodules
calculating Ext for coalgebra and comodules. Also does Finite Field linear algebra.
-
camera-intrinsic-model
Camera Intrinsic Models
-
area_crate
Basic Area function
-
cellumina
configure and run cellular automata
-
ilog
Base 10 and 2 logarithm functions for integer types
-
rs-sci
the scientific library
-
quickwit-search
Quickwit's search logic
-
cpntt
Number Theoretic Transform for competitive programming
-
base-converter
Convert a number in any base to any other base
-
query-curve
querying custom Bezier curves, compatible with curves created at https://querycurve.com
-
chrom
representing colours
-
ohsl
A collection of numerical routines and mathematical types for use in scientific computing
-
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.
-
eqrs
Zero-dependency math expression evaluator with variables
-
my_kgk_library
A brief description of what your library does
-
roundable
Round numbers and durations to a given factor
-
hebrides
Implementations for the real numbers, complex numbers, and basic linear algebra
-
sci_rust
A scientific Rust library
-
polynomial-over-finite-prime-field
polynomial over finite prime field
-
gecl
geometry types and a color type
-
vulcano-number
handling numbers
-
basemath
math, from the ground up
-
test_gmp_mpir
test gmp mpir for Rust
-
amfnengine
Amortization Functions (AmFn) Engine
-
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…
-
rustsat-tools
Tools and examples built on the RustSAT library
-
belnapian
Belnap's 4-valued logic basic building blocks in Rust
-
cdt
Fast, robust constrained Delaunay triangulation
-
toposort
Topological sorting
-
classgroup
class groups in Rust. Uses GMP for arithmetic.
-
asciimath
Mathematical expression parser and evaluator
-
astro-float
Multiple precision floating-point numbers library
-
ngeom
Geometry in N dimensions
-
haversine-rs
some helpers functions to calculate the distance between two points on Earth using the Haversine formula
-
wrapping_coords2d
Translate between 1D indices and 2D coordinates with wrapping
-
vex
3D math library
-
smolmatrix
Small simple matrix library
-
faer-svd
Basic linear algebra routines
-
maintenance-burden
Calculate the maintenance burden of each file in a git repository
-
odesolver
solving ODE's
-
abstract-calculus
A programming language and model of computation that matches the abstract algorithm perfectly
-
mightrix
treat continous memory as a matrix
-
sequential-integration
Lightweight library for sequential integration
-
curve-sampling
Adaptive sampling of parametric
-
fj
Early-stage b-rep CAD kernel
-
rtsam
Real Time Smoothing and Mapping (RTSAM) in Rust
-
libpcp
A constraint solver supporting arithmetic constraints over integers
-
toxicblend
gRPC based Blender-addons. WIP
-
ancomplex
Package provides easy to use, begginer frendly and python like complex numbers
-
cadical
Rust bindings for the CaDiCaL SAT solver
-
matrix42
A linear algebra library developed as a project in the 42 ecosystem
-
kata_machine
A quick way to generate a sandbox, start coding and easily test your katas across multiple languages
-
reductionist
S3 Active Storage server
-
math_repl
REPL for all different kinds of math
-
live-radio-songrec
Rust program to listen to live radio (audio) streams and recognize currently playing songs using Shazam
-
freude
An ODE library for ndarray providing some simple, fixed-step integrators
-
quad_gk
Pure rust numerical integration library based on Gauss Kronrod quadrature rule
-
rug-maths
rug wrapper implementing maths-traits
-
lerpable
a derive macro for combining ADTs
-
fibs
Get a Fibonacci number or sequence
-
acm
Arithmetic congruence monoid implementation in Rust
-
polyhedron-ops
Conway/Hart Polyhedron Operations
-
lcpc-brakedown-pc
polynomial commitment scheme from SDIG expander code
-
geo-aid-latex
Support for LaTeX output from Geo-AID
-
dess-examples
DESS examples
-
typerat
Type-level rational numbers based on
typenum -
m2csmt
A solver for systems of non-linear (in)equations
-
sabi-rust
A small framework to separate logics and data accesses for Rust application
-
gmatlib
linear algebra in Rust and beyond!
-
phlite
Persistent homology, for generic matrices, that's light on memory usage
-
fcwt
Fast Continuous Wavelet Transforms
-
smartcalc-tauri
Text based calculator for peoples supported in Tauri
-
qurs
Qulacs implementation in Rust
-
simple-simplex
Generates 2d simplex noise values and applies Fractal Brownian Motion
-
vectors
Sparse & dense vectors for use in high dimensional vector spaces
-
ellp
Linear programming library that provides primal and dual simplex solvers
-
srmfpa
Floating-point's four arithmetic operations (including fused multiply-add) and square root with strict rounding mode
-
expression_simplify
expression simplifier based on OO course(SCSE, BUAA)
-
dc-ock
reverse polish notation desk calculator library
-
map-range
map a value from a range to another range
-
ndarray-inverse
Pure Rust Inverse and Determinant trait for ndarray Array2
-
libreda-sta
Static timing analysis for netlists of the LibrEDA framework
-
apbool
Just arbitrary precision boolean arithmetic for Rust
-
competitive-programming-rs
Competitive Programming Library in Rust
-
cl-calc
A command line calculator
-
nimlib
Nim games: calculate nimbers and possible moves
-
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.
-
chemrust-nasl-app
New Adsorption Site Locator (NASL) for catalyst materials. Written in rust. Part of the
chemrusttoolchain. This is the binary crate. -
intercom-common
See 'intercom'
-
cblas
The package provides wrappers for CBLAS (C)
-
inari_wasm
A stripped-down version of Inari library (a Rust implementation of interval arithmetic) compatible with web assembly
-
collatz_conjecture
A small project demonstrating the collatz conjecture, a maths problem
-
ctclib
A collection of utilities related to CTC, with the goal of being fast and highly flexible
-
dashu-int
A big integer library with good performance
-
caldyn
Dynamic evaluation of mathematical expressions
-
zaplib_vector
The vector library for Zaplib
-
periodic-table-rs
A chemistry library written in Rust
-
float_extras
Extra floating-point math functions from C math library
-
eccodes-sys
Low-level Rust bindings for latests ecCodes version
-
unwrap-overflow-ops
arithmetic operations that always panic on overflow
-
oefpil-sys
Rust FFI bindings to statically linked C/Fortran library OEFPIL
-
kuroe
lightweight CLI tool for creating competitive programming problems
-
irating
Estimate iRacing iRating changes
-
cayley
generic, stack-allocated linear algebra stuff, such as matrices
-
mc64
Sparse matrix scalings
-
libprimesieve
Access to the C function primesieve_generate_primes
-
faasle
evaluating distances (metrics)
-
rust-linear-algebra
A linear algebra library for Rust
-
aether_primitives
Helpers for common SDR and signal generation operations
-
intervals
A generic interval type with support for open/closed bounds
-
banquo
An offline monitor for Signal Temporal Logic formulas
-
hwcalc_lib
Backend for the hwcalc calculator
-
tick-machine
tick calculator
-
time_series_utils
handling time series data
-
ring-math
Polynomial ring math over scalar finite fields
-
cbc-src
Redistribution of Coin-OR Cbc as a crate
-
structural-shapes
Common structural shapes
-
triangle_sides
calculating various properties of the triangle. Does not use points, but sides lengths for constructing a triangle
-
vector-space
Useful traits for working with vector spaces
-
math-kit
Math Library for Rust 🦀
-
matrixes
matrices up to and slightly beyond a highschool level. See README for details.
-
geo_filters
Geometric filters for set cardinality estimation
-
scad_tree_math
Math library for scad_tree
-
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!
-
sat_lab
providing the framework for using SAT problems
-
kaprekar
Include a function to find number of iterations to reach Kaprekar's constant
-
quadratic_residues
calculating quadratic residues of integers
-
i_shape_js
Boolean Operations for 2D Polygons. Supported operations: intersection, union, difference, XOR, and self-intersections for all polygon varieties.
-
sylvan-sys
Bindings for the Sylvan parallel decision diagrams library
-
sprs-ldl
Sparse cholesky factorization
-
projgeom-rs
Projective Geometry in Rust
-
aurora-engine-modexp
Custom ModExp implementation that used in Aurora Engine
-
simple_colatz
package to compute the colatz conjecture in rust
-
dace
Rust wrapper of DACE, the Differential Algebra Computational Toolbox
-
chewy
A command-line RPN calculator
-
sari
arithmetic expression evaluator
-
rust_poker
Rust poker library
-
stb_rect_pack
Wrapper over stb_rect_pack_sys, offering a cleaner abstraction than the bindgen generated interface
-
mpmfnum
A numbers library in Rust
-
tfpc
Team Fortress Price Calculator
-
galois_field
convenient operations on finite field, polynomials, and matrices over finite field
-
optimath
Linear Algebra using const generics for no_std and specialization to enable SIMD
-
ndgrid
n-dimensional grid library
-
kolakoski_algorithms
Efficient algorithms for the Kolakoski sequence
-
number-diff
number-based is an attempt of mine to make working with calculus easier
-
crabsformer
fundamental library for scientific computing with Rust, highly inspired by NumPy
-
nrfind
A set of useful mathematical functions for floating point numbers based on the Newton-Raphson method for finding roots
-
new_york_utils
calculation some things
-
pnets
A framework for Petri net manipulation
-
algebraeon-groups
Algorithms in group theory
-
globalsearch
Global optimization with scatter search and local NLP solvers written in Rust using argmin
-
ls_solver
linear system solution
-
extra-math
Accidentally published
-
rug-miller-rabin
A multi-threaded, arbitrary precision implementation of the Miller-Rabin primality test using rug (GMP)
-
exsym
Symbolic computing system for business
-
qunit
Experimental uom-like library which enables compile-time verification of dimensional analysis, with support for statically-sized vectors and matrices
-
bmi-calculator
BMI calculator for TI Nspire™, with data for Chinese
-
rasters
Raster processing library
-
tricolor
Color structs, color formats, and color conversions
-
pi_cg2d
cg2d
-
algebra
Abstract algebra for Rust
-
dynast
Feynman graph topology identification
-
rlfsc
A checker for the LFSC proof language
-
maths_function
Some maths fuctions
-
css_math
Tokenizes and validates strings as CSS Math statements
-
hello_cargo_lulu
cargo publish test
-
cuv
Compressed unit vectors that can be used to store things like normal vectors efficiently
-
adf-bdd-bin
Solver for ADFs grounded, complete, and stable semantics by utilising OBDDs - ordered binary decision diagrams
-
diving-decompression
Calculate required diving decompression procedures using the US Navy dive tables rev7
-
unifac
calculate non-ideal vapor-liquid equilibria using UNIFAC model
-
fitting
Pure Rust curve fitting library
-
ds-bst
Binary search tree implementation
-
amortize-rs
A loan amortization calculator library
-
na
wrapper around nalgebra to make it easier and mostly less verbose to work with the most used types in vector math for graphics
-
mathguru
An algebra system capable of mixed numeric and symbolic computation
-
lapack-traits
Generic real/complex scalar trait wrappers for BLAS and LAPACK routines
-
irox-stats
Various mathematical and statistics utilities
-
arthroprod
Clifford Algebra based computation for the theory of Absolute Relativity
-
arithmetic-typing
Hindley-Milner type inference for arithmetic expressions
-
math_rust
A Math library for vectors
-
ferric
A Probablistic Programming Language with a declarative syntax for random variables
-
smooth-numbers
Algorithms to generate smooth numbers
-
sparse_complex
solver for complex sparse matrices
-
lenia_ca
simulating the Lenia system of cellular automata
-
feos-dft
Generic classical DFT implementations for the
feosproject -
fsum
calculate accurate sum of floats
-
noise_fn
Some simple noise functions and traits to allow easy integration with your own
-
ecoord-io
IO operations for transforming between 3D coordinate frames
-
kalkulator
A mathematical expression evaluation tool and library
-
index_mask
masking indices
-
sickle_math
Math dependencies for sickle_ui
-
tick-id
Tick ID for deterministic simulations
-
roll-rs
Dice rolling library supporting full dice notation
-
dexterior
Discrete Exterior Calculus toolkit
-
oxygen_quark
Oxygen Quark is a maths library mainly developed for the Oxygen Game Engine
-
vdtfont
converting glyphs into triangulations
-
autd3-geometry-viewer
AUTD viewer for Geometry
-
qmat
2-dimensional matrices
-
money2
For storing and asynchronously converting between (a subset of) ISO-4217 currencies
-
basic-calc
Basic TUI calculator
-
yali
LargeInt Library
-
amalie
Mathmatical library written for rust and python
-
polys
A package for polygon geometry
-
overflow-proof
Monadic checked arithmetic for Rust
-
ramer_douglas_peucker
Ramer Douglas Peucker algorithm
-
big_lehmer
framework to encode (compress) and decode large number sequences into lehmer codes
-
peroxide-num
Numerical traits for Peroxide
-
castep-model-core
The core module to parse, read, edit, and write 3D lattice models for castep and compatible with Materials Studio
-
quadrature
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.
-
net_ensembles
Erdős-Rényi and small world ensembles. For simple sampling, Markov chains etc.
-
westem
calculator program written in Rust that performs basic arithmetic operations. It takes three command-line arguments: the left operand, the operator, and the right operand. The program…
-
acid2
2-adic double-precision floating-point implementation
-
calc_mjp
calc simple library
-
blasphemy
Inspired by Keras, powered by BLAS. Construct neural networks with one line of code per layer. That's BLASphemy.
-
endpoint-gen
Generate Rust code for websocket API endpoints
-
discrete
Combinatorial phantom types for discrete mathematics
-
saber
ScAlaBle Estimator Regressor for heritability estimation
-
collatz
Helper functions related to the Collatz conjecture
-
mini-math
Lightweight math routines for 3D graphics
-
rust-miller-rabin
Miller-Rabin primality test
-
alpha_g_detector
handle the raw output of the ALPHA-g detectors
-
chime
WIP library for continuous, predictable, mutable change over time
-
rs-measures
macros to encapsulate numbers in measures, provided with units of measurement, allowing any meaningful operation, but statically forbidding meaningless operations with them
-
b-spline
B-spline
-
rcublas-sys
FFI bindings to cuBLAS
-
llml
basic math data types with high level frontend and low level backend
-
rf-core
The core library for the RuFi framework
-
midpoint
Extension traits offering implementations of midpoint [currently, only for primitive integers]
-
triangle
Struct for geometric triangles. Includes Barycentric-Cartesian transforms and stuff..
-
polymath
Make math in Rust more powerful! (New math datatypes, traits, functions, etc...)
-
inexor-rgf-plugin-arithmetic
Inexor - Reactive Graph Flow - Plugin - Arithmetic
-
fdec
A collection of macros for generating fixed-size fixed-point numeric types for Rust
-
math_matrix
highschool level matrix implementation
-
minifb_geometry
meant to help draw shapes in the minifb window
-
duckduckgeo
2d geom library
-
mangle-factstore
Mangle, a logic programming language
-
feval
clt for fast evaluations
-
strnum_bitwidth
calcurate bit width of arbitrary based number string
-
creachadair-imath-sys
FFI bindings to creachadair imath
-
command_line_calculator
command-line calculator
-
binary_matrix
Dense binary matrix operations
-
simple-geom
plane geometry
-
arithmetic-sign
Arithmetic
Sign(≈+1|-1) to/from arithmetic types such asf64,i32utility -
dntk-matrix
Statically sized matrix using a definition with const generics (only for nightly)
-
basic_dsp_interop
Digital signal processing based on real or complex vectors in time or frequency domain
-
MathTriks
A single crate for every mathematical manipulation
-
primenumbe-rs
Generate the nth prime number
-
igrf
International Geomagnetic Reference Field (IGRF) implementation in pure Rust
-
iomath
fast math rust-library
-
calculator-lib
calculator library
-
pulgamecanica_matrix
matrix operations and linear algebra
-
optimization-solvers
Numerical optimization solvers for unconstrained and simple-bounds constrained convex optimization problems
-
cyclotomic
high-performance library for exact operations in cyclotomic fields
-
mersenne-prime-number-miller-rabin
This package provides function to generate Mersenne number and test primality with Miller-Rabin Algorithme
-
projective
The representation projective transformation
-
yaterbilang
terbilang
-
pfapack
Rust interface for the pfapack library, a Fortran library to compute Pfaffians
-
miscmath
will be a collection of general math functions and linear algebra structures like vectors and matrices
-
aviation-calculator
Useful calculations for aviators
-
logicng
Creating, Manipulating, and Solving Boolean Formulas
-
mathvites
An upcoming batteries included library for all things mathematics
-
progress-monitor
Track any progress
-
divisors
A blazing fast library to find all divisors of a natural number
-
cnetworks
A set of tools for creating and manipulating complex networks
-
ImtiazGermain
that checks if a number is a Germain and Imtiaz-Germain prime or not
-
fpn
Fixed point number
-
matlab-sys
Rust bindings for the Matlab C API
-
hcomplex
Lightweight complex and hypercomplex algebra library
-
piss
PISS (Picture Secret Steganography) is a command line tool to encode/decode secrets into/from image files
-
fuzzycomp
Comparison with margins
-
math-shop
mathematical tools in pure Rust
-
ecm
Lenstra's Elliptic Curve Factorization Implementation with Big Integers
-
thinarray
A thin alternative to Box<[T]>
-
parry2d-f64
2 dimensional collision detection library in Rust. 64-bit precision version.
-
testYD_rpncalc
Reverse Polish Notation Calculator
-
gardenerpersonal-rustpkg
that adds numbers
-
inverse-conway
Conway but backward
-
vodk_math
math vector and matrix library
-
nd_vec
A compile time n-dimensional vector library
-
rpn-reckoner
A Reverse Polish Notation library
-
large-primes
Package for Large Prime Number Analysis
-
bitmath
Tools for arbitrary-sized bitwise arithmetic
-
cgmatrix
matrix library for computer graphics in Rust
-
gac
Generic and Atomic Recipe Calculator for Factorio
-
circle-packer
Implements a circle packing algorithm: https://en.wikipedia.org/wiki/Circle_packing_theorem
-
meshcat
interface to https://github.com/rdeits/meshcat
-
smart-adder
this is smart-adder crate
-
rsmonad
Haskell-style monads for idiomatic Rust
-
rblas
BLAS bindings and wrappers
-
hyperoperation
(sometimes known as Knuth's notation) calculation library for Rust
-
ggt
calculate the ggt
-
rubikmaster
Tools to implement Rubik's cube applications
-
knife
An iterator that divides things evenly
-
easygradecalculator
easy grade calculator
-
brevet
Evaluator for Ei calculus with dependent merges and first class environments
-
temperature_calculator
A temperature calculator
-
common_math
A collection of common math functions
-
simple_math_utils
basic math functions
-
strata
A unique search technology
-
babygiant-alt-bn128
implementing a multi-threaded version of the baby-step giant-step algorithm on the Baby Jubjub curve (it is the curve whose base field is the scalar field of alt-bn-128 aka bn254) to decrypt u40 integers…
-
fgruc
Fast graphics rendering utility collection // A collection of utils for graphics rendering and game making made with performance in mind
-
piecewise-linear
manipulating piecewise linear functions
-
radians
storing angles
-
numru
A high-performance scientific computation library written in Rust
-
zonne
Mr.Z's Rust Open Source Library
-
dashu-float
A big float library supporting arbitrary precision, arbitrary base and arbitrary rounding mode
-
rustgf
implements several galois field operation in Rust, as well as gaussian elimination in Galois Field
-
bsd4random
4.4BSD random number generator
-
phy_numerical
Some functions for solving Physics-Physics_Numericals related to first,second & third equation of motion
-
positivity
checking the non-negativity of values across various types
-
matext4cgmath
Unofficial third-party cgmath extensions for calculate eigenvalues, operator norms and Iwasawa decomposition
-
quickmaths
A collection of algorithims for generic mathematics
-
klownie_matrice
My personnel project on matrices
-
reiterator
Lazy repeatable caching iterator that only ever calculates each element once
-
xer_adder
Example crate with a dependency
-
deep_core
deep prototype
-
heuristic-graph-coloring
Heuristic algorithms for graph vertex coloring
-
sleekfft_rs
A high performance FFT library for power of 2 signal sizes
-
fractionfree
Fraction-free linear algebra for ndarray
-
bog
The highly-modular abstraction standard
-
cga2d
2D Conformal Geometric Algebra primitives
-
bsplines
N-dimensional B-spline curves and their derivatives built on top of nalgebra
-
pirox
building a calculator
-
mtrs
matrices in Rust
-
poset
posets
-
eigs
Find Eigenvalues and Eigenvectors with Rust using UMFPACK + ARPACK
-
arithmetic_parser_kma
Arithmetic expression calculator parser
-
polysplit
Algorithm that allows to split polylines into segments by the defined list of points not necessary belonging to the polyline
-
signed
working with signed numbers' absolute values avoiding confusion
-
pekzep_numeral
See https://github.com/jurliyuuri/ckka#%E6%95%B0%E3%81%AE%E8%A1%A8%E7%8F%BE%E6%96%B9%E6%B3%95 and http://jurliyuuri.github.io/lin-marn/lin-marn.html#id317 for more context
-
fem_2d
2D Finite Element Method Toolkit
-
gstools-core
The core functions of GSTools
-
hatree_fock
Hatree-Fock Method implemented in Rust
-
herbie-lint
A rustc plugin to check for numerical instability
-
jacc
Just another cli calculator: A maths interpreter for the command-line
-
goniometry
module for working with trigonometric functions like sine, cosine, tangent and much more to come
-
fitnesstools
Collection of tools related to fitness and weightlifting
-
algeo
Computer algebra, algebraic geometry, and related math
-
tiny-dl
An experimental crate for exploring Description Logic
-
zkp-u256
Performant implementation of 256-bit unsigned integers
-
tscale_sequence
generating tscale sequences
-
mikino
induction and BMC engine
-
math_lib_test
test Library for rust
-
tg-sys
unsafe low-level bindings to the
tggeometry library -
batbox-la
Linear algebra
-
constrained_int
Integers that are constrained within inclusive ranges
-
agg
High-quality 2D graphics engine based on Anti-grain Geometry
-
tetra-master-calc
Calculator for Tetra Master mini-game in Final Fantasy IX
-
entropiter
A no-dep iterator-compatible frequency and Shannon entropy calculator
-
geometric_algebra
Generate(d) custom libraries for geometric algebras
-
rusty-psf
A comprehensive Point Spread Function (PSF) library for microscopy and optical systems
-
openhistogram
Fast, dense, stable auto-binning histograms
-
usze
Sometimes you just need a calculator
-
ipopt_bindgen
Rust bindings to the C interface of Ipopt, a library for large-scale, constrained, nonlinear optimization
-
rust-latex-doc-minimal-example
Minimal crate example for getting latex in docs
-
puan-pv
Propositional logic statements with evaluation functionalities implemented
-
rpn_lib
RPN(Reverse Polish Natation) library
-
arithmetic_parser_smetaniuk
Arithmetic expression calculator parser
-
mm0b_parser
parsing tools for Metamath Zero's MMB binary format
-
cplx
Complex and hypercomplex numbers
-
ezy
Easy to use tweening library
-
lineas
A mathematical linear algebra library for Rust
-
microcad-std
µcad Standard Library
-
hypercpu
Distributed symbolic computation
-
ginger-rs
Parallel Bairstow Root-finding Method in Rust
-
bempp-octree
create Octrees
-
nthD_Matrix
using matrixes of any arbitrary size and dimension
-
gramit
32-bit floating-point graphics math
-
simplicial_topology
Represent, manipulate, combine and perform computations on simplicial complexes
-
rmathlib
Port of R's C Library of Special Functions
-
jl-sys
contains the generated bindings for the Julia C API used by jlrs
-
mathbox
A math toolbox
-
algebr
Basic algebra
-
klein
Bindings to the Klein PGA3D library
-
hundred-doors
calculating and visualizing the '100 Doors' problem
-
symba
Computer Algebra System written in Rust
-
math_parser
A parser for mathematical expressions
-
omni-wave
Easy to use DWT (Discrete Wavelet Transform) library, no need to worry about padding, and a variety of wavelets are available
-
hilbert_index
D-dimensional Hilbert curve
-
xdbuf
reusable multi-dimensional buffer
-
divider
low level 2D path linearize and trapezoidator.fork from makepad
-
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
-
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
-
shapers
fitting shapes and operations on geometrical objects
-
mwa_rust_core
Convenience Rust code that handles coordinate transformations, Jones matrices, etc. for the Murchison Widefield Array (MWA) radio telescope.
-
asmcahligzamaze
Schizm and amalgamation of adventurer's probability distribution across multiverse 2D maze on a single screen
-
math-crate
A libary for doing simple calculations in Rust
-
sofa-sys
Standards of Fundamental Astronomy (SOFA) Rust bindings
-
matriarch
A Linear Algebra and Matrix library written in Rust
-
symbolics_core
Core expression module for the symbolics computer algebra library
-
cubecl-common
Common crate for CubeCL
-
oat_rust
User-friendly tools for applied topology
-
rs_handstrength
relative to board omaha hand strength calculator and equity on flop
-
eldenring-util
Implement common helpers for Elden Ring modding
-
biconnected-components
Find biconnected components in a graph
-
siffra
parse and evaluate human-friendly mathematical and natural language expressions
-
lapack-src
The package provides a LAPACK source of choice
-
q_rsqrt
fast inverse square root function from quake 3
-
normdecimal
Always normal decimal numbers
-
vector-expr
Vectorized expression parser and evaluator
-
mc-vanilla
MinecraftRS - Implementation of vanilla features for Minecraft, this extends and use mc-core
-
minifloat
Emulate various minifloats with const generics
-
ctclib-pp
A collection of utilities related to CTC, with the goal of being fast and highly flexible, with perplexity scores for KenLMs models
-
transformer
Easily transform your structs
-
numera
numbers
-
calculatex
A pretty printing calculator with support for units
-
tfhe-ark-poly
efficient polynomial arithmetic via FFTs over finite fields
-
pow2
Represents a non-negative power of 2, by storing its exponent
-
nvblas-sys
This package provides linkage to NVBLAS
-
equation
mathematical expression evaluation and simplification
-
radian
A normalized angle type
-
percent-rs
percentages of integers and floats
-
ferromagnetic
Calculate the world geomagnetic fields using IGRF/WMM
-
delaunay2d
compute Delaunay triangulations and Voronoi diagrams in 2D space
-
is-thirteen
Did you consider the fact that "Jodie Whittaker" represents the number 13 in some cultures? No you didn't. That's why you need this crate.
-
closed01
checked floating point operations within the range [0,1]
-
rusty-rootsearch
This package implements general one-dimensional root-finding algorithms built on the shoulders of the num_dual crate
-
pcw_fn
Generic piecewise function trait and impls
-
cheque
Convenient checked math
-
shunting
evaluating math expressions
-
simple_calculator_cmd
command line simple calculator and library
-
googology
giving names to large numbers
-
fib-sequence
retrieving fibonacci numbers in base 10
-
mathie
math type library
-
polygon_clipping
An algorithm for computing boolean operations on polygons
-
maria-linalg
linear algebra processing package
-
mathpak
Rust Math Routines, a simple to use math focused library written in rust
-
vlink
made for emberry https://github.com/emberry-org/emberry
-
gs-rs
basic monocular SLAM (Simultaneous Localization and Mapping) Algorithm in pure Rust
-
rubiks-moves
focusing on processing moves for 3x3 Rubiks cube
-
cons-laws
Particle methods to solve 1D conservation laws
-
math-in-rust-doc
Demo of add math to rust doc
-
nonscalar
Functions and types for operating on nonscalar values like vectors and complex numbers
-
jingle
SMT Modeling for Ghidra's PCODE
-
ufo
unsigned floats
-
radix-tools
Tools for computing powers or decomposing numbers by radix
-
rust-rectangles
program that calculates the area of a rectangle using variables, tuples, and structs
-
lambda_calc
A command-line untyped lambda calculus interpreter
-
equationx
parsing and evaluating simple mathematical expressions/equations
-
sjqchat
-
conclave-room
Logic for a Conclave Room
-
fffft
Number theoretic transform for PrimeField types (from ff crate)
-
FEA_code
-
ndvec
low-dimensional vectors
-
rpn_calc_nemutas_20240915
RPN(Reverse Polish Notatio) library
-
c_math
这是一个用于基础数据转换操作的一个包
-
My-7
I'm getting used to Rust
-
radix-number
Rust port of Radix Core Number
-
rmath-cli
cli calculator
-
epsilonz
Functional programming in Rust
-
smartcalc
Text based calculator for peoples
-
angular-units
representing, manipulating and converting between angular quantities in various units through a type-safe interace
-
gauss_adia
Small utility program to compute adiabatic energies for TD-DFT simulations with the gaussian 16 program suite
-
kair
COnstraint Based Reconstruction and Analysis (COBRA) in Rust
-
choice
Similar to
eitherbut supports an unbounded number of variants -
rust-test-crate-multiply
Test rust package
-
gradecalculators
grade calculators
-
raekna-compute
allows evaluating expressions into literals
-
const-trig
providing const trig functions
-
clamped
clamping of numbers in Rust
-
nodarium_utils
A collection of utilities for Nodarium
-
fixnum-approx-eq
Approximate equality checks & asserts for fixed-point precision numbers
-
sylvan_number
My own big number implementation, just for my own uses
-
logic_gate
Logic Gates
-
awint_ext
Externally allocating
awintfunctionality -
fibo
Compute the N-th Fibonacci number with arbitrary number precision
-
citi
Read and write CITI files
-
koek-redact
Allows for redaction of values when outputting them to places where sensitive data is not permitted
-
dlint
lint for deno
-
number-utils
A calculation crate
-
rust-kepler-solver
Efficient solvers for the elliptical and hyperbolic Kepler equation
-
axb
linear algebra
-
bdrk_geometry
Geometry Helpers
-
mixed_radix_counter
A no_std crate for counting in a mixed radix system
-
batbox-lapp
Linear algebra (batbox-la) extensions
-
sukker
Linear Algebra and Matrices made easy!
-
suitesparse_graphblas_sys
Rust bindings for SuiteSparse::GraphBLAS
-
griddy
general-purpose grid/matrix
-
scimath
A scientific computing library. WIP
-
xxcalc
Embeddable or standalone robust floating-point polynomial calculator
-
arcs
An extensible framework for creating 2D CAD applications using the Entity-Component-System pattern
-
rpn_calc_53Tanuki
RPN(Reverse Polish Notatio) library
-
granular-id
ID numbers with arbitrary precision
-
polygamma
function
-
slintcalc
A little calculator
-
moonalloy
The oxidized scientific computing library for the 21st century
-
chord_name
working with chord names in music theory
-
sleef-trig
Port of a few sleef.org trigonometric functions
-
nd_array
linear algebra that tries to have a similar api to numpy
-
pendragon
Easy polygon drawing built on top of lyon
-
extended
precision 80-bit floating-point numbers (f80)
-
geomag-wmm
Calculate the Earth magnetic fields and their variation using WMM
-
pupil
Arithmetic expression evaluator
-
index_key
lexicographic sort order encoding
-
stella
software that finds prime k-tuplets (also called prime constellations)
-
ntt
Fast NTT (number theoretic transform) for polynomial multiplcation for primes, prime power, and certain composite moduli
-
kapacitor-multi-indicator-stream-udf
A multi-indicator stream UDF for Kapacitor
-
snail_nn
small neural network libary, running on the cpu with parallelized stochastic gradient descent
-
ftl-numkernel
designed to provide numerical operations and error handling for both real and complex numbers, also supporting arbitrary precision types
-
aws_volume_limit_calculator
copy of https://github.com/awslabs/aws-support-tools/blob/master/EBS/VolumeLimitCalculator/volume_Limit_calculator.sh
-
primter
Prime number iterator based on sieve of Eratosthenes
-
fast
High-performance SIMD vectorized algorithms
-
tau
The important mathematical constant tau
-
d4-cadical-sys
wrapper around CaDiCaL for d4
-
safe-modular-arithmetic
modular arithmetic algorithms for all integer types in an overflow-safe and const-compatible manner
-
ak_arith_crate
perform arithmetic operations on i32 data type instance
-
multi_dim_point
multi-dimensional point
-
rMaths
Maths library made for Rust developers with ❤
-
shoelace
formula in your project
-
trianglo
Stupidly Fast And LightWeight Crate To Calculate Square Root & Logarithm
-
spiro-inner
Raph Levien's C implementation of Spiro in pure Rust, transpiled by C2Rust and then heavily edited
-
quake-inverse-sqrt
Quake Inverse Square root alghorithm
-
libdivide
Port of libdivide
-
RustPrimeNumberLibrary
Rust prime number checker library now step 1 is importing create and calling function and put one parameter. This prameter data type is u32
-
eprmutate
Permutation Library
-
lifeless
A no_std-friendly library for implementing Conway's Game of Life
-
ark-ff
finite fields
-
strict_types
Strict types: confined generalized algebraic data types (GADT)
-
mathlib
A math library for Rust
-
maglio
non stable package for 3d maths
-
lucent
toy programming language based on the calculus of constructions
-
unsigned-f64
A wrapper around f64 that guarantees that the value is always non-negative on the type level
-
symmetric-interaction-calculus
A programming language and model of computation that matches the abstract algorithm perfectly
-
big-num-manager
Rust big num manager
-
lamcal-repl
A lambda calculus command line repl
-
yz-curvep-exs
examples of curve paramterizations
-
geom2d
useful for manipulation of various of types including: numerals, points, vectors, etc... and includes various methods for flexibility.
-
doem-math
Const generic linear algebra math crate for 3D applications, made in conjunction with doem
-
a_add_b
这是一个两数相加的方法
-
matchmaker
fairly match students to categories
-
floorAndCeiling
Tiny crate that contains floor and ceiling functions
-
gear_combos
Attempts to make getting combinations of things easier with the use of gears and simple numeric states!
-
whiteboard
A math library made by someone not qualified to be making math libraries
-
square_calculator
Square Calculator
-
infinity-euler
These are my solutions to Project Euler implemented in Rust
-
toronto
Tools from me
-
ospf-rust-math
A math utils for ospf-rust
-
nd_vector
[WIP] Lengthen! Shrink! Iterate! Scale! Twist and turn to your imagination along any dimension on a vector!
-
camctrl
Camera control math
-
linea
Linear Algebra: Vectors and Matrices
-
planar
Strongly typed planar geometry
-
nabo-pbc
A fast K Nearest Neighbor (KNN) library for low-dimensional spaces, now with support for periodic boundary conditions
-
simple_calculator
First Library
-
safe_decimal
that solves the recurring decimal problem with fractions
-
hipparchus-geo
latlon, ellipisoid & geodesic calculations
-
numerical-linear-algebra
linear algebra implemented using numerical methods
-
surreal
that implements J. H. Conway's surreal numbers
-
calculator_util
that helps you evaluating mathmatical expressions
-
vtrig
Hidden trigonometry functions with their derivates and integrals
-
doctor-syn
Computer algebra system for Rust expressions
-
chains_f2vect
chain complexes and dg algebra manipulations
-
measurements
Handle metric, imperial, and other measurements with ease! Types: Length, Temperature, Weight, Volume, Pressure
-
sophus_opt
Sparse non-linear least squares optimization
-
modcholesky
Modified Cholesky decompositions
-
gated-development
Pedagogical implementation of command line calculator using basic logic gates
-
pincer
Generate permutations & combinations
-
math_test
Generates math questions for elementary school kids
-
hercules
A Heuristics toolbox for QUBO in Rust
-
mfem-sys
Rust bindings to MFEM
-
byte_arithmetic
arithmetic on byte-like objects
-
nekocalc
A Calculator
-
qvnt-i
Advanced quantum computation simulator
-
nzprimes
Output n primes numbers as decimal numbers, one per line
-
butterworth
filters
-
math-concept
Common math concepts from Computer Science classes, implemented in Rust
-
demo_test_add_2_numbers
Function for adding 2 numbers
-
arith
containers with arithmetics
-
rbf-interp
Radial Basis Function multidimensional interpolation
-
orca-rs
ORCA algorithm
-
pow_of_2
Integer-like types which can only represent powers of 2
-
talna
WIP
-
haversine-formula
Haversine formula
-
demo_crate_dia
Calculator
-
quickbrain
neural network library
-
vajra
-
haxcel
Excel gateway to Haskell
-
irox-fixedmath
Fixed Precision Math Primitives
-
const_fixedp
A const type for fixed point arithmetic
-
math_l
Math Functions for LeetCode
-
calculi
used to apply calculus functions on equations in string form
-
makepad-geometry
Geometry tools
-
mtl
Matrix template library. Dense2D matrix, SparseMatrix.
-
astro_nalgebra
astro-float for nalgebra
-
spv-rs
Math utility for astronomical data
-
doodle_unit_tools
handling and working with multiple different unit types
-
nines
9-Slice scaling math
-
pmsim
Porous media simulator
-
sat_toasty_helper
more-easily writing SAT constraints
-
cmath
一个新手的尝试
-
vec-utilities
A collection of methods that make working with Vecs of floats easier
-
unit18
whp-unit18
-
unit17
whp-unit17
-
simple_math
lib to do some mathematical manipulation
-
cellular-snapp
Create cellular automata
-
conum
big numbers, specified by arbitrary digit widths
-
simple_accumulator
accumulator for incremental statistical computations
-
traitgraph-dimacs-io
Functions to read and write graphs in DIMACS format
-
rantlib
Analysis Library for Non-linear Dynamical Systems written in Rust
-
lanczos
algorithm for eigen decomposition
-
ultrametric_matrix_tools
Toolbox that provides functions and data structures to generate and handle ultrametric matrices
-
egml-io
IO operations for processing GML data
-
matrix_operations_cuda
perform matrix operations using cuda
-
general_tools
offers many functions for many different types of operations, such as operations with strings, numbers, files, and more!
-
polyhorn-style
Shared types for Polyhorn style
-
bevy_lunex
Blazingly fast retained UI layout engine for Bevy ECS
-
legasea_line
Tools for working with lines
-
big_num
A big number implement in rust
-
aeiou
Algebraic effects
-
options-common
working with financial options
-
nice-numbers
Small library for number sequences
-
splinosaurus
flexible spline and surface library
-
rusoda
Pure rust and just need log dependencies implementation of odepack dlsoda
-
fuzzy_fraction
Struct for approximated human-readable fraction representation
-
Circle_Area
circle of area function
-
rascal-scheme
Rascal Scheme
-
topological_peak_detection
A mostly efficient topological algorithm for finding all peaks in a 1-D signal
-
vkfft
Rust bindings for VkFFT
-
negie
Generate complex scatter plots of eigenvalues from parametrized bohemian matrices
-
rawarray
file format for retrievably storing n-dimensional arrays
-
lie
A numerical library for working with Lie Groups and Algebras
-
pga2d
tools for 2 dimensional projective geometric algebra
-
smartcalc-tui
Terminal UI for erhanbaris/smartcalc
-
vec4
-
adder_trial
has a function
-
data-pipeline
A functional and extensible library for organized lazy processing of data with minimal overhead
-
nalgebra-lapack
Matrix decompositions using nalgebra matrices and Lapack bindings
-
mumps-src
Build Mumps as a crate
-
num-iter
External iterators for generic mathematics
-
unit-root
Unit root tests
-
rustplexity
bigram-based perplexity calculator, useful for filtering out boilerplate or other abnormal text
-
mathml-rs
MathML parser written in Rust
-
thirteensea
Test publish crate
-
calc_lib
calculating things with correct order of operations
-
markovian
Simulation of Markov Processes as stochastic processes
-
mrgraph
High-level Meritrank library
-
calcrs
A command-line calculator with everything you need
-
ux-indicators
Technical Analysis Function Library
-
dimensional
Functions, structs, and reference data for working with dimensional values, such as '1 second' and '3 miles per hour'
-
math-commons
math utils for rust
-
pboddupalli-helloworld
hello world package to understand packages, crates, modules
-
fibonacci-like
A small crate to help you interact with second order sequences, such as the Fibonacci sequence, with no_std support
-
real_float
Floating point types that check for correctness and implement total ordering
-
logik
Calculator for propositional logic formulas
-
currencies-core
core types for the currencies crate
-
trilean
Kleene's three-valued logic (boolean + unknown)
-
modinverse
Small library for finding the modular multiplicative inverses
-
dimensions
Struct(s) for handling dimensions
-
hann-rs
Blazingly fast Rust Hann Window
-
dusk-schnorr
A pure-Rust implementation of Schnorr signatures with a PLONK circuit module additionally
-
neis_calculator
bytes counter for NEIS
-
voroxx
Voro++, a 3D cell-based Voronoi library
-
ndelement
n-dimensional finite element definition library
-
voronoi
compute Voronoi diagrams, using Fortune's sweepline algorithm
-
add_one_hammahutz
Add one to a random number
-
nummer
minimal ndarray
-
simpler_vector
a very simple library for 2d/3d vector math
-
polyhedron-faces
polyhedron faces for Rust
-
normform
handling normal forms
-
spdcalc
Spontaneous Parametric Downconversion Calculator
-
lidrs
reading and representing light intensity distributions via photometric webs
-
gandiva_rust_udf
gandiva rust udfs
-
kalc-kman
Is a calculator for math
-
zkp-primefield
A 251-bit prime field suitable for FFTs
-
sinorust
hello world!
-
mdmath_core
Multidimensional math, fundamental functionality and types
-
static_linear_algebra
A static linear algebra library where size compatibility of operations are checked at compile time
-
kilac
ARCHIVED PROJECT
-
divisor_networks
Discrete Graphs for Indiscrete Researchers - Networks with Grothendieck Topology
-
rexl_matrix
matrix library for Rust
-
clblast
bindings for rust
-
translating-symbolic
A program to translate symbolic sequences from a circle map with two branches to a circle map that is the first map repeated twice. Refer README.
-
fj-export
Early-stage b-rep CAD kernel
-
routrs_highways_dataset
Highways dataset for routrs, the geograph-based shortest distance calculator for Rust
-
dsif
Dead simple integer factorization
-
fractran_rs
A FRACTRAN interpreter
-
euclidean_algo
euclidean algorithm to find the greatest common divisor
-
savage
A primitive computer algebra system (REPL)
-
rust_geometry
A geometry library for problems in ICPC programming contests
-
bose
mathematical and scientific formulas
-
robust-geo
floating-point expansions and geometric tests (https://people.eecs.berkeley.edu/~jrs/papers/robustr.pdf)
-
sna
Serial Number Arithmetic (RFC 1982) for Rust
-
mematrica
An easy to use library for working with matrices
-
lambert-bate
A fast solver for Lambert's problem
-
bq
A complete implementation of dual quaternions
-
librsb-sys
FFI interface for librsb
-
malachite-nz
The bignum types Natural and Integer, with efficient algorithms partially derived from GMP and FLINT
-
rufft
A pure rust FFT library !
-
gates
simulate logical gates
-
kahan_pairs
Generate pairs of integers
-
clnooms
Assembly-level implementation of interesting data types
-
condest
1-norm and condition number estimator by Higham and Tisseur, 2000
-
gali
untyped lambda caluculus, with some sugar for convenience
-
rug-gmpmee
Rust FFI bindings for GMPMEE
-
ark-ec
elliptic curves and pairings
-
lat
easy matrix manipulation on a component wise level - no linear algebra
-
rust-numpy
A row version of a convinient rust-numpy library which target is to dublicate functionality of well known python library 'numpy'
-
unit9
whp-unit9
-
benford
test the Benford-ness of a given set of numbers
-
siege-math
Math library for the Siege Engine
-
raith-common
learning project
-
yaccas
Callback-orientated Command line pArSer - nomen est omen
-
dexterior-core
Core crate of dexterior, a Discrete Exterior Calculus toolkit
-
delaunay
The representation of delaunay triangulation
-
numerical
Algorithm for numerical analysis
-
ruut-algebra
An incredibly minimal linear algebra crate meant to be used for ruut-functions
-
math_64
Only the numbers 1, 3, 5, 7 or 9 work. It's very odd.
-
neapolitan
Easily model and solve circuit-like problems
-
mee6
calculate mee6 leveling data
-
tmn
Instrument for working with complex numbers and quaternions
-
mathkid
Maths questions for kids
-
halfpoint_rs
Half-precision floating-point number
-
beeg
easy big number conversion
-
bvrs
A lightweight rust library for BitVector Rank&Select operations, coupled with a generic Sparse Array implementation
-
algebraeon-geometry
Algorithms for working with geometric shapes
-
adder_4702
This package calls the
add_onefunction from theadd_onelibrary -
wgm
A fast and simple math library for game and graphics development
-
math2d
2D Mathematics library designed for use with 2D drawing applications. Primarily designed for the needs of Direct2D, but this library should be perfectly capable of filling in the needs of other libraries such…
-
math_thingies
math thingies, traits. For self use
-
ju-rust-23-10
Head & Tails
-
yttria
that re-exports the other yttria sub-libraries for radio application development
-
snafu-numbers
Special Numeral-Analogue Fuel Units
-
ivory_kinematics
Kinematics library for Project Ivory
-
cartesian_trajectories
create cartesian motion profiles
-
clac
command-line calculator
-
machine_int
std::num::Wrapping on steroids
-
tactile
representing, manipulating, and drawing isohedral tilings on the plane
-
factorprime
finding whether a number is prime or not and also determine its factors
-
persentage_calculator
its calculate your persentage by your given input , input1 = marks_obtained and input2 = total_marks
-
xfft
Fast Fourier Transforms
-
Calculater
just for practice do not use this library Thank you
-
optim
combinatorial optimization tools
-
ticktick
-
vqf-rs
A
no-std, dependency-free port of VQF sensor fusion algorithm for IMUs -
permutations
generating permutations
-
mpt_lib
a function libaray for modern portfolio theroy
-
calculator_function
some description
-
geogebra-types
Geogebra types and API for building them
-
cenv_core
The internals for the cenv project, designed to be shared amongst different implementations
-
miller_rabin
A multi-threaded, arbitrary precision implementation of the Miller-Rabin primality test
-
foocalc
A command line RPN calculator with multiple precision and unit support
-
libnzprimes
Provide and maintain a list of prime numbers from 2 to what you need. Slow algorithm suited for the primes number below 1000000.
-
gategen
generate Gate circuits
-
nut_sys
Wrapper for Number-Theory-Utils C library
-
hexagon_tiles
that allows working with the hexagon shape and related math
-
dioxus-katex
Render math with KaTeX in Dioxus!
-
butter2d
Butterworth filter for image processing
-
some_math_lib
A basic math library
-
lorust
Modern Rust utility library delivering modularity, performance & extras; or simply Rust version of Lodash
-
redc
Unsigned integer types which are constrained within a modular field using montgomery multiplication, never overflowing or exceeding the modulo
-
sat-rs
A SAT solver written in Rust
-
hwcalc
An arbitrary bit-width calculator
-
i48
working with 48-bit integers
-
cellular_raza-building-blocks
cellular_raza Building Blocks
-
kct-crate-publish
calculate the fibonacci sequence, used to demonstrate how to publish a crate to crates.io
-
nalgebra-numpy
conversions between nalgebra and numpy
-
geomath
Stack-allocated maths for geometry, simulation and computer graphics
-
zero_based_index
Newtype offering some utility methods for zero-based indices
-
gemm-f16
Playground for matrix multiplication algorithms
-
const-decimal
Integer-backed decimals with constant precision
-
twoword
Construct bigger uints by combining two smaller ones into a two-word uint
-
blend-formula
macros for defining GPU blend modes from arbitrary formulae
-
faer-evd
Basic linear algebra routines
-
caliphui
calibrate and convert pH measurements using a two point method
-
frechet
basic autodifferentiation
-
deltav_calc
Allows you to generate a graph representing a delta'v map used in the game Kerbal Space Program
-
fractran
execute Fractran programs
-
pop-prob-cli
A population probability calculator
-
max_len_base_10_as_usize
Trait offering constant maximum lengths of primitive integers as usize
-
scal
Calculator that can add, sub, mul & div two input num
-
poseidon-paramgen
generating Poseidon parameters
-
antic
bindings for the antic C library for algebraic number theory
-
frames
Contextual frames made simple
-
rust-test-crate-add
Test rust package
-
rustmex
providing convenient Rust bindings to Matlab MEX API's
-
temp-converter-lib
terminal temperature unit converter between Celsius, Fahrenheit and Kelvin
-
accelerate-general
A general matrix and vector operations library using Apple's Accelerate framework
-
lsode
Solve systems of differntial equations using LSODE subroutine from ODEPACK written in Fortran
-
idem
0 and 1
-
overflower_support
A bunch of specialized traits + impls to allow automated overflow handling without type inference. Nightly only
-
libmath
Mathematical utilities
-
summed-area
table for fast sums or averages of subsections of a 2d array or an image
-
memu
Implementations of memory units and working with them
-
caliph
calibrate and convert pH measurements using a two point method
-
differential-geometry
differential-geometric calculations
-
opensrdk-symbolic-computation
Standard automatic differential library for OpenSRDK toolchain
-
claire_vector
claire is a rust lib for vector calculus
-
norman
Implementations of different norms for elements of vector spaces
-
C4lc
A program to help you access the public functions in this code and to perform mathematical calculations, including addition, subtraction, multiplication and division
-
rsmt2
Wrapper for SMT-LIB 2 compliant SMT solvers
-
molecules
working with molecules and molecular dynamics simulations
-
rpn_calc
RPN(Reverse Polish Notatio) library
-
tropical_algebra
tropical algebra in Rust
-
acm_dependent
Project dependent on the arithmetic_congruence_monoid library for working with arithmetic congruence monoids (ACM)
-
elinor
Evaluation Library in Information Retrieval
-
blis-sys2
FFI bindings for BLIS library (depends on blis-src)
-
clipcalc
calculator that reads from the clipboard and writes the result back to the clipboard
-
emath
Minimal 2D math library for GUI work
-
cassie
limited computer algebra system written for the fun of it
-
pnets_shrunk
A reducer for petri nets
-
matrix_algebra
supporting matrix algebra
-
digraphx-rs
Network Optimization Algorithms in Rust
-
crook_calculator
one function to compute mathematical equations from string slices
-
csparse21
Sparse Matrix Solver
-
rsruckig
Ruckig motion planning library for Rust
-
float_math
Does math on floating point values
-
pandas_rs
General Mathematics Library for Rust,Inspired by Python Pandas Library
-
moving-average
moving average library
-
croot
finding real and complex roots
-
bellande_node_importance
calculating n-dimensional node importance via API or local executable
-
unit4
whp-unit4
-
mech-matrix
Matrix library for the Mech language
-
dashu
set of big numbers
-
ark-poly-commit
constructing polynomial commitment schemes for use in zkSNARKs
-
rustc_apfloat
Rust port of C++ llvm::APFloat library
-
flowscad
2D graphic and 3D object design with a Rustic functional approach. SVG and OpenSCAD output.
-
rust-gmp-kzen
Rust bindings for GMP
-
ipasir-sys
that contains FFI bindings for IPASIR-compatible SAT solvers
-
xer_add_one
Example dependency crate
-
cereal_lib
Does the cereal box problem in either single or multi-threaded mode
-
proto-vulcan
A miniKanren-family relational logic programming language embedded in Rust
-
log_domain
Logarithmic representation of floats
-
vecto
vector2
-
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…
-
mat-rs
no_std implementation of mathematical matrix types
-
math_table
Randon Mathemetical & Multiplication Table Generator
-
amfnwasm
Amortization Functions (AmFn) Web Assembly
-
alphabet
working with alphabets
-
gemau
The beginnings of a computer algebra system for Combinatorial Game Theory
-
Engima
A command line interface for an Enigma machine simulator. Configurable with any reflector, number of rotors, and plugboard pairs.
-
full
Matrix and array types for numeric values
-
rust-fixed-point-decimal
Decimal fixed-point arithmetic
-
anndata-memory
Thread-safe AnnData-like structure for single-cell genomics data in Rust. Provides controlled mutability, efficient memory management, and flexible data manipulation. Ideal for concurrent bioinformatics applications.
-
rustamath_mnmz
Minimization functions
-
coin_cbc_sys
Rust bindings to the CoinOR CBC MILP Solveur using the C API
-
bignumber
arbitrary-precision decimal and non-decimal arithmetic
-
rust_ev_verifier_application_lib
common elements to implement an application using the crate
rust_ev_verifier_lib -
prime_bag
A bag datatype that used unsigned integers for storage
-
vecn
A procedural macro that transforms user-defined structs into general vector types
-
mc-core
MinecraftRS - Minimal core implementation of Minecraft backend
-
gml
Graphics Math Library. Generic Vector and Matrix Math library targetting graphics applications.
-
lmaths
A short 2D Maths library
-
online-statistics
Blazingly fast, generic, and serializable online statistics
-
gamemath
math library for game development, written in Rust
-
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… -
oscirs_linalg
GPU accelerated linear algebra crate for scientific computing
-
arith_traits
Traits unifying types based on various supported arithmetic operations
-
vector_calculus
A single easy-to-use library for all vector calculus computations
-
super_ultra_rpn_calc
RPN(Reverse Polish Notatio) library
-
r2rs-nmath
Statistics programming for Rust based on R's nmath package
-
linearkalman
Linear Kalman filtering and smoothing
-
complex_algebra
supporting complex number algebra
-
pire-dev
high performance cpu kernels
-
rbt3
Rigid body transform
-
parametrics
working with parametric functions
-
simple-interpreter
interpreter based on reverse poland notation
-
swnb-complex
complex number lib
-
mfcc
Calculate Mel Frequency Cepstral Coefficients from audio data
-
eigenvalues
algorithms to compute eigenvalue/eigenvectors of symmetric matrices
-
hilbert16
Hilbert transforms between 1D and 2D space, optimized for u16 coordinates
-
csaps
Cubic spline approximation (smoothing)
-
moo-math
math interpreter
-
d4-gmp-sys
wrapper around GMP for d4
-
rust_decimal_cql
that wraps rust_decimal::Decimal and implements traits for integration with ScyllaDB's native DECIMAL column type
-
rustlinalg
linear algebra crate to support crustacea ML crate
-
colon
A array and number utility functions
-
qrotate
Quaternion library for 3D rotation of vectors
-
rustbot
My package for aimbot calculations / vector math
-
del-geo-core
2D/3D geometry utility codes
-
polyeval
Evaluate polynomials
-
fenris-geometry
Geometry functionality for fenris
-
logsumexp
Numerically stable computation of log-sum-exp using a 1-pass algorithm
-
numlib
numerical library implementing common numberical algorithms in rust
-
kolakoski
sequence iterator
-
koto_geometry
A Koto library with basic geometry types and operations
-
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…
-
guff-ida
Information Dispersal Algorithm
-
schroidnger_equation
intuitive way to simulate the evolution of a quantum wave function as described by the Schrödinger equation
-
clamped_values
generic
ClampedValuestruct that stores a value and ensures that it is always within the specified minimum and maximum values -
acme-tensor
A comprehensive tensor library for Rust with support for automatic-differentiation
-
ratio-dsm
Ratio's DSM plotting library
-
rapier_testbed3d
Testbed for the Rapier 3-dimensional physics engine in Rust
-
beagle
A basic linear algebra library for computer graphics
-
binary-space-partition
Abstract BSP tree
-
multrix
matrix multiplication and manipulation library with multithreading support
-
finitefields
Perform algebraic operations between integers over a finite field
-
scalar
A trait for scalars (integers and floats)
-
swh_graph_topology
Collection of topology analysis utilities based on swh-graph
-
base95
Textual representation of base 95 fractional numbers with arbitrary precision
-
bempp
Boundary element method library
-
matlabblas-src
Provide a source for MATLAB's BLAS library for use with the BLAS crates
-
zetik_prime
generating prime numbers with an iterator
-
magnesia
A math library for Rust
-
optlib
The optimization algorithms realized in Rust. In given time realized genetic and particle swarm algorithms.
-
flexint
Big integer types, optimized for small values
-
hipparchus
<!-- TODO -->
-
parity
is_even and is_odd methods for primitive numeric types
-
set-partitions
Represent and enumerate set partitions
-
bies_math_parser
math parser built for use with graphing
-
fixed-point
Fixed point numbers
-
iltcme
Inverse Laplace transform with concentrated matrix-exponential functions
-
num-ord
Numerically ordered wrapper type for cross-type comparisons
-
mangle-analysis
Mangle, a logic programming language
-
small_matrix
matrix library made in Rust
-
prop
Propositional logic with types in Rust
-
dinglebit_combinatorics
A collection of combinatorics utilities
-
polynomial-roots
Find the real roots of huge polynomials in milliseconds
-
ggmath_testing
testing tool for custom ggmath scalars
-
numeric_constant_traits
Traits for generic numeric constants
-
c-prime
Convenience wrapper for machine-prime
-
stack-algebra
Stack-allocated lightweight algebra for bare-metal rust
-
afarray
Convenience methods for working with ArrayFire arrays in Rust
-
pico-lang
JSON Logic like language
-
better-num
Better numeric types in rust
-
upload_to_crate_io
Review Upload
-
microcheby
Single variable function approximation using Chebyshev polynomials. Embedded friendly and no_std compatible.
-
logical_gate
A logic gate crate
-
min_max_traits
Traits for MIN and MAX associated constants
-
sparse21
Sparse Matrix Solver
-
stat-rs
A statistics library
-
st
Fast and simple statistics on the command line
-
dynamic_poisson_sampling
A poisson disk sampling with dynamic distance
-
ndmath
Traits for doing vector geometry operations using built-in types
-
gomez
Framework and implementation for mathematical optimization and solving non-linear systems of equations
-
cisat
Cognitively-Inspired Simulated Annealing Teams
-
wright_omega
Wright Omega function
-
euler-rs
A command line tool for solving Project Euler problems in Rust
-
approxeq
A trait for approximate equality of types
-
num_base
manipulating with numbers (integers) in different bases
-
modulo-n-tools
modulo tools
-
codemonk-primes-cli
A command-line utility for finding prime numbers
-
sqrt-rs
Stupidly Fast And LightWeight Crate To Calculate Square/Cubic Root In Different Ways
-
math_quix
math quiz cli to practice basic arithmetic
-
fixed-vectors
Lightweight library implementing fixed-length vectors for Rust applications not compiled with the standard library
-
inexor-rgf-model-arithmetic
Inexor - Reactive Graph Flow - Model - Arithmetic
-
matrix-rs
using matrices in rust. Uses const generics to ensure compile-time matrix safety.
-
random-distributions-cli
generate samples from various random distributions, as a text lines or a binary stream. Includes a general form of Stable distribution.
-
ndarray-odeint
solve ODE using rust-ndarray
-
ferrous-simple-calc
Example crate: simple calculator
-
umath
ffast-math in rust
-
modmath
Modular math implemented with traits
-
aljabar
A super generic, super experimental linear algebra library
-
hipparchus-mean
A collection of basic mathematics solver: Lp norm, mean, moving average, sequence
-
compensated-summation
Compensated summation algorithms for better precision
-
d3_geo_voronoi_rs
A port into rustlang of the javascript library d3-geo-voronoi
-
qmu
Quigly's Math Utility
-
arpack-ng-sys
Bindings to arpack-ng
-
rect-lib
working with anything vaguely rectangular
-
intel-mkl-tool
Seek Intel(R) MKL library from system
-
dcim
dc improved - Expanded rewrite of a classic RPN calculator / esoteric programming language
-
discrete_transforms
Discrete Transforms
-
trust-graph-distro
Distribution package for the trust-graph service
-
cf_functions
has characteristic functions for a variety of distributions
-
math-symbols
Symbols for computer algebra
-
allen_interval_algebra
package for interval algebra for more information see https://en.wikipedia.org/wiki/Allen%27s_interval_algebra
-
antipode
Compute the antipode of a geographic point
-
temex
Regex-like temporal expressions for evaluating systems that change over time
-
cavalier_contours_ffi
C foreign function interface for the cavalier_contours crate
-
derangement
permutation with no fixed points, a derangement
-
df-maths
maths
-
eskf
Navigation filter based on an Error State Kalman Filter (ESKF)
-
quantum2
Advanced Rust quantum computer simulator, forked from "quantum"
-
factrs
Factor graph optimization for robotics
-
lapack-sys
The package provides bindings to LAPACK (Fortran)
-
gplu
Sparse LU factorization with partial pivoting
-
spice-sys
Thin wrapper for the C language implementation spice toolkit from NAIF
-
isEven
Returns true if the number is even
-
replicante_logging
Replicante common logging logic
-
eletric_calc
Calculator for Ohm's law
-
math
A math library
-
calculate
parsing and processing arithmetic expressions
-
mady
🌲 ahead-of-time automatic differentiation
-
cubic-splines
fitting cubic splines to datasets
-
precise-calc
A high precision calculator library and command line tool
-
arb-sys
Bindings to the Arb library
-
jpl-sys
Project Pluto JPL Ephemeris Rust bindings
-
rstm-core
focuses on building concrete implementations for Turing Machines
-
gaussfilt
Design and apply Gaussian filter for 1D data
-
ajkcalc
scriptable hybrid calculator
-
f64ad
Easy to use, efficient, and highly flexible automatic differentiation in Rust
-
modtype
Macros that implement modular arithmetic integer types
-
dt
distance transform
-
numrs
A numerical computations library for Rust
-
symbolic_polynomials
manipulation of polynomials over the integers
-
qcd-sme
numerical library for the screened massive expansion of QCD
-
algebraic-gen
Procedural Macro for Geometric Products of Any Dimension
-
histo_fp
histograms with configurable floating point buckets and floating point samples
-
del-fem
finite element method (FEM) utility codes
-
ralgeb
This package has some mathematical tools to allow user perform operations on Point, Line, Circle, Matrix
-
core-math
API for CORE-MATH
-
rainbow-shared
Don't depend on this directly - rainbow shared utilities 🌈
-
numeric
N-dimensional matrix class for Rust
-
geo-aid-svg
Support for SVG output from Geo-AID
-
makima_spline
modified akima spline interpolation
-
machine-factor
constant factorisation for machine-size integers
-
primefactor
finding whether a number is prime or not and also determine its factors
-
iseven_api
wrapper for isEven API
-
xcomplex
A complex number library
-
rink-js
Wasm bindings to Rink, for use in rink-web
-
fdecimal
Arbitrary precision fast decimal numbers
-
libreda-logic
Logic library for LibrEDA
-
routrs_railways_dataset
Railways dataset for routrs, the geograph-based shortest distance calculator for Rust
-
exponential-integral
The exponential integral function, a.k.a. Ei.
-
rusty-compression
Low rank compression algorithms in Rust
-
klick-domain
Calculate the carbon footprints for wastewater treatment plants
-
rapl
that makes numerical scripting with Rust simple and enjoyable
-
gon
Easy polygon drawing built on top of lyon
-
argmin_testfunctions
Test functions for optimization algorithms
-
shigens
A math library for calculate quaternion
-
postfix
expression evaluator
-
intervals-good
An interval arithmetic library with support for many functions and which tracks when domain errors may occur or are guaranteed to occur
-
plotters-fullerene
plotters fullerene and polyhedron for Rust
-
fftw
safe wrapper of FFTW3
-
sized_matrix
Sized matrices using const generics for better type checking and performance
-
z3tracer
Parser for Z3 tracing logs
-
igsolve
The program for solving impartial games
-
poke-type
A Pokemon type effectiveness calculator that accepts arbitrary type combinations
-
crlibm
Binding to CRlibm, a correctly rounded math lib
-
points_between
API to list the evenly-spaced discrete points between two N-dimensional points
-
type-equalities
Observing type equality with zero-sized proofs
-
galois_field_2pm
Galois Field (2^M) arithmetic
-
laddu-amplitudes
Amplitudes for the laddu library
-
orfeo_rpn_calc
RPN(Reverse Polish Notation) library
-
calcify
Physics vector library
-
field-matrix-utils
working with matrices over finite fields
-
alpha_g_physics
Data analysis library for the ALPHA-g experiment
-
gcv_spline
fitting and evaluating GCV splines
-
libmat
tools for linear algebra
-
sprs_suitesparse_ldl
sprs bindings to the suitesparse ldl solver
-
metamath-rs
manipulating Metamath databases, including a parallel and incremental verifier for Metamath databases
-
sparse-interp
Basic univariate polynomial arithmetic and sparse polynomial interpolation
-
nalgebra-sparse
Sparse matrix computation based on nalgebra
-
fj-kernel
Early-stage, next-generation, code-first CAD application. Because the world needs another CAD program.
-
wicker
Weighted probability picker for Rust
-
symbolics_calculus
Calculus module for the symbolics computer algebra library
-
gee
A convenience-first geometry library tailor-made for 2D games! 📐
-
irox-unsafe
irox (unsafe) Rust Tools & Libraries
-
l_calc
Levi's world renown calculator that can do some addition and subtraction!
-
mathew
Mathematical expression evaluator with context
-
qalqulator
A calculator that uses (and outputs) rational numbers wherever possible
-
lambdas
defining domain specific languages in a polymorphic lambda calculus
-
rexl_math
mathematics library for Rust
-
GSL-sys
binding for the GSL (the GNU scientific library)
-
qhull-sys
Rust bindings to Qhull
-
rust_combinatorics
Combinatoric utilities and functions for rust
-
expm
matrix exponential function by Higham and Al-Mohy, 2009
-
awint_dag
DAG
awintfunctionality -
polynomials
Tools to perform polynomial arithmetic and evaluation
-
envisim_samplr
Sampling methods for balanced and spatially balanced sampling
-
rsmaxsat
that provides bindings for the MaxSAT solver
-
boostvoronoi_core
Boost voronoi private workspace (this workspace will be re-integrated in the main crate in next release)
-
kukan
powerful tool for mathematical interval
-
psy-math
A fork of jet-proto-math. Helpful math utilities, used by PsyLend.
-
ruint-macro
The
uint!macro forUintandBitsliterals -
tri_poly_moment
Calculate moments of random variables. The distributions of the random variables are normal, uniform, and exponential.
-
mapping-suites
A collection of SLAM suites, based on mapping-algorithms
-
kalk_cli
A calculator that supports user-defined functions, variables and units, and can handle fairly ambiguous syntax
-
yttria-coding
A mathematical coding library tailored for use with the yttria set of libraries
-
ndarray_tools
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… -
ark-bls12-377
The BLS12-377 pairing-friendly elliptic curve
-
matio-rs-sys
Rust binder to MATLAB MAT file I/O library
-
natural_constants
Pre-defined constants from all disciplines (math, physics, ...)
-
polynomial-ring
A polynomial implementation
-
ipasir
Bindings for the IPASIR API to communicate with incremental SAT solvers
-
ludomath
A math library for 2D games and graphics
-
shape-triangulation
The representation of delaunay triangulation
-
smtlib-build-util
The build utils for building the smtlib family of crates
-
rgaussian16
Interface for the Gaussian16 quantum chemical package. This structure provides functions for auto generating input, and running the external program g16.
-
const-linear
linear algebra library based on const generics
-
amfnbatch
Amortization Functions (AmFn) Batch Process
-
geom
2D geometry library
-
linbra
Easily do linear algebra in game development, graphics and other sorts of calculations using vectors and matrices
-
yices2-sys
Low level Rust bindings to the Yices 2 SMT solver
-
tnt
runtime validated proofs in number theory
-
decorum
Total ordering, equivalence, hashing, and constraints for floating-point types
-
npy-writer
Export numpy arrays in the npy or npz format
-
yaum
Units of Measurement
-
trussx
designing and analyzing truss structures
-
fixed-exp
Exponentiation for fixed-point numbers
-
goldilocks-ntt
fast NTTs over the Goldilocks prime field
-
factorial-mod
Fast mod for $n! % p
-
normal-form
A trait to easily find the canonical/normal form of graph structures
-
graff
manipulating graphs
-
tilted
A toy mathematical interpreter written in Rust
-
lineq
Linear algebra library
-
primerug
A prime k-tuple finder based on the rug crate
-
taxicab-map
Coordinate transformation and pathfinding for Taxicab Geometry
-
candle-gemm-common
Playground for matrix multiplication algorithms
-
vec3-rs
3D vector math library
-
bitslice
transpose bits into and out of bitslice format, and perform various operations on bitsliced data
-
goertzel-nostd
An nostd implementation of Goertzel's Algoritm
-
pnets_tina
A parser for tina Petri net
-
renplex
capable of modeling complexed-valued neural networks built with Rust
-
linalg-rs
Linear algebra in Rust!
-
suitesparse_camd_sys
Raw bindings to SuiteSparse's CAMD algorithm
-
wmathrs
mathematical crate
-
scotch
Idiomatic wrapper for Scotch, the graph partitioner, graph clusterer and sparse matrix orderer
-
statrs-fork
Statistical computing library for Rust
-
calcul8
calculator CLI
-
beetle-calculator
A terminal calculator for parsing simple maths expressions
-
num-primes
Generating Large Prime and Composite Numbers using num with a simplistic interface
-
reuler
Solutions to Project Euler in Rust
-
stochastic-gbm
simulating Geometric Brownian Motion (GBM) process for financial asset modeling
-
mixed-num
A trait for generic implementations of numerical methods
-
astro-float-num
Multiple precision floating point numbers implemented purely in Rust
-
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…
-
logic-circus
Open source logic circuit simualtor written in Rust
-
dihedral
(torsion) angle calculations
-
fend-core
Arbitrary-precision unit-aware calculator
-
modutil
Provide the methods supports modular arithmetic
-
commuter
tooling to test diagrams for commutativity, allowing automated tests on algebraic systems
-
avlsort
AVL tree holding the rank and the number of duplicates of elements
-
rust_scicrate
A scientific computing library for Rust
-
dotbits
unsigned int <-> Vec<bool>, plus various helper functions
-
quick_maths
low-dimensional linear algebra structures
-
std-traits
Traits for types in the standard library
-
iter-rationals
A fixed size, linear time, no-std iterator over the rational numbers
-
tribool
Three-valued logic
-
faer-cholesky
Basic linear algebra routines
-
circuit_sat_check
generate circuit checking to CNF formula
-
ndarray-unit
A package providing a system of units to the ndarray type
-
cargo_calc
calculation lib
-
laddu-python
Amplitude analysis made short and sweet
-
bigbit
Implements the BigBit format, allowing for compact storage of arbitrarily large numbers
-
vertex_clustering
vertex clustering
-
highs-sys
Rust binding for the HiGHS linear programming solver. See http://highs.dev.
-
bempp-quadrature
Simplex quadrature rules and boundary element singular quadrature
-
hc
Handy calculator for haxor calculations
-
rcomplex
class for manipulating complex numbers. This project is mainly for educational purposes, and I reccomend using other more complete packages for complex math.
-
solver
Solve optimization problems
-
geo-aid-geogebra
Support for Geogebra (*.ggb) output from Geo-AID
-
nd_interpolate
1-10 dimensional linear and cubic spline interpolation implemented in Rust
-
unit_system
Automatically derived typed unit systems
-
bicubic
A base for bicubic interpolation
-
magicsquare
magic square/cube generation
-
logic-rs
representing logical formulas with support for temporal robustness semantics
-
rpn_calc_uc_sample
RPN sample library
-
rusty-cffi
Tools for interfacing with other languages via CFFI
-
rpn_calc_perl
RPN library for Perl
-
dfkzr
Dezimalfestkommazahlrechnung - decimal fixed point arithmetic with up to 19 digits
-
bool-logic
manipulating and evaluating boolean expressions
-
fibnacci
fast high precision fibonacci calculator using rayon and gmp
-
scalar-field
Traits and structs which define arithmetic operators on scalar fields
-
millimeter
Primitive type with millimeter unit attached
-
rust-expression
Calculator and solver for linear equations
-
ngau
Non-Generic Angle Units
-
avatar_graph
Avatar Graphs
-
ipasir-loading
Load shared libraries of IPASIR compatible SAT solvers
-
scirust
A scientific computing library
-
ComplexNumbers
performing operations on complex numbers in which the magnitude of the real and imaginary parts are provided in f64 datatype
-
sbml-rs
SBML parser written in Rust
-
batbox-num
num traits
-
coinipopt-sys
The low-level bindings to the COIN-OR Clp library
-
argmin-math
argmin math abstractions
-
unitdc
A dc-like arbitrary precision quantity calculator
-
envisim_utils
methods for design-based sampling methods and estimation
-
array-bin-ops
Efficient array binary operations
-
ferrix
matrix library for Rust
-
meansd-cli
calculate mean and standard deviation (CLI)
-
nums
Number theoretic functions, such as primality testing and factorization, for BigUints
-
primeval
A monstrosity of a prime number generator
-
astronomical-quantities
Unit-safe computations with astronomical quantities
-
concrete-fftw
Safe wrapper around FFTW
-
rapier_testbed2d
Testbed for the Rapier 2-dimensional physics engine in Rust
-
point_process
simulating random point processes
-
curso_09_libs
Teste de biblioteca
-
complex-stuff
working with complex numbers in rust
-
algebraeon-rings
Algorithms in linear algebra, polynomials, and number theory
-
r_mathlib
A port of R’s
nmathstats module to Rust -
safeeft
Safe and branchless error-free transformation algorithms for floating point numbers
-
pert
algoritm for solving task planning with resource overassignation
-
truck-geotrait
Defines geometric traits for truck
-
clfft
Bindings for clFFT, a FFT library for OpenCL
-
nicolas
Computational Algebra Library
-
simple_2d_vector
two-dimensional vectors in Rust
-
find-real-roots-of-polynomial
find all real roots of a polynomial
-
slvs
Rust wrapper for the SolveSpace constraint solver library
-
bens_number_theory
A sample Rust project for number theory stuff (I'm using this to learn Rust)
-
pire-gemm-s8u8s32
high performance cpu kernels
-
siiir_modular_power
A console app and library with function to quickly calculate k^n mod m
-
rapier3d-meshloader
STL file loader for the 3D rapier physics engine
-
mpir
partial Rust porting of mpir multiple precision library based on gmp mpfr
-
acme-graphs
Computational graphs for Rust
-
adv_linalg_lib
Core library for Adv_LinAlg procedral macros
-
unit-interval
Types for working with and constraining values to the unit interval
-
rsm-lib
A mathematics library for Rust, providing support for vector, matrix, and scalar operations
-
log2fix
no_std fixed-point base 2, e and 10 logarithm algorithm implementation
-
gap_solver
A solver for the generalized assignment problem
-
polygonical
2d polygon geometry and operations
-
numbrs
A flexible numerical computing package
-
double-pendulum
A mathematical model for double pendulums
-
dashu-ratio
A big rational library with good performance
-
float_approx_math
A math library for compile-time floating-point approximations (sqrt, sin, cos, etc...)
-
read_write
vector reading and writing tools for rust_poker
-
routrs_maritime_dataset
Maritime dataset for routrs, the geograph-based shortest distance calculator for Rust
-
varisat-checker
Proof checker for proofs generate by the Varisat SAT solver
-
ruststft
computes the short-time fourier transform on streaming data
-
analit
Add another dimension to your Rust project with analog geometric literals
-
bevy_hexasphere
A trimmed down and generic version of Hexasphere for bevy
-
whittaker_smoother
The perfect smoother: A discrete-time version of spline smoothing for equally spaced data
-
dices
calculate discrete probability distributions and statistics for combinations of dices
-
tcs-dhbw
Modules for a model traffic control system project at DHBW Stuttgart
-
metis-sys
Raw FFI to METIS, the serial graph partitioner and fill-reducing matrix orderer
-
windows-numerics
Windows numeric types
-
haversine-redux
Haversine formular library to determine the distances between two coordinates on the earth
-
nimble-client-connecting
Nimble Connecting Logic
-
spsolve
Solve sparse systems of linear equations
-
rust-polynomial
A lib to operate polynomials
-
numerical-integral
evaluating integrals using numerical methods
-
std-dev
Your Swiss Army knife for swiftly processing any amount of data. Implemented for industrial and educational purposes alike.
-
hugefloat
Extremely large, limited-precision floats for use in incremental games
-
markovgen
building markov chain graphs from text datasets and performantly generating text sequences by traversing them, includes an accompanying CLI application
-
seraphine-cli
CLI for the Seraphine programming language
-
irox-dot
DOT Graph Description Language writer, compatible with GraphViz
-
num-derive
Numeric syntax extensions
-
tinyfield
Small, finite fields
-
fftw-sys
unsafe wrapper of FFTW3
-
microtensor
Automatic differentiation for tensor operations
-
pblib-rs
Rust safe bindings for pblib
-
cuba
wrapper for the C Cuba integration library
-
geo-aid-plaintext
Support for plaintext output from Geo-AID
-
spaceform
A cross-platform SIMD-accelerated maths library for 3D graphics
-
hcode_functions_danielly
Biblioteca de funções da Hcode
-
graphed
implement graph-based functionality
-
lagrange-interpolation
Lagrange's Interpolation Formula
-
colamd
Column approximate minimum degree ordering algorithm
-
numerous
A set of tools to finding and classifying special numbers
-
polynomial_ops
Multivariable polynomial operations on arrays and vectors
-
hipparchus-az
angle representation, conversion and calculations
-
snark-tool
contains structures and algorithm for (mainly) cubic graph analysis
-
jnk
Jenna's Number Kruncher: a library for parsing math expressions
-
ndspec
A package for ocean waves and energy spectra
-
c_a_l
cool array language
-
ihateintegrals
A computer algebra library for solving integrals
-
chemrust-nasl
New Adsorption Site Locator (NASL) for catalyst materials. Written in rust. Part of the
chemrusttoolchain. -
is-odd
Returns true if the given number is odd
-
tc-tensor
TinyChain's Tensor collection type
-
dd_maths_traits
Strongly recommended to avoid using while in development. No semver guarantees.
-
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.
-
gpurs
GPU acceleration/linear algebra crate for scientific computing
-
spral
Rust wrapper for SPRAL
-
upcast-arithmetic
Arithmetic that is upcasted on overflow
-
advanedresearch-trinoise
A mathematical noise pattern of 3 values based on Number Theory and Set Theory
-
i_mth
A math library continuously under development made for use in particle and ridgid body dynamics and statics
-
finitediff
Finite/numerical differentiation
-
hypersphere
4D primitives for rotation and projection
-
flint-sys
Bindings to the FLINT C library
-
gsl_rust
A safe GSL wrapper
-
container-broadcast
analog of Julia's broadcast interface
-
pinteger
Positive integer types
-
fenris-paradis
Parallel processing of disjoint indices for the fenris library
-
softfloat-wrapper-riscv
a safe wrapper of Berkeley SoftFloat based on softfloat-sys for RISC-V based on https://github.com/dalance/softfloat-wrapper
-
qoqo_calculator_pyo3
Python interface to qoqo calculator, the calculator backend of the qoqo quantum computing toolkit by HQS Quantum Simulations
-
ezing
Easing functions
-
fj-math
Early-stage b-rep CAD kernel
-
kidy
kinematics and dynamics of multi-body
-
facto
Integer factorization and prime certification
-
waves_rs
A cross-platform, high-performance Rust implementation for various electromagnetic solvers
-
cordic
Special functions for fixed-point numbers using the CORDIC method
-
last_order_logic
An experimental logical language
-
coinbonmin-sys
The low-level bindings to the COIN-OR Clp library
-
matrix_operations
perform matrix operations
-
infallible_tobigint
Infallible ToBigInt/ToBigUint conversion traits for num-bigint
-
onlinecode
"Online Codes", a type of Fountain Code
-
nikisas
common mathematical functions with focus on speed and simplicity of implementation at the cost of precision, with support for
no_stdenvironments -
math_traits
traits to simplify vectorized mathematics
-
cyclic
complete, and dependency-free modular arithmetic
-
algebrust
basic linear algebra operations
-
inertia
Inertia
-
approximately
compare two any values
-
inertia-algebra
Abstract algebra for Rust
-
rational_extensions
Extensions for rational numbers
-
ida
A pure Rust port of the Implicit Differential-Algebraic solver from the Sundials suite
-
math-calc-cli
command-line utility for calculation
-
matriz
Zero allocation Rust linear algebra library
-
yttria-math
A DSP math library tailored for use with the yttria set of libraries
-
razor-chase
implements a variation of The Chase algorithm to find models for theories in geometric form
-
mathematics_table
that will generate a math table of an integer given by the user
-
bacon-sci-1
Scientific computing in Rust
-
nutils-poly
Low-level functions for evaluating and manipulating polynomials
-
rpn_calc_JM
RPN(Reverse Polish Notatio) library
-
floatd
just num_traits::Float + Debug + Display
-
piston3d-construct
higher order functional programming with homotopy maps to construct 3D geometry
-
predicatechecker
Check that a predicate is true if another is
-
ceres-solver-sys
Unsafe Rust bindings for the Ceres Solver
-
brain-assistant
Mathematics tool and encyclopedia for the terminal
-
polenta
A toy language about polynomials over finite-fields
-
lodestone_core
User friendly magnetic field calculations in Rust
-
hellocalc
test
-
fast-macro
High-performance SIMD mathematics, optimized GPU computation, and vectorized algorithms
-
ramp-primes
Generating Large Prime and Composite Numbers using ramp with a simplistic interface
-
napali
TUI interface for Integrated Reasoning's accelerated solver API
-
fishers_exact
Fisher's exact statistical test
-
rink-core
Unit conversion library behind rink
-
rgla
A linear algebra library for graphics that implements rotors instead of quaternions
-
lufact
Sparse LU factorization with partial pivoting
-
nze_geometry
Some basic 2D geometry types and functions
-
truncnorm
Normal and Truncated Normal distributions
-
basiclu
Rust wrapper for BasicLU
-
calcium-oxide
Calc-ium Oxide, a simple stack based command line calculator written in rust
-
zernike
Routines to compute the Zernike polynomials
-
polyglot_interpreter
A cross-platform, cross-language interpreter of simple logical expressions
-
propositional
Logic
-
basic_math_problem_generator
CLI math test with varying difficulty. Geared towards small children for practicing.
-
gemm-c64
Playground for matrix multiplication algorithms
-
in_range
Returns true if a number is in range
-
functions_shared
Test deply crates.io
-
nnls
Non-Negative Least Squares (nnls)
-
genpet
Generate petgraph graphs with geng
-
nova-math
Vector and matrix math utilities for nova-engine
-
icub3d_combinatorics
A collection of combinatorics utilities
-
faer-qr
Basic linear algebra routines
-
rpn_calc_taro_kobayashi
RPN(Reverse Polish Notation) library
-
funki_lang
A customisable embeddable functional langauge
-
osqp-rust-sys
c2rust(osqp-sys)
-
fts_units
that enables compile-time type-safe mathematical operations using units of measurement
-
elementwise
operations implemented for standard Rust containers
-
gateutil
basic utilities for GateSim
-
gemm-f64
Playground for matrix multiplication algorithms
-
ffts
Rust binding for ffts (The Fastest Fourier Transform in the South)
-
fftconvolve
The fast fourier transform convolution and correlation algorithm for Rust
-
hpnc
Binary wrapping the hpn RPN calculator library
-
factordb
Rust wrapper for FactorDB API
-
hkkim_lib_wikibooks_rpn_test
RPN(Reverse Polish Notatio) library
-
mini-kanren
miniKANREN in Rust
-
pesto_cli
hello there
-
framp
Fork of James Miller's Ramp, a high-performance multiple-precision arithmetic library
-
rpni
A basic command-line RPN calculator
-
complexible
A minimal and user-friendly Rust library complex-number operations, bringing the joy of complex mathematics to Rustaceans everywhere!
-
wordle-automaton
Solve wordle puzzles
-
avatar_hypergraph_rewriting
Hypergraph rewriting system with avatars for symbolic distinction
-
fixed
Fixed-point numbers
-
acgmath
A linear algebra and mathematics library for computer graphics. A fork of
cgmath. -
first_order_logic
first-order logic
-
sundials
Suite of nonlinear and differential/algebraic equation solvers
-
bigint-benchmark
Benchmarks for big integer implementations
-
slice2d
Ergonomic array slice for 2d array manipulation
-
spokes
A network and network flow library
-
gmpmee-sys
Rust FFI bindings for GMPMEE
-
displayr-rustr
R integration
-
usagi
Common algorithms and utilities library for Rust
-
shoemate-test
A test package. Currently tests that katex renders properly on docs.rs.
-
polynomint
A no-dependency library for working with integer polynomials
-
bellare-micali
1-out-of-2 Oblivious Transfer Protocol
-
is_signed_trait
Trait for IS_SIGNED associated constant
-
mrslac
sparse matrix data structures
-
ducc0
Wrapping ducc, the Distinctly Useful Code Collection
-
simple_3d_vector
three-dimensional vectors in Rust
-
xicor
Sourav Chatterjee's xi-correlation coefficient
-
rustypi
estimating π using Monte Carlo simulations
-
geologic
Mathematical and geometrical abstractions with a focus on ergonomics
-
rapier3d-lijay
3-dimensional physics engine in Rust
-
r2rs-stats
Statistics programming for Rust based on R's stats package
-
fts_gamemath
collection of crates that provide basic building blocks for 3d video game math
-
polynomial_tools
that contains some utilities for operations on polynomials
-
mermaid
Experimental Linear Algebra
-
rsvd
randomized singular value decomposition (rSVD)
-
rprime
useful functions for prime numbers
-
cp_sat
Rust bindings to the Google CP-SAT constraint programming solver
-
guff-sharefiles
Package IDA-encoded data in a portable file format
-
dashu-base
Common trait definitions and tools for the
dashulibraries -
symmetria
numerical library
-
pire-gemm-s16s16s32
high performance cpu kernels
-
prime-data
Prime Number Data Library
-
efloat
Error-bounded Floating Point
-
andre_wronscki_functions
Andre Wronscki package functions
-
libnum
Functions for efficient development in Math and Crypto
-
rapier2d-f64
2-dimensional physics engine in Rust
-
sphrs
Spherical harmonics and solid harmonics
-
zkp-elliptic-curve
A crypto-grade elliptic curve over
primefield -
closure_calculus
Closure Calculus
-
miura
Math library written for learning Rust
-
blas-sys
The package provides bindings to BLAS (Fortran)
-
greencurves
Generate statistics on Bezier paths
-
malachite-float
The arbitrary-precision floating-point type Float, with efficient algorithms partially derived from MPFR
-
play-rsa
RSA cryptography in Rust for pedagogical use
-
m61-modulus
Functions for performing arithmetic modulo the 61st Mersenne number. Aimed at testing bignum implementations.
-
frunk_laws
contains laws for algebras declared in Frunk
-
half
Half-precision floating point f16 and bf16 types for Rust implementing the IEEE 754-2008 standard binary16 and bfloat16 types
-
envisim_estimate
Design-based estimation and variance estimation
-
algae-rs
A collection of abstract algebraic structures implemented in Rust
-
exec-sat
Executes SAT solver and parses SAT solver output
-
simulated_annealing
An interface for global function optimization using simulated annealing
-
bigfactorial
Precalculated compile-time factorial macro for numbers upto 99
-
ndutest
the first test
-
math_vector
3D vector class
-
viewp
A program is get any argument, that generates prime. it argument be number. This Program is Test Stage.
-
wikiboos_rpn_calc_test_ver
RPN(Reverse Polish Notation) library
-
rug-polynomial
Polynomial arithmetic, built on Rug & FLINT
-
softfp
Software floating point operation library
-
geometric
A very simple vector and matrix library built on the vecmath crate
-
numerilib
Mathematics Library
-
propositional_logic
generate truth tables for compound propositions
-
stochastic-abm
simulating various stochastic processes, including Arithmetic Brownian Motion and more
-
primal-sieve
A high performance prime sieve
-
primality-test
Primality Test crate
-
erosion
plot fourier curves and functions
-
kahuna
A basic implementation of wave-function collapse for procedural generation
-
oeis-utils
Parse OEIS database archives
-
my-little-eval
A little library for evaluating mathematical expressions
-
quad
Quadrature integration
-
vector-basis
Access components of generic vector types
-
ezcgmath
Easy linear algebra Math library for use with computer graphics
-
fj-window
Early-stage b-rep CAD kernel
-
antic-sys
Bindings to the Antic library
-
plummerprimes
Builds, Runs, and reports benchmarks from https://github.com/PlummersSoftwareLLC/Primes
-
prime_tools
Generate primes, get prime factors, check primality, and other useful prime-related utilities
-
matrix-simp
A linear algebra package (WIP)
-
hcode_rust
Biblioteca de funções
-
cellular_raza-core
Cellular simulation tool
-
horner-eval
A macro for evaluating polynomials via Horner's rule
-
faer-ext
faer-rs API for interoperability with external libraries
-
math_utils_lib
providing math utilities such as a parser/evaluator and a LaTeX export to export a history of parsed expressions and solved equations to LaTeX
-
matrix-math
Mathematical matrices
-
si_units
handling arithmetic with SI units
-
polynom
handling polynomials
-
polynomials_pro
pro-level polynomials
-
croot-gui
graphing complex roots and numbers
-
currying
anything implementing
FnOnce. Arguments can be passed one at a time, yielding a new something implementingFnOnce(and possiblyFnMutandFn) which can be called with one less argument. -
standard_deviation
used to get the standard deviation from the cli
-
math-fun
A package providing mathematical functions commonly used in science and engineering
-
prime_gen
Generate prime numbers
-
vec3D
A minimal 3D Vector library in Rust
-
sciru
A high-performance library for mathematics, science, and engineering written in Rust
-
bootstrap-ht
Bootstrap Hypothesis Testing
-
malltec_libs
Projeto de estudo
-
exact-conv
Exact conversions between integer and floating point types
-
cruncher
jit-compiled mathematical expression calculator
-
gaussiant
Gaussian integers
-
interiors
Primal-Dual Interior Point Method for Nonlinear Programming
-
laddu-core
Core of the laddu library
-
turing-machine-rs
Open library for implementation Turing Machines
-
awint_core
Core no-std and no-alloc
awintfunctionality -
rust-gmp
Rust bindings for GMP
-
cw-bigint
Big integer implementation for Rust
-
cudd
Cudd Rust library
-
vmd-rs
Variational Mode Decomoposition in Rust
-
cat_solver
Rust bindings for the Kissat SAT solver
-
rustnomial
working with polynomials
-
bigint-base10
Experimental API for dealing with big integers in base-ten
-
polynominal-interpolation
interpolating a function using polynomial
-
mtrx
type-safe matrix operations using const generics
-
ark-bn254
The BN254 pairing-friendly elliptic curve
-
hampel
Sequential outlier detection and removal using Hampel identifiers
-
ripin
that handle Reverse Polish notated expressions, compiles, and evaluate them
-
scicrypt-numbertheory
A scicrypt crate implementing number theoretic algorithms such as random (safe) prime generation
-
alpha_stable
Sample and generate probability distribution functions of Alpha-Stable distributions in Rust
-
salva2d
2-dimensional particle-based fluid dynamics in Rust
-
gatenative
execute natively Gate circuits
-
coincbc-sys
The low-level bindings to the COIN-OR Cbc library
-
alga
Abstract algebra for Rust
-
mvmm_hydro
A moving mesh hydrodynamics (CFD) solver prioritizing flexibility over raw performance
-
superlu-sys
The package provides bindings to SuperLU
-
objforces
Allows to calculate mouvement of objects based on forces on a 3D axis
-
statistical-tests-rs
Statistical Tests for Rust
-
hcode_functions2
Biblioteca de funções da HCode
-
lukkid
Arithmetic Sequences
-
saleae
interacting with saleae devices
-
fuzzylogic
operations for fuzzy set theory
-
primality
Check if a number is prime
-
c-api-tools
Tools for the creation of C API bindings
-
matrix_mul_test
testing blas as a feature
-
graph_gen
Generate pseudo-random graphs based on the Erdos-Renyi G(n,p) model
-
sph2mm
Add an AMR background to an existing SPH initial conditions file
-
lodestone_python
User friendly magnetic field calculations in Rust
-
corries
Library/framework for 1D-hydrodynamics simulations using Riemann solvers
-
mop-common
Common definitions for MOP crates
-
bubblemath
A collection of mathematical algorithms in pure Rust
-
swifft
hash function, written in Rust
-
val_unc
A package for handling quantities with uncertainties
-
quickfib
A no_std compatible Fibonacci calculation algorithm implemented in Rust
-
mathlab
A Powerful Math Library for Rust
-
statc
essentially a TI-84 extended, geared towards statistical calculations and making data easily readable and obtainable
-
gemm-common
Playground for matrix multiplication algorithms
-
spfunc
numerical calculation of special functions
-
lagrangian_interpolation
An algorithm to interpolate between points with polynomials
-
elr_primes
prime number iterator and methods for basic calculations with prime numbers
-
glar-gemm-f16
high performance cpu kernels
-
dual_quaternion
A type-agnostic dual-quaternion math library
-
librustosa
Calculate Mel Frequency Cepstral Coefficients from audio data
-
concrete-fftw-sys
Sources of FFTW and unsafe binding
-
logic-long
Supercell's Logic Long implemented in Rust
-
yttria-modulation
A communications library tailored for use with the yttria set of libraries
-
horner
Evaluate polynomials using Horner's method
-
ldl
LDL factorisation for quasi-definite linear systems
-
rsmt2-zz
Wrapper for SMT-LIB 2 compliant SMT solvers. With ZZ downstream fixes
-
pire-gemm-c32
high performance cpu kernels
-
operations
Basic algebraic and mathematical expressions for use with dynamic elements
-
typed_floats_macros
only used to generate the
typed_floatscrate -
relation
based on the mathematical concept of financial relations
-
geo-aid-figure
Definitions for Geo-AID's JSON export format
-
wilson
Calculate Wilson confidence interval for binomial distribution using the formula from Wikipedia
-
matrix-basic
very basic matrix operations
-
blasoxide
BLAS implementation in rust
-
geo-nd
Traits and types particularly for 2D and 3D geometry with implementations for [float] and optionally SIMD
-
random-partition
Generate approximately uniformly distributed random integer partitions
-
worlde-automaton
Solve worlde puzzles
-
hypergraph
data structure library to create a directed hypergraph in which an hyperedge can join any number of vertices
-
ema
using exponential moving averages
-
simplex
A Linear Programming solver
-
fixed-polynomial
Polynomial arithmetic functions with compile-time degree checks
-
libbytestat
Randomness analyzer
-
depends_core
Ergonomic, performant, incremental computation between arbitrary types
-
sparkl3d-kernels
3-dimensional physics engine in Rust
-
num_vector
Enabling basic vector arithmetic operations
-
line-graph
Construct the line graph of an undirected graph
-
super-prime
Find the super prime number
-
basic_math_operation
can be used to perform basic operations like Addition, Subtraction, Multiplication and Division
-
fj-viewer
Early-stage b-rep CAD kernel
-
ext-ops
General purpose arithmetic operator traits which are missing from the standard library
-
poly
Generic dense polynomials
-
logic_trioxide
Logic Gate simulating Library
-
get_len_base_10_as_usize
Traits for getting length base 10 as usize, both at run and compile time
-
rust-gmp-serde
Rust bindings for GMP, added serde support
-
red_primality
zero-setup primality testing and factoring for all u64
-
complex-plane
complex numbers and their associated operations in the complex plane
-
factor-rs
A command-line program for listing the prime factors of a number or fraction
-
trinary
Rust types for trinary logic
-
fenris-sparse
Sparse matrix functionality for fenris
-
geo-aid-json
Support for JSON output from Geo-AID
-
num-rug-adapter
An adapter to use num crate where rug is needed
-
tiago_functions
Algumas funções para uso externo
-
cronbach_alpha_lib
get cronbach alpha value to check your reliable question
-
integral-exponential-polynomial
Integral exponential polynomial
-
ios_calculator
iOS calculator implementation
-
cblas-sys
The package provides bindings to CBLAS (C)
-
information
theory functions to use with ndarray
-
num-irrational
num-irrationalis based onnumand extends it with support for several kinds of irrational numbers -
accelerate-src
The package provides a source of BLAS and LAPACK via the Accelerate framework
-
fuzzy-expert
A fuzzy logic library with support for mamdani fuzzy inference
-
traitgraph
Abstracting over different graph representations
-
test_lulu
A fun test_lulu game
-
primapalooza
prime number calculations implemented in rust
-
shanksbot-rs
ShanksBot shown by Matt Parker in https://www.youtube.com/watch?v=DmfxIhmGPP4
-
junglefowl
Brutally murdering Rust's type system one proof at a time
-
sciport-rs
Rust port of scipy
-
new_project
Basic math operations
-
poly_log
working with polynomials
-
nonstdfloat
Floating point calculations for strafe
-
free-algebra
Types for constructing free algebras over sets
-
gmp-ecm
Rust high-level bindings for GMP-ECM
-
ode_integrate
Collection of numerical ODE Solvers written in generics and thus applicable in many scenarios
-
time_varying_graph
A complex graph package for interacting with time-varying graphs. For more information you can check out https://arxiv.org/abs/1012.0009
-
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)…
-
quickcount
Sleek, minimal and blazingly fast word counter app
-
faer-lu
Basic linear algebra routines
-
next_prime
A function that returns the next prime greater than or equal to its argument
-
melius-vectors
2-4 dimensional vectors that can be easily created and manipulated
-
glucose
multipurpose math and physics crate for my projects
-
discrete-logarithm
Fast discrete logarithm solver
-
simple-vectors
dimension generic vector math
-
sws-crawler
Web crawler with plugable scraping logic
-
prime-iter
An incremental-sieve based prime generator
-
sort_rust
sort for Rust
-
slender-math
Lightweight math library for game development
-
calculator_101
contains modules to perform basic arithmetic operation
-
qty-macros
Macros supporting the implementation of quantities
-
rug-fft
FFT implementations for rug integers
-
gatesim
The base library for the Gate Project
-
prim
find prime numbers
-
mkl-rs-sys
MKL bindings for Rust
-
com-croftsoft-core
A core library of highly reusable code
-
primeshor
project to explore prime numbers and factorization
-
netlib-src
The package provides a source of BLAS and LAPACK via Netlib
-
is-prime2
check if a number is prime
-
acme-macros
Acme aims to provide a solid foundation for developing robust machine-learning systems in Rust
-
pire-gemm-c64
high performance cpu kernels
-
isprime
Quickly check if a number is prime
-
samplers
Sample from distributions and calculate summary statistics from the command line
-
ark-bw6-761
The BW6-761 pairing-friendly elliptic curve
-
fftw-src
Source of FFTW
-
fj-app
Early-stage, next-generation, code-first CAD application. Because the world needs another CAD program.
-
logistics
Engineering Client
-
sparkl2d-kernels
3-dimensional physics engine in Rust
-
fpdec-core
Common constants and functions for crate fpdec
-
glar-gemm-f32
high performance cpu kernels
-
primeish
A CLI containing various prime number utilities
-
faer-sparse
Basic linear algebra routines
-
array-matrix
Treats two-dimensional arrays as matrices and introduces matrix operations
-
primal-estimate
State-of-the-art estimation of upper and lower bounds for π(n) (the number of primes below n) and p_k (the k-th prime)
-
factor-prime
finding whether a number is prime or not and also determine its factors
-
fructose
Mathematical Traits for the Glucose Library and the Rust programming language
-
iterstats
Statistics for rust iterators
-
scotch-sys
Raw FFI to Scotch, the graph partitioner, graph clusterer and sparse matrix orderer
-
ark-ed-on-bn254
A Twisted Edwards curve defined over the scalar field of the BN254 curve
-
faer-traits
linear algebra library
-
prime-rs
Command line utilities for finding prime numbers
-
lapacke
The package provides wrappers for LAPACKE (C)
-
physsol
Lightweight 2d and 3d physics library
-
inertia-core
Core functionality of the Inertia crate with high level wrappers for FLINT, Arb, and Antic
-
rust-fixed-point-decimal-core
Common constants and functions
-
sparkl3d
3-dimensional physics engine in Rust
-
traitgraph-algo
Graph algorithms based on the traitgraph crate
-
fj-host
Early-stage, next-generation, code-first CAD application. Because the world needs another CAD program.
-
q1tsim-logic-gates
extension crate to q1tsim implementing the AND, OR and XOR logic cates in a quantum comupting - friendly (i.e. reversible) way.
-
glar-gemm-c64
high performance cpu kernels
-
mkl-rs-build
Build utilities for MKL
-
same-as
Type equality in stable Rust
-
primal-bit
Bit-vector specialised to the prime-number-related needs of
primal -
geo-aid-dbg
A debugger for Geo-AID. Used in development for peeking inside Geo-AID in order to see how the generation process goes.
-
iron_learn
A pure Rust Machine Learning Library with Generic Tensor and a Gradient Descent Optimization Function
-
algebraic-equation-over-finite-prime-field
solve algebraic equation over finite prime field
-
pire-gemm-f16
high performance cpu kernels
-
sp2
2D geometric algebra spatial transforms and movement representations
-
sirp
Computing properties of factorials, k-factorials and SIRPs
-
sfcpl
private library for atcoder
-
gate_calc_log_bits
Helper for the Gate Project
-
blasoxide-ref
reference BLAS implementation
-
ssmr
Single-Shot Miller-Rabin primality test for small integers
-
curve_similarities
Calculation of curve similarities for 2-dimensional arrays
-
glar-gemm-c32
high performance cpu kernels
-
fj-operations
Early-stage, next-generation, code-first CAD application. Because the world needs another CAD program.
-
ncollide2d
2 and 3-dimensional collision detection library in Rust. Will be superseded by the parry2d crate.
-
ark-ed-on-bls12-381
A Twisted Edwards curve defined over the scalar field of the BLS12-381 curve
-
prime-portraits
A program that turns images into prime numbers
-
nt-primes
Recreational mathematics crate for various forms of primes