Enum Number 

pub enum Number {
    Integer(i64),
    Float(f64),
    BigInteger(Box<BigInt>),
    Rational(Box<Ratio<BigInt>>),
}

Unified number type supporting integers, rationals, and floats

Variants

Integer(i64)

Float(f64)

BigInteger(Box<BigInt>)

Rational(Box<Ratio<BigInt>>)

Implementations

impl Number

pub fn pow(&self, exponent: &Number) -> Result<Number, MathError>

Power operation with overflow checking

Computes self raised to the power of exponent. For integer bases and positive integer exponents, uses checked arithmetic with promotion to BigInt on overflow. For other cases, converts to float and checks for infinity/NaN.

Arguments

• exponent - The exponent to raise self to

Examples

use mathhook_core::Number;

let base = Number::integer(2);
let exp = Number::integer(3);
let result = base.pow(&exp).unwrap();
assert_eq!(result, Number::integer(8));

Errors

Returns MathError::NumericOverflow if:

• Float power results in infinity or NaN
• Exponentiation produces non-representable result

impl Number

pub fn integer(value: i64) -> Number

Create an integer number

Examples

use mathhook_core::Number;

let num = Number::integer(42);

pub fn float(value: f64) -> Number

Create a float number

Examples

use mathhook_core::Number;

let num = Number::float(3.14);

pub fn rational(value: Ratio<BigInt>) -> Number

Create a rational number

Examples

use mathhook_core::Number;
use num_rational::BigRational;
use num_bigint::BigInt;

let rational = BigRational::new(BigInt::from(3), BigInt::from(4));
let num = Number::rational(rational);

pub fn is_zero(&self) -> bool

Check if the number is zero

Examples

use mathhook_core::Number;

let zero = Number::integer(0);
assert!(zero.is_zero());

pub fn is_one(&self) -> bool

Check if the number is one

Examples

use mathhook_core::Number;

let one = Number::integer(1);
assert!(one.is_one());

pub fn is_negative_one(&self) -> bool

Check if the number is negative one

Examples

use mathhook_core::Number;

let neg_one = Number::integer(-1);
assert!(neg_one.is_negative_one());

Trait Implementations

impl Add for Number

Addition with overflow checking and promotion to BigInt

Examples

use mathhook_core::Number;

let a = Number::integer(5);
let b = Number::integer(3);
let result = (a + b).unwrap();
assert_eq!(result, Number::integer(8));

type Output = Result<Number, MathError>

The resulting type after applying the + operator.

fn add(self, other: Number) -> Result<Number, MathError>

Performs the + operation.

impl Clone for Number

fn clone(&self) -> Number

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Number

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Number

fn deserialize<__D>( __deserializer: __D, ) -> Result<Number, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Number

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Div for Number

Division with division by zero check and automatic promotion to rational

Examples

use mathhook_core::Number;

let a = Number::integer(10);
let b = Number::integer(2);
let result = (a / b).unwrap();
assert_eq!(result, Number::integer(5));

type Output = Result<Number, MathError>

The resulting type after applying the / operator.

fn div(self, other: Number) -> Result<Number, MathError>

Performs the / operation.

impl From<f64> for Number

fn from(value: f64) -> Number

Converts to this type from the input type.

impl From<i32> for Number

fn from(value: i32) -> Number

Converts to this type from the input type.

impl From<i64> for Number

fn from(value: i64) -> Number

Converts to this type from the input type.

impl Mul for Number

Multiplication with overflow checking and promotion to BigInt

Examples

use mathhook_core::Number;

let a = Number::integer(6);
let b = Number::integer(7);
let result = (a * b).unwrap();
assert_eq!(result, Number::integer(42));

type Output = Result<Number, MathError>

The resulting type after applying the * operator.

fn mul(self, other: Number) -> Result<Number, MathError>

Performs the * operation.

impl Neg for Number

Negation with overflow checking

Examples

use mathhook_core::Number;

let a = Number::integer(5);
let result = (-a).unwrap();
assert_eq!(result, Number::integer(-5));

type Output = Result<Number, MathError>

The resulting type after applying the - operator.

fn neg(self) -> Result<Number, MathError>

Performs the unary - operation.

impl PartialEq for Number

fn eq(&self, other: &Number) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Number

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Sub for Number

Subtraction with overflow checking and promotion to BigInt

Examples

use mathhook_core::Number;

let a = Number::integer(10);
let b = Number::integer(3);
let result = (a - b).unwrap();
assert_eq!(result, Number::integer(7));

type Output = Result<Number, MathError>

The resulting type after applying the - operator.

fn sub(self, other: Number) -> Result<Number, MathError>

Performs the - operation.

impl StructuralPartialEq for Number