-
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
-
uint
Large fixed-size integer arithmetic
-
kurbo
A 2D curves library
-
sprs
A sparse matrix library
-
nalgebra
General-purpose linear algebra library with transformations and statically-sized or dynamically-sized matrices
-
ruint
Unsigned integer type with const-generic bit length
-
rug
Arbitrary-precision integers, rational, floating-point and complex numbers based on GMP, MPFR and MPC
-
matrixmultiply
General matrix multiplication for f32 and f64 matrices. Operates on matrices with general layout (they can use arbitrary row and column stride). Detects and uses AVX or SSE2 on x86…
-
num-complex
Complex numbers implementation for Rust
-
euclid
Geometry primitives
-
ark-poly
efficient polynomial arithmetic via FFTs over finite fields
-
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.
-
ultraviolet
do linear algebra, fast
-
roots
well known algorithms for numerical root finding
-
num-traits
Numeric traits for generic mathematics
-
num-bigint-dig
Big integer implementation for Rust
-
parry3d
3 dimensional collision detection library in Rust
-
fend
Arbitrary-precision unit-aware calculator
-
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.
-
peroxide
Rust comprehensive scientific computation library contains linear algebra, numerical analysis, statistics and machine learning tools with farmiliar syntax
-
lapack
The package provides wrappers for LAPACK (Fortran)
-
faer
linear algebra library
-
yahoo_finance_api
adapter for the yahoo! finance API to fetch histories of market data quotes
-
easy-smt
Easily interact with an smt solver as a subprocess
-
bnum
Arbitrary, fixed size numeric types that extend the functionality of primitive numeric types
-
mint
Math interoperability standard types
-
biodivine-lib-bdd
thread-safe implementation of basic binary decision diagrams
-
i_overlay
Boolean Operations for 2D Polygons: Supports intersection, union, difference, xor, and self-intersections for all polygon varieties
-
russell_lab
Scientific laboratory for linear algebra and numerical mathematics
-
num-dual
Generalized (hyper) dual numbers for the calculation of exact (partial) derivatives
-
common_traits
Traits to write generic functions on different numeric types, with atomic support, and other features
-
argmin
Numerical optimization in pure Rust
-
num-modular
efficient integer division and modular arithmetic operations with generic number types. Supports various backends including num-bigint, etc
-
simba
SIMD algebra for Rust
-
triton-vm
virtual machine that comes with Algebraic Execution Tables (AET) and Arithmetic Intermediate Representations (AIR) for use in combination with a STARK proof system to allow proving correct…
-
hexasphere
evenly tile hexagons on a sphere
-
ode_solvers
Numerical methods to solve ordinary differential equations (ODEs) in Rust
-
typstyle
The CLI for Typstyle
-
kalc
a complex numbers, 2d/3d graphing, arbitrary precision, vector/matrix, cli calculator with real-time output and support for units
-
simple_moving_average
moving average (SMA) algorithms
-
twenty-first
Collection of mathematics routines and cryptography for the twenty-first century
-
plotpy
Rust plotting library using Python (Matplotlib)
-
russell_sparse
Solvers for large sparse linear systems (wraps MUMPS and UMFPACK)
-
kittycad
A fully generated & opinionated API client for the KittyCAD API
-
sci-rs
Rust scientific analysis library similar to SciPy
-
ibig
A big integer library with good performance
-
feos
framework for equations of state and classical density functional theory
-
lin_alg
Vector, matrix, and quaternion operations for general purposes
-
typed_floats
Types for handling floats with type checking at compile time
-
hexx
Hexagonal utilities
-
yume-pdq
Optimized kernels from hashing to vectorized or Vulkan shader-based exact matching for near real-time high-throughput high-recall PDQ-based image screening, including a hand-vectorized…
-
noisy_float
Contains floating point types that panic if they are set to an illegal value, such as NaN
-
lambdascript
Instructional program detailing the beta reduction of typed and untyped lambda terms
-
lambert_w
Fast and accurate evaluation of the Lambert W function by the method of T. Fukushima.
-
blas-src
The package provides a BLAS source of choice
-
glamour
Strongly typed linear algebra with glam
-
number_prefix
numeric prefixes (kilo, giga, kibi)
-
gauss-quad
applying Gaussian quadrature to integrate a function
-
deskephem
CLI Astronomy Calculator and Ephemeris Generator
-
mahc
riichi mahjong calculator library and CLI
-
microlp
A fast linear programming solver library
-
jlrs
bindings to the Julia C API that enable Julia code to be called from Rust and more
-
quaternion-core
quaternion operations and interconversion with several attitude representations
-
ndhistogram
multi-dimensional histogramming for Rust
-
lambda_calculus
zero-dependency implementation of pure lambda calculus in Safe Rust
-
num-rational
Rational numbers implementation for Rust
-
splines
Spline interpolation made easy
-
malachite
Arbitrary-precision arithmetic, with efficient algorithms partially derived from GMP, FLINT, and MPFR
-
cgmath
A linear algebra and mathematics library for computer graphics
-
splr
A modern CDCL SAT solver in Rust
-
quantities
Unit-safe computations with quantities
-
strict_types
Strict types: confined generalized algebraic data types (GADT)
-
stv-rs
Single Transferable Vote implementation in Rust
-
hecate-vm
The main package for the hecate vm
-
lp_parser_rs
parser for the LP file format
-
scientific
Arbitrary precision scientific number (no_std capable, in pure Rust)
-
joker_calculus
Joker Calculus in Rust
-
quaternion
type agnostic quaternion math library designed for reexporting
-
i_float
This fixed float math library provides an efficient and deterministic solution for arithmetic and geometric operations
-
cronus_cli
The CLI for cronus
-
mathru
Fundamental algorithms for scientific computing in Rust
-
ganesh
Function minimization in Rust, simplified
-
sliding_features
Modular sliding window with various signal processing functions and technical indicators
-
varpro
A straightforward nonlinear least-squares fitting library which uses the Variable Projection algorithm
-
machine-prime
ne plus ultra primality testing for machine-sized integers
-
satkit
Satellite Toolkit
-
labyr
A PDDL benchmarker
-
RustedSciThe
RustedSciThe is a Rust library for symbolic and numerical computing: parse string expressions in symbolic representation/symbolic function and compute symbolic (analytical) derivatives…
-
zen-engine
Business rules engine
-
fastnum
Fast decimal numbers library
-
bva
manipulating and doing arithmetics on bit vectors of fixed but arbitrary size
-
cubecl
Multi-platform high-performance compute language extension for Rust
-
icao-wgs84
performing geometric calculations on the WGS84 ellipsoid
-
geonum
geometric number library supporting unlimited dimensions with O(1) complexity
-
decaf377
A prime-order group designed for use in SNARKs over BLS12-377
-
rsparse
solving sparse linear systems using direct methods
-
pathfinder_geometry
Basic SIMD-accelerated geometry/linear algebra
-
noether
Abstract algebraic structures for Rust
-
fpdec
Decimal fixed-point arithmetic
-
maths-rs
A linear algebra library for gamedev and graphics
-
geo-aid
designed to generate geometrical figures based on given rules
-
stlrs
Seasonal-trend decomposition for Rust
-
light-curve-feature
Feature extractor from noisy time series
-
cpc
evaluates math expressions, with support for units and conversion between units
-
nanvm
NaN VM
-
clarabel
Conic Interior Point Solver for Rust / Python
-
engineering-repr
Numeric conversions for engineering notation (1.23k) and the RKM code variant (1k23)
-
stacked_linear_algebra_graph
Embedded in-memory graph using sparse linear algebra
-
ndarray-conv
N-Dimension convolution (with FFT) lib for ndarray
-
metis
Idiomatic wrapper for METIS, the serial graph partitioner and fill-reducing matrix orderer
-
creusot-contracts
contracts and logic helpers for Creusot
-
stats-ci
A pure Rust library for computing and working with confidence intervals on sample data
-
ncube
Generalized Hypercube Visualizer
-
parry3d-f64
3 dimensional collision detection library in Rust. 64-bits precision version.
-
erydanos
Optimized routines for ARM NEON and SSE
-
honeycomb-core
Core structure implementation for combinatorial maps
-
num-quaternion
Quaternion numbers implementation for Rust
-
adic
Arithmetic and rootfinding for p-adic numbers
-
big_num_math
computations on large numbers
-
coin_cbc
Rust bindings to the CoinOR CBC MILP Solveur using the C API
-
const-primes
Work with prime numbers in const contexts. Prime generation, primality testing, prime counting, and more.
-
nextsv
Next semantic version calculator
-
naivesat
Few solvers that uses the Gate project
-
colpetto
Async libinput wrapper
-
calc_rational
CLI calculator for rational numbers
-
yata
Technical Analysis library. For rust now.
-
centerline
finding centerlines of 2D closed geometry
-
ndrustfft
N-dimensional FFT, real-to-complex FFT and real-to-real DCT
-
transforms
A transform library to track reference frames and provide transforms between them
-
oxidd
A safe, concurrent, modular, and performant decision diagram framework
-
decimal-rs
High precision decimal implementation for Rust
-
enterpolation
creating and computing interpolations, extrapolations and smoothing of generic data points
-
balanced-ternary
manipulate balanced ternary values
-
temp-converter
terminal temperature unit converter between Celsius, Fahrenheit and Kelvin
-
rusty_neat
Pretty good NEAT implementation
-
num-prime
Generic and optimized primality test, factorization and various number theoretic functions with arbitrary precision based on
num -
hexgridspiral
Hexagonal Cube-Coordinate System with Spiralling Integer Tile Identifiers
-
numbat
A statically typed programming language for scientific computations with first class support for physical dimensions and units
-
rsc
A fast calculator for solving scientific and algebraic math equations in strings
-
d3_delaunay_rs
A port of D3/d3-delauany
-
scirs2-fft
Fast Fourier Transform module for SciRS2
-
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…
-
hyperdual
Fully-featured Dual Number implementation with features for automatic differentiation of multivariate vectorial functions
-
startin
A Delaunay triangulator for terrains
-
interpn
N-dimensional interpolation/extrapolation methods, no-std and no-alloc compatible
-
tyche
Dice rolling and dice expression (with a syntax similar to FoundryVTT) parsing library
-
primitive_fixed_point_decimal
Primitive fixed-point decimal types
-
rational
Minimalistic library for rational numbers
-
krnl
Safe, portable, high performance compute (GPGPU) kernels
-
vector-traits
Rust traits for 2D and 3D vector types
-
hooo
Propositional logic with exponentials
-
polynomial-ring
A polynomial implementation
-
mutils
Mathematical-like utilities. Points, Sizes, Colours, maths operating on them. Things like that.
-
hexing
A basic Rust library to manipulate hexagonal grids
-
series
Laurent series in a single variable
-
mosek
Rust API for MOSEK optimization tools
-
process_mining
Process Mining library for working with (object-centric) event data
-
angle-sc
performing accurate and efficient trigonometry calculations
-
lstsq
Return the least-squares solution to a linear matrix equation
-
figures
A math library specialized for 2d screen graphics
-
distrs
PDF, CDF, and percent-point/quantile functions for the normal and Student’s t distributions
-
dte
Decision table editor
-
autodj
Automatic Differentiation Library
-
russell_ode
Solvers for ordinary differential equations and differential algebraic equations
-
openblas-src
The package provides a source of BLAS and LAPACK via OpenBLAS
-
num-bigfloat
Increased precision floating point numbers implemented purely in Rust
-
nalgebra-spacetime
Spacetime Extension for nalgebra
-
rustitude
create and operate models for particle physics amplitude analyses
-
num-integer
Integer traits and functions
-
symbolica
A blazing fast computer algebra system
-
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
-
microgemm
General matrix multiplication with custom configuration in Rust. Supports no_std and no_alloc environments
-
rustneuro
neural signal analysis and feature extraction for scientists who require fast computation
-
zagreb-lib
analyzing graph properties using the Zagreb index and Hamiltonian criteria
-
inari
interval arithmetic
-
p3-dft
Plonky3 is a toolkit for implementing polynomial IOPs (PIOPs), such as PLONK and STARKs
-
pihex
Arbitrary place hexadecimal digits viewer of pi written in Rust
-
kalker
A calculator that supports user-defined functions, variables and units, and can handle fairly ambiguous syntax
-
honeycomb-kernels
Meshing kernel implementations using combinatorial maps
-
rebop
A fast stochastic simulator for chemical reaction networks
-
n_circular_array
An n-dimensional circular array
-
seuif97
The high-speed IAPWS-IF97 package with C and Python binding
-
jexl-eval
A JEXL evaluator written in Rust
-
arithmetic-eval
interpreter for arithmetic expressions
-
logru
A small, embeddable and fast interpreter for a subset of Prolog
-
mappers
Pure Rust geographical projections library
-
csc
Command Line Scientific Calculator
-
rpn-cli
Command line reverse Polish notation calculator
-
thermal_hydraulics_rs
A Thermal Hydraulics Library with some useful traits,enums and functions for heat transfer and fluid mechanics
-
russell_stat
Statistics calculations and (engineering) probability distributions
-
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…
-
fasb
faceted answer set browser
-
moontool
John Walker's moontool.c astronomical calculation routines, extracted and ported to Rust
-
fib-rs
A fast Fibonacci number calculator
-
reckoner
A high level arbitrary precision arithmetic library supporting integer and rational numbers
-
bigraph
Different representations with implemented operations on bigraphs
-
swamp-script-semantic
semantic types for swamp script
-
rink
Unit conversion tool, similar to frink
-
graphics-shapes
Shapes for graphics
-
flavio
welcomes you
-
faer-entity
Basic linear algebra routines
-
tiny-solver
Factor graph solver
-
rumoca
A Modelica translator with focus on Casadi, Sympy, JAX, and Collimator generation
-
ggmath
optimized generic-graphics-math
-
aviation_calc_util
assist with aviation related calculations
-
mech-math
Math library for the Mech language
-
qsv-stats
Computing summary statistics on streams
-
num-order
Numerically consistent
Eq,OrdandHashimplementations for variousnumtypes (u32,f64,num_bigint::BigInt, etc.) -
ecolor
Color structs and color conversion utilities
-
uniform-cubic-splines
uniform cubic spline evaluation and inversion
-
tictonix
that provides the ability to convert tokens into embeddings, as well as to encode their positions
-
piecewise_polynomial
Fitting and interpolation with piecewise polynomials
-
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…
-
camera-intrinsic-calibration
Camera Intrinsic Calibration
-
RustQuant_stochastics
quantitative finance
-
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
-
trprvr
TRanslate PRogress VieweR
-
float_next_after
A trait for native rust f64/f32 nextafter
-
starnav
A comprehensive navigation system for celestial navigation in Star Citizen
-
staged-sg-filter
A staged programming implementation for Savitzky-Golay filters. Loops go brrr.
-
cnfgen
Generate DIMACS CNF formula from operations
-
russell_tensor
Tensor analysis, calculus, and functions for continuum mechanics
-
finitelib
advanced maths over finite groups, fields, their extensions, multi precision operations, euclidean rings, polynomials and related things
-
kind2
A pure functional functional language that uses the HVM
-
yoda-calculator
command line app that acts as a scientific calculator, operating through commands instead of buttons
-
krabmaga
A modern developing art for reliable and efficient Agent-based Model (ABM) simulation with the Rust language
-
kifmm
Kernel-independent fast multipole method
-
geo-nd
Traits and types particularly for 2D and 3D geometry with implementations for [float] and optionally SIMD
-
bc
Use
bcin the Rust Programming Language -
kcl-lib
KittyCAD Language implementation and tools
-
metallic
C math functions from scratch
-
geom3
3d geometry classes
-
black_scholes
A Black Scholes option pricing library
-
intel-mkl-src
Redistribution of Intel(R) MKL as a crate
-
amplify_num
Amplifying numeric types: big-sized and bit-sized integers
-
tilezz
work with perfect-precision polygonal tiles built on top of complex integer rings
-
algori
Rust Algorithms
-
lean-sys
Bindings to Lean 4's C API
-
hallr
An experimental Blender addon
-
pocket_prover
A fast, brute force, automatic theorem prover for first order logic
-
rita
Randomized Incremental Triangulation Algorithms
-
fasteval
Fast evaluation of algebraic expressions
-
csvbinmatrix
Binary matrix Compressed Sparse Vector
-
agb_fixnum
abstracting over fixed precision numbers. Designed for use with the agb library for the Game Boy Advance
-
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.
-
mwa_hyperdrive
Calibration software for the Murchison Widefield Array (MWA) radio telescope
-
fractions-rs
Fractions numbers implementation for Rust
-
sgrust
A sparse grid library written in Rust
-
katex-gdef-v8
fast use of KaTeX via V8 engine
-
d3_geo_voronoi_rs
A port into rustlang of the javascript library d3-geo-voronoi
-
multicalc
Rust scientific computing for single and multi-variable calculus
-
reso
visual pixel-art logic-circuit design language
-
ldpc-toolbox
aid in LDPC code design
-
graph-cycles
Detect all cycles in a petgraph graph
-
quadraturerules
quadrature rules library
-
lieval
A lightweight Rust crate for parsing and evaluating mathematical expressions from strings
-
rapier_testbed2d
Testbed for the Rapier 2-dimensional physics engine in Rust
-
tex2typst-rs
Converts LaTeX math to Typst math
-
RayBNN_DiffEq
Matrix Differential Equation Solver using GPUs, CPUs, and FPGAs via CUDA, OpenCL, and oneAPI
-
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… -
fasteval2
Fast evaluation of algebraic expressions
-
irox
Tools & Libraries
-
saikoro
Parser and evaluator for doing math with dice notation expressions
-
matrixable
Traits and structs extending capabilities of matrix-like structures
-
bare_metal_modulo
ModNum is a highly ergonomic modular arithmetic struct intended for no_std use
-
pccc
Parallel-concatenated convolutional code
-
rmatrix_ks
matrix and some algebra in Rust
-
list_math
doing math on a list including average, smallest, largest, and standard deviation
-
lsts
Large Scale Type Systems
-
crater-rs
solid modeling primitives and operations
-
crc32c-cli
CLI wrapper for the crc32c crate
-
lair
Linear algebra in Rust
-
p256k1
Rust wrappers around libsecp256k1 which expose internal scalar and point APIs
-
string_calculator
A string calculator to compute formulas inside strings
-
diffsol
solving ordinary differential equations (ODEs) in Rust
-
rusticle
High-performance Rust library for numerical computing, built with power and simplicity
-
safe_math
Math without overflow, creates an enum and a macro to help mitigate any overflow while multiplying and adding
-
numerics-rs
Blazing fast numerical library written in pure Rust
-
iter_num_tools
Create simple iterators over non integer ranges. itertools + num = iter_num_tools
-
float_plus
Additional features for float values
-
ruut-functions
parse math functions from string (1D,2D,3D,ND) and perform symbolic derivation, gradient, hessian
-
frunk_laws
contains laws for algebras declared in Frunk
-
raa_tt
Proves sentences of propositional calculus
-
del-geo
2D/3D geometry utility codes
-
mathx
A mathematics library designed to work with no_std
-
simplify-polyline
Simplify polylines using Douglas-Peucker and radial distance algorithms. Port of the simplify-js library.
-
floccus
Formulae for air thermodynamic calculations
-
ellip
Elliptic integrals for Rust
-
al-jabr
An n-dimensional linear algebra library
-
plane-split
Plane splitting
-
ascent_base
support library for the ascent package
-
strict-num
A collection of bounded numeric types
-
fast-srgb8
Very fast conversions between linear float and 8-bit sRGB (with no_std support)
-
awint
Arbitrary width integers
-
zawgl-core
Zawgl Graph Core Library
-
scouter
logic
-
nabo
A fast K Nearest Neighbor (KNN) library for low-dimensional spaces
-
graphblas_sparse_linear_algebra
Wrapper for SuiteSparse:GraphBLAS
-
spherical_geometry
A package for working with spherical geometry
-
saturation
Real-time saturation and clipping designed for use with vst's
-
number-general
A generic number type for Rust which supports basic math and (de)serialization
-
truck-modeling
integrated modeling algorithms by geometry and topology
-
nacfahi
Simpler, but less error-prone API for
levenberg-marquardtoptimization crate -
snurr
Read BPMN 2.0 files and run the process flow
-
gemlab
Geometry and meshes laboratory for finite element analyses
-
reference-interval
reference interval helpers a.k.a. reference range helpers.
-
find_peaks
Find peaks that match criteria in 1D data
-
malachite-base
A collection of utilities, including new arithmetic traits and iterators that generate all values of a type
-
vector3
dealing with 3D mathematical vectors
-
grit-pattern-matcher
Pattern definitions and core matching logic for GritQL
-
taz
evaluate a mathematical expression
-
libcprover_rust
Rust API for CBMC and assorted CProver tools
-
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
-
moyo
Crystal Symmetry in Rust
-
nice_and_easy
A minimalistic Rust library for smooth and effortless easing functions
-
neophyte-linalg
Linear algebra types for Neophyte
-
re_arrow_util
Helpers for working with arrow
-
qhull
Rust bindings to Qhull
-
lazyivy
Lazy Runge-Kutta integration for initial value problems
-
matrixcompare
Tools for convenient comparison of matrices
-
ninterp
Numerical interpolation for N-dimensional rectilinear grids
-
Sph2-rs
An improved version of Sph-rs, that uses a mod to calculate the desired values
-
acme
Acme aims to provide a solid foundation for developing robust machine-learning systems in Rust
-
tifloats
Speedy, accurate emulation of TI-Floats
-
rose-bitsets
Small, fixed-size bitsets for storing integers/indices
-
linear_isomorphic
A set of traits to astract over linear-like types
-
iron-shapes
Basic data types and routines for computational geometry focused on VLSI chip design
-
biometrics
provide the vitals of a process in the form of counters, gauges, moments, and T-digests
-
rstm
focuses on building concrete implementations for Turing Machines
-
castep_model_generator_backend
A rust-written backend lib for edit and generation of lattice 3D-models compatible with CASTEP and Materials Studio
-
laddu
Amplitude analysis made short and sweet
-
cashmoney
safe monetary calculations
-
robomath
A lightweight, efficient, and generic mathematics library for 3D applications, with a focus on robotics and simulation
-
rooc
A mixed integer linear programming modeling language to solve linear optimization models. Extensible, works in WASM and easy to use.
-
dual_balanced_ternary
Dual Balanced Ternary Arithmetic
-
gctree
cache-friendly, graph-like, arena-allocated datastructures
-
cgt
Combinatorial Game Theory framework
-
concrete-ntt
pure Rust high performance number theoretic transform library
-
lox-math
Mathematical utilities for the Lox ecosystem
-
synerise/cleora
general-purpose model for efficient, scalable learning of stable and inductive entity embeddings for heterogeneous relational data
-
integrator
A math library
-
octad
puzzle generator and solver
-
squiid-engine
Squiid Engine is an RPN mathematical engine written in Rust
-
ogsolve
The program for solving octal games
-
realistic
Towards an API for the Real Numbers
-
powers-rs
Stochastic Dual Dynamic Programming (SDDP) algorithm in pure Rust, for the hydrothermal dispatch problem
-
pell-equation
solve Pell's equation
-
lk_math
Collection of reusable mathematical tools
-
factrs
Factor graph optimization for robotics
-
polynomial
manipulating polynomials
-
f256
Octuple-precision floating-point arithmetic
-
vector2math
Traits for doing 2D vector geometry operations using standard types
-
libfive
Tools for solid modeling, especially suited for parametric and procedural design
-
clifford-3-even
even sub-algebra of 3-dimensional clifford algebra, specifically for qubit processing
-
libceed
High-level interface for libCEED - the efficient high-order discretization library developed by the ECP co-design center CEED
-
i24
working with 24-bit integers
-
gendelbrot
A small, simplistic mandelbrot image generator
-
mdarray
Multidimensional array for Rust
-
meshless_voronoi
Meshless Voronoi algorithm
-
dcim
dc improved - Expanded rewrite of a classic RPN calculator / esoteric programming language
-
fixed-bigint
Fixed-size big integer implementation for Rust
-
softposit
Posit numbers
-
substrate-fixed
Fixed-point numbers
-
geopoint
conformal geometric algebra on the O(1) geonum crate
-
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
-
rsfrac
The Terminal-Based Fractal Explorer. Rsfrac is your terminal gateway to Mandelbrot, Burning Ship, and Julia.
-
windows-numerics
Windows numeric types
-
vecmat
Low-dimensional vector algebra with min_const_generics support
-
soilrust
A geotechnical engineering library for soil mechanics calculations in Rust
-
fastnum2
fork of Fast decimal numbers library
-
int_ratio
The type of ratios represented by two integers
-
metriken
A fast and lightweight metrics library
-
aspect360
This builds on the Ring360 to calculate aspect matches from target angles with orbs or an array of target aspect/orb pairs
-
ring-algorithm
algorithms on ring (Abstruct Algebra)
-
r-src
The package provides a source of BLAS and LAPACK via R
-
scirs2-special
Special functions module for SciRS2
-
secrust
source-level verification using Weakest Precondition calculus
-
ffnt
Finite fields for number theory
-
tampines-steam-tables
Steam Tables for the TAMPINES Library
-
gw_signal
Package with signal processing tools for graviational waves studies
-
theon
Abstraction of Euclidean spaces
-
floco
validates floats against constraints
-
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.
-
static_aabb2d_index
Fast static spatial index data structure for 2D axis aligned bounding boxes
-
diffsl
A compiler for a domain-specific language for ordinary differential equations (ODE)
-
del-ls
sparse solver library for research prototyping
-
ark-algebra-bench-templates
A benchmark library for finite fields and elliptic curves
-
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.
-
hfs
Hereditarily finite sets
-
rusttex
programmatically generating LaTeX documents
-
crystallographic-group
Provide crystallographic group reference and useful information, e.g. lattice coordinates and symmetry operation matrices.
-
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…
-
bbox
Managing axis aligned 3d Bounding Boxes
-
stochasta
stochastic analysis library
-
convers
Cool convert library that converts almost everything(not yet).Units,Languages,Calculations,etc
-
cratesio-assignment-calculator-BDM
A rudimentary calculator
-
metrics-exporter-opentelemetry
🐻❄️🎈 A
metricsexporter over OpenTelemetry -
trs-dataframe
Dataframe library for Teiresias
-
numdiff
Numerical differentiation via forward-mode automatic differentiation and finite difference approximations
-
multibody_dynamics
Multibody dynamics algorithms in Rust
-
enontekio
solve problems with data extraction and manipulation, like Advent of Code puzzles
-
mcdm
assist with solving Multiple-Criteria Decision Making (MCDM) problems
-
alum
Halfedge based polygon mesh library
-
fpmath
A floating point math library
-
baa
BitVector and Array Arithmetic
-
Rustb
A package for calculating band, angle state, linear and nonlinear conductivities based on tight-binding models
-
prime_factorization
Prime factorization up to 128 bit integers
-
coordinates
no nonsense, library for using two and three dimensonal coordinates in several systems
-
bezier-rs
Computational geometry algorithms for Bézier segments and shapes useful in the context of 2D graphics
-
vectrix
A stack-allocated matrix type implemented with const generics
-
liealg
lie group and lie algebra in rust
-
subsphere
Sphere tessellation toolkit
-
lerp
Generic linear interpolation and extrapolation, automatically implemented for a variety of numeric types
-
vecs
Vector Math Crate
-
aprilgrid
Aprilgrid
-
voxel-tiler-core
Convert point clouds to voxel data
-
csta
A personal statistics library
-
rustpython-format
Format helpers for RustPython
-
rlst
native linear algebra library
-
hyperion
Generic LSystem implementation
-
bunnies
A fast chess library for chess engines
-
histo
histograms with configurable buckets
-
oxidd-cli
Command line interface for OxiDD
-
cellular_raza
Cellular Agent-based Modeling from a Clean Slate
-
amonoid
A general-purpose monoid library
-
complex-bessel-rs
compute Bessel functions
-
mats
handling matrices and vectors
-
scalarff
A minimal, opinionated, library for working with scalar finite fields
-
simplecalc
CLI calculator
-
cubes
Applications for determining how to put a cube together
-
scilib
A scientific library for the Rust programming language
-
smooth-operator
Procedural macro that transforms regular infix arithmetic expressions into checked arithmetic expressions
-
cutup
A flexible and efficient allocation library for Rust, capable of distributing assets, resources, and other divisible entities
-
infinitable
Infinity for types without infinite values
-
feos-ad
Implicit automatic differentiation of equations of state and phase equilibria
-
zfc
Trait that represents a set according to Zermelo–Fraenkel set theory with the axiom of choice (ZFC)
-
eqlog-eqlog
Datalog with equality
-
int-div-cum-error
Primitive integer division with rounding kind and cumulative error
-
lower
desugar math where the compiler wont
-
csd-rs
Canonical Signed Digit Conversion in Rust
-
p-chan
Multimedia (Audio, Raster) Channel Newtypes and Conversions
-
sprs-superlu
The package provides a high level interface between SuperLU, sprs and ndarray
-
softfloat-wrapper
a safe wrapper of Berkeley SoftFloat based on softfloat-sys
-
egobox
A python binding for egobox crates
-
whittaker-eilers
A sparse matrix implementation of Whittaker-Eilers smoothing and interpolation
-
practicestuff
CLI trainer for improving calculation and memorisation skills
-
reflexo-vec2bbox
Render vector items BBox
-
padded-number
Work with numbers containing significant leading zeros
-
vector-victor
linear algebra crate
-
bacon-sci
Scientific computing in Rust
-
conspire
c o n s p i r e
-
truck-geotrait
Defines geometric traits for truck
-
tclifford
Geometric algebra library
-
fasteval3
Fast evaluation of algebraic expressions
-
chemp
chemical formulas parser
-
nearly
Compare IEEE floating point types
-
rust-poly
Numeric manipulation of real and complex polynomials
-
termcalc
Terminal Calculator
-
rust-cli-calculator
calculator written in Rust as a learning project
-
eng-units
Engineering unit coversions and calculations
-
mortgauge
calculator for figuring out how much you can offer for a house in the UK
-
quaigh
Logic optimization library
-
chemrust-core
The core modules defining the flow and structs of data in computational chemistry routines
-
int_math
Integer math
-
linalg-traits
Traits for generic linear algebra
-
comfy-bounded-ints
Bounded-integer types focused on ergonomics and safety. (See README.md)
-
hilbert_2d
Functions for mapping between 1D and 2D space using the Hilbert curve, and its approximations
-
palindromeda
Palindrome number generator and checker at blazing speed
-
ratio-graph
Ratio's graph manipulation library
-
vom_rs
Probabilistic Finite Automata
-
matio-rs
Rust wrapper to MATLAB MAT file I/O library
-
eva
Calculator REPL similar to bc(1)
-
rxcalc
An expression calculator, originally written in Scratch
-
rs-math3d
Rust 3D Math (no dependency on std)
-
polygon-offsetting
polygon offsetting crate
-
world-tax
world tax calculator
-
jakkunight-ali
CLI tool for matrix calculation
-
ruint2
Unsigned integer type with cont-generic bit length
-
stcalc
Stack calculator
-
math_repl
REPL for all different kinds of math
-
unit-sphere
performing geometric calculations on the surface of a sphere
-
ndarray-interp
Interpolation package for ndarray
-
x-math
fast math
-
fixed-macro
Macros for creating fixed-point constants for types in the
fixedcrate -
errorfunctions
Pure Rust package to compute the error function, Dawson's function, and Faddeeva's function for real and complex arguments
-
new_york_calculate_core
calculation some things
-
sundials-sys
Bindings to the SUNDIALS suite of Nonlinear and DAE Solvers
-
calc
CLI calculator app
-
relrc
Reference counted pointers, with relationships to other pointers
-
arcflash
Arc flash calculations according to IEEE 1584
-
mavdac
MAVIS Differential Astrometric Calibrator
-
daisycalc
A high-precision terminal scientific calculator
-
minvect
A mini vector library
-
rusev
Fast implementation of SeqEval, a sequence evaluation framework
-
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…
-
pergola
abstract types for join-semilattices
-
RayBNN_DataLoader
Read CSV, numpy, and binary files to Rust vectors of f16, f32, f64, u8, u16, u32, u64, i8, i16, i32, i64
-
ratio-matrix
Ratio's matrix data library
-
anthem
A command-line application for assisting in the verification of answer set programs
-
datafrog
Lightweight Datalog engine intended to be embedded in other Rust programs
-
bb-geometry
A small crate containing some data structures and methods for 4d Euclidean geometry
-
faer_gmres
GMRES implementation using faer
-
vectora
A vector computation library
-
renplex
capable of modeling complexed-valued neural networks built with Rust
-
petal-decomposition
Matrix decomposition algorithms including PCA (principal component analysis) and ICA (independent component analysis)
-
scorch
A straightforward and customizable neural network crate, built for machine learning tasks
-
noise-algebra
Easy manipulation of noise functions
-
binary_polynomial_mod_algebra
Basic algebra on univariate binary polynomial
-
lowdim
two- to four-dimensional integer geometry
-
projgeom-rs
Projective Geometry in Rust
-
checked_num
Overflow-checked numbers for safety without sacrificing ergonomics
-
stroke
zero-allocation library providing const-generic implementations of Bézier curves, B-Spline curves and specialized implementations of up to cubic Bézier…
-
rfcalc
calculate things
-
cli_calculator
A basic cli calcuator
-
warmup
Calculates the repetitions required for a warmup
-
confi
confidence intervals and significance levels for statistical computation
-
squiid-parser
The algebraic expression parser for Squiid Calculator
-
vqf-rs
A
no-std, dependency-free port of VQF sensor fusion algorithm for IMUs -
nauty-Traces-sys
Low-level bindings for nauty and Traces
-
bestagon
An engine for discrete stuff in hexagonal grids
-
exprimo
JavaScript expression evaluator written in Rust
-
mathfun
high-performance math functions
-
sum-calc
A sum calc
-
gpu-fft
performing Fast Fourier Transform (FFT) and Inverse FFT using GPU acceleration
-
gpca
'Async Hyper-Graph Cellular Automata' computational model
-
coloremetry
small color library written in Rust
-
simple_vector2
libary for generic vector manipulation that just works
-
mago-trinary
implementing three-valued logical operations (true, false, maybe) to handle complex logical reasoning scenarios
-
rao
Robust and scalable Adaptive Optics tools
-
special-fun
Special functions for Rust by binding to the Cephes library
-
poly_it
A no-std library for manipulating polynomials with slice support and minimal allocation
-
image_processing
This package provides tools for image processing with a focus on edge detection and morphological transformations
-
root1d
One dimensional root finding algorithms
-
fast-boolean-anf-transform
Fast implementation of the boolean Algebraic Normal Form (ANF) transform
-
iron_learn
A pure Rust Machine Learning Library with Generic Tensor and a Gradient Descent Optimization Function
-
scurve_motion
S-Curve motion planning library
-
metriken-exposition
Exposition for metriken metrics
-
distimate
providing probability distributions for estimation and risk analysis
-
fixed_math
Some math traits and functions for
fixedpoint numbers -
blas
The package provides wrappers for BLAS (Fortran)
-
algebraeon
computational algebra library re-exports for all components
-
arithmetic-parser
Parser for arithmetic expressions with flexible literals and type annotations
-
br-maths
maths
-
intfinity
An abstraction over numeric types with infinity implemented
-
sark_grids
A set of grids for storing and accessing data in a grid-like way
-
newnum
traits for number API and hierarchy
-
musclecalc
fitness: estimate the one repetition maximum (1RM)
-
physdes-rs
Physical Design in Rust
-
automesh
Automatic mesh generation
-
strmath
Do math with your strings
-
decimal-percentage
Percentage type with rust_decimal
-
signal-gen-cjds66-lib
An unofficial support library which can fully remote control the inexpensive Koolertron DDS Signal Generator known as GH-CJDS66
-
bls12_381-bls
BLS signatures using the BLS12-381 curve
-
expression_engine
An expression engine written in pure rust
-
vectorial
general-purpose vector math
-
type-fn
Allows for simpler coding of type-level logic, e.g. for type-number systems.
-
capy-graph
A framework for constructing arithmetic circuits on-the-fly
-
rust-kzg-bn254-primitives
offers a set of structs, traits and functions for generating Blobs and Polynomials which are used to interact with rust-kzg-bn254-prover and rust-kzg-bn254-verifier crates
-
balanced-direction
manipulate directions with discrete logic
-
cas-unit-convert
Unit conversion library for CalcScript
-
kneasle_ringing_utils
'kitchen sink' utility library for my ringing projects
-
wigners
Compute Wigner 3j and Clebsch-Gordan coefficients in pure Rust
-
boostvoronoi
Boost voronoi ported to 100% rust
-
palmfft
Palm-sized Faster Fourier Transform
-
tea-dtype
provide datatype and useful traits for datatype
-
ecoord-cli
CLI tool for transforming between 3D coordinate frames
-
gchemol
Graph-based CHEMical Objects Library
-
lav
Lane-Associated Vector (LAV): Portable SIMD vector trait as GAT of SIMD lane trait
-
blazing_fibonacci
A fast Fibonacci number calculator using matrix exponentiation and fast doubling
-
prime_finder_rust
A prime finder made in Rust (originally made in c++)
-
parry2d-f64
2 dimensional collision detection library in Rust. 64-bit precision version.
-
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…
-
minllm
minimalist LLM framework implemented in Rust with Python bindings
-
eiche
tools for working with symbolic expressions
-
owa4x
Idiomatic wrapper around the owa4x-sys crate
-
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…
-
owens-t
Owen's T Function and Bivariate Normal CDF computations
-
lucky
A program to test the probability of winning a prize
-
ohsl
A collection of numerical routines and mathematical types for use in scientific computing
-
vax-floating
VAX floating-point types
-
fnir
Fast numerical integration rules, like tanh-sinh quadrature
-
discrete-gaussian
Gaussian sampling over discrete fields/rings/sets
-
rustsat-cadical
Interface to the SAT solver CaDiCaL for the RustSAT library
-
ha-ndarray
A hardware-accelerated n-dimensional array
-
primal-check
Fast standalone primality testing
-
patronus
Hardware bug-finding toolkit
-
chfft
Fastest Fourier Transform library implemented with pure Rust
-
vf2
VF2 subgraph isomorphism algorithm in Rust
-
tabularlib
Small library for abstract matrices stored in single linear vectors created as practice project
-
tinymvt
serializing Mapbox Vector Tile (MVT) with minimal dependencies
-
combinatorial
tools, functions, and generators
-
rusty-wam
The Warren Abstract Machine in Rust
-
uint256
A light-weight implementation of 256-bit unsigned integers type with semantic API
-
rectutils
Common algorithms for rectangles (quadtree, rect packing, etc.)
-
geogram_predicates
Rust bindings to the Geogram library's predicates module
-
circle
Definition of circle and ellipse
-
camera-intrinsic-model
Camera Intrinsic Models
-
sigma-types
Types checked for an invariant
-
malachite-q
The arbitrary-precision type Rational, with efficient algorithms partially derived from GMP and FLINT
-
rapier3d-urdf
URDF file loader for the 3D rapier physics engine
-
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.
-
qvnt
Advanced quantum computation simulator
-
hasty
interface to system BLAS libraries for fast linear algebra operations
-
simple-bezier-easing
calculating cubic Bézier curves using De Casteljau's algorithm
-
resilience-rs
Resilience patterns in Rust
-
function
A set of useful traits for your functional needs
-
tritet
Triangle and tetrahedron mesh generators
-
control-sys
A Control System library implemented in Rust to design and analyze control systems
-
interactors
Command pattern implementation for Rust
-
crcp
Tools for CRC codes: calculation of order, weight, distance and dual distance distribution, minimum distance, optimality, etc
-
gaussian_curve_fit
A
no_stdand noalloclibrary for gaussian curve coefficents calculation -
beacon-calculator
calculating the glass colors needed to color a Minecraft beacon
-
deterministic-trigonometry
Trigonometry without floating point variables to achieve deterministic results across hardware and compilers
-
zkpolynomial
polynomial operations, including addition, multiplication, evaluation, and Lagrange interpolation for univariate polynomials
-
punc
Pun Calculus
-
libmf
Large-scale sparse matrix factorization for Rust
-
mscore
providing core operations for computational mass spectrometry proteomics
-
computable-real
Computable real number
-
google-dfareporting3-cli
A complete library to interact with dfareporting (protocol v3.0)
-
pemel
Parsing and Evaluating of Math Expressions Library
-
numint
ODE solvers and numerical integration in Rust
-
type_eval
Type level evaluation and proof-carrying
-
mikino_api
induction and BMC engine
-
ekg-identifier
generating and parsing EKG identifiers
-
ffactor
A very minimal number theory utilities
-
finite_element_method
A finite element method module
-
dotzilla
Native Rust implementation of efficient basic linear algebra routines
-
kalc-lib
a complex numbers, 2d/3d graphing, arbitrary precision, vector/matrix, cli calculator with real-time output and support for units
-
bounded-counter
Generic Incremental Bounded Counter
-
thue_morse
generating Thue-Morse number sequences for different bases. You can also specifically create evil numbers and odious numbers.
-
fj-interop
Early-stage b-rep CAD kernel
-
generic-interval
A generic closed interval library
-
adlo
Adaptive LLL algorithm for solving SVP
-
g_2_0_0
manipulate arbitrary object in the geometric algebra containing two perpendicular vectors that square to 1. Basically 2d VGA
-
windowfunctions
Common window functions for apodization
-
nonogram-rs
A fast and lightweight nonogram solving library
-
algexenotation
in Rust
-
static-math
Fast mathematical operations with static arrays, without
unsafecode -
cas-compute
Numerical and symbolic evaluation for CalcScript
-
adf_bdd
solve grounded, complete, and stable ADF-semantics by utilising OBDDs - ordered binary decision diagrams
-
rust-matrix
foundational matrix operations for matrices containing <f32>, <f64> or complex numbers built from those types
-
mapping-algorithms
A collection of pure-rust algorithms, for spatial and SLAM purposes
-
statistical_computing
statistical computing in Rust
-
incr_stats
Fast, scalable, incremental descriptive statistics in Rust
-
vecmath
type agnostic library for vector math designed for reexporting
-
algebra_kit
An abstract algebra library for Rust
-
numbat-cli
A statically typed programming language for scientific computations with first class support for physical dimensions and units
-
mlkem-fips203
MLKEM [512, 768, 1024] module-lattice key encapsulation mechanism following the FIPS 203 standard
-
boolean_function
Mathematical analysis of Boolean functions
-
lina
Linear algebra library with a focus on 3D applications like games (i.e. low-dimensional vectors and matrices)
-
arranged
Statically bounds-checked (machine-word-abstracting? TBD) ranged types as zero or low-runtime overhead abstractions providing safe (no unintentional overflow) arithmetic
-
captcha_breaker
多种验证码识别实现
-
jacderida-exp2-adder2
Little binary for experimenting with automated release workflows
-
fitme
CLI curve fitting tool. Parameterise an equation from a CSV dataset.
-
logic-form
representing Cube, Clause, CNF and DNF
-
y_conbinator
Y conbinator demonstration
-
algoroutine
Light-weight algebraic effect(algebraic goroutine) in Rust
-
rust-github-action-test-b76u22ivt4z3
四則演算を行うライブラリ
-
unicode-math-class
Determine the Unicode class of a mathematical character
-
principia_optimization
A Numerical Optimization Library
-
binarybit
Boolean algebra operations in Rust
-
delaunay_creator
delaunay triangulation for 2D and 3D(not implemented yet)
-
bounds
interact with bounded and unbounded ranges
-
boolean-logic
propositional logic evaluator that creates truth tables for propositional expressions
-
hmath
Big Integers and Rational Numbers
-
credit_portfolio_model
Simulation of factor model to calculate loss distribution of a credit portfolio
-
break_infinity
larger numbers up to 1e9e15 in Rust for Incremental Games
-
option-operations
Traits and auto-implementations to improve arithmetic operations usability when dealing with
Options -
spiro
Raph Levien's C implementation of Spiro in pure Rust, transpiled by C2Rust and then heavily edited
-
rust_ev_system_library
E-Voting system library functionalities for the Verifier
-
multidigraph
extraction multi digraph from a Vec of Paths
-
sqrtx
Square root calculation
-
proj5
Pure Rust, type-safe alternative to PROJ.4
-
twibint
arithmetic on arbitrarily large integers. Provides Python bindings as well.
-
commander-core
used by commander-rust only. Please don't use it!
-
geometry_tools
Efficient computation of single precision geometric data
-
quad-rs
Adaptive Gauss-Kronrod Integration in Rust
-
quad-to-quad-transformer
Translate 2d points from one quad to another
-
unit-prefix
Format numbers with metric and binary unit prefixes
-
math-comb
Math library for Combinatorics, Modular arithmetic & Number Theory utilities
-
nalgebra-mvn
Multivariate normal distribution using nalgebra
-
xldenis/creusot
prove your code is correct in an automated fashion
-
katex
Rust bindings to KaTeX
-
slice_math
A selection of useful math operations on slices
-
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.
-
mosekcomodel
Conic Optimization Modeling with Mosek
-
range-ext
Range intersection
-
rusty_math
mathematical, statistical and machine learning operations
-
meval
math expression parser and evaluator
-
irox-tools
Stuff that should have been in the Rust STL, but aren't
-
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).
-
firmath
Math Library for Graphics
-
rust-tensors
n-dimensional arrays
-
scirs2-linalg
Linear algebra module for SciRS2
-
sqpnp_simple
SQPnp camera pose estimation
-
honeycomb-render
Visualization tool for combinatorial maps
-
rpn-c
A calculator environment using Reverse Polish Notation and multiple precision numbers
-
opensrdk-probability
Standard probability library for OpenSRDK toolchain
-
CLI_Project_Scott_Coakley
CLI Project in Rust
-
cubature-sys
Bindings for cubature with support for Linux, macOS, and Windows
-
num_bound
Add bounds fn to anything implementing
Ordthat bounds a number to a range -
infojenn
Compute information content of ontology terms from corpora of annotated items
-
fibonacci-numbers
The 59th Fibonacci number
-
categorical
combining categorical random distributions and computing exact probabilities
-
linfa-tsne
Barnes-Hut t-distributed stochastic neighbor embedding
-
flat_matrix
that adds flat matrices
-
logaddexp
stable implementations of logaddexp and logsumexp
-
angulus
Unit agnostic angle
-
damndiff
Numerical methods for ODE
-
lcmx
Calculate the least common multiple of multiple values
-
rustitude-gluex
GlueX Amplitudes for Rustitude
-
mod3d-shapes
3D Models for Gl processing
-
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
-
fuzzy-logic_rs
fuzzy logic in rust!
-
espada
Texas Hold'em poker odds evaluator
-
flag-algebra
Razborov's flag algebras
-
reduced_row_echelon_form_jeck
reduced_row_echelon_formis an api that lets you constuct a Matrix and convert it to RREF -
rust_decimal_cql
that wraps rust_decimal and implements (de)serialization support for ScyllaDB's native DECIMAL type
-
xmath
Rust port of Microsoft DirectXMath
-
cubic_spline
Function that calculates curve points for cubic spline
-
gmp-mpfr-sys
Rust FFI bindings for GMP, MPFR and MPC
-
talos_metrics
Metric utilities used in Talos
-
intervalsets
bounded and unbounded intervals implemented as sets with all the associated set operations
-
single_algebra
A linear algebra convenience library for the single-rust library. Can be used externally as well.
-
alg-cli
Alg tool
-
specialized-div-rem
specialized division algorithms for integer primitives
-
kalman-rust
Dead simple implementation of Discrete Kalman filter for object tracking purposes
-
brine-fp
192-bit fixed-point math library with logarithmic and exponential functions. Designed for blockchain, scientific, and financial applications.
-
rlu
Sparse LU Decomposition (Gilbert-Peierls)
-
lox-earth
Tools for Earth-based astrodynamics for the Lox ecosystem
-
generic_fixedpoint
Generic fixed-point numbers
-
alemat
type-safe building of MathML
-
rust_decimal_ext
Decimal number implementation written in pure Rust suitable for financial and fixed-precision calculations
-
vectormatrix
Idiomatic Matrix and Vector types for Rust
-
sdf-df-guest
guest crate for sdf df wrapper
-
linear_algebra
basic linear algebra operations in Rust
-
integrate
Small, lightweight Rust library for performing numerical integration
-
pmm_math
Version of PMM Mathematical Formula Library
-
pandrs
pandas-like DataFrame for data analysis
-
albert
A terminal calculator written in Rust with ❤️
-
urs
Rust utility library
-
extent
replacement for std::ops::{Range,RangeInclusive}
-
mm0_util
MM0/MM1 language utilities
-
numera
numbers
-
net_promoter_score
calculating Net Promoter Score (NPS) from survey responses
-
ointer
Steal the high bits of a pointer to store an extra value
-
kabsch_umeyama
Kabsch-Umeyama algorithm is a method for aligning and comparing the similarity between two sets of points. It finds the optimal translation, rotation and scaling by minimizing the root-mean-square deviation (RMSD)…
-
num-runtime-fmt
Format numbers according to a format spec determined at runtime
-
curso7-8
Biblioteca de teste para funçoes simples somar e sub
-
analog_literals
Multi-Dimensional Analog Literals in Rust
-
voronota
Voronota-LT is an alternative version of Voronota for constructing tessellation-derived atomic contact areas and volumes
-
micro_ndarray
Very small multi-dimensional-array implementation
-
vctr2
2d vector library
-
zoc
Z-order curve based multidimensional range search
-
komunikilo
A chaotic communications simulator
-
mech-matrix
Matrix library for the Mech language
-
number-theory
Fast primality, factorization and elementary number theory for integer types
-
factorial
Convenient methods to compute the factorial, optionally checked
-
unifrac
working with normalized fractional values
-
gemm-benchmark
BLAS [sd]gemm benchmark
-
num-ordinal
Ordinal number types
-
kapacitor-multi-indicator-batch-udf
A multi-indicator batch UDF for Kapacitor
-
os_type
Detect the operating system type
-
starstuff-types
star catalog parser and primitive types for star coordinates and astronomical times
-
integral_lib
liblary for solving integrals using numerical methods
-
simp_linalg
A generically defined, light-weight linear algebra library for simple addition and multiplication of vectors and matrices
-
ggblas
Matrix multiplicatiosn in simple pure rust multithreadded blas-like interface. Exploits intrinsics on available targets
-
qc
An enhanced RPN cli tool for quick binary, octal, decimal, hexadecimal calcs
-
wedged
A robust and generalized library for Geometric Algebra in Rust
-
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.
-
green-kernels
Evaluation of Green's function kernels
-
cork
A command-line calculator for hex-lovers
-
feldera_rust_decimal
Decimal number implementation written in pure Rust suitable for financial and fixed-precision calculations
-
nalgebra-glm
A computer-graphics oriented API for nalgebra, inspired by the C++ GLM library
-
f3l_glam
3D Point Cloud Library
-
nauty-pet
Canonical graph labelling using nauty/Traces and petgraph
-
spalinalg
Sparse Linear Algebra Library
-
algebraeon-sets
Algorithms in combinatorics
-
mini-matrix
A mini linear algebra library implemented in Rust
-
g3
Neat library for computer graphics based on geometric algebra
-
num-lazy
Number macros for generic-typed functions
-
my_math_demo
A test demo
-
ravencol
Tabular data manipulation
-
mazer-cli
A minimal, simple math markup language that compiles to HTML, written in Rust
-
tropy
Entropy viewer for the command line
-
pitch-pipe
Pitch Pipe is a method for automatically tuning a one euro filter
-
traitgraph-dimacs-io
Functions to read and write graphs in DIMACS format
-
recall_entangler_cli
A command line interface (CLI) for the Aplha Entanglement
-
opensrdk-linear-algebra
Standard linear algebra library using blas and lapack for OpenSRDK toolchain
-
diman
Zero-cost compile-time dimensional analysis
-
kalkulator
A mathematical expression evaluation tool and library
-
multi_compare
Macro for comparing multiple values in a concise way. (a < b < c)
-
my_lib_tuanla
Sample rust
-
num-iter
External iterators for generic mathematics
-
rug-maths
rug wrapper implementing maths-traits
-
divrem
Division and modulus variants
-
fwd_ad
Forward auto-differentiation, allowing its user to manage memory location and minimize copying
-
rusty-talib
using pure rust code for technical analysis
-
arithmetic_yukinari
arithmetic library
-
rssat
that provides Rust bindings for multiple popular SAT solvers
-
gamemath
math library for game development, written in Rust
-
array_math
A selection of useful math operations on arrays
-
topology-traits
Topological traits for generic mathematics in Rust
-
machine-check-common
formal verification tool machine-check
-
faer-evd
Basic linear algebra routines
-
dtee
Decision table editor engine
-
prime-checker
hold sample functions to check the prime-ness of a given unsigned, 64-bit integer
-
sus-impls
Non-conflicting implementations for optional fields
-
inrust
Accumulate knowledge of my study on Rust language
-
cavalier_contours
2D polyline/shape library for offsetting, combining, etc
-
sr-rcd
Apply Refining-Cover-by-Defect algorithm to solve Sound Ranging problem in time-dependent-metric (and, in particular, (quasi-)metric) spaces
-
generic-matrix
Manipulations and data types that represent 2d matrix
-
funspace
N-dimensional function spaces and transforms
-
baiser
Curves manipulation library
-
rpoly
algorithm for finding all roots of a real-coefficient univariate polynomial
-
kn0syseccrs
Intuitive library for elliptic curve cryptography tutorials
-
xenn_simple-math
math library
-
numberlab
A collection of numerical algorithms
-
smartcalc-tauri
Text based calculator for peoples supported in Tauri
-
tatam
Theory And Time Analysis Machine
-
idcator
typed id
-
calcucalc
A general-purpose calculus library written in Rust
-
langtons-termite
Langton's Ant that runs in a terminal window
-
dace
Rust wrapper of DACE, the Differential Algebra Computational Toolbox
-
patch-tracker
Patch tracker
-
meansd
calculate mean and standard deviation
-
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 -
modular_equations
Program to solve quadratic and linear modular equations
-
break-eternity
A numerical library to represent numbers as large as 10^^1e308 and as 'small' as 10^-(10^^1e308)
-
gosh-model
Chemical model for gosh
-
swf-fixed
SWF fixed-point numbers for Rust
-
ommx
Open Mathematical prograMming eXchange (OMMX)
-
fdec
A collection of macros for generating fixed-size fixed-point numeric types for Rust
-
arithmetic_congruence_monoid
Реализует арифметические конгруэнтные моноиды (ACM) в проекте на основе YAML
-
linearalgebra
Test project to learn Rust and implement a small library for linear algebra
-
min_max_assign
Change min(max) implementation in Rust
-
seismic-response
Seismic response analysis of a single particle system is performed using Newmark's beta method
-
spherical-cow
Spherical Cow: High volume fraction sphere packing in arbitrary geometries
-
reductive
Optimized vector quantization for dense vectors
-
kolakoski_algorithms
Efficient algorithms for the Kolakoski sequence
-
longitude
Work with real world coordinates in Rust!
-
distributed_control
Create, analyze and simulate multi-agent, distributed control systems
-
curve-sampling
Adaptive sampling of parametric
-
numb_rs
An experimental numeric package
-
lib_polish_opz
ma
-
linal
tiny linear algebra library without dependencies
-
ipopt_bindgen
Rust bindings to the C interface of Ipopt, a library for large-scale, constrained, nonlinear optimization
-
feo-math
Math library for 3D transformation
-
gchemol-graph
Networkx-like API wrapper around petgraph
-
ring-math
Polynomial ring math over scalar finite fields
-
aberth
Aberth's method for finding the zeros of a polynomial
-
rust-3d
2D/3D library written in rust
-
ariprog
Need a powerful and simple library to work with arithmetic progressions in Rust? You should definitively try out ariprog!
-
abstalg
Abstract algebraic structures for Rust
-
mumps-src
Build Mumps as a crate
-
rounded-div
Get rounded result of an integer division
-
clausen
functions
-
arpack-ng
Save interface to arpack-ng-sys
-
ibdgen
Generate incomplete block designs for experiments with prohibited pairs
-
math-rs
A basic mathematical engine
-
coco-rs
Rust bindings for COCO benchmarking framework
-
spin4
esoteric programming language that uses 4D rotations for computations
-
matrix42
A linear algebra library developed as a project in the 42 ecosystem
-
ndarray-glm
Performs regression for generalized linear models using IRLS on data stored in arrays
-
signum-sign
Adds the signum function to Rust
-
doubled
Dekker arithmetic
-
munum
Micro 3D Math Library
-
aisth
A toy ray tracer
-
simoes_converter
numbers converter to another base
-
auto_regressive
constructing AR(p) models using the Yule-Walker equations
-
easy_complex
Complex numbers crate
-
slist
Algebraic lists with statically determined size that live on stack
-
oint
oint ('optional int') provides total operations on arithmetic
-
image-recovery
Image recovery algorithms, implemented in Rust
-
hpn
Text-based RPN-style calculator in the HP Voyager tradition
-
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.
-
jyafn
Computational graphs for Data Science that compile to machine code
-
vector-geometric-algebra
vector algebraic operations for 2d and 3d vector, as well as splines
-
piecewise-linear
manipulating piecewise linear functions
-
compute-pi
designed for computing pi to millions of digits
-
oat_python
User-friendly tools for applied topology in Python
-
kaede
adalah rust library untuk operasi matematika sederhana
-
kissunits
Different units (like distances or coordinates), keeping it small and simple
-
minimax-alpha-beta
Alpha-Beta Pruning + Minimax Algorithm for arbitrary two player minimax style games like Chess, Go, TicTacToe, etc
-
rust-blas
BLAS bindings and wrappers, fork of rblas
-
zkmatrix
zk-SNAKR for linear algebra
-
concision-data
Concision is a complete data-science toolkit written in Rust
-
algebraeon-nzq
natural numbers, integers and rationals for algebraeon
-
lineic
Flexible linear interpolator for Rust
-
padic
P-adic numbers in Rust
-
robust-predicates
Robust predicates for computer geometry
-
lnexp
Carefully evaluate compositions of log, exp, log1p and expm1
-
num_parser
A math interpreter and evaluator
-
fixed-exp2
Exponentiation for fixed-point numbers (forked, see README)
-
blis-src
Rust native linking for BLIS library
-
cblas
The package provides wrappers for CBLAS (C)
-
matrijs
A small 2D matrix library. There are many like it but this one is mine.
-
rect-iter
Iterator for 2D rectangle areas
-
f128
Bindings to the gcc quadmath library
-
euler
Mathematics library for 3D computer graphics
-
guff-matrix
Fast Galois Field matrix multiplication
-
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
-
indicato_rs
common statistical market signals
-
linxal
Linear Algebra package with rust-ndarray interface
-
ang
Angular types and common helper methods
-
simple_rpn_calc
RPN Calculator
-
metal-matrix
High-performance linear algebra library with Metal GPU acceleration
-
nmoney
money representation
-
uscope
Cytogon GUI
-
plexus
2D and 3D mesh processing
-
rspp
rust probolistic programming
-
aws-smt-ir
Intermediate representation for SMT problems
-
number-diff
number-based is an attempt of mine to make working with calculus easier
-
lll-rs
LLL algorithm for lattice reduction and it's improved version L²
-
mfem-cpp
Static build of MFEM for use as a Rust dependency
-
easing-fixed
easing iterators using fixed-point math
-
crum
Tensors, Matrices and Complex numbers for numerical analysis
-
vectune
A lightweight VectorDB with Incremental Indexing, based on FreshVamana
-
linfa-hierarchical
Agglomerative Hierarchical clustering
-
hundred-doors
calculating and visualizing the '100 Doors' problem
-
distmat
Distance matrix data types and file formats
-
lamcal
A lambda calculus parser and interpreter
-
nml-matrix
A small library to work with matrices
-
quaternion-wrapper
Operator overloading allows implementation similar to mathematical expressions
-
gateconvert_exec
The program to convert Gate circuit from/to foreign logic format
-
rust_solar
Date-time solutions for hypothetical cosmic calendars
-
mymatrix
My simple matrix library that can perform fraction operations
-
simple_math_utils
basic math functions
-
multi-skill
Skill estimation systems for multiplayer competitions
-
ndgrid
n-dimensional grid library
-
haxcel
Excel gateway to Haskell
-
cas-graph
A customizable graphing calculator for CalcScript
-
gematria_rs
Gematria, a traditional Hebrew numerology system
-
reals
Computable and unified real numbers
-
RayBNN_Sparse
Sparse Matrix Library for GPUs, CPUs, and FPGAs via CUDA, OpenCL, and oneAPI
-
net_ensembles
Erdős-Rényi and small world ensembles. For simple sampling, Markov chains etc.
-
belnapian
Belnap's 4-valued logic basic building blocks in Rust
-
xdd
Decision diagrams including BDD, ZDD, MBDD, πDD and more for combinatorics
-
libhackrf
A modern libhackrf wrapper that supports receiving and transmitting
-
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.
-
rs-sci
the scientific 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
-
nexsys
Solve nonlinear systems of equations using Newton's method
-
roundable
Round numbers and durations to a given factor
-
apbool
Just arbitrary precision boolean arithmetic for Rust
-
saturating_cast
saturating casts between integer primitives
-
malachite-nz
The bignum types Natural and Integer, with efficient algorithms partially derived from GMP and FLINT
-
xfeval
the Excel-like formula calculator
-
rust-freqdist
Frequency Distribution in Rust
-
geo_filters
Geometric filters for set cardinality estimation
-
vda5050-types
Types defined by the VDA5050 standard for AGV communication
-
amfnengine
Amortization Functions (AmFn) Engine
-
rusty_library123456
maths library
-
inspector-gadget
A cli-based, multi-architecture gadget-finding tool, designed for fast operation, even with large binaries like browser engines and OS kernels
-
eca
A cli tool to run elementary cellular automatons
-
lipmaa-link
A function to calculate lipmaa sequence numbers
-
yices2
Rust bindings to the Yices 2 SMT solver
-
caldyn
Dynamic evaluation of mathematical expressions
-
allan-tools
Package to compute statistics to study systems stability
-
pythagorean-hodographs
Pythaogrean hodograph splines
-
dcc-tiler
CLI for counting / rendering tilings of various shapes
-
speedicycle
locating fixed-length circuits in undirected graphs, built atop petgraph
-
ieee754
Low-level manipulations of IEEE754 floating-point numbers
-
octoon-math
Graphics utilities for Rust
-
t4t
Tit-for-tat: a game theory toolbox
-
rust_math
Math library written in Rust
-
rust-linear-algebra
A linear algebra library for Rust
-
ndarray-inverse
Pure Rust Inverse and Determinant trait for ndarray Array2
-
tutorial-1
Online store library
-
polar
A command-line calculator that can also convert between units
-
gfx-maths
Implementations for the most essential Graphics Math operations
-
sari
arithmetic expression evaluator
-
libpcp
A constraint solver supporting arithmetic constraints over integers
-
hrbf
Hermite Radial Basis Functions with higher order derivatives
-
argentum_standard_business
The business layer of standart component
-
mathio
A lightweight, simple and straight-forward opinionated library for math used in other projects
-
nalgebra_latex
several robust formatters for nalgebra::Matrix, LaTeX environments, and more
-
gecl
geometry types and a color type
-
interva
A feature-rich crate for handling intervals
-
guff
Implements Galois Fields for various natural sizes
-
scirs2-interpolate
Interpolation module for SciRS2
-
quantogram
Approximate quantiles using histograms with logarithmically sized bins to guarantee worst case absolute relative error
-
alpha_g_detector
handle the raw output of the ALPHA-g detectors
-
pire-base
high performance cpu kernels
-
homography
estimation using point and line correspondences
-
scirs2-integrate
Numerical integration module for SciRS2
-
round-to
Round floating point to integer
-
comodules
calculating Ext for coalgebra and comodules. Also does Finite Field linear algebra.
-
alphabeta
Tools for analysing epigenetic data
-
compute-tau
designed for computing tau to millions of digits
-
doodle_unit_tools
handling and working with multiple different unit types
-
query-curve
querying custom Bezier curves, compatible with curves created at https://querycurve.com
-
smt_sb-rs
SMT Simple Binding
-
sabi-rust
A small framework to separate logics and data accesses for Rust application
-
globalsearch
Global optimization with scatter search and local NLP solvers written in Rust using argmin
-
faer-svd
Basic linear algebra routines
-
iascar
incremental answer set count with anytime refinement
-
mathcalculate
My first Rust library
-
cherry-rs
Tools for designing sequential optical systems
-
hexga_math
Math related crate that support multi dimensionnal vector, matrix, rectangle
-
binairo
solver
-
aviation-calculator
Useful calculations for aviators
-
inter-val
Mathematical intervals, i.g., [a, b], (a, b), [a, b), and (a, b] on ℝ, and multi-dimensional axis-aligned boxes represented as Cartesian product of intervals
-
vertex_clustering
vertex clustering
-
tazui
terminal calculator
-
circomspect-circom-algebra
Support crate for the Circomspect static analyzer
-
classgroup
class groups in Rust. Uses GMP for arithmetic.
-
hebrides
Implementations for the real numbers, complex numbers, and basic linear algebra
-
sum_range
The sum of all consecutive numbers, both even and odd
-
wrapping_coords2d
Translate between 1D indices and 2D coordinates with wrapping
-
vectors
Sparse & dense vectors for use in high dimensional vector spaces
-
numrs2
inspired by NumPy for numerical computing (NumRS2)
-
gee
A convenience-first geometry library tailor-made for 2D games! 📐
-
intervals
A generic interval type with support for open/closed bounds
-
sparse_complex
solver for complex sparse matrices
-
arith_wrappers
Rust’s
stdoffers theWrappingtype for “intentionally wrapping” arithmetic, but curiously does not provide analagous implementations for intentionally saturating… -
mathsharp
collection of mathematical functions and resources to assist in solving a wide range of topics
-
wheel
algebra library for Rust
-
cpntt
Number Theoretic Transform for competitive programming
-
hambands
small Rust library for checking which amateur radio band a frequency belongs to
-
basemath
math, from the ground up
-
tazor
implementing a calculator based on mathematical expression
-
smolmatrix
Small simple matrix library
-
elementary-cellular-automaton
that handles Elementary Cellular Automata
-
dexterior
Discrete Exterior Calculus toolkit
-
typerat
Type-level rational numbers based on
typenum -
repunit
Generation Library for Rust
-
freude
An ODE library for ndarray providing some simple, fixed-step integrators
-
sci_rust
A scientific Rust library
-
gorf-core
Lambda calulcus backend library
-
acm
Arithmetic congruence monoid implementation in Rust
-
m4ri-rust
M4RI-based boolean linear algebra
-
my_kgk_library
A brief description of what your library does
-
asciimath
Mathematical expression parser and evaluator
-
periodic-table-rs
A chemistry library written in Rust
-
ambient_math
Convenient mathematical operations for the Ambient runtime
-
maintenance-burden
Calculate the maintenance burden of each file in a git repository
-
RatRod-rs
An FEM implementation written in Rust
-
goniometry
module for working with trigonometric functions like sine, cosine, tangent and much more to come
-
chemrust-nasl-app
New Adsorption Site Locator (NASL) for catalyst materials. Written in rust. Part of the
chemrusttoolchain. This is the binary crate. -
simple-simplex
Generates 2d simplex noise values and applies Fractal Brownian Motion
-
astro-float
Multiple precision floating-point numbers library
-
equation
mathematical expression evaluation and simplification
-
kaprekar
Include a function to find number of iterations to reach Kaprekar's constant
-
ngeom
Geometry in N dimensions
-
fix-rat
A rational number type with fixed denominator
-
duckduckgeo
2d geom library
-
scuttle
A multi-objective MaxSAT solver
-
gchemol-geometry
gchemol: a Graph-based CHEMical Objects Library
-
abstract-calculus
A programming language and model of computation that matches the abstract algorithm perfectly
-
dc-ock
reverse polish notation desk calculator library
-
structural-shapes
Common structural shapes
-
fibs
Get a Fibonacci number or sequence
-
appro-eq
Approximately equal traits and assertion
-
stardust-xr-fusion
High level client library for the Stardust XR display server
-
float_extras
Extra floating-point math functions from C math library
-
cl-calc
A command line calculator
-
odesolver
solving ODE's
-
ctclib
A collection of utilities related to CTC, with the goal of being fast and highly flexible
-
my3
My3
-
fcwt
Fast Continuous Wavelet Transforms
-
metrics_evaluation
Small foot-print parser and solver for (nested) text-based comparisons
-
stack-algebra
Stack-allocated lightweight algebra for bare-metal rust
-
complex-number
A basic implementation of complex numbers in rust
-
hmmmm
Performant and easy-to-use hidden Markov models
-
sylvan-sys
Bindings for the Sylvan parallel decision diagrams library
-
cyclotomic
high-performance library for exact operations in cyclotomic fields
-
q-num
Q notation for fixed-point numbers via a proc_macro
-
didu
Convert durations between units. Even supporting decades and centuries!
-
sprs-ldl
Sparse cholesky factorization
-
collatz_conjecture
A small project demonstrating the collatz conjecture, a maths problem
-
gmatlib
linear algebra in Rust and beyond!
-
rustsat-glucose
Interface to the SAT solver Glucose for the RustSAT library
-
srmfpa
Floating-point's four arithmetic operations (including fused multiply-add) and square root with strict rounding mode
-
zaplib_vector
The vector library for Zaplib
-
prop
Propositional logic with types in Rust
-
dess-examples
DESS examples
-
gmres
A sparse linear system solver using the GMRES iterative method
-
allowance
Rust Datatype to representate the deviation of measures
-
inari_wasm
A stripped-down version of Inari library (a Rust implementation of interval arithmetic) compatible with web assembly
-
jackal
Mathematical Expressions and Notations library for tensors
-
maths-traits
abstract system of mathematical traits for the Rust language
-
circadian_tools
Tools for working with circadian data, or data that is cyclical like time of day
-
ancomplex
Package provides easy to use, begginer frendly and python like complex numbers
-
irating
Estimate iRacing iRating changes
-
cf_functions
has characteristic functions for a variety of distributions
-
cayley
generic, stack-allocated linear algebra stuff, such as matrices
-
graph-algo-ptas
PTAS on planars and other graph classes
-
aftermath
parse and evaluate complex math expression
-
banquo
An offline monitor for Signal Temporal Logic formulas
-
autopp_inc
example package
-
zero_based_index
Newtype offering some utility methods for zero-based indices
-
gomez
Framework and implementation for mathematical optimization and solving non-linear systems of equations
-
expression_simplify
expression simplifier based on OO course(SCSE, BUAA)
-
adic-shape
Visualizing p-adic numbers
-
dashu-int
A big integer library with good performance
-
hwcalc_lib
Backend for the hwcalc calculator
-
rlfsc
A checker for the LFSC proof language
-
chrom
representing colours
-
scad_tree_math
Math library for scad_tree
-
geometric_algebra
Generate(d) custom libraries for geometric algebras
-
piss
PISS (Picture Secret Steganography) is a command line tool to encode/decode secrets into/from image files
-
chewy
A command-line RPN calculator
-
area_crate
Basic Area function
-
cga2d
2D Conformal Geometric Algebra primitives
-
rust-scheme
Scheme(R7RS) interpretor/compiler rust implementation
-
optimath
Linear Algebra using const generics for no_std and specialization to enable SIMD
-
rbf3
Radial Basis Function multidimensional interpolation
-
tick-machine
tick calculator
-
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…
-
agda-mode
Accessing Agda's interaction mode via command line, in Rust
-
base-converter
Convert a number in any base to any other base
-
math_matrix
highschool level matrix implementation
-
vector-space
Useful traits for working with vector spaces
-
pnets
A framework for Petri net manipulation
-
ellp
Linear programming library that provides primal and dual simplex solvers
-
collatz
Helper functions related to the Collatz conjecture
-
big_lehmer
framework to encode (compress) and decode large number sequences into lehmer codes
-
test_gmp_mpir
test gmp mpir for Rust
-
unwrap-overflow-ops
arithmetic operations that always panic on overflow
-
geo-aid-latex
Support for LaTeX output from Geo-AID
-
lib_rapid
LibRapid - a library specifically built for mathematical calculations and scientific applications
-
ramer_douglas_peucker
Ramer Douglas Peucker algorithm
-
chime
WIP library for continuous, predictable, mutable change over time
-
eqsolver
that solves equations using numerical methods
-
moonalloy
The oxidized scientific computing library for the 21st century
-
large-primes
Package for Large Prime Number Analysis
-
bmi-calculator
BMI calculator for TI Nspire™, with data for Chinese
-
polynomial-over-finite-prime-field
polynomial over finite prime field
-
lambda_calc
A command-line untyped lambda calculus interpreter
-
math-kit
Math Library for Rust 🦀
-
fibonacci_sequence
A module
-
map-range
map a value from a range to another range
-
matrixes
matrices up to and slightly beyond a highschool level. See README for details.
-
triangle_sides
calculating various properties of the triangle. Does not use points, but sides lengths for constructing a triangle
-
sequential-integration
Lightweight library for sequential integration
-
swipl-fli
Low-level bindings to the SWI-Prolog Foreign Language Interface
-
elfget
Get data from an ELF file
-
iltcme
Inverse Laplace transform with concentrated matrix-exponential functions
-
diving-decompression
Calculate required diving decompression procedures using the US Navy dive tables rev7
-
fj
Early-stage b-rep CAD kernel
-
usask_cba_calc
cli tool to calculate usask's first year engineering cba grades
-
algebra
Abstract algebra for Rust
-
ds-bst
Binary search tree implementation
-
lanczos
algorithm for eigen decomposition
-
galois_field
convenient operations on finite field, polynomials, and matrices over finite field
-
mathguru
An algebra system capable of mixed numeric and symbolic computation
-
binary_matrix
Dense binary matrix operations
-
varisat
A CDCL based SAT solver (library)
-
arthroprod
Clifford Algebra based computation for the theory of Absolute Relativity
-
roll-rs
Dice rolling library supporting full dice notation
-
openblas-build
The package provides a build helper for OpenBLAS
-
rapier_testbed3d-f64
Testbed for the Rapier 3-dimensional physics engine in Rust
-
nrfind
A set of useful mathematical functions for floating point numbers based on the Newton-Raphson method for finding roots
-
dana
Compile-time dimensional analysis via generic types
-
castep-model-core
The core module to parse, read, edit, and write 3D lattice models for castep and compatible with Materials Studio
-
octarine
Color manipulation library
-
noise_fn
Some simple noise functions and traits to allow easy integration with your own
-
lenia_ca
simulating the Lenia system of cellular automata
-
amalie
Mathmatical library written for rust and python
-
extra-math
Accidentally published
-
del-fem-cudarc
hogehoge
-
ferric
A Probablistic Programming Language with a declarative syntax for random variables
-
command_line_calculator
command-line calculator
-
maths_function
Some maths fuctions
-
toxicblend
gRPC based Blender-addons. WIP
-
exsym
Symbolic computing system for business
-
cupchan
async overwriting channel between two threads that is wait & block free by swapping cups around
-
pulgamecanica_matrix
matrix operations and linear algebra
-
strata
A unique search technology
-
xldenis/creusot-contracts
contracts and logic helpers for Creusot
-
algae-rs
A collection of abstract algebraic structures implemented in Rust
-
quadratic_residues
calculating quadratic residues of integers
-
fem_2d
2D Finite Element Method Toolkit
-
oxygen_quark
Oxygen Quark is a maths library mainly developed for the Oxygen Game Engine
-
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
-
fast_fp
Floating point fast-math optimizations
-
b-spline
B-spline
-
phlite
Persistent homology, for generic matrices, that's light on memory usage
-
gml
Graphics Math Library. Generic Vector and Matrix Math library targetting graphics applications.
-
math_rust
A Math library for vectors
-
nalgebra-lapack
Matrix decompositions using nalgebra matrices and Lapack bindings
-
basic-calc
Basic TUI calculator
-
rtsam
Real Time Smoothing and Mapping (RTSAM) in Rust
-
money2
For storing and asynchronously converting between (a subset of) ISO-4217 currencies
-
polys
A package for polygon geometry
-
overflow-proof
Monadic checked arithmetic for Rust
-
mini-math
Lightweight math routines for 3D graphics
-
blasphemy
Inspired by Keras, powered by BLAS. Construct neural networks with one line of code per layer. That's BLASphemy.
-
kifmm-fftw-src
FFTW src for fifmm
-
jacc
Just another cli calculator: A maths interpreter for the command-line
-
dashu-float
A big float library supporting arbitrary precision, arbitrary base and arbitrary rounding mode
-
radians
storing angles
-
midpoint
Extension traits offering implementations of midpoint [currently, only for primitive integers]
-
amortize-rs
A loan amortization calculator library
-
gplu
Sparse LU factorization with partial pivoting
-
autd3-geometry-viewer
AUTD viewer for Geometry
-
geomath
Stack-allocated maths for geometry, simulation and computer graphics
-
triangle
Struct for geometric triangles. Includes Barycentric-Cartesian transforms and stuff..
-
qrotate
Quaternion library for 3D rotation of vectors
-
creachadair-imath-sys
FFI bindings to creachadair imath
-
index_mask
masking indices
-
relative-duration
Duration with negative capabilities
-
wright_omega
Wright Omega function
-
rmq-tabulation
Rmq using extensive tabulation
-
raekna
combines the other crates in the workspace to make a functional program
-
dusk-schnorr
A pure-Rust implementation of Schnorr signatures with a PLONK circuit module additionally
-
fsum
calculate accurate sum of floats
-
qmat
2-dimensional matrices
-
rsmonad
Haskell-style monads for idiomatic Rust
-
feos-dft
Generic classical DFT implementations for the
feosproject -
phy_numerical
Some functions for solving Physics-Physics_Numericals related to first,second & third equation of motion
-
calc_mjp
calc simple library
-
dntk-matrix
Statically sized matrix using a definition with const generics (only for nightly)
-
MathTriks
A single crate for every mathematical manipulation
-
primenumbe-rs
Generate the nth prime number
-
vdtfont
converting glyphs into triangulations
-
surreal
that implements J. H. Conway's surreal numbers
-
beeg
easy big number conversion
-
yali
LargeInt Library
-
igrf
International Geomagnetic Reference Field (IGRF) implementation in pure Rust
-
saber
ScAlaBle Estimator Regressor for heritability estimation
-
arithmetic-sign
Arithmetic
Sign(≈+1|-1) to/from arithmetic types such asf64,i32utility -
cas-attrs
Derive macros for cas-error's ErrorKind and cas-compute's Builtin traits
-
dotbits
unsigned int <-> Vec<bool>, plus various helper functions
-
polymath
Make math in Rust more powerful! (New math datatypes, traits, functions, etc...)
-
yaterbilang
terbilang
-
pfapack
Rust interface for the pfapack library, a Fortran library to compute Pfaffians
-
acid2
2-adic double-precision floating-point implementation
-
memocalc
A useful tool for practicing mental mathematics
-
lapack-traits
Generic real/complex scalar trait wrappers for BLAS and LAPACK routines
-
Fullerene
Fullerene on the ODE (Open Dynamics Engine) for Rust
-
mathvites
An upcoming batteries included library for all things mathematics
-
progress-monitor
Track any progress
-
hexga_typedef
Provide a common typedef for
float,intanduint. The precision can be changed with feature flags and can be easily shared across multiple crates. -
wsb-rs
Calculates when your options will print
-
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…
-
minifb_geometry
meant to help draw shapes in the minifb window
-
ImtiazGermain
that checks if a number is a Germain and Imtiaz-Germain prime or not
-
cnetworks
A set of tools for creating and manipulating complex networks
-
llml
basic math data types with high level frontend and low level backend
-
lambda-rt
Lambda calulcus backend library
-
fuzzycomp
Comparison with margins
-
cubecl-common
Common crate for CubeCL
-
reuler
Solutions to Project Euler in Rust
-
miscmath
will be a collection of general math functions and linear algebra structures like vectors and matrices
-
sickle_math
Math dependencies for sickle_ui
-
kair
COnstraint Based Reconstruction and Analysis (COBRA) in Rust
-
dimensionals
Rust native generic, flexible n-dimensional array
-
satif-cadical
Rust wrapper for the CaDiCaL SAT solver
-
calculator-lib
calculator library
-
parity
is_even and is_odd methods for primitive numeric types
-
faasle
evaluating distances (metrics)
-
vodk_math
math vector and matrix library
-
trilean
Kleene's three-valued logic (boolean + unknown)
-
aurora-engine-modexp
Custom ModExp implementation that used in Aurora Engine
-
boomerang_runtime
Runtime types and discrete event executor for Boomerang
-
mathie
math type library
-
turing
hash function library
-
positivity
checking the non-negativity of values across various types
-
maria-linalg
linear algebra processing package
-
gstools-core
The core functions of GSTools
-
cgmatrix
matrix library for computer graphics in Rust
-
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!
-
gac
Generic and Atomic Recipe Calculator for Factorio
-
bitmath
Tools for arbitrary-sized bitwise arithmetic
-
smart-adder
this is smart-adder crate
-
Monte-Carlo-Pi
Estimer PI avec la méthode de Monte Carlo
-
sukker
Linear Algebra and Matrices made easy!
-
nthD_Matrix
using matrixes of any arbitrary size and dimension
-
d4-arjun-sys
wrapper around Arjun for d4
-
easygradecalculator
easy grade calculator
-
kctf-pow
CLI to solve, check, and generate proof-of-work challenges using kCTF's scheme
-
temperature_calculator
A temperature calculator
-
common_math
A collection of common math functions
-
lib_xch
xch-ceb's official lib
-
euler-rs
A command line tool for solving Project Euler problems in Rust
-
hypercpu
Distributed symbolic computation
-
fgruc
Fast graphics rendering utility collection // A collection of utils for graphics rendering and game making made with performance in mind
-
geomag-wmm
Calculate the Earth magnetic fields and their variation using WMM
-
ndelement
n-dimensional finite element definition library
-
dec-number
Decimal Floating Point Arithmetic for Rust
-
aoc-ornaments
Advent of Code tools
-
lcrs
A Lambda Calculus Interpreter written in Rust
-
swh_graph_topology
Collection of topology analysis utilities based on swh-graph
-
duckworth-lewis
A calculator for determining targets for the team batting second in weather affected cricket matches using the Duckworth Lewis Standard Edition methodology
-
noir-bignum-paramgen
command line tool to convert a modulus into bignum instance parameters for https://github.com/noir-lang/noir-bignum
-
fitting
Pure Rust curve fitting library
-
minifloat
Emulate various minifloats with const generics
-
rustbot
My package for aimbot calculations / vector math
-
feval
clt for fast evaluations
-
partial-functional
A small collection of Semigroups and Monoids for rust
-
deep_core
deep prototype
-
heuristic-graph-coloring
Heuristic algorithms for graph vertex coloring
-
gardenerpersonal-rustpkg
that adds numbers
-
hilbert_index
D-dimensional Hilbert curve
-
pirox
building a calculator
-
mtrs
matrices in Rust
-
bs_crate
The palindrome numbers library
-
eigs
Find Eigenvalues and Eigenvectors with Rust using UMFPACK + ARPACK
-
calculator-rs
Calculator is a library which support calculates the value of string
-
extended-euclidean-algorithm
computes the greatest common divisor of 2 natural numbers and 2 additional numbers such that gcd(a,b)=s·a+t·b holds
-
beagle
A basic linear algebra library for computer graphics
-
zonne
Mr.Z's Rust Open Source Library
-
signed
working with signed numbers' absolute values avoiding confusion
-
testYD_rpncalc
Reverse Polish Notation Calculator
-
lorust
Modern Rust utility library delivering modularity, performance & extras; or simply Rust version of Lodash
-
rs-measures
macros to encapsulate numbers in measures, provided with units of measurement, allowing any meaningful operation, but statically forbidding meaningless operations with them
-
probability_cli
A command line interface for probability calculations using Bayesian probability
-
spdcalc
Spontaneous Parametric Downconversion Calculator
-
hatree_fock
Hatree-Fock Method implemented in Rust
-
feanor-mempool
interface to memory allocation and pooling, designed for use by feanor-math
-
batbox-la
Linear algebra
-
polyhedron-ops
Conway/Hart Polyhedron Operations
-
algeo
Computer algebra, algebraic geometry, and related math
-
nd_vec
A compile time n-dimensional vector library
-
tg-sys
unsafe low-level bindings to the
tggeometry library -
rpn-reckoner
A Reverse Polish Notation library
-
rug-miller-rabin
A multi-threaded, arbitrary precision implementation of the Miller-Rabin primality test using rug (GMP)
-
rustgf
implements several galois field operation in Rust, as well as gaussian elimination in Galois Field
-
tetra-master-calc
Calculator for Tetra Master mini-game in Final Fantasy IX
-
mech-logic
Logic library for the Mech language
-
rust-money
basic and precise Money operations such as rounding, splitting and allocating
-
combinator
inspired by APL/J
-
spglib
Rust bindings to spglib
-
amfnwasm
Amortization Functions (AmFn) Web Assembly
-
cas-error
Error type for generic errors in CalcScript
-
usze
Sometimes you just need a calculator
-
mikino
induction and BMC engine
-
closed01
checked floating point operations within the range [0,1]
-
algebr
Basic algebra
-
ezy
Easy to use tweening library
-
gates
simulate logical gates
-
fffft
Number theoretic transform for PrimeField types (from ff crate)
-
choice
Similar to
eitherbut supports an unbounded number of variants -
rustsat-tools
Tools and examples built on the RustSAT library
-
mathbox
A math toolbox
-
reiterator
Lazy repeatable caching iterator that only ever calculates each element once
-
simple-geom
plane geometry
-
bog
The highly-modular abstraction standard
-
xer_adder
Example crate with a dependency
-
mdbook-katex
mdBook preprocessor rendering LaTeX equations to HTML
-
klein
Bindings to the Klein PGA3D library
-
crook_calculator
one function to compute mathematical equations from string slices
-
calcul8
calculator CLI
-
general_tools
offers many functions for many different types of operations, such as operations with strings, numbers, files, and more!
-
char_combinator
An iterator to create all combination of a given char range
-
smth
math library
-
square_calculator
Square Calculator
-
fitnesstools
Collection of tools related to fitness and weightlifting
-
rust_poker
Rust poker library
-
circle-packer
Implements a circle packing algorithm: https://en.wikipedia.org/wiki/Circle_packing_theorem
-
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
-
math-crate
A libary for doing simple calculations in Rust
-
tiny-dl
An experimental crate for exploring Description Logic
-
subnet
create IPv4 subnetworks based on a given address and the number of hosts you want to connect
-
ga2
Common types for 2D geometric algebra
-
matriarch
A Linear Algebra and Matrix library written in Rust
-
norman
Implementations of different norms for elements of vector spaces
-
hann-rs
Blazingly fast Rust Hann Window
-
calc_lib
calculating things with correct order of operations
-
colon
A array and number utility functions
-
egml-io
IO operations for processing GML data
-
rusty-psf
A comprehensive Point Spread Function (PSF) library for microscopy and optical systems
-
fpn
Fixed point number
-
flowscad
2D graphic and 3D object design with a Rustic functional approach. SVG and OpenSCAD output.
-
symengine
Unofficial Rust wrappers to the C++ library SymEngine, a fast C++ symbolic manipulation library
-
optimization-solvers
Numerical optimization solvers for unconstrained and simple-bounds constrained convex optimization problems
-
siiir_modular_power
A console app and library with function to quickly calculate k^n mod m
-
magicsquare
magic square/cube generation
-
inta
Interval arithmetic in Rust
-
rgla
A linear algebra library for graphics that implements rotors instead of quaternions
-
q_rsqrt
fast inverse square root function from quake 3
-
sylvan_number
My own big number implementation, just for my own uses
-
gs-rs
basic monocular SLAM (Simultaneous Localization and Mapping) Algorithm in pure Rust
-
polygamma
function
-
hcomplex
Lightweight complex and hypercomplex algebra library
-
mc-vanilla
MinecraftRS - Implementation of vanilla features for Minecraft, this extends and use mc-core
-
nabo-pbc
A fast K Nearest Neighbor (KNN) library for low-dimensional spaces, now with support for periodic boundary conditions
-
compute
statistical computing
-
arithmetic-typing
Hindley-Milner type inference for arithmetic expressions
-
unifac
calculate non-ideal vapor-liquid equilibria using UNIFAC model
-
rblas
BLAS bindings and wrappers
-
expressions
Flexible expression parser and evaluator
-
logi_code
A scripting language do executing combinational circuits
-
legasea_line
Tools for working with lines
-
nvblas-sys
This package provides linkage to NVBLAS
-
symba
Computer Algebra System written in Rust
-
gemau
The beginnings of a computer algebra system for Combinatorial Game Theory
-
openhistogram
Fast, dense, stable auto-binning histograms
-
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.
-
pow2
Represents a non-negative power of 2, by storing its exponent
-
rust-constraint
constraint satisfaction problem (CSPs)
-
normdecimal
Always normal decimal numbers
-
jingle
SMT Modeling for Ghidra's PCODE
-
generic_spline
generic implementation of spline which does not assume that spline is used in graphics context
-
cheque
Convenient checked math
-
fractionfree
Fraction-free linear algebra for ndarray
-
googology
giving names to large numbers
-
extended
precision 80-bit floating-point numbers (f80)
-
tau
The important mathematical constant tau
-
subnet_calculator
Subnet Calculator written in Rust
-
xxcalc
Embeddable or standalone robust floating-point polynomial calculator
-
cellular_raza-building-blocks
cellular_raza Building Blocks
-
lgeo
2D Geometry library, focusing on collision computation
-
nlsn-delaunay
Delaunay Triangulation and Refinement implementation through Bowyer Watson incremental insertion, conflict maps and ghost vertices
-
sv4state
SystemVerilog 4-state value library
-
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
-
ss-graph-rs
A graph algorithm library written in Rust, primarily featuring a function for finding all paths
-
math-in-rust-doc
Demo of add math to rust doc
-
libdivide
Port of libdivide
-
polygon_clipping
An algorithm for computing boolean operations on polygons
-
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… -
algebraeon-groups
Algorithms in group theory
-
better-num
Better numeric types in rust
-
knife
An iterator that divides things evenly
-
descent
Modelling and automatic differentiation for constrained optimisation
-
FEA_code
-
sparseglm
Fast memory-efficient solver for sparse generalized linear models
-
gf2_192
Arithmetic operations and polynomial interpolation over Galois fields GF(2^192)
-
mdmath_core
Multidimensional math, fundamental functionality and types
-
omni-wave
Easy to use DWT (Discrete Wavelet Transform) library, no need to worry about padding, and a variety of wavelets are available
-
blend-formula
macros for defining GPU blend modes from arbitrary formulae
-
rubikmaster
Tools to implement Rubik's cube applications
-
reddd
Domain-Driven Design (DDD) toolkit
-
My-7
I'm getting used to Rust
-
bytor
A small WIP programming language
-
delsum-poly
NTL bindings for the delsum crate
-
rmath-cli
cli calculator
-
validatornator
validator intended to be used value object constructors
-
leastsquares
Miller Updating Regression
-
quickmaths
A collection of algorithims for generic mathematics
-
polyhedron-faces
polyhedron faces for Rust
-
pcw_fn
Generic piecewise function trait and impls
-
conways_game_of_life_lib_rust
Core library functionality for Conway's Game of Life
-
hercules
A Heuristics toolbox for QUBO in 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.
-
percent-rs
percentages of integers and floats
-
shunting-yard
shunting yard algorithm implementation in Rust
-
gauss_adia
Small utility program to compute adiabatic energies for TD-DFT simulations with the gaussian 16 program suite
-
angular-units
representing, manipulating and converting between angular quantities in various units through a type-safe interace
-
projective
The representation projective transformation
-
gradecalculators
grade calculators
-
d4-gmp-sys
wrapper around GMP for d4
-
accord-rs
Calculate consensus sequences
-
shapers
fitting shapes and operations on geometrical objects
-
intel-mkl-tool
Seek Intel(R) MKL library from system
-
equationx
parsing and evaluating simple mathematical expressions/equations
-
koek-redact
Allows for redaction of values when outputting them to places where sensitive data is not permitted
-
lmbd
A macro that computes everything at compile time.Based on lambda calculus
-
simplicial_topology
Represent, manipulate, combine and perform computations on simplicial complexes
-
bempp-octree
create Octrees
-
nodarium_utils
A collection of utilities for Nodarium
-
cmsis_dsp
Bindings to the CMSIS DSP library for ARM Cortex-M processors
-
byte_arithmetic
arithmetic on byte-like objects
-
axb
linear algebra
-
statslicer
Guacamole provides a linearly-seekable random number generator
-
permutations
generating permutations
-
rust_pie_ob
a pie orderbook library for rust
-
scimath
A scientific computing library. WIP
-
arcs
An extensible framework for creating 2D CAD applications using the Entity-Component-System pattern
-
maglio
non stable package for 3d maths
-
modinverse
Small library for finding the modular multiplicative inverses
-
aljabar
A super generic, super experimental linear algebra library
-
pendragon
Easy polygon drawing built on top of lyon
-
index_key
lexicographic sort order encoding
-
radian
A normalized angle type
-
c_math
这是一个用于基础数据转换操作的一个包
-
zkp-u256
Performant implementation of 256-bit unsigned integers
-
nummer
minimal ndarray
-
quad_gk
Pure rust numerical integration library based on Gauss Kronrod quadrature rule
-
aws_volume_limit_calculator
copy of https://github.com/awslabs/aws-support-tools/blob/master/EBS/VolumeLimitCalculator/volume_Limit_calculator.sh
-
zkp-primefield
A 251-bit prime field suitable for FFTs
-
matlab-sys
Rust bindings for the Matlab C API
-
hexagon_tiles
that allows working with the hexagon shape and related math
-
deltav_calc
Allows you to generate a graph representing a delta'v map used in the game Kerbal Space Program
-
ak_arith_crate
perform arithmetic operations on i32 data type instance
-
rMaths
Maths library made for Rust developers with ❤
-
revpolnot
Infix to Reverse Polish notation converter lib and executable
-
trianglo
Stupidly Fast And LightWeight Crate To Calculate Square Root & Logarithm
-
quake-inverse-sqrt
Quake Inverse Square root alghorithm
-
nonscalar
Functions and types for operating on nonscalar values like vectors and complex numbers
-
divisor_networks
Discrete Graphs for Indiscrete Researchers - Networks with Grothendieck Topology
-
lie
A numerical library for working with Lie Groups and Algebras
-
fixed-vectors
Lightweight library implementing fixed-length vectors for Rust applications not compiled with the standard library
-
gridsim-ui
Visualizing gridsim grids
-
allan
variance and deviation
-
const-trig
providing const trig functions
-
epsilonz
Functional programming in Rust
-
matchmaker
fairly match students to categories
-
unsigned-f64
A wrapper around f64 that guarantees that the value is always non-negative on the type level
-
irox-stats
Various mathematical and statistics utilities
-
sfink_callgraph_traversal
Experimental callgraph traversal/analysis tool, currently limited to loading an internal format produced by a static analysis
-
rustc_apfloat
Rust port of C++ llvm::APFloat library
-
yz-curvep-exs
examples of curve paramterizations
-
doem-math
Const generic linear algebra math crate for 3D applications, made in conjunction with doem
-
m2csmt
A solver for systems of non-linear (in)equations
-
magnet_rs
User friendly magnetic field calculations in Rust
-
ospf-rust-math
A math utils for ospf-rust
-
gategen
generate Gate circuits
-
safe-modular-arithmetic
modular arithmetic algorithms for all integer types in an overflow-safe and const-compatible manner
-
irox-units
Physical Quantities, Units, & Reference Frames Library
-
gear_combos
Attempts to make getting combinations of things easier with the use of gears and simple numeric states!
-
ucsi
SI-based unit typing system
-
whiteboard
A math library made by someone not qualified to be making math libraries
-
infinity-euler
These are my solutions to Project Euler implemented in Rust
-
bsd4random
4.4BSD random number generator
-
lapack-sys
The package provides bindings to LAPACK (Fortran)
-
gchemol-lattice
Periodic 3D crystal lattice
-
camctrl
Camera control math
-
planar
Strongly typed planar geometry
-
scicrypt-numbertheory
A scicrypt crate implementing number theoretic algorithms such as random (safe) prime generation
-
simple_calculator
First Library
-
nice-numbers
Small library for number sequences
-
doctor-syn
Computer algebra system for Rust expressions
-
yttria-math
A DSP math library tailored for use with the yttria set of libraries
-
asmcahligzamaze
Schizm and amalgamation of adventurer's probability distribution across multiverse 2D maze on a single screen
-
ginger-rs
Parallel Bairstow Root-finding Method in Rust
-
pboddupalli-helloworld
hello world package to understand packages, crates, modules
-
agg
High-quality 2D graphics engine based on Anti-grain Geometry
-
shoelace
formula in your project
-
ecm
Lenstra's Elliptic Curve Factorization Implementation with Big Integers
-
kapacitor-multi-indicator-stream-udf
A multi-indicator stream UDF for Kapacitor
-
adf-bdd-bin
Solver for ADFs grounded, complete, and stable semantics by utilising OBDDs - ordered binary decision diagrams
-
pow_of_2
Integer-like types which can only represent powers of 2
-
math-concept
Common math concepts from Computer Science classes, implemented in Rust
-
molecules
working with molecules and molecular dynamics simulations
-
curso_09_libs
Teste de biblioteca
-
fib-sequence
retrieving fibonacci numbers in base 10
-
mrgraph
High-level Meritrank library
-
logik
Calculator for propositional logic formulas
-
matrix-sdk-base
The base component to build a Matrix client library
-
sleef-trig
Port of a few sleef.org trigonometric functions
-
demo_crate_dia
Calculator
-
CargoLibrary
Cargo by danielshih lab
-
kalk_cli
A calculator that supports user-defined functions, variables and units, and can handle fairly ambiguous syntax
-
lrk
learning rust
-
accelerate-general
A general matrix and vector operations library using Apple's Accelerate framework
-
sofa-sys
Standards of Fundamental Astronomy (SOFA) Rust bindings
-
adroit
AD on first-order SSA functions with arrays and algebraic types
-
math_l
Math Functions for LeetCode
-
unit_system
Automatically derived typed unit systems
-
a_add_b
这是一个两数相加的方法
-
treevolution
A simulation of the evolution of treelike structures in a cellular automata
-
makepad-geometry
Geometry tools
-
dioxus-katex
Render math with KaTeX in Dioxus!
-
nines
9-Slice scaling math
-
delaunay2d
compute Delaunay triangulations and Voronoi diagrams in 2D space
-
dinglebit_combinatorics
A collection of combinatorics utilities
-
calculator_util
that helps you evaluating mathmatical expressions
-
rusty_units
storing units of measurement in Rust
-
unit17
whp-unit17
-
unit18
whp-unit18
-
simple_math
lib to do some mathematical manipulation
-
mathlib
A math library for Rust
-
conum
big numbers, specified by arbitrary digit widths
-
mpmfnum
A numbers library in Rust
-
ultrametric_matrix_tools
Toolbox that provides functions and data structures to generate and handle ultrametric matrices
-
fixed-exp
Exponentiation for fixed-point numbers
-
condest
1-norm and condition number estimator by Higham and Tisseur, 2000
-
suitesparse-src
Builds the SuiteSparse components
-
ema-rs
Exponential Moving Average (EMA) Implementation In Rust
-
clamped
clamping of numbers in Rust
-
options-common
working with financial options
-
aeiou
Algebraic effects
-
quickbrain
neural network library
-
millimeter
Primitive type with millimeter unit attached
-
demo_test_add_2_numbers
Function for adding 2 numbers
-
fuzzy_fraction
Struct for approximated human-readable fraction representation
-
rusoda
Pure rust and just need log dependencies implementation of odepack dlsoda
-
finitely
Arithemtic over finite polynomial rings
-
ggmath_testing
testing tool for custom ggmath scalars
-
operations_parser
A Rust-based parser for basic math operations with function support
-
kalc-kman
Is a calculator for math
-
pga2d
tools for 2 dimensional projective geometric algebra
-
oat_rust
User-friendly tools for applied topology
-
smartcalc-tui
Terminal UI for erhanbaris/smartcalc
-
vec4
-
adder_trial
has a function
-
cassie
limited computer algebra system written for the fun of it
-
real_float
Floating point types that check for correctness and implement total ordering
-
bdrk_geometry
Geometry Helpers
-
rust-kepler-solver
Efficient solvers for the elliptical and hyperbolic Kepler equation
-
thirteensea
Test publish crate
-
irox-fixedmath
Fixed Precision Math Primitives
-
russell_pde
Essential tools to solve partial differential equations; not a full-fledged PDE solver
-
oscirs
Scientific computing environment for Rust
-
mathml-rs
MathML parser written in Rust
-
cell-automata-1d
Look Stephen Wolfram's cellular automata: https://www.wolframscience.com/nks/p170--cellular-automata/
-
oscirs_linalg
GPU accelerated linear algebra crate for scientific computing
-
modcholesky
Modified Cholesky decompositions
-
fibo
Compute the N-th Fibonacci number with arbitrary number precision
-
talna
WIP
-
calcrs
A command-line calculator with everything you need
-
gali
untyped lambda caluculus, with some sugar for convenience
-
rust-latex-doc-minimal-example
Minimal crate example for getting latex in docs
-
mylibrary
my librarry description
-
libnzprimes
Provide and maintain a list of prime numbers from 2 to what you need. Slow algorithm suited for the primes number below 1000000.
-
matext4cgmath
Unofficial third-party cgmath extensions for calculate eigenvalues, operator norms and Iwasawa decomposition
-
pupil
Arithmetic expression evaluator
-
bens_number_theory
A sample Rust project for number theory stuff (I'm using this to learn Rust)
-
awint_ext
Externally allocating
awintfunctionality -
lineas
A mathematical linear algebra library for Rust
-
lamb
Pure untyped lambda calculus in safe Rust
-
rug-gmpmee
Rust FFI bindings for GMPMEE
-
neis_calculator
bytes counter for NEIS
-
rmathlib
Port of R's C Library of Special Functions
-
static_linear_algebra
A static linear algebra library where size compatibility of operations are checked at compile time
-
simpler_vector
a very simple library for 2d/3d vector math
-
approxeq
A trait for approximate equality of types
-
dlint
lint for deno
-
rantlib
Analysis Library for Non-linear Dynamical Systems written in Rust
-
sinorust
hello world!
-
kilac
ARCHIVED PROJECT
-
currencies-core
core types for the currencies crate
-
spv-rs
Math utility for astronomical data
-
inexor-rgf-plugin-arithmetic
Inexor - Reactive Graph Flow - Plugin - Arithmetic
-
rexl_matrix
matrix library for Rust
-
lidrs
reading and representing light intensity distributions via photometric webs
-
dsif
Dead simple integer factorization
-
negie
Generate complex scatter plots of eigenvalues from parametrized bohemian matrices
-
robust-geo
floating-point expansions and geometric tests (https://people.eecs.berkeley.edu/~jrs/papers/robustr.pdf)
-
smartcalc
Text based calculator for peoples
-
polynomial-roots
Find the real roots of huge polynomials in milliseconds
-
double-pendulum
A mathematical model for double pendulums
-
clnooms
Assembly-level implementation of interesting data types
-
chord_name
working with chord names in music theory
-
russell_nonlin
Numerical continuation methods to solve nonlinear systems of equations
-
claire_vector
claire is a rust lib for vector calculus
-
bevy_lunex
Blazingly fast retained UI layout engine for Bevy ECS
-
genpet
Generate petgraph graphs with geng
-
polyscope
Wrapper of polyscope
-
lat
easy matrix manipulation on a component wise level - no linear algebra
-
unit9
whp-unit9
-
del-fem-ls
sparse solver library for research prototyping
-
Circle_Area
circle of area function
-
pulsejet-rs
Rust port of yupferris' audio codec Pulsejet
-
msh_rpn_calc_test_ver
RPN library
-
siege-math
Math library for the Siege Engine
-
ipasir-sys
that contains FFI bindings for IPASIR-compatible SAT solvers
-
raith-common
learning project
-
ux-indicators
Technical Analysis Function Library
-
raekna-compute
allows evaluating expressions into literals
-
fast
High-performance SIMD vectorized algorithms
-
derangement
permutation with no fixed points, a derangement
-
serde-ndim
Serde support for n-dimensional arrays from self-describing formats
-
hwcalc
An arbitrary bit-width calculator
-
math_64
Only the numbers 1, 3, 5, 7 or 9 work. It's very odd.
-
currency_rs_isotoxal
handling currencies uses less lifetimes and more data on heap use currency_rs if you need
-
bsplines
N-dimensional B-spline curves and their derivatives built on top of nalgebra
-
Dzahui
CFD Library for real-time simulation
-
ivory_kinematics
Kinematics library for Project Ivory
-
tropical_algebra
tropical algebra in Rust
-
halfpoint_rs
Half-precision floating-point number
-
cloth_bumpmap
Creates a bump map used in the clothify algorithm in GIMP (GNU Image Manipulation Program)
-
croot
finding real and complex roots
-
complex_algebra
supporting complex number algebra
-
euclidean_algo
euclidean algorithm to find the greatest common divisor
-
mathfacts
A small command-line application to practice math facts
-
projecteuler_rs
Project Euler solutions implemented in Rust
-
satif-kissat
Rust wrapper for the kissat SAT solver
-
rustmex
providing convenient Rust bindings to Matlab MEX API's
-
rbf-interp
Radial Basis Function multidimensional interpolation
-
dfkzr
Dezimalfestkommazahlrechnung - decimal fixed point arithmetic with up to 19 digits
-
frames
Contextual frames made simple
-
rustamath_mnmz
Minimization functions
-
math_thingies
math thingies, traits. For self use
-
qvnt-i
Advanced quantum computation simulator
-
mathjax
interface to MathJax
-
tricolor
Color structs, color formats, and color conversions
-
clac
command-line calculator
-
floorAndCeiling
Tiny crate that contains floor and ceiling functions
-
cartesian_trajectories
create cartesian motion profiles
-
mtl
Matrix template library. Dense2D matrix, SparseMatrix.
-
modtype
Macros that implement modular arithmetic integer types
-
slagalica
An exhaustive program for resolving a problem on Serbian TV
-
topological_peak_detection
A mostly efficient topological algorithm for finding all peaks in a 1-D signal
-
neapolitan
Easily model and solve circuit-like problems
-
unit-root
Unit root tests
-
tactile
representing, manipulating, and drawing isohedral tilings on the plane
-
persentage_calculator
its calculate your persentage by your given input , input1 = marks_obtained and input2 = total_marks
-
reikna
A work in progress math library
-
optim
combinatorial optimization tools
-
ticktick
-
lambert-bate
A fast solver for Lambert's problem
-
kani-verifier
A bit-precise model checker for Rust
-
calculator_function
some description
-
FullMathOP
Full Math OP
-
hask-replace
Rename haskell modules at the speed of Rust
-
routrs_highways_dataset
Highways dataset for routrs, the geograph-based shortest distance calculator for Rust
-
blissb
Post-quantum signature schemes - BLISS-B
-
static-la
A linear algebra library with excellent type safety
-
smtlib-syntax
Types mirroring most of the syntactic elements from the SMT-LIB 2.6 spec. Meant for code generation, not parsing.
-
arrow-arith
Arrow arithmetic kernels
-
nut_sys
Wrapper for Number-Theory-Utils C library
-
pnets_shrunk
A reducer for petri nets
-
delaunay
The representation of delaunay triangulation
-
eccodes-sys
Low-level Rust bindings for latests ecCodes version
-
foocalc
A command line RPN calculator with multiple precision and unit support
-
linalgo
Accessible and performant linear algebra library
-
canrun
A logic programming library inspired by the *Kanren family of language DSLs
-
is_thirteen_rs
package to check if a number is equal to 13
-
i48
working with 48-bit integers
-
fibonacci-like
A small crate to help you interact with second order sequences, such as the Fibonacci sequence, with no_std support
-
qmu
Quigly's Math Utility
-
pop-prob-cli
A population probability calculator
-
frechet
basic autodifferentiation
-
mm_math
Mathematics library
-
ftl-numkernel
designed to provide numerical operations and error handling for both real and complex numbers, also supporting arbitrary precision types
-
sparte
Helpers for scientific calculs
-
vector_operations
A collection of vector operations for Rust
-
differential-geometry
differential-geometric calculations
-
hcode_functions_danielly
Biblioteca de funções da Hcode
-
iseven_api
wrapper for isEven API
-
mrslac
sparse matrix data structures
-
nd_array
linear algebra that tries to have a similar api to numpy
-
ndvec
low-dimensional vectors
-
rapier3d-meshloader
STL file loader for the 3D rapier physics engine
-
astronomical-quantities
Unit-safe computations with astronomical quantities
-
batbox-lapp
Linear algebra (batbox-la) extensions
-
ntt
Fast NTT (number theoretic transform) for polynomial multiplcation for primes, prime power, and certain composite moduli
-
gfxmath-vec4
3D math library
-
poseidon-paramgen
generating Poseidon parameters
-
rawarray
file format for retrievably storing n-dimensional arrays
-
markovian
Simulation of Markov Processes as stochastic processes
-
const_fixedp
A const type for fixed point arithmetic
-
cp_sat
Rust bindings to the Google CP-SAT constraint programming solver
-
suitesparse_graphblas_sys
Rust bindings for SuiteSparse::GraphBLAS
-
log_domain
Logarithmic representation of floats
-
normform
handling normal forms
-
scal
Calculator that can add, sub, mul & div two input num
-
iter-rationals
A fixed size, linear time, no-std iterator over the rational numbers
-
hyperoperation
(sometimes known as Knuth's notation) calculation library for Rust
-
codemonk-primes-cli
A command-line utility for finding prime numbers
-
red_primality
zero-setup primality testing and factoring for all u64
-
scotch
Idiomatic wrapper for Scotch, the graph partitioner, graph clusterer and sparse matrix orderer
-
mematrica
An easy to use library for working with matrices
-
rstm-core
focuses on building concrete implementations for Turing Machines
-
mathpak
Rust Math Routines, a simple to use math focused library written in rust
-
buckingham
Arithmetic with units
-
veccentric
Tiny 2D vector library
-
vecn
A procedural macro that transforms user-defined structs into general vector types
-
scalar
A trait for scalars (integers and floats)
-
dimensions
Struct(s) for handling dimensions
-
float_math
Does math on floating point values
-
zapper
lightning fast templating engine
-
hipparchus-mean
A collection of basic mathematics solver: Lp norm, mean, moving average, sequence
-
add_one_hammahutz
Add one to a random number
-
rust-fixed-point-decimal
Decimal fixed-point arithmetic
-
ctclib-pp
A collection of utilities related to CTC, with the goal of being fast and highly flexible, with perplexity scores for KenLMs models
-
linearkalman
Linear Kalman filtering and smoothing
-
eigenvalues
algorithms to compute eigenvalue/eigenvectors of symmetric matrices
-
vecto
vector2
-
dfp-number-sys
Rust bindings for Intel® Decimal Floating-Point Math Library
-
acm_dependent
Project dependent on the arithmetic_congruence_monoid library for working with arithmetic congruence monoids (ACM)
-
mee6
calculate mee6 leveling data
-
sath
Toy math library
-
caliph
calibrate and convert pH measurements using a two point method
-
halo2-base
Embedded domain specific language (eDSL) for writing circuits with the
halo2API. It simplifies circuit programming to declaring constraints… -
bempp
Boundary element method library
-
metamath-rs
manipulating Metamath databases, including a parallel and incremental verifier for Metamath databases
-
game_logic
simulating turn-based games with customizable game logic and agent behavior
-
laddu-python
Amplitude analysis made short and sweet
-
dynast
Feynman graph topology identification
-
amfnbatch
Amortization Functions (AmFn) Batch Process
-
lamcal-repl
A lambda calculus command line repl
-
butterworth
filters
-
rust-numpy
A row version of a convinient rust-numpy library which target is to dublicate functionality of well known python library 'numpy'
-
exprtk_rs
Rust bindings to the ExprTk C++ library (http://www.partow.net/programming/exprtk)
-
unit4
whp-unit4
-
algebraeon-geometry
Algorithms for working with geometric shapes
-
memu
Implementations of memory units and working with them
-
base95
Textual representation of base 95 fractional numbers with arbitrary precision
-
voroxx
Voro++, a 3D cell-based Voronoi library
-
vtrig
Hidden trigonometry functions with their derivates and integrals
-
matrix-rs
using matrices in rust. Uses const generics to ensure compile-time matrix safety.
-
tinyfield
Small, finite fields
-
fix32
Easy implementation of fixed point numbers in Rust, using i32 as base. Decimal places should be configured at compile time, to be able to optimize the code at max. This is a personal…
-
summed-area
table for fast sums or averages of subsections of a 2d array or an image
-
umath
ffast-math in rust
-
libmath
Mathematical utilities
-
matrix_algebra
supporting matrix algebra
-
multi_dim_point
multi-dimensional point
-
nalgebra-numpy
conversions between nalgebra and numpy
-
miller_rabin
A multi-threaded, arbitrary precision implementation of the Miller-Rabin primality test
-
calculi
used to apply calculus functions on equations in string form
-
scicalc-rs
parsing and doing calculations with measurements, typically used in scientific contexts
-
nikisas
common mathematical functions with focus on speed and simplicity of implementation at the cost of precision, with support for
no_stdenvironments -
mangle-analysis
Mangle, a logic programming language
-
nalgebra-sparse
Sparse matrix computation based on nalgebra
-
gcv_spline
fitting and evaluating GCV splines
-
Math_module
Maths functions
-
gandiva_rust_udf
gandiva rust udfs
-
lisudoku-solver
Solver for sudoku puzzles used by lisudoku
-
max_len_base_10_as_usize
Trait offering constant maximum lengths of primitive integers as usize
-
logsumexp
Numerically stable computation of log-sum-exp using a 1-pass algorithm
-
avatar_graph
Avatar Graphs
-
mathew
Mathematical expression evaluator with context
-
ruut-algebra
An incredibly minimal linear algebra crate meant to be used for ruut-functions
-
cisat
Cognitively-Inspired Simulated Annealing Teams
-
lasy
A small library dedicated to LASER path optimisation
-
rsruckig
Ruckig motion planning library for Rust
-
postfix
expression evaluator
-
c-prime
Convenience wrapper for machine-prime
-
written-numbers
Convert numbers (1337) to words (one thousand three hundred thirty-seven)
-
kahan_pairs
Generate pairs of integers
-
caliphui
calibrate and convert pH measurements using a two point method
-
mc-core
MinecraftRS - Minimal core implementation of Minecraft backend
-
cadical
Rust bindings for the CaDiCaL SAT solver
-
decimal-wad
Math for preserving precision floats up to 18 decimal places
-
fj-kernel
Early-stage, next-generation, code-first CAD application. Because the world needs another CAD program.
-
xer_add_one
Example dependency crate
-
quickmath
A quick command-line math evaluator
-
calcer
nice program to write graphs from programs
-
clipcalc
calculator that reads from the clipboard and writes the result back to the clipboard
-
i_mth
A math library continuously under development made for use in particle and ridgid body dynamics and statics
-
del-msh-nalgebra
mesh utility library for computer graphics research and prototyping
-
superset_map
Map that stores distinct supersets based on the total order defined
-
crlibm
Binding to CRlibm, a correctly rounded math lib
-
data-pipeline
A functional and extensible library for organized lazy processing of data with minimal overhead
-
mapping-suites
A collection of SLAM suites, based on mapping-algorithms
-
st
Fast and simple statistics on the command line
-
dashu
set of big numbers
-
fractran
execute Fractran programs
-
yaccas
Callback-orientated Command line pArSer - nomen est omen
-
astro_nalgebra
astro-float for nalgebra
-
allen_interval_algebra
package for interval algebra for more information see https://en.wikipedia.org/wiki/Allen%27s_interval_algebra
-
pmsim
Porous media simulator
-
fend-core
Arbitrary-precision unit-aware calculator
-
geo-aid-svg
Support for SVG output from Geo-AID
-
eskf
Navigation filter based on an Error State Kalman Filter (ESKF)
-
fenris-geometry
Geometry functionality for fenris
-
rustlinalg
linear algebra crate to support crustacea ML crate
-
f128_internal
Internal bindings to the gcc quadmath library
-
nze_geometry
Some basic 2D geometry types and functions
-
rust-test-crate-multiply
Test rust package
-
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…
-
emath
Minimal 2D math library for GUI work
-
online-statistics
Blazingly fast, generic, and serializable online statistics
-
rust-gmp-kzen
Rust bindings for GMP
-
m_calc
calculate math expressions
-
compensated-summation
Compensated summation algorithms for better precision
-
pgnumeric
Arbitrary precision numeric implementation written in Rust, compatible with PostgreSQL's numeric
-
ferrix
matrix library for Rust
-
multrix
matrix multiplication and manipulation library with multithreading support
-
C4lc
A program to help you access the public functions in this code and to perform mathematical calculations, including addition, subtraction, multiplication and division
-
modulo-n-tools
modulo tools
-
operations_parser_kucherenko
A Rust-based parser for basic math operations with function support
-
meansd-cli
calculate mean and standard deviation (CLI)
-
gaussfilt
Design and apply Gaussian filter for 1D data
-
lapack-src
The package provides a LAPACK source of choice
-
discrete_transforms
Discrete Transforms
-
fftw
safe wrapper of FFTW3
-
fractran_rs
A FRACTRAN interpreter
-
phylodm
Efficient calculation of phylogenetic distance matrices
-
intervals-good
An interval arithmetic library with support for many functions and which tracks when domain errors may occur or are guaranteed to occur
-
ark-poly-commit
constructing polynomial commitment schemes for use in zkSNARKs
-
natural_constants
Pre-defined constants from all disciplines (math, physics, ...)
-
pandas_rs
General Mathematics Library for Rust,Inspired by Python Pandas Library
-
binary-space-partition
Abstract BSP tree
-
del-geo-core
2D/3D geometry utility codes
-
symbolics_calculus
Calculus module for the symbolics computer algebra library
-
opensrdk-symbolic-computation
Standard automatic differential library for OpenSRDK toolchain
-
log2fix
no_std fixed-point base 2, e and 10 logarithm algorithm implementation
-
polyeval
Evaluate polynomials
-
swnb-complex
complex number lib
-
sqrt-rs
Stupidly Fast And LightWeight Crate To Calculate Square/Cubic Root In Different Ways
-
num-derive
Numeric syntax extensions
-
bellande_node_importance
calculating n-dimensional node importance via API or local executable
-
functions_shared
Test deply crates.io
-
ndarray-unit
A package providing a system of units to the ndarray type
-
samplers
Sample from distributions and calculate summary statistics from the command line
-
temp-converter-lib
terminal temperature unit converter between Celsius, Fahrenheit and Kelvin
-
rexl_math
mathematics library for Rust
-
set-partitions
Represent and enumerate set partitions
-
logical_expression_parser
logical expression parser written in Rust using pest library
-
lmaths
A short 2D Maths library
-
simple_calculator_cmd
command line simple calculator and library
-
temex
Regex-like temporal expressions for evaluating systems that change over time
-
arb-sys
Bindings to the Arb library
-
microcheby
Single variable function approximation using Chebyshev polynomials. Embedded friendly and no_std compatible.
-
half
Half-precision floating point f16 and bf16 types for Rust implementing the IEEE 754-2008 standard binary16 and bfloat16 types
-
libmat
tools for linear algebra
-
simple_2d_vector
two-dimensional vectors in Rust
-
symbolic_polynomials
manipulation of polynomials over the integers
-
sparse21
Sparse Matrix Solver
-
qcd-sme
numerical library for the screened massive expansion of QCD
-
klick-domain
Calculate the carbon footprints for wastewater treatment plants
-
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.
-
mfcc
Calculate Mel Frequency Cepstral Coefficients from audio data
-
sized_matrix
Sized matrices using const generics for better type checking and performance
-
ndmath
Traits for doing vector geometry operations using built-in types
-
super_ultra_rpn_calc
RPN(Reverse Polish Notatio) library
-
batbox-range
Helpers for working with ranges
-
xcomplex
A complex number library
-
pire-gemm-c32
high performance cpu kernels
-
implicit3d
3d implicit geometry
-
faer-cholesky
Basic linear algebra routines
-
scirs2-sparse
Sparse matrix module for SciRS2
-
csaps
Cubic spline approximation (smoothing)
-
tri_poly_moment
Calculate moments of random variables. The distributions of the random variables are normal, uniform, and exponential.
-
simple-interpreter
interpreter based on reverse poland notation
-
kolakoski
sequence iterator
-
mady
🌲 ahead-of-time automatic differentiation
-
scirs2-signal
Signal processing module for SciRS2
-
rsmt2
Wrapper for SMT-LIB 2 compliant SMT solvers
-
cavalier_contours_ffi
C foreign function interface for the cavalier_contours crate
-
rational_extensions
Extensions for rational numbers
-
alpha_g_physics
Data analysis library for the ALPHA-g experiment
-
f64ad
Easy to use, efficient, and highly flexible automatic differentiation in Rust
-
rest_tensors
Provide efficient tensor operations for the Rust-based Electronic Structure Tool (REST)
-
hipparchus
<!-- TODO -->
-
numeric
N-dimensional matrix class for Rust
-
tnt
runtime validated proofs in number theory
-
some_math_lib
A basic math library
-
vec3-rs
3D vector math library
-
galois_field_2pm
Galois Field (2^M) arithmetic
-
rulinalg
A linear algebra library
-
calcify
Physics vector library
-
point_process
simulating random point processes
-
ark-ec
elliptic curves and pairings
-
df-maths
maths
-
fast-macro
High-performance SIMD mathematics, optimized GPU computation, and vectorized algorithms
-
arpack-ng-sys
Bindings to arpack-ng
-
mathlab
A Powerful Math Library for Rust
-
bose
mathematical and scientific formulas
-
r2rs-nmath
Statistics programming for Rust based on R's nmath package
-
replicante_logging
Replicante common logging logic
-
const-decimal
Integer-backed decimals with constant precision
-
normal-form
A trait to easily find the canonical/normal form of graph structures
-
cmn
accessing a collection of mathematical and cryptographic constants
-
guff-ida
Information Dispersal Algorithm
-
bignumber
arbitrary-precision decimal and non-decimal arithmetic
-
antic
bindings for the antic C library for algebraic number theory
-
small_matrix
matrix library made in Rust
-
sprs_suitesparse_ldl
sprs bindings to the suitesparse ldl solver
-
arithmetic_parser_smetaniuk
Arithmetic expression calculator parser
-
simplicity
simulation of simplicity (https://arxiv.org/pdf/math/9410209.pdf)
-
andre_wronscki_functions
Andre Wronscki package functions
-
concrete-fftw
Safe wrapper around FFTW
-
upload_to_crate_io
Review Upload
-
rpni
A basic command-line RPN calculator
-
moving-average
moving average library
-
bq
A complete implementation of dual quaternions
-
stat-rs
A statistics library
-
xdbuf
reusable multi-dimensional buffer
-
voronoi
compute Voronoi diagrams, using Fortune's sweepline algorithm
-
gon
Easy polygon drawing built on top of lyon
-
dihedral
(torsion) angle calculations
-
sir_ddft
SIR-DDFT model
-
chopchop
-
commuter
tooling to test diagrams for commutativity, allowing automated tests on algebraic systems
-
walc_model
Interpreter for Walc programming language
-
softfloat-wrapper-riscv
a safe wrapper of Berkeley SoftFloat based on softfloat-sys for RISC-V based on https://github.com/dalance/softfloat-wrapper
-
rufft
A pure rust FFT library !
-
calcium-oxide
Calc-ium Oxide, a simple stack based command line calculator written in rust
-
rect-lib
working with anything vaguely rectangular
-
ajkcalc
scriptable hybrid calculator
-
modular_arithmetic
memory safe modular arithmetic with some number theoretic functions: GCD, Jacobi symbol, even/odd powers
-
bullet
Supersonic Math
-
shape-triangulation
The representation of delaunay triangulation
-
eletric_calc
Calculator for Ohm's law
-
goertzel-nostd
An nostd implementation of Goertzel's Algoritm
-
simple-vectors
dimension generic vector math
-
algebraeon-rings
Algorithms in linear algebra, polynomials, and number theory
-
magnesia
A math library for Rust
-
num_base
manipulating with numbers (integers) in different bases
-
algebraic-gen
Procedural Macro for Geometric Products of Any Dimension
-
biconnected-components
Find biconnected components in a graph
-
nearly_eq
Nearly(Approximately) equal traits and assertion
-
rainbow-shared
Don't depend on this directly - rainbow shared utilities 🌈
-
factorprime
finding whether a number is prime or not and also determine its factors
-
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…
-
arith_traits
Traits unifying types based on various supported arithmetic operations
-
oxlex
lexer/tokenizer used in OxyScript
-
factordb
Rust wrapper for FactorDB API
-
simsimd
Portable mixed-precision BLAS-like vector math library for x86 and ARM
-
linbra
Easily do linear algebra in game development, graphics and other sorts of calculations using vectors and matrices
-
peroxide-num
Numerical traits for Peroxide
-
min_max_traits
Traits for MIN and MAX associated constants
-
koto_geometry
A Koto library with basic geometry types and operations
-
exponential-integral
The exponential integral function, a.k.a. Ei.
-
cereal_lib
Does the cereal box problem in either single or multi-threaded mode
-
num-ord
Numerically ordered wrapper type for cross-type comparisons
-
malltec_libs
Projeto de estudo
-
ferrous-simple-calc
Example crate: simple calculator
-
factorial-mod
Fast mod for $n! % p
-
spice-sys
Thin wrapper for the C language implementation spice toolkit from NAIF
-
modmath
Modular math implemented with traits
-
beetle-calculator
A terminal calculator for parsing simple maths expressions
-
kahuna
A basic implementation of wave-function collapse for procedural generation
-
ospf-rust-base
Base definition for ospf-rust
-
routrs_railways_dataset
Railways dataset for routrs, the geograph-based shortest distance calculator for Rust
-
math-symbols
Symbols for computer algebra
-
geom
2D geometry library
-
fenris-paradis
Parallel processing of disjoint indices for the fenris library
-
quick_maths
low-dimensional linear algebra structures
-
libr
types and bingings to native C functions in libR, providing most of embedded-R and R math functions
-
dexterior-core
Core crate of dexterior, a Discrete Exterior Calculus toolkit
-
ajtai
A no-std implementation of the Ajtai commitment scheme
-
lineq
Linear algebra library
-
sparkl2d-kernels
3-dimensional physics engine in Rust
-
basiclu
Rust wrapper for BasicLU
-
jpl-sys
Project Pluto JPL Ephemeris Rust bindings
-
makima_spline
modified akima spline interpolation
-
alphabet
working with alphabets
-
hilbert_curve
Hilbert curve mapping algorithms in Rust
-
mpt_lib
a function libaray for modern portfolio theroy
-
libreda-logic
Logic library for LibrEDA
-
expm
matrix exponential function by Higham and Al-Mohy, 2009
-
dicoco_safe_math
simplified safe math operations
-
matlabblas-src
Provide a source for MATLAB's BLAS library for use with the BLAS crates
-
precise-calc
A high precision calculator library and command line tool
-
rusty-compression
Low rank compression algorithms in Rust
-
yttria
that re-exports the other yttria sub-libraries for radio application development
-
sm_dev
Math operations with safety checks that throw on error
-
numerical-linear-algebra
linear algebra implemented using numerical methods
-
hcode_functions2
Biblioteca de funções da HCode
-
bvrs
A lightweight rust library for BitVector Rank&Select operations, coupled with a generic Sparse Array implementation
-
coin_cbc_sys
Rust bindings to the CoinOR CBC MILP Solveur using the C API
-
arithmetic_parser_kma
Arithmetic expression calculator parser
-
nd_interpolate
1-10 dimensional linear and cubic spline interpolation implemented in Rust
-
moo-math
math interpreter
-
gateutil
basic utilities for GateSim
-
colamd
Column approximate minimum degree ordering algorithm
-
qoqo_calculator_pyo3
Python interface to qoqo calculator, the calculator backend of the qoqo quantum computing toolkit by HQS Quantum Simulations
-
sparse-interp
Basic univariate polynomial arithmetic and sparse polynomial interpolation
-
kukan
powerful tool for mathematical interval
-
goldilocks-ntt
fast NTTs over the Goldilocks prime field
-
ruint-macro
The
uint!macro forUintandBitsliterals -
acme-tensor
A comprehensive tensor library for Rust with support for automatic-differentiation
-
linalg-rs
Linear algebra in Rust!
-
lsode
Solve systems of differntial equations using LSODE subroutine from ODEPACK written in Fortran
-
argmin-math
argmin math abstractions
-
flexint
Big integer types, optimized for small values
-
rust_combinatorics
Combinatoric utilities and functions for rust
-
rpn_calc_perl
RPN library for Perl
-
bitslice
transpose bits into and out of bitslice format, and perform various operations on bitsliced data
-
machine-factor
constant factorisation for machine-size integers
-
alpha-counter-cli
Alphabetic counter
-
lufact
Sparse LU factorization with partial pivoting
-
macromath
Macros for convenient maths with checked, wrapping or saturating semantics
-
smt-lang
Sat Modulo Theory Language
-
convg
convert directed and undirected graphs from NAUTY and Traces into adjacency, dot, and net files
-
hc
Handy calculator for haxor calculations
-
ipasir
Bindings for the IPASIR API to communicate with incremental SAT solvers
-
qalqulator
A calculator that uses (and outputs) rational numbers wherever possible
-
netlib-src
The package provides a source of BLAS and LAPACK via Netlib
-
bigbit
Implements the BigBit format, allowing for compact storage of arbitrarily large numbers
-
brain-assistant
Mathematics tool and encyclopedia for the terminal
-
statrs-fork
Statistical computing library for Rust
-
splinosaurus
flexible spline and surface library
-
tribool
Three-valued logic
-
refined-float
Refined float with a subset of functions of std float
-
cargo_calc
calculation lib
-
rsm-lib
A mathematics library for Rust, providing support for vector, matrix, and scalar operations
-
hilbert16
Hilbert transforms between 1D and 2D space, optimized for u16 coordinates
-
primerug
A prime k-tuple finder based on the rug crate
-
ndarray-odeint
solve ODE using rust-ndarray
-
math_quix
math quiz cli to practice basic arithmetic
-
sparkl3d-kernels
3-dimensional physics engine in Rust
-
afarray
Convenience methods for working with ArrayFire arrays in Rust
-
math-calc-cli
command-line utility for calculation
-
orfeo_rpn_calc
RPN(Reverse Polish Notation) library
-
ipopt-ad
Blackbox NLP solver using IPOPT and automatic differentiation
-
ludomath
A math library for 2D games and graphics
-
safe_decimal
that solves the recurring decimal problem with fractions
-
tiago_functions
Algumas funções para uso externo
-
core-math
API for CORE-MATH
-
primeval
A monstrosity of a prime number generator
-
bool-logic
manipulating and evaluating boolean expressions
-
symbolic_math
performing symbolic mathematics. Supports basic arithmetic operations, expression simplification, and expansion, and evaluation.
-
rcomplex
class for manipulating complex numbers. This project is mainly for educational purposes, and I reccomend using other more complete packages for complex math.
-
flint-sys
Bindings to the FLINT C library
-
shigens
A math library for calculate quaternion
-
rml
A machine learning library in Rust
-
rust-test-crate-add
Test rust package
-
envisim_utils
methods for design-based sampling methods and estimation
-
mixed-num
A trait for generic implementations of numerical methods
-
rusty-cffi
Tools for interfacing with other languages via CFFI
-
fftw-src
Source of FFTW
-
redc
Unsigned integer types which are constrained within a modular field using montgomery multiplication, never overflowing or exceeding the modulo
-
siffra
parse and evaluate human-friendly mathematical and natural language expressions
-
terrain-graph
Graph Library for Rust
-
spawn-stochastic
simulating multiple stochastic processes including ABM, GBM, Ornstein-Uhlenbeck, Feller Square Root, and Brownian Bridge
-
hexga_number
Provide basic trait and constant for number, and the macro map_on!
-
jubjub-schnorr
A pure-Rust implementation of Schnorr signatures with a PLONK circuit module additionally
-
sna
Serial Number Arithmetic (RFC 1982) for Rust
-
hcode_rust
Biblioteca de funções
-
matrix_operations
perform matrix operations
-
rubiks-moves
focusing on processing moves for 3x3 Rubiks cube
-
linfa-clustering
A collection of clustering algorithms
-
scalar-field
Traits and structs which define arithmetic operators on scalar fields
-
stroemung
A Computational Fluid Dynamics (CFD) simulator in Rust
-
const-linear
linear algebra library based on const generics
-
overflower_support
A bunch of specialized traits + impls to allow automated overflow handling without type inference. Nightly only
-
mpir
partial Rust porting of mpir multiple precision library based on gmp mpfr
-
logic-circus
Open source logic circuit simualtor written in Rust
-
trussx
designing and analyzing truss structures
-
gap_solver
A solver for the generalized assignment problem
-
cuba
wrapper for the C Cuba integration library
-
fdecimal
Arbitrary precision fast decimal numbers
-
perfect-decimal
Limited range decimals which serialize as IEE754 floats with no loss of precision
-
avlsort
AVL tree holding the rank and the number of duplicates of elements
-
rsmaxsat
that provides bindings for the MaxSAT solver
-
logic-rs
representing logical formulas with support for temporal robustness semantics
-
spsolve
Solve sparse systems of linear equations
-
ukanren
µKanren, a featherweight relational programming language
-
ralgeb
This package has some mathematical tools to allow user perform operations on Point, Line, Circle, Matrix
-
primefactor
finding whether a number is prime or not and also determine its factors
-
unitdc
A dc-like arbitrary precision quantity calculator
-
finitefields
Perform algebraic operations between integers over a finite field
-
complex-stuff
working with complex numbers in rust
-
numlib
numerical library implementing common numberical algorithms in rust
-
wicker
Weighted probability picker for Rust
-
pnets_tina
A parser for tina Petri net
-
pesto_cli
hello there
-
dmntk-feel
DMNTK | FEEL definitions
-
astro-float-num
Multiple precision floating point numbers implemented purely in Rust
-
gramit
32-bit floating-point graphics math
-
optlib
The optimization algorithms realized in Rust. In given time realized genetic and particle swarm algorithms.
-
polynomials
Tools to perform polynomial arithmetic and evaluation
-
slvs
Rust wrapper for the SolveSpace constraint solver library
-
npy-writer
Export numpy arrays in the npy or npz format
-
pop-prob
A population probability calculator
-
whittaker_smoother
The perfect smoother: A discrete-time version of spline smoothing for equally spaced data
-
ngau
Non-Generic Angle Units
-
is_even_odd
categorizing and operating on integers
-
primal-sieve
A high performance prime sieve
-
ezcgmath
Easy linear algebra Math library for use with computer graphics
-
facto
Integer factorization and prime certification
-
math_test
Generates math questions for elementary school kids
-
igsolve
The program for solving impartial games
-
openweather-async
An async library for use with the openweathermap.org API
-
jnk
Jenna's Number Kruncher: a library for parsing math expressions
-
points_between
API to list the evenly-spaced discrete points between two N-dimensional points
-
decorum
Total ordering, equivalence, hashing, and constraints for floating-point types
-
mazer-data-structures
A minimal, simple math markup language that compiles to HTML, written in Rust
-
rgaussian16
Interface for the Gaussian16 quantum chemical package. This structure provides functions for auto generating input, and running the external program g16.
-
nums
Number theoretic functions, such as primality testing and factorization, for BigUints
-
twoword
Construct bigger uints by combining two smaller ones into a two-word uint
-
approximately
compare two any values
-
inexor-rgf-model-arithmetic
Inexor - Reactive Graph Flow - Model - Arithmetic
-
perplex_num
Perplex (hyperbolic or split-complex) numbers based on num-traits
-
plotters-fullerene
plotters fullerene and polyhedron for Rust
-
fj-export
Early-stage b-rep CAD kernel
-
faer-qr
Basic linear algebra routines
-
field-matrix-utils
working with matrices over finite fields
-
ju-rust-23-10
Head & Tails
-
geo-aid-geogebra
Support for Geogebra (*.ggb) output from Geo-AID
-
laddu-core
Core of the laddu library
-
safeeft
Safe and branchless error-free transformation algorithms for floating point numbers
-
r_mathlib
A port of R’s
nmathstats module to Rust -
nova-math
Vector and matrix math utilities for nova-engine
-
pakr-iec
Functions to format numbers as decimal (1000 is 1.0k) and IEC (1024 is 1.0ki) up to YOTTA suffix
-
avery
A scattering event format for converting between other formats
-
ark-bls12-381
The BLS12-381 pairing-friendly elliptic curve
-
advanedresearch-trinoise
A mathematical noise pattern of 3 values based on Number Theory and Set Theory
-
hipparchus-az
angle representation, conversion and calculations
-
ruststft
computes the short-time fourier transform on streaming data
-
infallible_tobigint
Infallible ToBigInt/ToBigUint conversion traits for num-bigint
-
adv_linalg_lib
Core library for Adv_LinAlg procedral macros
-
geologic
Mathematical and geometrical abstractions with a focus on ergonomics
-
dices
calculate discrete probability distributions and statistics for combinations of dices
-
metis-sys
Raw FFI to METIS, the serial graph partitioner and fill-reducing matrix orderer
-
iomath
fast math rust-library
-
com-croftsoft-core
A core library of highly reusable code
-
wmathrs
mathematical crate
-
seximal
(base6) equivalent of Rust's type system
-
Gen_Prime
A way to transform a hash to a prime number
-
floatd
just num_traits::Float + Debug + Display
-
sphrs
Spherical harmonics and solid harmonics
-
ls_solver
linear system solution
-
simple_3d_vector
three-dimensional vectors in Rust
-
markovgen
building markov chain graphs from text datasets and performantly generating text sequences by traversing them, includes an accompanying CLI application
-
ramp-primes
Generating Large Prime and Composite Numbers using ramp with a simplistic interface
-
erosion
plot fourier curves and functions
-
math_traits
traits to simplify vectorized mathematics
-
geo-aid-plaintext
Support for plaintext output from Geo-AID
-
glar-gemm-f16
high performance cpu kernels
-
viewp
A program is get any argument, that generates prime. it argument be number. This Program is Test Stage.
-
bevy_hexasphere
A trimmed down and generic version of Hexasphere for bevy
-
upcast-arithmetic
Arithmetic that is upcasted on overflow
-
modutil
Provide the methods supports modular arithmetic
-
rust-expression
Calculator and solver for linear equations
-
tcs-dhbw
Modules for a model traffic control system project at DHBW Stuttgart
-
quantum2
Advanced Rust quantum computer simulator, forked from "quantum"
-
icub3d_combinatorics
A collection of combinatorics utilities
-
nicolas
Computational Algebra Library
-
fibnacci
fast high precision fibonacci calculator using rayon and gmp
-
last_order_logic
An experimental logical language
-
btor2rs
Safe-Rust Btor2 parser
-
pblib-rs
Rust safe bindings for pblib
-
cyclic
complete, and dependency-free modular arithmetic
-
ihateintegrals
A computer algebra library for solving integrals
-
analit
Add another dimension to your Rust project with analog geometric literals
-
ripin
that handle Reverse Polish notated expressions, compiles, and evaluate them
-
random-distributions-cli
generate samples from various random distributions, as a text lines or a binary stream. Includes a general form of Stable distribution.
-
math_lib_test
test Library for rust
-
ComplexNumbers
performing operations on complex numbers in which the magnitude of the real and imaginary parts are provided in f64 datatype
-
matio-rs-sys
Rust binder to MATLAB MAT file I/O library
-
rustypi
estimating π using Monte Carlo simulations
-
main_test_123
Online store library
-
algebrust
basic linear algebra operations
-
predicatechecker
Check that a predicate is true if another is
-
malachite-float
The arbitrary-precision floating-point type Float, with efficient algorithms partially derived from MPFR
-
fenris-optimize
Optimization functionality used by fenris
-
matriz
Zero allocation Rust linear algebra library
-
zernike
Routines to compute the Zernike polynomials
-
solver
Solve optimization problems
-
exmex
fast, simple, and extendable mathematical expression evaluator able to compute partial derivatives
-
gpurs
GPU acceleration/linear algebra crate for scientific computing
-
rust_ev_verifier_application_lib
common elements to implement an application using the crate
rust_ev_verifier_lib -
batbox-num
num traits
-
chemrust-nasl
New Adsorption Site Locator (NASL) for catalyst materials. Written in rust. Part of the
chemrusttoolchain. -
spaceform
A cross-platform SIMD-accelerated maths library for 3D graphics
-
polygonical
2d polygon geometry and operations
-
dashu-ratio
A big rational library with good performance
-
awint_dag
DAG
awintfunctionality -
gatenative
execute natively Gate circuits
-
pire-gemm-c64
high performance cpu kernels
-
bicubic
A base for bicubic interpolation
-
smtlib-build-util
The build utils for building the smtlib family of crates
-
irox-unsafe
irox (unsafe) Rust Tools & Libraries
-
kidy
kinematics and dynamics of multi-body
-
fixed
Fixed-point numbers
-
dd_maths_traits
Strongly recommended to avoid using while in development. No semver guarantees.
-
fishers_exact
Fisher's exact statistical test
-
exec-sat
Executes SAT solver and parses SAT solver output
-
cruncher
jit-compiled mathematical expression calculator
-
ducc0
Wrapping ducc, the Distinctly Useful Code Collection
-
float_approx_math
A math library for compile-time floating-point approximations (sqrt, sin, cos, etc...)
-
haversine-redux
Haversine formular library to determine the distances between two coordinates on the earth
-
inertia
Inertia
-
xicor
Sourav Chatterjee's xi-correlation coefficient
-
earcut
port of the Earcut polygon triangulation library
-
routrs_maritime_dataset
Maritime dataset for routrs, the geograph-based shortest distance calculator for Rust
-
lagrange-interpolation
Lagrange's Interpolation Formula
-
ndspec
A package for ocean waves and energy spectra
-
del-fem
finite element method (FEM) utility codes
-
time_series_utils
handling time series data
-
hugefloat
Extremely large, limited-precision floats for use in incremental games
-
polynomial_ops
Multivariable polynomial operations on arrays and vectors
-
nutils-poly
Low-level functions for evaluating and manipulating polynomials
-
caso
Category Theory Solver for Commutative Diagrams
-
dmntk-examples
DMNTK | Examples
-
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
-
hypergraph
data structure library to create a directed hypergraph in which an hyperedge can join any number of vertices
-
libnum
Functions for efficient development in Math and Crypto
-
logic_gate
Logic Gates
-
rust-polynomial
A lib to operate polynomials
-
yttria-coding
A mathematical coding library tailored for use with the yttria set of libraries
-
math_vector
3D vector class
-
tc-tensor
TinyChain's Tensor collection type
-
onlinecode
"Online Codes", a type of Fountain Code
-
soy
Interpolation library
-
bempp-quadrature
Simplex quadrature rules and boundary element singular quadrature
-
ipasir-loading
Load shared libraries of IPASIR compatible SAT solvers
-
hypersphere
4D primitives for rotation and projection
-
in_range
Returns true if a number is in range
-
polenta
A toy language about polynomials over finite-fields
-
powers
Power flow simulation and optimization
-
find-real-roots-of-polynomial
find all real roots of a polynomial
-
oeis-utils
Parse OEIS database archives
-
rapier3d-lijay
3-dimensional physics engine in Rust
-
polyglot_interpreter
A cross-platform, cross-language interpreter of simple logical expressions
-
scirs2-cluster
Clustering algorithms module for SciRS2
-
usagi
Common algorithms and utilities library for Rust
-
mish
A proof of concept Rust libm like implementation with almost full coverage of libm
-
faer-lu
Basic linear algebra routines
-
numerous
A set of tools to finding and classifying special numbers
-
hellocalc
test
-
razor-chase
implements a variation of The Chase algorithm to find models for theories in geometric form
-
rpn_calc_JM
RPN(Reverse Polish Notatio) library
-
aether_primitives
Helpers for common SDR and signal generation operations
-
dec
A decimal arithmetic library providing high-level, safe bindings to libdecnumber
-
irox-dot
DOT Graph Description Language writer, compatible with GraphViz
-
slicemath
element-wise operations on arrays of numeric values
-
didp-yaml
YAML interface for Dynamic Programming Description Language (DyPDL) and DyPDL solvers
-
acme-graphs
Computational graphs for Rust
-
scirust
A scientific computing library
-
bacon-sci-1
Scientific computing in Rust
-
mermaid
Experimental Linear Algebra
-
spokes
A network and network flow library
-
dashu-base
Common trait definitions and tools for the
dashulibraries -
fts_units
that enables compile-time type-safe mathematical operations using units of measurement
-
calculatex
A pretty printing calculator with support for units
-
finitediff
Finite/numerical differentiation
-
basic_math_problem_generator
CLI math test with varying difficulty. Geared towards small children for practicing.
-
hpnc
Binary wrapping the hpn RPN calculator library
-
prime-data
Prime Number Data Library
-
ida
A pure Rust port of the Implicit Differential-Algebraic solver from the Sundials suite
-
schroidnger_equation
intuitive way to simulate the evolution of a quantum wave function as described by the Schrödinger equation
-
acgmath
A linear algebra and mathematics library for computer graphics. A fork of
cgmath. -
miura
Math library written for learning Rust
-
is-odd
Returns true if the given number is odd
-
nnls
Non-Negative Least Squares (nnls)
-
hampel
Sequential outlier detection and removal using Hampel identifiers
-
inertia-algebra
Abstract algebra for Rust
-
mathematics_table
that will generate a math table of an integer given by the user
-
standard_deviation
used to get the standard deviation from the cli
-
num-consts
General-purpose mathematical constants
-
faer-ext
faer-rs API for interoperability with external libraries
-
truncnorm
Normal and Truncated Normal distributions
-
shoemate-test
A test package. Currently tests that katex renders properly on docs.rs.
-
scirs2
port of SciPy with AI/ML extensions - Scientific Computing and AI Library
-
mini-kanren
miniKANREN in Rust
-
geometric
A very simple vector and matrix library built on the vecmath crate
-
rpn_calc_taro_kobayashi
RPN(Reverse Polish Notation) library
-
alga
Abstract algebra for Rust
-
microtensor
Automatic differentiation for tensor operations
-
hkkim_lib_wikibooks_rpn_test
RPN(Reverse Polish Notatio) library
-
libprimesieve
Access to the C function primesieve_generate_primes
-
lukkid
Arithmetic Sequences
-
gmpmee-sys
Rust FFI bindings for GMPMEE
-
snark-tool
contains structures and algorithm for (mainly) cubic graph analysis
-
bigint-benchmark
Benchmarks for big integer implementations
-
ffts
Rust binding for ffts (The Fastest Fourier Transform in the South)
-
feos-core
Core traits and functionalities for the
feosproject -
mersenne-prime-number-miller-rabin
This package provides function to generate Mersenne number and test primality with Miller-Rabin Algorithme
-
hstats
Online histogram statistics calculations
-
ldl
LDL factorisation for quasi-definite linear systems
-
datamars
rewrite of https://www.gnu.org/software/datamash/
-
fftconvolve
The fast fourier transform convolution and correlation algorithm for Rust
-
matrix-simp
A linear algebra package (WIP)
-
propositional
Logic
-
piston3d-construct
higher order functional programming with homotopy maps to construct 3D geometry
-
antic-sys
Bindings to the Antic library
-
geo-aid-figure
Definitions for Geo-AID's JSON export format
-
expy
Embeddable & extensible expression evaluator
-
fj-math
Early-stage b-rep CAD kernel
-
r2rs-stats
Statistics programming for Rust based on R's stats package
-
xiaotian_s_minigrep
just a test
-
numerilib
Mathematics Library
-
osqp-rust-sys
c2rust(osqp-sys)
-
polynomint
A no-dependency library for working with integer polynomials
-
sat_toasty_helper
more-easily writing SAT constraints
-
melius-vectors
2-4 dimensional vectors that can be easily created and manipulated
-
q1tsim-logic-gates
extension crate to q1tsim implementing the AND, OR and XOR logic cates in a quantum comupting - friendly (i.e. reversible) way.
-
my-little-eval
A little library for evaluating mathematical expressions
-
numrs
A numerical computations library for Rust
-
rustnomial
working with polynomials
-
pretty-print-nalgebra
a small macro-only crate providing ability to pretty-print a 2D nalgebra array
-
nnf
Negation Normal Form manipulation library
-
glar-gemm-f32
high performance cpu kernels
-
blas-sys
The package provides bindings to BLAS (Fortran)
-
efloat
Error-bounded Floating Point
-
complexible
A minimal and user-friendly Rust library complex-number operations, bringing the joy of complex mathematics to Rustaceans everywhere!
-
polynomials_pro
pro-level polynomials
-
cas-rs
A CalcScript executor and REPL
-
croot-gui
graphing complex roots and numbers
-
envisim_estimate
Design-based estimation and variance estimation
-
turing-machine-rs
Open library for implementation Turing Machines
-
closure_calculus
Closure Calculus
-
graph_gen
Generate pseudo-random graphs based on the Erdos-Renyi G(n,p) model
-
circuit_sat_check
generate circuit checking to CNF formula
-
m61-modulus
Functions for performing arithmetic modulo the 61st Mersenne number. Aimed at testing bignum implementations.
-
optrs
Forcefield molecule optimization
-
lodestone_core
User friendly magnetic field calculations in Rust
-
play-rsa
RSA cryptography in Rust for pedagogical use
-
const_num_bigint
const bigint
-
container-broadcast
analog of Julia's broadcast interface
-
avatar_hypergraph_rewriting
Hypergraph rewriting system with avatars for symbolic distinction
-
stochastic-abm
simulating various stochastic processes, including Arithmetic Brownian Motion and more
-
num_vector
Enabling basic vector arithmetic operations
-
slender-math
Lightweight math library for game development
-
is_signed_trait
Trait for IS_SIGNED associated constant
-
logistics
Engineering Client
-
directx_math
translation of DirectXMath, a SIMD linear algebra library for use in games and graphics apps
-
mat-rs
no_std implementation of mathematical matrix types
-
ext-ops
General purpose arithmetic operator traits which are missing from the standard library
-
saleae
interacting with saleae devices
-
funki_lang
A customisable embeddable functional langauge
-
bootstrap-ht
Bootstrap Hypothesis Testing
-
plummerprimes
Builds, Runs, and reports benchmarks from https://github.com/PlummersSoftwareLLC/Primes
-
lrs
resolving (conjunctive) normal-form logical clauses
-
guff-sharefiles
Package IDA-encoded data in a portable file format
-
qty-macros
Macros supporting the implementation of quantities
-
klownie_matrice
My personnel project on matrices
-
cw-bigint
Big integer implementation for Rust
-
math-fun
A package providing mathematical functions commonly used in science and engineering
-
zkp-elliptic-curve
A crypto-grade elliptic curve over
primefield -
sparkl3d
3-dimensional physics engine in Rust
-
vmd-rs
Variational Mode Decomoposition in Rust
-
concrete-fftw-sys
Sources of FFTW and unsafe binding
-
fuzzylogic
operations for fuzzy set theory
-
simulated_annealing
An interface for global function optimization using simulated annealing
-
vec3D
A minimal 3D Vector library in Rust
-
softfp
Software floating point operation library
-
quad
Quadrature integration
-
polynomial_tools
that contains some utilities for operations on polynomials
-
crabsformer
fundamental library for scientific computing with Rust, highly inspired by NumPy
-
polynom
handling polynomials
-
dimensional
Functions, structs, and reference data for working with dimensional values, such as '1 second' and '3 miles per hour'
-
sph2mm
Add an AMR background to an existing SPH initial conditions file
-
kalk
A math evaluator library that supports user-defined functions, variables and units, and can handle fairly ambiguous syntax
-
corries
Library/framework for 1D-hydrodynamics simulations using Riemann solvers
-
elr_primes
prime number iterator and methods for basic calculations with prime numbers
-
alpha_stable
Sample and generate probability distribution functions of Alpha-Stable distributions in Rust
-
horner-eval
A macro for evaluating polynomials via Horner's rule
-
glar-gemm-c32
high performance cpu kernels
-
logic-long
Supercell's Logic Long implemented in Rust
-
prime_gen
Generate prime numbers
-
path_semantics_std
type checked implementation of the standard dictionary of path semantics using constrained functions
-
ark-bls12-377
The BLS12-377 pairing-friendly elliptic curve
-
slice2d
Ergonomic array slice for 2d array manipulation
-
cudd
Cudd Rust library
-
rust-gmp
Rust bindings for GMP
-
objforces
Allows to calculate mouvement of objects based on forces on a 3D axis
-
c-api-tools
Tools for the creation of C API bindings
-
superlu-sys
The package provides bindings to SuperLU
-
big_num
A big number implement in rust
-
rug-polynomial
Polynomial arithmetic, built on Rug & FLINT
-
vec-utilities
A collection of methods that make working with Vecs of floats easier
-
gaussiant
Gaussian integers
-
mop-common
Common definitions for MOP crates
-
accelerate-src
The package provides a source of BLAS and LAPACK via the Accelerate framework
-
yttria-modulation
A communications library tailored for use with the yttria set of libraries
-
relation
based on the mathematical concept of financial relations
-
exact-conv
Exact conversions between integer and floating point types
-
logic_trioxide
Logic Gate simulating Library
-
val_unc
A package for handling quantities with uncertainties
-
efficient_pca
Principal component computation using SVD and covariance matrix trick
-
mvmm_hydro
A moving mesh hydrodynamics (CFD) solver prioritizing flexibility over raw performance
-
primter
Prime number iterator based on sieve of Eratosthenes
-
quickfib
A no_std compatible Fibonacci calculation algorithm implemented in Rust
-
primality
Check if a number is prime
-
junglefowl
Brutally murdering Rust's type system one proof at a time
-
si_units
handling arithmetic with SI units
-
psina
Blazzzzingly fast graphql schema generator from prisma file
-
bigfactorial
Precalculated compile-time factorial macro for numbers upto 99
-
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
-
cronbach_alpha_lib
get cronbach alpha value to check your reliable question
-
matrix-math
Mathematical matrices
-
poly_log
working with polynomials
-
vecfx
Extra batteries for a vec of floats
-
big-num-manager
Rust big num manager
-
glucose
multipurpose math and physics crate for my projects
-
shanksbot-rs
ShanksBot shown by Matt Parker in https://www.youtube.com/watch?v=DmfxIhmGPP4
-
fj-window
Early-stage b-rep CAD kernel
-
polynominal-interpolation
interpolating a function using polynomial
-
scirs2-spatial
Spatial algorithms module for SciRS2
-
statistical-tests-rs
Statistical Tests for Rust
-
horner
Evaluate polynomials using Horner's method
-
simplex
A Linear Programming solver
-
num-rug-adapter
An adapter to use num crate where rug is needed
-
dual_quaternion
A type-agnostic dual-quaternion math library
-
statc
essentially a TI-84 extended, geared towards statistical calculations and making data easily readable and obtainable
-
numbrs
A flexible numerical computing package
-
prime-rs
Command line utilities for finding prime numbers
-
unit-interval
Types for working with and constraining values to the unit interval
-
super-prime
Find the super prime number
-
free-algebra
Types for constructing free algebras over sets
-
ode_integrate
Collection of numerical ODE Solvers written in generics and thus applicable in many scenarios
-
algebraeon-macros
Macros for Algebraeon
-
typed_floats_macros
only used to generate the
typed_floatscrate -
factor-rs
A command-line program for listing the prime factors of a number or fraction
-
z3tracer
Parser for Z3 tracing logs
-
matrix_mul_test
testing blas as a feature
-
geo-aid-math
The mathematics engine for Geo-AID
-
fixed-polynomial
Polynomial arithmetic functions with compile-time degree checks
-
cblas-sys
The package provides bindings to CBLAS (C)
-
aspic
An ASPIC+ argumentation system and reasoning engine
-
librustosa
Calculate Mel Frequency Cepstral Coefficients from audio data
-
poly
Generic dense polynomials
-
argmin-observer-slog
slog logging observer for argmin
-
mtrx
type-safe matrix operations using const generics
-
bigint-base10
Experimental API for dealing with big integers in base-ten
-
traitgraph-tsplib-io
Functions to read and write graphs in TSPLIB format
-
trinary
Rust types for trinary logic
-
blasoxide
BLAS implementation in rust
-
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
-
sort_rust
sort for Rust
-
libbytestat
Randomness analyzer
-
faer-sparse
Basic linear algebra routines
-
parry2d
2 dimensional collision detection library in Rust
-
cryptix-field
group, ring and field arithmetics based on cryptix-bigint
-
information
theory functions to use with ndarray
-
glar-base
high performance cpu kernels
-
depends_core
Ergonomic, performant, incremental computation between arbitrary types
-
ark-bn254
The BN254 pairing-friendly elliptic curve
-
sciport-rs
Rust port of scipy
-
matrix-basic
very basic matrix operations
-
lodestone_python
User friendly magnetic field calculations in Rust
-
fuzzy-expert
A fuzzy logic library with support for mamdani fuzzy inference
-
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)…
-
fenris-sparse
Sparse matrix functionality for fenris
-
num-irrational
num-irrationalis based onnumand extends it with support for several kinds of irrational numbers -
wilson
Calculate Wilson confidence interval for binomial distribution using the formula from Wikipedia
-
keccak_prime
The hashing algorithm that keeps your blockchain green
-
random-partition
Generate approximately uniformly distributed random integer partitions
-
cufft_rust
A safe cuFFT wrapper
-
lagrangian_interpolation
An algorithm to interpolate between points with polynomials
-
get_len_base_10_as_usize
Traits for getting length base 10 as usize, both at run and compile time