Release 0.3.0 (#2)

Author: terror

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "val"
-version = "0.2.0"
+version = "0.3.0"
 authors = ["Liam <[email protected]>"]
 categories = ["science", "parser-implementations", "command-line-interface"]
 description = "An arbitrary precision calculator language"

Cargo.toml

@@ -91,7 +91,7 @@ program. The tool supports executing arbitrary expressions inline using the
 
 ```bash
 val -p 53 -e 'sin(2) * e ^ pi * cos(sum([1, 2, 3]))'
-1.6481455793912883588e+1
+16.481455793912883588
 ```
 
 **n.b.** The `--expression` option and `filename` argument are mutually
@@ -161,15 +161,17 @@ complex operations:
 
 #### Number
 
-Numeric values are represented as arbitrary floating point numbers:
+Numeric values are represented as arbitrary floating point numbers (using
+[astro_float(https://docs.rs/astro-float/latest/astro_float/index.html)] under
+the hood):
 
 ```rust
 > pi
-3.141592653589793115997963468544185161590576171875e+0
+3.141592653589793115997963468544185161590576171875
 > e
-2.718281828459045090795598298427648842334747314453125e+0
+2.718281828459045090795598298427648842334747314453125
 > sin(2) * e ^ pi * cos(sum([1, 2, 3]))
-1.64814557939128835908118223753548409318930600432600320575175542910885566534716862696709583557263450637540094805515971245058657340687939442764118452427864231041058959960049996970569867866035825048029794926250103816423751837050040821914044725396611746570949840536443560831710407959633707222226883928822125018008e+1
+16.4814557939128835908118223753548409318930600432600320575175542910885566534716862696709583557263450637540094805515971245058657340687939442764118452427864231041058959960049996970569867866035825048029794926250103816423751837050040821914044725396611746570949840536443560831710407959633707222226883928822125018007
 >
 ```
 

README.md

@@ -261,7 +261,7 @@ impl Display for Expression<'_> {
       Expression::ListAccess(list, index) => {
         write!(f, "list_access({}, {})", list.0, index.0)
       }
-      Expression::Number(number) => write!(f, "number({})", number),
+      Expression::Number(number) => write!(f, "number({})", number.display()),
       Expression::String(string) => write!(f, "string(\"{}\")", string),
       Expression::UnaryOp(op, expr) => {
         write!(f, "unary_op({}, {})", op, expr.0)

src/ast.rs

@@ -572,7 +572,7 @@ impl<'src> Environment<'src> {
 
         let number = payload.arguments[0].number(payload.span)?;
 
-        if number < BigFloat::from(0.0) {
+        if number.is_negative() {
           return Err(Error::new(
             payload.span,
             "Cannot take square root of negative number",
@@ -718,7 +718,20 @@ impl<'src> Environment<'src> {
           ));
         }
 
-        process::exit(0);
+        let code = match payload.arguments[0]
+          .number(payload.span)?
+          .to_f64(payload.config.rounding_mode)
+        {
+          Some(n) if n.is_finite() && n >= 0.0 => n as usize,
+          _ => {
+            return Err(Error::new(
+              payload.span,
+              "Argument to `exit` must be a non-negative finite number",
+            ));
+          }
+        };
+
+        process::exit(code as i32);
       }),
     );
 
@@ -739,7 +752,20 @@ impl<'src> Environment<'src> {
           ));
         }
 
-        process::exit(0);
+        let code = match payload.arguments[0]
+          .number(payload.span)?
+          .to_f64(payload.config.rounding_mode)
+        {
+          Some(n) if n.is_finite() && n >= 0.0 => n as usize,
+          _ => {
+            return Err(Error::new(
+              payload.span,
+              "Argument to `quit` must be a non-negative finite number",
+            ));
+          }
+        };
+
+        process::exit(code as i32);
       }),
     );
 

src/environment.rs

