rithm 14.1.0

Description:

rithm 14.1.0

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
python -m pip install --upgrade pip setuptools

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

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

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

Install
python setup.py install

Usage
Python
Arbitrary precision integer
With setup
>>> from rithm.integer import Int

we can:

construct
>>> 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
>>> 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
>>> 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
>>> from rithm.fraction import Fraction

we can:

construct
>>> 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
>>> 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
>>> 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
/// 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 DIGIT_BITNESS: usize = (Digit::BITS - 1) as usize;
const _: () = assert!(big_int::is_valid_digit_bitness::<Digit, DIGIT_BITNESS>());
type BigInt = big_int::BigInt<Digit, DIGIT_BITNESS>;
/// we can:
/// - construct
assert_eq!(BigInt::zero(), 0);
assert_eq!(BigInt::from(9), 9);
assert_eq!(BigInt::try_from("9").unwrap(), 9);
assert_eq!(BigInt::try_from("0b1001").unwrap(), 9);
assert_eq!(BigInt::try_from("0o11").unwrap(), 9);
assert_eq!(BigInt::try_from("0x9").unwrap(), 9);
assert_eq!(BigInt::from_str_radix("1001", 2).unwrap(), 9);
assert_eq!(BigInt::from_str_radix("11", 8).unwrap(), 9);
assert_eq!(BigInt::from_str_radix("9", 16).unwrap(), 9);
assert_eq!(BigInt::try_from(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
assert_eq!(BigInt::from(-9).abs(), 9);
assert_eq!(BigInt::from(4) + BigInt::from(5), 9);
assert_eq!(BigInt::from(9) & BigInt::from(11), 9);
assert_eq!(BigInt::from(1) | BigInt::from(8), 9);
assert_eq!(BigInt::from(2) ^ BigInt::from(11), 9);
assert_eq!(BigInt::from(19) / BigInt::from(2), 9);
assert_eq!(BigInt::from(19).div_euclid(BigInt::from(2)), 9);
assert_eq!(BigInt::from(3) * BigInt::from(3), 9);
assert_eq!(-BigInt::from(-9), 9);
assert_eq!(!BigInt::from(-10), 9);
assert_eq!(BigInt::from(3).pow(BigInt::from(2)), 9);
assert_eq!(BigInt::from(19) % BigInt::from(10), 9);
assert_eq!(BigInt::from(19).rem_euclid(BigInt::from(10)), 9);
assert_eq!(BigInt::from(5) << 1, 10);
assert_eq!(BigInt::from(5) >> 1, 2);
assert_eq!(BigInt::from(25) - BigInt::from(16), 9);

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

type Fraction = fraction::Fraction<i8>;
/// we can:
/// - construct
assert_eq!(Fraction::zero(), 0);
assert_eq!(Fraction::one(), 1);
assert_eq!(Fraction::new(1, 2), Some(Fraction::from(1) / 2));
assert_eq!(Fraction::new(50, 100), Fraction::new(1, 2));
assert_eq!(Fraction::try_from(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
assert_eq!(Fraction::new(-1, 2).unwrap().abs(), Fraction::new(1, 2).unwrap());
assert_eq!(Fraction::new(1, 3).unwrap() + Fraction::new(1, 6).unwrap(),
Fraction::new(1, 2).unwrap());
assert_eq!(Fraction::new(1, 3).unwrap() / Fraction::new(2, 3).unwrap(),
Fraction::new(1, 2).unwrap());
assert_eq!(Fraction::new(3, 2).unwrap().div_euclid(Fraction::from(1)), 1);
assert_eq!(Fraction::new(1, 3).unwrap() * Fraction::new(3, 2).unwrap(),
Fraction::new(1, 2).unwrap());
assert_eq!(-Fraction::new(-1, 2).unwrap(), Fraction::new(1, 2).unwrap());
assert_eq!(Fraction::new(1, 2).unwrap().pow(2), Fraction::new(1, 4).unwrap());
assert_eq!(Fraction::new(3, 2).unwrap() % Fraction::from(1),
Fraction::new(1, 2).unwrap());
assert_eq!(Fraction::new(3, 2).unwrap().rem_euclid(Fraction::from(1)),
Fraction::new(1, 2).unwrap());
assert_eq!(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
bump2version --dry-run --verbose $CATEGORY

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

This will set version to major.minor.patch-alpha.
Release
Test bumping version
bump2version --dry-run --verbose release

Bump version
bump2version --verbose release

This will set version to major.minor.patch.
Running tests
Install dependencies
python -m pip install -r requirements-tests.txt

Plain
pytest

Inside Docker container:

with CPython
docker-compose --file docker-compose.cpython.yml up


with PyPy
docker-compose --file docker-compose.pypy.yml up



Bash script:


with CPython
./run-tests.sh

or
./run-tests.sh cpython



with PyPy
./run-tests.sh pypy



PowerShell script:

with CPython
.\run-tests.ps1

or
.\run-tests.ps1 cpython


with PyPy
.\run-tests.ps1 pypy