simgear/nasal/mathlib.c

   1 #include <math.h>
   2 #include <string.h>
   3
   4 #include "nasal.h"
   5
   6 // Toss a runtime error for any NaN or Inf values produced.  Note that
   7 // this assumes an IEEE 754 format.
   8 #define VALIDATE(r) (valid(r.num) ? (r) : die(c, __FUNCTION__+2))
   9
  10 static int valid(double d)
  11 {
  12     union { double d; unsigned long long ull; } u;
  13     u.d = d;
  14     return ((u.ull >> 52) & 0x7ff) != 0x7ff;
  15 }
  16
  17 static naRef die(naContext c, const char* fn)
  18 {
  19     naRuntimeError(c, "floating point error in math.%s()", fn);
  20     return naNil();
  21 }
  22
  23 static naRef f_sin(naContext c, naRef me, int argc, naRef* args)
  24 {
  25     naRef a = naNumValue(argc > 0 ? args[0] : naNil());
  26     if(naIsNil(a))
  27         naRuntimeError(c, "non numeric argument to sin()");
  28     a.num = sin(a.num);
  29     return VALIDATE(a);
  30 }
  31
  32 static naRef f_cos(naContext c, naRef me, int argc, naRef* args)
  33 {
  34     naRef a = naNumValue(argc > 0 ? args[0] : naNil());
  35     if(naIsNil(a))
  36         naRuntimeError(c, "non numeric argument to cos()");
  37     a.num = cos(a.num);
  38     return VALIDATE(a);
  39 }
  40
  41 static naRef f_exp(naContext c, naRef me, int argc, naRef* args)
  42 {
  43     naRef a = naNumValue(argc > 0 ? args[0] : naNil());
  44     if(naIsNil(a))
  45         naRuntimeError(c, "non numeric argument to exp()");
  46     a.num = exp(a.num);
  47     return VALIDATE(a);
  48 }
  49
  50 static naRef f_ln(naContext c, naRef me, int argc, naRef* args)
  51 {
  52     naRef a = naNumValue(argc > 0 ? args[0] : naNil());
  53     if(naIsNil(a))
  54         naRuntimeError(c, "non numeric argument to ln()");
  55     a.num = log(a.num);
  56     return VALIDATE(a);
  57 }
  58
  59 static naRef f_sqrt(naContext c, naRef me, int argc, naRef* args)
  60 {
  61     naRef a = naNumValue(argc > 0 ? args[0] : naNil());
  62     if(naIsNil(a))
  63         naRuntimeError(c, "non numeric argument to sqrt()");
  64     a.num = sqrt(a.num);
  65     return VALIDATE(a);
  66 }
  67
  68 static naRef f_atan2(naContext c, naRef me, int argc, naRef* args)
  69 {
  70     naRef a = naNumValue(argc > 0 ? args[0] : naNil());
  71     naRef b = naNumValue(argc > 1 ? args[1] : naNil());
  72     if(naIsNil(a) || naIsNil(b))
  73         naRuntimeError(c, "non numeric argument to atan2()");
  74     a.num = atan2(a.num, b.num);
  75     return VALIDATE(a);
  76 }
  77
  78 static naRef f_floor(naContext c, naRef me, int argc, naRef* args)
  79 {
  80     naRef a = naNumValue(argc > 0 ? args[0] : naNil());
  81     if(naIsNil(a))
  82         naRuntimeError(c, "non numeric argument to floor()");
  83     a.num = floor(a.num);
  84     return VALIDATE(a);
  85 }
  86
  87 static naRef f_ceil(naContext c, naRef me, int argc, naRef* args)
  88 {
  89     naRef a = naNumValue(argc > 0 ? args[0] : naNil());
  90     if(naIsNil(a))
  91         naRuntimeError(c, "non numeric argument to ceil()");
  92     a.num = ceil(a.num);
  93     return VALIDATE(a);
  94 }
  95
  96 static naRef f_mod(naContext c, naRef me, int argc, naRef* args)
  97 {
  98     naRef a = naNumValue(argc > 0 ? args[0] : naNil());
  99     naRef b = naNumValue(argc > 1 ? args[1] : naNil());
 100     if(naIsNil(a) || naIsNil(b))
 101         naRuntimeError(c, "non numeric arguments to mod()");
 102
 103     a.num = fmod(a.num, b.num);
 104     return VALIDATE(a);
 105 }
 106
 107 static naRef f_clamp(naContext c, naRef me, int argc, naRef* args)
 108 {
 109     naRef a = naNumValue(argc > 0 ? args[0] : naNil());
 110     naRef b = naNumValue(argc > 1 ? args[1] : naNil());
 111     naRef x = naNumValue(argc > 2 ? args[2] : naNil());
 112
 113     if(naIsNil(a) || naIsNil(b) || naIsNil(x))
 114         naRuntimeError(c, "non numeric arguments to clamp()");
 115
 116     if (a.num < b.num) b.num = a.num;
 117     if (b.num > x.num) b.num = x.num;
 118     return VALIDATE(b);
 119 }
 120
 121 static naRef f_periodic(naContext c, naRef me, int argc, naRef* args)
 122 {
 123     double range;
 124     naRef a = naNumValue(argc > 0 ? args[0] : naNil());
 125     naRef b = naNumValue(argc > 1 ? args[1] : naNil());
 126     naRef x = naNumValue(argc > 2 ? args[2] : naNil());
 127
 128     if(naIsNil(a) || naIsNil(b) || naIsNil(x))
 129         naRuntimeError(c, "non numeric arguments to periodic()");
 130
 131     range = b.num - a.num;
 132     x.num = x.num - range*floor((x.num - a.num)/range);
 133     // two security checks that can only happen due to roundoff
 134     if (x.num <= a.num)
 135         x.num = a.num;
 136     if (b.num <= x.num)
 137         x.num = b.num;
 138     return VALIDATE(x);
 139
 140 //    x.num = SGMiscd::normalizePeriodic(a, b, x);
 141     return VALIDATE(x);
 142 }
 143
 144 static naCFuncItem funcs[] = {
 145     { "sin", f_sin },
 146     { "cos", f_cos },
 147     { "exp", f_exp },
 148     { "ln", f_ln },
 149     { "sqrt", f_sqrt },
 150     { "atan2", f_atan2 },
 151     { "floor", f_floor },
 152     { "ceil", f_ceil },
 153     { "mod", f_mod },
 154     { "clamp", f_clamp },
 155     { "periodic", f_periodic },
 156     { 0 }
 157 };
 158
 159
 160
 161 naRef naInit_math(naContext c)
 162 {
 163     naRef ns = naGenLib(c, funcs);
 164     naAddSym(c, ns, "pi", naNum(3.14159265358979323846));
 165     naAddSym(c, ns, "e", naNum(2.7182818284590452354));
 166     return ns;
 167 }