Module numeric 

Numeric traits and utilities for SciRS2

This module provides unified access to numeric traits and complex numbers.

SciRS2 POLICY Compliance

This is the only module in the SciRS2 ecosystem that should directly import external numeric libraries. All other crates must use this module.

Re-exports

• num_traits: All numeric traits (Float, Zero, One, etc.)
• num_complex: Complex number types
• num_integer: Integer-specific functions (gcd, lcm, etc.)

Modules

advanced_simd

Advanced-optimized SIMD operations for numerical computations

num_complex

Complex numbers.

num_integer

Integer trait and functions.

num_traits

Numeric traits for generic mathematics

precision_tracking

Automated precision tracking for numerical computations

scientific_types

Specialized numeric types for scientific domains

stability

Numerical stability improvements

stable_algorithms

Stable numerical algorithms

Structs

Complex

A complex number in Cartesian form.

ExtendedGcd

Greatest common divisor and Bézout coefficients

Scalar

Type-safe representation of a unitless quantity

Traits

AngleConversion

Trait for converting between degrees and radians

AsPrimitive

A generic interface for casting between machine scalars with the as operator, which admits narrowing and precision loss. Implementers of this trait AsPrimitive should behave like a primitive numeric type (e.g. a newtype around another primitive), and the intended conversion must never fail.

Average

Provides methods to compute the average of two integers, without overflows.

Bounded

Numbers which have upper and lower bounds

CheckedAdd

Performs addition that returns None instead of wrapping around on overflow.

CheckedDiv

Performs division that returns None instead of panicking on division by zero and instead of wrapping around on underflow and overflow.

CheckedMul

Performs multiplication that returns None instead of wrapping around on underflow or overflow.

CheckedNeg

Performs negation that returns None if the result can’t be represented.

CheckedRem

Performs an integral remainder that returns None instead of panicking on division by zero and instead of wrapping around on underflow and overflow.

CheckedShl

Performs a left shift that returns None on shifts larger than or equal to the type width.

CheckedShr

Performs a right shift that returns None on shifts larger than or equal to the type width.

CheckedSub

Performs subtraction that returns None instead of wrapping around on underflow.

ComplexFloat

Generic trait for floating point complex numbers.

ComplexNumber

A trait for complex number types

Float

Generic trait for floating point numbers

FloatConst

FromPrimitive

A generic trait for converting a number to a value.

Integer

Inv

Unary operator for retrieving the multiplicative inverse, or reciprocal, of a value.

MulAdd

Fused multiply-add. Computes (self * a) + b with only one rounding error, yielding a more accurate result than an unfused multiply-add.

MulAddAssign

The fused multiply-add assignment operation *self = (*self * a) + b

Num

The base trait for numeric types, covering 0 and 1 values, comparisons, basic numeric operations, and string conversion.

NumAssign

The trait for Num types which also implement assignment operators.

NumAssignOps

Generic trait for types implementing numeric assignment operators (like +=).

NumAssignRef

The trait for NumAssign types which also implement assignment operations taking the second operand by reference.

NumCast

An interface for casting between machine scalars.

NumOps

Generic trait for types implementing basic numeric operations

NumRef

The trait for Num types which also implement numeric operations taking the second operand by reference.

NumericConversion

Conversion between different numeric types

One

Defines a multiplicative identity element for Self.

Pow

Binary operator for raising a value to a power.

PrimInt

Generic trait for primitive integers.

Real

A trait for real number types that do not necessarily have floating-point-specific characteristics such as NaN and infinity.

RealNumber

A trait for real-valued floating point types

Roots

Provides methods to compute an integer’s square root, cube root, and arbitrary nth root.

Saturating

Saturating math operations. Deprecated, use SaturatingAdd, SaturatingSub and SaturatingMul instead.

SaturatingAdd

Performs addition that saturates at the numeric bounds instead of overflowing.

SaturatingMul

Performs multiplication that saturates at the numeric bounds instead of overflowing.

SaturatingSub

Performs subtraction that saturates at the numeric bounds instead of overflowing.

ScientificInteger

A trait for integers that can be used in scientific calculations

ScientificNumber

A trait for numeric types that can be used in scientific calculations

Signed

Useful functions for signed numbers (i.e. numbers that can be negative).

SparseElement

Trait for types that can be used as sparse matrix elements

ToPrimitive

A generic trait for converting a value to a number.

Unsigned

A trait for values which cannot be negative

WrappingAdd

Performs addition that wraps around on overflow.

WrappingMul

Performs multiplication that wraps around on overflow.

WrappingNeg

Performs a negation that does not panic.

WrappingShl

Performs a left shift that does not panic.

WrappingShr

Performs a right shift that does not panic.

WrappingSub

Performs subtraction that wraps around on overflow.

Zero

Defines an additive identity element for Self.

Functions

checked_pow

Raises a value to the power of exp, returning None if an overflow occurred.

div_ceil

Ceiled integer division

div_floor

Floored integer division

div_mod_floor

Simultaneous floored integer division and modulus

gcd

Calculates the Greatest Common Divisor (GCD) of the number and other. The result is always non-negative.

gcd_lcm

Calculates the Greatest Common Divisor (GCD) and Lowest Common Multiple (LCM) of the number and other.

lcm

Calculates the Lowest Common Multiple (LCM) of the number and other.

Type Aliases

Complex32

Alias for a Complex<f32>

Complex64

Alias for a Complex<f64>