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_pow(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 pow()");
  74     a.num = pow(a.num, b.num);
  75     return VALIDATE(a);
  76 }
  77
  78 static naRef f_atan2(naContext c, naRef me, int argc, naRef* args)
  79 {
  80     naRef a = naNumValue(argc > 0 ? args[0] : naNil());
  81     naRef b = naNumValue(argc > 1 ? args[1] : naNil());
  82     if(naIsNil(a) || naIsNil(b))
  83         naRuntimeError(c, "non numeric argument to atan2()");
  84     a.num = atan2(a.num, b.num);
  85     return VALIDATE(a);
  86 }
  87
  88 static naRef f_floor(naContext c, naRef me, int argc, naRef* args)
  89 {
  90     naRef a = naNumValue(argc > 0 ? args[0] : naNil());
  91     if(naIsNil(a))
  92         naRuntimeError(c, "non numeric argument to floor()");
  93     a.num = floor(a.num);
  94     return VALIDATE(a);
  95 }
  96
  97 static naRef f_ceil(naContext c, naRef me, int argc, naRef* args)
  98 {
  99     naRef a = naNumValue(argc > 0 ? args[0] : naNil());
 100     if(naIsNil(a))
 101         naRuntimeError(c, "non numeric argument to ceil()");
 102     a.num = ceil(a.num);
 103     return VALIDATE(a);
 104 }
 105
 106 static naRef f_fmod(naContext c, naRef me, int argc, naRef* args)
 107 {
 108     naRef a = naNumValue(argc > 0 ? args[0] : naNil());
 109     naRef b = naNumValue(argc > 1 ? args[1] : naNil());
 110     if(naIsNil(a) || naIsNil(b))
 111         naRuntimeError(c, "non numeric arguments to fmod()");
 112
 113     a.num = fmod(a.num, b.num);
 114     return VALIDATE(a);
 115 }
 116
 117 static naRef f_clamp(naContext c, naRef me, int argc, naRef* args)
 118 {
 119     naRef a = naNumValue(argc > 0 ? args[0] : naNil());
 120     naRef b = naNumValue(argc > 1 ? args[1] : naNil());
 121     naRef x = naNumValue(argc > 2 ? args[2] : naNil());
 122
 123     if(naIsNil(a) || naIsNil(b) || naIsNil(x))
 124         naRuntimeError(c, "non numeric arguments to clamp()");
 125
 126     if (a.num < b.num) b.num = a.num;
 127     if (b.num > x.num) b.num = x.num;
 128     return VALIDATE(b);
 129 }
 130
 131 static naRef f_periodic(naContext c, naRef me, int argc, naRef* args)
 132 {
 133     double range;
 134     naRef a = naNumValue(argc > 0 ? args[0] : naNil());
 135     naRef b = naNumValue(argc > 1 ? args[1] : naNil());
 136     naRef x = naNumValue(argc > 2 ? args[2] : naNil());
 137
 138     if(naIsNil(a) || naIsNil(b) || naIsNil(x))
 139         naRuntimeError(c, "non numeric arguments to periodic()");
 140
 141     range = b.num - a.num;
 142     x.num = x.num - range*floor((x.num - a.num)/range);
 143     // two security checks that can only happen due to roundoff
 144     if (x.num <= a.num)
 145         x.num = a.num;
 146     if (b.num <= x.num)
 147         x.num = b.num;
 148     return VALIDATE(x);
 149
 150 //    x.num = SGMiscd::normalizePeriodic(a, b, x);
 151     return VALIDATE(x);
 152 }
 153
 154 static naRef f_round(naContext c, naRef me, int argc, naRef* args)
 155 {
 156     naRef a = naNumValue(argc > 0 ? args[0] : naNil());
 157     naRef b = naNumValue(argc > 1 ? args[1] : naNil());
 158     if(naIsNil(a))
 159         naRuntimeError(c, "non numeric arguments to round()");
 160     if (naIsNil(b))
 161         b.num = 1.0;
 162
 163 #ifdef _MSC_VER // MSVC is not C99-compatible, no round() in math.h
 164     double y = a.num / b.num;
 165     double x = floor(y + 0.5);
 166 #else
 167     double x = round(a.num / b.num);
 168 #endif
 169     a.num = x * b.num;
 170
 171     return VALIDATE(a);
 172 }
 173
 174
 175 static naRef f_tan(naContext c, naRef me, int argc, naRef* args)
 176 {
 177     naRef a = naNumValue(argc > 0 ? args[0] : naNil());
 178     if(naIsNil(a))
 179         naRuntimeError(c, "non numeric arguments to tan()");
 180
 181    a.num = tan(a.num);
 182    return VALIDATE(a);
 183 }
 184
 185 static naRef f_asin(naContext c, naRef me, int argc, naRef* args)
 186 {
 187     naRef a = naNumValue(argc > 0 ? args[0] : naNil());
 188     if(naIsNil(a))
 189         naRuntimeError(c, "non numeric argument to asin()");
 190     a.num = asin(a.num);
 191     return VALIDATE(a);
 192 }
 193
 194 static naRef f_acos(naContext c, naRef me, int argc, naRef* args)
 195 {
 196     naRef a = naNumValue(argc > 0 ? args[0] : naNil());
 197     if(naIsNil(a))
 198         naRuntimeError(c, "non numeric argument to acos()");
 199     a.num = acos(a.num);
 200     return VALIDATE(a);
 201 }
 202
 203 static naCFuncItem funcs[] = {
 204     { "sin", f_sin },
 205     { "cos", f_cos },
 206     { "exp", f_exp },
 207     { "ln", f_ln },
 208     { "pow", f_pow },
 209     { "sqrt", f_sqrt },
 210     { "atan2", f_atan2 },
 211     { "floor", f_floor },
 212     { "ceil", f_ceil },
 213     { "fmod", f_fmod },
 214     { "clamp", f_clamp },
 215     { "periodic", f_periodic },
 216     { "round", f_round },
 217     { "tan", f_tan },
 218     { "acos", f_acos },
 219     { "asin", f_asin },
 220     { 0 }
 221 };
 222
 223
 224
 225 naRef naInit_math(naContext c)
 226 {
 227     naRef ns = naGenLib(c, funcs);
 228     naAddSym(c, ns, "pi", naNum(3.14159265358979323846));
 229     naAddSym(c, ns, "e", naNum(2.7182818284590452354));
 230     return ns;
 231 }