CHDK_DE Vorschauversion  Trunk Rev. 5842
 Alle Datenstrukturen Dateien Funktionen Variablen Typdefinitionen Aufzählungen Aufzählungswerte Makrodefinitionen
Makrodefinitionen | Typdefinitionen | Aufzählungen | Funktionen | Variablen
cordic_math.h-Dateireferenz
#include "limits.h"
+ Include-Abhängigkeitsdiagramm für cordic_math.h:
+ Dieser Graph zeigt, welche Datei direkt oder indirekt diese Datei enthält:

gehe zum Quellcode dieser Datei

Makrodefinitionen

#define FIXED(X)   (floatToFixed((X)))
 
#define FLOAT(X)   ((X) / (double)CORDIC_SCALE)
 
#define INT2FIXED(X)   (intToFixed((X), 0))
 
#define INT2FIXEDR(X)   (intToFixed((X), 1))
 
#define FIXED2INT(X)   (fixedToInt((X), 0))
 
#define FIXED2INTR(X)   (fixedToInt((X), 1))
 

Typdefinitionen

typedef long fixed
 
typedef int int4b
 
typedef int fcordic
 
typedef int tangle
 

Aufzählungen

enum  fcordic { ROTATE, VECTOR }
 
enum  tangle { RAD, DEG }
 
enum  {
  FRACTIONBITS = 17, N = 17, M = 9, CORDIC_SCALE = 1 << FRACTIONBITS,
  CORDIC_INTEGER = ~(CORDIC_SCALE - 1), INT_SCALE = 1000
}
 

Funktionen

LUALIB_API void cordic (tangle t, fcordic f, fixed *x, fixed *y, fixed *z)
 
LUALIB_API fixed mulScaled (fixed a, fixed b)
 
LUALIB_API fixed divScaled (fixed a, fixed b)
 
LUALIB_API int convertToQ1 (fixed *x, fixed *y)
 
LUALIB_API void convertFromQ1 (fixed *x, fixed *y, int q)
 
LUALIB_API int rotateToQ1 (tangle t, fixed *phi)
 
LUALIB_API void rotateFromQ1 (tangle t, fixed *phi, int q)
 
LUALIB_API fixed cathetus (fixed x)
 
LUALIB_API void sincosCordic (tangle t, fixed phi, fixed *sinphi, fixed *cosphi)
 
LUALIB_API void atanhypCordic (tangle t, fixed px, fixed py, fixed *phi, fixed *hyp)
 
LUALIB_API fixed sinCordic (tangle t, fixed phi)
 
LUALIB_API fixed cosCordic (tangle t, fixed phi)
 
LUALIB_API fixed tanCordic (tangle t, fixed phi)
 
LUALIB_API void recCordic (tangle t, fixed r, fixed theta, fixed *px, fixed *py)
 
LUALIB_API fixed asinCordic (tangle t, fixed x)
 
LUALIB_API fixed acosCordic (tangle t, fixed x)
 
LUALIB_API fixed atanCordic (tangle t, fixed x)
 
LUALIB_API void polCordic (tangle t, fixed px, fixed py, fixed *r, fixed *theta)
 
LUALIB_API fixed floatToFixed (double a)
 
LUALIB_API fixed intToFixed (int4b a, int round)
 
LUALIB_API int4b fixedToInt (fixed a, int round)
 
LUALIB_API fixed muldivScaled (fixed a, fixed b, fixed c)
 
LUALIB_API fixed sind (fixed phi)
 
LUALIB_API fixed cosd (fixed phi)
 
LUALIB_API fixed tand (fixed phi)
 
LUALIB_API void recd (fixed r, fixed theta, fixed *px, fixed *py)
 
LUALIB_API fixed asind (fixed x)
 
LUALIB_API fixed acosd (fixed x)
 
LUALIB_API fixed atand (fixed x)
 
LUALIB_API void pold (fixed px, fixed py, fixed *r, fixed *theta)
 
LUALIB_API fixed sinr (fixed phi)
 
LUALIB_API fixed cosr (fixed phi)
 
LUALIB_API fixed tanr (fixed phi)
 
LUALIB_API void recr (fixed r, fixed theta, fixed *px, fixed *py)
 
LUALIB_API fixed asinr (fixed x)
 
