karpal-algebra 0.6.1

Abstract algebra structures for the Industrial Algebra ecosystem
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
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

# karpal-algebra

Abstract algebra structures for Rust: Group, Ring, Field, Lattice, Module,
and VectorSpace.

## What's inside

### Trait hierarchy

```
Semigroup (karpal-core)         Semiring (independent)      Lattice (independent)
  |                               |                           |
Monoid (karpal-core)            Ring                        BoundedLattice
  |                               |
Group                           Field
  |
AbelianGroup (marker)           Module<R: Ring>: AbelianGroup
                                  |
                                VectorSpace<F: Field>
```

### Group hierarchy

| Trait | Extends | Key method | Instances |
|-------|---------|-----------|-----------|
| `Group` | `Monoid` | `invert(self) -> Self` | signed integers, f32, f64, (A, B) |
| `AbelianGroup` | `Group` | marker trait | all Group types |

### Semiring / Ring / Field

| Trait | Extends | Key methods | Instances |
|-------|---------|------------|-----------|
| `Semiring` | (independent) | `zero`, `one`, `add`, `mul` | all numerics, bool |
| `Ring` | `Semiring` | `negate`, `sub` | signed integers, f32, f64 |
| `Field` | `Ring` | `reciprocal`, `div` | f32, f64 |

### Lattice

| Trait | Extends | Key methods | Instances |
|-------|---------|------------|-----------|
| `Lattice` | (independent) | `join`, `meet` | all integers, bool, f32, f64 |
| `BoundedLattice` | `Lattice` | `top`, `bottom` | all integers, bool |

### Module / VectorSpace

| Trait | Extends | Key method | Instances |
|-------|---------|-----------|-----------|
| `Module<R: Ring>` | `AbelianGroup` | `scale(self, R) -> Self` | f32, f64, (F, F) |
| `VectorSpace<F: Field>` | `Module<F>` | marker trait | f32, f64, (F, F) |

### Example: Group and Ring

```rust
use karpal_algebra::{Group, Ring, Semiring};
use karpal_core::{Semigroup, Monoid};

// Group: every element has an inverse
assert_eq!(5i32.invert(), -5);
assert_eq!(5i32.combine(5i32.invert()), 0);
assert_eq!(10i32.combine_inverse(3), 7);

// Ring: two operations with additive inverse
assert_eq!(5i32.negate(), -5);
assert_eq!(10i32.sub(3), 7);
```

### Example: VectorSpace

```rust
use karpal_algebra::{VectorSpace, Module, Semiring};
use karpal_core::Semigroup;

// 2D vectors as a vector space
let e1 = (1.0f64, 0.0);
let e2 = (0.0f64, 1.0);
let v = e1.scale(3.0).combine(e2.scale(4.0));
assert!((v.0 - 3.0).abs() < 1e-10);
assert!((v.1 - 4.0).abs() < 1e-10);
```

### Newtype wrappers (in karpal-core)

Select alternative Semigroup/Monoid instances:

| Wrapper | Semigroup | Monoid `empty()` |
|---------|-----------|-----------------|
| `Sum<T>` | `+` | `Sum(0)` |
| `Product<T>` | `*` | `Product(1)` |
| `Min<T>` | `min` | `Min(T::MAX)` |
| `Max<T>` | `max` | `Max(T::MIN)` |
| `First<Option<T>>` | first `Some` | `First(None)` |
| `Last<Option<T>>` | last `Some` | `Last(None)` |

```rust
use karpal_core::{Sum, Product, Semigroup, Monoid, Foldable};
use karpal_core::hkt::VecF;

let product = VecF::fold_map(vec![1, 2, 3, 4], |x| Product(x));
assert_eq!(product, Product(24));
```

## Features

| Feature | Default | Description |
|---------|---------|-------------|
| `std`   | yes     | Implies `alloc` |
| `alloc` | no      | Enables `alloc`-gated features |

All traits are `no_std` compatible with no feature gates.

## License

Apache-2.0