CHDK_DE Vorschauversion  Trunk Rev. 5302
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,
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
DEG

Definiert in Zeile 41 der Datei cordic_math.h.

## Dokumentation der Funktionen

 LUALIB_API fixed acosCordic ( tangle t, fixed x )

Definiert in Zeile 197 der Datei cordic_math.c.

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

Definiert in Zeile 239 der Datei cordic_math.c.

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

Definiert in Zeile 272 der Datei cordic_math.c.

272  {
274 }
 LUALIB_API fixed asinCordic ( tangle t, fixed x )

Definiert in Zeile 190 der Datei cordic_math.c.

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

Definiert in Zeile 235 der Datei cordic_math.c.

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

Definiert in Zeile 268 der Datei cordic_math.c.

268  {
270 }
 LUALIB_API fixed atanCordic ( tangle t, fixed x )

Definiert in Zeile 204 der Datei cordic_math.c.

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

Definiert in Zeile 243 der Datei cordic_math.c.

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

Definiert in Zeile 140 der Datei cordic_math.c.

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

Definiert in Zeile 276 der Datei cordic_math.c.

276  {
278 }
 LUALIB_API fixed cathetus ( fixed x)

Definiert in Zeile 125 der Datei cordic_math.c.

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

Definiert in Zeile 98 der Datei cordic_math.c.

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

Definiert in Zeile 83 der Datei cordic_math.c.

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

Definiert in Zeile 30 der Datei cordic_math.c.

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

Definiert in Zeile 170 der Datei cordic_math.c.

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

Definiert in Zeile 223 der Datei cordic_math.c.

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

Definiert in Zeile 256 der Datei cordic_math.c.

256  {
258 }
 LUALIB_API fixed divScaled ( fixed a, fixed b )

Definiert in Zeile 79 der Datei cordic_math.c.

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

Definiert in Zeile 289 der Datei cordic_math.c.

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

Definiert in Zeile 294 der Datei cordic_math.c.

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

Definiert in Zeile 285 der Datei cordic_math.c.

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

Definiert in Zeile 328 der Datei cordic_math.c.

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

Definiert in Zeile 304 der Datei cordic_math.c.

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

Definiert in Zeile 299 der Datei cordic_math.c.

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

Definiert in Zeile 317 der Datei cordic_math.c.

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

Definiert in Zeile 59 der Datei cordic_math.c.

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

Definiert in Zeile 75 der Datei cordic_math.c.

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

Definiert in Zeile 210 der Datei cordic_math.c.

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

Definiert in Zeile 247 der Datei cordic_math.c.

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

Definiert in Zeile 280 der Datei cordic_math.c.

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

Definiert in Zeile 182 der Datei cordic_math.c.

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

Definiert in Zeile 231 der Datei cordic_math.c.

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

Definiert in Zeile 264 der Datei cordic_math.c.

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

Definiert in Zeile 117 der Datei cordic_math.c.

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

Definiert in Zeile 106 der Datei cordic_math.c.

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

Definiert in Zeile 164 der Datei cordic_math.c.

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

Definiert in Zeile 130 der Datei cordic_math.c.

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

Definiert in Zeile 219 der Datei cordic_math.c.

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

Definiert in Zeile 252 der Datei cordic_math.c.

252  {
254 }
 LUALIB_API fixed tanCordic ( tangle t, fixed phi )

Definiert in Zeile 176 der Datei cordic_math.c.

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

Definiert in Zeile 227 der Datei cordic_math.c.

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

Definiert in Zeile 260 der Datei cordic_math.c.

260  {
262 }

## 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.