CHDK_DE Vorschauversion  Trunk Rev. 6014
 Alle Datenstrukturen Dateien Funktionen Variablen Typdefinitionen Aufzählungen Aufzählungswerte Makrodefinitionen
Makrodefinitionen | Aufzählungen | Funktionen | Variablen
lfmathlib.c-Dateireferenz
#include "stdlib.h"
#include "math.h"
#include "lua.h"
#include "lauxlib.h"
#include "lualib.h"
+ Include-Abhängigkeitsdiagramm für lfmathlib.c:

gehe zum Quellcode dieser Datei

Makrodefinitionen

#define lfmathlib_c
 
#define LUA_LIB
 
#define fabs(x)   ((((x) < 0.0) ? -(x) : (x)))
 
#define N   17
 
#define M   9
 
#define INV_GAIN_CIRCLE   0.60725293501477
 
#define trunc(x)   ((double)((int)(x)))
 

Aufzählungen

enum  {
  FN_MUL = 0, FN_DIV, FN_ADD, FN_SUB,
  FN_POW, FN_MOD, FN_LOG, FN_LOG2,
  FN_LOG10, FN_SQRT, FN_NEG, FN_DEG,
  FN_RAD, FN_EQ, FN_LT, FN_LE,
  FN_INT, FN_CEIL, FN_FLOOR, FN_ROUND,
  FN_SIN, FN_COS, FN_TAN, FN_ASIN,
  FN_ACOS, FN_ATAN
}
 
enum  { ROTATE = 0, VECTOR }
 

Funktionen

static double arg (lua_State *L, int n)
 
static double * newval (lua_State *L, double v)
 
static int fmath_new (lua_State *L)
 
static int fmath_toStr (lua_State *L)
 
static void cordic (int f, double *x, double *y, double *z)
 
static double fmod (double x, double y)
 
static double cathetus (double x)
 
static void sincosCordic (double phi, double *sinphi, double *cosphi)
 
static void atanhypCordic (double x, double y, double *phi, double *hyp)
 
static int twoargfn (lua_State *L, int fn)
 
static int oneargfn (lua_State *L, int fn)
 
static int boolfn (lua_State *L, int fn)
 
static int intfn (lua_State *L, int fn)
 
static int trigfn (lua_State *L, int fn)
 
static int atrigfn (lua_State *L, int fn)
 
static int fmath_rec (lua_State *L)
 
static int fmath_pol (lua_State *L)
 
static int fmath_mul (lua_State *L)
 
static int fmath_div (lua_State *L)
 
static int fmath_add (lua_State *L)
 
static int fmath_sub (lua_State *L)
 
static int fmath_pow (lua_State *L)
 
static int fmath_mod (lua_State *L)
 
static int fmath_eq (lua_State *L)
 
static int fmath_lt (lua_State *L)
 
static int fmath_le (lua_State *L)
 
static int fmath_neg (lua_State *L)
 
static int fmath_log (lua_State *L)
 
static int fmath_log2 (lua_State *L)
 
static int fmath_log10 (lua_State *L)
 
static int fmath_sqrt (lua_State *L)
 
static int fmath_deg (lua_State *L)
 
static int fmath_rad (lua_State *L)
 
static int fmath_int (lua_State *L)
 
static int fmath_ceil (lua_State *L)
 
static int fmath_floor (lua_State *L)
 
static int fmath_round (lua_State *L)
 
static int fmath_sin (lua_State *L)
 
static int fmath_cos (lua_State *L)
 
static int fmath_tan (lua_State *L)
 
static int fmath_asin (lua_State *L)
 
static int fmath_acos (lua_State *L)
 
static int fmath_atan (lua_State *L)
 
LUALIB_API int luaopen_fmath (lua_State *L)
 

Variablen

static double atan_tab [M]
 
static const luaL_Reg fmathlib_m []
 

Makro-Dokumentation

#define fabs (   x)    ((((x) < 0.0) ? -(x) : (x)))

Definiert in Zeile 69 der Datei lfmathlib.c.

#define INV_GAIN_CIRCLE   0.60725293501477

Definiert in Zeile 178 der Datei lfmathlib.c.

#define lfmathlib_c

Definiert in Zeile 61 der Datei lfmathlib.c.

#define LUA_LIB

Definiert in Zeile 62 der Datei lfmathlib.c.

#define M   9

Definiert in Zeile 171 der Datei lfmathlib.c.

#define N   17

Definiert in Zeile 170 der Datei lfmathlib.c.