LUALIB_API fixed acosr (fixed x)
 
LUALIB_API fixed atanr (fixed x)
 
LUALIB_API void polr (fixed px, fixed py, fixed *r, fixed *theta)
 
LUALIB_API fixed fint (fixed a)
 
LUALIB_API fixed fceil (fixed a)
 
LUALIB_API fixed ffloor (fixed a)
 
LUALIB_API fixed fround (fixed a)
 

Variablen

LUAI_DATA fixed FULL_CIRCLE []
 
LUAI_DATA fixed HALF_CIRCLE []
 
LUAI_DATA fixed QUART_CIRCLE []
 

Makro-Dokumentation

#define FIXED (   X)    (floatToFixed((X)))

Definiert in Zeile 55 der Datei cordic_math.h.

#define FIXED2INT (   X)    (fixedToInt((X), 0))

Definiert in Zeile 59 der Datei cordic_math.h.

#define FIXED2INTR (   X)    (fixedToInt((X), 1))

Definiert in Zeile 60 der Datei cordic_math.h.

#define FLOAT (   X)    ((X) / (double)CORDIC_SCALE)

Definiert in Zeile 56 der Datei cordic_math.h.

#define INT2FIXED (   X)    (intToFixed((X), 0))

Definiert in Zeile 57 der Datei cordic_math.h.

#define INT2FIXEDR (   X)    (intToFixed((X), 1))

Definiert in Zeile 58 der Datei cordic_math.h.

Dokumentation der benutzerdefinierten Typen

typedef int fcordic

Definiert in Zeile 40 der Datei cordic_math.h.

typedef long fixed

Definiert in Zeile 37 der Datei cordic_math.h.

typedef int int4b

Definiert in Zeile 38 der Datei cordic_math.h.

typedef int tangle

Definiert in Zeile 42 der Datei cordic_math.h.

Dokumentation der Aufzählungstypen

anonymous enum
Aufzählungswerte
FRACTIONBITS 
N 
M 
CORDIC_SCALE 
CORDIC_INTEGER 
INT_SCALE 

Definiert in Zeile 44 der Datei cordic_math.h.

44  {
45  FRACTIONBITS = 17,
46  N = 17,
47  M = 9,
48  CORDIC_SCALE = 1 << FRACTIONBITS,
49  CORDIC_INTEGER = ~(CORDIC_SCALE - 1),
50  INT_SCALE = 1000,
51 };
enum fcordic
Aufzählungswerte
ROTATE 
VECTOR 

Definiert in Zeile 39 der Datei cordic_math.h.

39 {ROTATE, VECTOR};
enum tangle
Aufzählungswerte
RAD 
DEG 

Definiert in Zeile 41 der Datei cordic_math.h.

41 {RAD, DEG};

Dokumentation der Funktionen

LUALIB_API fixed acosCordic ( tangle  t,
fixed  x 
)

Definiert in Zeile 196 der Datei cordic_math.c.

196  {
197  fixed phi, hyp;
198  fixed _sin = cathetus(x);
199  atanhypCordic(t, x, _sin, &phi, &hyp);
200  return phi;
201 }
LUALIB_API fixed acosd ( fixed  x)

Definiert in Zeile 238 der Datei cordic_math.c.

238  {
239  return acosCordic(DEG, x);
240 }
LUALIB_API fixed acosr ( fixed  x)

Definiert in Zeile 271 der Datei cordic_math.c.

271  {
272  return acosCordic(RAD, x);
273 }
LUALIB_API fixed asinCordic ( tangle  t,
fixed  x 
)

Definiert in Zeile 189 der Datei cordic_math.c.

189  {
190  fixed phi, hyp;
191  fixed _cos = cathetus(x);
192  atanhypCordic(t, _cos, x, &phi, &hyp);
193  return phi;
194 }
LUALIB_API fixed asind ( fixed  x)

Definiert in Zeile 234 der Datei cordic_math.c.

234  {
235  return asinCordic(DEG, x);
236 }
LUALIB_API fixed asinr ( fixed  x)

Definiert in Zeile 267 der Datei cordic_math.c.

267  {
268  return asinCordic(RAD, x);
269 }
LUALIB_API fixed atanCordic ( tangle  t,
fixed  x 
)

Definiert in Zeile 203 der Datei cordic_math.c.

