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