Sync std math with base

The std copy of math still used the older RealFuns witness wrapper while
base had moved to direct float functions. That left std.math out of step
with the unboxed math ABI used on this branch.

Copy the simplified math.act shape from base and keep only the std module
symbol prefix in math.ext.c. The exported C functions now use raw double
arguments and results like the base module.

Author: Kristian Larsson

std/src/std/math.act

@@ -11,70 +11,36 @@
 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #
 
-pi = 3.141592653589793
+pi: float = 3.141592653589793
 
-protocol RealFuns:
-    @staticmethod
-    sqrt       : (Self) -> Self
-    @staticmethod
-    exp        : (Self) -> Self
-    @staticmethod
-    log        : (Self) -> Self
-    @staticmethod
-    sin        : (Self) -> Self
-    @staticmethod
-    cos        : (Self) -> Self
-    @staticmethod
-    tan        : (Self) -> Self
-    @staticmethod
-    asin       : (Self) -> Self
-    @staticmethod
-    acos       : (Self) -> Self
-    @staticmethod
-    atan       : (Self) -> Self
-    @staticmethod
-    sinh       : (Self) -> Self
-    @staticmethod
-    cosh       : (Self) -> Self
-    @staticmethod
-    tanh       : (Self) -> Self
-    @staticmethod
-    asinh       : (Self) -> Self
-    @staticmethod
-    acosh       : (Self) -> Self
-    @staticmethod
-    atanh       : (Self) -> Self
 
-extension float (RealFuns):
-    NotImplemented
-
-def sqrt(x: float):
-   return RealFuns.sqrt(x)
-def exp(x: float):
-   return RealFuns.exp(x)
-def log(x: float):
-   return RealFuns.log(x)
-def sin(x: float):
-   return RealFuns.sin(x)
-def cos(x: float):
-   return RealFuns.cos(x)
-def tan(x: float):
-   return RealFuns.tan(x)
-def asin(x: float):
-   return RealFuns.asin(x)
-def acos(x: float):
-   return RealFuns.acos(x)
-def atan(x: float):
-   return RealFuns.atan(x)
-def sinh(x: float):
-   return RealFuns.sinh(x)
-def cosh(x: float):
-   return RealFuns.cosh(x)
-def tanh(x: float):
-   return RealFuns.tanh(x)
-def asinh(x: float):
-   return RealFuns.asinh(x)
-def acosh(x: float):
-   return RealFuns.acosh(x)
-def atanh(x: float):
-   return RealFuns.atanh(x)
+def sqrt(x: float)->float:
+   NotImplemented
+def exp(x: float)->float:
+   NotImplemented
+def log(x: float)->float:
+   NotImplemented
+def sin(x: float)->float:
+   NotImplemented
+def cos(x: float)->float:
+   NotImplemented
+def tan(x: float)->float:
+   NotImplemented
+def asin(x: float)->float:
+   NotImplemented
+def acos(x: float)->float:
+   NotImplemented
+def atan(x: float)->float:
+   NotImplemented
+def sinh(x: float)->float:
+   NotImplemented
+def cosh(x: float)->float:
+   NotImplemented
+def tanh(x: float)->float:
+   NotImplemented
+def asinh(x: float)->float:
+   NotImplemented
+def acosh(x: float)->float:
+   NotImplemented
+def atanh(x: float)->float:
+   NotImplemented

std/src/std/math.ext.c

@@ -1,47 +1,47 @@
-B_float stdQ_mathQ_RealFunsD_floatD_sqrt(stdQ_mathQ_RealFunsD_float wit, B_float x) {
-  return to$float(sqrt(x->val));
+double stdQ_mathQ_sqrt(double x) {
+  return sqrt(x);
 }
-B_float stdQ_mathQ_RealFunsD_floatD_exp(stdQ_mathQ_RealFunsD_float wit, B_float x) {
-  return to$float(exp(x->val));
+double stdQ_mathQ_exp(double x) {
+  return exp(x);
 }
-B_float stdQ_mathQ_RealFunsD_floatD_log(stdQ_mathQ_RealFunsD_float wit, B_float x) {
-  return to$float(log(x->val));
+double stdQ_mathQ_log(double x) {
+  return log(x);
 }
-B_float stdQ_mathQ_RealFunsD_floatD_sin(stdQ_mathQ_RealFunsD_float wit, B_float x) {
-  return to$float(sin(x->val));
+double stdQ_mathQ_sin(double x) {
+  return sin(x);
 }
-B_float stdQ_mathQ_RealFunsD_floatD_cos(stdQ_mathQ_RealFunsD_float wit, B_float x) {
-  return to$float(cos(x->val));
+double stdQ_mathQ_cos(double x) {
+  return cos(x);
 }
-B_float stdQ_mathQ_RealFunsD_floatD_tan(stdQ_mathQ_RealFunsD_float wit, B_float x) {
-  return to$float(tan(x->val));
+double stdQ_mathQ_tan(double x) {
+  return tan(x);
 }
-B_float stdQ_mathQ_RealFunsD_floatD_asin(stdQ_mathQ_RealFunsD_float wit, B_float x) {
-  return to$float(asin(x->val));
+double stdQ_mathQ_asin(double x) {
+  return asin(x);
 }
-B_float stdQ_mathQ_RealFunsD_floatD_acos(stdQ_mathQ_RealFunsD_float wit, B_float x) {
-  return to$float(acos(x->val));
+double stdQ_mathQ_acos(double x) {
+  return acos(x);
 }
-B_float stdQ_mathQ_RealFunsD_floatD_atan(stdQ_mathQ_RealFunsD_float wit, B_float x) {
-  return to$float(atan(x->val));
+double stdQ_mathQ_atan(double x) {
+  return atan(x);
 }
-B_float stdQ_mathQ_RealFunsD_floatD_sinh(stdQ_mathQ_RealFunsD_float wit, B_float x) {
-  return to$float(sinh(x->val));
+double stdQ_mathQ_sinh(double x) {
+  return sinh(x);
 }
-B_float stdQ_mathQ_RealFunsD_floatD_cosh(stdQ_mathQ_RealFunsD_float wit, B_float x) {
-  return to$float(cosh(x->val));
+double stdQ_mathQ_cosh(double x) {
+  return cosh(x);
 }
-B_float stdQ_mathQ_RealFunsD_floatD_tanh(stdQ_mathQ_RealFunsD_float wit, B_float x) {
-  return to$float(tanh(x->val));
+double stdQ_mathQ_tanh(double x) {
+  return tanh(x);
 }
-B_float stdQ_mathQ_RealFunsD_floatD_asinh(stdQ_mathQ_RealFunsD_float wit, B_float x) {
-  return to$float(asinh(x->val));
+double stdQ_mathQ_asinh(double x) {
+  return asinh(x);
 }
-B_float stdQ_mathQ_RealFunsD_floatD_acosh(stdQ_mathQ_RealFunsD_float wit, B_float x) {
-  return to$float(acosh(x->val));
+double stdQ_mathQ_acosh(double x) {
+  return acosh(x);
 }
-B_float stdQ_mathQ_RealFunsD_floatD_atanh(stdQ_mathQ_RealFunsD_float wit, B_float x) {
-  return to$float(atanh(x->val));
+double stdQ_mathQ_atanh(double x) {
+  return atanh(x);
 }
 
 void stdQ_mathQ___ext_init__() {