722 lines
25 KiB
Rust
722 lines
25 KiB
Rust
use crate::allocator::*;
|
|
use crate::arena::*;
|
|
use crate::atom_table::*;
|
|
use crate::fixtures::*;
|
|
use crate::forms::*;
|
|
use crate::instructions::*;
|
|
use crate::iterators::*;
|
|
use crate::types::*;
|
|
|
|
use crate::parser::ast::*;
|
|
use crate::parser::rug::ops::PowAssign;
|
|
use crate::parser::rug::{Assign, Integer, Rational};
|
|
|
|
use crate::machine::machine_errors::*;
|
|
use crate::machine::machine_indices::*;
|
|
|
|
use ordered_float::*;
|
|
|
|
use std::cell::Cell;
|
|
use std::cmp::{max, min, Ordering};
|
|
use std::convert::TryFrom;
|
|
use std::f64;
|
|
use std::num::FpCategory;
|
|
use std::ops::Div;
|
|
use std::rc::Rc;
|
|
use std::vec::Vec;
|
|
|
|
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
|
|
pub enum ArithmeticTerm {
|
|
Reg(RegType),
|
|
Interm(usize),
|
|
Number(Number),
|
|
}
|
|
|
|
impl ArithmeticTerm {
|
|
pub(crate) fn interm_or(&self, interm: usize) -> usize {
|
|
if let &ArithmeticTerm::Interm(interm) = self {
|
|
interm
|
|
} else {
|
|
interm
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Default for ArithmeticTerm {
|
|
fn default() -> Self {
|
|
ArithmeticTerm::Number(Number::default())
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub(crate) struct ArithInstructionIterator<'a> {
|
|
state_stack: Vec<TermIterState<'a>>,
|
|
}
|
|
|
|
pub(crate) type ArithCont = (Code, Option<ArithmeticTerm>);
|
|
|
|
impl<'a> ArithInstructionIterator<'a> {
|
|
fn push_subterm(&mut self, lvl: Level, term: &'a Term) {
|
|
self.state_stack
|
|
.push(TermIterState::subterm_to_state(lvl, term));
|
|
}
|
|
|
|
fn from(term: &'a Term) -> Result<Self, ArithmeticError> {
|
|
let state = match term {
|
|
Term::AnonVar => return Err(ArithmeticError::UninstantiatedVar),
|
|
Term::Clause(cell, name, terms) => match ClauseType::from(*name, terms.len()) {
|
|
ct @ ClauseType::Named(..) => {
|
|
Ok(TermIterState::Clause(Level::Shallow, 0, cell, ct, terms))
|
|
}
|
|
ClauseType::Inlined(InlinedClauseType::IsFloat(_)) => {
|
|
let ct = ClauseType::Named(1, atom!("float"), CodeIndex::default());
|
|
Ok(TermIterState::Clause(Level::Shallow, 0, cell, ct, terms))
|
|
}
|
|
_ => Err(ArithmeticError::NonEvaluableFunctor(
|
|
Literal::Atom(*name),
|
|
terms.len(),
|
|
)),
|
|
}?,
|
|
Term::Literal(cell, cons) => TermIterState::Literal(Level::Shallow, cell, cons),
|
|
Term::Cons(..) | Term::PartialString(..) => {
|
|
return Err(ArithmeticError::NonEvaluableFunctor(
|
|
Literal::Atom(atom!(".")),
|
|
2,
|
|
))
|
|
}
|
|
Term::Var(cell, var) => TermIterState::Var(Level::Shallow, cell, var.clone()),
|
|
};
|
|
|
|
Ok(ArithInstructionIterator {
|
|
state_stack: vec![state],
|
|
})
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub(crate) enum ArithTermRef<'a> {
|
|
Literal(&'a Literal),
|
|
Op(Atom, usize), // name, arity.
|
|
Var(Level, &'a Cell<VarReg>, Rc<String>),
|
|
}
|
|
|
|
impl<'a> Iterator for ArithInstructionIterator<'a> {
|
|
type Item = Result<ArithTermRef<'a>, ArithmeticError>;
|
|
|
|
fn next(&mut self) -> Option<Self::Item> {
|
|
while let Some(iter_state) = self.state_stack.pop() {
|
|
match iter_state {
|
|
TermIterState::AnonVar(_) => return Some(Err(ArithmeticError::UninstantiatedVar)),
|
|
TermIterState::Clause(lvl, child_num, cell, ct, subterms) => {
|
|
let arity = subterms.len();
|
|
|
|
if child_num == arity {
|
|
return Some(Ok(ArithTermRef::Op(ct.name(), arity)));
|
|
} else {
|
|
self.state_stack.push(TermIterState::Clause(
|
|
lvl,
|
|
child_num + 1,
|
|
cell,
|
|
ct,
|
|
subterms,
|
|
));
|
|
|
|
self.push_subterm(lvl, &subterms[child_num]);
|
|
}
|
|
}
|
|
TermIterState::Literal(_, _, c) => return Some(Ok(ArithTermRef::Literal(c))),
|
|
TermIterState::Var(lvl, cell, var) => {
|
|
// the expression is the second argument of an
|
|
// is/2 but the iterator can't see that, so the
|
|
// level needs to be demoted manually.
|
|
return Some(Ok(ArithTermRef::Var(lvl.child_level(), cell, var.clone())));
|
|
}
|
|
_ => {
|
|
return Some(Err(ArithmeticError::NonEvaluableFunctor(
|
|
Literal::Atom(atom!(".")),
|
|
2,
|
|
)));
|
|
}
|
|
};
|
|
}
|
|
|
|
None
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub(crate) struct ArithmeticEvaluator<'a, TermMarker> {
|
|
marker: &'a mut TermMarker,
|
|
interm: Vec<ArithmeticTerm>,
|
|
interm_c: usize,
|
|
}
|
|
|
|
pub(crate) trait ArithmeticTermIter<'a> {
|
|
type Iter: Iterator<Item = Result<ArithTermRef<'a>, ArithmeticError>>;
|
|
|
|
fn iter(self) -> Result<Self::Iter, ArithmeticError>;
|
|
}
|
|
|
|
impl<'a> ArithmeticTermIter<'a> for &'a Term {
|
|
type Iter = ArithInstructionIterator<'a>;
|
|
|
|
fn iter(self) -> Result<Self::Iter, ArithmeticError> {
|
|
ArithInstructionIterator::from(self)
|
|
}
|
|
}
|
|
|
|
fn push_literal(interm: &mut Vec<ArithmeticTerm>, c: &Literal) -> Result<(), ArithmeticError> {
|
|
match c {
|
|
Literal::Fixnum(n) => interm.push(ArithmeticTerm::Number(Number::Fixnum(*n))),
|
|
Literal::Integer(n) => interm.push(ArithmeticTerm::Number(Number::Integer(*n))),
|
|
Literal::Float(n) => interm.push(ArithmeticTerm::Number(Number::Float(**n))),
|
|
Literal::Rational(n) => interm.push(ArithmeticTerm::Number(Number::Rational(*n))),
|
|
Literal::Atom(name) if name == &atom!("e") => interm.push(ArithmeticTerm::Number(
|
|
Number::Float(OrderedFloat(std::f64::consts::E))
|
|
)),
|
|
Literal::Atom(name) if name == &atom!("pi") => interm.push(ArithmeticTerm::Number(
|
|
Number::Float(OrderedFloat(std::f64::consts::PI))
|
|
)),
|
|
Literal::Atom(name) if name == &atom!("epsilon") => interm.push(ArithmeticTerm::Number(
|
|
Number::Float(OrderedFloat(std::f64::EPSILON))
|
|
)),
|
|
_ => return Err(ArithmeticError::NonEvaluableFunctor(*c, 0)),
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
impl<'a, TermMarker: Allocator> ArithmeticEvaluator<'a, TermMarker> {
|
|
pub(crate) fn new(marker: &'a mut TermMarker, target_int: usize) -> Self {
|
|
ArithmeticEvaluator {
|
|
marker,
|
|
interm: Vec::new(),
|
|
interm_c: target_int,
|
|
}
|
|
}
|
|
|
|
fn get_unary_instr(
|
|
&self,
|
|
name: Atom,
|
|
a1: ArithmeticTerm,
|
|
t: usize,
|
|
) -> Result<Instruction, ArithmeticError> {
|
|
match name {
|
|
atom!("abs") => Ok(Instruction::Abs(a1, t)),
|
|
atom!("-") => Ok(Instruction::Neg(a1, t)),
|
|
atom!("+") => Ok(Instruction::Plus(a1, t)),
|
|
atom!("cos") => Ok(Instruction::Cos(a1, t)),
|
|
atom!("sin") => Ok(Instruction::Sin(a1, t)),
|
|
atom!("tan") => Ok(Instruction::Tan(a1, t)),
|
|
atom!("log") => Ok(Instruction::Log(a1, t)),
|
|
atom!("exp") => Ok(Instruction::Exp(a1, t)),
|
|
atom!("sqrt") => Ok(Instruction::Sqrt(a1, t)),
|
|
atom!("acos") => Ok(Instruction::ACos(a1, t)),
|
|
atom!("asin") => Ok(Instruction::ASin(a1, t)),
|
|
atom!("atan") => Ok(Instruction::ATan(a1, t)),
|
|
atom!("float") => Ok(Instruction::Float(a1, t)),
|
|
atom!("truncate") => Ok(Instruction::Truncate(a1, t)),
|
|
atom!("round") => Ok(Instruction::Round(a1, t)),
|
|
atom!("ceiling") => Ok(Instruction::Ceiling(a1, t)),
|
|
atom!("floor") => Ok(Instruction::Floor(a1, t)),
|
|
atom!("sign") => Ok(Instruction::Sign(a1, t)),
|
|
atom!("\\") => Ok(Instruction::BitwiseComplement(a1, t)),
|
|
_ => Err(ArithmeticError::NonEvaluableFunctor(Literal::Atom(name), 1)),
|
|
}
|
|
}
|
|
|
|
fn get_binary_instr(
|
|
&self,
|
|
name: Atom,
|
|
a1: ArithmeticTerm,
|
|
a2: ArithmeticTerm,
|
|
t: usize,
|
|
) -> Result<Instruction, ArithmeticError> {
|
|
match name {
|
|
atom!("+") => Ok(Instruction::Add(a1, a2, t)),
|
|
atom!("-") => Ok(Instruction::Sub(a1, a2, t)),
|
|
atom!("/") => Ok(Instruction::Div(a1, a2, t)),
|
|
atom!("//") => Ok(Instruction::IDiv(a1, a2, t)),
|
|
atom!("max") => Ok(Instruction::Max(a1, a2, t)),
|
|
atom!("min") => Ok(Instruction::Min(a1, a2, t)),
|
|
atom!("div") => Ok(Instruction::IntFloorDiv(a1, a2, t)),
|
|
atom!("rdiv") => Ok(Instruction::RDiv(a1, a2, t)),
|
|
atom!("*") => Ok(Instruction::Mul(a1, a2, t)),
|
|
atom!("**") => Ok(Instruction::Pow(a1, a2, t)),
|
|
atom!("^") => Ok(Instruction::IntPow(a1, a2, t)),
|
|
atom!(">>") => Ok(Instruction::Shr(a1, a2, t)),
|
|
atom!("<<") => Ok(Instruction::Shl(a1, a2, t)),
|
|
atom!("/\\") => Ok(Instruction::And(a1, a2, t)),
|
|
atom!("\\/") => Ok(Instruction::Or(a1, a2, t)),
|
|
atom!("xor") => Ok(Instruction::Xor(a1, a2, t)),
|
|
atom!("mod") => Ok(Instruction::Mod(a1, a2, t)),
|
|
atom!("rem") => Ok(Instruction::Rem(a1, a2, t)),
|
|
atom!("gcd") => Ok(Instruction::Gcd(a1, a2, t)),
|
|
atom!("atan2") => Ok(Instruction::ATan2(a1, a2, t)),
|
|
_ => Err(ArithmeticError::NonEvaluableFunctor(Literal::Atom(name), 2)),
|
|
}
|
|
}
|
|
|
|
fn incr_interm(&mut self) -> usize {
|
|
let temp = self.interm_c;
|
|
|
|
self.interm.push(ArithmeticTerm::Interm(temp));
|
|
self.interm_c += 1;
|
|
|
|
temp
|
|
}
|
|
|
|
fn instr_from_clause(
|
|
&mut self,
|
|
name: Atom,
|
|
arity: usize,
|
|
) -> Result<Instruction, ArithmeticError> {
|
|
match arity {
|
|
1 => {
|
|
let a1 = self.interm.pop().unwrap();
|
|
|
|
let ninterm = if a1.interm_or(0) == 0 {
|
|
self.incr_interm()
|
|
} else {
|
|
self.interm.push(a1.clone());
|
|
a1.interm_or(0)
|
|
};
|
|
|
|
self.get_unary_instr(name, a1, ninterm)
|
|
}
|
|
2 => {
|
|
let a2 = self.interm.pop().unwrap();
|
|
let a1 = self.interm.pop().unwrap();
|
|
|
|
let min_interm = min(a1.interm_or(0), a2.interm_or(0));
|
|
|
|
let ninterm = if min_interm == 0 {
|
|
let max_interm = max(a1.interm_or(0), a2.interm_or(0));
|
|
|
|
if max_interm == 0 {
|
|
self.incr_interm()
|
|
} else {
|
|
self.interm.push(ArithmeticTerm::Interm(max_interm));
|
|
self.interm_c = max_interm + 1;
|
|
max_interm
|
|
}
|
|
} else {
|
|
self.interm.push(ArithmeticTerm::Interm(min_interm));
|
|
self.interm_c = min_interm + 1;
|
|
min_interm
|
|
};
|
|
|
|
self.get_binary_instr(name, a1, a2, ninterm)
|
|
}
|
|
_ => Err(ArithmeticError::NonEvaluableFunctor(
|
|
Literal::Atom(name),
|
|
arity,
|
|
)),
|
|
}
|
|
}
|
|
|
|
pub(crate) fn eval(
|
|
&mut self,
|
|
src: &'a Term,
|
|
term_loc: GenContext,
|
|
) -> Result<ArithCont, ArithmeticError>
|
|
{
|
|
let mut code = vec![];
|
|
let mut iter = src.iter()?;
|
|
|
|
while let Some(term_ref) = iter.next() {
|
|
match term_ref? {
|
|
ArithTermRef::Literal(c) => push_literal(&mut self.interm, c)?,
|
|
ArithTermRef::Var(lvl, cell, name) => {
|
|
let r = if cell.get().norm().reg_num() == 0 {
|
|
let mut getter = || {
|
|
use crate::targets::QueryInstruction;
|
|
|
|
loop {
|
|
match self.marker.bindings().get(&name) {
|
|
Some(&VarData::Temp(_, t, _)) if t != 0 =>
|
|
return RegType::Temp(t),
|
|
Some(&VarData::Perm(p)) if p != 0 =>
|
|
return RegType::Perm(p),
|
|
_ => {
|
|
self.marker.mark_var::<QueryInstruction>(
|
|
name.clone(),
|
|
lvl,
|
|
cell,
|
|
term_loc,
|
|
&mut code,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
getter()
|
|
/*
|
|
_ => return Err(ArithmeticError::UninstantiatedVar),
|
|
*/
|
|
} else {
|
|
cell.get().norm()
|
|
};
|
|
|
|
self.interm.push(ArithmeticTerm::Reg(r));
|
|
}
|
|
ArithTermRef::Op(name, arity) => {
|
|
code.push(self.instr_from_clause(name, arity)?);
|
|
}
|
|
}
|
|
}
|
|
|
|
Ok((code, self.interm.pop()))
|
|
}
|
|
}
|
|
|
|
// integer division rounding function -- 9.1.3.1.
|
|
pub(crate) fn rnd_i<'a>(n: &'a Number, arena: &mut Arena) -> Number {
|
|
match n {
|
|
&Number::Integer(_) | &Number::Fixnum(_) => *n,
|
|
&Number::Float(f) => {
|
|
let f = f.floor();
|
|
|
|
const I64_MIN_TO_F: OrderedFloat<f64> = OrderedFloat(i64::MIN as f64);
|
|
const I64_MAX_TO_F: OrderedFloat<f64> = OrderedFloat(i64::MIN as f64);
|
|
|
|
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::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);
|
|
|
|
Number::Integer(arena_alloc!(floor, arena))
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<Fixnum> for Integer {
|
|
#[inline]
|
|
fn from(n: Fixnum) -> Integer {
|
|
Integer::from(n.get_num())
|
|
}
|
|
}
|
|
|
|
// floating point rounding function -- 9.1.4.1.
|
|
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::Float(OrderedFloat(f)) => f,
|
|
&Number::Rational(ref r) => r.to_f64(),
|
|
}
|
|
}
|
|
|
|
// floating point result function -- 9.1.4.2.
|
|
pub(crate) fn result_f(n: &Number) -> Result<f64, EvalError> {
|
|
classify_float(rnd_f(n))
|
|
}
|
|
|
|
fn classify_float(f: f64) -> Result<f64, EvalError> {
|
|
match f.classify() {
|
|
FpCategory::Normal | FpCategory::Zero => Ok(f),
|
|
FpCategory::Infinite => {
|
|
if OrderedFloat(f) == OrderedFloat(f64::MAX) {
|
|
Ok(f)
|
|
} else {
|
|
Err(EvalError::FloatOverflow)
|
|
}
|
|
}
|
|
FpCategory::Nan => Err(EvalError::Undefined),
|
|
_ => Ok(f)
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub(crate) fn float_fn_to_f(n: i64) -> Result<f64, EvalError> {
|
|
classify_float(n as f64)
|
|
}
|
|
|
|
#[inline]
|
|
pub(crate) fn float_i_to_f(n: &Integer) -> Result<f64, EvalError> {
|
|
classify_float(n.to_f64())
|
|
}
|
|
|
|
#[inline]
|
|
pub(crate) fn float_r_to_f(r: &Rational) -> Result<f64, EvalError> {
|
|
classify_float(r.to_f64())
|
|
}
|
|
|
|
#[inline]
|
|
pub(crate) fn add_f(f1: f64, f2: f64) -> Result<OrderedFloat<f64>, EvalError> {
|
|
Ok(OrderedFloat(classify_float(f1 + f2)?))
|
|
}
|
|
|
|
#[inline]
|
|
pub(crate) fn mul_f(f1: f64, f2: f64) -> Result<OrderedFloat<f64>, EvalError> {
|
|
Ok(OrderedFloat(classify_float(f1 * f2)?))
|
|
}
|
|
|
|
#[inline]
|
|
fn div_f(f1: f64, f2: f64) -> Result<OrderedFloat<f64>, EvalError> {
|
|
if FpCategory::Zero == f2.classify() {
|
|
Err(EvalError::ZeroDivisor)
|
|
} else {
|
|
Ok(OrderedFloat(classify_float(f1 / f2)?))
|
|
}
|
|
}
|
|
|
|
impl Div<Number> for Number {
|
|
type Output = Result<Number, EvalError>;
|
|
|
|
fn div(self, rhs: Number) -> Self::Output {
|
|
match (self, rhs) {
|
|
(Number::Fixnum(n1), Number::Fixnum(n2)) => Ok(Number::Float(div_f(
|
|
float_fn_to_f(n1.get_num())?,
|
|
float_fn_to_f(n2.get_num())?,
|
|
)?)),
|
|
(Number::Fixnum(n1), Number::Integer(n2)) => Ok(Number::Float(div_f(
|
|
float_fn_to_f(n1.get_num())?,
|
|
float_i_to_f(&n2)?,
|
|
)?)),
|
|
(Number::Integer(n1), Number::Fixnum(n2)) => Ok(Number::Float(div_f(
|
|
float_i_to_f(&n1)?,
|
|
float_fn_to_f(n2.get_num())?,
|
|
)?)),
|
|
(Number::Fixnum(n1), Number::Rational(n2)) => Ok(Number::Float(div_f(
|
|
float_fn_to_f(n1.get_num())?,
|
|
float_r_to_f(&n2)?,
|
|
)?)),
|
|
(Number::Rational(n1), Number::Fixnum(n2)) => Ok(Number::Float(div_f(
|
|
float_r_to_f(&n1)?,
|
|
float_fn_to_f(n2.get_num())?,
|
|
)?)),
|
|
(Number::Fixnum(n1), Number::Float(OrderedFloat(n2))) => {
|
|
Ok(Number::Float(div_f(float_fn_to_f(n1.get_num())?, n2)?))
|
|
}
|
|
(Number::Float(OrderedFloat(n1)), Number::Fixnum(n2)) => {
|
|
Ok(Number::Float(div_f(n1, float_fn_to_f(n2.get_num())?)?))
|
|
}
|
|
(Number::Integer(n1), Number::Integer(n2)) => Ok(Number::Float(div_f(
|
|
float_i_to_f(&n1)?,
|
|
float_i_to_f(&n2)?,
|
|
)?)),
|
|
(Number::Integer(n1), Number::Float(OrderedFloat(n2))) => {
|
|
Ok(Number::Float(div_f(float_i_to_f(&n1)?, n2)?))
|
|
}
|
|
(Number::Float(OrderedFloat(n2)), Number::Integer(n1)) => {
|
|
Ok(Number::Float(div_f(n2, float_i_to_f(&n1)?)?))
|
|
}
|
|
(Number::Integer(n1), Number::Rational(n2)) => Ok(Number::Float(div_f(
|
|
float_i_to_f(&n1)?,
|
|
float_r_to_f(&n2)?,
|
|
)?)),
|
|
(Number::Rational(n2), Number::Integer(n1)) => Ok(Number::Float(div_f(
|
|
float_r_to_f(&n2)?,
|
|
float_i_to_f(&n1)?,
|
|
)?)),
|
|
(Number::Rational(n1), Number::Float(OrderedFloat(n2))) => {
|
|
Ok(Number::Float(div_f(float_r_to_f(&n1)?, n2)?))
|
|
}
|
|
(Number::Float(OrderedFloat(n2)), Number::Rational(n1)) => {
|
|
Ok(Number::Float(div_f(n2, float_r_to_f(&n1)?)?))
|
|
}
|
|
(Number::Float(OrderedFloat(f1)), Number::Float(OrderedFloat(f2))) => {
|
|
Ok(Number::Float(div_f(f1, f2)?))
|
|
}
|
|
(Number::Rational(r1), Number::Rational(r2)) => Ok(Number::Float(div_f(
|
|
float_r_to_f(&r1)?,
|
|
float_r_to_f(&r2)?,
|
|
)?)),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl PartialEq for Number {
|
|
fn eq(&self, rhs: &Self) -> bool {
|
|
match (self, rhs) {
|
|
(&Number::Fixnum(n1), &Number::Fixnum(n2)) => n1.eq(&n2),
|
|
(&Number::Fixnum(n1), &Number::Integer(ref n2)) => n1.get_num().eq(&**n2),
|
|
(&Number::Integer(ref n1), &Number::Fixnum(n2)) => (&**n1).eq(&n2.get_num()),
|
|
(&Number::Fixnum(n1), &Number::Rational(ref n2)) => n1.get_num().eq(&**n2),
|
|
(&Number::Rational(ref n1), &Number::Fixnum(n2)) => (&**n1).eq(&n2.get_num()),
|
|
(&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::Rational(ref n2)) => {
|
|
#[cfg(feature = "num")]
|
|
{
|
|
&Rational::from(&**n1) == &**n2
|
|
}
|
|
#[cfg(not(feature = "num"))]
|
|
{
|
|
&**n1 == &**n2
|
|
}
|
|
}
|
|
(&Number::Rational(ref n1), &Number::Integer(ref n2)) => {
|
|
#[cfg(feature = "num")]
|
|
{
|
|
&**n1 == &Rational::from(&**n2)
|
|
}
|
|
#[cfg(not(feature = "num"))]
|
|
{
|
|
&**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::Float(f1), &Number::Float(f2)) => f1.eq(&f2),
|
|
(&Number::Rational(ref r1), &Number::Rational(ref r2)) => r1.eq(&r2),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Eq for Number {}
|
|
|
|
impl PartialOrd<usize> for Number {
|
|
#[inline]
|
|
fn partial_cmp(&self, rhs: &usize) -> Option<Ordering> {
|
|
match self {
|
|
Number::Fixnum(n) => {
|
|
let n = n.get_num();
|
|
|
|
if n < 0i64 {
|
|
Some(Ordering::Less)
|
|
} else {
|
|
(n as usize).partial_cmp(rhs)
|
|
}
|
|
}
|
|
Number::Integer(n) => (&**n).partial_cmp(rhs),
|
|
Number::Rational(r) => (&**r).partial_cmp(rhs),
|
|
Number::Float(f) => f.partial_cmp(&OrderedFloat(*rhs as f64)),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl PartialEq<usize> for Number {
|
|
#[inline]
|
|
fn eq(&self, rhs: &usize) -> bool {
|
|
match self {
|
|
Number::Fixnum(n) => {
|
|
let n = n.get_num();
|
|
|
|
if n < 0i64 {
|
|
false
|
|
} else {
|
|
(n as usize).eq(rhs)
|
|
}
|
|
}
|
|
Number::Integer(n) => (&**n).eq(rhs),
|
|
Number::Rational(r) => (&**r).eq(rhs),
|
|
Number::Float(f) => f.eq(&OrderedFloat(*rhs as f64)),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl PartialOrd for Number {
|
|
fn partial_cmp(&self, rhs: &Number) -> Option<Ordering> {
|
|
Some(self.cmp(rhs))
|
|
}
|
|
}
|
|
|
|
impl Ord for Number {
|
|
fn cmp(&self, rhs: &Number) -> Ordering {
|
|
match (self, rhs) {
|
|
(&Number::Fixnum(n1), &Number::Fixnum(n2)) => n1.get_num().cmp(&n2.get_num()),
|
|
(&Number::Fixnum(n1), Number::Integer(n2)) => Integer::from(n1.get_num()).cmp(&*n2),
|
|
(Number::Integer(n1), &Number::Fixnum(n2)) => (&**n1).cmp(&Integer::from(n2.get_num())),
|
|
(&Number::Fixnum(n1), Number::Rational(n2)) => Rational::from(n1.get_num()).cmp(&*n2),
|
|
(Number::Rational(n1), &Number::Fixnum(n2)) => {
|
|
(&**n1).cmp(&Rational::from(n2.get_num()))
|
|
}
|
|
(&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::Rational(n2)) => {
|
|
#[cfg(feature = "num")]
|
|
{
|
|
Rational::from(&**n1).cmp(n2)
|
|
}
|
|
#[cfg(not(feature = "num"))]
|
|
{
|
|
(&*n1).partial_cmp(&*n2).unwrap_or(Ordering::Less)
|
|
}
|
|
}
|
|
(&Number::Rational(n1), &Number::Integer(n2)) => {
|
|
#[cfg(feature = "num")]
|
|
{
|
|
(&**n1).cmp(&Rational::from(&**n2))
|
|
}
|
|
#[cfg(not(feature = "num"))]
|
|
{
|
|
(&*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::Float(f1), &Number::Float(f2)) => f1.cmp(&f2),
|
|
(&Number::Rational(r1), &Number::Rational(r2)) => (*r1).cmp(&*r2),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl TryFrom<HeapCellValue> for Number {
|
|
type Error = ();
|
|
|
|
#[inline]
|
|
fn try_from(value: HeapCellValue) -> Result<Number, Self::Error> {
|
|
read_heap_cell!(value,
|
|
(HeapCellValueTag::Cons, c) => {
|
|
match_untyped_arena_ptr!(c,
|
|
(ArenaHeaderTag::Integer, n) => {
|
|
Ok(Number::Integer(n))
|
|
}
|
|
(ArenaHeaderTag::Rational, n) => {
|
|
Ok(Number::Rational(n))
|
|
}
|
|
_ => {
|
|
Err(())
|
|
}
|
|
)
|
|
}
|
|
(HeapCellValueTag::F64, n) => {
|
|
Ok(Number::Float(*n))
|
|
}
|
|
(HeapCellValueTag::Fixnum, n) => {
|
|
Ok(Number::Fixnum(n))
|
|
}
|
|
_ => {
|
|
Err(())
|
|
}
|
|
)
|
|
}
|
|
}
|
|
|
|
// 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());
|
|
|
|
if power == 0 {
|
|
return Integer::from(1);
|
|
}
|
|
|
|
let mut oddand = Integer::from(1);
|
|
|
|
while power > 1 {
|
|
if power.is_odd() {
|
|
oddand *= &n;
|
|
}
|
|
|
|
n.pow_assign(2);
|
|
power >>= 1;
|
|
}
|
|
|
|
n * oddand
|
|
}
|