203  {
204  fixed phi, hyp;
205  atanhypCordic(t, CORDIC_SCALE, x, &phi, &hyp);
206  return phi;
207 }
LUALIB_API fixed atand ( fixed  x)

Definiert in Zeile 242 der Datei cordic_math.c.

242  {
243  return atanCordic(DEG, x);
244 }
LUALIB_API void atanhypCordic ( tangle  t,
fixed  px,
fixed  py,
fixed *  phi,
fixed *  hyp 
)

Definiert in Zeile 139 der Datei cordic_math.c.

139  {
140  int q = convertToQ1(&px, &py);
141  int f = 0;
142  while (px > ATAN_LIMIT || py > ATAN_LIMIT) {
143  px /= 2;
144  py /= 2;
145  f = 1;
146  }
147  if (px == 0 && py == 0) {
148  // error input vales
149  *phi = 0;
150  *hyp = 0;
151  } else {
152  fixed x = px, y = py, z = 0;
153  cordic(t, VECTOR, &x, &y, &z);
154  rotateFromQ1(t, &z, q);
155  //shift to [pi; -pi]
156  if ((q == 3) || (q == 4)) { z = z - FULL_CIRCLE[t]; }
157  *phi = z;
158  *hyp = (f)? 0 : x;
159  }
160 }
LUALIB_API fixed atanr ( fixed  x)

Definiert in Zeile 275 der Datei cordic_math.c.

275  {
276  return atanCordic(RAD, x);
277 }
LUALIB_API fixed cathetus ( fixed  x)

Definiert in Zeile 124 der Datei cordic_math.c.

124  {
125  return FIXED(sqrt((1 + FLOAT(x)) * (1 - FLOAT(x))));
126 }
LUALIB_API void convertFromQ1 ( fixed *  x,
fixed *  y,
int  q 
)

Definiert in Zeile 97 der Datei cordic_math.c.

97  {
98  int fx = 1, fy = 1;
99  if ((q == 2) || (q == 3)) { fx = -1; }
100  if ((q == 3) || (q == 4)) { fy = -1; }
101  *x = fx * *x;
102  *y = fy * *y;
103 }
LUALIB_API int convertToQ1 ( fixed *  x,
fixed *  y 
)

Definiert in Zeile 82 der Datei cordic_math.c.

82  {
83  int fx = (*x >= 0), fy = (*y >= 0);
84  int q = 1;
85  if (!fx && fy) {
86  q = 2;
87  } else if (!fx && !fy) {
88  q = 3;
89  } else if (fx && !fy) {
90  q = 4;
91  }
92  *x = cordic_abs(*x);
93  *y = cordic_abs(*y);
94  return q;
95 }
LUALIB_API void cordic ( tangle  t,
fcordic  f,
fixed *  x,
fixed *  y,
fixed *  z 
)

Definiert in Zeile 29 der Datei cordic_math.c.

29  {
30  long *patan_tab = atan_tab[t];
31  long xstep, ystep, zstep = 1;
32  int i;
33  for (i = 0; i < N; ++i) {
34  xstep = *x >> i;
35  ystep = *y >> i;
36  if (i < M) {
37  zstep = *patan_tab;
38  ++patan_tab;
39  } else zstep >>= 1;
40  int f1 = (f) ? *y >= 0 : *z < 0;
41  *x = (f1) ? *x + ystep : *x - ystep;
42  *y = (f1) ? *y - xstep : *y + xstep;
43  *z = (f1) ? *z + zstep : *z - zstep;
44  }
45 }
LUALIB_API fixed cosCordic ( tangle  t,
fixed  phi 
)

Definiert in Zeile 169 der Datei cordic_math.c.

169  {
170  fixed _sin, _cos;
171  sincosCordic(t, phi, &_sin, &_cos);
172  return _cos;
173 }
LUALIB_API fixed cosd ( fixed  phi)

Definiert in Zeile 222 der Datei cordic_math.c.

222  {
223  return cosCordic(DEG, phi);
224 }
LUALIB_API fixed cosr ( fixed  phi)

Definiert in Zeile 255 der Datei cordic_math.c.

255  {
256  return cosCordic(RAD, phi);
257 }
LUALIB_API fixed divScaled ( fixed  a,
fixed  b 
)

