rithm

In what follows python is an alias for python3.8 or pypy3.8 or any later version (python3.9, pypy3.9 and so on).

Installation

Install the latest pip & setuptools packages versions bash python -m pip install --upgrade pip setuptools

User

Download and install the latest stable version from PyPI repository bash python -m pip install --upgrade rithm

Developer

Download the latest version from GitHub repository bash git clone https://github.com/lycantropos/rithm.git cd rithm

Install dependencies bash python -m pip install -r requirements.txt

Install bash python setup.py install

Usage

Python

Arbitrary precision integer

With setup ```python

from rithm.integer import Int

we can: - construct python

Int() Int(0) Int(9) Int(9) Int('9') Int(9) Int('0b1001', 2) Int(9) Int('0o11', 8) Int(9) Int('0x9', 16) Int(9) Int('1001', 2) Int(9) Int('0o11', 8) Int(9) Int('9', 16) Int(9) Int(9.99) Int(9)

- compare python

Int(9) == Int(9) True Int(9) >= Int(9) True Int(9) > Int(8) True Int(9) <= Int(9) True Int(9) < Int(10) True

- calculate python

abs(Int(-9)) Int(9) Int(4) + Int(5) Int(9) Int(9) & Int(11) Int(9) Int(19) // Int(2) Int(9) ~Int(-10) Int(9) Int(19) % Int(10) Int(9) Int(3) * Int(3) Int(9) -Int(-9) Int(9) Int(1) | Int(8) Int(9) Int(3) ** Int(2) Int(9) Int(5) << Int(1) Int(10) Int(5) >> Int(1) Int(2) Int(25) - Int(16) Int(9) Int(18) / Int(2) Fraction(Int(9), Int(1)) Int(2) ^ Int(11) Int(9)

```

Exact fraction

With setup ```python

from rithm.fraction import Fraction

we can: - construct python

Fraction() Fraction(Int(0), Int(1)) Fraction(1) Fraction(Int(1), Int(1)) Fraction(1, 2) Fraction(Int(1), Int(2)) Fraction(50, 100) Fraction(Int(1), Int(2)) Fraction(0.5) Fraction(Int(1), Int(2))

- compare python

Fraction(1, 2) == Fraction(1, 2) True Fraction(1, 2) >= Fraction(1, 2) True Fraction(1, 2) > Fraction(1, 3) True Fraction(1, 2) < Fraction(2, 3) True Fraction(1, 2) != Fraction(1, 3) True

- calculate python

abs(Fraction(-1, 2)) Fraction(Int(1), Int(2)) Fraction(1, 3) + Fraction(1, 6) Fraction(Int(1), Int(2)) Fraction(3, 2) // Fraction(1) Int(1) Fraction(3, 2) % Fraction(1) Fraction(Int(1), Int(2)) Fraction(1, 3) * Fraction(3, 2) Fraction(Int(1), Int(2)) -Fraction(-1, 2) Fraction(Int(1), Int(2)) Fraction(1, 2) ** 2 Fraction(Int(1), Int(4)) Fraction(3, 2) - Fraction(1) Fraction(Int(1), Int(2)) Fraction(1, 3) / Fraction(2, 3) Fraction(Int(1), Int(2))

```

Rust

Arbitrary precision integer

```rust /// With setup use std::convert::TryFrom; use traiter::numbers::{ Abs, DivEuclid, FromStrRadix, Pow, RemEuclid, Zero }; use rithm::big_int;

[cfg(target_arch = "x86")]

type Digit = u16;

[cfg(not(target_arch = "x86"))]

type Digit = u32; const DIGITBITNESS: usize = (Digit::BITS - 1) as usize; const _: () = assert!(bigint::isvaliddigitbitness::()); type BigInt = bigint::BigInt; /// we can: /// - construct asserteq!(BigInt::zero(), 0); asserteq!(BigInt::from(9), 9); asserteq!(BigInt::tryfrom("9").unwrap(), 9); asserteq!(BigInt::tryfrom("0b1001").unwrap(), 9); asserteq!(BigInt::tryfrom("0o11").unwrap(), 9); asserteq!(BigInt::tryfrom("0x9").unwrap(), 9); asserteq!(BigInt::fromstrradix("1001", 2).unwrap(), 9); asserteq!(BigInt::fromstrradix("11", 8).unwrap(), 9); asserteq!(BigInt::fromstrradix("9", 16).unwrap(), 9); asserteq!(BigInt::tryfrom(9.99).unwrap(), 9); /// - compare assert!(BigInt::from(9) == BigInt::from(9)); assert!(BigInt::from(9) >= BigInt::from(9)); assert!(BigInt::from(9) > BigInt::from(8)); assert!(BigInt::from(9) <= BigInt::from(9)); assert!(BigInt::from(9) < BigInt::from(10)); /// - calculate asserteq!(BigInt::from(-9).abs(), 9); asserteq!(BigInt::from(4) + BigInt::from(5), 9); asserteq!(BigInt::from(9) & BigInt::from(11), 9); asserteq!(BigInt::from(1) | BigInt::from(8), 9); asserteq!(BigInt::from(2) ^ BigInt::from(11), 9); asserteq!(BigInt::from(19) / BigInt::from(2), 9); asserteq!(BigInt::from(19).diveuclid(BigInt::from(2)), 9); asserteq!(BigInt::from(3) * BigInt::from(3), 9); asserteq!(-BigInt::from(-9), 9); asserteq!(!BigInt::from(-10), 9); asserteq!(BigInt::from(3).pow(BigInt::from(2)), 9); asserteq!(BigInt::from(19) % BigInt::from(10), 9); asserteq!(BigInt::from(19).remeuclid(BigInt::from(10)), 9); asserteq!(BigInt::from(5) << 1, 10); asserteq!(BigInt::from(5) >> 1, 2); assert_eq!(BigInt::from(25) - BigInt::from(16), 9); ```

