Skip to content
algebraic numbers implemented in rust; mirror of https://salsa.debian.org/Kazan-team/algebraics
Rust
Branch: master
Clone or download
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
src make doctests in readme run Sep 19, 2019
.gitignore initial commit Jul 16, 2019
Cargo.toml add readme Sep 19, 2019
LICENSE.md add license Jul 19, 2019
Notices.txt add license Jul 19, 2019
README.md add big number example Sep 19, 2019

README.md

Algebraic Numbers Library

Use when you need exact arithmetic, speed is not critical, and rational numbers aren't good enough.

Example:

use algebraics::prelude::*;
use algebraics::RealAlgebraicNumber as Number;

let two = Number::from(2);

// 2 is a rational number
assert!(two.is_rational());

// 1/2 is the reciprocal of 2
let one_half = two.recip();

// 1/2 is also a rational number
assert!(one_half.is_rational());

// 2^(1/4)
let root = (&two).pow((1, 4));

// we can use all the standard comparison operators
assert!(root != Number::from(3));
assert!(root < Number::from(2));
assert!(root > Number::from(1));

// we can use all of add, subtract, multiply, divide, and remainder
let sum = &root + &root;
let difference = &root - Number::from(47);
let product = &root * &one_half;
let quotient = &one_half / &root;
let remainder = &root % &one_half;

// root is not a rational number
assert!(!root.is_rational());

// the calculations are always exact
assert_eq!((&root).pow(4), two);

// lets compute 30 decimal places of root
let scale = Number::from(10).pow(30);
let scaled = &root * scale;
let digits = scaled.into_integer_trunc();
assert_eq!(
    digits.to_string(),
    1_18920_71150_02721_06671_74999_70560u128.to_string()
);

// get the minimal polynomial
let other_number = root + two.pow((1, 2));
assert_eq!(
    &other_number.minimal_polynomial().to_string(),
    "2 + -8*X + -4*X^2 + 0*X^3 + 1*X^4"
);

// works with really big numbers
let really_big = Number::from(1_00000_00000i64).pow(20) + Number::from(23);
assert_eq!(
    &really_big.to_integer_floor().to_string(),
    "100000000000000000000000000000000000000000000\
     000000000000000000000000000000000000000000000\
     000000000000000000000000000000000000000000000\
     000000000000000000000000000000000000000000000\
     000000000000000000023"
)
You can’t perform that action at this time.