#define trunc (   x)    ((double)((int)(x)))

Definiert in Zeile 201 der Datei lfmathlib.c.

Dokumentation der Aufzählungstypen

anonymous enum
Aufzählungswerte
FN_MUL 
FN_DIV 
FN_ADD 
FN_SUB 
FN_POW 
FN_MOD 
FN_LOG 
FN_LOG2 
FN_LOG10 
FN_SQRT 
FN_NEG 
FN_DEG 
FN_RAD 
FN_EQ 
FN_LT 
FN_LE 
FN_INT 
FN_CEIL 
FN_FLOOR 
FN_ROUND 
FN_SIN 
FN_COS 
FN_TAN 
FN_ASIN 
FN_ACOS 
FN_ATAN 

Definiert in Zeile 131 der Datei lfmathlib.c.

131  {
132  FN_MUL = 0,
133  FN_DIV,
134  FN_ADD,
135  FN_SUB,
136  FN_POW,
137  FN_MOD,
138  FN_LOG,
139  FN_LOG2,
140  FN_LOG10,
141  FN_SQRT,
142  FN_NEG,
143  FN_DEG,
144  FN_RAD,
145  FN_EQ,
146  FN_LT,
147  FN_LE,
148  FN_INT,
149  FN_CEIL,
150  FN_FLOOR,
151  FN_ROUND,
152  FN_SIN,
153  FN_COS,
154  FN_TAN,
155  FN_ASIN,
156  FN_ACOS,
157  FN_ATAN,
158 };
anonymous enum
Aufzählungswerte
ROTATE 
VECTOR 

Definiert in Zeile 160 der Datei lfmathlib.c.

160  {
161  ROTATE = 0,
162  VECTOR
163 };

Dokumentation der Funktionen

static double arg ( lua_State *  L,
int  n 
)
static

Definiert in Zeile 72 der Datei lfmathlib.c.

72  {
73  double* v = (double*)lua_touserdata(L, n);
74  if (v == 0) {
75  int i = luaL_checknumber(L, n);
76  return (double)i;
77  }
78  return *v;
79 }
static void atanhypCordic ( double  x,
double  y,
double *  phi,
double *  hyp 
)
static

Definiert in Zeile 234 der Datei lfmathlib.c.

234  {
235  if (x == 0 && y == 0) {
236  // error input vales
237  *phi = 0;
238  *hyp = 0;
239  return;
240  }
241 
242  // convert to quadrant 1
243  int fy = (y >= 0);
244  int q = 1;
245  if (x < 0) {
246  if (fy)
247  q = 2;
248  else
249  q = 3;
250  } else if (!fy) {
251  q = 4;
252  }
253  x = fabs(x);
254  y = fabs(y);
255 
256  double z = 0;
257  cordic(VECTOR, &x, &y, &z);
258 
259  // convert to original quadrant
260  switch(q) {
261  case 2: z = M_PI - z; break;
262  case 3: z = z - M_PI; break;
263  case 4: z = -z; break;
264  }
265 
266  *phi = z;
267  *hyp = x;
268 }
static int atrigfn ( lua_State *  L,
int  fn 
)
static

Definiert in Zeile 416 der Datei lfmathlib.c.

416  {
417  double x = arg(L, 1);
418  double y = 0;
419  switch(fn) {
420  case FN_ASIN:
421  y = x;
422  x = cathetus(x);
423  break;
424  case FN_ACOS:
425  y = cathetus(x);
426  break;
427  case FN_ATAN:
428  y = x;
429  x = 1.0;
430  break;
431  default:
432  break;
433  }
434  double phi, hyp;
435  atanhypCordic(x, y, &phi, &hyp);
436  newval(L, phi);
437  return 1;
438 }
static int boolfn ( lua_State *  L,
int  fn 
)
static

Definiert in Zeile 340 der Datei lfmathlib.c.

340  {
341  double a = arg(L, 1);
342  double b = arg(L, 2);
343  int r = 0;
344  switch(fn) {
345  case FN_EQ:
346  r = (a == b);
347  break;
348  case FN_LT:
349  r = (a < b);
350  break;
351  case FN_LE:
352  r = (a <= b);
353  break;
354  default:
355  break;
356  }
357  lua_pushboolean(L, r);
358  return 1;
359 }
static double cathetus ( double  x)
static

Definiert in Zeile 207 der Datei lfmathlib.c.

207  {
208  return sqrt((1 + x) * (1 - x));
209 }
static void cordic ( int  f,
double *  x,
double *  y,
double *  z 
)
static

