#numerics #mathematics #abstract-algebra

nightly un_algebra

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.

11 unstable releases (3 breaking)

✓ Uses Rust 2018 edition

0.4.0 Jan 31, 2019
0.3.0 Jan 17, 2019
0.2.2 Jan 3, 2019
0.2.1 Dec 22, 2018
0.1.0 Jul 16, 2018

#43 in Math

Download history 22/week @ 2018-11-18 26/week @ 2018-11-25 14/week @ 2018-12-02 33/week @ 2018-12-09 16/week @ 2018-12-16 112/week @ 2018-12-23 16/week @ 2018-12-30 26/week @ 2019-01-06 27/week @ 2019-01-13 3/week @ 2019-01-20 9/week @ 2019-01-27 3/week @ 2019-02-03 3/week @ 2019-02-24

95 downloads per month

MIT license

152KB
3K SLoC

un_algebra

crate link documentation rustc version license

Simple Rust implementations of selected abstract algebraic structures.

Synopsis

Mathematical abstract algebra is built on a rich collection of algebraic structures. Learning about these structures can give non-mathematicians insights into the mathematical entities they need to work with--for example, real numbers, complex numbers, vectors, matrices, and permutations. By definition, these structures must comply with sets of axioms and properties, which are in turn a rich source of properties for generative testing.

un_algebra (_un_derstanding _algebra_) is a simple implementation of selected algebraic structures in Rust. I hope it is useful for developers learning abstract algebra concepts for the first time. Currently this crate provides magma, semigroup, quasigroup, monoid, group, ring and field implementations.

Documentation

See https://docs.rs/un_algebra

Contributions

Please refer to the contributing guide.

Installation

Add un_algebra to your Cargo.toml dependencies:

[dependencies]
un_algebra = "0.4.0"

Production use

un_algebra is intended to support self-study of abstract algebraic structures--it is not optimized for use in a production environment. For production environments I recommend using a more sophisticated library like alga.

Compatibility

un_algebra uses 2018 edition features but unfortunately requires Rust nightly as it uses the (experimental) external documentation feature.

Errors

I'm not a mathematician so my implementation of the various structures and their respective axioms in un_algebra may not be strictly correct. Please let me know of any errors.

Examples

un_algebra implements the relevant structure traits for all the Rust standard library integer and floating point types, for example, an additive group for integer types i8, i16, i32, etc.

The Rust standard library has no support for complex numbers (ℂ) or rational numbers (ℚ) so I've used the complex and rational types from the [num] crate and implemented examples using both these numeric types.

In addition, the crate examples directory contains abstract structure implementations of selected concepts, for example, finite fields.

Example

Rust's i128 type forms several un_algebra algebraic structures, starting with additive and multiplicative magmas (with "wrapping" or modular arithmetic):

use un_algebra::prelude::*;

impl AddMagma for i128 {
  fn add(&self, other: &Self) -> Self {
    self.wrapping_add(other)
  }
}

impl MulMagma for i128 {
  fn mul(&self, other: &Self) -> Self {
    self.wrapping_mul(other)
  }
}

i128 also forms additive and multiplicative semigroups:

impl AddSemigroup for i128 {}

impl MulSemigroup for i128 {}

And additive and multiplicative monoids with one and zero as the monoid identities:

impl AddMonoid for i128 {
  fn zero() -> Self {
    0
  }
}

impl MulMonoid for i128 {
  fn one() -> Self {
    1
  }
}

i128 also forms an additive group and additive commutative group (with "wrapping" or modular negation), but not a multiplicative group, as the integers have no closed division operation:

impl AddGroup for i128 {
  fn negate(&self) -> Self {
    self.wrapping_neg()
  }
}

impl AddComGroup for i128 {}

And a ring and commutative ring:

impl Ring for i128 {}

impl CommRing for i128 {}

References

Please refer to the reading document for more background on each structure and its associated axioms and properties.

To-Do

  • Some structures have up to five trait variants: abstract, additive, multiplicative and their numeric counterparts. Research techniques for reducing the number of these traits with some kind of trait "context" that can be abstract, additive, or multiplicative.

  • Should the numeric equality traits be factored out to a separate crate used by un_algebra?

License

This project is licensed under the MIT license (see LICENSE.txt or https://opensource.org/licenses/MIT).

Dependencies

~1.5MB
~30K SLoC