Definiert in Zeile 78 der Datei cordic_math.c.

78  {
79  return muldivScaled(CORDIC_SCALE, a, b);
80 }
LUALIB_API fixed fceil ( fixed  a)

Definiert in Zeile 288 der Datei cordic_math.c.

288  {
289  fixed int_a = fint(a);
290  return (a < 0 || a == int_a)? int_a: int_a + CORDIC_SCALE;
291 }
LUALIB_API fixed ffloor ( fixed  a)

Definiert in Zeile 293 der Datei cordic_math.c.

293  {
294  fixed int_a = fint(a);
295  return (a > 0 || a == int_a)? int_a: int_a - CORDIC_SCALE;
296 }
LUALIB_API fixed fint ( fixed  a)

Definiert in Zeile 284 der Datei cordic_math.c.

284  {
285  return cordic_sign(a) * (cordic_abs(a) & CORDIC_INTEGER);
286 }
LUALIB_API int4b fixedToInt ( fixed  a,
int  round 
)

Definiert in Zeile 327 der Datei cordic_math.c.

327  {
328  double res = cordic_abs(a);
329  if (res > INT_MAX) {
330  // error int4b overflow
331  res = INT_MAX;
332  }
333  res = res * INT_SCALE / CORDIC_SCALE;
334  if (round) res = res + 0.5;
335  return cordic_sign(a) * res;
336 }
LUALIB_API fixed floatToFixed ( double  a)

Definiert in Zeile 303 der Datei cordic_math.c.

303  {
304  int sign = 1;
305  if (a < 0) {
306  sign = -1;
307  a = -a;
308  }
309  if (a > FIXED_MAX) {
310  // error fixed overflow
311  a = FIXED_MAX;
312  }
313  return a * CORDIC_SCALE * sign;
314 }
LUALIB_API fixed fround ( fixed  a)

Definiert in Zeile 298 der Datei cordic_math.c.

298  {
299  return ffloor(a + CORDIC_SCALE / 2);
300 }
LUALIB_API fixed intToFixed ( int4b  a,
int  round 
)

Definiert in Zeile 316 der Datei cordic_math.c.

316  {
317  double res = cordic_abs(a);
318  if (round) res = res + 0.5;
319  res = res * CORDIC_SCALE / INT_SCALE;
320  if (res > INT_MAX) {
321  // error fixed overflow
322  res = INT_MAX;
323  }
324  return cordic_sign(a) * res;
325 }
LUALIB_API fixed muldivScaled ( fixed  a,
fixed  b,
fixed  c 
)

Definiert in Zeile 58 der Datei cordic_math.c.

58  {
59  double res;
60  if (c != 0) {
61  int sign = cordic_sign(a) * cordic_sign(b) / cordic_sign(c);
62  res = FLOAT(cordic_abs(a)) * FLOAT(cordic_abs(b)) / FLOAT(cordic_abs(c));
63  if (res > INT_MAX) {
64  // error overflow
65  res = INT_MAX;
66  } else { res = sign * res; }
67  } else {
68  // error div 0
69  res = 0;
70  }
71  return FIXED(res);
72 }
LUALIB_API fixed mulScaled ( fixed  a,
fixed  b 
)

Definiert in Zeile 74 der Datei cordic_math.c.

74  {
75  return muldivScaled(a, b, CORDIC_SCALE);
76 }
LUALIB_API void polCordic ( tangle  t,
fixed  px,
fixed  py,
fixed *  r,
fixed *  theta 
)

Definiert in Zeile 209 der Datei cordic_math.c.

209  {
210  fixed phi, hyp;
211  atanhypCordic(t, px, py, &phi, &hyp);
212  *theta = phi;
213  *r = mulScaled(hyp, INV_GAIN_CIRCLE[t]);
214 }
LUALIB_API void pold ( fixed  px,
fixed  py,
fixed *  r,
fixed *  theta 
)

Definiert in Zeile 246 der Datei cordic_math.c.

246  {
247  polCordic(DEG, px, py, r, theta);
248 }
LUALIB_API void polr ( fixed  px,
fixed  py,
fixed *  r,
fixed *  theta 
)

Definiert in Zeile 279 der Datei cordic_math.c.

