Bump version of rust_decimal and add more functions.

src/packages/arithmetic.rs

@@ -5,9 +5,6 @@ use crate::{def_package, EvalAltResult, Position, INT};
 #[cfg(feature = "no_std")]
 use std::prelude::v1::*;
 
-#[cfg(not(feature = "no_float"))]
-use crate::FLOAT;
-
 #[cfg(feature = "no_std")]
 #[cfg(not(feature = "no_float"))]
 use num_traits::Float;
@@ -77,7 +74,7 @@ macro_rules! gen_arithmetic_functions {
                         } else if y < 0 {
                             Err(make_err(format!("Integer raised to a negative index: {} ~ {}", x, y)))
                         } else {
-                            x.checked_pow(y as u32).ok_or_else(|| make_err(format!("Power overflow: {} ~ {}", x, y)))
+                            x.checked_pow(y as u32).ok_or_else(|| make_err(format!("Exponential overflow: {} ~ {}", x, y)))
                         }
                     } else {
                         Ok(x.pow(y as u32))
@@ -423,23 +420,13 @@ mod f64_functions {
             1
         }
     }
-    #[rhai_fn(name = "**", return_raw)]
-    pub fn pow_f_i(x: FLOAT, y: INT) -> Result<FLOAT, Box<EvalAltResult>> {
-        if cfg!(not(feature = "unchecked")) && y > (i32::MAX as INT) {
-            Err(make_err(format!(
-                "Number raised to too large an index: {} ~ {}",
-                x, y
-            )))
-        } else {
-            Ok(x.powi(y as i32))
-        }
-    }
 }
 
 #[cfg(feature = "decimal")]
 #[export_module]
 pub mod decimal_functions {
-    use rust_decimal::{prelude::Zero, Decimal};
+    use num_traits::Pow;
+    use rust_decimal::{prelude::Zero, Decimal, MathematicalOps};
 
     #[rhai_fn(skip, return_raw)]
     pub fn add(x: Decimal, y: Decimal) -> Result<Decimal, Box<EvalAltResult>> {
@@ -495,6 +482,15 @@ pub mod decimal_functions {
             Ok(x % y)
         }
     }
+    #[rhai_fn(skip, return_raw)]
+    pub fn power(x: Decimal, y: Decimal) -> Result<Decimal, Box<EvalAltResult>> {
+        if cfg!(not(feature = "unchecked")) {
+            x.checked_powd(y)
+                .ok_or_else(|| make_err(format!("Exponential overflow: {} + {}", x, y)))
+        } else {
+            Ok(x.pow(y))
+        }
+    }
     #[rhai_fn(name = "-")]
     pub fn neg(x: Decimal) -> Decimal {
         -x

src/packages/iter_basic.rs

@@ -253,15 +253,11 @@ def_package!(crate:BasicIteratorPackage:"Basic range iterators.", lib, {
         impl StepDecimalRange {
             pub fn new(from: Decimal, to: Decimal, step: Decimal) -> Result<Self, Box<EvalAltResult>> {
                 #[cfg(not(feature = "unchecked"))]
-                {
-                    use num_traits::Zero;
-
-                    if step.is_zero() {
-                        return EvalAltResult::ErrorInFunctionCall("range".to_string(), "".to_string(),
-                            Box::new(EvalAltResult::ErrorArithmetic("step value cannot be zero".to_string(), crate::Position::NONE)),
-                            crate::Position::NONE,
-                        ).into();
-                    }
+                if step.is_zero() {
+                    return EvalAltResult::ErrorInFunctionCall("range".to_string(), "".to_string(),
+                        Box::new(EvalAltResult::ErrorArithmetic("step value cannot be zero".to_string(), crate::Position::NONE)),
+                        crate::Position::NONE,
+                    ).into();
                 }
 
                 Ok(Self(from, to, step))

src/packages/math_basic.rs

@@ -222,6 +222,7 @@ mod float_functions {
     pub fn log(x: FLOAT, base: FLOAT) -> FLOAT {
         x.log(base)
     }
+    #[rhai_fn(name = "log")]
     pub fn log10(x: FLOAT) -> FLOAT {
         x.log10()
     }
@@ -305,9 +306,33 @@ mod float_functions {
 mod decimal_functions {
     use rust_decimal::{
         prelude::{FromStr, RoundingStrategy},
-        Decimal,
+        Decimal, MathematicalOps,
     };
 
+    #[rhai_fn(return_raw)]
+    pub fn sqrt(x: Decimal) -> Result<Decimal, Box<EvalAltResult>> {
+        if cfg!(not(feature = "unchecked")) {
+            x.sqrt()
+                .ok_or_else(|| make_err(format!("Error taking the square root of {}", x,)))
+        } else {
+            Ok(x.sqrt().unwrap())
+        }
+    }
+    #[rhai_fn(return_raw)]
+    pub fn exp(x: Decimal) -> Result<Decimal, Box<EvalAltResult>> {
+        if cfg!(not(feature = "unchecked")) {
+            if x > Decimal::from_parts(10, 0, 0, false, 0) {
+                Err(make_err(format!("Exponential overflow: e ** {}", x,)))
+            } else {
+                Ok(x.exp())
+            }
+        } else {
+            Ok(x.exp())
+        }
+    }
+    pub fn ln(x: Decimal) -> Decimal {
+        x.ln()
+    }
     #[rhai_fn(name = "floor", get = "floor")]
     pub fn floor(x: Decimal) -> Decimal {
         x.floor()