diff --git a/Cargo.lock b/Cargo.lock index 72725aac..967181ad 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -58,12 +58,6 @@ version = "1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa" -[[package]] -name = "az" -version = "1.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7b7e4c2464d97fe331d41de9d5db0def0a96f4d823b8b32a2efd503578988973" - [[package]] name = "backtrace" version = "0.3.67" @@ -355,6 +349,73 @@ dependencies = [ "windows-sys 0.48.0", ] +[[package]] +name = "dashu" +version = "0.3.1" +source = "git+https://github.com/coasys/dashu.git#ae7ee53fad213e09da5fe4b30e9e9e8bce96aedd" +dependencies = [ + "dashu-base", + "dashu-float", + "dashu-int", + "dashu-macros", + "dashu-ratio", +] + +[[package]] +name = "dashu-base" +version = "0.3.1" +source = "git+https://github.com/coasys/dashu.git#ae7ee53fad213e09da5fe4b30e9e9e8bce96aedd" + +[[package]] +name = "dashu-float" +version = "0.3.2" +source = "git+https://github.com/coasys/dashu.git#ae7ee53fad213e09da5fe4b30e9e9e8bce96aedd" +dependencies = [ + "dashu-base", + "dashu-int", + "num-order", + "num-traits", + "static_assertions", +] + +[[package]] +name = "dashu-int" +version = "0.3.1" +source = "git+https://github.com/coasys/dashu.git#ae7ee53fad213e09da5fe4b30e9e9e8bce96aedd" +dependencies = [ + "cfg-if", + "dashu-base", + "num-modular 0.6.0", + "num-order", + "num-traits", + "static_assertions", +] + +[[package]] +name = "dashu-macros" +version = "0.3.1" +source = "git+https://github.com/coasys/dashu.git#ae7ee53fad213e09da5fe4b30e9e9e8bce96aedd" +dependencies = [ + "dashu-base", + "dashu-float", + "dashu-int", + "dashu-ratio", + "proc-macro2", + "quote", +] + +[[package]] +name = "dashu-ratio" +version = "0.3.2" +source = "git+https://github.com/coasys/dashu.git#ae7ee53fad213e09da5fe4b30e9e9e8bce96aedd" +dependencies = [ + "dashu-base", + "dashu-float", + "dashu-int", + "num-order", + "num-traits", +] + [[package]] name = "derive_deref" version = "1.1.1" @@ -708,16 +769,6 @@ dependencies = [ "syn 1.0.109", ] -[[package]] -name = "gmp-mpfr-sys" -version = "1.5.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "13eabc29d16e4a621b495e3919c71ebb7caaed24380955671e7d417370fea95d" -dependencies = [ - "libc", - "windows-sys 0.42.0", -] - [[package]] name = "h2" version = "0.3.20" @@ -826,9 +877,9 @@ dependencies = [ [[package]] name = "http-body-util" -version = "0.1.0-rc.2" +version = "0.1.0-rc.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "92445bc9cc14bfa0a3ce56817dc3b5bcc227a168781a356b702410789cec0d10" +checksum = "08ef12f041acdd397010e5fb6433270c147d3b8b2d0a840cd7fff8e531dca5c8" dependencies = [ "bytes", "futures-util", @@ -1048,8 +1099,7 @@ checksum = "b4668fb0ea861c1df094127ac5f1da3409a82116a4ba74fca2e58ef927159bb3" [[package]] name = "libffi" version = "3.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ce826c243048e3d5cec441799724de52e2d42f820468431fc3fceee2341871e2" +source = "git+https://github.com/coasys/libffi-rs.git?branch=windows-space#f6e9e50efde0aa4e940dd6f709a59bb426875362" dependencies = [ "libc", "libffi-sys", @@ -1058,8 +1108,7 @@ dependencies = [ [[package]] name = "libffi-sys" version = "2.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f36115160c57e8529781b4183c2bb51fdc1f6d6d1ed345591d84be7703befb3c" +source = "git+https://github.com/coasys/libffi-rs.git?branch=windows-space#f6e9e50efde0aa4e940dd6f709a59bb426875362" dependencies = [ "cc", ] @@ -1279,6 +1328,41 @@ dependencies = [ "winapi", ] +[[package]] +name = "num-integer" +version = "0.1.45" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9" +dependencies = [ + "autocfg", + "num-traits", +] + +[[package]] +name = "num-modular" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "64a5fe11d4135c3bcdf3a95b18b194afa9608a5f6ff034f5d857bc9a27fb0119" +dependencies = [ + "num-integer", + "num-traits", +] + +[[package]] +name = "num-modular" +version = "0.6.0" +source = "git+https://github.com/coasys/num-modular.git#87d6dc30600207445e07c2cc84e0a47ff58f0aca" + +[[package]] +name = "num-order" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e81e321057a0370997b13e6638bba6bd7f6f426e1f8e9a2562490a28eb23e1bc" +dependencies = [ + "num-modular 0.5.1", + "num-traits", +] + [[package]] name = "num-traits" version = "0.2.15" @@ -1748,17 +1832,6 @@ dependencies = [ "xmlparser", ] -[[package]] -name = "rug" -version = "1.19.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "555e8b44763d034526db899c88cd56ccc4486cd38b444c8aa0e79d4e70ae5a34" -dependencies = [ - "az", - "gmp-mpfr-sys", - "libc", -] - [[package]] name = "rustc-demangle" version = "0.1.23" @@ -1866,6 +1939,7 @@ dependencies = [ "crossterm", "crrl", "ctrlc", + "dashu", "derive_deref", "dirs-next", "divrem", @@ -1888,12 +1962,12 @@ dependencies = [ "predicates-core", "proc-macro2", "quote", + "rand", "ref_thread_local", "reqwest", "ring", "ripemd160", "roxmltree", - "rug", "rustyline", "ryu", "select", @@ -1947,9 +2021,9 @@ dependencies = [ [[package]] name = "serde" -version = "1.0.164" +version = "1.0.174" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9e8c8cf938e98f769bc164923b06dce91cea1751522f46f8466461af04c9027d" +checksum = "3b88756493a5bd5e5395d53baa70b194b05764ab85b59e43e4b8f4e1192fa9b1" [[package]] name = "serde_json" diff --git a/Cargo.toml b/Cargo.toml index 7db6c287..194d4482 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -13,7 +13,6 @@ build = "build/main.rs" rust-version = "1.63" [features] -default = ["rug"] [build-dependencies] indexmap = "1.0.2" @@ -45,7 +44,6 @@ ctrlc = "3.2.2" ordered-float = "2.6.0" phf = { version = "0.9", features = ["macros"] } ref_thread_local = "0.0.0" -rug = { version = "1.15.0", optional = true } rustyline = "12.0.0" ring = "0.16.13" ripemd160 = "0.8.0" @@ -64,12 +62,14 @@ ryu = "1.0.9" hyper = { version = "1.0.0-rc.3", features = ["full"] } tokio = { version = "1.28.2", features = ["full"] } futures = "0.3" -libffi = "3.1.0" libloading = "0.7" derive_deref = "1.1.1" http-body-util = "0.1.0-rc.2" bytes = "1" reqwest = { version = "0.11.18", features = ["blocking"] } +dashu = { git = "https://github.com/coasys/dashu.git" } +libffi = { git = "https://github.com/coasys/libffi-rs.git", branch = "windows-space" } +rand = "0.8.5" [dev-dependencies] assert_cmd = "1.0.3" diff --git a/src/arena.rs b/src/arena.rs index b055c8db..3d321c5a 100644 --- a/src/arena.rs +++ b/src/arena.rs @@ -6,7 +6,7 @@ use crate::raw_block::*; use crate::read::*; use ordered_float::OrderedFloat; -use crate::parser::rug::{Integer, Rational}; +use crate::parser::dashu::{Integer, Rational}; use std::alloc; use std::fmt; @@ -788,7 +788,7 @@ mod tests { use crate::machine::partial_string::*; use ordered_float::OrderedFloat; - use crate::parser::rug::{Integer, Rational}; + use crate::parser::dashu::{Integer, Rational}; #[test] fn float_ptr_cast() { @@ -889,7 +889,7 @@ mod tests { // rational - let big_rat = 2 * Rational::from(1u64 << 63); + let big_rat = Rational::from(2) * Rational::from(1u64 << 63); let big_rat_ptr: TypedArenaPtr = arena_alloc!(big_rat, &mut wam.machine_st.arena); assert!(!big_rat_ptr.as_ptr().is_null()); @@ -915,7 +915,7 @@ mod tests { (HeapCellValueTag::Cons, cons_ptr) => { match_untyped_arena_ptr!(cons_ptr, (ArenaHeaderTag::Rational, n) => { - assert_eq!(&*n, &(2 * Rational::from(1u64 << 63))); + assert_eq!(&*n, &(Rational::from(2) * Rational::from(1u64 << 63))); } _ => unreachable!() ) diff --git a/src/arithmetic.rs b/src/arithmetic.rs index a75f2efe..ded84906 100644 --- a/src/arithmetic.rs +++ b/src/arithmetic.rs @@ -9,11 +9,11 @@ use crate::targets::QueryInstruction; use crate::types::*; use crate::parser::ast::*; -use crate::parser::rug::ops::PowAssign; -use crate::parser::rug::{Assign, Integer, Rational}; +use crate::parser::dashu::{Integer, Rational}; use crate::machine::machine_errors::*; +use dashu::base::Abs; use ordered_float::*; use std::cell::Cell; @@ -386,13 +386,11 @@ pub(crate) fn rnd_i<'a>(n: &'a Number, arena: &mut Arena) -> Number { if I64_MIN_TO_F <= f && f <= I64_MAX_TO_F { fixnum!(Number, f.into_inner() as i64, arena) } else { - Number::Integer(arena_alloc!(Integer::from_f64(f.into_inner()).unwrap(), arena)) + Number::Integer(arena_alloc!(Integer::from(f.0 as i64), arena)) } } &Number::Rational(ref r) => { - let r_ref = r.fract_floor_ref(); - let (mut fract, mut floor) = (Rational::new(), Integer::new()); - (&mut fract, &mut floor).assign(r_ref); + let (_, floor) = (r.fract(), r.floor()); if let Some(floor) = floor.to_i64() { fixnum!(Number, floor, arena) @@ -414,9 +412,9 @@ impl From for Integer { pub(crate) fn rnd_f(n: &Number) -> f64 { match n { &Number::Fixnum(n) => n.get_num() as f64, - &Number::Integer(ref n) => n.to_f64(), + &Number::Integer(ref n) => n.to_f64().value(), &Number::Float(OrderedFloat(f)) => f, - &Number::Rational(ref r) => r.to_f64(), + &Number::Rational(ref r) => r.to_f64().value(), } } @@ -447,12 +445,12 @@ pub(crate) fn float_fn_to_f(n: i64) -> Result { #[inline] pub(crate) fn float_i_to_f(n: &Integer) -> Result { - classify_float(n.to_f64()) + classify_float(n.to_f64().value()) } #[inline] pub(crate) fn float_r_to_f(r: &Rational) -> Result { - classify_float(r.to_f64()) + classify_float(r.to_f64().value()) } #[inline] @@ -551,8 +549,8 @@ impl PartialEq for Number { (&Number::Fixnum(n1), &Number::Float(n2)) => OrderedFloat(n1.get_num() as f64).eq(&n2), (&Number::Float(n1), &Number::Fixnum(n2)) => n1.eq(&OrderedFloat(n2.get_num() as f64)), (&Number::Integer(ref n1), &Number::Integer(ref n2)) => n1.eq(n2), - (&Number::Integer(ref n1), Number::Float(n2)) => OrderedFloat(n1.to_f64()).eq(n2), - (&Number::Float(n1), &Number::Integer(ref n2)) => n1.eq(&OrderedFloat(n2.to_f64())), + (&Number::Integer(ref n1), Number::Float(n2)) => OrderedFloat(n1.to_f64().value()).eq(n2), + (&Number::Float(n1), &Number::Integer(ref n2)) => n1.eq(&OrderedFloat(n2.to_f64().value())), (&Number::Integer(ref n1), &Number::Rational(ref n2)) => { #[cfg(feature = "num")] { @@ -573,8 +571,8 @@ impl PartialEq for Number { &**n1 == &**n2 } } - (&Number::Rational(ref n1), &Number::Float(n2)) => OrderedFloat(n1.to_f64()).eq(&n2), - (&Number::Float(n1), &Number::Rational(ref n2)) => n1.eq(&OrderedFloat(n2.to_f64())), + (&Number::Rational(ref n1), &Number::Float(n2)) => OrderedFloat(n1.to_f64().value()).eq(&n2), + (&Number::Float(n1), &Number::Rational(ref n2)) => n1.eq(&OrderedFloat(n2.to_f64().value())), (&Number::Float(f1), &Number::Float(f2)) => f1.eq(&f2), (&Number::Rational(ref r1), &Number::Rational(ref r2)) => r1.eq(&r2), } @@ -642,8 +640,8 @@ impl Ord for Number { (&Number::Fixnum(n1), &Number::Float(n2)) => OrderedFloat(n1.get_num() as f64).cmp(&n2), (&Number::Float(n1), &Number::Fixnum(n2)) => n1.cmp(&OrderedFloat(n2.get_num() as f64)), (&Number::Integer(n1), &Number::Integer(n2)) => (*n1).cmp(&*n2), - (&Number::Integer(n1), Number::Float(n2)) => OrderedFloat(n1.to_f64()).cmp(n2), - (&Number::Float(n1), &Number::Integer(ref n2)) => n1.cmp(&OrderedFloat(n2.to_f64())), + (&Number::Integer(n1), Number::Float(n2)) => OrderedFloat(n1.to_f64().value()).cmp(n2), + (&Number::Float(n1), &Number::Integer(ref n2)) => n1.cmp(&OrderedFloat(n2.to_f64().value())), (&Number::Integer(n1), &Number::Rational(n2)) => { #[cfg(feature = "num")] { @@ -664,8 +662,8 @@ impl Ord for Number { (&*n1).partial_cmp(&*n2).unwrap_or(Ordering::Less) } } - (&Number::Rational(n1), &Number::Float(n2)) => OrderedFloat(n1.to_f64()).cmp(&n2), - (&Number::Float(n1), &Number::Rational(n2)) => n1.cmp(&OrderedFloat(n2.to_f64())), + (&Number::Rational(n1), &Number::Float(n2)) => OrderedFloat(n1.to_f64().value()).cmp(&n2), + (&Number::Float(n1), &Number::Rational(n2)) => n1.cmp(&OrderedFloat(n2.to_f64().value())), (&Number::Float(f1), &Number::Float(f2)) => f1.cmp(&f2), (&Number::Rational(r1), &Number::Rational(r2)) => (*r1).cmp(&*r2), } @@ -706,7 +704,7 @@ impl TryFrom for Number { // Computes n ^ power. Ignores the sign of power. pub(crate) fn binary_pow(mut n: Integer, power: &Integer) -> Integer { - let mut power = Integer::from(power.abs_ref()); + let mut power = Integer::from(power.abs()); if power == 0 { return Integer::from(1); @@ -719,7 +717,7 @@ pub(crate) fn binary_pow(mut n: Integer, power: &Integer) -> Integer { oddand *= &n; } - n.pow_assign(2); + n = n.pow(2); power >>= 1; } diff --git a/src/forms.rs b/src/forms.rs index 2e04eb0e..fd9c1e28 100644 --- a/src/forms.rs +++ b/src/forms.rs @@ -8,7 +8,7 @@ use crate::machine::machine_errors::*; use crate::machine::machine_indices::*; use crate::parser::ast::*; use crate::parser::parser::CompositeOpDesc; -use crate::parser::rug::{Integer, Rational}; +use crate::parser::dashu::{Integer, Rational}; use crate::types::*; use fxhash::FxBuildHasher; @@ -771,9 +771,9 @@ impl Number { pub(crate) fn is_positive(&self) -> bool { match self { &Number::Fixnum(n) => n.get_num() > 0, - &Number::Integer(ref n) => &**n > &0, + &Number::Integer(ref n) => &**n > &Integer::from(0), &Number::Float(f) => f.is_sign_positive(), - &Number::Rational(ref r) => &**r > &0, + &Number::Rational(ref r) => &**r > &Rational::from(0), } } @@ -781,9 +781,9 @@ impl Number { pub(crate) fn is_negative(&self) -> bool { match self { &Number::Fixnum(n) => n.get_num() < 0, - &Number::Integer(ref n) => &**n < &0, + &Number::Integer(ref n) => &**n < &Integer::from(0), &Number::Float(OrderedFloat(f)) => f.is_sign_negative() && OrderedFloat(f) != -0f64, - &Number::Rational(ref r) => &**r < &0, + &Number::Rational(ref r) => &**r < &Rational::from(0), } } @@ -791,9 +791,9 @@ impl Number { pub(crate) fn is_zero(&self) -> bool { match self { &Number::Fixnum(n) => n.get_num() == 0, - &Number::Integer(ref n) => &**n == &0, + &Number::Integer(ref n) => &**n == &Integer::from(0), &Number::Float(f) => f == OrderedFloat(0f64) || f == OrderedFloat(-0f64), - &Number::Rational(ref r) => &**r == &0, + &Number::Rational(ref r) => &**r == &Rational::from(0), } } diff --git a/src/heap_print.rs b/src/heap_print.rs index d1d87587..5112cda4 100644 --- a/src/heap_print.rs +++ b/src/heap_print.rs @@ -1,7 +1,7 @@ use crate::arena::*; use crate::atom_table::*; use crate::parser::ast::*; -use crate::parser::rug::{Integer, Rational}; +use crate::parser::dashu::{Integer, Rational}; use crate::{ alpha_numeric_char, capital_letter_char, cut_char, decimal_digit_char, graphic_token_char, is_fx, is_infix, is_postfix, is_prefix, is_xf, is_xfx, is_xfy, is_yfx, semicolon_char, @@ -18,6 +18,8 @@ use crate::machine::stack::*; use crate::machine::streams::*; use crate::types::*; +use dashu::base::DivRem; +use dashu::base::DivRemEuclid; use ordered_float::OrderedFloat; use indexmap::IndexMap; @@ -205,7 +207,7 @@ impl NumberFocus { fn is_negative(&self) -> bool { match self { NumberFocus::Unfocused(n) => n.is_negative(), - NumberFocus::Denominator(r) | NumberFocus::Numerator(r) => **r < 0, + NumberFocus::Denominator(r) | NumberFocus::Numerator(r) => **r < Rational::from(0), } } } @@ -411,8 +413,8 @@ fn negated_op_needs_bracketing( && iter.leftmost_leaf_has_property(op_dir, |addr| match Number::try_from(addr) { Ok(Number::Fixnum(n)) => n.get_num() > 0, Ok(Number::Float(f)) => f > OrderedFloat(0f64), - Ok(Number::Integer(n)) => &*n > &0, - Ok(Number::Rational(n)) => &*n > &0, + Ok(Number::Integer(n)) => &*n > &Integer::from(0), + Ok(Number::Rational(n)) => &*n > &Rational::from(0), _ => false, }) } else { @@ -520,11 +522,13 @@ pub(crate) fn numbervar(offset: &Integer, addr: HeapCellValue) -> Option 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', ]; - let i = n.mod_u(26) as usize; - let j = n.div_rem_floor(Integer::from(26)); + let n_clone: Integer = n.clone(); + + let i = n.div_rem_euclid(Integer::from(26)).1.to_f32().value() as usize; + let j = n_clone.div_rem(Integer::from(26)); let j = <(Integer, Integer)>::from(j).0; - if j == 0 { + if j == Integer::from(0) { CHAR_CODES[i].to_string() } else { format!("{}{}", CHAR_CODES[i], j) @@ -540,7 +544,7 @@ pub(crate) fn numbervar(offset: &Integer, addr: HeapCellValue) -> Option } } Ok(Number::Integer(n)) => { - if &*n >= &0 { + if &*n >= &Integer::from(0) { Some(numbervar(Integer::from(offset + &*n))) } else { None @@ -987,14 +991,14 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> { } }, NumberFocus::Denominator(r) => { - let output_str = format!("{}", r.denom()); + let output_str = format!("{}", r.denominator()); push_space_if_amb!(self, &output_str, { append_str!(self, &output_str); }); } NumberFocus::Numerator(r) => { - let output_str = format!("{}", r.numer()); + let output_str = format!("{}", r.numerator()); push_space_if_amb!(self, &output_str, { append_str!(self, &output_str); @@ -1359,10 +1363,10 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> { if self.numbervars && arity == 1 && name == atom!("$VAR") { !self.iter.immediate_leaf_has_property(|addr| { match Number::try_from(addr) { - Ok(Number::Integer(n)) => &*n >= &0, + Ok(Number::Integer(n)) => &*n >= &Integer::from(0), Ok(Number::Fixnum(n)) => n.get_num() >= 0, Ok(Number::Float(f)) => f >= OrderedFloat(0f64), - Ok(Number::Rational(r)) => &*r >= &0, + Ok(Number::Rational(r)) => &*r >= &Integer::from(0), _ => false, } }) && needs_bracketing(op_desc, op) diff --git a/src/machine/arithmetic_ops.rs b/src/machine/arithmetic_ops.rs index 6be49e8d..02087865 100644 --- a/src/machine/arithmetic_ops.rs +++ b/src/machine/arithmetic_ops.rs @@ -1,3 +1,6 @@ +use dashu::base::Abs; +use dashu::base::Gcd; +use dashu::integer::IBig; use divrem::*; use crate::arena::*; @@ -8,7 +11,7 @@ use crate::heap_iter::*; use crate::machine::machine_errors::*; use crate::machine::machine_state::*; use crate::parser::ast::*; -use crate::parser::rug::{Integer, Rational}; +use crate::parser::dashu::{Integer, Rational}; use crate::types::*; use crate::fixnum; @@ -159,7 +162,7 @@ pub(crate) fn add(lhs: Number, rhs: Number, arena: &mut Arena) -> Result { - Ok(Number::arena_from(Integer::from(&*n1) + &*n2, arena)) // add_i + Ok(Number::arena_from(&*n1 + &*n2, arena)) // add_i } (Number::Integer(n1), Number::Float(OrderedFloat(n2))) | (Number::Float(OrderedFloat(n2)), Number::Integer(n1)) => { @@ -167,7 +170,7 @@ pub(crate) fn add(lhs: Number, rhs: Number, arena: &mut Arena) -> Result { - Ok(Number::arena_from(Rational::from(&*n1) + &*n2, arena)) + Ok(Number::arena_from(&*n1 + &*n2, arena)) } (Number::Rational(n1), Number::Float(OrderedFloat(n2))) | (Number::Float(OrderedFloat(n2)), Number::Rational(n1)) => { @@ -177,7 +180,7 @@ pub(crate) fn add(lhs: Number, rhs: Number, arena: &mut Arena) -> Result { - Ok(Number::arena_from(Rational::from(&*r1) + &*r2, arena)) + Ok(Number::arena_from(&*r1 + &*r2, arena)) } } } @@ -191,9 +194,15 @@ pub(crate) fn neg(n: Number, arena: &mut Arena) -> Number { Number::arena_from(-Integer::from(n.get_num()), arena) } } - Number::Integer(n) => Number::arena_from(-Integer::from(&*n), arena), + Number::Integer(n) => { + let n_clone: Integer = (*n).clone(); + Number::arena_from(-Integer::from(n_clone), arena) + }, Number::Float(OrderedFloat(f)) => Number::Float(OrderedFloat(-f)), - Number::Rational(r) => Number::arena_from(-Rational::from(&*r), arena), + Number::Rational(r) => { + let r_clone: Rational = (*r).clone(); + Number::arena_from(-Rational::from(r_clone), arena) + }, } } @@ -203,12 +212,19 @@ pub(crate) fn abs(n: Number, arena: &mut Arena) -> Number { if let Some(n) = n.get_num().checked_abs() { fixnum!(Number, n, arena) } else { - Number::arena_from(Integer::from(n.get_num()).abs(), arena) + let arena_int = Integer::from(n.get_num()); + Number::arena_from(arena_int.abs(), arena) } } - Number::Integer(n) => Number::arena_from(Integer::from(n.abs_ref()), arena), + Number::Integer(n) => { + let n_clone: Integer = (*n).clone(); + Number::arena_from(Integer::from(n_clone.abs()), arena) + }, Number::Float(f) => Number::Float(f.abs()), - Number::Rational(r) => Number::arena_from(Rational::from(r.abs_ref()), arena), + Number::Rational(r) => { + let r_clone: Rational = (*r).clone(); + Number::arena_from(Rational::from(r_clone.abs()), arena) + }, } } @@ -247,7 +263,8 @@ pub(crate) fn mul(lhs: Number, rhs: Number, arena: &mut Arena) -> Result { - Ok(Number::arena_from(Integer::from(&*n1) * &*n2, arena)) // mul_i + let n1_clone: Integer = (*n1).clone(); + Ok(Number::arena_from(Integer::from(n1_clone) * &*n2, arena)) // mul_i } (Number::Integer(n1), Number::Float(OrderedFloat(n2))) | (Number::Float(OrderedFloat(n2)), Number::Integer(n1)) => { @@ -255,7 +272,8 @@ pub(crate) fn mul(lhs: Number, rhs: Number, arena: &mut Arena) -> Result { - Ok(Number::arena_from(Rational::from(&*n1) * &*n2, arena)) + let n1_clone: Integer = (*n1).clone(); + Ok(Number::arena_from(Rational::from(n1_clone) * &*n2, arena)) } (Number::Rational(n1), Number::Float(OrderedFloat(n2))) | (Number::Float(OrderedFloat(n2)), Number::Rational(n1)) => { @@ -265,7 +283,8 @@ pub(crate) fn mul(lhs: Number, rhs: Number, arena: &mut Arena) -> Result { - Ok(Number::arena_from(Rational::from(&*r1) * &*r2, arena)) + let r1_clone: Rational = (*r1).clone(); + Ok(Number::arena_from(Rational::from(r1_clone) * &*r2, arena)) } } } @@ -338,7 +357,7 @@ pub(crate) fn int_pow(n1: Number, n2: Number, arena: &mut Arena) -> Result { let n1_i = n1.get_num(); - if !(n1_i == 1 || n1_i == 0 || n1_i == -1) && &*n2 < &0 { + if !(n1_i == 1 || n1_i == 0 || n1_i == -1) && &*n2 < &Integer::from(0) { let n = Number::Fixnum(n1); Err(numerical_type_error(ValidType::Float, n, stub_gen)) } else { @@ -349,7 +368,7 @@ pub(crate) fn int_pow(n1: Number, n2: Number, arena: &mut Arena) -> Result { let n2_i = n2.get_num(); - if !(&*n1 == &1 || &*n1 == &0 || &*n1 == &-1) && n2_i < 0 { + if !(&*n1 == &Integer::from(1) || &*n1 == &Integer::from(0) || &*n1 == &Integer::from(-1)) && n2_i < 0 { let n = Number::Integer(n1); Err(numerical_type_error(ValidType::Float, n, stub_gen)) } else { @@ -358,7 +377,7 @@ pub(crate) fn int_pow(n1: Number, n2: Number, arena: &mut Arena) -> Result { - if !(&*n1 == &1 || &*n1 == &0 || &*n1 == &-1) && &*n2 < &0 { + if !(&*n1 == &Integer::from(1) || &*n1 == &Integer::from(0) || &*n1 == &Integer::from(-1)) && &*n2 < &Integer::from(0) { let n = Number::Integer(n1); Err(numerical_type_error(ValidType::Float, n, stub_gen)) } else { @@ -521,7 +540,7 @@ pub fn rational_from_number( match n { Number::Fixnum(n) => Ok(arena_alloc!(Rational::from(n.get_num()), arena)), Number::Rational(r) => Ok(r), - Number::Float(OrderedFloat(f)) => match Rational::from_f64(f) { + Number::Float(OrderedFloat(f)) => match Rational::simplest_from_f64(f) { Some(r) => Ok(arena_alloc!(r, arena)), None => Err(Box::new(move |machine_st| { let instantiation_error = machine_st.instantiation_error(); @@ -530,7 +549,10 @@ pub fn rational_from_number( machine_st.error_form(instantiation_error, stub) })), }, - Number::Integer(n) => Ok(arena_alloc!(Rational::from(&*n), arena)), + Number::Integer(n) => { + let n_clone: Integer = (*n).clone(); + Ok(arena_alloc!(Rational::from(n_clone), arena)) + }, } } @@ -590,7 +612,7 @@ pub(crate) fn idiv(n1: Number, n2: Number, arena: &mut Arena) -> Result::from(n1.div_rem_ref(&*n2)).0, + <(Integer, Integer)>::from(n1.div_rem_floor_ref(&*n2)).0, arena, )) } @@ -696,7 +718,7 @@ pub(crate) fn shl(n1: Number, n2: Number, arena: &mut Arena) -> Result Ok(Number::arena_from(n1 << n2, arena)), + Some(n2) => Ok(Number::arena_from(n1.to_u64().unwrap() << n2, arena)), _ => { Ok(Number::arena_from(n1 << usize::max_value(), arena)) } @@ -709,7 +731,7 @@ pub(crate) fn shl(n1: Number, n2: Number, arena: &mut Arena) -> Result match n2.to_u32() { - Some(n2) => Ok(Number::arena_from(Integer::from(&*n1 << n2), arena)), + Some(n2) => Ok(Number::arena_from(Integer::from(n1.to_u64().unwrap() << n2), arena)), _ => { Ok(Number::arena_from(Integer::from(&*n1 << usize::max_value()),arena)) } @@ -926,18 +948,21 @@ pub(crate) fn gcd(n1: Number, n2: Number, arena: &mut Arena) -> Result { let n1 = Integer::from(n1.get_num()); - Ok(Number::arena_from(Integer::from(n2.gcd_ref(&n1)), arena)) + let n2_clone: Integer = (*n2).clone(); + Ok(Number::arena_from(Integer::from(n2_clone.gcd(&n1)), arena)) } (Number::Integer(n1), Number::Integer(n2)) => { - Ok(Number::arena_from(Integer::from(n1.gcd_ref(&n2)), arena)) + let n1_clone: Integer = (*n1).clone(); + Ok(Number::arena_from(Integer::from(n1_clone.gcd(&Integer::from(n2.to_isize().unwrap()))) as IBig, arena)) } (Number::Float(f), _) | (_, Number::Float(f)) => { let n = Number::Float(f); diff --git a/src/machine/disjuncts.rs b/src/machine/disjuncts.rs index e8b59ed2..6c6d3a7b 100644 --- a/src/machine/disjuncts.rs +++ b/src/machine/disjuncts.rs @@ -6,9 +6,10 @@ use crate::machine::loader::*; use crate::machine::machine_errors::CompilationError; use crate::machine::preprocessor::*; use crate::parser::ast::*; -use crate::parser::rug::Rational; +use crate::parser::dashu::Rational; use crate::variable_records::*; +use dashu::Integer; use indexmap::{IndexMap, IndexSet}; use std::cell::Cell; @@ -221,7 +222,7 @@ fn merge_branch_seq(branches: impl Iterator) -> BranchInfo { branch_info.chunks.extend(branch.chunks.drain(..)); } - branch_info.branch_num.delta *= 2; + branch_info.branch_num.delta = branch_info.branch_num.delta * Integer::from(2); branch_info.branch_num.branch_num -= &branch_info.branch_num.delta; branch_info diff --git a/src/machine/dispatch.rs b/src/machine/dispatch.rs index 31592d68..6eeedb63 100644 --- a/src/machine/dispatch.rs +++ b/src/machine/dispatch.rs @@ -2608,7 +2608,7 @@ impl Machine { self.machine_st.p += 1; } Ok(Number::Rational(n)) => { - if n.denom() == &1 { + if n.denominator().is_one() { self.machine_st.p += 1; } else { self.machine_st.backtrack(); @@ -2627,7 +2627,7 @@ impl Machine { self.machine_st.p = self.machine_st.cp; } Ok(Number::Rational(n)) => { - if n.denom() == &1 { + if n.denominator().is_one() { self.machine_st.p = self.machine_st.cp; } else { self.machine_st.backtrack(); diff --git a/src/machine/heap.rs b/src/machine/heap.rs index 59e63009..1cdfeb74 100644 --- a/src/machine/heap.rs +++ b/src/machine/heap.rs @@ -6,7 +6,7 @@ use crate::machine::partial_string::*; use crate::parser::ast::*; use crate::types::*; -use crate::parser::rug::{Integer, Rational}; +use crate::parser::dashu::{Integer, Rational}; use std::convert::TryFrom; diff --git a/src/machine/loader.rs b/src/machine/loader.rs index 0c39063c..b65c2351 100644 --- a/src/machine/loader.rs +++ b/src/machine/loader.rs @@ -1649,7 +1649,7 @@ impl Machine { .store(self.machine_st.deref(self.machine_st.registers[3])); let arity = match Number::try_from(arity) { - Ok(Number::Integer(n)) if &*n >= &0 && &*n <= &MAX_ARITY => Ok(n.to_usize().unwrap()), + Ok(Number::Integer(n)) if &*n >= &Integer::from(0) && &*n <= &Integer::from(MAX_ARITY) => Ok(n.to_usize().unwrap()), Ok(Number::Fixnum(n)) if n.get_num() >= 0 && n.get_num() <= MAX_ARITY as i64 => { Ok(usize::try_from(n.get_num()).unwrap()) } diff --git a/src/machine/machine_state.rs b/src/machine/machine_state.rs index d76e1cf1..ccd65764 100644 --- a/src/machine/machine_state.rs +++ b/src/machine/machine_state.rs @@ -15,7 +15,7 @@ use crate::parser::ast::*; use crate::read::TermWriteResult; use crate::types::*; -use crate::parser::rug::Integer; +use crate::parser::dashu::Integer; use indexmap::IndexMap; diff --git a/src/machine/machine_state_impl.rs b/src/machine/machine_state_impl.rs index a161481c..90036db6 100644 --- a/src/machine/machine_state_impl.rs +++ b/src/machine/machine_state_impl.rs @@ -13,7 +13,7 @@ use crate::machine::partial_string::*; use crate::machine::stack::*; use crate::machine::unify::*; use crate::parser::ast::*; -use crate::parser::rug::{Integer, Rational}; +use crate::parser::dashu::{Integer, Rational}; use indexmap::IndexSet; @@ -1385,7 +1385,7 @@ impl MachineState { Ok(Number::Float(_)) => { return type_error(arity); } - Ok(Number::Rational(n)) if n.denom() != &1 => { + Ok(Number::Rational(n)) if !n.denominator().is_one() => { return type_error(arity); } Ok(n) if n > MAX_ARITY => { @@ -1398,7 +1398,7 @@ impl MachineState { let err = self.domain_error(DomainErrorType::NotLessThanZero, n); return Err(self.error_form(err, stub_gen())); } - Ok(Number::Rational(n)) => n.numer().to_i64().unwrap(), + Ok(Number::Rational(n)) => n.numerator().to_i64().unwrap(), Ok(Number::Fixnum(n)) => n.get_num(), Ok(Number::Integer(n)) => n.to_i64().unwrap(), Err(_) => { diff --git a/src/machine/mod.rs b/src/machine/mod.rs index afbdda67..a3f0a24c 100644 --- a/src/machine/mod.rs +++ b/src/machine/mod.rs @@ -41,7 +41,7 @@ use crate::machine::machine_state::*; use crate::machine::stack::*; use crate::machine::streams::*; use crate::parser::ast::*; -use crate::parser::rug::{Integer, Rational}; +use crate::parser::dashu::{Integer, Rational}; use crate::types::*; use indexmap::IndexMap; @@ -1259,4 +1259,4 @@ impl Machine { } } } -} +} \ No newline at end of file diff --git a/src/machine/system_calls.rs b/src/machine/system_calls.rs index 85d26922..016a3c7d 100644 --- a/src/machine/system_calls.rs +++ b/src/machine/system_calls.rs @@ -1,6 +1,7 @@ use crate::parser::ast::*; use crate::parser::parser::*; +use dashu::integer::UBig; use lazy_static::lazy_static; use crate::arena::*; @@ -24,22 +25,24 @@ use crate::machine::preprocessor::to_op_decl; use crate::machine::stack::*; use crate::machine::streams::*; use crate::parser::char_reader::*; -use crate::parser::rug::Integer; -use crate::parser::rug::rand::RandState; +use crate::parser::dashu::Integer; use crate::read::*; use crate::types::*; +use rand::{Rng, SeedableRng}; +use rand::rngs::StdRng; use ordered_float::OrderedFloat; use fxhash::{FxBuildHasher, FxHasher}; use indexmap::IndexSet; -use ref_thread_local::{RefThreadLocal, ref_thread_local}; +pub(crate) use ref_thread_local::RefThreadLocal; +use std::borrow::BorrowMut; use std::cell::Cell; use std::cmp::Ordering; use std::collections::BTreeSet; -use std::convert::{TryFrom}; +use std::convert::TryFrom; use std::env; use std::ffi::CString; use std::fs; @@ -86,10 +89,6 @@ use http_body_util::BodyExt; use bytes::Buf; use reqwest::Url; -ref_thread_local! { - pub(crate) static managed RANDOM_STATE: RandState<'static> = RandState::new(); -} - pub(crate) fn get_key() -> KeyEvent { let key; enable_raw_mode().expect("failed to enable raw mode"); @@ -2733,7 +2732,7 @@ impl Machine { // n has already been confirmed as an integer, and // internally, Rational is assumed reduced, so its denominator // must be 1. - r.numer().to_string() + r.numerator().to_string() } _ => { unreachable!() @@ -2762,7 +2761,7 @@ impl Machine { // n has already been confirmed as an integer, and // internally, Rational is assumed reduced, so its // denominator must be 1. - r.numer().to_string() + r.numerator().to_string() } _ => { unreachable!() @@ -4138,9 +4137,24 @@ impl Machine { #[inline(always)] pub(crate) fn maybe(&mut self) { + fn generate_random_bits(num_bits: usize) -> u64 { + let mut rng = rand::thread_rng(); + let rand = rng.borrow_mut(); + let mut random_bits: u64 = 0; + + for _ in 0..num_bits { + random_bits <<= 1; + + if rand.gen_bool(0.5) { + random_bits |= 1; + } + } + + random_bits + } + let result = { - let mut rand = RANDOM_STATE.borrow_mut(); - rand.bits(1) == 0 + generate_random_bits(1) == 0 }; self.machine_st.fail = result; @@ -5239,7 +5253,7 @@ impl Machine { // n has already been confirmed as an integer, and // internally, Rational is assumed reduced, so its // denominator must be 1. - r.numer().to_u8().unwrap() + r.numerator().to_u8().unwrap() } _ => { unreachable!() @@ -5950,12 +5964,20 @@ impl Machine { #[inline(always)] pub(crate) fn set_seed(&mut self) { let seed = self.deref_register(1); - let mut rand = RANDOM_STATE.borrow_mut(); + match Number::try_from(seed) { - Ok(Number::Fixnum(n)) => rand.seed(&Integer::from(n)), - Ok(Number::Integer(n)) => rand.seed(&*n), - Ok(Number::Rational(n)) if n.denom() == &1 => rand.seed(n.numer()), + Ok(Number::Fixnum(n)) => { + let _: StdRng = SeedableRng::seed_from_u64(Integer::from(n).to_u64().unwrap()); + }, + Ok(Number::Integer(n)) => { + let _: StdRng = SeedableRng::seed_from_u64(n.to_u64().unwrap()); + }, + Ok(Number::Rational(n)) => { + if n.denominator() == &UBig::from(1 as u32) { + let _: StdRng = SeedableRng::seed_from_u64(n.numerator().to_u64().unwrap()); + } + }, _ => { self.machine_st.fail = true; } @@ -5969,7 +5991,7 @@ impl Machine { let time = match Number::try_from(time) { Ok(Number::Float(n)) => n.into_inner(), Ok(Number::Fixnum(n)) => n.get_num() as f64, - Ok(Number::Integer(n)) => n.to_f64(), + Ok(Number::Integer(n)) => n.to_f64().value(), _ => { unreachable!() } @@ -7625,7 +7647,7 @@ impl Machine { Number::Fixnum(Fixnum::build_with(n.get_num().count_ones() as i64)) } Ok(Number::Integer(n)) => { - Number::arena_from(n.count_ones().unwrap(), &mut self.machine_st.arena) + Number::arena_from(n.count_ones(), &mut self.machine_st.arena) } _ => { unreachable!() diff --git a/src/parser/ast.rs b/src/parser/ast.rs index 68ebd0fa..fc728782 100644 --- a/src/parser/ast.rs +++ b/src/parser/ast.rs @@ -12,7 +12,7 @@ use std::ops::{Deref, Neg}; use std::rc::Rc; use std::vec::Vec; -use crate::parser::rug::{Integer, Rational}; +use crate::parser::dashu::{Integer, Rational}; use fxhash::FxBuildHasher; use indexmap::IndexMap; diff --git a/src/parser/lexer.rs b/src/parser/lexer.rs index 664af935..3aa82d13 100644 --- a/src/parser/lexer.rs +++ b/src/parser/lexer.rs @@ -5,7 +5,7 @@ use crate::atom_table::*; pub use crate::machine::machine_state::*; use crate::parser::ast::*; use crate::parser::char_reader::*; -use crate::parser::rug::Integer; +use crate::parser::dashu::Integer; use std::convert::TryFrom; use std::fmt; diff --git a/src/parser/mod.rs b/src/parser/mod.rs index fa7b8859..ef6a8e0a 100644 --- a/src/parser/mod.rs +++ b/src/parser/mod.rs @@ -1,8 +1,4 @@ -#[cfg(feature = "num-rug-adapter")] -pub use num_rug_adapter as rug; - -#[cfg(feature = "rug")] -pub use rug; +pub use dashu; // #[macro_use] // extern crate lazy_static; diff --git a/src/parser/parser.rs b/src/parser/parser.rs index a952f73f..b14e0923 100644 --- a/src/parser/parser.rs +++ b/src/parser/parser.rs @@ -1,13 +1,16 @@ +use dashu::Integer; +use dashu::Rational; + use crate::arena::*; use crate::atom_table::*; use crate::parser::ast::*; use crate::parser::char_reader::*; use crate::parser::lexer::*; -use crate::parser::rug::ops::NegAssign; use std::cell::Cell; use std::mem; +use std::ops::Neg; #[derive(Debug, Clone, Copy, PartialEq)] enum TokenType { @@ -950,9 +953,16 @@ impl<'a, R: CharRead> Parser<'a, R> { } fn shift_token(&mut self, token: Token, op_dir: &CompositeOpDir) -> Result<(), ParserError> { - fn negate_rc(mut t: TypedArenaPtr) -> TypedArenaPtr { - (&mut t).neg_assign(); - t + fn negate_int_rc(t: TypedArenaPtr) -> TypedArenaPtr { + let i: Integer = (*t).clone(); + let mut data = i.neg(); + TypedArenaPtr::new(&mut data) + } + + fn negate_rat_rc(t: TypedArenaPtr) -> TypedArenaPtr { + let r: Rational = (*t).clone(); + let mut data = r.neg(); + TypedArenaPtr::new(&mut data) } match token { @@ -960,10 +970,10 @@ impl<'a, R: CharRead> Parser<'a, R> { self.negate_number(n, |n| -n, |n, _| Literal::Fixnum(n)) } Token::Literal(Literal::Integer(n)) => { - self.negate_number(n, negate_rc, |n, _| Literal::Integer(n)) + self.negate_number(n, negate_int_rc, |n, _| Literal::Integer(n)) } Token::Literal(Literal::Rational(n)) => { - self.negate_number(n, negate_rc, |r, _| Literal::Rational(r)) + self.negate_number(n, negate_rat_rc, |r, _| Literal::Rational(r)) } Token::Literal(Literal::Float(n)) => self.negate_number( **n.as_ptr(),