Add INFINITY and NAN constants to stdlib/math.jou (#1267)

Author: Akuli

doc/json-building.md

@@ -107,13 +107,14 @@ For example:
 import "stdlib/json.jou"
 import "stdlib/io.jou"
 import "stdlib/mem.jou"
+import "stdlib/math.jou"  # defines INFINITY and NAN
 
 def main() -> int:
     jb = JSONBuilder{}
     jb.begin_array()
-    jb.number(1.0 / 0.0)
-    jb.number(-1.0 / 0.0)
-    jb.number(0.0 / 0.0)
+    jb.number(INFINITY)
+    jb.number(-INFINITY)
+    jb.number(NAN)
     jb.end_array()
 
     json = jb.finish()

doc/types.md

@@ -177,15 +177,15 @@ For example:
 
 ```python
 import "stdlib/io.jou"
+import "stdlib/math.jou"
 
 def main() -> int:
     printf("%d\n", 1234.5 as byte)  # Output: 255
     printf("%d\n", 24.68 as int)    # Output: 24
     printf("%d\n", -24.68 as int)   # Output: -24
 
-    # Infinity and NaN
-    printf("%d\n", (1.0 / 0.0) as int)   # Output: 2147483647
-    printf("%d\n", (0.0 / 0.0) as int)   # Output: 0
+    printf("%d\n", INFINITY as int)   # Output: 2147483647
+    printf("%d\n", NAN as int)        # Output: 0
 
     return 0
 ```

stdlib/json.jou

@@ -495,19 +495,19 @@ def skip_number(s: byte*) -> byte*:
 @public
 def json_to_double(s: byte*) -> double:
     if s == NULL:
-        return 0.0 / 0.0
+        return NAN
 
     while is_json_whitespace(*s):
         s++
     if skip_number(s) == NULL:
-        return 0.0 / 0.0
+        return NAN
 
     if starts_with(s, "Infinity"):
-        return 1.0 / 0.0
+        return INFINITY
     if starts_with(s, "-Infinity"):
-        return -1.0 / 0.0
+        return -INFINITY
     if starts_with(s, "NaN"):
-        return 0.0 / 0.0
+        return NAN
 
     return atof(s)
 

stdlib/math.jou

@@ -64,14 +64,13 @@ declare fmaxf(a: float, b: float) -> float
 #   - infinite (plus infinity or minus infinity)
 #   - NaN (Not a Number, basically indicates that something went wrong)
 #
-# To create infinite values, you can use e.g. 1.0/0.0 or -1.0/0.0. To create a
-# NaN, you can use 0.0/0.0.
-#
-# The following functions check which kind of number you are dealing with. They
-# work with both floats and doubles. Please create an issue on GitHub if you
-# need float-only versions of these functions for some reason.
+# Like M_PI and M_E, these are doubles. Use "as float" as needed.
+@public
+const INFINITY: double = 1.0 / 0.0
+@public
+const NAN: double = 0.0 / 0.0
 
-# Returns True if x a plain old finite value.
+# Returns True if x is a finite value, not infinity or minus infinity or NaN.
 @public
 @inline
 def isfinite(x: double) -> bool:

tests/should_succeed/json_test_builder.jou

@@ -195,9 +195,9 @@ def test_numbers() -> None:
     jb.number(pow(2, -20))
     # Technically Infinity and NaN are not valid JSON, but many libraries
     # support them to some extent so we support them too.
-    jb.number(1.0 / 0.0)    # Infinity
-    jb.number(-1.0 / 0.0)   # -Infinity
-    jb.number(0.0 / 0.0)    # NaN
+    jb.number(INFINITY)
+    jb.number(-INFINITY)
+    jb.number(NAN)
     jb.end_array()
 
     json = jb.finish()
@@ -305,7 +305,7 @@ def test_complex_example() -> None:
     jb.key("alternative null")
     jb.string(NULL)
     jb.key("big numba")
-    jb.number(1.0 / 0.0)
+    jb.number(INFINITY)
     jb.end_object()
     jb.end_array()
 

tests/should_succeed/json_test_parsing.jou

@@ -362,9 +362,9 @@ def test_numbers() -> None:
     assert not json_is_valid("5k")
     assert json_to_double("5k") == 5
     assert not json_is_valid("Infinityyyy")
-    assert json_to_double("Infinityyyy") == 1.0 / 0.0
+    assert json_to_double("Infinityyyy") == INFINITY
     assert not json_is_valid("-Infinityyyy")
-    assert json_to_double("-Infinityyyy") == -1.0 / 0.0
+    assert json_to_double("-Infinityyyy") == -INFINITY
 
 
 def test_json_from_github_api() -> None:

tests/should_succeed/math_test.jou

@@ -1,17 +1,6 @@
 import "stdlib/math.jou"
 import "stdlib/io.jou"
 
-# TODO: move these to stdlib/math.jou
-#
-# Here are some more readable ways to construct non-finite values. Note that
-# there are multiple different NaN values (see also: nan boxing), and the NaN
-# constructed here is just one of them.
-#
-# Like M_PI and M_E, these are doubles. Use "as float" as needed.
-@public
-const INFINITY: double = 1.0 / 0.0
-@public
-const NAN: double = 0.0 / 0.0
 
 def main() -> int:
     printf("%f\n", M_PI)  # Output: 3.141593