copilot-c99: Fix issue in C99 implementation of signum. Refs #278.

copilot-c99's translation of the function signum to C99 differs from the
meaning of the same function in the interpreter. The C99 backend uses
the function copysign, whose meaning differs from Haskell's signum.

For example, as evaluated by the interpreter, signum 0 returns 0, but
the C99 code generated for it (which executes copysign(1.0, 0)), returns
1. Moreover, when dealing with floating-point numbers, signum (-0) and
signum NaN return -0 and NaN, respectively, in the interpreter, but the
C99-based implementation returns -1.0 and ±1.0 (depending on the sign
bit of the NaN), respectively.

The meaning of all Copilot constructs should be consistent between the
interpreter and all backends.

This commit replaces the `copysign`-based implementation such that
`signum e` now returns `e > 0 ? 1 : (e < 0 ? -1 : e)`. This new
implementation follows the definition of signum in Haskell's base,
including for cases where `e` is `±0` or `NaN`.

It is possible to reproduce the error, and check the fix, by comparing
the output of the compiled code and the interpreter for a stream with
signum. For example, given the following specification:

```
{-# LANGUAGE CPP               #-}
{-# LANGUAGE NoImplicitPrelude #-}

-- | An example of a specification using the 'signum' function.
module Main where

import Data.List (genericLength)

import Copilot.Compile.C99
import Language.Copilot

nums :: [Int32]
nums = [-2, -1, 0, 1, 2]

stream :: Stream Int32
stream = extern "stream" (Just nums)

spec :: Spec
spec =
  trigger "func" true [arg (signum stream)]

main :: IO ()
main = do
  spec' <- reify spec
#ifdef INTERPRET
  csv (genericLength nums) spec
#else
  compile "signum" spec'
#endif
```

with -DINTERPRET, the program will print:

```
$ cabal v1-exec -- runhaskell -DINTERPRET Signum.hs
Note: CSV format does not output observers.
#
func,-1
#
func,-1
#
func,0
#
func,1
#
func,1
```

The generated C99 can be executed with the following main:

```
#include <stdint.h>
#include <stdio.h>
#include "signum.h"

int32_t nums[5] = { -2, -1, 0, 1, 2 };

int32_t stream;

void func (int32_t sign)
{
  printf ("%d\n", sign);
}

int main () {
  int i = 0;
  for (i=0; i<5; i++)
  {
     stream = nums[i];
     step();
  }
  return 0;
}
```

And it will print:
```
-1
-1
1
1
1
```

so long as the bug is present. The new implementation corrects that
behavior to print, instead, the same values produced by the interpreter.

Co-authored-by: Ivan Perez <ivan.perezdominguez@nasa.gov>

Author: RyanGlScott

copilot-c99/src/Copilot/Compile/C99/Translate.hs

@@ -55,7 +55,7 @@ transop1 :: Op1 a b -> C.Expr -> C.Expr
 transop1 op e = case op of
   Not             -> (C..!) e
   Abs      _      -> funcall "abs"      [e]
-  Sign     _      -> funcall "copysign" [C.LitDouble 1.0, e]
+  Sign     ty     -> transSign ty e
   Recip    _      -> C.LitDouble 1.0 C../ e
   Exp      _      -> funcall "exp"   [e]
   Sqrt     _      -> funcall "sqrt"  [e]
@@ -112,6 +112,58 @@ transop3 :: Op3 a b c d -> C.Expr -> C.Expr -> C.Expr -> C.Expr
 transop3 op e1 e2 e3 = case op of
   Mux _ -> C.Cond e1 e2 e3
 
+-- | Translate @'Sign' e@ in Copilot Core into a C99 expression.
+--
+-- Sign is is translated as @e > 0 ? 1 : (e < 0 ? -1 : e)@, that is:
+--
+-- 1. If @e@ is positive, return @1@.
+--
+-- 2. If @e@ is negative, return @-1@.
+--
+-- 3. Otherwise, return @e@. This handles the case where @e@ is @0@ when the
+--    type is an integral type. If the type is a floating-point type, it also
+--    handles the cases where @e@ is @-0@ or @NaN@.
+--
+-- This implementation is modeled after how GHC implements 'signum'
+-- <https://gitlab.haskell.org/ghc/ghc/-/blob/aed98ddaf72cc38fb570d8415cac5de9d8888818/libraries/base/GHC/Float.hs#L523-L525 here>.
+transSign :: Type a -> C.Expr -> C.Expr
+transSign ty e = positiveCase $ negativeCase e
+  where
+    -- If @e@ is positive, return @1@, otherwise fall back to argument.
+    --
+    -- Produces the following code, where @<arg>@ is the argument to this
+    -- function:
+    -- @
+    -- e > 0 ? 1 : <arg>
+    -- @
+    positiveCase :: C.Expr  -- ^ Value returned if @e@ is not positive.
+                 -> C.Expr
+    positiveCase =
+      C.Cond (C.BinaryOp C.GT e (constNumTy ty 0)) (constNumTy ty 1)
+
+    -- If @e@ is negative, return @1@, otherwise fall back to argument.
+    --
+    -- Produces the following code, where @<arg>@ is the argument to this
+    -- function:
+    -- @
+    -- e < 0 ? -1 : <arg>
+    -- @
+    negativeCase :: C.Expr  -- ^ Value returned if @e@ is not negative.
+                 -> C.Expr
+    negativeCase =
+      C.Cond (C.BinaryOp C.LT e (constNumTy ty 0)) (constNumTy ty (-1))
+
+    -- Translate a literal number of type @ty@ into a C99 literal.
+    --
+    -- PRE: The type of PRE is numeric (integer or floating-point), that
+    -- is, not boolean, struct or array.
+    constNumTy :: Type a -> Integer -> C.Expr
+    constNumTy ty =
+      case ty of
+        Float  -> C.LitFloat . fromInteger
+        Double -> C.LitDouble . fromInteger
+        _      -> C.LitInt
+
 -- | Transform a Copilot Core literal, based on its value and type, into a C99
 -- literal.
 constty :: Type a -> a -> C.Expr