2315 lines
73 KiB
Rust
2315 lines
73 KiB
Rust
pub mod bigint {
|
|
|
|
use core::{
|
|
cmp::{Eq, Ord, Ordering, PartialOrd},
|
|
fmt::Debug,
|
|
ops::{Add, AddAssign, Div, Mul, Not, Rem, Shl, Shr, Sub, SubAssign},
|
|
};
|
|
|
|
use crate::lexer::Radix;
|
|
/// A base-4_294_967_295 number.
|
|
#[derive(Clone)]
|
|
pub struct BigInt(Vec<u32>);
|
|
|
|
impl BigInt {
|
|
pub fn parse_digits<C: IntoIterator<Item = char>>(text: C, radix: Radix) -> BigInt {
|
|
Self(parse_bigint(text.into_iter(), radix))
|
|
}
|
|
pub fn from_u32(v: u32) -> BigInt {
|
|
Self(vec![v])
|
|
}
|
|
pub fn from_u64(v: u64) -> BigInt {
|
|
let (lo, hi) = into_lo_hi(v);
|
|
Self(vec![lo, hi])
|
|
}
|
|
|
|
pub fn one() -> BigInt {
|
|
Self(vec![1])
|
|
}
|
|
pub fn zero() -> BigInt {
|
|
Self(vec![])
|
|
}
|
|
|
|
pub fn num_digits(&self) -> usize {
|
|
self.0.iter().rposition(|&d| d != 0).map_or(0, |i| i + 1)
|
|
}
|
|
|
|
pub fn bit_width(&self) -> usize {
|
|
count_bits(&self.0)
|
|
}
|
|
|
|
pub fn is_zero(&self) -> bool {
|
|
bigint_is_zero(&self.0)
|
|
}
|
|
|
|
pub fn is_one(&self) -> bool {
|
|
bigint_is_one(&self.0)
|
|
}
|
|
|
|
pub fn is_power_of_two(&self) -> bool {
|
|
is_power_of_two(&self.0)
|
|
}
|
|
|
|
pub fn trailing_zeros(&self) -> usize {
|
|
trailing_zeros(&self.0)
|
|
}
|
|
|
|
pub fn from_bytes_le(bytes: &[u8]) -> BigInt {
|
|
let data = bytes
|
|
.chunks(4)
|
|
.map(|chunk| {
|
|
let mut int = [0u8; 4];
|
|
int[..chunk.len()].copy_from_slice(chunk);
|
|
u32::from_le_bytes(int)
|
|
})
|
|
.collect::<Vec<_>>();
|
|
|
|
BigInt(data)
|
|
}
|
|
|
|
pub fn into_bytes_le(&self) -> Vec<u8> {
|
|
let mut bytes = Vec::<u8>::new();
|
|
|
|
for d in &self.0[..] {
|
|
bytes.extend(&d.to_le_bytes());
|
|
}
|
|
|
|
let count = bytes.iter().rev().take_while(|&&b| b == 0).count();
|
|
bytes.truncate(bytes.len() - count);
|
|
|
|
bytes
|
|
}
|
|
|
|
pub fn normalise(&mut self) {
|
|
let len = self.0.iter().rposition(|&d| d != 0).map_or(0, |i| i + 1);
|
|
self.0.truncate(len);
|
|
}
|
|
|
|
pub fn normalised(mut self) -> BigInt {
|
|
self.normalise();
|
|
self
|
|
}
|
|
|
|
pub fn into_u64(&self) -> Option<u64> {
|
|
if self.0.len() <= 2 {
|
|
let mut bytes = [0u8; 8];
|
|
self.0
|
|
.get(0)
|
|
.map(|&dw| bytes[..4].copy_from_slice(&dw.to_le_bytes()));
|
|
self.0
|
|
.get(1)
|
|
.map(|&dw| bytes[4..].copy_from_slice(&dw.to_le_bytes()));
|
|
Some(u64::from_le_bytes(bytes))
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
}
|
|
|
|
impl PartialEq for BigInt {
|
|
fn eq(&self, other: &Self) -> bool {
|
|
cmp_bigint(&self.0, &other.0) == Ordering::Equal
|
|
}
|
|
}
|
|
|
|
impl PartialEq<u32> for BigInt {
|
|
fn eq(&self, other: &u32) -> bool {
|
|
self.num_digits() == 1 && self.0[0] == *other
|
|
}
|
|
}
|
|
|
|
impl PartialEq<u64> for BigInt {
|
|
fn eq(&self, other: &u64) -> bool {
|
|
let (lo, hi) = into_lo_hi(*other);
|
|
cmp_bigint(&self.0, &[lo, hi]) == Ordering::Equal
|
|
}
|
|
}
|
|
|
|
impl PartialOrd<u32> for BigInt {
|
|
fn partial_cmp(&self, other: &u32) -> Option<Ordering> {
|
|
(self.num_digits() == 1).then(|| self.0[0].cmp(other))
|
|
}
|
|
}
|
|
|
|
impl PartialOrd<u64> for BigInt {
|
|
fn partial_cmp(&self, other: &u64) -> Option<Ordering> {
|
|
let (lo, hi) = into_lo_hi(*other);
|
|
Some(cmp_bigint(&self.0, &[lo, hi]))
|
|
}
|
|
}
|
|
|
|
impl Eq for BigInt {}
|
|
|
|
impl PartialOrd for BigInt {
|
|
fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
|
|
Some(cmp_bigint(&self.0, &other.0))
|
|
}
|
|
}
|
|
impl Ord for BigInt {
|
|
fn cmp(&self, other: &Self) -> std::cmp::Ordering {
|
|
cmp_bigint(&self.0, &other.0)
|
|
}
|
|
}
|
|
|
|
impl Shl<usize> for BigInt {
|
|
type Output = Self;
|
|
|
|
fn shl(mut self, rhs: usize) -> Self::Output {
|
|
shl_bitint(&mut self.0, rhs);
|
|
self
|
|
}
|
|
}
|
|
impl Shr<usize> for BigInt {
|
|
type Output = Self;
|
|
|
|
fn shr(mut self, rhs: usize) -> Self::Output {
|
|
shr_bitint(&mut self.0, rhs);
|
|
self
|
|
}
|
|
}
|
|
|
|
impl Add for BigInt {
|
|
type Output = Self;
|
|
|
|
fn add(mut self, mut rhs: Self) -> Self::Output {
|
|
let (mut digits, carry) = if self.0.len() > rhs.0.len() {
|
|
let c = add_bigint(&mut self.0, &rhs.0);
|
|
(self.0, c)
|
|
} else {
|
|
let c = add_bigint(&mut rhs.0, &self.0);
|
|
(rhs.0, c)
|
|
};
|
|
|
|
if carry {
|
|
digits.push(u32::from(carry));
|
|
}
|
|
|
|
BigInt(digits)
|
|
}
|
|
}
|
|
|
|
impl Add<u32> for BigInt {
|
|
type Output = Self;
|
|
|
|
fn add(mut self, rhs: u32) -> Self::Output {
|
|
self += rhs;
|
|
self
|
|
}
|
|
}
|
|
|
|
impl AddAssign<u32> for BigInt {
|
|
fn add_assign(&mut self, rhs: u32) {
|
|
let carry = add_bigint_scalar(&mut self.0, rhs);
|
|
if carry {
|
|
self.0.push(carry as u32);
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Add<u64> for BigInt {
|
|
type Output = Self;
|
|
|
|
fn add(mut self, rhs: u64) -> Self::Output {
|
|
self += rhs;
|
|
self
|
|
}
|
|
}
|
|
|
|
impl AddAssign<u64> for BigInt {
|
|
fn add_assign(&mut self, rhs: u64) {
|
|
let (lo, hi) = into_lo_hi(rhs);
|
|
if hi == 0 {
|
|
*self += lo;
|
|
} else {
|
|
while self.num_digits() < 2 {
|
|
self.0.push(0);
|
|
}
|
|
let carry = add_bigint(&mut self.0, &[lo, hi]);
|
|
if carry {
|
|
self.0.push(carry as u32);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Sub for BigInt {
|
|
type Output = Self;
|
|
|
|
fn sub(mut self, rhs: Self) -> Self::Output {
|
|
if self.0.len() < rhs.0.len() {
|
|
println!("extending self by {} zeroes", rhs.0.len() - self.0.len());
|
|
self.0
|
|
.extend(core::iter::repeat(0).take(rhs.0.len() - self.0.len()));
|
|
println!("self: {self:?}");
|
|
}
|
|
sub_bigint(&mut self.0, &rhs.0);
|
|
|
|
self
|
|
}
|
|
}
|
|
|
|
impl Sub<u32> for BigInt {
|
|
type Output = Self;
|
|
|
|
fn sub(mut self, rhs: u32) -> Self::Output {
|
|
self -= rhs;
|
|
self
|
|
}
|
|
}
|
|
|
|
impl Sub<BigInt> for u32 {
|
|
type Output = BigInt;
|
|
|
|
fn sub(self, mut rhs: BigInt) -> Self::Output {
|
|
if rhs.0.is_empty() {
|
|
rhs.0.push(self);
|
|
} else {
|
|
sub_bigint_in_right(&[self], &mut rhs.0);
|
|
}
|
|
rhs.normalised()
|
|
}
|
|
}
|
|
|
|
impl Sub<BigInt> for u64 {
|
|
type Output = BigInt;
|
|
|
|
fn sub(self, mut rhs: BigInt) -> Self::Output {
|
|
while rhs.num_digits() < 2 {
|
|
rhs.0.push(0);
|
|
}
|
|
|
|
let (lo, hi) = into_lo_hi(self);
|
|
sub_bigint_in_right(&[lo, hi], &mut rhs.0);
|
|
|
|
rhs.normalised()
|
|
}
|
|
}
|
|
|
|
impl SubAssign<u32> for BigInt {
|
|
fn sub_assign(&mut self, rhs: u32) {
|
|
sub_bigint_scalar(&mut self.0, rhs);
|
|
}
|
|
}
|
|
|
|
impl Sub<u64> for BigInt {
|
|
type Output = Self;
|
|
|
|
fn sub(mut self, rhs: u64) -> Self::Output {
|
|
self -= rhs;
|
|
self
|
|
}
|
|
}
|
|
|
|
impl SubAssign<u64> for BigInt {
|
|
fn sub_assign(&mut self, rhs: u64) {
|
|
let (lo, hi) = into_lo_hi(rhs);
|
|
while self.num_digits() < 2 {
|
|
self.0.push(0);
|
|
}
|
|
sub_bigint(&mut self.0, &[lo, hi]);
|
|
self.normalise();
|
|
}
|
|
}
|
|
|
|
impl Mul for BigInt {
|
|
type Output = Self;
|
|
|
|
fn mul(self, rhs: Self) -> Self::Output {
|
|
BigInt(mul_bigint(&self.0, &rhs.0))
|
|
}
|
|
}
|
|
|
|
impl Mul<u32> for BigInt {
|
|
type Output = Self;
|
|
|
|
fn mul(mut self, rhs: u32) -> Self::Output {
|
|
u32_mul_bigint(&mut self.0, rhs);
|
|
self
|
|
}
|
|
}
|
|
|
|
impl Mul<u64> for BigInt {
|
|
type Output = Self;
|
|
|
|
fn mul(self, rhs: u64) -> Self::Output {
|
|
let (lo, hi) = into_lo_hi(rhs);
|
|
BigInt(mul_bigint(&self.0, &[lo, hi]))
|
|
}
|
|
}
|
|
|
|
impl Div for BigInt {
|
|
type Output = Self;
|
|
|
|
fn div(self, rhs: Self) -> Self::Output {
|
|
div_rem_bigint(self, rhs).0
|
|
}
|
|
}
|
|
|
|
impl Div<u32> for BigInt {
|
|
type Output = Self;
|
|
|
|
fn div(self, rhs: u32) -> Self::Output {
|
|
div_digit_bigint(self, rhs).0
|
|
}
|
|
}
|
|
|
|
impl Div<u64> for BigInt {
|
|
type Output = Self;
|
|
|
|
fn div(self, rhs: u64) -> Self::Output {
|
|
let (lo, hi) = into_lo_hi(rhs);
|
|
div_rem_bigint(self, BigInt([lo, hi].to_vec())).0
|
|
}
|
|
}
|
|
|
|
impl Rem for BigInt {
|
|
type Output = Self;
|
|
|
|
fn rem(self, rhs: Self) -> Self::Output {
|
|
div_rem_bigint(self, rhs).1
|
|
}
|
|
}
|
|
|
|
impl Rem<u32> for BigInt {
|
|
type Output = Self;
|
|
|
|
fn rem(self, rhs: u32) -> Self::Output {
|
|
BigInt::zero() + div_digit_bigint(self, rhs).1
|
|
}
|
|
}
|
|
|
|
impl Rem<u64> for BigInt {
|
|
type Output = Self;
|
|
|
|
fn rem(self, rhs: u64) -> Self::Output {
|
|
let (lo, hi) = into_lo_hi(rhs);
|
|
div_rem_bigint(self, BigInt([lo, hi].to_vec())).1
|
|
}
|
|
}
|
|
|
|
impl Not for BigInt {
|
|
type Output = Self;
|
|
|
|
fn not(mut self) -> Self::Output {
|
|
self.0.iter_mut().for_each(|c| *c = !*c);
|
|
self
|
|
}
|
|
}
|
|
|
|
impl Debug for BigInt {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
|
|
let mut list = f.debug_list();
|
|
list.entries(self.0.iter().rev()).finish()
|
|
}
|
|
}
|
|
|
|
/// counts used bits in a u32 slice, discards leading zeros in MSB.
|
|
/// `[0xff,0xff,0x00,0x00]` -> 16
|
|
/// `[0xff,0xff,0x00]` -> 16
|
|
/// `[0xff,0xff,0x0f]` -> 20
|
|
pub fn count_bits(bytes: &[u32]) -> usize {
|
|
let mut bits = bytes.len() * u32::BITS as usize;
|
|
|
|
for &d in bytes.iter().rev() {
|
|
if d == 0 {
|
|
bits -= u32::BITS as usize;
|
|
} else {
|
|
bits -= d.leading_zeros() as usize;
|
|
break;
|
|
}
|
|
}
|
|
|
|
bits
|
|
}
|
|
|
|
#[test]
|
|
fn test_count_bits() {
|
|
assert_eq!(count_bits(&[0xffffffff, 0x00, 0x00]), 32);
|
|
assert_eq!(count_bits(&[0x00, 0x00, 0x00]), 0);
|
|
assert_eq!(count_bits(&[]), 0);
|
|
assert_eq!(count_bits(&[0xffffffff, 0xff, 0x00]), 40);
|
|
assert_eq!(count_bits(&[0xffffffff, 0xff]), 40);
|
|
assert_eq!(count_bits(&[0xffffffff, 0xff, 0xffff]), 64 + 16);
|
|
}
|
|
#[test]
|
|
fn test_count_trailing_zeros() {
|
|
assert_eq!(trailing_zeros(&[0xffffffff, 0x00, 0x00]), 0);
|
|
assert_eq!(trailing_zeros(&[0x00, 0x00, 0x00]), 0);
|
|
assert_eq!(trailing_zeros(&[]), 0);
|
|
assert_eq!(trailing_zeros(&[0x00, 0xffffffff, 0xff]), 32);
|
|
assert_eq!(trailing_zeros(&[0x00, 0xffffff00, 0xff]), 40);
|
|
}
|
|
|
|
#[allow(unused)]
|
|
/// lhs <=> rhs
|
|
fn cmp_bigint(lhs: &[u32], rhs: &[u32]) -> Ordering {
|
|
use core::cmp::Ordering;
|
|
let lhs_bits = count_bits(lhs);
|
|
let rhs_bits = count_bits(rhs);
|
|
|
|
match lhs_bits.cmp(&rhs_bits) {
|
|
Ordering::Less => Ordering::Less,
|
|
Ordering::Greater => Ordering::Greater,
|
|
Ordering::Equal => {
|
|
for (a, b) in lhs[..(lhs_bits / u32::BITS as usize)]
|
|
.iter()
|
|
.zip(rhs[..(lhs_bits / u32::BITS as usize)].iter())
|
|
.rev()
|
|
{
|
|
let ord = a.cmp(b);
|
|
if ord != Ordering::Equal {
|
|
return ord;
|
|
}
|
|
}
|
|
return Ordering::Equal;
|
|
}
|
|
}
|
|
}
|
|
|
|
fn bigint_is_zero(lhs: &[u32]) -> bool {
|
|
if lhs.len() == 0 {
|
|
true
|
|
} else {
|
|
lhs.iter().all(|c| c == &0)
|
|
}
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
fn bigint_is_one(lhs: &[u32]) -> bool {
|
|
lhs.len() > 0 && lhs[0] == 1 && lhs[1..].iter().all(|c| c == &0)
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
fn bitnot_bigint(lhs: &mut [u32]) {
|
|
for d in lhs.iter_mut() {
|
|
*d = !*d;
|
|
}
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
fn u32_mul_bigint(lhs: &mut Vec<u32>, scalar: u32) {
|
|
match scalar {
|
|
0 => {
|
|
lhs.clear();
|
|
lhs.push(0)
|
|
}
|
|
1 => {}
|
|
_ => {
|
|
if scalar.is_power_of_two() {
|
|
lhs.push(0);
|
|
shl_bitint(lhs.as_mut_slice(), scalar.trailing_zeros() as usize);
|
|
} else {
|
|
let mut carry = 0;
|
|
for a in lhs.iter_mut() {
|
|
(*a, carry) = (*a).carrying_mul(scalar, carry);
|
|
}
|
|
if carry != 0 {
|
|
lhs.push(carry);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
fn u64_mul_bigint(lhs: &mut Vec<u32>, scalar: u64) {
|
|
let lo = scalar as u32;
|
|
let hi = (scalar >> 32) as u32;
|
|
u32_mul_bigint(lhs, lo);
|
|
shl_bitint(lhs, 32);
|
|
u32_mul_bigint(lhs, hi);
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
fn mul_bigint(lhs: &[u32], rhs: &[u32]) -> Vec<u32> {
|
|
if bigint_is_zero(lhs) || bigint_is_zero(rhs) {
|
|
return vec![];
|
|
}
|
|
|
|
let len = lhs.len() + rhs.len() + 1;
|
|
let mut product = vec![0u32; len];
|
|
|
|
for (bth, &b) in rhs.iter().enumerate() {
|
|
let mut carry = 0u32;
|
|
|
|
for (ath, &a) in lhs.iter().enumerate() {
|
|
let prod;
|
|
(prod, carry) = a.carrying_mul(b, carry);
|
|
let (digit, c) = product[ath + bth].carrying_add(prod, false);
|
|
carry += c as u32;
|
|
product[ath + bth] = digit;
|
|
}
|
|
|
|
if carry != 0 {
|
|
product[bth + lhs.len()] += carry;
|
|
}
|
|
}
|
|
|
|
product
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
fn sum_digits(digits: &[u32]) -> u64 {
|
|
let mut sum = 0u64;
|
|
|
|
let mut carry = false;
|
|
for &d in digits {
|
|
(sum, carry) = sum.carrying_add(d as u64, carry);
|
|
}
|
|
|
|
sum + carry as u64
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
fn count_ones(lhs: &[u32]) -> usize {
|
|
lhs.iter()
|
|
.fold(0usize, |acc, c| acc + c.count_ones() as usize)
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
fn trailing_zeros(lhs: &[u32]) -> usize {
|
|
lhs.iter()
|
|
.enumerate()
|
|
.find(|(_, &c)| c != 0)
|
|
.map(|(i, &c)| i * u32::BITS as usize + c.trailing_zeros() as usize)
|
|
.unwrap_or(0)
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
fn is_power_of_two(lhs: &[u32]) -> bool {
|
|
count_ones(lhs) == 1
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
/// divident must be at least as wide as divisor
|
|
/// returns (quotient, remainder)
|
|
pub fn div_rem_bigint_ref(divident: &BigInt, divisor: &BigInt) -> (BigInt, BigInt) {
|
|
if bigint_is_zero(&divisor.0) {
|
|
panic!("divide by zero!");
|
|
}
|
|
if bigint_is_zero(÷nt.0) {
|
|
return (BigInt::zero(), BigInt::zero());
|
|
}
|
|
use core::cmp::Ordering;
|
|
match cmp_bigint(÷nt.0, &divisor.0) {
|
|
Ordering::Less => return (BigInt::zero(), divident.clone()),
|
|
Ordering::Equal => {
|
|
return (BigInt::one(), BigInt::zero());
|
|
}
|
|
Ordering::Greater => {}
|
|
}
|
|
|
|
if divisor.is_power_of_two() {
|
|
let exp = divisor.trailing_zeros();
|
|
let (div, rem) = divident.0.split_at(exp.div_floor(u32::BITS as usize));
|
|
let (mut div, mut rem) = (div.to_vec(), rem.to_vec());
|
|
|
|
shr_bitint(&mut div, exp % u32::BITS as usize);
|
|
let mask = (1u32 << exp as u32 % u32::BITS) - 1;
|
|
if let Some(last) = rem.last_mut() {
|
|
*last &= mask;
|
|
}
|
|
|
|
return (BigInt(div), BigInt(rem));
|
|
}
|
|
|
|
if divisor.num_digits() == 1 {
|
|
if divisor.0[0] == 1 {
|
|
return (divident.clone(), BigInt::zero());
|
|
}
|
|
|
|
let (div, rem) = div_digit_bigint(divident.clone(), divisor.0[0]);
|
|
let rem = BigInt::zero() + rem;
|
|
return (div, rem);
|
|
}
|
|
|
|
let shift = divisor.0.last().unwrap().leading_zeros() as usize;
|
|
if shift == 0 {
|
|
div_rem_core(divident.clone(), &divisor.0)
|
|
} else {
|
|
let (q, r) = div_rem_core(divident.clone() << shift, &(divisor.clone() << shift).0);
|
|
|
|
(q, r >> shift)
|
|
}
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
/// divident must be at least as wide as divisor
|
|
/// returns (quotient, remainder)
|
|
pub fn div_rem_bigint(divident: BigInt, divisor: BigInt) -> (BigInt, BigInt) {
|
|
let divident = divident.normalised();
|
|
let mut divisor = divisor.normalised();
|
|
|
|
if bigint_is_zero(&divisor.0) {
|
|
panic!("divide by zero!");
|
|
}
|
|
if bigint_is_zero(÷nt.0) {
|
|
return (BigInt::zero(), BigInt::zero());
|
|
}
|
|
use core::cmp::Ordering;
|
|
match cmp_bigint(÷nt.0, &divisor.0) {
|
|
Ordering::Less => return (BigInt::zero(), divident),
|
|
Ordering::Equal => {
|
|
return (BigInt::one(), BigInt::zero());
|
|
}
|
|
Ordering::Greater => {}
|
|
}
|
|
|
|
if divisor.is_power_of_two() {
|
|
let exp = divisor.trailing_zeros();
|
|
let (div, rem) = divident.0.split_at(exp.div_floor(u32::BITS as usize));
|
|
let (mut div, mut rem) = (div.to_vec(), rem.to_vec());
|
|
|
|
shr_bitint(&mut div, exp % u32::BITS as usize);
|
|
let mask = (1u32 << exp as u32 % u32::BITS) - 1;
|
|
if let Some(last) = rem.last_mut() {
|
|
*last &= mask;
|
|
}
|
|
|
|
return (BigInt(div), BigInt(rem));
|
|
}
|
|
|
|
if divisor.num_digits() == 1 {
|
|
if divisor.0[0] == 1 {
|
|
return (divident, BigInt::zero());
|
|
}
|
|
|
|
let (div, rem) = div_digit_bigint(divident, divisor.0[0]);
|
|
divisor.0.clear();
|
|
divisor.0.push(rem);
|
|
return (div, divisor);
|
|
}
|
|
|
|
let shift = divisor.0.last().unwrap().leading_zeros() as usize;
|
|
if shift == 0 {
|
|
div_rem_core(divident, &divisor.0)
|
|
} else {
|
|
let (q, r) = div_rem_core(divident << shift, &(divisor << shift).0);
|
|
|
|
(q, r >> shift)
|
|
}
|
|
}
|
|
|
|
fn scalar_div_wide(hi: u32, lo: u32, divisor: u32) -> (u32, u32) {
|
|
let (div, rem);
|
|
|
|
unsafe {
|
|
core::arch::asm! {
|
|
"div {0:e}",
|
|
in(reg) divisor,
|
|
inout("dx") hi => rem,
|
|
inout("ax") lo => div,
|
|
}
|
|
}
|
|
|
|
(div, rem)
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
fn div_digit_bigint(mut divident: BigInt, divisor: u32) -> (BigInt, u32) {
|
|
assert!(divisor != 0);
|
|
let mut rem = 0;
|
|
|
|
for d in divident.0.iter_mut().rev() {
|
|
(*d, rem) = scalar_div_wide(rem, *d, divisor);
|
|
}
|
|
|
|
(divident.normalised(), rem)
|
|
}
|
|
|
|
fn from_lo_hi(lo: u32, hi: u32) -> u64 {
|
|
lo as u64 | (hi as u64) << 32
|
|
}
|
|
fn into_lo_hi(qword: u64) -> (u32, u32) {
|
|
(qword as u32, (qword >> 32) as u32)
|
|
}
|
|
|
|
// from rust num_bigint
|
|
/// Subtract a multiple.
|
|
/// a -= b * c
|
|
/// Returns a borrow (if a < b then borrow > 0).
|
|
fn sub_mul_digit_same_len(a: &mut [u32], b: &[u32], c: u32) -> u32 {
|
|
assert!(a.len() == b.len());
|
|
|
|
// carry is between -big_digit::MAX and 0, so to avoid overflow we store
|
|
// offset_carry = carry + big_digit::MAX
|
|
let mut offset_carry = u32::MAX;
|
|
|
|
for (x, y) in a.iter_mut().zip(b) {
|
|
// We want to calculate sum = x - y * c + carry.
|
|
// sum >= -(big_digit::MAX * big_digit::MAX) - big_digit::MAX
|
|
// sum <= big_digit::MAX
|
|
// Offsetting sum by (big_digit::MAX << big_digit::BITS) puts it in DoubleBigDigit range.
|
|
let offset_sum = from_lo_hi(u32::MAX, *x) - u32::MAX as u64 + offset_carry as u64
|
|
- *y as u64 * c as u64;
|
|
|
|
let (new_x, new_offset_carry) = into_lo_hi(offset_sum);
|
|
offset_carry = new_offset_carry;
|
|
*x = new_x;
|
|
}
|
|
|
|
// Return the borrow.
|
|
u32::MAX - offset_carry
|
|
}
|
|
|
|
// from rust num_bigint
|
|
fn div_rem_core(mut a: BigInt, b: &[u32]) -> (BigInt, BigInt) {
|
|
// sanity check on fast paths
|
|
assert!(a.0.len() >= b.len() && b.len() > 1);
|
|
|
|
// a0 stores an additional extra most significant digit of the dividend, not stored in a.
|
|
let mut a0 = 0;
|
|
|
|
// [b1, b0] are the two most significant digits of the divisor. They never change.
|
|
let b0 = b[b.len() - 1];
|
|
let b1 = b[b.len() - 2];
|
|
|
|
let q_len = a.0.len() - b.len() + 1;
|
|
let mut q = BigInt(vec![0; q_len]);
|
|
|
|
for j in (0..q_len).rev() {
|
|
assert!(a.0.len() == b.len() + j);
|
|
|
|
let a1 = *a.0.last().unwrap();
|
|
let a2 = a.0[a.0.len() - 2];
|
|
|
|
// The first q0 estimate is [a1,a0] / b0. It will never be too small, it may be too large
|
|
// by at most 2.
|
|
let (mut q0, mut r) = if a0 < b0 {
|
|
let (q0, r) = scalar_div_wide(a0, a1, b0);
|
|
(q0, r as u64)
|
|
} else {
|
|
assert!(a0 == b0);
|
|
// Avoid overflowing q0, we know the quotient fits in BigDigit.
|
|
// [a1,a0] = b0 * (1<<BITS - 1) + (a0 + a1)
|
|
(u32::MAX, a0 as u64 + a1 as u64)
|
|
};
|
|
|
|
// r = [a1,a0] - q0 * b0
|
|
//
|
|
// Now we want to compute a more precise estimate [a2,a1,a0] / [b1,b0] which can only be
|
|
// less or equal to the current q0.
|
|
//
|
|
// q0 is too large if:
|
|
// [a2,a1,a0] < q0 * [b1,b0]
|
|
// (r << BITS) + a2 < q0 * b1
|
|
while r <= u32::MAX as u64 && from_lo_hi(r as u32, a2) < q0 as u64 * b1 as u64 {
|
|
q0 -= 1;
|
|
r += b0 as u64;
|
|
}
|
|
|
|
// q0 is now either the correct quotient digit, or in rare cases 1 too large.
|
|
// Subtract (q0 << j) from a. This may overflow, in which case we will have to correct.
|
|
|
|
let mut borrow = sub_mul_digit_same_len(&mut a.0[j..], b, q0);
|
|
if borrow > a0 {
|
|
// q0 is too large. We need to add back one multiple of b.
|
|
q0 -= 1;
|
|
borrow -= add_bigint(&mut a.0[j..], b) as u32;
|
|
}
|
|
// The top digit of a, stored in a0, has now been zeroed.
|
|
assert!(borrow == a0);
|
|
|
|
q.0[j] = q0;
|
|
|
|
// Pop off the next top digit of a.
|
|
a0 = a.0.pop().unwrap();
|
|
}
|
|
|
|
a.0.push(a0);
|
|
a.normalise();
|
|
|
|
assert_eq!(cmp_bigint(&a.0, b), core::cmp::Ordering::Less);
|
|
|
|
(q.normalised(), a)
|
|
}
|
|
|
|
#[allow(unused)]
|
|
fn shr_bitint(lhs: &mut [u32], shift: usize) {
|
|
if bigint_is_zero(lhs) || shift == 0 {
|
|
return;
|
|
}
|
|
|
|
let len = lhs.len();
|
|
let digit_offset = shift / 32;
|
|
let bit_shift = shift % 32;
|
|
|
|
if digit_offset != 0 {
|
|
lhs.copy_within(digit_offset..len, 0);
|
|
lhs[(len - digit_offset)..].fill(0);
|
|
}
|
|
if bit_shift != 0 {
|
|
let lo_mask = (1u32 << (u32::BITS as usize - bit_shift)) - 1;
|
|
let hi_mask = !lo_mask;
|
|
|
|
eprintln!("lhs >> {shift}");
|
|
eprintln!("\tdigit_offset: {digit_offset}");
|
|
eprintln!("\tbit_shift: {bit_shift}");
|
|
eprintln!("\tlo_mask: 0b{lo_mask:0>32b}");
|
|
eprintln!("\thi_mask: 0b{hi_mask:0>32b}");
|
|
|
|
let mut carry = 0u32;
|
|
for i in 0..lhs.len() {
|
|
let digit = ((lhs[i] as u64) << 32) >> bit_shift;
|
|
let lo = digit as u32;
|
|
let hi = (digit >> 32) as u32;
|
|
|
|
lhs[i] &= hi_mask;
|
|
lhs[i] |= hi;
|
|
|
|
if i > 0 {
|
|
lhs[i - 1] &= lo_mask;
|
|
lhs[i - 1] |= lo;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[allow(unused)]
|
|
/// lhs must have shift / 32 + 1 digits past the last bit if shifted-past bits are desired.
|
|
fn shl_bitint(lhs: &mut [u32], shift: usize) {
|
|
if bigint_is_zero(lhs) || shift == 0 {
|
|
return;
|
|
}
|
|
|
|
let len = lhs.len();
|
|
let digit_offset = shift / 32;
|
|
let bit_shift = shift % 32;
|
|
|
|
if digit_offset != 0 {
|
|
lhs.copy_within(0..(len - digit_offset), digit_offset);
|
|
lhs[..digit_offset].fill(0);
|
|
}
|
|
if bit_shift != 0 {
|
|
let hi_mask = (1u32 << bit_shift) - 1;
|
|
let lo_mask = !hi_mask;
|
|
|
|
eprintln!("lhs << {shift}");
|
|
eprintln!("\tdigit_offset: {digit_offset}");
|
|
eprintln!("\tbit_shift: {bit_shift}");
|
|
eprintln!("\tlo_mask: 0b{lo_mask:0>32b}");
|
|
eprintln!("\thi_mask: 0b{hi_mask:0>32b}");
|
|
|
|
// example with u8 digits, shift = 3;
|
|
// hi_mask = 0b00000111
|
|
// lo_mask = 0b11111000
|
|
//
|
|
// lhs[i] as u16 = 0b00000000_01111000
|
|
// digit = 0b00000011_11000000
|
|
// hi = 0b00000011
|
|
// lo = 0b11000000
|
|
|
|
let mut carry = 0u32;
|
|
for i in (digit_offset..len).rev() {
|
|
let digit = (lhs[i] as u64) << bit_shift;
|
|
let lo = digit as u32;
|
|
let hi = (digit >> 32) as u32;
|
|
|
|
lhs[i] &= lo_mask;
|
|
lhs[i] |= lo;
|
|
|
|
if i + 1 < len {
|
|
lhs[i + 1] &= hi_mask;
|
|
lhs[i + 1] |= hi;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[allow(unused)]
|
|
/// lhs must be bigger than rhs
|
|
fn sub_bigint(lhs: &mut [u32], rhs: &[u32]) {
|
|
if bigint_is_zero(rhs) {
|
|
return;
|
|
}
|
|
|
|
let len = lhs.len().min(rhs.len());
|
|
let (l_lo, l_hi) = lhs.split_at_mut(len);
|
|
let (r_lo, r_hi) = rhs.split_at(len);
|
|
|
|
println!("lhs: {{ lo: {l_lo:?}, hi: {l_hi:?} }}");
|
|
println!("rhs: {{ lo: {r_lo:?}, hi: {r_hi:?} }}");
|
|
|
|
let mut borrow = false;
|
|
for (lhs, rhs) in l_lo.iter_mut().zip(r_lo) {
|
|
(*lhs, borrow) = lhs.borrowing_sub(*rhs, borrow);
|
|
}
|
|
|
|
if borrow {
|
|
for lhs in l_hi {
|
|
(*lhs, borrow) = lhs.borrowing_sub(0, borrow);
|
|
}
|
|
}
|
|
|
|
if borrow || !r_hi.iter().all(|&v| v == 0) {
|
|
panic!("sub failed: borrow: {borrow}");
|
|
}
|
|
}
|
|
|
|
fn sub_bigint_in_right_simple(lhs: &[u32], rhs: &mut [u32]) -> bool {
|
|
assert!(lhs.len() == rhs.len());
|
|
let mut borrow = false;
|
|
for (l, r) in lhs.iter().zip(rhs) {
|
|
(*r, borrow) = l.borrowing_sub(*r, borrow);
|
|
}
|
|
|
|
borrow
|
|
}
|
|
|
|
fn sub_bigint_in_right(lhs: &[u32], rhs: &mut [u32]) {
|
|
assert!(rhs.len() >= lhs.len());
|
|
|
|
let min_len = lhs.len().min(rhs.len());
|
|
let (r_lo, r_hi) = rhs.split_at_mut(min_len);
|
|
let (l_lo, l_hi) = lhs.split_at(min_len);
|
|
|
|
let borrow = sub_bigint_in_right_simple(l_lo, r_lo);
|
|
|
|
assert!(l_hi.is_empty());
|
|
assert!(!borrow);
|
|
assert!(r_hi.iter().all(|&d| d == 0));
|
|
}
|
|
|
|
fn sub_bigint_scalar(lhs: &mut [u32], rhs: u32) {
|
|
let mut rhs = Some(rhs);
|
|
let mut borrow = false;
|
|
for lhs in lhs.iter_mut() {
|
|
(*lhs, borrow) = lhs.borrowing_sub(rhs.take().unwrap_or(0), borrow);
|
|
if !borrow {
|
|
break;
|
|
}
|
|
}
|
|
if borrow {
|
|
panic!("sub failed: borrow: {borrow}");
|
|
}
|
|
}
|
|
|
|
fn add_bigint_scalar(lhs: &mut [u32], rhs: u32) -> bool {
|
|
let mut rhs = Some(rhs);
|
|
let mut carry = false;
|
|
for d in lhs.iter_mut() {
|
|
(*d, carry) = (*d).carrying_add(rhs.take().unwrap_or(0), carry);
|
|
if !carry {
|
|
break;
|
|
}
|
|
}
|
|
carry
|
|
}
|
|
|
|
/// lhs must be bigger than rhs
|
|
/// returns carry
|
|
fn add_bigint(lhs: &mut [u32], rhs: &[u32]) -> bool {
|
|
if bigint_is_zero(rhs) {
|
|
return false;
|
|
}
|
|
|
|
let (l_lo, l_hi) = lhs.split_at_mut(rhs.len());
|
|
|
|
let mut carry = false;
|
|
for (lhs, rhs) in l_lo.iter_mut().zip(rhs) {
|
|
(*lhs, carry) = lhs.carrying_add(*rhs, carry);
|
|
}
|
|
|
|
if carry {
|
|
for d in l_hi.iter_mut() {
|
|
(*d, carry) = d.carrying_add(0, carry);
|
|
if !carry {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
carry
|
|
}
|
|
|
|
pub fn parse_bigint(text: impl Iterator<Item = char>, radix: Radix) -> Vec<u32> {
|
|
let digits = text
|
|
.filter_map(|c| match c {
|
|
'_' => None,
|
|
c => Some(radix.map_digit(c)),
|
|
})
|
|
.collect::<Vec<_>>();
|
|
|
|
let (max, power) = {
|
|
let radix = radix.radix() as u64;
|
|
let mut power = 1;
|
|
let mut base = radix;
|
|
while let Some(b) = base.checked_mul(radix) {
|
|
if b > u32::MAX as u64 {
|
|
break;
|
|
}
|
|
base = b;
|
|
power += 1;
|
|
}
|
|
(base, power)
|
|
};
|
|
let radix = radix.radix() as u32;
|
|
|
|
let r = digits.len() % power;
|
|
let i = if r == 0 { power } else { r };
|
|
let (head, tail) = digits.split_at(i);
|
|
|
|
let first = head
|
|
.iter()
|
|
.fold(0, |acc, &digit| acc * radix + digit as u32);
|
|
let mut data = vec![first];
|
|
|
|
for chunk in tail.chunks(power) {
|
|
if data.last() != Some(&0) {
|
|
data.push(0);
|
|
}
|
|
let mut carry = 0u64;
|
|
for digit in data.iter_mut() {
|
|
carry += *digit as u64 * max as u64;
|
|
*digit = carry as u32;
|
|
carry >>= u32::BITS;
|
|
}
|
|
assert!(carry == 0);
|
|
let next = chunk
|
|
.iter()
|
|
.fold(0, |acc, &digit| acc * radix + digit as u32);
|
|
|
|
let (res, mut carry) = data[0].carrying_add(next, false);
|
|
data[0] = res;
|
|
if carry {
|
|
for digit in data[1..].iter_mut() {
|
|
(*digit, carry) = digit.carrying_add(0, carry);
|
|
if !carry {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
data
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn parse() {
|
|
let bigint = BigInt::parse_digits("2_cafe_babe_dead_beef".chars(), Radix::Hex);
|
|
println!("{:#x?}", bigint);
|
|
let bigint = BigInt::parse_digits("f".chars(), Radix::Hex);
|
|
println!("{:#x?}", bigint);
|
|
}
|
|
#[test]
|
|
fn add() {
|
|
let a = BigInt::parse_digits("2_0000_0000_0000_0000".chars(), Radix::Hex);
|
|
println!("{:#x?}", a);
|
|
let b = BigInt::parse_digits("cafebabe".chars(), Radix::Hex);
|
|
println!("{:#x?}", b);
|
|
let sum = a + b;
|
|
println!("{:#x?}", sum);
|
|
}
|
|
#[test]
|
|
fn sub() {
|
|
let a = BigInt::parse_digits("deadbeef".chars(), Radix::Hex);
|
|
println!("{:#x?}", a);
|
|
let b = BigInt::parse_digits("56d2c".chars(), Radix::Hex);
|
|
println!("{:#x?}", b);
|
|
let sum = a - b;
|
|
println!("{:#x?}", sum);
|
|
}
|
|
#[test]
|
|
fn overflowing_sub() {
|
|
let a = BigInt::parse_digits("2_0000_0000_0000_0000".chars(), Radix::Hex);
|
|
println!("{:#x?}", a);
|
|
let b = BigInt::parse_digits("ffff_ffff".chars(), Radix::Hex);
|
|
println!("{:#x?}", b);
|
|
let sum = b - a;
|
|
println!("{:#x?}", sum);
|
|
}
|
|
#[test]
|
|
fn shr() {
|
|
let mut a = BigInt::parse_digits("cafe_babe_0000".chars(), Radix::Hex);
|
|
print!("{:0>8x?} >> 32 ", a);
|
|
shr_bitint(&mut a.0, 32);
|
|
println!("{:0>8x?}", a);
|
|
|
|
let mut a = BigInt::parse_digits("11110000".chars(), Radix::Bin);
|
|
print!("{:0>8x?} >> 32 ", a);
|
|
shr_bitint(&mut a.0, 3);
|
|
println!("{:0>8x?}", a);
|
|
}
|
|
#[test]
|
|
fn shl() {
|
|
let mut a = BigInt::parse_digits("ffff_ffff".chars(), Radix::Hex);
|
|
a.0.extend([0; 4]);
|
|
println!("{:0>8x?}", a);
|
|
shl_bitint(&mut a.0, 40);
|
|
println!("{:0>8x?}", a);
|
|
}
|
|
#[test]
|
|
fn div() {
|
|
let a = BigInt::parse_digits("cafebabe".chars(), Radix::Hex);
|
|
let b = BigInt::parse_digits("dead".chars(), Radix::Hex);
|
|
let (div, rem) = div_rem_bigint(a, b);
|
|
println!("div: {:0>8x?}", div);
|
|
println!("rem: {:0>8x?}", rem);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub mod bigsint {
|
|
use std::{
|
|
cmp::Ordering,
|
|
ops::{Add, AddAssign, Div, Mul, Neg, Not, Rem, Shl, Shr, Sub, SubAssign},
|
|
};
|
|
|
|
use super::bigint::{self, *};
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
|
|
enum Sign {
|
|
Negative = 0,
|
|
None = 1,
|
|
Positive = 2,
|
|
}
|
|
|
|
impl Neg for Sign {
|
|
type Output = Self;
|
|
|
|
fn neg(self) -> Self::Output {
|
|
match self {
|
|
Sign::Negative => Self::Positive,
|
|
Sign::None => Self::None,
|
|
Sign::Positive => Self::Negative,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// A base-4_294_967_295 number.
|
|
#[derive(Clone, Debug, Eq, Ord)]
|
|
pub struct BigSInt {
|
|
sign: Sign,
|
|
bigint: BigInt,
|
|
}
|
|
|
|
impl BigSInt {
|
|
pub fn zero() -> BigSInt {
|
|
Self {
|
|
sign: Sign::None,
|
|
bigint: BigInt::zero(),
|
|
}
|
|
}
|
|
pub fn one() -> BigSInt {
|
|
Self {
|
|
sign: Sign::Positive,
|
|
bigint: BigInt::one(),
|
|
}
|
|
}
|
|
|
|
pub fn positive(bigint: BigInt) -> BigSInt {
|
|
Self {
|
|
sign: Sign::Positive,
|
|
bigint,
|
|
}
|
|
}
|
|
|
|
pub fn from_u32(v: u32) -> BigSInt {
|
|
let sign = core::num::NonZero::new(v)
|
|
.map(|_| Sign::Positive)
|
|
.unwrap_or(Sign::None);
|
|
Self {
|
|
sign,
|
|
bigint: BigInt::from_u32(v),
|
|
}
|
|
}
|
|
pub fn from_u64(v: u64) -> BigSInt {
|
|
let sign = core::num::NonZero::new(v)
|
|
.map(|_| Sign::Positive)
|
|
.unwrap_or(Sign::None);
|
|
Self {
|
|
sign,
|
|
bigint: BigInt::from_u64(v),
|
|
}
|
|
}
|
|
pub fn from_i32(v: i32) -> BigSInt {
|
|
if v >= 0 {
|
|
Self::from_u32(v as u32)
|
|
} else {
|
|
let v = u32::MAX - (v as u32) + 1;
|
|
Self {
|
|
sign: Sign::Negative,
|
|
bigint: BigInt::from_u32(v),
|
|
}
|
|
}
|
|
}
|
|
pub fn from_i64(v: i64) -> BigSInt {
|
|
if v >= 0 {
|
|
Self::from_u64(v as u64)
|
|
} else {
|
|
let v = u64::MAX - (v as u64) + 1;
|
|
Self {
|
|
sign: Sign::Negative,
|
|
bigint: BigInt::from_u64(v),
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn is_negative(&self) -> bool {
|
|
self.sign == Sign::Negative
|
|
}
|
|
}
|
|
|
|
impl PartialEq for BigSInt {
|
|
fn eq(&self, other: &Self) -> bool {
|
|
self.sign == other.sign && self.bigint == other.bigint
|
|
}
|
|
}
|
|
|
|
impl PartialOrd for BigSInt {
|
|
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
|
|
match self.sign.partial_cmp(&other.sign) {
|
|
Some(core::cmp::Ordering::Equal) => {}
|
|
ord => return ord,
|
|
}
|
|
self.bigint.partial_cmp(&other.bigint)
|
|
}
|
|
}
|
|
|
|
impl Not for BigSInt {
|
|
type Output = Self;
|
|
|
|
fn not(mut self) -> Self::Output {
|
|
match self.sign {
|
|
Sign::Negative => {
|
|
self.bigint -= 1u32;
|
|
self.sign = if self.bigint.is_zero() {
|
|
Sign::None
|
|
} else {
|
|
Sign::Positive
|
|
};
|
|
}
|
|
Sign::None | Sign::Positive => {
|
|
self.bigint += 1u32;
|
|
self.sign = Sign::Negative;
|
|
}
|
|
}
|
|
self
|
|
}
|
|
}
|
|
|
|
impl Add for BigSInt {
|
|
type Output = Self;
|
|
|
|
fn add(self, rhs: Self) -> Self::Output {
|
|
match (self.sign, rhs.sign) {
|
|
(_, Sign::None) => self,
|
|
(Sign::None, _) => rhs,
|
|
(Sign::Positive, Sign::Positive) | (Sign::Negative, Sign::Negative) => Self {
|
|
sign: self.sign,
|
|
bigint: self.bigint + rhs.bigint,
|
|
},
|
|
(Sign::Positive, Sign::Negative) | (Sign::Negative, Sign::Positive) => {
|
|
match self.bigint.cmp(&rhs.bigint) {
|
|
Ordering::Less => Self {
|
|
sign: rhs.sign,
|
|
bigint: rhs.bigint - self.bigint,
|
|
},
|
|
Ordering::Equal => Self::zero(),
|
|
Ordering::Greater => Self {
|
|
sign: self.sign,
|
|
bigint: self.bigint - rhs.bigint,
|
|
},
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Add<u32> for BigSInt {
|
|
type Output = BigSInt;
|
|
|
|
fn add(self, rhs: u32) -> Self::Output {
|
|
match self.sign {
|
|
Sign::Negative => match self.bigint.partial_cmp(&rhs).unwrap() {
|
|
Ordering::Less => Self::positive(rhs - self.bigint),
|
|
Ordering::Equal => Self::zero(),
|
|
Ordering::Greater => -Self::positive(self.bigint - rhs),
|
|
},
|
|
Sign::None => Self::from_u32(rhs),
|
|
Sign::Positive => Self::positive(self.bigint + rhs),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Add<u64> for BigSInt {
|
|
type Output = BigSInt;
|
|
|
|
fn add(self, rhs: u64) -> Self::Output {
|
|
match self.sign {
|
|
Sign::Negative => match self.bigint.partial_cmp(&rhs).unwrap() {
|
|
Ordering::Less => Self::positive(rhs - self.bigint),
|
|
Ordering::Equal => Self::zero(),
|
|
Ordering::Greater => -Self::positive(self.bigint - rhs),
|
|
},
|
|
Sign::None => Self::from_u64(rhs),
|
|
Sign::Positive => Self::positive(self.bigint + rhs),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl AddAssign for BigSInt {
|
|
fn add_assign(&mut self, rhs: Self) {
|
|
let n = core::mem::replace(self, Self::zero());
|
|
*self = n + rhs;
|
|
}
|
|
}
|
|
|
|
impl Sub for BigSInt {
|
|
type Output = Self;
|
|
|
|
fn sub(self, rhs: Self) -> Self::Output {
|
|
match (self.sign, rhs.sign) {
|
|
(_, Sign::None) => self,
|
|
(Sign::None, _) => -rhs,
|
|
(Sign::Positive, Sign::Negative) | (Sign::Negative, Sign::Positive) => Self {
|
|
sign: self.sign,
|
|
bigint: self.bigint + rhs.bigint,
|
|
},
|
|
(Sign::Positive, Sign::Positive) | (Sign::Negative, Sign::Negative) => {
|
|
match self.bigint.cmp(&rhs.bigint) {
|
|
Ordering::Less => Self {
|
|
sign: -self.sign,
|
|
bigint: rhs.bigint - self.bigint,
|
|
},
|
|
Ordering::Equal => Self::zero(),
|
|
Ordering::Greater => Self {
|
|
sign: self.sign,
|
|
bigint: self.bigint - rhs.bigint,
|
|
},
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SubAssign for BigSInt {
|
|
fn sub_assign(&mut self, rhs: Self) {
|
|
let n = core::mem::replace(self, Self::zero());
|
|
*self = n - rhs;
|
|
}
|
|
}
|
|
|
|
impl Shl<usize> for BigSInt {
|
|
type Output = Self;
|
|
|
|
fn shl(self, rhs: usize) -> Self::Output {
|
|
Self {
|
|
sign: self.sign,
|
|
bigint: self.bigint << rhs,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Shr<usize> for BigSInt {
|
|
type Output = Self;
|
|
|
|
fn shr(self, rhs: usize) -> Self::Output {
|
|
let rounding = shr_rounding(&self, rhs);
|
|
let mut out = Self {
|
|
sign: self.sign,
|
|
bigint: self.bigint >> rhs,
|
|
};
|
|
|
|
if rounding {
|
|
out.bigint += 1u32;
|
|
}
|
|
|
|
out
|
|
}
|
|
}
|
|
|
|
impl Mul for Sign {
|
|
type Output = Self;
|
|
|
|
fn mul(self, rhs: Self) -> Self::Output {
|
|
use Sign::*;
|
|
match (self, rhs) {
|
|
(Negative, Negative) | (Positive, Positive) => Positive,
|
|
(None, _) | (_, None) => todo!(),
|
|
(Negative, Positive) | (Positive, Negative) => Negative,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Mul for BigSInt {
|
|
type Output = Self;
|
|
|
|
fn mul(self, rhs: Self) -> Self::Output {
|
|
Self {
|
|
sign: self.sign * rhs.sign,
|
|
bigint: self.bigint * rhs.bigint,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Div for BigSInt {
|
|
type Output = Self;
|
|
|
|
fn div(self, rhs: Self) -> Self::Output {
|
|
div_rem_bigsint(&self, &rhs).0
|
|
}
|
|
}
|
|
|
|
impl Rem for BigSInt {
|
|
type Output = Self;
|
|
|
|
fn rem(self, rhs: Self) -> Self::Output {
|
|
div_rem_bigsint(&self, &rhs).1
|
|
}
|
|
}
|
|
|
|
fn div_rem_bigsint(lhs: &BigSInt, rhs: &BigSInt) -> (BigSInt, BigSInt) {
|
|
let (q, r) = bigint::div_rem_bigint_ref(&lhs.bigint, &rhs.bigint);
|
|
let q = BigSInt {
|
|
sign: lhs.sign,
|
|
bigint: q,
|
|
};
|
|
let r = BigSInt {
|
|
sign: lhs.sign,
|
|
bigint: r,
|
|
};
|
|
|
|
if rhs.is_negative() {
|
|
(-q, r)
|
|
} else {
|
|
(q, r)
|
|
}
|
|
}
|
|
|
|
fn shr_rounding(lhs: &BigSInt, shift: usize) -> bool {
|
|
if lhs.is_negative() {
|
|
let ctz = lhs.bigint.trailing_zeros();
|
|
shift > 0 && ctz < shift
|
|
} else {
|
|
false
|
|
}
|
|
}
|
|
|
|
impl Neg for BigSInt {
|
|
type Output = Self;
|
|
|
|
fn neg(mut self) -> Self::Output {
|
|
self.sign = -self.sign;
|
|
self
|
|
}
|
|
}
|
|
}
|
|
|
|
use std::{
|
|
cmp::Ordering,
|
|
ops::{BitAnd, BitOr, BitXor, Not},
|
|
};
|
|
|
|
use num_bigint::{BigInt, BigUint, Sign};
|
|
use num_traits::{cast::ToPrimitive, ToBytes};
|
|
|
|
use crate::ast::{FloatingType, IntegralType, Type};
|
|
|
|
#[derive(Debug, thiserror::Error)]
|
|
pub enum Error {
|
|
#[error("Incompatible Comptime Number variants.")]
|
|
IncompatibleTypes,
|
|
#[error("Integer overflow.")]
|
|
IntegerOverflow,
|
|
#[error("Shift cannot fit into u32.")]
|
|
ShiftTooLarge,
|
|
#[error("Cannot negate unsigned integer")]
|
|
UnsignedNegation,
|
|
#[error("Incomparable floats.")]
|
|
FloatingCmp,
|
|
#[error("Not a comptime expression.")]
|
|
NotComptime,
|
|
}
|
|
|
|
pub type Result<T> = core::result::Result<T, Error>;
|
|
|
|
#[derive(Debug, PartialEq, Eq)]
|
|
pub enum ComptimeInt {
|
|
Native { bits: u128, ty: IntegralType },
|
|
BigInt { bits: BigInt, ty: IntegralType },
|
|
Comptime(BigInt),
|
|
}
|
|
|
|
impl ComptimeInt {
|
|
pub fn add(self, other: Self) -> Result<Self> {
|
|
let (a, b) = self.coalesce(other)?;
|
|
match (a, b) {
|
|
(ComptimeInt::Native { bits: a, ty }, ComptimeInt::Native { bits: b, .. }) => {
|
|
let bits = a.checked_add(b).ok_or(Error::IntegerOverflow)?;
|
|
if bits & !ty.u128_bitmask() != 0 {
|
|
return Err(Error::IntegerOverflow);
|
|
}
|
|
Ok(Self::Native { bits, ty })
|
|
}
|
|
(ComptimeInt::BigInt { bits: a, ty }, ComptimeInt::BigInt { bits: b, .. }) => {
|
|
let width = ty.bits - ty.signed as u16;
|
|
let bits = a + b;
|
|
if bits.bits() > width as u64 {
|
|
Err(Error::IntegerOverflow)
|
|
} else {
|
|
Ok(Self::BigInt { bits, ty })
|
|
}
|
|
}
|
|
(ComptimeInt::Comptime(a), ComptimeInt::Comptime(b)) => Ok(Self::Comptime(a + b)),
|
|
_ => {
|
|
unreachable!()
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn sub(self, other: Self) -> Result<Self> {
|
|
let (a, b) = self.coalesce(other)?;
|
|
match (a, b) {
|
|
(ComptimeInt::Native { bits: a, ty }, ComptimeInt::Native { bits: b, .. }) => {
|
|
let bits = a.checked_sub(b).ok_or(Error::IntegerOverflow)?;
|
|
if bits & !ty.u128_bitmask() != 0 {
|
|
return Err(Error::IntegerOverflow);
|
|
}
|
|
Ok(Self::Native { bits, ty })
|
|
}
|
|
(ComptimeInt::BigInt { bits: a, ty }, ComptimeInt::BigInt { bits: b, .. }) => {
|
|
let width = ty.bits - ty.signed as u16;
|
|
let bits = a - b;
|
|
if bits.bits() > width as u64 {
|
|
Err(Error::IntegerOverflow)
|
|
} else {
|
|
Ok(Self::BigInt { bits, ty })
|
|
}
|
|
}
|
|
(ComptimeInt::Comptime(a), ComptimeInt::Comptime(b)) => Ok(Self::Comptime(a - b)),
|
|
_ => {
|
|
unreachable!()
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn mul(self, other: Self) -> Result<Self> {
|
|
let (a, b) = self.coalesce(other)?;
|
|
match (a, b) {
|
|
(ComptimeInt::Native { bits: a, ty }, ComptimeInt::Native { bits: b, .. }) => {
|
|
let bits = a.checked_mul(b).ok_or(Error::IntegerOverflow)?;
|
|
if bits & !ty.u128_bitmask() != 0 {
|
|
return Err(Error::IntegerOverflow);
|
|
}
|
|
Ok(Self::Native { bits, ty })
|
|
}
|
|
(ComptimeInt::BigInt { bits: a, ty }, ComptimeInt::BigInt { bits: b, .. }) => {
|
|
let width = ty.bits - ty.signed as u16;
|
|
let bits = a * b;
|
|
if bits.bits() > width as u64 {
|
|
Err(Error::IntegerOverflow)
|
|
} else {
|
|
Ok(Self::BigInt { bits, ty })
|
|
}
|
|
}
|
|
(ComptimeInt::Comptime(a), ComptimeInt::Comptime(b)) => Ok(Self::Comptime(a * b)),
|
|
_ => {
|
|
unreachable!()
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn div(self, other: Self) -> Result<Self> {
|
|
let (a, b) = self.coalesce(other)?;
|
|
match (a, b) {
|
|
(ComptimeInt::Native { bits: a, ty }, ComptimeInt::Native { bits: b, .. }) => {
|
|
let bits = a.checked_div(b).ok_or(Error::IntegerOverflow)?;
|
|
if bits & !ty.u128_bitmask() != 0 {
|
|
return Err(Error::IntegerOverflow);
|
|
}
|
|
Ok(Self::Native { bits, ty })
|
|
}
|
|
(ComptimeInt::BigInt { bits: a, ty }, ComptimeInt::BigInt { bits: b, .. }) => {
|
|
let width = ty.bits - ty.signed as u16;
|
|
let bits = a / b;
|
|
if bits.bits() > width as u64 {
|
|
Err(Error::IntegerOverflow)
|
|
} else {
|
|
Ok(Self::BigInt { bits, ty })
|
|
}
|
|
}
|
|
(ComptimeInt::Comptime(a), ComptimeInt::Comptime(b)) => Ok(Self::Comptime(a / b)),
|
|
_ => {
|
|
unreachable!()
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn rem(self, other: Self) -> Result<Self> {
|
|
let (a, b) = self.coalesce(other)?;
|
|
match (a, b) {
|
|
(ComptimeInt::Native { bits: a, ty }, ComptimeInt::Native { bits: b, .. }) => {
|
|
let bits = a.checked_rem(b).ok_or(Error::IntegerOverflow)?;
|
|
if bits & !ty.u128_bitmask() != 0 {
|
|
return Err(Error::IntegerOverflow);
|
|
}
|
|
Ok(Self::Native { bits, ty })
|
|
}
|
|
(ComptimeInt::BigInt { bits: a, ty }, ComptimeInt::BigInt { bits: b, .. }) => {
|
|
let width = ty.bits - ty.signed as u16;
|
|
let bits = a % b;
|
|
if bits.bits() > width as u64 {
|
|
Err(Error::IntegerOverflow)
|
|
} else {
|
|
Ok(Self::BigInt { bits, ty })
|
|
}
|
|
}
|
|
(ComptimeInt::Comptime(a), ComptimeInt::Comptime(b)) => Ok(Self::Comptime(a % b)),
|
|
_ => {
|
|
unreachable!()
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn bitand(self, other: Self) -> Result<Self> {
|
|
let (a, b) = self.coalesce(other)?;
|
|
match (a, b) {
|
|
(ComptimeInt::Native { bits: a, ty }, ComptimeInt::Native { bits: b, .. }) => {
|
|
let bits = a.bitand(b);
|
|
Ok(Self::Native { bits, ty })
|
|
}
|
|
(ComptimeInt::BigInt { bits: a, ty }, ComptimeInt::BigInt { bits: b, .. }) => {
|
|
let bits = a & b;
|
|
Ok(Self::BigInt { bits, ty })
|
|
}
|
|
(ComptimeInt::Comptime(a), ComptimeInt::Comptime(b)) => Ok(Self::Comptime(a & b)),
|
|
_ => {
|
|
unreachable!()
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn bitor(self, other: Self) -> Result<Self> {
|
|
let (a, b) = self.coalesce(other)?;
|
|
match (a, b) {
|
|
(ComptimeInt::Native { bits: a, ty }, ComptimeInt::Native { bits: b, .. }) => {
|
|
let bits = a.bitor(b);
|
|
Ok(Self::Native { bits, ty })
|
|
}
|
|
(ComptimeInt::BigInt { bits: a, ty }, ComptimeInt::BigInt { bits: b, .. }) => {
|
|
let bits = a | b;
|
|
Ok(Self::BigInt { bits, ty })
|
|
}
|
|
(ComptimeInt::Comptime(a), ComptimeInt::Comptime(b)) => Ok(Self::Comptime(a | b)),
|
|
_ => {
|
|
unreachable!()
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn bitxor(self, other: Self) -> Result<Self> {
|
|
let (a, b) = self.coalesce(other)?;
|
|
match (a, b) {
|
|
(ComptimeInt::Native { bits: a, ty }, ComptimeInt::Native { bits: b, .. }) => {
|
|
let bits = a.bitxor(b);
|
|
Ok(Self::Native { bits, ty })
|
|
}
|
|
(ComptimeInt::BigInt { bits: a, ty }, ComptimeInt::BigInt { bits: b, .. }) => {
|
|
let bits = a ^ b;
|
|
Ok(Self::BigInt { bits, ty })
|
|
}
|
|
(ComptimeInt::Comptime(a), ComptimeInt::Comptime(b)) => Ok(Self::Comptime(a ^ b)),
|
|
_ => {
|
|
unreachable!()
|
|
}
|
|
}
|
|
}
|
|
pub fn cmp(self, other: Self) -> Result<Ordering> {
|
|
let (a, b) = self.coalesce(other)?;
|
|
let ord = match (a, b) {
|
|
(ComptimeInt::Native { bits: a, .. }, ComptimeInt::Native { bits: b, .. }) => a.cmp(&b),
|
|
(ComptimeInt::BigInt { bits: a, .. }, ComptimeInt::BigInt { bits: b, .. }) => a.cmp(&b),
|
|
(ComptimeInt::Comptime(a), ComptimeInt::Comptime(b)) => a.cmp(&b),
|
|
_ => {
|
|
unreachable!()
|
|
}
|
|
};
|
|
|
|
Ok(ord)
|
|
}
|
|
|
|
pub fn shl(self, other: Self) -> Result<Self> {
|
|
use core::ops::Shl;
|
|
let shift = other.try_to_u32()?;
|
|
match self {
|
|
ComptimeInt::Native { bits, ty } => {
|
|
let bits = if ty.signed {
|
|
(bits as i128)
|
|
.checked_shl(shift)
|
|
.ok_or(Error::IntegerOverflow)? as u128
|
|
} else {
|
|
(bits as u128)
|
|
.checked_shl(shift)
|
|
.ok_or(Error::IntegerOverflow)? as u128
|
|
} & ty.u128_bitmask();
|
|
|
|
Ok(Self::Native { bits, ty })
|
|
}
|
|
ComptimeInt::BigInt { bits, ty } => {
|
|
let mut bits = bits.shl(shift);
|
|
|
|
for i in 0..shift as u16 {
|
|
bits.set_bit((i * ty.bits) as u64, false);
|
|
}
|
|
Ok(Self::BigInt { bits, ty })
|
|
}
|
|
ComptimeInt::Comptime(bits) => Ok(Self::Comptime(bits.shl(shift))),
|
|
}
|
|
}
|
|
|
|
pub fn shr(self, other: Self) -> Result<Self> {
|
|
use core::ops::Shr;
|
|
let shift = other.try_to_u32()?;
|
|
match self {
|
|
ComptimeInt::Native { bits, ty } => {
|
|
let bits = if ty.signed {
|
|
(bits as i128)
|
|
.checked_shr(shift)
|
|
.ok_or(Error::IntegerOverflow)? as u128
|
|
} else {
|
|
(bits as u128)
|
|
.checked_shr(shift)
|
|
.ok_or(Error::IntegerOverflow)? as u128
|
|
};
|
|
|
|
Ok(Self::Native { bits, ty })
|
|
}
|
|
ComptimeInt::BigInt { bits, ty } => Ok(Self::BigInt {
|
|
bits: bits.shr(shift),
|
|
ty,
|
|
}),
|
|
ComptimeInt::Comptime(bits) => Ok(Self::Comptime(bits.shr(shift))),
|
|
}
|
|
}
|
|
|
|
pub fn neg(self) -> Result<Self> {
|
|
match self {
|
|
Self::Native { bits: a, ty } => {
|
|
if ty.signed {
|
|
return Err(Error::UnsignedNegation);
|
|
}
|
|
let bits = (a as i128).checked_neg().ok_or(Error::IntegerOverflow)? as u128;
|
|
|
|
if bits & !ty.u128_bitmask() != 0 {
|
|
return Err(Error::IntegerOverflow);
|
|
}
|
|
Ok(Self::Native { bits, ty })
|
|
}
|
|
Self::Comptime(a) => Ok(Self::Comptime(-a)),
|
|
Self::BigInt { bits, ty } => Ok(Self::BigInt { bits: -bits, ty }),
|
|
}
|
|
}
|
|
|
|
pub fn not(self) -> Result<Self> {
|
|
match self {
|
|
ComptimeInt::Native { bits, ty } => Ok(Self::Native {
|
|
bits: !bits | ty.u128_bitmask(),
|
|
ty,
|
|
}),
|
|
ComptimeInt::BigInt { bits, ty } => Ok(Self::BigInt { bits: !bits, ty }),
|
|
ComptimeInt::Comptime(bigint) => Ok(Self::Comptime(!bigint)),
|
|
}
|
|
}
|
|
|
|
fn try_to_u32(&self) -> Result<u32> {
|
|
match self {
|
|
ComptimeInt::Native { bits, .. } => bits.to_u32(),
|
|
ComptimeInt::BigInt { bits, .. } => bits.to_u32(),
|
|
ComptimeInt::Comptime(bits) => bits.to_u32(),
|
|
}
|
|
.ok_or(Error::ShiftTooLarge)
|
|
}
|
|
|
|
fn coalesce(self, other: Self) -> Result<(ComptimeInt, ComptimeInt)> {
|
|
match (self, other) {
|
|
(lhs @ ComptimeInt::Native { ty: a_ty, .. }, ComptimeInt::Comptime(b))
|
|
| (lhs @ ComptimeInt::Native { ty: a_ty, .. }, ComptimeInt::BigInt { bits: b, .. }) => {
|
|
let b_signed = b.sign() == Sign::Minus;
|
|
if !a_ty.signed && b_signed {
|
|
return Err(Error::IncompatibleTypes);
|
|
}
|
|
|
|
let bits = b.bits() + a_ty.signed as u64;
|
|
if bits as u16 > a_ty.bits {
|
|
return Err(Error::IncompatibleTypes);
|
|
}
|
|
let b = if b_signed {
|
|
b.to_i128().unwrap() as u128
|
|
} else {
|
|
b.to_u128().unwrap()
|
|
};
|
|
Ok((lhs, Self::Native { bits: b, ty: a_ty }))
|
|
}
|
|
(ComptimeInt::Comptime(b), rhs @ ComptimeInt::Native { ty: a_ty, .. })
|
|
| (ComptimeInt::BigInt { bits: b, .. }, rhs @ ComptimeInt::Native { ty: a_ty, .. }) => {
|
|
let b_signed = b.sign() == Sign::Minus;
|
|
if !a_ty.signed && b_signed {
|
|
return Err(Error::IncompatibleTypes);
|
|
}
|
|
|
|
let bits = b.bits() + a_ty.signed as u64;
|
|
if bits as u16 > a_ty.bits {
|
|
return Err(Error::IncompatibleTypes);
|
|
}
|
|
let b = if b_signed {
|
|
b.to_i128().unwrap() as u128
|
|
} else {
|
|
b.to_u128().unwrap()
|
|
};
|
|
Ok((Self::Native { bits: b, ty: a_ty }, rhs))
|
|
}
|
|
(lhs @ ComptimeInt::BigInt { ty, .. }, ComptimeInt::Comptime(b)) => {
|
|
let b_signed = b.sign() == Sign::Minus;
|
|
if !ty.signed && b_signed {
|
|
return Err(Error::IncompatibleTypes);
|
|
}
|
|
|
|
let bits = b.bits() + ty.signed as u64;
|
|
if bits as u16 > ty.bits {
|
|
return Err(Error::IncompatibleTypes);
|
|
}
|
|
Ok((lhs, Self::BigInt { bits: b, ty }))
|
|
}
|
|
(ComptimeInt::Comptime(b), rhs @ ComptimeInt::BigInt { ty, .. }) => {
|
|
let b_signed = b.sign() == Sign::Minus;
|
|
if !ty.signed && b_signed {
|
|
return Err(Error::IncompatibleTypes);
|
|
}
|
|
|
|
let bits = b.bits() + ty.signed as u64;
|
|
if bits as u16 > ty.bits {
|
|
return Err(Error::IncompatibleTypes);
|
|
}
|
|
Ok((Self::BigInt { bits: b, ty }, rhs))
|
|
}
|
|
(lhs @ ComptimeInt::Native { ty: a, .. }, rhs @ ComptimeInt::Native { ty: b, .. }) => {
|
|
if a == b {
|
|
Ok((lhs, rhs))
|
|
} else {
|
|
Err(Error::IncompatibleTypes)
|
|
}
|
|
}
|
|
(lhs @ ComptimeInt::BigInt { ty: a, .. }, rhs @ ComptimeInt::BigInt { ty: b, .. }) => {
|
|
if a == b {
|
|
Ok((lhs, rhs))
|
|
} else {
|
|
Err(Error::IncompatibleTypes)
|
|
}
|
|
}
|
|
(lhs, rhs) => Ok((lhs, rhs)),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, PartialEq)]
|
|
pub enum ComptimeFloat {
|
|
Binary32(f32),
|
|
Binary64(f64),
|
|
}
|
|
|
|
impl ComptimeFloat {
|
|
pub fn add(self, other: Self) -> Result<ComptimeFloat> {
|
|
match (self, other) {
|
|
(ComptimeFloat::Binary32(a), ComptimeFloat::Binary32(b)) => Ok(Self::Binary32(a + b)),
|
|
(ComptimeFloat::Binary64(a), ComptimeFloat::Binary64(b)) => Ok(Self::Binary64(a + b)),
|
|
_ => Err(Error::IncompatibleTypes),
|
|
}
|
|
}
|
|
pub fn sub(self, other: Self) -> Result<ComptimeFloat> {
|
|
match (self, other) {
|
|
(ComptimeFloat::Binary32(a), ComptimeFloat::Binary32(b)) => Ok(Self::Binary32(a - b)),
|
|
(ComptimeFloat::Binary64(a), ComptimeFloat::Binary64(b)) => Ok(Self::Binary64(a - b)),
|
|
_ => Err(Error::IncompatibleTypes),
|
|
}
|
|
}
|
|
pub fn mul(self, other: Self) -> Result<ComptimeFloat> {
|
|
match (self, other) {
|
|
(ComptimeFloat::Binary32(a), ComptimeFloat::Binary32(b)) => Ok(Self::Binary32(a * b)),
|
|
(ComptimeFloat::Binary64(a), ComptimeFloat::Binary64(b)) => Ok(Self::Binary64(a * b)),
|
|
_ => Err(Error::IncompatibleTypes),
|
|
}
|
|
}
|
|
pub fn div(self, other: Self) -> Result<ComptimeFloat> {
|
|
match (self, other) {
|
|
(ComptimeFloat::Binary32(a), ComptimeFloat::Binary32(b)) => Ok(Self::Binary32(a / b)),
|
|
(ComptimeFloat::Binary64(a), ComptimeFloat::Binary64(b)) => Ok(Self::Binary64(a / b)),
|
|
_ => Err(Error::IncompatibleTypes),
|
|
}
|
|
}
|
|
pub fn rem(self, other: Self) -> Result<ComptimeFloat> {
|
|
match (self, other) {
|
|
(ComptimeFloat::Binary32(a), ComptimeFloat::Binary32(b)) => Ok(Self::Binary32(a % b)),
|
|
(ComptimeFloat::Binary64(a), ComptimeFloat::Binary64(b)) => Ok(Self::Binary64(a % b)),
|
|
_ => Err(Error::IncompatibleTypes),
|
|
}
|
|
}
|
|
pub fn neg(self) -> Result<ComptimeFloat> {
|
|
match self {
|
|
ComptimeFloat::Binary32(a) => Ok(Self::Binary32(-a)),
|
|
ComptimeFloat::Binary64(a) => Ok(Self::Binary64(-a)),
|
|
}
|
|
}
|
|
pub fn cmp(self, other: Self) -> Result<Ordering> {
|
|
let ord = match (self, other) {
|
|
(ComptimeFloat::Binary32(a), ComptimeFloat::Binary32(b)) => a.partial_cmp(&b),
|
|
(ComptimeFloat::Binary64(a), ComptimeFloat::Binary64(b)) => a.partial_cmp(&b),
|
|
_ => {
|
|
return Err(Error::IncompatibleTypes);
|
|
}
|
|
};
|
|
|
|
ord.ok_or(Error::FloatingCmp)
|
|
}
|
|
}
|
|
|
|
pub enum ComptimeNumber {
|
|
Integral(ComptimeInt),
|
|
Bool(bool),
|
|
Floating(ComptimeFloat),
|
|
}
|
|
|
|
impl From<bool> for ComptimeNumber {
|
|
fn from(value: bool) -> Self {
|
|
Self::Bool(value)
|
|
}
|
|
}
|
|
|
|
impl From<f32> for ComptimeNumber {
|
|
fn from(value: f32) -> Self {
|
|
Self::Floating(ComptimeFloat::Binary32(value))
|
|
}
|
|
}
|
|
|
|
impl From<f64> for ComptimeNumber {
|
|
fn from(value: f64) -> Self {
|
|
Self::Floating(ComptimeFloat::Binary64(value))
|
|
}
|
|
}
|
|
|
|
impl From<BigInt> for ComptimeNumber {
|
|
fn from(value: BigInt) -> Self {
|
|
Self::Integral(ComptimeInt::Comptime(value))
|
|
}
|
|
}
|
|
|
|
impl From<(BigInt, IntegralType)> for ComptimeNumber {
|
|
fn from((bits, ty): (BigInt, IntegralType)) -> Self {
|
|
Self::Integral(ComptimeInt::BigInt { bits, ty })
|
|
}
|
|
}
|
|
impl From<(u128, IntegralType)> for ComptimeNumber {
|
|
fn from((bits, ty): (u128, IntegralType)) -> Self {
|
|
Self::Integral(ComptimeInt::Native { bits, ty })
|
|
}
|
|
}
|
|
|
|
impl ComptimeNumber {
|
|
pub fn bit_count(&self) -> u16 {
|
|
match self {
|
|
ComptimeNumber::Integral(i) => match i {
|
|
ComptimeInt::Native { ty, .. } => ty.bits,
|
|
ComptimeInt::BigInt { ty, .. } => ty.bits,
|
|
ComptimeInt::Comptime(i) => i.bits() as u16,
|
|
},
|
|
ComptimeNumber::Bool(_) => 1,
|
|
ComptimeNumber::Floating(f) => match f {
|
|
ComptimeFloat::Binary32(_) => 32,
|
|
ComptimeFloat::Binary64(_) => 64,
|
|
},
|
|
}
|
|
}
|
|
pub fn add(self, other: Self) -> Result<Self> {
|
|
match (self, other) {
|
|
(ComptimeNumber::Integral(a), ComptimeNumber::Integral(b)) => {
|
|
Ok(Self::Integral(a.add(b)?))
|
|
}
|
|
(ComptimeNumber::Floating(a), ComptimeNumber::Floating(b)) => {
|
|
Ok(Self::Floating(a.add(b)?))
|
|
}
|
|
// (ComptimeNumber::Bool(a), ComptimeNumber::Bool(b)) => Self::Bool(a.add(b)),
|
|
_ => Err(Error::IncompatibleTypes),
|
|
}
|
|
}
|
|
pub fn sub(self, other: Self) -> Result<Self> {
|
|
match (self, other) {
|
|
(ComptimeNumber::Integral(a), ComptimeNumber::Integral(b)) => {
|
|
Ok(Self::Integral(a.sub(b)?))
|
|
}
|
|
(ComptimeNumber::Floating(a), ComptimeNumber::Floating(b)) => {
|
|
Ok(Self::Floating(a.sub(b)?))
|
|
}
|
|
// (ComptimeNumber::Bool(a), ComptimeNumber::Bool(b)) => Self::Bool(a.sub(b)),
|
|
_ => Err(Error::IncompatibleTypes),
|
|
}
|
|
}
|
|
pub fn mul(self, other: Self) -> Result<Self> {
|
|
match (self, other) {
|
|
(ComptimeNumber::Integral(a), ComptimeNumber::Integral(b)) => {
|
|
Ok(Self::Integral(a.mul(b)?))
|
|
}
|
|
(ComptimeNumber::Floating(a), ComptimeNumber::Floating(b)) => {
|
|
Ok(Self::Floating(a.mul(b)?))
|
|
}
|
|
// (ComptimeNumber::Bool(a), ComptimeNumber::Bool(b)) => Self::Bool(a.mul(b)),
|
|
_ => Err(Error::IncompatibleTypes),
|
|
}
|
|
}
|
|
pub fn div(self, other: Self) -> Result<Self> {
|
|
match (self, other) {
|
|
(ComptimeNumber::Integral(a), ComptimeNumber::Integral(b)) => {
|
|
Ok(Self::Integral(a.div(b)?))
|
|
}
|
|
(ComptimeNumber::Floating(a), ComptimeNumber::Floating(b)) => {
|
|
Ok(Self::Floating(a.div(b)?))
|
|
}
|
|
// (ComptimeNumber::Bool(a), ComptimeNumber::Bool(b)) => Self::Bool(a.div(b)),
|
|
_ => Err(Error::IncompatibleTypes),
|
|
}
|
|
}
|
|
pub fn rem(self, other: Self) -> Result<Self> {
|
|
match (self, other) {
|
|
(ComptimeNumber::Integral(a), ComptimeNumber::Integral(b)) => {
|
|
Ok(Self::Integral(a.rem(b)?))
|
|
}
|
|
(ComptimeNumber::Floating(a), ComptimeNumber::Floating(b)) => {
|
|
Ok(Self::Floating(a.rem(b)?))
|
|
}
|
|
// (ComptimeNumber::Bool(a), ComptimeNumber::Bool(b)) => Self::Bool(a.rem(b)),
|
|
_ => Err(Error::IncompatibleTypes),
|
|
}
|
|
}
|
|
pub fn neg(self) -> Result<Self> {
|
|
match self {
|
|
ComptimeNumber::Integral(a) => Ok(Self::Integral(a.neg()?)),
|
|
ComptimeNumber::Floating(a) => Ok(Self::Floating(a.neg()?)),
|
|
//ComptimeNumber::Bool(a) => todo!(),
|
|
_ => Err(Error::IncompatibleTypes),
|
|
}
|
|
}
|
|
pub fn not(self) -> Result<Self> {
|
|
match self {
|
|
ComptimeNumber::Integral(a) => Ok(Self::Integral(a.not()?)),
|
|
// ComptimeNumber::Floating(a) => Ok(Self::Floating(a.not()?)),
|
|
ComptimeNumber::Bool(a) => Ok(Self::Bool(a.not())),
|
|
_ => Err(Error::IncompatibleTypes),
|
|
}
|
|
}
|
|
pub fn bitand(self, other: Self) -> Result<Self> {
|
|
match (self, other) {
|
|
(ComptimeNumber::Integral(a), ComptimeNumber::Integral(b)) => {
|
|
Ok(Self::Integral(a.bitand(b)?))
|
|
}
|
|
// (ComptimeNumber::Floating(a), ComptimeNumber::Floating(b)) => {
|
|
// Ok(Self::Floating(a.sub(b)?))
|
|
// }
|
|
(ComptimeNumber::Bool(a), ComptimeNumber::Bool(b)) => Ok(Self::Bool(a.bitand(b))),
|
|
_ => Err(Error::IncompatibleTypes),
|
|
}
|
|
}
|
|
pub fn bitor(self, other: Self) -> Result<Self> {
|
|
match (self, other) {
|
|
(ComptimeNumber::Integral(a), ComptimeNumber::Integral(b)) => {
|
|
Ok(Self::Integral(a.bitor(b)?))
|
|
}
|
|
// (ComptimeNumber::Floating(a), ComptimeNumber::Floating(b)) => {
|
|
// Ok(Self::Floating(a.bitor(b)?))
|
|
// }
|
|
(ComptimeNumber::Bool(a), ComptimeNumber::Bool(b)) => Ok(Self::Bool(a.bitor(b))),
|
|
_ => Err(Error::IncompatibleTypes),
|
|
}
|
|
}
|
|
pub fn bitxor(self, other: Self) -> Result<Self> {
|
|
match (self, other) {
|
|
(ComptimeNumber::Integral(a), ComptimeNumber::Integral(b)) => {
|
|
Ok(Self::Integral(a.bitxor(b)?))
|
|
}
|
|
// (ComptimeNumber::Floating(a), ComptimeNumber::Floating(b)) => {
|
|
// Ok(Self::Floating(a.bitxor(b)?))
|
|
// }
|
|
(ComptimeNumber::Bool(a), ComptimeNumber::Bool(b)) => Ok(Self::Bool(a.bitxor(b))),
|
|
_ => Err(Error::IncompatibleTypes),
|
|
}
|
|
}
|
|
pub fn shl(self, other: Self) -> Result<Self> {
|
|
match (self, other) {
|
|
(ComptimeNumber::Integral(a), ComptimeNumber::Integral(b)) => {
|
|
Ok(Self::Integral(a.shl(b)?))
|
|
}
|
|
// (ComptimeNumber::Floating(a), ComptimeNumber::Floating(b)) => {
|
|
// Ok(Self::Floating(a.bitxor(b)?))
|
|
// }
|
|
// (ComptimeNumber::Bool(a), ComptimeNumber::Bool(b)) => Ok(Self::Bool(a.bitxor(b))),
|
|
_ => Err(Error::IncompatibleTypes),
|
|
}
|
|
}
|
|
pub fn shr(self, other: Self) -> Result<Self> {
|
|
match (self, other) {
|
|
(ComptimeNumber::Integral(a), ComptimeNumber::Integral(b)) => {
|
|
Ok(Self::Integral(a.shr(b)?))
|
|
}
|
|
// (ComptimeNumber::Floating(a), ComptimeNumber::Floating(b)) => {
|
|
// Ok(Self::Floating(a.bitxor(b)?))
|
|
// }
|
|
// (ComptimeNumber::Bool(a), ComptimeNumber::Bool(b)) => Ok(Self::Bool(a.bitxor(b))),
|
|
_ => Err(Error::IncompatibleTypes),
|
|
}
|
|
}
|
|
pub fn or(self, other: Self) -> Result<Self> {
|
|
match (self, other) {
|
|
// (ComptimeNumber::Integral(a), ComptimeNumber::Integral(b)) => {
|
|
// Ok(Self::Integral(a.shr(b)?))
|
|
// }
|
|
// (ComptimeNumber::Floating(a), ComptimeNumber::Floating(b)) => {
|
|
// Ok(Self::Floating(a.bitxor(b)?))
|
|
// }
|
|
(ComptimeNumber::Bool(a), ComptimeNumber::Bool(b)) => Ok(Self::Bool(a || b)),
|
|
_ => Err(Error::IncompatibleTypes),
|
|
}
|
|
}
|
|
pub fn and(self, other: Self) -> Result<Self> {
|
|
match (self, other) {
|
|
// (ComptimeNumber::Integral(a), ComptimeNumber::Integral(b)) => {
|
|
// Ok(Self::Integral(a.shr(b)?))
|
|
// }
|
|
// (ComptimeNumber::Floating(a), ComptimeNumber::Floating(b)) => {
|
|
// Ok(Self::Floating(a.bitxor(b)?))
|
|
// }
|
|
(ComptimeNumber::Bool(a), ComptimeNumber::Bool(b)) => Ok(Self::Bool(a && b)),
|
|
_ => Err(Error::IncompatibleTypes),
|
|
}
|
|
}
|
|
pub fn eq(self, other: Self) -> Result<Self> {
|
|
match (self, other) {
|
|
(ComptimeNumber::Integral(a), ComptimeNumber::Integral(b)) => Ok(Self::Bool(a == b)),
|
|
(ComptimeNumber::Floating(a), ComptimeNumber::Floating(b)) => Ok(Self::Bool(a == b)),
|
|
(ComptimeNumber::Bool(a), ComptimeNumber::Bool(b)) => Ok(Self::Bool(a == b)),
|
|
_ => Err(Error::IncompatibleTypes),
|
|
}
|
|
}
|
|
|
|
pub fn cmp(self, other: Self) -> Result<Ordering> {
|
|
let ord = match (self, other) {
|
|
(ComptimeNumber::Integral(a), ComptimeNumber::Integral(b)) => a.cmp(b)?,
|
|
(ComptimeNumber::Floating(a), ComptimeNumber::Floating(b)) => a.cmp(b)?,
|
|
(ComptimeNumber::Bool(a), ComptimeNumber::Bool(b)) => a.cmp(&b),
|
|
_ => {
|
|
return Err(Error::IncompatibleTypes);
|
|
}
|
|
};
|
|
|
|
Ok(ord)
|
|
}
|
|
|
|
pub fn lt(self, other: Self) -> Result<Self> {
|
|
Ok(Self::Bool(self.cmp(other)? == Ordering::Less))
|
|
}
|
|
|
|
pub fn gt(self, other: Self) -> Result<Self> {
|
|
Ok(Self::Bool(self.cmp(other)? == Ordering::Greater))
|
|
}
|
|
|
|
pub fn ge(self, other: Self) -> Result<Self> {
|
|
Ok(Self::Bool(self.cmp(other)? != Ordering::Less))
|
|
}
|
|
|
|
pub fn le(self, other: Self) -> Result<Self> {
|
|
Ok(Self::Bool(self.cmp(other)? != Ordering::Greater))
|
|
}
|
|
|
|
pub fn into_bool(self) -> Result<Self> {
|
|
match self {
|
|
ComptimeNumber::Integral(i) => match i {
|
|
ComptimeInt::Native { bits, .. } => Ok((bits != 0).into()),
|
|
ComptimeInt::Comptime(bits) | ComptimeInt::BigInt { bits, .. } => {
|
|
Ok((bits.sign() != Sign::NoSign).into())
|
|
}
|
|
},
|
|
ComptimeNumber::Floating(ComptimeFloat::Binary32(f)) => Ok((f != 0.0).into()),
|
|
ComptimeNumber::Floating(ComptimeFloat::Binary64(f)) => Ok((f != 0.0).into()),
|
|
a => Ok(a),
|
|
}
|
|
}
|
|
|
|
pub fn into_int(self, ty: IntegralType) -> Result<Self> {
|
|
match self {
|
|
ComptimeNumber::Integral(i) => match i {
|
|
ComptimeInt::Native { bits, .. } => Ok((bits & ty.u128_bitmask(), ty).into()),
|
|
ComptimeInt::Comptime(bits) | ComptimeInt::BigInt { bits, .. } => {
|
|
let max = BigUint::from(2u32).pow((ty.bits - ty.signed as u16) as u32);
|
|
let (sign, data) = bits.into_parts();
|
|
let data = data.clamp(BigUint::ZERO, max);
|
|
|
|
Ok((BigInt::from_biguint(sign, data), ty).into())
|
|
}
|
|
},
|
|
ComptimeNumber::Bool(b) => Ok((b as u128 & ty.u128_bitmask(), ty).into()),
|
|
ComptimeNumber::Floating(f) => match f {
|
|
ComptimeFloat::Binary32(f) => Ok((f as u128 & ty.u128_bitmask(), ty).into()),
|
|
ComptimeFloat::Binary64(f) => Ok((f as u128 & ty.u128_bitmask(), ty).into()),
|
|
},
|
|
}
|
|
}
|
|
pub fn into_float(self, ty: FloatingType) -> Result<Self> {
|
|
let f = match self {
|
|
ComptimeNumber::Integral(i) => match i {
|
|
ComptimeInt::Native { bits, .. } => bits as f64,
|
|
ComptimeInt::Comptime(bits) | ComptimeInt::BigInt { bits, .. } => {
|
|
bits.to_f64().unwrap_or(f64::NAN)
|
|
}
|
|
},
|
|
ComptimeNumber::Bool(b) => {
|
|
if b {
|
|
1.0f64
|
|
} else {
|
|
0.0f64
|
|
}
|
|
}
|
|
ComptimeNumber::Floating(f) => match f {
|
|
ComptimeFloat::Binary32(f) => f as f64,
|
|
ComptimeFloat::Binary64(f) => f as f64,
|
|
},
|
|
};
|
|
|
|
match ty {
|
|
FloatingType::Binary32 => Ok((f as f32).into()),
|
|
FloatingType::Binary64 => Ok(f.into()),
|
|
}
|
|
}
|
|
|
|
pub fn into_bytes_and_type(self) -> (Vec<u8>, Type) {
|
|
match self {
|
|
ComptimeNumber::Integral(i) => match i {
|
|
ComptimeInt::Native { bits, ty } => {
|
|
let bytes = (u128::BITS - bits.leading_zeros() + 7) / 8;
|
|
(
|
|
bits.to_le_bytes()[..bytes as usize].to_vec(),
|
|
Type::Integer(ty),
|
|
)
|
|
}
|
|
ComptimeInt::BigInt { bits, ty } => {
|
|
(bits.to_le_bytes().to_vec(), Type::Integer(ty))
|
|
}
|
|
ComptimeInt::Comptime(bits) => {
|
|
(bits.to_le_bytes().to_vec(), Type::comptime_number())
|
|
}
|
|
},
|
|
ComptimeNumber::Bool(b) => (vec![b as u8], Type::bool()),
|
|
ComptimeNumber::Floating(f) => match f {
|
|
ComptimeFloat::Binary32(f) => (
|
|
f.to_le_bytes().to_vec(),
|
|
Type::Floating(FloatingType::Binary32),
|
|
),
|
|
ComptimeFloat::Binary64(f) => (
|
|
f.to_le_bytes().to_vec(),
|
|
Type::Floating(FloatingType::Binary64),
|
|
),
|
|
},
|
|
}
|
|
}
|
|
}
|