Definiert in Zeile 181 der Datei lfmathlib.c.

181  {
182  double *patan_tab = atan_tab;
183  double xstep, ystep, zstep = 1;
184  double div = 1;
185  int i;
186  for (i = 0; i < N; i += 1) {
187  xstep = *x / div;
188  ystep = *y / div;
189  if (i < M) {
190  zstep = *patan_tab;
191  ++patan_tab;
192  } else zstep = zstep / 2.0;
193  int f1 = (f) ? *y >= 0 : *z < 0;
194  *x = (f1) ? *x + ystep : *x - ystep;
195  *y = (f1) ? *y - xstep : *y + xstep;
196  *z = (f1) ? *z + zstep : *z - zstep;
197  div = div * 2.0;
198  }
199 }
static int fmath_acos ( lua_State *  L)
static

Definiert in Zeile 489 der Datei lfmathlib.c.

489 { return atrigfn(L, FN_ACOS); }
static int fmath_add ( lua_State *  L)
static

Definiert in Zeile 462 der Datei lfmathlib.c.

462 { return twoargfn(L, FN_ADD); }
static int fmath_asin ( lua_State *  L)
static

Definiert in Zeile 488 der Datei lfmathlib.c.

488 { return atrigfn(L, FN_ASIN); }
static int fmath_atan ( lua_State *  L)
static

Definiert in Zeile 490 der Datei lfmathlib.c.

490 { return atrigfn(L, FN_ATAN); }
static int fmath_ceil ( lua_State *  L)
static

Definiert in Zeile 480 der Datei lfmathlib.c.

480 { return intfn(L, FN_CEIL); }
static int fmath_cos ( lua_State *  L)
static

Definiert in Zeile 485 der Datei lfmathlib.c.

485 { return trigfn(L, FN_COS); }
static int fmath_deg ( lua_State *  L)
static

Definiert in Zeile 476 der Datei lfmathlib.c.

476 { return oneargfn(L, FN_DEG); }
static int fmath_div ( lua_State *  L)
static

Definiert in Zeile 461 der Datei lfmathlib.c.

461 { return twoargfn(L, FN_DIV); }
static int fmath_eq ( lua_State *  L)
static

Definiert in Zeile 467 der Datei lfmathlib.c.

467 { return boolfn(L, FN_EQ); }
static int fmath_floor ( lua_State *  L)
static

Definiert in Zeile 481 der Datei lfmathlib.c.

481 { return intfn(L, FN_FLOOR); }
static int fmath_int ( lua_State *  L)
static

Definiert in Zeile 479 der Datei lfmathlib.c.

479 { return intfn(L, FN_INT); }
static int fmath_le ( lua_State *  L)
static

Definiert in Zeile 469 der Datei lfmathlib.c.

469 { return boolfn(L, FN_LE); }
static int fmath_log ( lua_State *  L)
static

Definiert in Zeile 472 der Datei lfmathlib.c.

472 { return oneargfn(L, FN_LOG); }
static int fmath_log10 ( lua_State *  L)
static

Definiert in Zeile 474 der Datei lfmathlib.c.

474 { return oneargfn(L, FN_LOG10); }
static int fmath_log2 ( lua_State *  L)
static

Definiert in Zeile 473 der Datei lfmathlib.c.

473 { return oneargfn(L, FN_LOG2); }
static int fmath_lt ( lua_State *  L)
static

Definiert in Zeile 468 der Datei lfmathlib.c.

468 { return boolfn(L, FN_LT); }
static int fmath_mod ( lua_State *  L)
static

Definiert in Zeile 465 der Datei lfmathlib.c.

465 { return twoargfn(L, FN_MOD); }
static int fmath_mul ( lua_State *  L)
static

Definiert in Zeile 460 der Datei lfmathlib.c.

460 { return twoargfn(L, FN_MUL); }
static int fmath_neg ( lua_State *  L)
static

Definiert in Zeile 471 der Datei lfmathlib.c.

471 { return oneargfn(L, FN_NEG); }
static int fmath_new ( lua_State *  L)
static

Definiert in Zeile 90 der Datei lfmathlib.c.

90  {
91  int n = luaL_checknumber(L, 1);
92  int d = luaL_optnumber(L, 2, 1);
93  newval(L, (double)n / (double)d);
94  return 1;
95 }
static int fmath_pol ( lua_State *  L)
static

Definiert in Zeile 450 der Datei lfmathlib.c.

