calc_rational

lib.rs (128984B)

---

 //! # `calc_lib`  
 //!   
 //! `calc_lib` is a library for performing basic rational number arithmetic using standard operator precedence
 //! and associativity. Internally, it is based on
 //! [`Ratio<T>`] and [`BigInt`].
 //!   
 //! ## Expressions  
 //!   
 //! The following are the list of expressions in descending order of precedence:  
 //!   1. number literals, `@`, `()`, `||`, `round()`, `rand()`  
 //!   2. `!`  
 //!   3. `^`  
 //!   4. `-` (unary negation operator)  
 //!   5. `*`, `/`, `mod`  
 //!   6. `+`, `-`  
 //!   
 //! All binary operators are left-associative sans `^` which is right-associative.  
 //!   
 //! Any expression is allowed to be enclosed in `()`. Note that parentheses are purely for grouping expressions;
 //! in particular, you cannot use them to represent multiplication (e.g., `4(2)` is grammatically incorrect and
 //! will result in an error message).  
 //!   
 //! Any expression is allowed to be enclosed in `||`. This unary operator represents absolute value.  
 //!   
 //! `!` is the factorial operator. Due to its high precedence, something like *-i!^j!* for *i, j ∈ ℕ* is
 //! the same thing as *-((i!)^(j!))*. If the expression preceding it does not evaluate to a non-negative integer,
 //! then an error will be displayed. Spaces  and tabs are *not* ignored; so `1 !` is grammatically incorrect and
 //! will result in an error message.  
 //!   
 //! `^` is the exponentiation operator. The expression left of the operator can evaluate to any rational number;
 //! however the expression right of the operator must evaluate to an integer or ±1/2 unless the expression on
 //! the left evaluates to `0` or `1`. In the event of the former, the expression right of the operator must evaluate
 //! to a non-negative rational number. In the event of the latter, the expression right of the operator can evaluate to
 //! any rational number. Note that `0^0` is defined to be 1. When the operand right of `^` evaluates to ±1/2, then
 //! the left operand must be the square of a rational number.  
 //!   
 //! The unary operator `-` represents negation.  
 //!   
 //! The operators `*` and `/` represent multiplication and division respectively. Expressions right of `/`
 //! must evaluate to any non-zero rational number; otherwise an error will be displayed.  
 //!   
 //! The binary operator `mod` represents modulo such that *n mod m = r = n - m\*q* for *n,q ∈ ℤ, m ∈ ℤ\\{0}, and r ∈ ℕ*
 //! where *r* is the minimum non-negative solution.  
 //!   
 //! The binary operators `+` and `-` represent addition and subtraction respectively.  
 //!   
 //! With the aforementioned exception of `!`, all spaces and tabs before and after operators are ignored.  
 //!   
 //! ## Round expression  
 //!   
 //! `round(expression, digit)` rounds `expression` to `digit`-number of fractional digits. An error will
 //! be displayed if called incorrectly.  
 //!   
 //! ## Rand expression  
 //!   
 //! `rand(expression, expression)` generates a random 64-bit integer inclusively between the passed expressions.
 //! An error will be displayed if called incorrectly. `rand()` generates a random 64-bit integer.  
 //!   
 //! ## Numbers  
 //!   
 //! A number literal is a non-empty sequence of digits or a non-empty sequence of digits immediately followed by `.`
 //! which is immediately followed by a non-empty sequence of digits (e.g., `134.901`). This means that number
 //! literals represent precisely all rational numbers that are equivalent to a ratio of a non-negative integer
 //! to a positive integer whose sole prime factors are 2 or 5. To represent all other rational numbers, the unary
 //! operator `-` and binary operator `/` must be used.  
 //!   
 //! ## Empty expression  
 //!   
 //! The empty expression (i.e., expression that at most only consists of spaces and tabs) will return
 //! the result from the previous non-(empty/store) expression in *decimal* form using the minimum number of digits.
 //! In the event an infinite number of digits is required, it will be rounded to 9 fractional digits using normal rounding
 //! rules first.  
 //!   
 //! ## Store expression  
 //!   
 //! To store the result of the previous non-(empty/store) expression, one simply passes `s`. In addition to storing the
 //! result which will subsequently be available via `@`, it displays the result. At most 8 results can be stored at once;
 //! at which point, results that are stored overwrite the oldest result.  
 //!   
 //! ## Recall expression  
 //!   
 //! `@` is used to recall previously stored results. It can be followed by any *digit* from `1` to `8`.
 //! If such a digit does not immediately follow it, then it will be interpreted as if there were a `1`.
 //! `@i` returns the *i*-th most-previous stored result where *i ∈ {1, 2, 3, 4, 5, 6, 7, 8}*.
 //! Note that spaces and tabs are *not* ignored so `@ 2` is grammatically incorrect and will result in an error message.
 //! As emphasized, it does not work on expressions; so both `@@` and `@(1)` are grammatically incorrect.  
 //!   
 //! ## Character encoding  
 //!   
 //! All inputs must only contain the ASCII encoding of the following Unicode scalar values: `0`-`9`, `.`, `+`, `-`,
 //! `*`, `/`, `^`, `!`, `mod`, `|`, `(`, `)`, `round`, `rand`, `,`, `@`, `s`, &lt;space&gt;, &lt;tab&gt;,
 //! &lt;line feed&gt;, &lt;carriage return&gt;, and `q`. Any other byte sequences are grammatically incorrect and will
 //! lead to an error message.  
 //!   
 //! ## Errors  
 //!   
 //! Errors due to a language violation (e.g., dividing by `0`) manifest into an error message. `panic!`s
 //! and [`io::Error`](https://doc.rust-lang.org/std/io/struct.Error.html)s caused by writing to the global
 //! standard output stream lead to program abortion.  
 //!   
 //! ## Exiting  
 //!   
 //! `q` with any number of spaces and tabs before and after will cause the program to terminate.  
 //!   
 //! ### Formal language specification  
 //!   
 //! For a more precise specification of the “calc language”, one can read the
 //! [calc language specification](https://git.philomathiclife.com/calc_rational/lang.pdf).
 #![no_std]
 #![cfg_attr(all(doc, channel_nightly), feature(doc_auto_cfg))]
 #![deny(
     unknown_lints,
     future_incompatible,
     let_underscore,
     missing_docs,
     nonstandard_style,
     refining_impl_trait,
     rust_2018_compatibility,
     rust_2018_idioms,
     rust_2021_compatibility,
     rust_2024_compatibility,
     unsafe_code,
     unused,
     unused_crate_dependencies,
     warnings,
     clippy::all,
     clippy::cargo,
     clippy::complexity,
     clippy::correctness,
     clippy::nursery,
     clippy::pedantic,
     clippy::perf,
     clippy::restriction,
     clippy::style,
     clippy::suspicious
 )]
 #![expect(
     clippy::arithmetic_side_effects,
     reason = "this is a calculator, so this is unavoidable"
 )]
 #![expect(
     clippy::blanket_clippy_restriction_lints,
     clippy::indexing_slicing,
     clippy::exhaustive_enums,
     clippy::implicit_return,
     clippy::min_ident_chars,
     clippy::missing_trait_methods,
     clippy::question_mark_used,
     clippy::ref_patterns,
     clippy::single_char_lifetime_names,
     clippy::unseparated_literal_suffix,
     reason = "noisy, opinionated, and likely doesn't prevent bugs or improve APIs"
 )]
 extern crate alloc;
 use alloc::{
     string::{String, ToString},
     vec,
     vec::Vec,
 };
 use cache::Cache;
 #[cfg(not(feature = "rand"))]
 use core::marker::PhantomData;
 use core::{
     convert,
     fmt::{self, Display, Formatter},
     ops::Index,
 };
 pub use num_bigint;
 use num_bigint::{BigInt, BigUint, Sign};
 use num_integer::Integer;
 pub use num_rational;
 use num_rational::Ratio;
 #[cfg(feature = "rand")]
 use num_traits::ToPrimitive;
 use num_traits::{Inv, Pow};
 #[cfg(feature = "rand")]
 pub use rand;
 #[cfg(feature = "rand")]
 use rand::{rngs::ThreadRng, RngCore};
 use LangErr::{
     DivByZero, ExpDivByZero, ExpIsNotIntOrOneHalf, InvalidAbs, InvalidDec, InvalidPar, InvalidQuit,
     InvalidRound, InvalidStore, MissingTerm, ModIsNotInt, ModZero, NotEnoughPrevResults,
     NotNonNegIntFact, SqrtDoesNotExist, TrailingSyms,
 };
 use O::{Empty, Eval, Exit, Store};
 /// Fixed-sized cache that automatically overwrites the oldest data
 /// when a new item is added and the cache is full. One can think of
 /// [`Cache`] as a very limited but more performant [`VecDeque`][alloc::collections::VecDeque] that only
 /// adds new data or reads old data.
 pub mod cache;
 /// Generalizes [`Iterator`] by using
 /// generic associated types.
 pub mod lending_iterator;
 /// Error due to a language violation.
 #[non_exhaustive]
 #[derive(Debug)]
 pub enum LangErr {
     /// The input began with a `q` but had non-whitespace
     /// that followed it.
     InvalidQuit,
     /// The input began with an `s` but had non-whitespace
     /// that followed it.
     InvalidStore,
     /// A sub-expression in the input would have led
     /// to a division by zero.
     DivByZero(usize),
     /// A sub-expression in the input would have led
     /// to a rational number that was not 0 or 1 to be
     /// raised to a non-integer power that is not (+/-) 1/2.
     ExpIsNotIntOrOneHalf(usize),
     /// A sub-expression in the input would have led
     /// to 0 being raised to a negative power which itself
     /// would have led to a division by zero.
     ExpDivByZero(usize),
     /// A sub-expression in the input would have led
     /// to a number modulo 0.
     ModZero(usize),
     /// A sub-expression in the input would have led
     /// to the mod of two expressions with at least one
     /// not being an integer.
     ModIsNotInt(usize),
     /// A sub-expression in the input would have led
     /// to a non-integer factorial or a negative integer factorial.
     NotNonNegIntFact(usize),
     /// The input contained a non-empty sequence of digits followed
     /// by `.` which was not followed by a non-empty sequence of digits.
     InvalidDec(usize),
     /// A recall expression was used to recall the *i*-th most-recent stored result,
     /// but there are fewer than *i* stored where
     /// *i ∈ {1, 2, 3, 4, 5, 6, 7, 8}*.
     NotEnoughPrevResults(usize),
     /// The input did not contain a closing `|`.
     InvalidAbs(usize),
     /// The input did not contain a closing `)`.
     InvalidPar(usize),
     /// The input contained an invalid round expression.
     InvalidRound(usize),
     /// A sub-expression in the input had a missing terminal expression
     /// where a terminal expression is a decimal literal expression,
     /// recall expression, absolute value expression, parenthetical
     /// expression, or round expression.
     MissingTerm(usize),
     /// The expression that was passed to the square root does not have a solution
     /// in the field of rational numbers.
     SqrtDoesNotExist(usize),
     /// The input started with a valid expression but was immediately followed
     /// by symbols that could not be chained with the preceding expression.
     TrailingSyms(usize),
     /// The input contained an invalid random expression.
     #[cfg(feature = "rand")]
     InvalidRand(usize),
     /// Error when the second argument is less than first in the rand function.
     #[cfg(feature = "rand")]
     RandInvalidArgs(usize),
     /// Error when there are no 64-bit integers in the interval passed to the random function.
     #[cfg(feature = "rand")]
     RandNoInts(usize),
 }
 impl Display for LangErr {
     #[inline]
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match *self {
             InvalidStore => f.write_str("Invalid store expression. A store expression must be of the extended regex form: ^[ \\t]*s[ \\t]*$."),
             InvalidQuit => f.write_str("Invalid quit expression. A quit expression must be of the extended regex form: ^[ \\t]*q[ \\t]*$."),
             DivByZero(u) => write!(f, "Division by zero ending at position {u}."),
             ExpIsNotIntOrOneHalf(u) => write!(f, "Non-integer exponent that is not (+/-) 1/2 with a base that was not 0 or 1 ending at position {u}."),
             ExpDivByZero(u) => write!(f, "Non-negative exponent with a base of 0 ending at position {u}."),
             ModZero(u) => write!(f, "A number modulo 0 ending at position {u}."),
             ModIsNotInt(u) => write!(f, "The modulo expression was applied to at least one non-integer ending at position {u}."),
             NotNonNegIntFact(u) => write!(f, "Factorial of a rational number that was not a non-negative integer ending at position {u}."),
             InvalidDec(u) => write!(f, "Invalid decimal literal expression ending at position {u}. A decimal literal expression must be of the extended regex form: [0-9]+(\\.[0-9]+)?."),
             NotEnoughPrevResults(len) => write!(f, "There are only {len} previous results."),
             InvalidAbs(u) => write!(f, "Invalid absolute value expression ending at position {u}. An absolute value expression is an addition expression enclosed in '||'."),
             InvalidPar(u) => write!(f, "Invalid parenthetical expression ending at position {u}. A parenthetical expression is an addition expression enclosed in '()'."),
             InvalidRound(u) => write!(f, "Invalid round expression ending at position {u}. A round expression is of the form 'round(<mod expression>, digit)'"),
             SqrtDoesNotExist(u) => write!(f, "The square root of the passed expression does not have a solution in the field of rational numbers ending at position {u}."),
             #[cfg(not(feature = "rand"))]
             MissingTerm(u) => write!(f, "Missing terminal expression at position {u}. A terminal expression is a decimal literal expression, recall expression, absolute value expression, parenthetical expression, or round expression."),
             #[cfg(feature = "rand")]
             MissingTerm(u) => write!(f, "Missing terminal expression at position {u}. A terminal expression is a decimal literal expression, recall expression, absolute value expression, parenthetical expression, round expression, or rand expression."),
             TrailingSyms(u) => write!(f, "Trailing symbols starting at position {u}."),
             #[cfg(feature = "rand")]
             Self::InvalidRand(u) => write!(f, "Invalid rand expression ending at position {u}. A rand expression is of the form 'rand()' or 'rand(<mod expression>, <mod expression>)'."),
             #[cfg(feature = "rand")]
             Self::RandInvalidArgs(u) => write!(f, "The second expression passed to the random function evaluated to rational number less than the first ending at position {u}."),
             #[cfg(feature = "rand")]
             Self::RandNoInts(u) => write!(f, "There are no 64-bit integers within the interval passed to the random function ending at position {u}."),
         }
     }
 }
 /// A successful evaluation of an input.
 #[derive(Debug)]
 pub enum O<'a> {
     /// The input only contained whitespace.
     /// This returns the previous `Eval`.
     /// It is `None` iff there have been no
     /// previous `Eval` results.
     Empty(&'a Option<Ratio<BigInt>>),
     /// The quit expression was issued to terminate the program.
     Exit,
     /// Result of a "normal" expression.
     Eval(&'a Ratio<BigInt>),
     /// The store expression stores and returns the previous `Eval`.
     /// It is `None` iff there have been no previous `Eval` results.
     Store(&'a Option<Ratio<BigInt>>),
 }
 impl<'a> Display for O<'a> {
     #[expect(
         unsafe_code,
         reason = "manually construct guaranteed UTF-8; thus avoid the needless check"
     )]
     #[inline]
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match *self {
             Empty(o) => {
                 o.as_ref().map_or(Ok(()), |val| {
                     if val.is_integer() {
                         write!(f, "> {val}")
                     } else {
                         // If the prime factors of the denominator are only 2 and 5,
                         // then the number requires a finite number of digits and thus
                         // will be represented perfectly using the fewest number of digits.
                         // Any other situation will be rounded to 9 fractional digits.
                         // max{twos, fives} represents the minimum number of fractional
                         // digits necessary to represent val.
                         let mut twos = 0;
                         let mut fives = 0;
                         let zero = BigInt::from_biguint(Sign::NoSign, BigUint::new(Vec::new()));
                         let one = BigInt::from_biguint(Sign::Plus, BigUint::new(vec![1]));
                         let two = BigInt::from_biguint(Sign::Plus, BigUint::new(vec![2]));
                         let five = BigInt::from_biguint(Sign::Plus, BigUint::new(vec![5]));
                         let mut denom = val.denom().clone();
                         let mut div_rem;
                         while denom > one {
                             div_rem = denom.div_rem(&two);
                             if div_rem.1 == zero {
                                 twos += 1;
                                 denom = div_rem.0;
                             } else {
                                 break;
                             }
                         }
                         while denom > one {
                             div_rem = denom.div_rem(&five);
                             if div_rem.1 == zero {
                                 fives += 1;
                                 denom = div_rem.0;
                             } else {
                                 break;
                             }
                         }
                         // int < 0 iff val <= -1. frac < 0 iff val is a negative non-integer.
                         let (int, frac, digits) = if denom == one {
                             let (int, mut frac) = val.numer().div_rem(val.denom());
                             while twos > fives {
                                 frac *= &five;
                                 fives += 1;
                             }
                             while fives > twos {
                                 frac *= &two;
                                 twos += 1;
                             }
                             (int, frac, twos)
                         } else {
                             // Requires an infinite number of decimal digits to represent, so we display
                             // 9 digits after rounding.
                             let mult =
                                 BigInt::from_biguint(Sign::Plus, BigUint::new(vec![10])).pow(9u8);
                             let (int, frac) = (val * &mult).round().numer().div_rem(&mult);
                             (int, frac, 9)
                         };
                         let int_str = int.to_string().into_bytes();
                         let (mut v, frac_str) = if val.numer().sign() == Sign::Minus {
                             if int_str[0] == b'-' {
                                 (
                                     Vec::with_capacity(int_str.len() + 1 + digits),
                                     (-frac).to_string().into_bytes(),
                                 )
                             } else {
                                 let mut tmp = Vec::with_capacity(int_str.len() + 2 + digits);
                                 tmp.push(b'-');
                                 (tmp, (-frac).to_string().into_bytes())
                             }
                         } else {
                             (
                                 Vec::with_capacity(int_str.len() + 1 + digits),
                                 frac.to_string().into_bytes(),
                             )
                         };
                         v.extend_from_slice(int_str.as_slice());
                         v.push(b'.');
                         // digits >= frac_str.len().
                         v.resize(v.len() + (digits - frac_str.len()), b'0');
                         v.extend_from_slice(frac_str.as_slice());
                         // SAFETY:
                         // v contains precisely the UTF-8 code units returned from Strings
                         // returned from the to_string function on the integer and fraction part of
                         // val plus optionally the single byte encodings of ".", "-", and "0".
                         write!(f, "> {}", unsafe { String::from_utf8_unchecked(v) })
                     }
                 })
             }
             Eval(r) => write!(f, "> {r}"),
             Exit => Ok(()),
             Store(o) => o.as_ref().map_or(Ok(()), |val| write!(f, "> {val}")),
         }
     }
 }
 /// Size of [`Evaluator::cache`].
 const CACHE_SIZE: usize = 8;
 /// Evaluates the supplied input.
 pub struct Evaluator<'input, 'cache, 'prev, 'scratch, 'rand> {
     /// The input to be evaluated.
     utf8: &'input [u8],
     /// The index within `utf8` that evaluation needs to continue.
     /// We use this instead of slicing from `utf8` since we want
     /// to be able to report the position within the input
     /// that an error occurs.
     i: usize,
     /// The cache of previously stored results.
     cache: &'cache mut Cache<Ratio<BigInt>, CACHE_SIZE>,
     /// The last result.
     prev: &'prev mut Option<Ratio<BigInt>>,
     /// Buffer used to evaluate right-associative sub-expressions.
     scratch: &'scratch mut Vec<Ratio<BigInt>>,
     /// Random number generator.
     #[cfg(feature = "rand")]
     rng: &'rand mut ThreadRng,
     #[cfg(not(feature = "rand"))]
     _rng: PhantomData<fn() -> &'rand ()>,
 }
 impl<'input, 'cache, 'prev, 'scratch, 'rand> Evaluator<'input, 'cache, 'prev, 'scratch, 'rand> {
     /// Creates an `Evaluator<'input, 'cache, 'prev, 'scratch, 'rand>` based on the supplied arguments.
     #[cfg(not(feature = "rand"))]
     #[inline]
     pub fn new(
         utf8: &'input [u8],
         cache: &'cache mut Cache<Ratio<BigInt>, 8>,
         prev: &'prev mut Option<Ratio<BigInt>>,
         scratch: &'scratch mut Vec<Ratio<BigInt>>,
     ) -> Self {
         Self {
             utf8,
             i: 0,
             cache,
             prev,
             scratch,
             _rng: PhantomData,
         }
     }
     /// Creates an `Evaluator<'input, 'cache, 'prev, 'scratch, 'rand>` based on the supplied arguments.
     #[cfg(feature = "rand")]
     #[inline]
     pub fn new(
         utf8: &'input [u8],
         cache: &'cache mut Cache<Ratio<BigInt>, 8>,
         prev: &'prev mut Option<Ratio<BigInt>>,
         scratch: &'scratch mut Vec<Ratio<BigInt>>,
         rng: &'rand mut ThreadRng,
     ) -> Self {
         Self {
             utf8,
             i: 0,
             cache,
             prev,
             scratch,
             rng,
         }
     }
     /// Evaluates the input consuming the `Evaluator<'input, 'cache, 'exp>`.
     /// Requires the input to contain one expression (i.e., if there are
     /// multiple newlines, it will error).
 
     /// # Errors
     ///
     /// Returns a [`LangErr`] iff the input violates the calc language.
     #[inline]
     pub fn evaluate(mut self) -> Result<O<'prev>, LangErr> {
         self.utf8 = if self.utf8.last().map_or(true, |b| *b != b'\n') {
             self.utf8
         } else {
             &self.utf8[..self.utf8.len()
                 - self
                     .utf8
                     .get(self.utf8.len().wrapping_sub(2))
                     .map_or(1, |b| if *b == b'\r' { 2 } else { 1 })]
         };
         self.consume_ws();
         let Some(b) = self.utf8.get(self.i) else {
             return Ok(Empty(self.prev));
         };
         if *b == b'q' {
             self.i += 1;
             self.consume_ws();
             if self.i == self.utf8.len() {
                 Ok(Exit)
             } else {
                 Err(InvalidQuit)
             }
         } else if *b == b's' {
             self.i += 1;
             self.consume_ws();
             if self.i == self.utf8.len() {
                 if let Some(ref val) = *self.prev {
                     self.cache.push(val.clone());
                 }
                 Ok(Store(self.prev))
             } else {
                 Err(InvalidStore)
             }
         } else {
             self.get_adds().and_then(move |val| {
                 self.consume_ws();
                 if self.i == self.utf8.len() {
                     Ok(Eval(self.prev.insert(val)))
                 } else {
                     Err(TrailingSyms(self.i))
                 }
             })
         }
     }
     /// Reads from the input until the next non-{space/tab} byte value.
     fn consume_ws(&mut self) {
         // ControlFlow makes more sense to use in try_fold; however due to a lack
         // of a map_or_else function, it is easier to simply return a Result with
         // Err taking the role of ControlFlow::Break.
         self.i += self.utf8[self.i..]
             .iter()
             .try_fold(0, |val, b| match *b {
                 b' ' | b'\t' => Ok(val + 1),
                 _ => Err(val),
             })
             .map_or_else(convert::identity, convert::identity);
     }
     /// Evaluates addition expressions as defined in the calc language.
     /// This function is used for both addition and subtraction operations which
     /// themselves are based on multiplication expressions.
     fn get_adds(&mut self) -> Result<Ratio<BigInt>, LangErr> {
         let mut left = self.get_mults()?;
         let mut j;
         self.consume_ws();
         while let Some(i) = self.utf8.get(self.i) {
             j = *i;
             self.consume_ws();
             if j == b'+' {
                 self.i += 1;
                 self.consume_ws();
                 left += self.get_mults()?;
             } else if j == b'-' {
                 self.i += 1;
                 self.consume_ws();
                 left -= self.get_mults()?;
             } else {
                 break;
             }
         }
         Ok(left)
     }
     /// Evaluates multiplication expressions as defined in the calc language.
     /// This function is used for both multiplication and division operations which
     /// themselves are based on negation expressions.
     fn get_mults(&mut self) -> Result<Ratio<BigInt>, LangErr> {
         let mut left = self.get_neg()?;
         let mut right;
         let mut j;
         let mut mod_val;
         let mut numer;
         self.consume_ws();
         while let Some(i) = self.utf8.get(self.i) {
             j = *i;
             self.consume_ws();
             if j == b'*' {
                 self.i += 1;
                 self.consume_ws();
                 left *= self.get_neg()?;
             } else if j == b'/' {
                 self.i += 1;
                 self.consume_ws();
                 right = self.get_neg()?;
                 if right.numer().sign() == Sign::NoSign {
                     return Err(DivByZero(self.i));
                 }
                 left /= right;
             } else if let Some(k) = self.utf8.get(self.i..self.i.saturating_add(3)) {
                 if k == b"mod" {
                     if !left.is_integer() {
                         return Err(ModIsNotInt(self.i));
                     }
                     self.i += 3;
                     self.consume_ws();
                     right = self.get_neg()?;
                     if !right.is_integer() {
                         return Err(ModIsNotInt(self.i));
                     }
                     numer = right.numer();
                     if numer.sign() == Sign::NoSign {
                         return Err(ModZero(self.i));
                     }
                     mod_val = left.numer() % numer;
                     left = Ratio::from_integer(if mod_val.sign() == Sign::Minus {
                         if numer.sign() == Sign::Minus {
                             mod_val - numer
                         } else {
                             mod_val + numer
                         }
                     } else {
                         mod_val
                     });
                 } else {
                     break;
                 }
             } else {
                 break;
             }
         }
         Ok(left)
     }
     /// Evaluates negation expressions as defined in the calc language.
     /// This function is based on exponentiation expressions.
     fn get_neg(&mut self) -> Result<Ratio<BigInt>, LangErr> {
         let mut count = 0usize;
         while let Some(b) = self.utf8.get(self.i) {
             if *b == b'-' {
                 self.i += 1;
                 self.consume_ws();
                 count += 1;
             } else {
                 break;
             }
         }
         self.get_exps()
             .map(|val| if count & 1 == 0 { val } else { -val })
     }
     /// Gets the square root of value so long as a solution exists.
     #[expect(
         clippy::unreachable,
         reason = "code that shouldn't happen did, so we want to crash"
     )]
     fn sqrt(val: Ratio<BigInt>) -> Option<Ratio<BigInt>> {
         /// Returns the square root of `n` if one exists; otherwise
         /// returns `None`.
         /// MUST NOT pass 0.
         #[expect(clippy::suspicious_operation_groupings, reason = "false positive")]
         fn calc(n: &BigUint) -> Option<BigUint> {
             let mut shift = n.bits();
             shift += shift & 1;
             let mut result = BigUint::new(Vec::new());
             let one = BigUint::new(vec![1]);
             let zero = BigUint::new(Vec::new());
             loop {
                 shift -= 2;
                 result <<= 1u32;
                 result |= &one;
                 result ^= if &result * &result > (n >> shift) {
                     &one
                 } else {
                     &zero
                 };
                 if shift == 0 {
                     break (&result * &result == *n).then_some(result);
                 }
             }
         }
         let numer = val.numer();
         if numer.sign() == Sign::NoSign {
             Some(val)
         } else {
             numer.try_into().map_or_else(
                 |_| None,
                 |num| {
                     calc(&num).and_then(|n| {
                         calc(&val.denom().try_into().unwrap_or_else(|_| {
                             unreachable!("Ratio must never have a negative denominator")
                         }))
                         .map(|d| Ratio::new(n.into(), d.into()))
                     })
                 },
             )
         }
     }
     /// Evaluates exponentiation expressions as defined in the calc language.
     /// This function is based on negation expressions.
     fn get_exps(&mut self) -> Result<Ratio<BigInt>, LangErr> {
         let mut t = self.get_fact()?;
         let ix = self.scratch.len();
         let mut prev;
         let mut numer;
         self.scratch.push(t);
         self.consume_ws();
         let mut j;
         let one = BigInt::new(Sign::Plus, vec![1]);
         let min_one = BigInt::new(Sign::Minus, vec![1]);
         let two = BigInt::new(Sign::Plus, vec![2]);
         while let Some(i) = self.utf8.get(self.i) {
             j = *i;
             self.consume_ws();
             if j == b'^' {
                 self.i += 1;
                 self.consume_ws();
                 t = self.get_neg()?;
                 // Safe since we always push at least one value, and we always
                 // return immediately once we encounter an error.
                 prev = self.scratch.index(self.scratch.len() - 1);
                 numer = prev.numer();
                 // Equiv to checking if prev is 0.
                 if numer.sign() == Sign::NoSign {
                     if t.numer().sign() == Sign::Minus {
                         self.scratch.clear();
                         return Err(ExpDivByZero(self.i));
                     }
                     self.scratch.push(t);
                 } else if prev.is_integer() {
                     let t_numer = t.numer();
                     // 1 raised to anything is 1, so we don't bother
                     // storing the exponent.
                     if *numer == one {
                     } else if t.is_integer()
                         || ((*t_numer == one || *t_numer == min_one) && *t.denom() == two)
                     {
                         self.scratch.push(t);
                     } else {
                         self.scratch.clear();
                         return Err(ExpIsNotIntOrOneHalf(self.i));
                     }
                 } else if t.is_integer()
                     || ((*t.numer() == one || *t.numer() == min_one) && *t.denom() == two)
                 {
                     self.scratch.push(t);
                 } else {
                     self.scratch.clear();
                     return Err(ExpIsNotIntOrOneHalf(self.i));
                 }
             } else {
                 break;
             }
         }
         self.scratch
             .drain(ix..)
             .try_rfold(Ratio::from_integer(one.clone()), |exp, base| {
                 if exp.is_integer() {
                     Ok(base.pow(exp.numer()))
                 } else if base.numer().sign() == Sign::NoSign {
                     Ok(base)
                 } else if *exp.denom() == two {
                     if *exp.numer() == one {
                         Self::sqrt(base).map_or_else(|| Err(SqrtDoesNotExist(self.i)), Ok)
                     } else if *exp.numer() == min_one {
                         Self::sqrt(base)
                             .map_or_else(|| Err(SqrtDoesNotExist(self.i)), |v| Ok(v.inv()))
                     } else {
                         Err(ExpIsNotIntOrOneHalf(self.i))
                     }
                 } else {
                     Err(ExpIsNotIntOrOneHalf(self.i))
                 }
             })
     }
     /// Evaluates factorial expressions as defined in the calc language.
     /// This function is based on terminal expressions.
     fn get_fact(&mut self) -> Result<Ratio<BigInt>, LangErr> {
         /// Calculates the factorial of `val`.
         fn fact(mut val: BigUint) -> BigUint {
             let zero = BigUint::new(Vec::new());
             let one = BigUint::new(vec![1]);
             let mut calc = BigUint::new(vec![1]);
             while val > zero {
                 calc *= &val;
                 val -= &one;
             }
             calc
         }
         let t = self.get_term()?;
         let Some(b) = self.utf8.get(self.i) else {
             return Ok(t);
         };
         if *b == b'!' {
             self.i += 1;
             if t.is_integer() {
                 // We can make a copy of self.i here, or call map_or instead
                 // of map_or_else.
                 let i = self.i;
                 t.numer().try_into().map_or_else(
                     |_| Err(NotNonNegIntFact(i)),
                     |val| {
                         let mut factorial = fact(val);
                         while let Some(b2) = self.utf8.get(self.i) {
                             if *b2 == b'!' {
                                 self.i += 1;
                                 factorial = fact(factorial);
                             } else {
                                 break;
                             }
                         }
                         Ok(Ratio::from_integer(BigInt::from_biguint(
                             Sign::Plus,
                             factorial,
                         )))
                     },
                 )
             } else {
                 Err(NotNonNegIntFact(self.i))
             }
         } else {
             Ok(t)
         }
     }
     /// Evaluates terminal expressions as defined in the calc language.
     /// This function is based on number literal expressions, parenthetical expressions,
     /// recall expressions, absolute value expressions, round expressions, and possibly
     /// rand expressions if that feature is enabled.
     fn get_term(&mut self) -> Result<Ratio<BigInt>, LangErr> {
         self.get_rational().map_or_else(Err, |o| {
             o.map_or_else(
                 || {
                     self.get_par().map_or_else(Err, |o2| {
                         o2.map_or_else(
                             || {
                                 self.get_recall().map_or_else(Err, |o3| {
                                     o3.map_or_else(
                                         || {
                                             self.get_abs().map_or_else(Err, |o4| {
                                                 o4.map_or_else(
                                                     || {
                                                         self.get_round().and_then(|o5| {
                                                             o5.map_or_else(
                                                                 #[cfg(not(feature = "rand"))]
                                                                 || Err(MissingTerm(self.i)),
                                                                 #[cfg(feature = "rand")]
                                                                 || self.get_rand(),
                                                                 Ok,
                                                             )
                                                         })
                                                     },
                                                     Ok,
                                                 )
                                             })
                                         },
                                         Ok,
                                     )
                                 })
                             },
                             Ok,
                         )
                     })
                 },
                 Ok,
             )
         })
     }
     /// Generates a random 64-bit integer. This function is based on add expressions. This is the last terminal
     /// expression attempted when needing a terminal expression; as a result, it is the only terminal expression
     /// that does not return an `Option`.
     #[cfg(feature = "rand")]
     fn get_rand(&mut self) -> Result<Ratio<BigInt>, LangErr> {
         /// Generates a random 64-bit integer.
         #[expect(clippy::host_endian_bytes, reason = "must keep platform endianness")]
         fn rand(rng: &mut ThreadRng) -> i64 {
             let mut bytes = [0; 8];
             // `ThreadRng::try_fill_bytes` is infallible, so easier to call `fill_bytes`.
             rng.fill_bytes(&mut bytes);
             i64::from_ne_bytes(bytes)
         }
         /// Generates a random 64-bit integer inclusively between the passed arguments.
         #[expect(clippy::single_call_fn, reason = "easier to reason about")]
         #[expect(
             clippy::integer_division_remainder_used,
             reason = "need for uniform randomness"
         )]
         #[expect(
             clippy::as_conversions,
             clippy::cast_possible_truncation,
             clippy::cast_possible_wrap,
             clippy::cast_sign_loss,
             reason = "lossless conversions between signed integers"
         )]
         fn rand_range(
             rng: &mut ThreadRng,
             lower: &Ratio<BigInt>,
             upper: &Ratio<BigInt>,
             i: usize,
         ) -> Result<i64, LangErr> {
             if lower > upper {
                 return Err(LangErr::RandInvalidArgs(i));
             }
             let lo = lower.ceil();
             let up = upper.floor();
             let lo_int = lo.numer();
             let up_int = up.numer();
             if lo_int > &BigInt::from(i64::MAX) || up_int < &BigInt::from(i64::MIN) {
                 return Err(LangErr::RandNoInts(i));
             }
             let lo_min = lo_int.to_i64().unwrap_or(i64::MIN);
             let up_max = up_int.to_i64().unwrap_or(i64::MAX);
             if up_max > lo_min || upper.is_integer() || lower.is_integer() {
                 let low = i128::from(lo_min);
                 // `i64::MAX >= up_max >= low`; so underflow and overflow cannot happen.
                 // range is [1, 2^64] so casting to a u128 is fine.
                 let modulus = (i128::from(up_max) - low + 1) as u128;
                 // range is [0, i64::MAX] so converting to a `u64` is fine.
                 // rem represents how many values need to be removed
                 // when generating a random i64 in order for uniformity.
                 let rem = (0x0001_0000_0000_0000_0000 % modulus) as u64;
                 let mut low_adj;
                 loop {
                     low_adj = rand(rng) as u64;
                     // Since rem is in [0, i64::MAX], this is the same as low_adj < 0 || low_adj >= rem.
                     if low_adj >= rem {
                         return Ok(
                             // range is [i64::MIN, i64::MAX]; thus casts are safe.
                             // modulus is up_max - low + 1; so as low grows,
                             // % shrinks by the same factor. i64::MAX happens
                             // when low = up_max = i64::MAX or when low = 0,
                             // up_max = i64::MAX and low_adj is i64::MAX.
                             ((u128::from(low_adj) % modulus) as i128 + low) as i64,
                         );
                     }
                 }
             } else {
                 Err(LangErr::RandNoInts(i))
             }
         }
         // This is the last kind of terminal expression that is attempted.
         // If there is no more data, then we have a missing terminal expression.
         let Some(b) = self.utf8.get(self.i..self.i.saturating_add(5)) else {
             return Err(MissingTerm(self.i));
         };
         if b == b"rand(" {
             self.i += 5;
             self.consume_ws();
             let i = self.i;
             self.utf8.get(self.i).map_or_else(
                 || Err(LangErr::InvalidRand(i)),
                 |p| {
                     if *p == b')' {
                         self.i += 1;
                         Ok(Ratio::from_integer(BigInt::from(rand(self.rng))))
                     } else {
                         let add = self.get_adds()?;
                         let Some(b2) = self.utf8.get(self.i) else {
                             return Err(LangErr::InvalidRand(self.i));
                         };
                         if *b2 == b',' {
                             self.i += 1;
                             self.consume_ws();
                             let add2 = self.get_adds()?;
                             self.consume_ws();
                             let Some(b3) = self.utf8.get(self.i) else {
                                 return Err(LangErr::InvalidRand(self.i));
                             };
                             if *b3 == b')' {
                                 self.i += 1;
                                 rand_range(self.rng, &add, &add2, self.i)
                                     .map(|v| Ratio::from_integer(BigInt::from(v)))
                             } else {
                                 Err(LangErr::InvalidRand(self.i))
                             }
                         } else {
                             Err(LangErr::InvalidRand(self.i))
                         }
                     }
                 },
             )
         } else {
             Err(MissingTerm(self.i))
         }
     }
     /// Rounds a value to the specified number of fractional digits.
     /// This function is based on add expressions.
     fn get_round(&mut self) -> Result<Option<Ratio<BigInt>>, LangErr> {
         let Some(b) = self.utf8.get(self.i..self.i.saturating_add(6)) else {
             return Ok(None);
         };
         if b == b"round(" {
             self.i += 6;
             self.consume_ws();
             let val = self.get_adds()?;
             self.consume_ws();
             let Some(b2) = self.utf8.get(self.i) else {
                 return Err(InvalidRound(self.i));
             };
             let b3 = *b2;
             if b3 == b',' {
                 self.i += 1;
                 self.consume_ws();
                 let Some(b4) = self.utf8.get(self.i) else {
                     return Err(InvalidRound(self.i));
                 };
                 let r = if b4.is_ascii_digit() {
                     self.i += 1;
                     *b4 - b'0'
                 } else {
                     return Err(InvalidRound(self.i));
                 };
                 self.consume_ws();
                 let i = self.i;
                 self.utf8.get(self.i).map_or_else(
                     || Err(InvalidRound(i)),
                     |p| {
                         if *p == b')' {
                             self.i += 1;
                             let mult =
                                 BigInt::from_biguint(Sign::Plus, BigUint::new(vec![10])).pow(r);
                             Ok(Some((val * &mult).round() / &mult))
                         } else {
                             Err(InvalidRound(self.i))
                         }
                     },
                 )
             } else {
                 Err(InvalidRound(self.i))
             }
         } else {
             Ok(None)
         }
     }
     /// Evaluates absolute value expressions as defined in the calc language.
     /// This function is based on add expressions.
     fn get_abs(&mut self) -> Result<Option<Ratio<BigInt>>, LangErr> {
         let Some(b) = self.utf8.get(self.i) else {
             return Ok(None);
         };
         if *b == b'|' {
             self.i += 1;
             self.consume_ws();
             let r = self.get_adds()?;
             self.consume_ws();
             let Some(b2) = self.utf8.get(self.i) else {
                 return Err(InvalidAbs(self.i));
             };
             let b3 = *b2;
             if b3 == b'|' {
                 self.i += 1;
                 Ok(Some(if r.numer().sign() == Sign::Minus {
                     -r
                 } else {
                     r
                 }))
             } else {
                 Err(InvalidAbs(self.i))
             }
         } else {
             Ok(None)
         }
     }
     /// Evaluates recall expressions as defined in the calc language.
     // This does not return a Result<Option<&Ratio<BigInt>>, LangErr>
     // since the only place this function is called is in get_term which
     // would end up needing to clone the Ratio anyway. By not forcing
     // get_term to clone, it can rely on map_or_else over match expressions.
     fn get_recall(&mut self) -> Result<Option<Ratio<BigInt>>, LangErr> {
         let Some(b) = self.utf8.get(self.i) else {
             return Ok(None);
         };
         if *b == b'@' {
             self.i += 1;
             self.cache
                 .get(self.utf8.get(self.i).map_or(0, |b2| {
                     if (b'1'..b'9').contains(b2) {
                         self.i += 1;
                         usize::from(*b2 - b'1')
                     } else {
                         0
                     }
                 }))
                 .map_or_else(
                     || Err(NotEnoughPrevResults(self.cache.len())),
                     |p| Ok(Some(p.clone())),
                 )
         } else {
             Ok(None)
         }
     }
     /// Evaluates parenthetical expressions as defined in the calc language.
     /// This function is based on add expressions.
     fn get_par(&mut self) -> Result<Option<Ratio<BigInt>>, LangErr> {
         let Some(b) = self.utf8.get(self.i) else {
             return Ok(None);
         };
         if *b == b'(' {
             self.i += 1;
             self.consume_ws();
             let r = self.get_adds()?;
             self.consume_ws();
             let Some(b2) = self.utf8.get(self.i) else {
                 return Err(InvalidPar(self.i));
             };
             let b3 = *b2;
             if b3 == b')' {
                 self.i += 1;
                 Ok(Some(r))
             } else {
                 Err(InvalidPar(self.i))
             }
         } else {
             Ok(None)
         }
     }
     /// Evaluates number literal expressions as defined in the calc language.
     fn get_rational(&mut self) -> Result<Option<Ratio<BigInt>>, LangErr> {
         // ControlFlow makes more sense to use in try_fold; however due to a lack
         // of a map_or_else function, it is easier to simply return a Result with
         // Err taking the role of ControlFlow::Break.
         /// Used to parse a sequence of digits into an unsigned integer.
         fn to_biguint(v: &[u8]) -> (BigUint, usize) {
             v.iter()
                 .try_fold((BigUint::new(Vec::new()), 0), |mut prev, d| {
                     if d.is_ascii_digit() {
                         prev.1 += 1;
                         // `*d - b'0'` is guaranteed to return a integer between 0 and 9.
                         prev.0 = prev.0 * 10u8 + (*d - b'0');
                         Ok(prev)
                     } else {
                         Err(prev)
                     }
                 })
                 .map_or_else(convert::identity, convert::identity)
         }
         let (int, len) = to_biguint(&self.utf8[self.i..]);
         if len == 0 {
             return Ok(None);
         }
         self.i += len;
         if let Some(b) = self.utf8.get(self.i) {
             if *b == b'.' {
                 self.i += 1;
                 let (numer, len2) = to_biguint(&self.utf8[self.i..]);
                 if len2 == 0 {
                     Err(InvalidDec(self.i))
                 } else {
                     self.i += len2;
                     Ok(Some(
                         Ratio::from_integer(BigInt::from_biguint(Sign::Plus, int))
                             + Ratio::new(
                                 BigInt::from_biguint(Sign::Plus, numer),
                                 BigInt::from_biguint(Sign::Plus, BigUint::new(vec![10]).pow(len2)),
                             ),
                     ))
                 }
             } else {
                 Ok(Some(Ratio::from_integer(BigInt::from_biguint(
                     Sign::Plus,
                     int,
                 ))))
             }
         } else {
             Ok(Some(Ratio::from_integer(BigInt::from_biguint(
                 Sign::Plus,
                 int,
             ))))
         }
     }
 }
 /// Reads data from `R` passing each line to an [`Evaluator`] to be evaluated.
 #[cfg(feature = "std")]
 pub struct EvalIter<R> {
     /// Reader that contains input data.
     reader: R,
     /// Buffer that is used by `reader` to read
     /// data into.
     input_buffer: Vec<u8>,
     /// Cache of stored results.
     cache: Cache<Ratio<BigInt>, 8>,
     /// Result of the previous expression.
     prev: Option<Ratio<BigInt>>,
     /// Buffer used by [`Evaluator`] to process
     /// sub-expressions.
     exp_buffer: Vec<Ratio<BigInt>>,
     /// Random number generator.
     #[cfg(feature = "rand")]
     rng: ThreadRng,
 }
 #[cfg(feature = "std")]
 impl<R> EvalIter<R> {
     /// Creates a new `EvalIter`.
     #[inline]
     #[cfg(feature = "rand")]
     pub fn new(reader: R) -> Self {
         Self {
             reader,
             input_buffer: Vec::new(),
             cache: Cache::new(),
             prev: None,
             exp_buffer: Vec::new(),
             rng: rand::thread_rng(),
         }
     }
     /// Creates a new `EvalIter`.
     #[inline]
     #[cfg(any(doc, not(feature = "rand")))]
     pub fn new(reader: R) -> Self {
         Self {
             reader,
             input_buffer: Vec::new(),
             cache: Cache::new(),
             prev: None,
             exp_buffer: Vec::new(),
         }
     }
 }
 #[cfg(feature = "std")]
 extern crate std;
 #[cfg(feature = "std")]
 use std::io::{BufRead, Error};
 #[cfg(feature = "std")]
 /// Error returned from [`EvalIter`] when an expression has an error.
 #[derive(Debug)]
 pub enum E {
     /// Error containing [`Error`] which is returned
     /// from [`EvalIter`] when reading from the supplied
     /// [`BufRead`]er.
     Error(Error),
     /// Error containing [`LangErr`] which is returned
     /// from [`EvalIter`] when evaluating a single expression.
     LangErr(LangErr),
 }
 #[cfg(feature = "std")]
 impl Display for E {
     #[inline]
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match *self {
             Self::Error(ref e) => e.fmt(f),
             Self::LangErr(ref e) => e.fmt(f),
         }
     }
 }
 #[cfg(feature = "std")]
 use crate::lending_iterator::LendingIterator;
 #[cfg(feature = "std")]
 impl<R> LendingIterator for EvalIter<R>
 where
     R: BufRead,
 {
     type Item<'a> = Result<O<'a>, E> where Self: 'a;
     #[inline]
     fn lend_next(&mut self) -> Option<Result<O<'_>, E>> {
         self.input_buffer.clear();
         self.exp_buffer.clear();
         self.reader
             .read_until(b'\n', &mut self.input_buffer)
             .map_or_else(
                 |e| Some(Err(E::Error(e))),
                 |c| {
                     if c == 0 {
                         None
                     } else {
                         Evaluator::new(
                             self.input_buffer.as_slice(),
                             &mut self.cache,
                             &mut self.prev,
                             &mut self.exp_buffer,
                             #[cfg(feature = "rand")]
                             &mut self.rng,
                         )
                         .evaluate()
                         .map_or_else(
                             |e| Some(Err(E::LangErr(e))),
                             |o| match o {
                                 O::Empty(_) | O::Eval(_) | O::Store(_) => Some(Ok(o)),
                                 O::Exit => None,
                             },
                         )
                     }
                 },
             )
     }
 }
 #[cfg(test)]
 mod tests {
     use super::*;
     #[cfg(not(feature = "rand"))]
     #[test]
     fn empty() {
         // Empty expressions without a previous result return nothing.
         assert!(
             match Evaluator::new(b"\n", &mut Cache::new(), &mut None, &mut Vec::new())
                 .evaluate()
                 .unwrap()
             {
                 O::Empty(o) => o.is_none(),
                 _ => false,
             }
         );
         assert!(
             Evaluator::new(
                 b"  \t  \t \n",
                 &mut Cache::new(),
                 &mut Some(Ratio::from_integer(BigInt::from_biguint(
                     Sign::Minus,
                     BigUint::new(vec![12])
                 ))),
                 &mut Vec::new()
             )
             .evaluate()
             .unwrap()
             .to_string()
                 == "> -12"
         );
         assert!(
             Evaluator::new(
                 b"\t\n",
                 &mut Cache::new(),
                 &mut Some(Ratio::new(
                     BigInt::from_biguint(Sign::Minus, BigUint::new(vec![4])),
                     BigInt::from_biguint(Sign::Plus, BigUint::new(vec![6]))
                 )),
                 &mut Vec::new()
             )
             .evaluate()
             .unwrap()
             .to_string()
                 == "> -0.666666667"
         );
         assert!(
             Evaluator::new(
                 b"\t\n",
                 &mut Cache::new(),
                 &mut Some(Ratio::new(
                     BigInt::from_biguint(Sign::Plus, BigUint::new(vec![1])),
                     BigInt::from_biguint(Sign::Plus, BigUint::new(vec![4230196224, 6]))
                 )),
                 &mut Vec::new()
             )
             .evaluate()
             .unwrap()
             .to_string()
                 == "> 0.000000000"
         );
         assert!(
             Evaluator::new(
                 b"\t\n",
                 &mut Cache::new(),
                 &mut Some(Ratio::new(
                     BigInt::from_biguint(Sign::Plus, BigUint::new(vec![17])),
                     BigInt::from_biguint(Sign::Plus, BigUint::new(vec![4230196224, 6]))
                 )),
                 &mut Vec::new()
             )
             .evaluate()
             .unwrap()
             .to_string()
                 == "> 0.000000001"
         );
         assert!(
             Evaluator::new(
                 b"\t\n",
                 &mut Cache::new(),
                 &mut Some(Ratio::new(
                     BigInt::from_biguint(Sign::Plus, BigUint::new(vec![3])),
                     BigInt::from_biguint(Sign::Plus, BigUint::new(vec![10]))
                 )),
                 &mut Vec::new()
             )
             .evaluate()
             .unwrap()
             .to_string()
                 == "> 0.3"
         );
         assert!(
             Evaluator::new(
                 b"\t\n",
                 &mut Cache::new(),
                 &mut Some(Ratio::new(
                     BigInt::from_biguint(Sign::Minus, BigUint::new(vec![203])),
                     BigInt::from_biguint(Sign::Plus, BigUint::new(vec![10]))
                 )),
                 &mut Vec::new()
             )
             .evaluate()
             .unwrap()
             .to_string()
                 == "> -20.3"
         );
         assert!(
             Evaluator::new(
                 &[0u8; 0],
                 &mut Cache::new(),
                 &mut Some(Ratio::new(
                     BigInt::from_biguint(Sign::Minus, BigUint::new(vec![203])),
                     BigInt::from_biguint(Sign::Plus, BigUint::new(vec![10]))
                 )),
                 &mut Vec::new()
             )
             .evaluate()
             .unwrap()
             .to_string()
                 == "> -20.3"
         );
     }
     #[cfg(not(feature = "rand"))]
     #[test]
     fn number_literal() {
         // Normal 0 is fine.
         assert!(
             Evaluator::new(b"0", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_rational()
                 .unwrap()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(
                     Sign::NoSign,
                     BigUint::new(Vec::new())
                 ))
         );
         // Leading 0s and trailing 0s are fine.
         assert!(
             Evaluator::new(b"0000.00000", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_rational()
                 .unwrap()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(
                     Sign::NoSign,
                     BigUint::new(Vec::new())
                 ))
         );
         // Parsing stops at first non-(digit/period).
         assert!(
             Evaluator::new(b"1 0", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_rational()
                 .unwrap()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![1])))
         );
         let int = b"3397450981271938475135134759823759835414";
         let frac = b"913759810573549872354897210539127530981570";
         let left = Ratio::from_integer(BigInt::parse_bytes(int, 10).unwrap());
         let right = Ratio::new(
             BigInt::parse_bytes(frac, 10).unwrap(),
             BigInt::from_biguint(Sign::Plus, BigUint::new(vec![10]).pow(frac.len() + 1)),
         );
         let mut vec = Vec::new();
         vec.extend_from_slice(int);
         vec.push(b'.');
         vec.push(b'0');
         vec.extend_from_slice(frac);
         // Test a number whose integer and fraction portions are larger than u128::MAX.
         assert!(
             Evaluator::new(
                 vec.as_slice(),
                 &mut Cache::new(),
                 &mut None,
                 &mut Vec::new()
             )
             .get_rational()
             .unwrap()
             .unwrap()
                 == left + right
         );
         // Leading 0s and trailing 0s for a non-zero value are fine.
         assert!(
             Evaluator::new(
                 b"000000014.0000000000000",
                 &mut Cache::new(),
                 &mut None,
                 &mut Vec::new()
             )
             .get_rational()
             .unwrap()
             .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![14])))
         );
         // A sequence of digits followed immediately by a decimal point but no digits after is invalid.
         assert!(
             match Evaluator::new(b"1.", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_rational()
                 .unwrap_err()
             {
                 InvalidDec(i) => i == 2,
                 _ => false,
             }
         );
         // A sequence of digits followed immediately by a decimal point but no digits after is invalid.
         // This just shows that spaces are not ignored in number literals.
         assert!(
             match Evaluator::new(b"1. 2", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_rational()
                 .unwrap_err()
             {
                 InvalidDec(i) => i == 2,
                 _ => false,
             }
         );
         // Non-whitespace starting the input is valid but produces no value.
         // This also shows that an invalid byte sequence does not produce an error here.
         assert!(
             Evaluator::new(b"a1", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_rational()
                 .unwrap()
                 .is_none()
         );
         // A space starting the input is valid but produces no value.
         assert!(
             Evaluator::new(b" 1", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_rational()
                 .unwrap()
                 .is_none()
         );
         // A tab starting the input is valid but produces no value.
         assert!(
             Evaluator::new(b"\t1", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_rational()
                 .unwrap()
                 .is_none()
         );
         // Negative literals don't exist, so this should succeed but produce nothing.
         assert!(
             Evaluator::new(b"-1", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_rational()
                 .unwrap()
                 .is_none()
         );
         // '/' is division and not part of a number literal so only the "numerator" is parsed.
         assert!(
             Evaluator::new(b"1/2", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_rational()
                 .unwrap()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![1])))
         );
         // A sequence of digits followed by invalid bytes is valid and produces a number equal to the digits before the invalid bytes.
         assert!(
             Evaluator::new(b"130alj", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_rational()
                 .unwrap()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![130])))
         );
     }
     #[cfg(not(feature = "rand"))]
     #[test]
     fn par() {
         // Missing closing ')'
         assert!(
             match Evaluator::new(b"(1", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_par()
                 .unwrap_err()
             {
                 InvalidPar(i) => i == 2,
                 _ => false,
             }
         );
         assert!(
             match Evaluator::new(b"((1\t + 2)", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_par()
                 .unwrap_err()
             {
                 InvalidPar(i) => i == 9,
                 _ => false,
             }
         );
         assert!(
             Evaluator::new(b"(  0 \t )", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_par()
                 .unwrap()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(
                     Sign::NoSign,
                     BigUint::new(Vec::new())
                 ))
         );
         assert!(
             Evaluator::new(b"( - \t 5 )", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_par()
                 .unwrap()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Minus, BigUint::new(vec![5])))
         );
         assert!(
             Evaluator::new(
                 b"( ( 2 -\t  5) * 9 )",
                 &mut Cache::new(),
                 &mut None,
                 &mut Vec::new()
             )
             .get_par()
             .unwrap()
             .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Minus, BigUint::new(vec![27])))
         );
     }
     #[cfg(not(feature = "rand"))]
     #[test]
     fn recall_expression() {
         // If the input does not start with '@', then it's valid but produces nothing.
         assert!(
             Evaluator::new(b"1", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_recall()
                 .unwrap()
                 .is_none()
         );
         assert!(
             Evaluator::new(b"a", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_recall()
                 .unwrap()
                 .is_none()
         );
         assert!(
             Evaluator::new(b" @", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_recall()
                 .unwrap()
                 .is_none()
         );
         assert!(
             Evaluator::new(b"\t@", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_recall()
                 .unwrap()
                 .is_none()
         );
         // Invalid recall expression since there are no previous results.
         assert!(
             match Evaluator::new(b"@", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_recall()
                 .unwrap_err()
             {
                 NotEnoughPrevResults(count) => count == 0,
                 _ => false,
             }
         );
         // Invalid recall expression since there are no previous results.
         assert!(
             match Evaluator::new(b"@4", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_recall()
                 .unwrap_err()
             {
                 NotEnoughPrevResults(count) => count == 0,
                 _ => false,
             }
         );
         // Invalid recall expression since there are no previous results.
         // The input violates our grammar, but this error happens before that.
         assert!(
             match Evaluator::new(b"@0", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_recall()
                 .unwrap_err()
             {
                 NotEnoughPrevResults(count) => count == 0,
                 _ => false,
             }
         );
         // Successfully extract previous expression.
         let mut prev = None;
         let mut cache = Cache::new();
         Evaluator::new(b"1\n", &mut cache, &mut prev, &mut Vec::new())
             .evaluate()
             .unwrap();
         Evaluator::new(b"   s   \r\n", &mut cache, &mut prev, &mut Vec::new())
             .evaluate()
             .unwrap();
         assert!(
             Evaluator::new(b"@", &mut cache, &mut prev, &mut Vec::new())
                 .get_recall()
                 .unwrap()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![1])))
         );
         // Invalid characters are ignored at this stage.
         assert!(
             Evaluator::new(b"@&", &mut cache, &mut prev, &mut Vec::new())
                 .get_recall()
                 .unwrap()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![1])))
         );
         // 0 is not a valid stored value only 1-8 are.
         assert!(
             Evaluator::new(b"@0", &mut cache, &mut prev, &mut Vec::new())
                 .get_recall()
                 .unwrap()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![1])))
         );
         // 9 is not a valid stored value only 1-8 are.
         assert!(
             Evaluator::new(b"@9", &mut cache, &mut prev, &mut Vec::new())
                 .get_recall()
                 .unwrap()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![1])))
         );
         // Spaces are not cleaned; otherwise this would error since we only have 1 stored value.
         assert!(
             Evaluator::new(b"@ 2", &mut cache, &mut prev, &mut Vec::new())
                 .get_recall()
                 .unwrap()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![1])))
         );
         // Tabs are not cleaned; otherwise this would error since we only have 1 stored value.
         assert!(
             Evaluator::new(b"@\t2", &mut cache, &mut prev, &mut Vec::new())
                 .get_recall()
                 .unwrap()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![1])))
         );
         // One digits are looked at so this is not @<ten>.
         assert!(
             Evaluator::new(b"@10", &mut cache, &mut prev, &mut Vec::new())
                 .get_recall()
                 .unwrap()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![1])))
         );
         // Invalid recall expression since there is only one stored result.
         assert!(
             match Evaluator::new(b"@2", &mut cache, &mut prev, &mut Vec::new())
                 .get_recall()
                 .unwrap_err()
             {
                 NotEnoughPrevResults(count) => count == 1,
                 _ => false,
             }
         );
         Evaluator::new(b"2\r\n", &mut cache, &mut prev, &mut Vec::new())
             .evaluate()
             .unwrap();
         Evaluator::new(b"s\n", &mut cache, &mut prev, &mut Vec::new())
             .evaluate()
             .unwrap();
         // Stored values correct.
         assert!(
             Evaluator::new(b"@", &mut cache, &mut prev, &mut Vec::new())
                 .get_recall()
                 .unwrap()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![2])))
         );
         assert!(
             Evaluator::new(b"@2", &mut cache, &mut prev, &mut Vec::new())
                 .get_recall()
                 .unwrap()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![1])))
         );
         // Invalid recall expression since there are only three stored results.
         assert!(
             match Evaluator::new(b"@3", &mut cache, &mut prev, &mut Vec::new())
                 .get_recall()
                 .unwrap_err()
             {
                 NotEnoughPrevResults(count) => count == 2,
                 _ => false,
             }
         );
         let mut v = vec![0, b'\n'];
         for i in b'3'..=b'8' {
             v[0] = i;
             Evaluator::new(v.as_slice(), &mut cache, &mut prev, &mut Vec::new())
                 .evaluate()
                 .unwrap();
             Evaluator::new(b"s\n", &mut cache, &mut prev, &mut Vec::new())
                 .evaluate()
                 .unwrap();
         }
         v[0] = b'@';
         for i in b'1'..=b'8' {
             v[1] = i;
             // Cache is filled up correctly storing all previous values.
             assert!(
                 Evaluator::new(v.as_slice(), &mut cache, &mut prev, &mut Vec::new())
                     .get_recall()
                     .unwrap()
                     .unwrap()
                     == Ratio::from_integer(BigInt::from_biguint(
                         Sign::Plus,
                         BigUint::new(vec![(b'9' - i) as u32])
                     ))
             );
         }
         // Only parses the first @ since the second @ is not a digit between 1 and 8.
         assert!(
             Evaluator::new(b"@@", &mut cache, &mut prev, &mut Vec::new())
                 .get_recall()
                 .unwrap()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![8])))
         );
         Evaluator::new(b"9\r\n", &mut cache, &mut prev, &mut Vec::new())
             .evaluate()
             .unwrap();
         Evaluator::new(b"s\n", &mut cache, &mut prev, &mut Vec::new())
             .evaluate()
             .unwrap();
         // Oldest value is overwritten; all others remain.
         for i in b'1'..=b'8' {
             v[1] = i;
             assert!(
                 Evaluator::new(v.as_slice(), &mut cache, &mut prev, &mut Vec::new())
                     .get_recall()
                     .unwrap()
                     .unwrap()
                     == Ratio::from_integer(BigInt::from_biguint(
                         Sign::Plus,
                         BigUint::new(vec![((b'9' + 1) - i) as u32])
                     ))
             );
         }
     }
     #[cfg(not(feature = "rand"))]
     #[test]
     fn abs() {
         // Missing closing '|'
         assert!(
             match Evaluator::new(b"|1", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_abs()
                 .unwrap_err()
             {
                 InvalidAbs(i) => i == 2,
                 _ => false,
             }
         );
         assert!(
             match Evaluator::new(b"||1 + 2|", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_abs()
                 .unwrap_err()
             {
                 InvalidAbs(i) => i == 8,
                 _ => false,
             }
         );
         assert!(
             Evaluator::new(
                 b"|  0\t \t |",
                 &mut Cache::new(),
                 &mut None,
                 &mut Vec::new()
             )
             .get_abs()
             .unwrap()
             .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(
                     Sign::NoSign,
                     BigUint::new(Vec::new())
                 ))
         );
         assert!(
             Evaluator::new(b"| -  5 |", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_abs()
                 .unwrap()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![5])))
         );
         assert!(
             Evaluator::new(
                 b"| \t| 2 -  5| * 9 |",
                 &mut Cache::new(),
                 &mut None,
                 &mut Vec::new()
             )
             .get_abs()
             .unwrap()
             .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![27])))
         );
         // If the input does not start with '|', then it's valid but produces nothing.
         assert!(
             Evaluator::new(b" \t|9|", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_abs()
                 .unwrap()
                 .is_none()
         );
     }
     #[cfg(not(feature = "rand"))]
     #[test]
     fn round() {
         // Missing ',<digit>)'
         assert!(
             match Evaluator::new(b"round(1", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_round()
                 .unwrap_err()
             {
                 InvalidRound(i) => i == 7,
                 _ => false,
             }
         );
         assert!(
             match Evaluator::new(b"round(1,", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_round()
                 .unwrap_err()
             {
                 InvalidRound(i) => i == 8,
                 _ => false,
             }
         );
         assert!(
             match Evaluator::new(b"round(1,2", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_round()
                 .unwrap_err()
             {
                 InvalidRound(i) => i == 9,
                 _ => false,
             }
         );
         assert!(match Evaluator::new(
             b"round(1,10)",
             &mut Cache::new(),
             &mut None,
             &mut Vec::new()
         )
         .get_round()
         .unwrap_err()
         {
             InvalidRound(i) => i == 9,
             _ => false,
         });
         assert!(
             match Evaluator::new(b"round(1,a)", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_round()
                 .unwrap_err()
             {
                 InvalidRound(i) => i == 8,
                 _ => false,
             }
         );
         assert!(
             Evaluator::new(
                 b"round(2, 7)",
                 &mut Cache::new(),
                 &mut None,
                 &mut Vec::new()
             )
             .get_round()
             .unwrap()
                 == Some(Ratio::from_integer(BigInt::from_biguint(
                     Sign::Plus,
                     BigUint::new(vec![2])
                 )))
         );
         assert!(
             Evaluator::new(
                 b"round(2.677, 1)",
                 &mut Cache::new(),
                 &mut None,
                 &mut Vec::new()
             )
             .get_round()
             .unwrap()
                 == Some(Ratio::new(
                     BigInt::from_biguint(Sign::Plus, BigUint::new(vec![27])),
                     BigInt::from_biguint(Sign::Plus, BigUint::new(vec![10]))
                 ))
         );
     }
     #[cfg(feature = "rand")]
     #[test]
     fn rand() {
         assert!(match Evaluator::new(
             b"rand(1",
             &mut Cache::new(),
             &mut None,
             &mut Vec::new(),
             &mut rand::thread_rng()
         )
         .get_rand()
         .unwrap_err()
         {
             LangErr::InvalidRand(i) => i == 6,
             _ => false,
         });
         assert!(match Evaluator::new(
             b"rand(1,2",
             &mut Cache::new(),
             &mut None,
             &mut Vec::new(),
             &mut rand::thread_rng()
         )
         .get_rand()
         .unwrap_err()
         {
             LangErr::InvalidRand(i) => i == 8,
             _ => false,
         });
         assert!(match Evaluator::new(
             b"rand(1/2,3/4)",
             &mut Cache::new(),
             &mut None,
             &mut Vec::new(),
             &mut rand::thread_rng(),
         )
         .get_rand()
         .unwrap_err()
         {
             LangErr::RandNoInts(i) => i == 13,
             _ => false,
         });
         assert!(match Evaluator::new(
             b"rand(-100000000000000000000000,-1000000000000000000000)",
             &mut Cache::new(),
             &mut None,
             &mut Vec::new(),
             &mut rand::thread_rng(),
         )
         .get_rand()
         .unwrap_err()
         {
             LangErr::RandNoInts(i) => i == 55,
             _ => false,
         });
         assert!(match Evaluator::new(
             b"rand(2/3,1/3)",
             &mut Cache::new(),
             &mut None,
             &mut Vec::new(),
             &mut rand::thread_rng(),
         )
         .get_rand()
         .unwrap_err()
         {
             LangErr::RandInvalidArgs(i) => i == 13,
             _ => false,
         });
         // If the input does not start with 'rand(', then it's invalid since get_rand must only be called as the last terminal expression which means whitespace must be consumed already.
         assert!(match Evaluator::new(
             b" rand(2/3,2)",
             &mut Cache::new(),
             &mut None,
             &mut Vec::new(),
             &mut rand::thread_rng(),
         )
         .get_rand()
         .unwrap_err()
         {
             MissingTerm(i) => i == 0,
             _ => false,
         });
         assert!(Evaluator::new(
             b"rand(2, 7)",
             &mut Cache::new(),
             &mut None,
             &mut Vec::new(),
             &mut rand::thread_rng()
         )
         .get_rand()
         .map(|r| {
             let int = r.numer();
             int >= &BigInt::from_biguint(Sign::Plus, BigUint::new(vec![2]))
                 && *int <= BigInt::from_biguint(Sign::Plus, BigUint::new(vec![7]))
         })
         .unwrap());
         assert!(Evaluator::new(
             b"rand()",
             &mut Cache::new(),
             &mut None,
             &mut Vec::new(),
             &mut rand::thread_rng()
         )
         .get_rand()
         .map(|r| {
             let int = r.numer();
             int >= &BigInt::from(i64::MIN) && *int <= BigInt::from(i64::MAX)
         })
         .unwrap());
         for _ in 0..100 {
             assert!(Evaluator::new(
                 b"rand(2, 2)",
                 &mut Cache::new(),
                 &mut None,
                 &mut Vec::new(),
                 &mut rand::thread_rng()
             )
             .get_rand()
             .map(|r| *r.numer() == BigInt::from_biguint(Sign::Plus, BigUint::new(vec![2])))
             .unwrap());
         }
     }
     #[cfg(feature = "rand")]
     #[test]
     #[ignore]
     fn rand_uni() {
         // Test rand on an interval that is not a power of 2 in size.
         // This causes rand to adjust the interval to enforce uniformity.
         let mut vals = [0u32; 3];
         let mut vec = Vec::new();
         let mut cache = Cache::new();
         let mut none = None;
         const COUNT: u32 = 999999;
         for _ in 1..COUNT {
             vals[(Evaluator::new(
                 b"rand(-1, 1)",
                 &mut cache,
                 &mut none,
                 &mut vec,
                 &mut rand::thread_rng(),
             )
             .get_rand()
             .unwrap()
             .numer()
             .to_i32()
             .unwrap()
                 + 1) as usize] += 1;
         }
         // Test that the distribution is within 1% of what is expected.
         assert!(vals
             .into_iter()
             .try_fold(false, |_, r| {
                 if r < COUNT * 33 / 100 || r > COUNT * 101 / 300 {
                     Err(false)
                 } else {
                     Ok(true)
                 }
             })
             .unwrap());
     }
     #[test]
     fn term() {
         #[cfg(not(feature = "rand"))]
         assert!(
             Evaluator::new(b"0000.00000", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_term()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(
                     Sign::NoSign,
                     BigUint::new(Vec::new())
                 ))
         );
         #[cfg(not(feature = "rand"))]
         assert!(
             Evaluator::new(b"(4)", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_term()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![4])))
         );
         #[cfg(not(feature = "rand"))]
         assert!(
             Evaluator::new(
                 b"round(-2/3,2)",
                 &mut Cache::new(),
                 &mut None,
                 &mut Vec::new()
             )
             .get_term()
             .unwrap()
                 == Ratio::new(
                     BigInt::from_biguint(Sign::Minus, BigUint::new(vec![67])),
                     BigInt::from_biguint(Sign::Plus, BigUint::new(vec![100]))
                 )
         );
         #[cfg(feature = "rand")]
         assert!(Evaluator::new(
             b"rand()",
             &mut Cache::new(),
             &mut None,
             &mut Vec::new(),
             &mut rand::thread_rng()
         )
         .get_term()
         .is_ok());
         #[cfg(feature = "rand")]
         assert!(Evaluator::new(
             b"rand(-13/93, 833)",
             &mut Cache::new(),
             &mut None,
             &mut Vec::new(),
             &mut rand::thread_rng(),
         )
         .get_term()
         .is_ok());
         #[cfg(not(feature = "rand"))]
         assert!(
             match Evaluator::new(b"rand()", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_term()
                 .unwrap_err()
             {
                 MissingTerm(i) => i == 0,
                 _ => false,
             }
         );
         #[cfg(not(feature = "rand"))]
         assert!(
             Evaluator::new(b"|4|", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_term()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![4])))
         );
         // Terminal expressions do no clean up before or after.
         #[cfg(not(feature = "rand"))]
         assert!(
             match Evaluator::new(b" 2", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_term()
                 .unwrap_err()
             {
                 MissingTerm(i) => i == 0,
                 _ => false,
             }
         );
         #[cfg(not(feature = "rand"))]
         let mut prev = None;
         #[cfg(not(feature = "rand"))]
         let mut cache = Cache::new();
         #[cfg(not(feature = "rand"))]
         Evaluator::new(b"1\n", &mut cache, &mut prev, &mut Vec::new())
             .evaluate()
             .unwrap();
         #[cfg(not(feature = "rand"))]
         Evaluator::new(b"s\n", &mut cache, &mut prev, &mut Vec::new())
             .evaluate()
             .unwrap();
         #[cfg(not(feature = "rand"))]
         assert!(
             Evaluator::new(b"@", &mut cache, &mut prev, &mut Vec::new())
                 .get_term()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![1])))
         );
     }
     #[cfg(not(feature = "rand"))]
     #[test]
     fn factorial() {
         // Negative integer is not allowed.
         assert!(
             match Evaluator::new(b"(-1)!", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_fact()
                 .unwrap_err()
             {
                 NotNonNegIntFact(i) => i == 5,
                 _ => false,
             }
         );
         // Non-integer is not allowed.
         assert!(
             match Evaluator::new(b"2.5!", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_fact()
                 .unwrap_err()
             {
                 NotNonNegIntFact(i) => i == 4,
                 _ => false,
             }
         );
         // factorials always become terminal expressions eventually.
         assert!(
             Evaluator::new(b"7", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_fact()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![7])))
         );
         assert!(
             Evaluator::new(b"(7)", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_fact()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![7])))
         );
         assert!(
             Evaluator::new(b"|7|", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_fact()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![7])))
         );
         let mut prev = None;
         let mut cache = Cache::new();
         Evaluator::new(b"3\n", &mut cache, &mut prev, &mut Vec::new())
             .evaluate()
             .unwrap();
         Evaluator::new(b"s\n", &mut cache, &mut prev, &mut Vec::new())
             .evaluate()
             .unwrap();
         assert!(
             Evaluator::new(b"@!", &mut cache, &mut prev, &mut Vec::new())
                 .get_fact()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![6])))
         );
         assert!(
             Evaluator::new(b"@", &mut cache, &mut prev, &mut Vec::new())
                 .get_fact()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![3])))
         );
         // 0! = 1.
         assert!(
             Evaluator::new(b"0.0!", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_fact()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![1])))
         );
         // 1! = 1.
         assert!(
             Evaluator::new(b"1!", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_fact()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![1])))
         );
         // 4! = 24, and whitespace is not consumed.
         assert!(
             Evaluator::new(b"4! \t", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_fact()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![24])))
         );
         // Factorials can be chained.
         assert!(
             Evaluator::new(b"3!! ", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_fact()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![720])))
         );
         // only factorial is consumed.
         assert!(
             Evaluator::new(b"2!+3", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_fact()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![2])))
         );
         // Error since leading/trailing whitespace is not consumed by factorial or higher precedence expressions.
         assert!(
             match Evaluator::new(b" 2!", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_fact()
                 .unwrap_err()
             {
                 MissingTerm(i) => i == 0,
                 _ => false,
             }
         );
         assert!(
             match Evaluator::new(b"\t2!", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_fact()
                 .unwrap_err()
             {
                 MissingTerm(i) => i == 0,
                 _ => false,
             }
         );
         // Error since negation is not consumed by factorial or higher precedence expressions.
         assert!(
             match Evaluator::new(b"-2!", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_fact()
                 .unwrap_err()
             {
                 MissingTerm(i) => i == 0,
                 _ => false,
             }
         );
     }
     #[cfg(not(feature = "rand"))]
     #[test]
     fn exp() {
         // 1 can be raised to anything and return 1.
         // Also white space is ignored between operator.
         assert!(
             Evaluator::new(b"1  ^\t  0", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_exps()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![1])))
         );
         assert!(
             Evaluator::new(b"1^0.5", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_exps()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![1])))
         );
         assert!(
             Evaluator::new(b"1^(-1/2)", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_exps()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![1])))
         );
         assert!(
             Evaluator::new(b"1.0^(-2)", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_exps()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![1])))
         );
         // 0 can be raised to any non-negative value and will always return 0 unless raised to 0 which will return 1.
         assert!(
             Evaluator::new(b"0^0", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_exps()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![1])))
         );
         assert!(
             Evaluator::new(b"0^1", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_exps()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::NoSign, BigUint::new(vec![0])))
         );
         assert!(
             Evaluator::new(b"0^0.5", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_exps()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::NoSign, BigUint::new(vec![0])))
         );
         // Anything else can only be raised to integers.
         assert!(
             Evaluator::new(b"4^0", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_exps()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![1])))
         );
         assert!(
             Evaluator::new(b"4^1", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_exps()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![4])))
         );
         assert!(
             Evaluator::new(b"4^(-2)", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_exps()
                 .unwrap()
                 == Ratio::new(
                     BigInt::from_biguint(Sign::Plus, BigUint::new(vec![1])),
                     BigInt::from_biguint(Sign::Plus, BigUint::new(vec![16]))
                 )
         );
         assert!(
             Evaluator::new(b"(-4)^0", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_exps()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![1])))
         );
         assert!(
             Evaluator::new(b"(-4)^1", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_exps()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Minus, BigUint::new(vec![4])))
         );
         assert!(
             Evaluator::new(b"(-4)^2", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_exps()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![16])))
         );
         assert!(
             Evaluator::new(b"(-4)^(-2)", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_exps()
                 .unwrap()
                 == Ratio::new(
                     BigInt::from_biguint(Sign::Plus, BigUint::new(vec![1])),
                     BigInt::from_biguint(Sign::Plus, BigUint::new(vec![16]))
                 )
         );
         assert!(
             Evaluator::new(b"(-4)^(-3)", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_exps()
                 .unwrap()
                 == Ratio::new(
                     BigInt::from_biguint(Sign::Minus, BigUint::new(vec![1])),
                     BigInt::from_biguint(Sign::Plus, BigUint::new(vec![64]))
                 )
         );
         assert!(
             Evaluator::new(b"(2/3)^0", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_exps()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![1])))
         );
         assert!(
             Evaluator::new(b"(2/3)^(2)", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_exps()
                 .unwrap()
                 == Ratio::new(
                     BigInt::from_biguint(Sign::Plus, BigUint::new(vec![4])),
                     BigInt::from_biguint(Sign::Plus, BigUint::new(vec![9]))
                 )
         );
         assert!(
             Evaluator::new(b"(2/3)^(-3)", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_exps()
                 .unwrap()
                 == Ratio::new(
                     BigInt::from_biguint(Sign::Plus, BigUint::new(vec![27])),
                     BigInt::from_biguint(Sign::Plus, BigUint::new(vec![8]))
                 )
         );
         assert!(
             Evaluator::new(b"(-2/3)^0", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_exps()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![1])))
         );
         assert!(
             Evaluator::new(b"(-2/3)^(2)", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_exps()
                 .unwrap()
                 == Ratio::new(
                     BigInt::from_biguint(Sign::Plus, BigUint::new(vec![4])),
                     BigInt::from_biguint(Sign::Plus, BigUint::new(vec![9]))
                 )
         );
         assert!(
             Evaluator::new(b"(-2/3)^(3)", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_exps()
                 .unwrap()
                 == Ratio::new(
                     BigInt::from_biguint(Sign::Minus, BigUint::new(vec![8])),
                     BigInt::from_biguint(Sign::Plus, BigUint::new(vec![27]))
                 )
         );
         assert!(
             Evaluator::new(
                 b"(-2/3)^(-2)",
                 &mut Cache::new(),
                 &mut None,
                 &mut Vec::new()
             )
             .get_exps()
             .unwrap()
                 == Ratio::new(
                     BigInt::from_biguint(Sign::Plus, BigUint::new(vec![9])),
                     BigInt::from_biguint(Sign::Plus, BigUint::new(vec![4]))
                 )
         );
         assert!(
             Evaluator::new(
                 b"(-2/3)^(-3)",
                 &mut Cache::new(),
                 &mut None,
                 &mut Vec::new()
             )
             .get_exps()
             .unwrap()
                 == Ratio::new(
                     BigInt::from_biguint(Sign::Minus, BigUint::new(vec![27])),
                     BigInt::from_biguint(Sign::Plus, BigUint::new(vec![8]))
                 )
         );
         assert!(
             Evaluator::new(
                 b"(4/9)^(-1/2)",
                 &mut Cache::new(),
                 &mut None,
                 &mut Vec::new()
             )
             .get_exps()
             .unwrap()
                 == Ratio::new(
                     BigInt::from_biguint(Sign::Plus, BigUint::new(vec![3])),
                     BigInt::from_biguint(Sign::Plus, BigUint::new(vec![2]))
                 )
         );
         // Error since 0 cannot be raised to a negative power.
         assert!(
             match Evaluator::new(b"0^(-1)", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_exps()
                 .unwrap_err()
             {
                 ExpDivByZero(i) => i == 6,
                 _ => false,
             }
         );
         // Error since anything other than 0 or 1 cannot be raised to a non-integer power or (+/-) 1/2.
         assert!(
             match Evaluator::new(b"2^(1/3)", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_exps()
                 .unwrap_err()
             {
                 ExpIsNotIntOrOneHalf(i) => i == 7,
                 _ => false,
             }
         );
         // When exponent is (+/-) 1/2, base has to be the square of a rational number.
         assert!(
             match Evaluator::new(b"2^(1/2)", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_exps()
                 .unwrap_err()
             {
                 SqrtDoesNotExist(i) => i == 7,
                 _ => false,
             }
         );
         // exps always become factorials eventually.
         assert!(
             Evaluator::new(b"3!", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_exps()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![6])))
         );
         // exponentiation has lower precedence than factorials.
         assert!(
             Evaluator::new(b"2^3!", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_exps()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![64])))
         );
         assert!(
             Evaluator::new(b"3!^2", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_exps()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![36])))
         );
         // Error since leading/trailing whitespace is not consumed by exponentiation or higher precedence expressions.
         assert!(
             match Evaluator::new(b" 2^2", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_exps()
                 .unwrap_err()
             {
                 MissingTerm(i) => i == 0,
                 _ => false,
             }
         );
         assert!(
             match Evaluator::new(b"\t2^2", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_exps()
                 .unwrap_err()
             {
                 MissingTerm(i) => i == 0,
                 _ => false,
             }
         );
     }
     #[cfg(not(feature = "rand"))]
     #[test]
     fn neg() {
         assert!(
             Evaluator::new(b"-1", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_neg()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Minus, BigUint::new(vec![1])))
         );
         assert!(
             Evaluator::new(b"- \t  -  1", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_neg()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![1])))
         );
         assert!(
             Evaluator::new(b"-0", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_neg()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(
                     Sign::NoSign,
                     BigUint::new(Vec::new())
                 ))
         );
         // negation has lower precedence than exponentiation.
         assert!(
             Evaluator::new(b"-2^2", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_neg()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Minus, BigUint::new(vec![4])))
         );
         // negation always becomes exponentiation eventually.
         assert!(
             Evaluator::new(b"2.0^2.0", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_neg()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![4])))
         );
         // Error since leading/trailing whitespace is not consumed by exponentiation or higher precedence expressions.
         assert!(
             match Evaluator::new(b" -2", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_neg()
                 .unwrap_err()
             {
                 MissingTerm(i) => i == 0,
                 _ => false,
             }
         );
         assert!(
             match Evaluator::new(b"\t-2", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_neg()
                 .unwrap_err()
             {
                 MissingTerm(i) => i == 0,
                 _ => false,
             }
         );
     }
     #[cfg(not(feature = "rand"))]
     #[test]
     fn mult() {
         assert!(
             Evaluator::new(b"2  *   3", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_mults()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![6])))
         );
         assert!(
             Evaluator::new(
                 b"-2  * \t  3",
                 &mut Cache::new(),
                 &mut None,
                 &mut Vec::new()
             )
             .get_mults()
             .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Minus, BigUint::new(vec![6])))
         );
         assert!(
             Evaluator::new(
                 b"2\t  *   -3.0",
                 &mut Cache::new(),
                 &mut None,
                 &mut Vec::new()
             )
             .get_mults()
             .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Minus, BigUint::new(vec![6])))
         );
         assert!(
             Evaluator::new(b"-2.5*-3.5", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_mults()
                 .unwrap()
                 == Ratio::new(
                     BigInt::from_biguint(Sign::Plus, BigUint::new(vec![35])),
                     BigInt::from_biguint(Sign::Plus, BigUint::new(vec![4]))
                 )
         );
         assert!(
             Evaluator::new(b"4.0\t /  6", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_mults()
                 .unwrap()
                 == Ratio::new(
                     BigInt::from_biguint(Sign::Plus, BigUint::new(vec![2])),
                     BigInt::from_biguint(Sign::Plus, BigUint::new(vec![3]))
                 )
         );
         assert!(
             Evaluator::new(b"6/3", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_mults()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![2])))
         );
         assert!(
             Evaluator::new(b"-6/3", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_mults()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Minus, BigUint::new(vec![2])))
         );
         assert!(
             Evaluator::new(b"6/-3", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_mults()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Minus, BigUint::new(vec![2])))
         );
         assert!(
             Evaluator::new(
                 b"-  6 /\t -  3",
                 &mut Cache::new(),
                 &mut None,
                 &mut Vec::new()
             )
             .get_mults()
             .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![2])))
         );
         // Number literals are not strictly equivalent to "ratios" as "ratios" don't exist (i.e., 2/3 is not the ratio of 2 to 3 but is the rational number two divided by the rational number 3).
         assert!(
             Evaluator::new(b"1/1.5", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_mults()
                 .unwrap()
                 != Evaluator::new(b"1/3/2", &mut Cache::new(), &mut None, &mut Vec::new())
                     .get_mults()
                     .unwrap()
         );
         assert!(
             Evaluator::new(b"1/1.5", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_mults()
                 .unwrap()
                 == Evaluator::new(b"1/(3/2)", &mut Cache::new(), &mut None, &mut Vec::new())
                     .get_mults()
                     .unwrap()
         );
         // multiplication always becomes negation eventually.
         assert!(
             Evaluator::new(b"-2.0", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_mults()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Minus, BigUint::new(vec![2])))
         );
         // Error since leading/trailing whitespace is not consumed by multiplication or higher precedence expressions.
         assert!(
             match Evaluator::new(b" 2*2", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_mults()
                 .unwrap_err()
             {
                 MissingTerm(i) => i == 0,
                 _ => false,
             }
         );
         assert!(
             match Evaluator::new(b"\t2/2", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_mults()
                 .unwrap_err()
             {
                 MissingTerm(i) => i == 0,
                 _ => false,
             }
         );
         assert!(
             Evaluator::new(
                 b"4.0\t mod  6",
                 &mut Cache::new(),
                 &mut None,
                 &mut Vec::new()
             )
             .get_mults()
             .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![4])),)
         );
         assert!(
             Evaluator::new(b"5 mod 3", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_mults()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![2])))
         );
         assert!(
             Evaluator::new(b"-5 mod 3", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_mults()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![1])))
         );
         assert!(
             Evaluator::new(b"5 mod -3", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_mults()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![2])))
         );
         assert!(
             Evaluator::new(
                 b"-5   mod\t -3",
                 &mut Cache::new(),
                 &mut None,
                 &mut Vec::new()
             )
             .get_mults()
             .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![1])))
         );
         // Cannot divide by 0.
         assert!(
             match Evaluator::new(b"2/0", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_mults()
                 .unwrap_err()
             {
                 DivByZero(i) => i == 3,
                 _ => false,
             }
         );
         assert!(
             match Evaluator::new(b"2 mod 0", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_mults()
                 .unwrap_err()
             {
                 ModZero(i) => i == 7,
                 _ => false,
             }
         );
         // Right and left operands of mod must be integers.
         assert!(
             match Evaluator::new(b"3.2 mod 1", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_mults()
                 .unwrap_err()
             {
                 ModIsNotInt(i) => i == 4,
                 _ => false,
             }
         );
         assert!(
             match Evaluator::new(b"3 mod 3.2", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_mults()
                 .unwrap_err()
             {
                 ModIsNotInt(i) => i == 9,
                 _ => false,
             }
         );
         // multiplication has lower precedence than exponentiation.
         assert!(
             Evaluator::new(b"2*2^2", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_mults()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![8])))
         );
         assert!(
             Evaluator::new(b"8/2^2", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_mults()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![2])))
         );
         assert!(
             Evaluator::new(b"8 mod 3^2", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_mults()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![8])))
         );
     }
     #[cfg(not(feature = "rand"))]
     #[test]
     fn add() {
         assert!(
             Evaluator::new(b"2  +   3", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_adds()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![5])))
         );
         assert!(
             Evaluator::new(b"-2  +   3", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_adds()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![1])))
         );
         assert!(
             Evaluator::new(
                 b"2  +  \t -3.0",
                 &mut Cache::new(),
                 &mut None,
                 &mut Vec::new()
             )
             .get_adds()
             .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Minus, BigUint::new(vec![1])))
         );
         assert!(
             Evaluator::new(b"-2.5+-3.5", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_adds()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Minus, BigUint::new(vec![6])))
         );
         assert!(
             Evaluator::new(b"4.0\t -  6", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_adds()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Minus, BigUint::new(vec![2])))
         );
         assert!(
             Evaluator::new(b"6-3", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_adds()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![3])))
         );
         assert!(
             Evaluator::new(b"-6-3", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_adds()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Minus, BigUint::new(vec![9])))
         );
         assert!(
             Evaluator::new(b"6--3", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_adds()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![9])))
         );
         assert!(
             Evaluator::new(
                 b"-  6 -\t -  3",
                 &mut Cache::new(),
                 &mut None,
                 &mut Vec::new()
             )
             .get_adds()
             .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Minus, BigUint::new(vec![3])))
         );
         // addition always becomes multiplication eventually.
         assert!(
             Evaluator::new(b"2 * 8", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_adds()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![16])))
         );
         assert!(
             Evaluator::new(b"8 /\t 2", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_adds()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![4])))
         );
         // Error since leading/trailing whitespace is not consumed by addition or higher precedence expressions.
         assert!(
             match Evaluator::new(b" 2+2", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_adds()
                 .unwrap_err()
             {
                 MissingTerm(i) => i == 0,
                 _ => false,
             }
         );
         assert!(
             match Evaluator::new(b" 2-2", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_adds()
                 .unwrap_err()
             {
                 MissingTerm(i) => i == 0,
                 _ => false,
             }
         );
         // addition has lower precedence than multiplication.
         assert!(
             Evaluator::new(b"2+2*2", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_adds()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![6])))
         );
         assert!(
             Evaluator::new(b"2+2/2", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_adds()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![3])))
         );
         assert!(
             Evaluator::new(b"2-2*2", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_adds()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Minus, BigUint::new(vec![2])))
         );
         assert!(
             Evaluator::new(b"2-2/2", &mut Cache::new(), &mut None, &mut Vec::new())
                 .get_adds()
                 .unwrap()
                 == Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![1])))
         );
     }
     #[cfg(not(feature = "rand"))]
     #[test]
     fn exit() {
         assert!(
             match Evaluator::new(b"  q    \n", &mut Cache::new(), &mut None, &mut Vec::new())
                 .evaluate()
                 .unwrap()
             {
                 O::Exit => true,
                 _ => false,
             }
         );
         assert!(match Evaluator::new(
             b"  q    \r\n",
             &mut Cache::new(),
             &mut None,
             &mut Vec::new()
         )
         .evaluate()
         .unwrap()
         {
             O::Exit => true,
             _ => false,
         });
         assert!(
             match Evaluator::new(b"q\n", &mut Cache::new(), &mut None, &mut Vec::new())
                 .evaluate()
                 .unwrap()
             {
                 O::Exit => true,
                 _ => false,
             }
         );
         assert!(
             match Evaluator::new(b"q\r\n", &mut Cache::new(), &mut None, &mut Vec::new())
                 .evaluate()
                 .unwrap()
             {
                 O::Exit => true,
                 _ => false,
             }
         );
         assert!(
             match Evaluator::new(b"\rq\n", &mut Cache::new(), &mut None, &mut Vec::new())
                 .evaluate()
                 .unwrap_err()
             {
                 MissingTerm(i) => i == 0,
                 _ => false,
             }
         );
         assert!(
             match Evaluator::new(b"\tq\n", &mut Cache::new(), &mut None, &mut Vec::new())
                 .evaluate()
                 .unwrap()
             {
                 O::Exit => true,
                 _ => false,
             }
         );
         assert!(
             match Evaluator::new(b"q\n\n", &mut Cache::new(), &mut None, &mut Vec::new())
                 .evaluate()
                 .unwrap_err()
             {
                 InvalidQuit => true,
                 _ => false,
             }
         );
         assert!(
             match Evaluator::new(b"\nq\n", &mut Cache::new(), &mut None, &mut Vec::new())
                 .evaluate()
                 .unwrap_err()
             {
                 MissingTerm(i) => i == 0,
                 _ => false,
             }
         );
         assert!(
             match Evaluator::new(b"q", &mut Cache::new(), &mut None, &mut Vec::new())
                 .evaluate()
                 .unwrap()
             {
                 O::Exit => true,
                 _ => false,
             }
         );
     }
     #[cfg(not(feature = "rand"))]
     #[test]
     fn store() {
         let mut prev = None;
         let mut cache = Cache::new();
         Evaluator::new(b"1\n", &mut cache, &mut prev, &mut Vec::new())
             .evaluate()
             .unwrap();
         assert!(cache.is_empty());
         assert!(
             match Evaluator::new(b"s\n", &mut cache, &mut prev, &mut Vec::new())
                 .evaluate()
                 .unwrap()
             {
                 O::Store(o) =>
                     o.as_ref().unwrap()
                         == &Ratio::from_integer(BigInt::from_biguint(
                             Sign::Plus,
                             BigUint::new(vec![1])
                         )),
                 _ => false,
             }
         );
         assert!(cache.len() == 1);
     }
     #[cfg(not(feature = "rand"))]
     #[test]
     fn eval() {
         use core::str::FromStr;
         let mut prev = None;
         let mut cache = Cache::new();
         let mut exp = Vec::new();
         assert!(
             match Evaluator::new(b"1+2\n", &mut cache, &mut prev, &mut exp)
                 .evaluate()
                 .unwrap()
             {
                 O::Eval(i) =>
                     i == &Ratio::from_integer(BigInt::from_biguint(
                         Sign::Plus,
                         BigUint::new(vec![3])
                     )),
                 _ => false,
             }
         );
         assert!(
             match Evaluator::new(b"\t  s  \n", &mut cache, &mut prev, &mut exp)
                 .evaluate()
                 .unwrap()
             {
                 O::Store(o) =>
                     o.as_ref().unwrap()
                         == &Ratio::from_integer(BigInt::from_biguint(
                             Sign::Plus,
                             BigUint::new(vec![3])
                         )),
                 _ => false,
             }
         );
         assert!(
             match Evaluator::new(b"-1/2+2*@\n", &mut cache, &mut prev, &mut exp)
                 .evaluate()
                 .unwrap()
             {
                 O::Eval(i) =>
                     i == &Ratio::new(
                         BigInt::from_biguint(Sign::Plus, BigUint::new(vec![11])),
                         BigInt::from_biguint(Sign::Plus, BigUint::new(vec![2]))
                     ),
                 _ => false,
             }
         );
         assert!(
             match Evaluator::new(b"s\n", &mut cache, &mut prev, &mut exp)
                 .evaluate()
                 .unwrap()
             {
                 O::Store(o) =>
                     o == &Some(Ratio::new(
                         BigInt::from_biguint(Sign::Plus, BigUint::new(vec![11])),
                         BigInt::from_biguint(Sign::Plus, BigUint::new(vec![2]))
                     )),
                 _ => false,
             }
         );
         assert!(
             match Evaluator::new(b"@^@2!\r\n", &mut cache, &mut prev, &mut exp)
                 .evaluate()
                 .unwrap()
             {
                 O::Eval(i) =>
                     i == &Ratio::new(
                         BigInt::from_biguint(Sign::Plus, BigUint::new(vec![1771561])),
                         BigInt::from_biguint(Sign::Plus, BigUint::new(vec![64]))
                     ),
                 _ => false,
             }
         );
         assert!(
             match Evaluator::new(b"s\n", &mut cache, &mut prev, &mut exp)
                 .evaluate()
                 .unwrap()
             {
                 O::Store(o) =>
                     o == &Some(Ratio::new(
                         BigInt::from_biguint(Sign::Plus, BigUint::new(vec![1771561])),
                         BigInt::from_biguint(Sign::Plus, BigUint::new(vec![64]))
                     )),
                 _ => false,
             }
         );
         // Verified with Wolfram Alpha.
         assert!(match Evaluator::new(b" \t 1 + (2 * |(7.98\t - 12/7)|) / 4!^@3!^|1-3|\t  \n", &mut cache, &mut prev, &mut exp).evaluate().unwrap() {
             O::Eval(i) => i == &Ratio::from_str("2841328814244153299237884950647090899374680152474331/2841328814244153299237884950647090899374680152473600").unwrap(),
             _ => false,
         });
         assert!(match Evaluator::new(
             b" \t round(19/6,0)!\t  \r\n",
             &mut cache,
             &mut prev,
             &mut exp
         )
         .evaluate()
         .unwrap()
         {
             O::Eval(i) =>
                 i == &Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![6]))),
             _ => false,
         });
         assert!(match Evaluator::new(
             b" \t 2^round(19/6,0)!\t  \r\n",
             &mut cache,
             &mut prev,
             &mut exp
         )
         .evaluate()
         .unwrap()
         {
             O::Eval(i) =>
                 i == &Ratio::from_integer(BigInt::from_biguint(Sign::Plus, BigUint::new(vec![64]))),
             _ => false,
         });
         assert!(
             match Evaluator::new(b"round(19/6,0)^2\t\n", &mut cache, &mut prev, &mut exp)
                 .evaluate()
                 .unwrap()
             {
                 O::Eval(i) =>
                     i == &Ratio::from_integer(BigInt::from_biguint(
                         Sign::Plus,
                         BigUint::new(vec![9])
                     )),
                 _ => false,
             }
         );
         // Invalid UTF-8 does not cause a panic!.
         assert!(
             match Evaluator::new(&[255, 255, 255, b'\n'], &mut cache, &mut prev, &mut exp)
                 .evaluate()
                 .unwrap_err()
             {
                 MissingTerm(i) => i == 0,
                 _ => false,
             }
         );
         assert!(
             match Evaluator::new(&[b'2', 255, b'\n'], &mut cache, &mut prev, &mut exp)
                 .evaluate()
                 .unwrap_err()
             {
                 TrailingSyms(i) => i == 1,
                 _ => false,
             }
         );
         // Exactly one newline is required.
         assert!(
             match Evaluator::new(b"2\n\n", &mut cache, &mut prev, &mut exp)
                 .evaluate()
                 .unwrap_err()
             {
                 TrailingSyms(i) => i == 1,
                 _ => false,
             }
         );
         assert!(
             prev == Some(Ratio::from_integer(BigInt::from_biguint(
                 Sign::Plus,
                 BigUint::new(vec![9])
             )))
         );
         assert!(match Evaluator::new(b"\n", &mut cache, &mut prev, &mut exp)
             .evaluate()
             .unwrap()
         {
             O::Empty(o) =>
                 o == &Some(Ratio::from_integer(BigInt::from_biguint(
                     Sign::Plus,
                     BigUint::new(vec![9])
                 ))),
             _ => false,
         });
         assert!(
             prev == Some(Ratio::from_integer(BigInt::from_biguint(
                 Sign::Plus,
                 BigUint::new(vec![9])
             )))
         );
         assert!(
             match Evaluator::new(b"\r\n", &mut cache, &mut prev.clone(), &mut exp)
                 .evaluate()
                 .unwrap()
             {
                 O::Empty(o) => *o == prev,
                 _ => false,
             }
         );
         assert!(
             match Evaluator::new(&[0u8; 0], &mut cache, &mut prev.clone(), &mut exp)
                 .evaluate()
                 .unwrap()
             {
                 O::Empty(o) => *o == prev,
                 _ => false,
             }
         );
     }
     #[cfg(feature = "rand")]
     #[test]
     fn eval_iter() {
         use super::*;
         use num_traits::ToPrimitive;
         use std::io::{self, BufRead, Error, ErrorKind, Read};
         struct Reader<'a> {
             data: &'a [u8],
             err: bool,
         }
         impl<'a> Reader<'a> {
             fn new(data: &'a [u8]) -> Self {
                 Self { data, err: true }
             }
         }
         impl<'a> Read for Reader<'a> {
             fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
                 if self.err {
                     self.err = false;
                     Err(Error::new(ErrorKind::Other, ""))
                 } else {
                     let len = usize::min(buf.len(), self.data.len());
                     buf[..len].copy_from_slice(&self.data[..len]);
                     Ok(len)
                 }
             }
         }
         impl<'a> BufRead for Reader<'a> {
             fn fill_buf(&mut self) -> io::Result<&[u8]> {
                 if self.err {
                     self.err = false;
                     Err(Error::new(ErrorKind::Other, ""))
                 } else {
                     Ok(self.data)
                 }
             }
             fn consume(&mut self, amt: usize) {
                 self.data = &self.data[amt..];
             }
         }
         let mut iter = EvalIter::new(Reader::new(
             b"1+2\n4\n\nq\n5\ns\nrand() + rand(-139/@, 2984/134)\nab",
         ));
         assert!(match iter.lend_next().unwrap().unwrap_err() {
             E::Error(_) => true,
             _ => false,
         });
         assert!(match iter.lend_next().unwrap().unwrap() {
             O::Eval(r) => r.numer().to_i32().unwrap() == 3,
             _ => false,
         });
         assert!(match iter.lend_next().unwrap().unwrap() {
             O::Eval(r) => r.numer().to_i32().unwrap() == 4,
             _ => false,
         });
         assert!(match iter.lend_next().unwrap().unwrap() {
             O::Empty(r) => r.as_ref().unwrap().numer().to_i32().unwrap() == 4,
             _ => false,
         });
         assert!(iter.lend_next().is_none());
         assert!(match iter.lend_next().unwrap().unwrap() {
             O::Eval(r) => r.numer().to_i32().unwrap() == 5,
             _ => false,
         });
         assert!(match iter.lend_next().unwrap().unwrap() {
             O::Store(r) => r.as_ref().unwrap().numer().to_i32().unwrap() == 5,
             _ => false,
         });
         assert!(match iter.lend_next().unwrap().unwrap() {
             O::Eval(r) => r.is_integer(),
             _ => false,
         });
         assert!(match iter.lend_next().unwrap().unwrap_err() {
             E::LangErr(e) => match e {
                 LangErr::MissingTerm(_) => true,
                 _ => false,
             },
             _ => false,
         });
         assert!(iter.lend_next().is_none());
         assert!(iter.lend_next().is_none());
         assert!(iter.lend_next().is_none());
     }
 }