-
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
-
num-traits
Numeric traits for generic mathematics
-
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…
-
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-bigint-dig
Big integer implementation for Rust
-
parry3d
3 dimensional collision detection library in Rust
-
fend
Arbitrary-precision unit-aware calculator
-
peroxide
Rust comprehensive scientific computation library contains linear algebra, numerical analysis, statistics and machine learning tools with farmiliar syntax
-
num-complex
Complex numbers implementation for Rust
-
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
-
typed_floats
Types for handling floats with type checking at compile time
-
lin_alg
Vector, matrix, and quaternion operations for general purposes
-
hexx
Hexagonal utilities
-
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
-
yume-pdq
hand-vectorized implementation of the Facebook PDQ Perceptual Hash estimation algorithm that prioritizes low latency, high throughput with statistically low upper-bound false negative rate…
-
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
-
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
-
cronus_cli
The CLI for cronus
-
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…
-
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
-
decaf377
A prime-order group designed for use in SNARKs over BLS12-377
-
rsparse
solving sparse linear systems using direct methods
-
geonum
geometric number library supporting unlimited dimensions with O(1) complexity
-
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.
-
honeycomb-core
Core structure implementation for combinatorial maps
-
erydanos
Optimized routines for ARM NEON and SSE
-
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
-
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
-
const-primes
Work with prime numbers in const contexts. Prime generation, primality testing, prime counting, and more.
-
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
-
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
-
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
-
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
-
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
-
d3_geo_voronoi_rs
A port into rustlang of the javascript library d3-geo-voronoi
-
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
-
zen-engine
Business rules engine
-
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
-
honeycomb-kernels
Meshing kernel implementations using combinatorial maps
-
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
-
qsv-stats
Computing summary statistics on streams
-
num-order
Numerically consistent
Eq,OrdandHashimplementations for variousnumtypes (u32,f64,num_bigint::BigInt, etc.) -
fib-rs
A fast Fibonacci number calculator
-
ecolor
Color structs and color conversion utilities
-
camera-intrinsic-calibration
Camera Intrinsic Calibration
-
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…
-
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
-
kcl-lib
KittyCAD Language implementation and tools
-
bc
Use
bcin the Rust Programming Language -
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
-
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
-
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
-
mech-math
Math library for the Mech language
-
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
-
num-bigfloat
Increased precision floating point numbers implemented purely in Rust
-
pccc
Parallel-concatenated convolutional code
-
geogram_predicates
Rust bindings to the Geogram library's predicates module
-
list_math
doing math on a list including average, smallest, largest, and standard deviation
-
re_arrow_util
Helpers for working with arrow
-
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
-
rmatrix_ks
matrix and some 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
-
ninterp
Numerical interpolation for N-dimensional rectilinear grids
-
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
-
d3_delaunay_rs
A port of D3/d3-delauany
-
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
-
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
-
qhull
Rust bindings to Qhull
-
lazyivy
Lazy Runge-Kutta integration for initial value problems
-
matrixcompare
Tools for convenient comparison of matrices
-
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
-
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
-
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
-
fastnum2
fork of Fast decimal numbers library
-
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
-
soilrust
A geotechnical engineering library for soil mechanics calculations in 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
-
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
-
cgt
Combinatorial Game Theory framework
-
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
-
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…
-
linear_isomorphic
A set of traits to astract over linear-like types
-
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
-
csd-rs
Canonical Signed Digit Conversion in Rust
-
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
-
eqlog-eqlog
Datalog with equality
-
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
-
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
-
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
-
rs-math3d
Rust 3D Math (no dependency on std)
-
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)
-
mats
handling matrices and vectors
-
lower
desugar math where the compiler wont
-
p-chan
Multimedia (Audio, Raster) Channel Newtypes and Conversions
-
bunnies
A fast chess library for chess engines
-
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
-
whittaker-eilers
A sparse matrix implementation of Whittaker-Eilers smoothing and interpolation
-
egobox
A python binding for egobox crates
-
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
-
lowdim
two- to four-dimensional integer geometry
-
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)
-
vecmath
type agnostic library for vector math designed for reexporting
-
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
-
eva
Calculator REPL similar to bc(1)
-
rxcalc
An expression calculator, originally written in Scratch
-
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
-
matio-rs
Rust wrapper to MATLAB MAT file I/O library
-
arcflash
Arc flash calculations according to IEEE 1584
-
mavdac
MAVIS Differential Astrometric Calibrator
-
mscore
providing core operations for computational mass spectrometry proteomics
-
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
-
relrc
Reference counted pointers, with relationships to other pointers
-
fnir
Fast numerical integration rules, like tanh-sinh quadrature
-
datafrog
Lightweight Datalog engine intended to be embedded in other Rust programs
-
physdes-rs
Physical Design in Rust
-
faer_gmres
GMRES implementation using faer
-
decimal-percentage
Percentage type with rust_decimal
-
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
-
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
-
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
-
chfft
Fastest Fourier Transform library implemented with pure Rust
-
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)
-
automesh
Automatic mesh generation
-
strmath
Do math with your strings
-
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
-
sigma-types
Types checked for an invariant
-
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
-
gpu-fft
performing Fast Fourier Transform (FFT) and Inverse FFT using GPU acceleration
-
tea-dtype
provide datatype and useful traits for datatype
-
ecoord-cli
CLI tool for transforming between 3D coordinate frames
-
malachite-q
The arbitrary-precision type Rational, with efficient algorithms partially derived from GMP and FLINT
-
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…
-
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
-
discrete-gaussian
Gaussian sampling over discrete fields/rings/sets
-
rustsat-cadical
Interface to the SAT solver CaDiCaL for the RustSAT library
-
incr_stats
Fast, scalable, incremental descriptive statistics in Rust
-
ha-ndarray
A hardware-accelerated n-dimensional array
-
primal-check
Fast standalone primality testing
-
patronus
Hardware bug-finding toolkit
-
vf2
VF2 subgraph isomorphism algorithm in Rust
-
tabularlib
Small library for abstract matrices stored in single linear vectors created as practice project
-
combinatorial
tools, functions, and generators
-
rusty-wam
The Warren Abstract Machine in Rust
-
bb-geometry
A small crate containing some data structures and methods for 4d Euclidean geometry
-
uint256
A light-weight implementation of 256-bit unsigned integers type with semantic API
-
rectutils
Common algorithms for rectangles (quadtree, rect packing, etc.)
-
circle
Definition of circle and ellipse
-
camera-intrinsic-model
Camera Intrinsic Models
-
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
-
tinymvt
serializing Mapbox Vector Tile (MVT) with minimal dependencies
-
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
-
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
-
int-div-cum-error
Primitive integer division with rounding kind and cumulative error
-
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
-
numbat-cli
A statically typed programming language for scientific computations with first class support for physical dimensions and units
-
punc
Pun Calculus
-
logic-form
representing Cube, Clause, CNF and DNF
-
libmf
Large-scale sparse matrix factorization for Rust
-
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
-
rapier3d-urdf
URDF file loader for the 3D rapier physics engine
-
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
-
rita
Randomized Incremental Triangulation Algorithms
-
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
-
geometry_tools
Efficient computation of single precision geometric data
-
static-math
Fast mathematical operations with static arrays, without
unsafecode -
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
-
quad-rs
Adaptive Gauss-Kronrod Integration in Rust
-
algebra_kit
An abstract algebra library for Rust
-
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
-
jacderida-exp2-adder2
Little binary for experimenting with automated release workflows
-
fitme
CLI curve fitting tool. Parameterise an equation from a CSV dataset.
-
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
-
captcha_breaker
多种验证码识别实现
-
boolean-logic
propositional logic evaluator that creates truth tables for propositional expressions
-
hmath
Big Integers and Rational Numbers
-
rust_decimal_cql
that wraps rust_decimal and implements (de)serialization support for ScyllaDB's native DECIMAL type
-
credit_portfolio_model
Simulation of factor model to calculate loss distribution of a credit portfolio
-
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!
-
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
-
primitive_fixed_point_decimal
Primitive fixed-point decimal types
-
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
-
honeycomb-render
Visualization tool for combinatorial maps
-
rust-tensors
n-dimensional arrays
-
sqpnp_simple
SQPnp camera pose estimation
-
rpn-c
A calculator environment using Reverse Polish Notation and multiple precision numbers
-
break_infinity
larger numbers up to 1e9e15 in Rust for Incremental Games
-
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 -
fibonacci-numbers
The 59th Fibonacci number
-
categorical
combining categorical random distributions and computing exact probabilities
-
brine-fp
192-bit fixed-point math library with logarithmic and exponential functions. Designed for blockchain, scientific, and financial applications.
-
scirs2-interpolate
Interpolation module for SciRS2
-
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
-
integrate
Small, lightweight Rust library for performing numerical integration
-
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 -
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
-
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
-
single_algebra
A linear algebra convenience library for the single-rust library. Can be used externally as well.
-
rlu
Sparse LU Decomposition (Gilbert-Peierls)
-
lox-earth
Tools for Earth-based astrodynamics for the Lox ecosystem
-
generic_fixedpoint
Generic fixed-point numbers
-
cork
A command-line calculator for hex-lovers
-
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
-
pmm_math
Version of PMM Mathematical Formula Library
-
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
-
divrem
Division and modulus variants
-
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
-
topology-traits
Topological traits for generic mathematics in Rust
-
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
-
array_math
A selection of useful math operations on arrays
-
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
-
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
-
algexenotation
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
-
rpoly
algorithm for finding all roots of a real-coefficient univariate polynomial
-
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
-
ibdgen
Generate incomplete block designs for experiments with prohibited pairs
-
num-iter
External iterators for generic mathematics
-
rug-maths
rug wrapper implementing maths-traits
-
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 -
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
-
ndarray-glm
Performs regression for generalized linear models using IRLS on data stored in arrays
-
gamemath
math library for game development, written 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
-
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
-
aberth
Aberth's method for finding the zeros of a polynomial
-
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
-
matrix42
A linear algebra library developed as a project in the 42 ecosystem
-
meansd
calculate mean and standard deviation
-
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
-
mech-matrix
Matrix library for the Mech language
-
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
-
oat_python
User-friendly tools for applied topology in Python
-
longitude
Work with real world coordinates in Rust!
-
compute-pi
designed for computing pi to millions of digits
-
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
-
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
-
math-rs
A basic mathematical engine
-
coco-rs
Rust bindings for COCO benchmarking framework
-
spin4
esoteric programming language that uses 4D rotations for computations
-
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
-
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
-
easing-fixed
easing iterators using fixed-point math
-
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
-
allan-tools
Package to compute statistics to study systems stability
-
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
-
reals
Computable and unified real numbers
-
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.
-
belnapian
Belnap's 4-valued logic basic building blocks in Rust
-
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
-
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
-
crum
Tensors, Matrices and Complex numbers for numerical analysis
-
vectune
A lightweight VectorDB with Incremental Indexing, based on FreshVamana
-
quantogram
Approximate quantiles using histograms with logarithmically sized bins to guarantee worst case absolute relative error
-
linfa-hierarchical
Agglomerative Hierarchical clustering
-
ieee754
Low-level manipulations of IEEE754 floating-point numbers
-
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
-
gematria_rs
Gematria, a traditional Hebrew numerology system
-
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.
-
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
-
nalgebra_latex
several robust formatters for nalgebra::Matrix, LaTeX environments, and more
-
plexus
2D and 3D mesh processing
-
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
-
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
-
octoon-math
Graphics utilities for Rust
-
compute-tau
designed for computing tau to millions of digits
-
t4t
Tit-for-tat: a game theory toolbox
-
rust_math
Math library written in Rust
-
sabi-rust
A small framework to separate logics and data accesses for Rust application
-
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
-
gecl
geometry types and a color type
-
interva
A feature-rich crate for handling intervals
-
guff
Implements Galois Fields for various natural sizes
-
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
-
scirs2-linalg
Linear algebra 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
-
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
-
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
-
mathsharp
collection of mathematical functions and resources to assist in solving a wide range of topics
-
cherry-rs
Tools for designing sequential optical systems
-
hexga_math
Math related crate that support multi dimensionnal vector, matrix, rectangle
-
repunit
Generation Library for Rust
-
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
-
metrics_evaluation
Small foot-print parser and solver for (nested) text-based comparisons
-
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
-
gee
A convenience-first geometry library tailor-made for 2D games! 📐
-
intervals
A generic interval type with support for open/closed bounds
-
appro-eq
Approximately equal traits and assertion
-
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… -
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 -
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
-
aftermath
parse and evaluate complex math expression
-
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
-
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
-
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!
-
optimath
Linear Algebra using const generics for no_std and specialization to enable SIMD
-
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
-
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…
-
base-converter
Convert a number in any base to any other base
-
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
-
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
-
rbf3
Radial Basis Function multidimensional interpolation
-
tick-machine
tick calculator
-
agda-mode
Accessing Agda's interaction mode via command line, in Rust
-
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
-
dana
Compile-time dimensional analysis via generic types
-
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
-
rtsam
Real Time Smoothing and Mapping (RTSAM) in Rust
-
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
-
dashu-float
A big float library supporting arbitrary precision, arbitrary base and arbitrary rounding mode
-
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
-
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
-
rsmonad
Haskell-style monads for idiomatic Rust
-
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
-
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
-
beeg
easy big number conversion
-
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
-
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
-
faasle
evaluating distances (metrics)
-
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
-
fitting
Pure Rust curve fitting library
-
dimensionals
Rust native generic, flexible n-dimensional array
-
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
-
quadratic_residues
calculating quadratic residues of integers
-
calc_mjp
calc simple library
-
dntk-matrix
Statically sized matrix using a definition with const generics (only for nightly)
-
trilean
Kleene's three-valued logic (boolean + unknown)
-
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
-
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 -
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…
-
swh_graph_topology
Collection of topology analysis utilities based on swh-graph
-
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
-
feval
clt for fast evaluations
-
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
-
rs-measures
macros to encapsulate numbers in measures, provided with units of measurement, allowing any meaningful operation, but statically forbidding meaningless operations with them
-
kair
COnstraint Based Reconstruction and Analysis (COBRA) in Rust
-
satif-cadical
Rust wrapper for the CaDiCaL SAT solver
-
calculator-lib
calculator library
-
parity
is_even and is_odd methods for primitive numeric types
-
vodk_math
math vector and matrix library
-
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
-
openhistogram
Fast, dense, stable auto-binning histograms
-
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
-
mdbook-katex
mdBook preprocessor rendering LaTeX equations to HTML
-
lcrs
A Lambda Calculus Interpreter written in Rust
-
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
-
minifloat
Emulate various minifloats with const generics
-
rustbot
My package for aimbot calculations / vector math
-
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
-
colon
A array and number utility functions
-
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
-
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
-
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
-
norman
Implementations of different norms for elements of vector spaces
-
batbox-la
Linear algebra
-
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
-
rust-money
basic and precise Money operations such as rounding, splitting and allocating
-
combinator
inspired by APL/J
-
spglib
Rust bindings to spglib
-
accord-rs
Calculate consensus sequences
-
amfnwasm
Amortization Functions (AmFn) Web Assembly
-
nabo-pbc
A fast K Nearest Neighbor (KNN) library for low-dimensional spaces, now with support for periodic boundary conditions
-
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 -
mech-logic
Logic library for the Mech language
-
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
-
compute
statistical computing
-
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!
-
sv4state
SystemVerilog 4-state value library
-
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
-
beagle
A basic linear algebra library for computer graphics
-
polyhedron-ops
Conway/Hart Polyhedron Operations
-
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
-
sparseglm
Fast memory-efficient solver for sparse generalized linear models
-
hann-rs
Blazingly fast Rust Hann Window
-
calc_lib
calculating things with correct order of operations
-
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
-
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
-
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)
-
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
-
irox-stats
Various mathematical and statistics utilities
-
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
-
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
-
radian
A normalized angle type
-
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
-
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
-
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
-
normdecimal
Always normal decimal numbers
-
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
-
irox-units
Physical Quantities, Units, & Reference Frames Library
-
statslicer
Guacamole provides a linearly-seekable random number generator
-
permutations
generating permutations
-
rust_pie_ob
a pie orderbook library for rust
-
gategen
generate Gate circuits
-
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
-
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
-
unit_system
Automatically derived typed unit systems
-
unsigned-f64
A wrapper around f64 that guarantees that the value is always non-negative on the type level
-
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
-
safe-modular-arithmetic
modular arithmetic algorithms for all integer types in an overflow-safe and const-compatible manner
-
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
-
rusty_units
storing units of measurement in Rust
-
rmathlib
Port of R's C Library of Special Functions
-
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
-
millimeter
Primitive type with millimeter unit attached
-
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
-
rust-latex-doc-minimal-example
Minimal crate example for getting latex in docs
-
oat_rust
User-friendly tools for applied topology
-
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
-
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
-
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
-
rug-gmpmee
Rust FFI bindings for GMPMEE
-
mpmfnum
A numbers library in Rust
-
awint_ext
Externally allocating
awintfunctionality -
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
-
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
-
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/
-
unit-root
Unit root tests
-
oscirs_linalg
GPU accelerated linear algebra crate for scientific computing
-
russell_nonlin
Numerical continuation methods to solve nonlinear systems of equations
-
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
-
serde-ndim
Serde support for n-dimensional arrays from self-describing formats
-
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)
-
lineas
A mathematical linear algebra library for Rust
-
lamb
Pure untyped lambda calculus in safe Rust
-
currency_rs_isotoxal
handling currencies uses less lifetimes and more data on heap use currency_rs if you need
-
neis_calculator
bytes counter for NEIS
-
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!
-
nd_array
linear algebra that tries to have a similar api to numpy
-
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
-
tricolor
Color structs, color formats, and color conversions
-
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
-
chord_name
working with chord names in music theory
-
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
-
nut_sys
Wrapper for Number-Theory-Utils C library
-
pulsejet-rs
Rust port of yupferris' audio codec Pulsejet
-
msh_rpn_calc_test_ver
RPN library
-
siege-math
Math library for the Siege Engine
-
canrun
A logic programming library inspired by the *Kanren family of language DSLs
-
pop-prob-cli
A population probability calculator
-
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
-
hwcalc
An arbitrary bit-width calculator
-
math_64
Only the numbers 1, 3, 5, 7 or 9 work. It's very odd.
-
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
-
vector_operations
A collection of vector operations for Rust
-
tropical_algebra
tropical algebra in Rust
-
butter2d
Butterworth filter for image processing
-
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
-
i48
working with 48-bit integers
-
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
-
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
-
rawarray
file format for retrievably storing n-dimensional arrays
-
neapolitan
Easily model and solve circuit-like problems
-
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
-
clnooms
Assembly-level implementation of interesting data types
-
calculator_function
some description
-
FullMathOP
Full Math OP
-
hask-replace
Rename haskell modules at the speed of Rust
-
routrs_maritime_dataset
Maritime 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
-
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
-
is_thirteen_rs
package to check if a number is equal to 13
-
fibonacci-like
A small crate to help you interact with second order sequences, such as the Fibonacci sequence, with no_std support
-
float_math
Does math on floating point values
-
qmu
Quigly's Math Utility
-
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
-
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
-
sddrs
Bottom-up Sentential Decision Diagram compiler library
-
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
-
rust-numpy
A row version of a convinient rust-numpy library which target is to dublicate functionality of well known python library 'numpy'
-
ntt
Fast NTT (number theoretic transform) for polynomial multiplcation for primes, prime power, and certain composite moduli
-
mee6
calculate mee6 leveling data
-
caliph
calibrate and convert pH measurements using a two point method
-
gfxmath-vec4
3D math library
-
poseidon-paramgen
generating Poseidon parameters
-
markovian
Simulation of Markov Processes as stochastic processes
-
const_fixedp
A const type for fixed point arithmetic
-
game_logic
simulating turn-based games with customizable game logic and agent behavior
-
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
-
base95
Textual representation of base 95 fractional numbers with arbitrary precision
-
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
-
lamcal-repl
A lambda calculus command line repl
-
scotch
Idiomatic wrapper for Scotch, the graph partitioner, graph clusterer and sparse matrix orderer
-
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
-
zapper
lightning fast templating engine
-
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
-
eigenvalues
algorithms to compute eigenvalue/eigenvectors of symmetric matrices
-
vecto
vector2
-
nalgebra-numpy
conversions between nalgebra and numpy
-
acm_dependent
Project dependent on the arithmetic_congruence_monoid library for working with arithmetic congruence monoids (ACM)
-
sath
Toy math library
-
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
-
scicalc-rs
parsing and doing calculations with measurements, typically used in scientific contexts
-
laddu-python
Amplitude analysis made short and sweet
-
dynast
Feynman graph topology identification
-
amfnbatch
Amortization Functions (AmFn) Batch Process
-
mematrica
An easy to use library for working with matrices
-
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
-
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
-
dfp-number-sys
Rust bindings for Intel® Decimal Floating-Point Math Library
-
scirs2-sparse
Sparse matrix module for SciRS2
-
umath
ffast-math in rust
-
libmath
Mathematical utilities
-
matrix_algebra
supporting matrix algebra
-
scirs2-signal
Signal processing module for SciRS2
-
multi_dim_point
multi-dimensional point
-
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
-
linearkalman
Linear Kalman filtering and smoothing
-
online-statistics
Blazingly fast, generic, and serializable online statistics
-
nikisas
common mathematical functions with focus on speed and simplicity of implementation at the cost of precision, with support for
no_stdenvironments -
cadical
Rust bindings for the CaDiCaL SAT solver
-
mangle-analysis
Mangle, a logic programming language
-
nalgebra-sparse
Sparse matrix computation based on nalgebra
-
calcer
nice program to write graphs from programs
-
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
-
butterworth
filters
-
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
-
fend-core
Arbitrary-precision unit-aware calculator
-
lasy
A small library dedicated to LASER path optimisation
-
pandas_rs
General Mathematics Library for Rust,Inspired by Python Pandas Library
-
rsruckig
Ruckig motion planning library for Rust
-
postfix
expression evaluator
-
c-prime
Convenience wrapper for machine-prime
-
pgnumeric
Arbitrary precision numeric implementation written in Rust, compatible with PostgreSQL's numeric
-
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
-
compensated-summation
Compensated summation algorithms for better precision
-
decimal-wad
Math for preserving precision floats up to 18 decimal places
-
rust-gmp-kzen
Rust bindings for GMP
-
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
-
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
-
phylodm
Efficient calculation of phylogenetic distance matrices
-
data-pipeline
A functional and extensible library for organized lazy processing of data with minimal overhead
-
set-partitions
Represent and enumerate set partitions
-
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
-
geo-aid-svg
Support for SVG output from Geo-AID
-
fenris-geometry
Geometry functionality for fenris
-
natural_constants
Pre-defined constants from all disciplines (math, physics, ...)
-
samplers
Sample from distributions and calculate summary statistics from the command line
-
rustlinalg
linear algebra crate to support crustacea ML crate
-
f128_internal
Internal bindings to the gcc quadmath library
-
ndarray-unit
A package providing a system of units to the ndarray type
-
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
-
logical_expression_parser
logical expression parser written in Rust using pest library
-
m_calc
calculate math expressions
-
ferrix
matrix library for Rust
-
temex
Regex-like temporal expressions for evaluating systems that change over time
-
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)
-
lapack-src
The package provides a LAPACK source of choice
-
discrete_transforms
Discrete Transforms
-
fftw
safe wrapper of FFTW3
-
fractran_rs
A FRACTRAN interpreter
-
mfcc
Calculate Mel Frequency Cepstral Coefficients from audio data
-
intervals-good
An interval arithmetic library with support for many functions and which tracks when domain errors may occur or are guaranteed to occur
-
sized_matrix
Sized matrices using const generics for better type checking and performance
-
ark-poly-commit
constructing polynomial commitment schemes for use in zkSNARKs
-
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
-
eskf
Navigation filter based on an Error State Kalman Filter (ESKF)
-
functions_shared
Test deply crates.io
-
temp-converter-lib
terminal temperature unit converter between Celsius, Fahrenheit and Kelvin
-
rexl_math
mathematics library for Rust
-
simple_calculator_cmd
command line simple calculator and library
-
point_process
simulating random point processes
-
r2rs-nmath
Statistics programming for Rust based on R's nmath package
-
arb-sys
Bindings to the Arb library
-
stat-rs
A statistics 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
-
hipparchus
<!-- TODO -->
-
simple_2d_vector
two-dimensional vectors in Rust
-
gaussfilt
Design and apply Gaussian filter for 1D data
-
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.
-
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
-
tnt
runtime validated proofs in number theory
-
calcify
Physics vector library
-
xcomplex
A complex number library
-
moving-average
moving average library
-
pire-gemm-c32
high performance cpu kernels
-
implicit3d
3d implicit geometry
-
faer-cholesky
Basic linear algebra routines
-
lmaths
A short 2D Maths library
-
csaps
Cubic spline approximation (smoothing)
-
bose
mathematical and scientific formulas
-
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
-
replicante_logging
Replicante common logging logic
-
const-decimal
Integer-backed decimals with constant precision
-
rsmt2
Wrapper for SMT-LIB 2 compliant SMT solvers
-
arithmetic_parser_smetaniuk
Arithmetic expression calculator parser
-
cavalier_contours_ffi
C foreign function interface for the cavalier_contours crate
-
rational_extensions
Extensions for rational numbers
-
libmat
tools for linear algebra
-
alpha_g_physics
Data analysis library for the ALPHA-g experiment
-
f64ad
Easy to use, efficient, and highly flexible automatic differentiation in Rust
-
hipparchus-az
angle representation, conversion and calculations
-
rest_tensors
Provide efficient tensor operations for the Rust-based Electronic Structure Tool (REST)
-
ajkcalc
scriptable hybrid calculator
-
numeric
N-dimensional matrix class for Rust
-
xdbuf
reusable multi-dimensional buffer
-
var_num
Variable length number implementation that can be used as a drop in replacement for any number primitive
-
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
-
ark-ec
elliptic curves and pairings
-
df-maths
maths
-
fast-macro
High-performance SIMD mathematics, optimized GPU computation, and vectorized algorithms
-
rufft
A pure rust FFT library !
-
arpack-ng-sys
Bindings to arpack-ng
-
mathlab
A Powerful Math Library for Rust
-
num_base
manipulating with numbers (integers) in different bases
-
nearly_eq
Nearly(Approximately) equal traits and assertion
-
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
-
simplicity
simulation of simplicity (https://arxiv.org/pdf/math/9410209.pdf)
-
andre_wronscki_functions
Andre Wronscki package functions
-
upload_to_crate_io
Review Upload
-
rpni
A basic command-line RPN calculator
-
bq
A complete implementation of dual quaternions
-
voronoi
compute Voronoi diagrams, using Fortune's sweepline algorithm
-
gon
Easy polygon drawing built on top of lyon
-
dihedral
(torsion) angle calculations
-
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
-
peroxide-num
Numerical traits for Peroxide
-
exponential-integral
The exponential integral function, a.k.a. Ei.
-
calcium-oxide
Calc-ium Oxide, a simple stack based command line calculator written in rust
-
rect-lib
working with anything vaguely rectangular
-
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
-
simple-vectors
dimension generic vector math
-
algebraeon-rings
Algorithms in linear algebra, polynomials, and number theory
-
magnesia
A math library for Rust
-
algebraic-gen
Procedural Macro for Geometric Products of Any Dimension
-
biconnected-components
Find biconnected components in a graph
-
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
-
concrete-fftw
Safe wrapper around FFTW
-
sir_ddft
SIR-DDFT model
-
alphabet
working with alphabets
-
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
-
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
-
min_max_traits
Traits for MIN and MAX associated constants
-
koto_geometry
A Koto library with basic geometry types and operations
-
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
-
factorial-mod
Fast mod for $n! % p
-
libreda-logic
Logic library for LibrEDA
-
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
-
numerical-linear-algebra
linear algebra implemented using numerical methods
-
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
-
goertzel-nostd
An nostd implementation of Goertzel's Algoritm
-
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
-
bvrs
A lightweight rust library for BitVector Rank&Select operations, coupled with a generic Sparse Array implementation
-
arithmetic_parser_kma
Arithmetic expression calculator parser
-
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
-
hilbert_curve
Hilbert curve mapping algorithms in Rust
-
mpt_lib
a function libaray for modern portfolio theroy
-
oxlex
lexer/tokenizer used in OxyScript
-
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
-
gateutil
basic utilities for GateSim
-
precise-calc
A high precision calculator library and command line tool
-
ferrous-simple-calc
Example crate: simple calculator
-
rusty-compression
Low rank compression algorithms in Rust
-
statrs-fork
Statistical computing library for 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
-
hcode_functions2
Biblioteca de funções da HCode
-
bitslice
transpose bits into and out of bitslice format, and perform various operations on bitsliced data
-
coin_cbc_sys
Rust bindings to the CoinOR CBC MILP Solveur using the C API
-
nd_interpolate
1-10 dimensional linear and cubic spline interpolation implemented in Rust
-
moo-math
math interpreter
-
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
-
convg
convert directed and undirected graphs from NAUTY and Traces into adjacency, dot, and net files
-
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!
-
ipasir
Bindings for the IPASIR API to communicate with incremental SAT solvers
-
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
-
tribool
Three-valued logic
-
rust_combinatorics
Combinatoric utilities and functions for rust
-
rpn_calc_perl
RPN library for Perl
-
envisim_utils
methods for design-based sampling methods and estimation
-
lufact
Sparse LU factorization with partial pivoting
-
macromath
Macros for convenient maths with checked, wrapping or saturating semantics
-
afarray
Convenience methods for working with ArrayFire arrays in Rust
-
hc
Handy calculator for haxor calculations
-
machine-factor
constant factorisation for machine-size integers
-
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
-
splinosaurus
flexible spline and surface library
-
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
-
mixed-num
A trait for generic implementations of numerical methods
-
hilbert16
Hilbert transforms between 1D and 2D space, optimized for u16 coordinates
-
smt-lang
Sat Modulo Theory Language
-
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
-
math-calc-cli
command-line utility for calculation
-
orfeo_rpn_calc
RPN(Reverse Polish Notation) library
-
alpha-counter-cli
Alphabetic counter
-
ipopt-ad
Blackbox NLP solver using IPOPT and automatic differentiation
-
ludomath
A math library for 2D games and graphics
-
logic-rs
representing logical formulas with support for temporal robustness semantics
-
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
-
rusty-cffi
Tools for interfacing with other languages via CFFI
-
fftw-src
Source of FFTW
-
hipparchus-mean
A collection of basic mathematics solver: Lp norm, mean, moving average, sequence
-
redc
Unsigned integer types which are constrained within a modular field using montgomery multiplication, never overflowing or exceeding the modulo
-
terrain-graph
Graph Library for Rust
-
spawn-stochastic
simulating multiple stochastic processes including ABM, GBM, Ornstein-Uhlenbeck, Feller Square Root, and Brownian Bridge
-
pesto_cli
hello there
-
numlib
numerical library implementing common numberical algorithms in rust
-
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
-
mazer-data-structures
A minimal, simple math markup language that compiles to HTML, written in Rust
-
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
-
spsolve
Solve sparse systems of linear equations
-
pop-prob
A population probability calculator
-
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
-
hcode_functions_eduardo
Biblioteca de funções do curso
-
complex-stuff
working with complex numbers in rust
-
siffra
parse and evaluate human-friendly mathematical and natural language expressions
-
wicker
Weighted probability picker for Rust
-
r_mathlib
A port of R’s
nmathstats module to Rust -
pnets_tina
A parser for tina Petri net
-
dmntk-feel
DMNTK | FEEL definitions
-
rsmaxsat
that provides bindings for the MaxSAT solver
-
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
-
approximately
compare two any values
-
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
-
astro-float-num
Multiple precision floating point numbers implemented purely in Rust
-
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
-
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
-
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
-
dices
calculate discrete probability distributions and statistics for combinations of dices
-
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
-
nova-math
Vector and matrix math utilities for nova-engine
-
math_interval
checking numbers for membership in an interval easy
-
btor2rs
Safe-Rust Btor2 parser
-
pakr-iec
Functions to format numbers as decimal (1000 is 1.0k) and IEC (1024 is 1.0ki) up to YOTTA suffix
-
whittaker_smoother
The perfect smoother: A discrete-time version of spline smoothing for equally spaced data
-
avery
A scattering event format for converting between other formats
-
ark-bls12-381
The BLS12-381 pairing-friendly elliptic curve
-
seximal
(base6) equivalent of Rust's type system
-
advanedresearch-trinoise
A mathematical noise pattern of 3 values based on Number Theory and Set Theory
-
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
-
safeeft
Safe and branchless error-free transformation algorithms for floating point numbers
-
metis-sys
Raw FFI to METIS, the serial graph partitioner and fill-reducing matrix orderer
-
upcast-arithmetic
Arithmetic that is upcasted on overflow
-
rust-expression
Calculator and solver for linear equations
-
iomath
fast math rust-library
-
tcs-dhbw
Modules for a model traffic control system project at DHBW Stuttgart
-
com-croftsoft-core
A core library of highly reusable code
-
wmathrs
mathematical crate
-
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
-
modutil
Provide the methods supports modular arithmetic
-
solver
Solve optimization problems
-
predicatechecker
Check that a predicate is true if another is
-
icub3d_combinatorics
A collection of combinatorics utilities
-
nicolas
Computational Algebra Library
-
fibnacci
fast high precision fibonacci calculator using rayon and gmp
-
fishers_exact
Fisher's exact statistical test
-
last_order_logic
An experimental logical language
-
pblib-rs
Rust safe bindings for pblib
-
cyclic
complete, and dependency-free modular arithmetic
-
scirs2-cluster
Clustering algorithms module for SciRS2
-
xicor
Sourav Chatterjee's xi-correlation coefficient
-
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
-
awint_dag
DAG
awintfunctionality -
malachite-float
The arbitrary-precision floating-point type Float, with efficient algorithms partially derived from MPFR
-
quantum2
Advanced Rust quantum computer simulator, forked from "quantum"
-
fenris-optimize
Optimization functionality used by fenris
-
matriz
Zero allocation Rust linear algebra library
-
zernike
Routines to compute the Zernike polynomials
-
exmex
fast, simple, and extendable mathematical expression evaluator able to compute partial derivatives
-
gpurs
GPU acceleration/linear algebra crate for scientific computing
-
time_series_utils
handling time series data
-
rust_ev_verifier_application_lib
common elements to implement an application using the crate
rust_ev_verifier_lib -
exec-sat
Executes SAT solver and parses SAT solver output
-
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
-
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
-
polygonical
2d polygon geometry and operations
-
hugefloat
Extremely large, limited-precision floats for use in incremental games
-
dashu-ratio
A big rational library with good performance
-
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.
-
cruncher
jit-compiled mathematical expression calculator
-
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
-
earcut
port of the Earcut polygon triangulation library
-
routrs_highways_dataset
Highways dataset for routrs, the geograph-based shortest distance calculator for Rust
-
lagrange-interpolation
Lagrange's Interpolation Formula
-
hypergraph
data structure library to create a directed hypergraph in which an hyperedge can join any number of vertices
-
ndspec
A package for ocean waves and energy spectra
-
logic_gate
Logic Gates
-
del-fem
finite element method (FEM) utility codes
-
polynomial_ops
Multivariable polynomial operations on arrays and vectors
-
mish
A proof of concept Rust libm like implementation with almost full coverage of libm
-
nutils-poly
Low-level functions for evaluating and manipulating polynomials
-
circuit_sat_check
generate circuit checking to CNF formula
-
ducc0
Wrapping ducc, the Distinctly Useful Code Collection
-
caso
Category Theory Solver for Commutative Diagrams
-
dmntk-examples
DMNTK | Examples
-
libnum
Functions for efficient development in Math and Crypto
-
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
-
in_range
Returns true if a number is in range
-
soy
Interpolation library
-
bempp-quadrature
Simplex quadrature rules and boundary element singular quadrature
-
scirs2
port of SciPy with AI/ML extensions - Scientific Computing and AI Library
-
rpn_calc_JM
RPN(Reverse Polish Notatio) library
-
ipasir-loading
Load shared libraries of IPASIR compatible SAT solvers
-
razor-chase
implements a variation of The Chase algorithm to find models for theories in geometric form
-
hypersphere
4D primitives for rotation and projection
-
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
-
slicemath
element-wise operations on arrays of numeric values
-
usagi
Common algorithms and utilities library for Rust
-
faer-lu
Basic linear algebra routines
-
numerous
A set of tools to finding and classifying special numbers
-
hellocalc
test
-
scirust
A scientific computing 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
-
calculatex
A pretty printing calculator with support for units
-
didp-yaml
YAML interface for Dynamic Programming Description Language (DyPDL) and DyPDL solvers
-
acme-graphs
Computational graphs for Rust
-
standard_deviation
used to get the standard deviation from the cli
-
truncnorm
Normal and Truncated Normal distributions
-
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
-
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
-
mini-kanren
miniKANREN in Rust
-
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
-
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
-
num-consts
General-purpose mathematical constants
-
faer-ext
faer-rs API for interoperability with external libraries
-
shoemate-test
A test package. Currently tests that katex renders properly on docs.rs.
-
hstats
Online histogram statistics calculations
-
geometric
A very simple vector and matrix library built on the vecmath crate
-
rpn_calc_taro_kobayashi
RPN(Reverse Polish Notation) library
-
snark-tool
contains structures and algorithm for (mainly) cubic graph analysis
-
nnls
Non-Negative Least Squares (nnls)
-
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
-
datamars
rewrite of https://www.gnu.org/software/datamash/
-
gmpmee-sys
Rust FFI bindings for GMPMEE
-
bigint-benchmark
Benchmarks for big integer implementations
-
r2rs-stats
Statistics programming for Rust based on R's stats package
-
propositional
Logic
-
numerilib
Mathematics Library
-
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
-
ldl
LDL factorisation for quasi-definite linear systems
-
matrix-simp
A linear algebra package (WIP)
-
ffts
Rust binding for ffts (The Fastest Fourier Transform in the South)
-
piston3d-construct
higher order functional programming with homotopy maps to construct 3D geometry
-
sat_toasty_helper
more-easily writing SAT constraints
-
antic-sys
Bindings to the Antic library
-
geo-aid-figure
Definitions for Geo-AID's JSON export format
-
expy
Embeddable & extensible expression evaluator
-
fftconvolve
The fast fourier transform convolution and correlation algorithm for Rust
-
fj-math
Early-stage b-rep CAD kernel
-
xiaotian_s_minigrep
just a test
-
osqp-rust-sys
c2rust(osqp-sys)
-
polynomint
A no-dependency library for working with integer polynomials
-
q1tsim-logic-gates
extension crate to q1tsim implementing the AND, OR and XOR logic cates in a quantum comupting - friendly (i.e. reversible) way.
-
numrs
A numerical computations library for Rust
-
pretty-print-nalgebra
a small macro-only crate providing ability to pretty-print a 2D nalgebra array
-
gatenative
execute natively Gate circuits
-
melius-vectors
2-4 dimensional vectors that can be easily created and manipulated
-
rustnomial
working with polynomials
-
envisim_estimate
Design-based estimation and variance estimation
-
my-little-eval
A little library for evaluating mathematical expressions
-
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
-
container-broadcast
analog of Julia's broadcast interface
-
croot-gui
graphing complex roots and numbers
-
num_vector
Enabling basic vector arithmetic operations
-
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
-
m61-modulus
Functions for performing arithmetic modulo the 61st Mersenne number. Aimed at testing bignum implementations.
-
optrs
Forcefield molecule optimization
-
bootstrap-ht
Bootstrap Hypothesis Testing
-
lodestone_core
User friendly magnetic field calculations in Rust
-
play-rsa
RSA cryptography in Rust for pedagogical use
-
const_num_bigint
const bigint
-
avatar_hypergraph_rewriting
Hypergraph rewriting system with avatars for symbolic distinction
-
stochastic-abm
simulating various stochastic processes, including Arithmetic Brownian Motion and more
-
slender-math
Lightweight math library for game development
-
is_signed_trait
Trait for IS_SIGNED associated constant
-
logistics
Engineering Client
-
ext-ops
General purpose arithmetic operator traits which are missing from the standard library
-
saleae
interacting with saleae devices
-
directx_math
translation of DirectXMath, a SIMD linear algebra library for use in games and graphics apps
-
qty-macros
Macros supporting the implementation of quantities
-
mat-rs
no_std implementation of mathematical matrix types
-
funki_lang
A customisable embeddable functional langauge
-
fuzzylogic
operations for fuzzy set theory
-
plummerprimes
Builds, Runs, and reports benchmarks from https://github.com/PlummersSoftwareLLC/Primes
-
lrs
resolving (conjunctive) normal-form logical clauses
-
softfp
Software floating point operation library
-
guff-sharefiles
Package IDA-encoded data in a portable file format
-
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
-
concrete-fftw-sys
Sources of FFTW and unsafe binding
-
simulated_annealing
An interface for global function optimization using simulated annealing
-
vec3D
A minimal 3D Vector library in Rust
-
quad
Quadrature integration
-
polynomial_tools
that contains some utilities for operations on polynomials
-
alpha_stable
Sample and generate probability distribution functions of Alpha-Stable distributions in Rust
-
logic-long
Supercell's Logic Long implemented in Rust
-
kalk
A math evaluator library that supports user-defined functions, variables and units, and can handle fairly ambiguous syntax
-
polynom
handling polynomials
-
crabsformer
fundamental library for scientific computing with Rust, highly inspired by NumPy
-
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
-
slice2d
Ergonomic array slice for 2d array manipulation
-
corries
Library/framework for 1D-hydrodynamics simulations using Riemann solvers
-
vmd-rs
Variational Mode Decomoposition in Rust
-
elr_primes
prime number iterator and methods for basic calculations with prime numbers
-
horner-eval
A macro for evaluating polynomials via Horner's rule
-
glar-gemm-c32
high performance cpu kernels
-
prime_gen
Generate prime numbers
-
cudd
Cudd Rust library
-
rust-gmp
Rust bindings for GMP
-
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
-
scirs2-spatial
Spatial algorithms module for SciRS2
-
efficient_pca
Principal component computation using SVD and covariance matrix trick
-
objforces
Allows to calculate mouvement of objects based on forces on a 3D axis
-
relation
based on the mathematical concept of financial relations
-
exact-conv
Exact conversions between integer and floating point types
-
c-api-tools
Tools for the creation of C API bindings
-
logic_trioxide
Logic Gate simulating Library
-
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
-
quickfib
A no_std compatible Fibonacci calculation algorithm implemented in Rust
-
accelerate-src
The package provides a source of BLAS and LAPACK via the Accelerate framework
-
si_units
handling arithmetic with SI units
-
junglefowl
Brutally murdering Rust's type system one proof at a time
-
cronbach_alpha_lib
get cronbach alpha value to check your reliable question
-
val_unc
A package for handling quantities with uncertainties
-
mvmm_hydro
A moving mesh hydrodynamics (CFD) solver prioritizing flexibility over raw performance
-
primter
Prime number iterator based on sieve of Eratosthenes
-
statistical-tests-rs
Statistical Tests for Rust
-
primality
Check if a number is prime
-
yttria-modulation
A communications library tailored for use with the yttria set of libraries
-
psina
Blazzzzingly fast graphql schema generator from prisma file
-
bigfactorial
Precalculated compile-time factorial macro for numbers upto 99
-
shanksbot-rs
ShanksBot shown by Matt Parker in https://www.youtube.com/watch?v=DmfxIhmGPP4
-
statc
essentially a TI-84 extended, geared towards statistical calculations and making data easily readable and obtainable
-
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
-
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
-
fj-window
Early-stage b-rep CAD kernel
-
polynominal-interpolation
interpolating a function using polynomial
-
numbrs
A flexible numerical computing package
-
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
-
unit-interval
Types for working with and constraining values to the unit interval
-
prime-rs
Command line utilities for finding prime numbers
-
typed_floats_macros
only used to generate the
typed_floatscrate -
horner
Evaluate polynomials using Horner's method
-
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
-
aspic
An ASPIC+ argumentation system and reasoning engine
-
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
-
super-prime
Find the super prime number
-
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)
-
libbytestat
Randomness analyzer
-
trinary
Rust types for trinary logic
-
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
-
information
theory functions to use with ndarray
-
traitgraph-tsplib-io
Functions to read and write graphs in TSPLIB format
-
librustosa
Calculate Mel Frequency Cepstral Coefficients from audio data
-
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
-
faer-sparse
Basic linear algebra routines
-
wilson
Calculate Wilson confidence interval for binomial distribution using the formula from Wikipedia
-
fuzzy-expert
A fuzzy logic library with support for mamdani fuzzy inference
-
parry2d
2 dimensional collision detection library in Rust
-
cryptix-field
group, ring and field arithmetics based on cryptix-bigint
-
sciport-rs
Rust port of scipy
-
glar-base
high performance cpu kernels
-
depends_core
Ergonomic, performant, incremental computation between arbitrary types
-
ark-bn254
The BN254 pairing-friendly elliptic curve
-
matrix-basic
very basic matrix operations
-
lodestone_python
User friendly magnetic field calculations in Rust
-
ferrate
Math Library
-
lagrangian_interpolation
An algorithm to interpolate between points with polynomials
-
fenris-sparse
Sparse matrix functionality for fenris
-
num-irrational
num-irrationalis based onnumand extends it with support for several kinds of irrational numbers -
keccak_prime
The hashing algorithm that keeps your blockchain green
-
random-partition
Generate approximately uniformly distributed random integer partitions
-
nonstdfloat
Floating point calculations for strafe
-
get_len_base_10_as_usize
Traits for getting length base 10 as usize, both at run and compile time
-
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)…
-
gatesim
The base library for the Gate Project
-
primeshor
project to explore prime numbers and factorization
-
ios_calculator
iOS calculator implementation
-
cufft_rust
A safe cuFFT wrapper
-
awint_core
Core no-std and no-alloc
awintfunctionality -
rprime
useful functions for prime numbers
-
primapalooza
prime number calculations implemented in rust
-
rsmt2-zz
Wrapper for SMT-LIB 2 compliant SMT solvers. With ZZ downstream fixes
-
mkl-rs-sys
MKL bindings for Rust