450  {
451  double px = arg(L, 1);
452  double py = arg(L, 2);
453  double phi, hyp;
454  atanhypCordic(px, py, &phi, &hyp);
455  newval(L, hyp * INV_GAIN_CIRCLE);
456  newval(L, phi);
457  return 2;
458 }
static int fmath_pow ( lua_State *  L)
static

Definiert in Zeile 464 der Datei lfmathlib.c.

464 { return twoargfn(L, FN_POW); }
static int fmath_rad ( lua_State *  L)
static

Definiert in Zeile 477 der Datei lfmathlib.c.

477 { return oneargfn(L, FN_RAD); }
static int fmath_rec ( lua_State *  L)
static

Definiert in Zeile 440 der Datei lfmathlib.c.

440  {
441  double r = arg(L, 1);
442  double theta = arg(L, 2);
443  double _sin, _cos;
444  sincosCordic(theta, &_sin, &_cos);
445  newval(L, r * _cos);
446  newval(L, r * _sin);
447  return 2;
448 }
static int fmath_round ( lua_State *  L)
static

Definiert in Zeile 482 der Datei lfmathlib.c.

482 { return intfn(L, FN_ROUND); }
static int fmath_sin ( lua_State *  L)
static

Definiert in Zeile 484 der Datei lfmathlib.c.

484 { return trigfn(L, FN_SIN); }
static int fmath_sqrt ( lua_State *  L)
static

Definiert in Zeile 475 der Datei lfmathlib.c.

475 { return oneargfn(L, FN_SQRT); }
static int fmath_sub ( lua_State *  L)
static

Definiert in Zeile 463 der Datei lfmathlib.c.

463 { return twoargfn(L, FN_SUB); }
static int fmath_tan ( lua_State *  L)
static

Definiert in Zeile 486 der Datei lfmathlib.c.

486 { return trigfn(L, FN_TAN); }
static int fmath_toStr ( lua_State *  L)
static

Definiert in Zeile 99 der Datei lfmathlib.c.

99  {
100  char buf[100];
101  // value
102  double a = arg(L, 1);
103  // precision
104  int p = luaL_optnumber(L, 2, 6);
105  if (p < 0) p = 0;
106  if (p > 9) p = 9;
107  // decimal scaling / rounding factor
108  double m = pow(10.0, p);
109  // sign
110  const char* s = (a < 0) ? "-" : "";
111  // round absolute value
112  a = fabs(a) + (0.5 / m);
113  // whole part
114  unsigned int w = (int)a;
115  if (p > 0) {
116  // decimal part
117  unsigned int d = (int)((a - w) * m);
118  // format string
119  char fmt[20];
120  sprintf(fmt, "%s%%u.%%0%du", s, p);
121  // value string
122  sprintf(buf, fmt, w, d);
123  } else {
124  // value string
125  sprintf(buf, "%s%d", s, w);
126  }
127  lua_pushstring(L, buf);
128  return 1;
129 }
static double fmod ( double  x,
double  y 
)
static

Definiert in Zeile 203 der Datei lfmathlib.c.

203  {
204  return x - trunc(x / y) * y;
205 }
static int intfn ( lua_State *  L,
int  fn 
)
static

Definiert in Zeile 361 der Datei lfmathlib.c.

361  {
362  double a = arg(L, 1);
363  double frac = a - (int)a;
364  int r = 0;
365  switch(fn) {
366  case FN_INT:
367  r = (int)a;
368  break;
369  case FN_CEIL:
370  if ((a > 0.0) && (frac != 0.0))
371  r = (int)a + 1;
372  else
373  r = (int)a;
374  break;
375  case FN_FLOOR:
376  if ((a < 0.0) && (frac != 0.0))
377  r = (int)a - 1;
378  else
379  r = (int)a;
380  break;
381  case FN_ROUND:
382  if (a < 0.0)
383  r = (int)(a - 0.5);
384  else
385  r = (int)(a + 0.5);
386  break;
387  default:
388  break;
389  }
390  lua_pushnumber(L, r);
391  return 1;
392 }
LUALIB_API int luaopen_fmath ( lua_State *  L)

Definiert in Zeile 530 der Datei lfmathlib.c.

