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

//
// # Example: The game of _rock_, _paper_, _scissors_.
//
// The values {`R`,`P`, `S`} representing the choices in a game of rock,
// paper, scissors [RPS] form a _magma_. In this game plays are
// commutative, but _not_ associative, so they do not form a semigroup
// or other derived algebraic structure.
//
// [RPS]: https://en.wikipedia.org/wiki/Commutative_magma
//
#![allow(non_snake_case)]

use proptest_derive::*;
use un_algebra::tests::*;
use un_algebra::prelude::*;


//
// The game choices in rock, paper, scissors.
//
#[derive(Copy, Clone, PartialEq, Debug, Arbitrary)]
pub enum RPS {
  R, P, S
}


//
// Rock, paper, scissors choices form a magma.
//
impl Magma for RPS {

  // Magma operation as per the game rules.
  fn op(&self, other: &Self) -> Self {

    // Redundant branch expressions used for clarity.
    match (self, other) {
      (RPS::R, RPS::R) => RPS::R,
      (RPS::R, RPS::P) => RPS::P,
      (RPS::R, RPS::S) => RPS::R,
      (RPS::P, RPS::R) => RPS::P,
      (RPS::P, RPS::P) => RPS::P,
      (RPS::P, RPS::S) => RPS::S,
      (RPS::S, RPS::R) => RPS::R,
      (RPS::S, RPS::P) => RPS::S,
      (RPS::S, RPS::S) => RPS::S
    }
  }
}


//
// Generative tests of rock, paper, scissors algebraic axioms.
//
proptest! {
  #![proptest_config(config::standard())]


  #[test]
  fn closure((x, y) in any::<(RPS, RPS)>()) {
    prop_assert!(MagmaLaws::closure(&x, &y))
  }


  #[test]
  fn closure_t2([xs, ys] in any::<[(RPS, RPS); 2]>()) {
    prop_assert!(MagmaLaws::closure(&xs, &ys))
  }


  #[test]
  fn closure_a2([xs, ys] in any::<[[RPS; 2]; 2]>()) {
    prop_assert!(MagmaLaws::closure(&xs, &ys))
  }


  #[test]
  fn commutivity((x, y) in any::<(RPS, RPS)>()) {
    prop_assert!(x.op(&y) == y.op(&x))
  }


  #[test]
  fn commutivity_t1((x, y) in any::<(RPS, RPS)>()) {
    prop_assert!((x,).op(&(y,)) == (y,).op(&(x,)))
  }


  #[test]
  fn commutivity_a1((x, y) in any::<(RPS, RPS)>()) {
    prop_assert!([x].op(&[y]) == [y].op(&[x]))
  }
}


fn main() {
}