Add ISNA and ISERROR (and ISERR and ISNAN aliases) functions

Closes #22

Author: Blake-Madden

TinyExprChanges.md

@@ -51,15 +51,20 @@ The following are changes from the original TinyExpr C library:
   - `even`: returns a value rounded up to the nearest even integer.
   - `fact`: alias for `fac()`, like the *Excel* function.
   - `false`: returns `false` (i.e., `0`) in a boolean expression.
+  - `iserr`: returns true if an expression evaluates to NaN.
+  - `iserror`: alias for `iserr`.
   - `iseven`: returns true if a number is even, false if odd.
+  - `isna`: alias for `iserr`.
+  - `isnan`: alias for `iserr`.
   - `isodd`: returns true if a number is odd, false if even.
   - `if`: if a value is true (i.e., non-zero), then returns the second argument; otherwise, returns the third argument.
   - `ifs`: checks up to three conditions, returning the value corresponding to the first met condition.
   - `max`: returns the maximum of a range of values (accepts 1-24 arguments).
   - `maxint`: returns the largest integer value that the parser can store.
   - `min`: returns the minimum of a range of values (accepts 1-24 arguments).
   - `mod`: returns remainder from a division.
-  - `nan`: returns `NaN` (i.e., Not-a-Number) in a boolean expression.
+  - `na`: returns `NaN` (i.e., Not-a-Number) in a boolean expression.
+  - `nan`: alias for `na`.
   - `nominal`: returns the nominal annual interest rate, provided the effective rate and the number of compounding periods per year.
   - `odd`: returns a value rounded up to the nearest odd integer.
   - `or`: returns true (i.e., non-zero) if any condition is true (accepts 1-24 arguments).

docs/manual/functions.qmd

@@ -19,9 +19,13 @@ The following built-in functions are available:
 | EXP(Number) | Euler to the power of *Number*. |
 | EVEN(Number) | Returns *Number* rounded up to the nearest even integer.<br>\linebreak Values are always rounded away from zero (e.g., `EVEN(-3)` = -4). |
 | FAC(Number) | Returns the factorial of *Number*. The factorial of *Number* is equal to 1\*2\*3\*...\* *Number* |
-| FACT(Number) | Alias for `FAC()` |
+| FACT(Number) | Alias for `FAC()`. |
 | FLOOR(Number) | Returns the largest integer not greater than *Number*.<br>\linebreak `FLOOR(-3.2)` = -4<br>\linebreak `FLOOR(3.2)` = 3 |
+| ISERR(Expression) | Returns true if *Expression* evaluates to NaN. |
+| ISERROR(Expression) | Alias for `ISERR()`. |
 | ISEVEN(Number) | Returns true if *Number* is even, false if odd. |
+| ISNA(Expression) | Alias for `ISERR()`. |
+| ISNAN(Expression) | Alias for `ISERR()`. |
 | ISODD(Number) | Returns true if *Number* is odd, false if even. |
 | LN(Number) | Natural logarithm of *Number* (base Euler). |
 | LOG10(Number) | Common logarithm of *Number* (base 10). |
@@ -50,6 +54,12 @@ The following built-in functions are available:
 Table: Math Functions\index{functions!math}
 :::
 
+::: {.warningsection data-latex=""}
+`ISNA()` differs from some spreadsheet programs for certain expressions, such as divisions by zero.
+*TinyExpr++* will return true for this situation, while *Excel* will return false.
+This is because *Excel* distinguishes between `#DIV/0!` and `#N/A` errors, while *TinyExpr++* treats all invalid numbers (e.g., NaN, INF, -INF) as NaN.
+:::
+
 {{< pagebreak >}}
 
 | Function | Description |

tests/tetests.cpp

@@ -1139,12 +1139,26 @@ TEST_CASE("NaN", "[nan]")
     CHECK(std::isnan(tep.evaluate("npr(-2, 4)")));
     CHECK(std::isnan(tep.evaluate("npr(2, -4)")));
 
-    CHECK(tep.evaluate("NAN()"));
+    CHECK(std::isnan(tep.evaluate("NAN()")));
+    CHECK(tep.success());
+    CHECK(std::isnan(tep.evaluate("NAN")));
     CHECK(tep.success());
-    CHECK(tep.evaluate("NAN"));
+    CHECK(std::isnan(tep.evaluate("NA")));
     CHECK(tep.success());
-    CHECK(tep.evaluate("npr(NAN,90)"));
+    CHECK(std::isnan(tep.evaluate("npr(NAN,90)")));
     CHECK(tep.success());
+
+    CHECK(tep.evaluate("ISNAN(NA)"));
+    CHECK(tep.evaluate("ISNAN(5/0)"));
+    CHECK(tep.evaluate("ISNA(5/0)"));
+    CHECK(tep.evaluate("ISNA(npr(2, -4))"));
+    CHECK_FALSE(tep.evaluate("ISNA(2 + 2)"));
+
+    CHECK(tep.evaluate("ISERROR(NA)"));
+    CHECK(tep.evaluate("ISERR(5/0)"));
+    CHECK(tep.evaluate("ISERROR(5/0)"));
+    CHECK(tep.evaluate("ISERR(npr(2, -4))"));
+    CHECK_FALSE(tep.evaluate("ISERROR(2 + 2)"));
     }
 
 TEST_CASE("Even", "[even]")

tinyexpr.cpp

@@ -76,6 +76,12 @@ namespace te_builtins
         return te_parser::get_max_integer();
         }
 
+    [[nodiscard]]
+    static te_type te_is_nan(te_type val)
+        {
+        return (!std::isfinite(val) ? 1 : 0);
+        }
+
     [[nodiscard]]
     static te_type te_even(te_type val)
         {
@@ -1465,7 +1471,11 @@ const std::set<te_variable> te_parser::m_functions = { // NOLINT
     { "fact", static_cast<te_fun1>(te_builtins::te_fac), TE_PURE },
     { "false", static_cast<te_fun0>(te_builtins::te_false_value), TE_PURE },
     { "floor", static_cast<te_fun1>(te_builtins::te_floor), TE_PURE },
+    { "iserr", static_cast<te_fun1>(te_builtins::te_is_nan), TE_PURE },
+    { "iserror", static_cast<te_fun1>(te_builtins::te_is_nan), TE_PURE },
     { "iseven", static_cast<te_fun1>(te_builtins::te_is_even), TE_PURE },
+    { "isna", static_cast<te_fun1>(te_builtins::te_is_nan), TE_PURE },
+    { "isnan", static_cast<te_fun1>(te_builtins::te_is_nan), TE_PURE },
     { "isodd", static_cast<te_fun1>(te_builtins::te_is_odd), TE_PURE },
     { "if", static_cast<te_fun3>(te_builtins::te_if), TE_PURE },
     { "ifs", static_cast<te_fun24>(te_builtins::te_ifs),