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

//!
//! Commutative rings.
//!
//! An algebraic _commutative_ _ring_ `R`, is a _ring_ (formally a
//! _ring_ _with_ _identity_) where the _multiplication_ operation `×`
//! is _commutative_.
//!
//! # Axioms
//!
//! ```text
//! ∀g, h ∈ R
//!
//! Commutivity: g × h = h × g.
//! ```
//!
//! # References
//!
//! See [references] for a formal definition of a commutative ring.
//!
#![doc(include = "../../doc/references.md")]

use crate::ring::*;
use crate::numeric::*;


///
/// An algebraic _commutative ring_.
///
pub trait ComRing: Ring {}


///
/// Laws of commutative rings.
///
pub trait ComRingLaws: ComRing {

  /// The axiom of _multiplicative_ _commutivity_.
  fn commutivity(&self, x: &Self) -> bool {
    self.mul(x) == x.mul(self)
  }
}


///
/// Blanket implementation of commutative ring laws for commutative ring
/// implementations.
///
impl<R: ComRing> ComRingLaws for R {}


///
/// Numeric laws of commutative rings.
///
pub trait NumComRingLaws: NumEq + ComRing {

  /// The numeric axiom of _multiplicative_ _commutivity_.
  fn num_commutivity(&self, x: &Self, eps: &Self::Eps) -> bool {
    self.mul(x).num_eq(&x.mul(self), eps)
  }
}


///
/// Blanket implementation of numeric commutative ring laws for
/// commutative ring implementations.
///
impl<R: NumEq + ComRing> NumComRingLaws for R {}


///
/// Define `ComRing` implementations for numeric types.
///
macro_rules! numeric_com_ring {
  ($type:ty) => {
    impl ComRing for $type {}
  };

  ($type:ty, $($others:ty),+) => {
    numeric_com_ring! {$type}
    numeric_com_ring! {$($others),+}
  };
}


// Only signed integer and float types form a commutative ring.
numeric_com_ring! {
  i8, i16, i32, i64, i128, isize, f32, f64
}


///
/// 0-tuples form a commutative ring.
///
impl ComRing for () {}


///
/// 1-tuples form a commutative ring when their items do.
///
impl<A: ComRing> ComRing for (A,) {}


///
/// 2-tuples form a commutative ring when their items do.
///
impl<A: ComRing, B: ComRing> ComRing for (A, B) {}


///
/// 3-tuples form a commutative ring when their items do.
///
impl<A: ComRing, B: ComRing, C: ComRing> ComRing for (A, B, C) {}


///
/// Define `ComRing` implementations for arrays. Maybe not needed if
/// Rust had _const_ _generics_.
///
macro_rules! array_com_ring {
  ($size:expr) => {
    impl<T: Copy + ComRing> ComRing for [T; $size] {}
  };

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


// Array commutative ring types.
array_com_ring! {
  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16
}


// Module unit tests are in a sub-module.
#[cfg(test)]
mod tests;