279  {
280  polCordic(RAD, px, py, r, theta);
281 }
LUALIB_API void recCordic ( tangle  t,
fixed  r,
fixed  theta,
fixed *  px,
fixed *  py 
)

Definiert in Zeile 181 der Datei cordic_math.c.

181  {
182  fixed _sin, _cos;
183  sincosCordic(t, theta, &_sin, &_cos);
184  *px = mulScaled(r, _cos);
185  *py = mulScaled(r, _sin);
186 }
LUALIB_API void recd ( fixed  r,
fixed  theta,
fixed *  px,
fixed *  py 
)

Definiert in Zeile 230 der Datei cordic_math.c.

230  {
231  recCordic(DEG, r, theta, px, py);
232 }
LUALIB_API void recr ( fixed  r,
fixed  theta,
fixed *  px,
fixed *  py 
)

Definiert in Zeile 263 der Datei cordic_math.c.

263  {
264  recCordic(RAD, r, theta, px, py);
265 }
LUALIB_API void rotateFromQ1 ( tangle  t,
fixed *  phi,
int  q 
)

Definiert in Zeile 116 der Datei cordic_math.c.

116  {
117  switch(q) {
118  case 2: *phi = HALF_CIRCLE[t] - *phi; break;
119  case 3: *phi = HALF_CIRCLE[t] + *phi; break;
120  case 4: *phi = FULL_CIRCLE[t] - *phi; break;
121  }
122 }
LUALIB_API int rotateToQ1 ( tangle  t,
fixed *  phi 
)

Definiert in Zeile 105 der Datei cordic_math.c.

105  {
106  *phi = (*phi % FULL_CIRCLE[t] + FULL_CIRCLE[t]) % FULL_CIRCLE[t];
107  int q = *phi / QUART_CIRCLE[t] + 1;
108  switch(q) {
109  case 2: *phi = HALF_CIRCLE[t] - *phi; break;
110  case 3: *phi = *phi - HALF_CIRCLE[t]; break;
111  case 4: *phi = FULL_CIRCLE[t] - *phi; break;
112  }
113  return q;
114 }
LUALIB_API fixed sinCordic ( tangle  t,
fixed  phi 
)

Definiert in Zeile 163 der Datei cordic_math.c.

163  {
164  fixed _sin, _cos;
165  sincosCordic(t, phi, &_sin, &_cos);
166  return _sin;
167 }
LUALIB_API void sincosCordic ( tangle  t,
fixed  phi,
fixed *  sinphi,
fixed *  cosphi 
)

Definiert in Zeile 129 der Datei cordic_math.c.

129  {
130  int q = rotateToQ1(t, &phi);
131  fixed x = INV_GAIN_CIRCLE[t], y = 0, z = phi;
132  cordic(t, ROTATE, &x, &y, &z);
133  convertFromQ1(&x, &y, q);
134  *sinphi = y;
135  *cosphi = x;
136 }
LUALIB_API fixed sind ( fixed  phi)

Definiert in Zeile 218 der Datei cordic_math.c.

218  {
219  return sinCordic(DEG, phi);
220 }
LUALIB_API fixed sinr ( fixed  phi)

Definiert in Zeile 251 der Datei cordic_math.c.

251  {
252  return sinCordic(RAD, phi);
253 }
LUALIB_API fixed tanCordic ( tangle  t,
fixed  phi 
)

Definiert in Zeile 175 der Datei cordic_math.c.

175  {
176  fixed _sin, _cos;
177  sincosCordic(t, phi, &_sin, &_cos);
178  return divScaled(_sin, _cos);
179 }
LUALIB_API fixed tand ( fixed  phi)

Definiert in Zeile 226 der Datei cordic_math.c.

226  {
227  return tanCordic(DEG, phi);
228 }
LUALIB_API fixed tanr ( fixed  phi)

Definiert in Zeile 259 der Datei cordic_math.c.

259  {
260  return tanCordic(RAD, phi);
261 }

Variablen-Dokumentation

LUAI_DATA fixed FULL_CIRCLE[]

Definiert in Zeile 88 der Datei cordic_math.h.

LUAI_DATA fixed HALF_CIRCLE[]

Definiert in Zeile 89 der Datei cordic_math.h.

LUAI_DATA fixed QUART_CIRCLE[]

Definiert in Zeile 90 der Datei cordic_math.h.