@@ -300,7 +300,7 @@ impl<'a> Evaluator<'a> {
 
         match (&lhs_val, &rhs_val) {
           (Value::Number(a), Value::Number(b)) => Ok(Value::Number(a.add(
-            &b,
+            b,
             self.environment.config.precision,
             self.environment.config.rounding_mode,
           ))),

src/evaluator.rs

@@ -2,55 +2,146 @@ use super::*;
 
 pub trait FloatExt {
   fn to_f64(&self, rounding_mode: astro_float::RoundingMode) -> Option<f64>;
+  fn display(&self) -> String;
 }
 
 impl FloatExt for BigFloat {
+  fn display(&self) -> String {
+    if let Some(parts) = self.as_raw_parts() {
+      let number =
+        BigFloat::from_raw_parts(parts.0, parts.1, parts.2, parts.3, parts.4);
+
+      if number.is_nan() {
+        return "NaN".into();
+      }
+
+      if number.is_inf_pos() {
+        return "Inf".into();
+      }
+
+      if number.is_inf_neg() {
+        return "-Inf".into();
+      }
+
+      if number.is_zero() {
+        return "0".into();
+      }
+
+      let formatted = number
+        .format(
+          Radix::Dec,
+          astro_float::RoundingMode::None,
+          &mut Consts::new().expect("BigFloat constants cache"),
+        )
+        .unwrap();
+
+      if !formatted.contains('e') {
+        return formatted;
+      }
+
+      let (mant, exp) = {
+        let mut parts = formatted.split('e');
+        (parts.next().unwrap(), parts.next().unwrap())
+      };
+
+      let exp: i32 = exp.parse().unwrap();
+
+      let (sign, mant) =
+        mant.split_at(if mant.starts_with('-') { 1 } else { 0 });
+
+      let digits = mant.replace('.', "");
+
+      let new_int_len = mant.find('.').unwrap_or(mant.len()) as i32 + exp;
+
+      let result = if new_int_len <= 0 {
+        format!(
+          "{}0.{}{}",
+          sign,
+          "0".repeat((-new_int_len) as usize),
+          digits
+        )
+      } else if new_int_len as usize >= digits.len() {
+        format!(
+          "{}{}{}",
+          sign,
+          digits,
+          "0".repeat(new_int_len as usize - digits.len())
+        )
+      } else {
+        let (left, right) = digits.split_at(new_int_len as usize);
+        format!("{}{}.{}", sign, left, right)
+      };
+
+      if result.find('.').is_some() {
+        result
+          .trim_end_matches('0')
+          .trim_end_matches('.')
+          .to_string()
+      } else {
+        result
+      }
+    } else {
+      self.to_string()
+    }
+  }
+
   fn to_f64(&self, rounding_mode: astro_float::RoundingMode) -> Option<f64> {
     let mut big_float = self.clone();
     big_float.set_precision(64, rounding_mode).ok()?;
 
     let sign = big_float.sign()?;
+
     let exponent = big_float.exponent()? as isize;
+
     let mantissa_digits = big_float.mantissa_digits()?;
 
     if mantissa_digits.is_empty() {
       return Some(0.0);
     }
 
     let mantissa = mantissa_digits[0];
+
     if mantissa == 0 {
       return Some(0.0);
     }
 
     let mut exponent = exponent + 0b1111111111;
+
     let mut ret = 0u64;
 
     if exponent >= 0b11111111111 {
-      return Some(match sign {
+      Some(match sign {
         Sign::Pos => f64::INFINITY,
         Sign::Neg => f64::NEG_INFINITY,
-      });
+      })
     } else if exponent <= 0 {
       let shift = -exponent;
+
       if shift < 52 {
         ret |= mantissa >> (shift + 12);
+
         if sign == Sign::Neg {
           ret |= 0x8000000000000000u64;
         }
+
         return Some(f64::from_bits(ret));
       } else {
         return Some(0.0);
       }
     } else {
       let mantissa = mantissa << 1;
+
       exponent -= 1;
+
       if sign == Sign::Neg {
         ret |= 1;
       }
+
       ret <<= 11;
       ret |= exponent as u64;
       ret <<= 52;
       ret |= mantissa >> 12;
+
       return Some(f64::from_bits(ret));
     }
   }

src/float_ext.rs

@@ -1,6 +1,6 @@
 pub(crate) use {
   ariadne::{Color, Label, Report, ReportKind, Source},
-  astro_float::{BigFloat, Consts, Sign},
+  astro_float::{BigFloat, Consts, Radix, Sign},
   chumsky::prelude::*,
   clap::Parser as Clap,
   environment::Environment,

src/lib.rs

@@ -48,9 +48,9 @@ impl std::str::FromStr for RoundingMode {
   }
 }
 
-impl Into<astro_float::RoundingMode> for RoundingMode {
-  fn into(self) -> astro_float::RoundingMode {
-    match self {
+impl From<RoundingMode> for astro_float::RoundingMode {
+  fn from(mode: RoundingMode) -> Self {
+    match mode {
       RoundingMode::None => astro_float::RoundingMode::None,
       RoundingMode::Up => astro_float::RoundingMode::Up,
       RoundingMode::Down => astro_float::RoundingMode::Down,

src/rounding_mode.rs

@@ -33,7 +33,7 @@ impl Display for Value<'_> {
           .join(", ")
       ),
       Value::Null => write!(f, "null"),
-      Value::Number(number) => write!(f, "{number}",),
+      Value::Number(number) => write!(f, "{}", number.display()),
       Value::String(string) => write!(f, "{string}"),
     }
   }