un_algebra 0.9.0

Simple implementations of selected abstract algebraic structures--including groups, rings, and fields. Intended for self-study of abstract algebra concepts and not for production use.
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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

//!
//! Numeric ordering tests.
//!
//! Traits and implementations of _numeric_ _ordering_--that is,
//! ordering with an "epsilon" or error term. Usually, this means
//! ordering of floating point values.
//!
use super::equal::*;
use crate::helpers::*;


///
/// Numeric ordering predicates.
///
pub trait NumOrd: PartialOrd + NumEq {

  /// Are two values _numerically_ ordered, within `eps`?
  fn num_lt(&self, other: &Self, eps: &Self::Eps) -> bool {
    self.num_ne(other, eps) && self < other
  }


  /// Are two values _numerically_ ordered or equal, within `eps`?
  fn num_le(&self, other: &Self, eps: &Self::Eps) -> bool {
    self.num_eq(other, eps) || self < other
  }


  /// Are two values _numerically_ un-ordered, within `eps`?
  fn num_gt(&self, other: &Self, eps: &Self::Eps) -> bool {
    self.num_ne(other, eps) && self > other
  }


  /// Are two values _numerically_ un-ordered or equal, within `eps`?
  fn num_ge(&self, other: &Self, eps: &Self::Eps) -> bool {
    self.num_eq(other, eps) || self > other
  }
}


///
/// Define `NumOrd` implementations for floating point types. Probably
/// not needed if Rust had a `Float` super-trait.
///
macro_rules! float_num_order {
  ($type:ty) => {
    impl NumOrd for $type {}
  };
}


// 32 and 64 bit IEEE floating point ordering.
float_num_order! {f32}
float_num_order! {f64}


///
/// Define `NumOrd` implementations for homogeneous tuple types (T,),
/// (T, T), etc.
///
macro_rules! tuple_num_order {
  ($tuple:ty) => {
    impl<T: NumOrd> NumOrd for $tuple {

      /// Numeric order is by matching element.
      fn num_gt(&self, other: &Self, eps: &Self::Eps) -> bool {
        self.all_with(other, &|x, y| x.num_gt(y, eps))
      }


      /// Numeric order-equality is by matching element.
      fn num_ge(&self, other: &Self, eps: &Self::Eps) -> bool {
        self.all_with(other, &|x, y| x.num_ge(y, eps))
      }


      /// Numeric un-order is by matching element.
      fn num_lt(&self, other: &Self, eps: &Self::Eps) -> bool {
        self.all_with(other, &|x, y| x.num_lt(y, eps))
      }


      /// Numeric un-order-equality is by matching element.
      fn num_le(&self, other: &Self, eps: &Self::Eps) -> bool {
        self.all_with(other, &|x, y| x.num_le(y, eps))
      }
    }
  };

  ($tuple:ty, $($others:ty),+) => {
    tuple_num_order! {$tuple}
    tuple_num_order! {$($others),+}
  };
}


// Tuple numeric ordering implementations.
tuple_num_order! {(T, ), (T, T), (T, T, T), (T, T, T, T)}


///
/// Define `NumOrd` implementations for arrays. This macro may not
/// needed if Rust had _const_ _generics_.
///
macro_rules! array_num_order {
  ($size:expr) => {
    impl<T: NumOrd + Copy> NumOrd for [T; $size] {

      /// Numeric order is by matching element.
      fn num_gt(&self, other: &Self, eps: &Self::Eps) -> bool {
        self.all_with(other, &|x, y| x.num_gt(y, eps))
      }


      /// Numeric order-equality is by matching element.
      fn num_ge(&self, other: &Self, eps: &Self::Eps) -> bool {
        self.all_with(other, &|x, y| x.num_ge(y, eps))
      }


      /// Numeric un-order is by matching element.
      fn num_lt(&self, other: &Self, eps: &Self::Eps) -> bool {
        self.all_with(other, &|x, y| x.num_lt(y, eps))
      }


      /// Numeric un-order-equality is by matching element.
      fn num_le(&self, other: &Self, eps: &Self::Eps) -> bool {
        self.all_with(other, &|x, y| x.num_le(y, eps))
      }
    }
  };

  ($size:expr, $($others:expr),+) => {
    array_num_order! {$size}
    array_num_order! {$($others),+}
  };
}


// Array numeric ordering implementations.
array_num_order! {
  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16
}