remove non-conforming hyperbolic and log10 evaluable functors

diff --git a/build/instructions_template.rs b/build/instructions_template.rs
index 8aa4d8372cecb6dfd8473396b5e2aed4dfb132c0..990daa733dcc6f08b3d7d38edd29a458d2d3402a 100644 (file)
--- a/build/instructions_template.rs
+++ b/build/instructions_template.rs
@@ -764,20 +764,6 @@ enum InstructionTemplate {
     Neg(ArithmeticTerm, usize),
     #[strum_discriminants(strum(props(Arity = "1", Name = "plus")))]
     Plus(ArithmeticTerm, usize),
-    #[strum_discriminants(strum(props(Arity = "1", Name = "acosh")))]
-    ACosh(ArithmeticTerm, usize),
-    #[strum_discriminants(strum(props(Arity = "1", Name = "asinh")))]
-    ASinh(ArithmeticTerm, usize),
-    #[strum_discriminants(strum(props(Arity = "1", Name = "atanh")))]
-    ATanh(ArithmeticTerm, usize),
-    #[strum_discriminants(strum(props(Arity = "1", Name = "cosh")))]
-    Cosh(ArithmeticTerm, usize),
-    #[strum_discriminants(strum(props(Arity = "1", Name = "sinh")))]
-    Sinh(ArithmeticTerm, usize),
-    #[strum_discriminants(strum(props(Arity = "1", Name = "tanh")))]
-    Tanh(ArithmeticTerm, usize),
-    #[strum_discriminants(strum(props(Arity = "1", Name = "log10")))]
-    Log10(ArithmeticTerm, usize),
     #[strum_discriminants(strum(props(Arity = "1", Name = "bitwise_complement")))]
     BitwiseComplement(ArithmeticTerm, usize),
     // control instructions
@@ -1449,30 +1435,9 @@ fn generate_instruction_preface() -> TokenStream {
                     &Instruction::ATan(ref at, t) => {
                         arith_instr_unary_functor(h, atom!("atan"), arena, at, t)
                     }
-                    &Instruction::ACosh(ref at, t) => {
-                        arith_instr_unary_functor(h, atom!("acosh"), arena, at, t)
-                    }
-                    &Instruction::ASinh(ref at, t) => {
-                        arith_instr_unary_functor(h, atom!("asinh"), arena, at, t)
-                    }
-                    &Instruction::ATanh(ref at, t) => {
-                        arith_instr_unary_functor(h, atom!("atanh"), arena, at, t)
-                    }
-                    &Instruction::Cosh(ref at, t) => {
-                        arith_instr_unary_functor(h, atom!("cosh"), arena, at, t)
-                    }
-                    &Instruction::Sinh(ref at, t) => {
-                        arith_instr_unary_functor(h, atom!("sinh"), arena, at, t)
-                    }
-                    &Instruction::Tanh(ref at, t) => {
-                        arith_instr_unary_functor(h, atom!("tanh"), arena, at, t)
-                    }
                     &Instruction::Sqrt(ref at, t) => {
                         arith_instr_unary_functor(h, atom!("sqrt"), arena, at, t)
                     }
-                    &Instruction::Log10(ref at, t) => {
-                        arith_instr_unary_functor(h, atom!("log10"), arena, at, t)
-                    }
                     &Instruction::Abs(ref at, t) => {
                         arith_instr_unary_functor(h, atom!("abs"), arena, at, t)
                     }

diff --git a/src/arithmetic.rs b/src/arithmetic.rs
index 8ec3cee89a651e220d12dee269a79bd803b9fcca..5aa7b1b045fa5b7899428ed6e96641c9761258f4 100644 (file)
--- a/src/arithmetic.rs
+++ b/src/arithmetic.rs
@@ -197,13 +197,6 @@ impl<'a> ArithmeticEvaluator<'a> {
             atom!("sin") => Ok(Instruction::Sin(a1, t)),
             atom!("tan") => Ok(Instruction::Tan(a1, t)),
             atom!("log") => Ok(Instruction::Log(a1, t)),
-            atom!("asinh") => Ok(Instruction::ASinh(a1, t)),
-            atom!("acosh") => Ok(Instruction::ACosh(a1, t)),
-            atom!("atanh") => Ok(Instruction::ATanh(a1, t)),
-            atom!("sinh") => Ok(Instruction::Sinh(a1, t)),
-            atom!("cosh") => Ok(Instruction::Cosh(a1, t)),
-            atom!("tanh") => Ok(Instruction::Tanh(a1, t)),
-            atom!("log10") => Ok(Instruction::Log10(a1, t)),
             atom!("exp") => Ok(Instruction::Exp(a1, t)),
             atom!("sqrt") => Ok(Instruction::Sqrt(a1, t)),
             atom!("acos") => Ok(Instruction::ACos(a1, t)),

diff --git a/src/machine/arithmetic_ops.rs b/src/machine/arithmetic_ops.rs
index 20c503a90c46d1d9d15a0b77d8bfcc194b1e490b..677fa5816081b7d90306e8b1f5cb344a97ca7cec 100644 (file)
--- a/src/machine/arithmetic_ops.rs
+++ b/src/machine/arithmetic_ops.rs
@@ -1053,55 +1053,6 @@ pub(crate) fn atan(n1: Number) -> Result<f64, MachineStubGen> {
     unary_float_fn_template(n1, |f| f.atan())
 }
 
-#[inline]
-pub(crate) fn asinh(n1: Number) -> Result<f64, MachineStubGen> {
-    unary_float_fn_template(n1, |f| f.asinh())
-}
-
-#[inline]
-pub(crate) fn acosh(n1: Number) -> Result<f64, MachineStubGen> {
-    unary_float_fn_template(n1, |f| f.acosh())
-}
-
-#[inline]
-pub(crate) fn atanh(n1: Number) -> Result<f64, MachineStubGen> {
-    let stub_gen = || {
-        let is_atom = atom!("is");
-        functor_stub(is_atom, 2)
-    };
-
-    let f1 = try_numeric_result!(result_f(&n1), stub_gen)?;
-
-    try_numeric_result!(
-        if f1 == 1.0 || f1 == -1.0 {
-            Err(EvalError::Undefined)
-        } else {
-            result_f(&Number::Float(OrderedFloat(f1.atanh())))
-        },
-        stub_gen
-    )
-}
-
-#[inline]
-pub(crate) fn sinh(n1: Number) -> Result<f64, MachineStubGen> {
-    unary_float_fn_template(n1, |f| f.sinh())
-}
-
-#[inline]
-pub(crate) fn cosh(n1: Number) -> Result<f64, MachineStubGen> {
-    unary_float_fn_template(n1, |f| f.cosh())
-}
-
-#[inline]
-pub(crate) fn tanh(n1: Number) -> Result<f64, MachineStubGen> {
-    unary_float_fn_template(n1, |f| f.tanh())
-}
-
-#[inline]
-pub(crate) fn log10(n1: Number) -> Result<f64, MachineStubGen> {
-    unary_float_fn_template(n1, |f| f.log(10f64))
-}
-
 #[inline]
 pub(crate) fn float_fractional_part(n1: Number) -> Result<f64, MachineStubGen> {
     unary_float_fn_template(n1, |f| f.fract())
@@ -1366,27 +1317,6 @@ impl MachineState {
                             atom!("tan") => self.interms.push(Number::Float(OrderedFloat(
                                 drop_iter_on_err!(self, iter, tan(a1))
                             ))),
-                            atom!("cosh") => self.interms.push(Number::Float(OrderedFloat(
-                                drop_iter_on_err!(self, iter, cosh(a1))
-                            ))),
-                            atom!("sinh") => self.interms.push(Number::Float(OrderedFloat(
-                                drop_iter_on_err!(self, iter, sinh(a1))
-                            ))),
-                            atom!("tanh") => self.interms.push(Number::Float(OrderedFloat(
-                                drop_iter_on_err!(self, iter, tanh(a1))
-                            ))),
-                            atom!("acosh") => self.interms.push(Number::Float(OrderedFloat(
-                                drop_iter_on_err!(self, iter, acosh(a1))
-                            ))),
-                            atom!("asinh") => self.interms.push(Number::Float(OrderedFloat(
-                                drop_iter_on_err!(self, iter, asinh(a1))
-                            ))),
-                            atom!("atanh") => self.interms.push(Number::Float(OrderedFloat(
-                                drop_iter_on_err!(self, iter, atanh(a1))
-                            ))),
-                            atom!("log10") => self.interms.push(Number::Float(OrderedFloat(
-                                drop_iter_on_err!(self, iter, log10(a1))
-                            ))),
                             atom!("float_fractional_part") => self.interms.push(Number::Float(OrderedFloat(
                                 drop_iter_on_err!(self, iter, float_fractional_part(a1))
                             ))),

diff --git a/src/machine/dispatch.rs b/src/machine/dispatch.rs
index 23fe7c029f87d39cb63489af7b2b92ee6707bd5b..e04961d93de89c69dd16337fc7c629aacb9bb1a9 100644 (file)
--- a/src/machine/dispatch.rs
+++ b/src/machine/dispatch.rs
@@ -917,69 +917,6 @@ impl Machine {
 
                         self.machine_st.p += 1;
                     }
-                    &Instruction::ACosh(ref a1, t) => {
-                        let n1 = try_or_throw!(self.machine_st, self.machine_st.get_number(a1));
-
-                        self.machine_st.interms[t - 1] = Number::Float(OrderedFloat(
-                            try_or_throw_gen!(&mut self.machine_st, acosh(n1)),
-                        ));
-
-                        self.machine_st.p += 1;
-                    }
-                    &Instruction::ASinh(ref a1, t) => {
-                        let n1 = try_or_throw!(self.machine_st, self.machine_st.get_number(a1));
-
-                        self.machine_st.interms[t - 1] = Number::Float(OrderedFloat(
-                            try_or_throw_gen!(&mut self.machine_st, asinh(n1)),
-                        ));
-
-                        self.machine_st.p += 1;
-                    }
-                    &Instruction::ATanh(ref a1, t) => {
-                        let n1 = try_or_throw!(self.machine_st, self.machine_st.get_number(a1));
-
-                        self.machine_st.interms[t - 1] = Number::Float(OrderedFloat(
-                            try_or_throw_gen!(&mut self.machine_st, atanh(n1)),
-                        ));
-
-                        self.machine_st.p += 1;
-                    }
-                    &Instruction::Cosh(ref a1, t) => {
-                        let n1 = try_or_throw!(self.machine_st, self.machine_st.get_number(a1));
-
-                        self.machine_st.interms[t - 1] = Number::Float(OrderedFloat(
-                            try_or_throw_gen!(&mut self.machine_st, cosh(n1)),
-                        ));
-
-                        self.machine_st.p += 1;
-                    }
-                    &Instruction::Sinh(ref a1, t) => {
-                        let n1 = try_or_throw!(self.machine_st, self.machine_st.get_number(a1));
-
-                        self.machine_st.interms[t - 1] = Number::Float(OrderedFloat(
-                            try_or_throw_gen!(&mut self.machine_st, sinh(n1)),
-                        ));
-
-                        self.machine_st.p += 1;
-                    }
-                    &Instruction::Tanh(ref a1, t) => {
-                        let n1 = try_or_throw!(self.machine_st, self.machine_st.get_number(a1));
-
-                        self.machine_st.interms[t - 1] = Number::Float(OrderedFloat(
-                            try_or_throw_gen!(&mut self.machine_st, tanh(n1)),
-                        ));
-
-                        self.machine_st.p += 1;
-                    }
-                    &Instruction::Log10(ref a1, t) => {
-                        let n1 = try_or_throw!(self.machine_st, self.machine_st.get_number(a1));
-
-                        self.machine_st.interms[t - 1] = Number::Float(OrderedFloat(
-                            try_or_throw_gen!(&mut self.machine_st, log10(n1)),
-                        ));
-
-                        self.machine_st.p += 1;
-                    }
                     &Instruction::Float(ref a1, t) => {
                         let n1 = try_or_throw!(self.machine_st, self.machine_st.get_number(a1));