oxinum-rational 0.1.3

Exact rational numbers for OxiNum (RBig via dashu-ratio)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

//! Core trait implementations for [`BigRational`]:
//! [`OxiNum`], [`OxiSigned`], and [`Pow<u32>`].

use oxinum_core::{OxiNum, OxiSigned, Pow, Sign};
use oxinum_int::native::{BigInt, BigUint};

use super::rational::BigRational;

// ---------------------------------------------------------------------------
// OxiNum
// ---------------------------------------------------------------------------

impl OxiNum for BigRational {
    #[inline]
    fn is_zero(&self) -> bool {
        BigRational::is_zero(self)
    }

    #[inline]
    fn is_one(&self) -> bool {
        BigRational::is_one(self)
    }
}

// ---------------------------------------------------------------------------
// OxiSigned
// ---------------------------------------------------------------------------

impl OxiSigned for BigRational {
    /// Returns the sign of this rational number.
    ///
    /// For zero, returns `Sign::Positive` (canonical convention matching
    /// `BigInt::signum`).
    #[inline]
    fn signum(&self) -> Sign {
        // BigInt::signum() returns Sign directly; zero is Sign::Positive
        // by canonical-zero invariant. The numerator carries the sign.
        self.num.signum()
    }

    #[inline]
    fn abs(&self) -> Self {
        BigRational::abs(self)
    }
}

// ---------------------------------------------------------------------------
// Pow<u32>
// ---------------------------------------------------------------------------

/// Compute `num^exp` for a `BigInt` value.
///
/// Uses the `BigUint::pow` method on the magnitude, then reattaches the
/// sign: negative base raised to an odd exponent stays negative, even
/// exponent is positive.
fn bigint_pow(base: &BigInt, exp: u32) -> BigInt {
    if exp == 0 {
        return BigInt::one();
    }
    let mag_pow = base.magnitude().pow(exp);
    // If exp is odd and base is negative, result is negative.
    if base.sign() == Sign::Negative && exp % 2 == 1 {
        BigInt::from_parts(Sign::Negative, mag_pow)
    } else {
        BigInt::from_parts(Sign::Positive, mag_pow)
    }
}

/// Compute `(num/den)^exp` returning a reduced `BigRational`.
fn rational_pow_u32(r: &BigRational, exp: u32) -> BigRational {
    if exp == 0 {
        return BigRational::one();
    }
    let num_pow: BigInt = bigint_pow(&r.num, exp);
    let den_pow: BigUint = r.den.pow(exp);
    BigRational::from_parts(num_pow, den_pow)
        .expect("rational pow: denominator is always non-zero after exponentiation")
}

impl Pow<u32> for BigRational {
    type Output = BigRational;

    #[inline]
    fn pow(&self, exp: u32) -> BigRational {
        rational_pow_u32(self, exp)
    }
}