wheel 0.1.0

Wheel algebra library for Rust
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

#![cfg_attr(not(test), no_std)]
//! # Wheel
//! Wheel algebra library for Rust 
//! 
//! ```
//! use wheel::*;
//! 
//! let inf = w64::ONE / w64::ZERO;
//! assert_eq!(inf, w64::INFINITY);
//! ```

pub mod fraction;
pub mod float;

pub use fraction::FractionWheel;
pub use fraction::FractionWheel8;
pub use fraction::FractionWheel16;
pub use fraction::FractionWheel32;
pub use fraction::FractionWheel64;
pub use fraction::FractionWheel128;
pub use fraction::qw8;
pub use fraction::qw16;
pub use fraction::qw32;
pub use fraction::qw64;
pub use fraction::qw128;

pub use float::Wheel32;
pub use float::Wheel64;
pub use float::w32;
pub use float::w64;

/// Wheel is an algebraic structure where division is always defined.
/// Division is not necesarily the same as the multiplicative inverse.
/// Eq is always defined, but PartialOrd is not.
pub trait Wheel: PartialEq + Eq + Sized {
    /// Additive identity. There is no signed zero.
    const ZERO: Self;

    /// Multiplicative identity.
    const ONE: Self;

    /// Infinity is always unsigned.
    const INFINITY: Self;

    /// Bottom is a special value that represents an undefined value.
    /// But it is a number, so it can be used in calculations.
    const BOTTOM: Self;

    /// Normal addition.
    fn add(&self, other: &Self) -> Self;

    /// Normal negation.
    fn neg(&self) -> Self;

    /// Defined as `self + other.neg()`.
    /// `x - x` is not always zero.
    fn sub(&self, other: &Self) -> Self {
        self.add(&other.neg())
    }

    /// `0 * x` is not always zero.
    fn mul(&self, other: &Self) -> Self;

    /// Always defined. Not the same as the multiplicative inverse.
    fn inv(&self) -> Self;

    /// Always defined as `self * other.inv()`.
    /// `x / x` is not always one
    fn div(&self, other: &Self) -> Self {
        self.mul(&other.inv())
    }
}