Commit: 4baf5e2d7637d274495705c7d28f69ce1ac5baeb - cammy (git)

A categorical programming language

Commit MetaInfo

• Revisión: 4baf5e2d7637d274495705c7d28f69ce1ac5baeb (tree)
• Tiempo: 2021-11-06 07:13:23
• Autor: Corbin <cds@corb...>
• Commiter: Corbin

Log Message

cammy-run: Better NaN handling in f-add and f-mul.

Cambiar Resumen

• modified: cammy-run/main.py

Diferencia incremental

--- a/cammy-run/main.py
+++ b/cammy-run/main.py
@@ -10,14 +10,10 @@ util.find_library = patched_find_library
 
 import math, sys
 
-from rpython.rlib.jit import JitDriver, set_param, unroll_safe
-from rpython.rlib.parsing.main import make_parser_from_file
-from rpython.rlib.parsing.tree import RPythonVisitor
+from rpython.rlib.jit import JitDriver, set_param, unroll_safe, we_are_jitted
 from rpython.rlib.rbigint import rbigint
-from rpython.rlib.rfile import create_stdio
 from rpython.rlib.rfloat import string_to_float
 from rpython.rlib.rstring import StringBuilder, split
-from rpython.rlib.unroll import unrolling_iterable
 
 import stb
 
@@ -69,7 +65,7 @@ class F(Element):
     _immutable_ = True
 
     def __init__(self, f):
-        if math.isnan(f):
+        if not we_are_jitted() and math.isnan(f):
             raise TypeFail("runtime NaN")
         self._f = f
 
@@ -259,21 +255,23 @@ class FLT(Arrow):
 class FAdd(Arrow):
     _immutable_ = True
     def run(self, x):
-        f = x.first().f() + x.second().f()
-        # The only case handled is Infinity - Infinity, for which we apply:
-        # x - x == 0.0
-        return F(0.0 if math.isnan(f) else f)
+        rv = x.first().f() + x.second().f()
+        # The only time addition can NaN is Infinity - Infinity, which is 0.0.
+        if math.isnan(rv):
+            rv = 0.0
+        return F(rv)
 
 class FMul(Arrow):
     _immutable_ = True
     def run(self, x):
         y = x.first().f()
         z = x.second().f()
-        # Check for division by zero.
-        if y in (0.0, -0.0) or z in (0.0, -0.0):
-            return F(0.0 * math.copysign(1.0, y) * math.copysign(1.0, z))
-        else:
-            return F(y * z)
+        rv = y * z
+        # The only time multiplication can NaN is 0.0 * Infinity. We define it
+        # to be 0.0, but must respect source signs.
+        if math.isnan(rv):
+            rv = 0.0 * math.copysign(1.0, y) * math.copysign(1.0, z)
+        return F(rv)
 
 class FSqrt(Arrow):
     _immutable_ = True
@@ -435,7 +433,8 @@ class Window(object):
         c2 = scale(self._corners[1], self._corners[3], dh + ih * h)
         return c1, c2
 
-driver = JitDriver(greens=["program"], reds=["x", "y"])
+driver = JitDriver(greens=["program"],
+        reds=["x", "y"])
 
 def sample(program, x, y):
     driver.jit_merge_point(program=program, x=x, y=y)