Exact fraction

```rust /// With setup use std::convert::TryFrom; use traiter::numbers::{Abs, DivEuclid, One, Pow, RemEuclid, Zero}; use rithm::fraction;

type Fraction = fraction::Fraction; /// we can: /// - construct asserteq!(Fraction::zero(), 0); asserteq!(Fraction::one(), 1); asserteq!(Fraction::new(1, 2), Some(Fraction::from(1) / 2)); asserteq!(Fraction::new(50, 100), Fraction::new(1, 2)); asserteq!(Fraction::tryfrom(0.5).unwrap(), Fraction::new(1, 2).unwrap()); /// - compare assert!(Fraction::new(1, 2).unwrap() == Fraction::new(1, 2).unwrap()); assert!(Fraction::new(1, 2).unwrap() >= Fraction::new(1, 2).unwrap()); assert!(Fraction::new(1, 2).unwrap() > Fraction::new(1, 3).unwrap()); assert!(Fraction::new(1, 2).unwrap() <= Fraction::new(1, 2).unwrap()); assert!(Fraction::new(1, 2).unwrap() < Fraction::new(2, 3).unwrap()); assert!(Fraction::new(1, 2).unwrap() != Fraction::new(1, 3).unwrap()); /// - calculate asserteq!(Fraction::new(-1, 2).unwrap().abs(), Fraction::new(1, 2).unwrap()); asserteq!(Fraction::new(1, 3).unwrap() + Fraction::new(1, 6).unwrap(), Fraction::new(1, 2).unwrap()); asserteq!(Fraction::new(1, 3).unwrap() / Fraction::new(2, 3).unwrap(), Fraction::new(1, 2).unwrap()); asserteq!(Fraction::new(3, 2).unwrap().diveuclid(Fraction::from(1)), 1); asserteq!(Fraction::new(1, 3).unwrap() * Fraction::new(3, 2).unwrap(), Fraction::new(1, 2).unwrap()); asserteq!(-Fraction::new(-1, 2).unwrap(), Fraction::new(1, 2).unwrap()); asserteq!(Fraction::new(1, 2).unwrap().pow(2), Fraction::new(1, 4).unwrap()); asserteq!(Fraction::new(3, 2).unwrap() % Fraction::from(1), Fraction::new(1, 2).unwrap()); asserteq!(Fraction::new(3, 2).unwrap().remeuclid(Fraction::from(1)), Fraction::new(1, 2).unwrap()); asserteq!(Fraction::new(3, 2).unwrap() - Fraction::from(1), Fraction::new(1, 2).unwrap()); ```

Development

Bumping version

Preparation

Install bump2version.

Pre-release

Choose which version number category to bump following semver specification.

Test bumping version bash bump2version --dry-run --verbose $CATEGORY

where $CATEGORY is the target version number category name, possible values are patch/minor/major.

Bump version bash bump2version --verbose $CATEGORY

This will set version to major.minor.patch-alpha.

Release

Test bumping version bash bump2version --dry-run --verbose release

Bump version bash bump2version --verbose release

This will set version to major.minor.patch.

Running tests

Install dependencies bash python -m pip install -r requirements-tests.txt

Plain bash pytest

Inside Docker container: - with CPython bash docker-compose --file docker-compose.cpython.yml up - with PyPy bash docker-compose --file docker-compose.pypy.yml up

Bash script: - with CPython bash ./run-tests.sh or bash ./run-tests.sh cpython

• with PyPy bash ./run-tests.sh pypy

PowerShell script: - with CPython powershell .\run-tests.ps1 or powershell .\run-tests.ps1 cpython - with PyPy powershell .\run-tests.ps1 pypy