530  {
531  luaL_newmetatable(L, "fmathmeta");
532  lua_pushstring(L, "__index");
533  lua_pushvalue(L, -2); /* pushes the metatable */
534  lua_settable(L, -3); /* metatable.__index = metatable */
535  luaL_register(L, NULL, fmathlib_m);
536 
537  luaL_register(L, LUA_FMATHLIBNAME, &fmathlib_m[7]); // adjust offset if table is changed
538 
539  newval(L, M_PI * 2.0);
540  lua_setfield(L, -2, "pi2");
541  newval(L, M_PI);
542  lua_setfield(L, -2, "pi");
543  newval(L, M_PI / 2.0);
544  lua_setfield(L, -2, "pi_2");
545 
546  return 1;
547 }
static double* newval ( lua_State *  L,
double  v 
)
static

Definiert in Zeile 82 der Datei lfmathlib.c.

82  {
83  double* r = (double*)lua_newuserdata(L, sizeof(double));
84  luaL_getmetatable(L, "fmathmeta");
85  lua_setmetatable(L, -2);
86  *r = v;
87  return r;
88 }
static int oneargfn ( lua_State *  L,
int  fn 
)
static

Definiert in Zeile 308 der Datei lfmathlib.c.

308  {
309  double a = arg(L, 1);
310  double r = 0;
311  switch(fn) {
312  case FN_LOG:
313  r = log(a);
314  break;
315  case FN_LOG2:
316  r = log2(a);
317  break;
318  case FN_LOG10:
319  r = log10(a);
320  break;
321  case FN_SQRT:
322  r = sqrt(a);
323  break;
324  case FN_NEG:
325  r = -a;
326  break;
327  case FN_DEG:
328  r = a * 180.0 / M_PI;
329  break;
330  case FN_RAD:
331  r = a * M_PI / 180.0;
332  break;
333  default:
334  break;
335  }
336  newval(L, r);
337  return 1;
338 }
static void sincosCordic ( double  phi,
double *  sinphi,
double *  cosphi 
)
static

Definiert in Zeile 212 der Datei lfmathlib.c.

212  {
213  // convert to quadrant 1
214  phi = fmod(fmod(phi, M_PI * 2.0) + (M_PI * 2.0), M_PI * 2.0);
215  int q = (int)(phi / (M_PI / 2.0)) + 1;
216  switch(q) {
217  case 2: phi = M_PI - phi; break;
218  case 3: phi = phi - M_PI; break;
219  case 4: phi = M_PI * 2.0 - phi; break;
220  }
221 
222  double x = INV_GAIN_CIRCLE, y = 0, z = phi;
223  cordic(ROTATE, &x, &y, &z);
224 
225  // convert to original quadrant
226  if ((q == 2) || (q == 3)) { x = -x; }
227  if ((q == 3) || (q == 4)) { y = -y; }
228 
229  *sinphi = y;
230  *cosphi = x;
231 }
static int trigfn ( lua_State *  L,
int  fn 
)
static

Definiert in Zeile 394 der Datei lfmathlib.c.

394  {
395  double a = arg(L, 1);
396  double _sin, _cos;
397  double r = 0;
398  sincosCordic(a, &_sin, &_cos);
399  switch(fn) {
400  case FN_SIN:
401  r = _sin;
402  break;
403  case FN_COS:
404  r = _cos;
405  break;
406  case FN_TAN:
407  r = _sin / _cos;
408  break;
409  default:
410  break;
411  }
412  newval(L, r);
413  return 1;
414 }
static int twoargfn ( lua_State *  L,
int  fn 
)
static

Definiert in Zeile 278 der Datei lfmathlib.c.

278  {
279  double a = arg(L, 1);
280  double b = arg(L, 2);
281  double r = 0;
282  switch(fn) {
283  case FN_MUL:
284  r = a * b;
285  break;
286  case FN_DIV:
287  r = a / b;
288  break;
289  case FN_ADD:
290  r = a + b;
291  break;
292  case FN_SUB:
293  r = a - b;
294  break;
295  case FN_POW:
296  r = pow(a, b);
297  break;
298  case FN_MOD:
299  r = fmod(a, b);
300  break;
301  default:
302  break;
303  }
304  newval(L, r);
305  return 1;
306 }

Variablen-Dokumentation

double atan_tab[M]
static
Initialisierung:
= {
0.78539816339745, 0.46364760900081, 0.24497866312686, 0.12435499454676,
0.06241880999596, 0.03123983343027, 0.01562372862048, 0.00781234106010,
0.00390623013197
}

Definiert in Zeile 173 der Datei lfmathlib.c.

const luaL_Reg fmathlib_m[]
static

Definiert in Zeile 492 der Datei lfmathlib.c.