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

gehe zum Quellcode dieser Datei

Funktionen

static void cordic (tangle t, fcordic f, fixed *x, fixed *y, fixed *z)
 
static int cordic_abs (int a)
 
static int cordic_sign (int a)
 
LUALIB_API fixed muldivScaled (fixed a, fixed b, fixed c)
 
static fixed mulScaled (fixed a, fixed b)
 
static fixed divScaled (fixed a, fixed b)
 
static fixed cathetus (fixed x)
 
static void sincosCordic (tangle t, fixed phi, fixed *sinphi, fixed *cosphi)
 
static void atanhypCordic (tangle t, fixed px, fixed py, fixed *phi, fixed *hyp)
 
static fixed sinCordic (tangle t, fixed phi)
 
static fixed cosCordic (tangle t, fixed phi)
 
static fixed tanCordic (tangle t, fixed phi)
 
static void recCordic (tangle t, fixed r, fixed theta, fixed *px, fixed *py)
 
static fixed asinCordic (tangle t, fixed x)
 
static fixed acosCordic (tangle t, fixed x)
 
static fixed atanCordic (tangle t, fixed x)
 
static void polCordic (tangle t, fixed px, fixed py, fixed *r, fixed *theta)
 
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)
 
LUALIB_API fixed floatToFixed (double a)
 
LUALIB_API fixed intToFixed (int4b a, int round)
 
LUALIB_API int4b fixedToInt (fixed a, int round)
 

Variablen

fixed atan_tab [][M]
 
fixed INV_GAIN_CIRCLE [] = {0x136e9, 0x136e8}
 
fixed FULL_CIRCLE [] = {0xc90fd, 0x2d00000}
 
fixed HALF_CIRCLE [] = {0x6487e, 0x1680000}
 
fixed QUART_CIRCLE [] = {0x3243f, 0xb40000}
 
fixed ATAN_LIMIT = 0x36f602be
 
fixed FIXED_MAX = 16383.99999
 

Dokumentation der Funktionen

static fixed acosCordic ( tangle  t,
fixed  x 
)
static

Definiert in Zeile 179 der Datei cordic_math.c.

179  {
180  fixed phi, hyp;
181  fixed _sin = cathetus(x);
182  atanhypCordic(t, x, _sin, &phi, &hyp);
183  return phi;
184 }
LUALIB_API fixed acosd ( fixed  x)

Definiert in Zeile 221 der Datei cordic_math.c.

221  {
222  return acosCordic(DEG, x);
223 }
LUALIB_API fixed acosr ( fixed  x)

Definiert in Zeile 254 der Datei cordic_math.c.

254  {
255  return acosCordic(RAD, x);
256 }
static fixed asinCordic ( tangle  t,
fixed  x 
)
static

Definiert in Zeile 172 der Datei cordic_math.c.

172  {
173  fixed phi, hyp;
174  fixed _cos = cathetus(x);
175  atanhypCordic(t, _cos, x, &phi, &hyp);
176  return phi;
177 }
LUALIB_API fixed asind ( fixed  x)

Definiert in Zeile 217 der Datei cordic_math.c.

217  {
218  return asinCordic(DEG, x);
219 }
LUALIB_API fixed asinr ( fixed  x)

Definiert in Zeile 250 der Datei cordic_math.c.

250  {
251  return asinCordic(RAD, x);
252 }
static fixed atanCordic ( tangle  t,
fixed  x 
)
static

Definiert in Zeile 186 der Datei cordic_math.c.

186  {
187  fixed phi, hyp;
188  atanhypCordic(t, CORDIC_SCALE, x, &phi, &hyp);
189  return phi;
190 }
LUALIB_API fixed atand ( fixed  x)

Definiert in Zeile 225 der Datei cordic_math.c.

225  {
226  return atanCordic(DEG, x);
227 }
static void atanhypCordic ( tangle  t,
fixed  px,
fixed  py,
fixed *  phi,
fixed *  hyp 
)
static

Definiert in Zeile 106 der Datei cordic_math.c.

106  {
107  // convert to quadrant 1
108  int fy = (py >= 0);
109  int q = 1;
110  if (px < 0) {
111  if (fy)
112  q = 2;
113  else
114  q = 3;
115  } else if (!fy) {
116  q = 4;
117  }
118  px = cordic_abs(px);
119  py = cordic_abs(py);
120 
121  int f = 0;
122  while (px > ATAN_LIMIT || py > ATAN_LIMIT) {
123  px /= 2;
124  py /= 2;
125  f = 1;
126  }
127  if (px == 0 && py == 0) {
128  // error input vales
129  *phi = 0;
130  *hyp = 0;
131  } else {
132  fixed x = px, y = py, z = 0;
133  cordic(t, VECTOR, &x, &y, &z);
134  // convert to original quadrant
135  switch(q) {
136  case 2: z = HALF_CIRCLE[t] - z; break;
137  case 3: z = z - HALF_CIRCLE[t]; break;
138  case 4: z = -z; break;
139  }
140  *phi = z;
141  *hyp = (f)? 0 : x;
142  }
143 }
LUALIB_API fixed atanr ( fixed  x)

Definiert in Zeile 258 der Datei cordic_math.c.

258  {
259  return atanCordic(RAD, x);
260 }
static fixed cathetus ( fixed  x)
static

Definiert in Zeile 82 der Datei cordic_math.c.

82  {
83  return FIXED(sqrt((1 + FLOAT(x)) * (1 - FLOAT(x))));
84 }
static void cordic ( tangle  t,
fcordic  f,
fixed *  x,
fixed *  y,
fixed *  z 
)
static

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 }
static int cordic_abs ( int  a)
static

Definiert in Zeile 48 der Datei cordic_math.c.

48  {
49  if (a < -INT_MAX) a = -INT_MAX;
50  return abs(a);
51 }
static int cordic_sign ( int  a)
static

Definiert in Zeile 53 der Datei cordic_math.c.

53  {
54  return (a < 0)? -1 : 1;
55 }
static fixed cosCordic ( tangle  t,
fixed  phi 
)
static

Definiert in Zeile 152 der Datei cordic_math.c.

152  {
153  fixed _sin, _cos;
154  sincosCordic(t, phi, &_sin, &_cos);
155  return _cos;
156 }
LUALIB_API fixed cosd ( fixed  phi)

Definiert in Zeile 205 der Datei cordic_math.c.

205  {
206  return cosCordic(DEG, phi);
207 }
LUALIB_API fixed cosr ( fixed  phi)

Definiert in Zeile 238 der Datei cordic_math.c.

238  {
239  return cosCordic(RAD, phi);
240 }
static fixed divScaled ( fixed  a,
fixed  b 
)
static

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 271 der Datei cordic_math.c.

271  {
272  fixed int_a = fint(a);
273  return (a < 0 || a == int_a)? int_a: int_a + CORDIC_SCALE;
274 }
LUALIB_API fixed ffloor ( fixed  a)

Definiert in Zeile 276 der Datei cordic_math.c.

276  {
277  fixed int_a = fint(a);
278  return (a > 0 || a == int_a)? int_a: int_a - CORDIC_SCALE;
279 }
LUALIB_API fixed fint ( fixed  a)

Definiert in Zeile 267 der Datei cordic_math.c.

267  {
268  return cordic_sign(a) * (cordic_abs(a) & CORDIC_INTEGER);
269 }
LUALIB_API int4b fixedToInt ( fixed  a,
int  round 
)

Definiert in Zeile 310 der Datei cordic_math.c.

310  {
311  double res = cordic_abs(a);
312  if (res > INT_MAX) {
313  // error int4b overflow
314  res = INT_MAX;
315  }
316  res = res * INT_SCALE / CORDIC_SCALE;
317  if (round) res = res + 0.5;
318  return cordic_sign(a) * res;
319 }
LUALIB_API fixed floatToFixed ( double  a)

Definiert in Zeile 286 der Datei cordic_math.c.

286  {
287  int sign = 1;
288  if (a < 0) {
289  sign = -1;
290  a = -a;
291  }
292  if (a > FIXED_MAX) {
293  // error fixed overflow
294  a = FIXED_MAX;
295  }
296  return a * CORDIC_SCALE * sign;
297 }
LUALIB_API fixed fround ( fixed  a)

Definiert in Zeile 281 der Datei cordic_math.c.

281  {
282  return ffloor(a + CORDIC_SCALE / 2);
283 }
LUALIB_API fixed intToFixed ( int4b  a,
int  round 
)

Definiert in Zeile 299 der Datei cordic_math.c.

299  {
300  double res = cordic_abs(a);
301  if (round) res = res + 0.5;
302  res = res * CORDIC_SCALE / INT_SCALE;
303  if (res > INT_MAX) {
304  // error fixed overflow
305  res = INT_MAX;
306  }
307  return cordic_sign(a) * res;
308 }
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 }
static fixed mulScaled ( fixed  a,
fixed  b 
)
static

Definiert in Zeile 74 der Datei cordic_math.c.

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

Definiert in Zeile 192 der Datei cordic_math.c.

192  {
193  fixed phi, hyp;
194  atanhypCordic(t, px, py, &phi, &hyp);
195  *theta = phi;
196  *r = mulScaled(hyp, INV_GAIN_CIRCLE[t]);
197 }
LUALIB_API void pold ( fixed  px,
fixed  py,
fixed *  r,
fixed *  theta 
)

Definiert in Zeile 229 der Datei cordic_math.c.

229  {
230  polCordic(DEG, px, py, r, theta);
231 }
LUALIB_API void polr ( fixed  px,
fixed  py,
fixed *  r,
fixed *  theta 
)

Definiert in Zeile 262 der Datei cordic_math.c.

262  {
263  polCordic(RAD, px, py, r, theta);
264 }
static void recCordic ( tangle  t,
fixed  r,
fixed  theta,
fixed *  px,
fixed *  py 
)
static

Definiert in Zeile 164 der Datei cordic_math.c.

164  {
165  fixed _sin, _cos;
166  sincosCordic(t, theta, &_sin, &_cos);
167  *px = mulScaled(r, _cos);
168  *py = mulScaled(r, _sin);
169 }
LUALIB_API void recd ( fixed  r,
fixed  theta,
fixed *  px,
fixed *  py 
)

Definiert in Zeile 213 der Datei cordic_math.c.

213  {
214  recCordic(DEG, r, theta, px, py);
215 }
LUALIB_API void recr ( fixed  r,
fixed  theta,
fixed *  px,
fixed *  py 
)

Definiert in Zeile 246 der Datei cordic_math.c.

246  {
247  recCordic(RAD, r, theta, px, py);
248 }
static fixed sinCordic ( tangle  t,
fixed  phi 
)
static

Definiert in Zeile 146 der Datei cordic_math.c.

146  {
147  fixed _sin, _cos;
148  sincosCordic(t, phi, &_sin, &_cos);
149  return _sin;
150 }
static void sincosCordic ( tangle  t,
fixed  phi,
fixed *  sinphi,
fixed *  cosphi 
)
static

Definiert in Zeile 87 der Datei cordic_math.c.

87  {
88  // convert to quadrant 1
89  phi = (phi % FULL_CIRCLE[t] + FULL_CIRCLE[t]) % FULL_CIRCLE[t];
90  int q = phi / QUART_CIRCLE[t] + 1;
91  switch(q) {
92  case 2: phi = HALF_CIRCLE[t] - phi; break;
93  case 3: phi = phi - HALF_CIRCLE[t]; break;
94  case 4: phi = FULL_CIRCLE[t] - phi; break;
95  }
96  fixed x = INV_GAIN_CIRCLE[t], y = 0, z = phi;
97  cordic(t, ROTATE, &x, &y, &z);
98  // convert to original quadrant
99  if ((q == 2) || (q == 3)) { x = -x; }
100  if ((q == 3) || (q == 4)) { y = -y; }
101  *sinphi = y;
102  *cosphi = x;
103 }
LUALIB_API fixed sind ( fixed  phi)

Definiert in Zeile 201 der Datei cordic_math.c.

201  {
202  return sinCordic(DEG, phi);
203 }
LUALIB_API fixed sinr ( fixed  phi)

Definiert in Zeile 234 der Datei cordic_math.c.

234  {
235  return sinCordic(RAD, phi);
236 }
static fixed tanCordic ( tangle  t,
fixed  phi 
)
static

Definiert in Zeile 158 der Datei cordic_math.c.

158  {
159  fixed _sin, _cos;
160  sincosCordic(t, phi, &_sin, &_cos);
161  return divScaled(_sin, _cos);
162 }
LUALIB_API fixed tand ( fixed  phi)

Definiert in Zeile 209 der Datei cordic_math.c.

209  {
210  return tanCordic(DEG, phi);
211 }
LUALIB_API fixed tanr ( fixed  phi)

Definiert in Zeile 242 der Datei cordic_math.c.

242  {
243  return tanCordic(RAD, phi);
244 }

Variablen-Dokumentation

fixed ATAN_LIMIT = 0x36f602be

Definiert in Zeile 25 der Datei cordic_math.c.

fixed atan_tab[][M]
Initialisierung:
= {
{0x1921f, 0xed63, 0x7d6d, 0x3fab, 0x1ff5, 0xffe, 0x7ff, 0x3ff, 0x1ff},
{0x5a0000, 0x35214e, 0x1c128e, 0xe4002, 0x72715, 0x3946f, 0x1ca54, 0xe52d, 0x7297}
}

Definiert in Zeile 17 der Datei cordic_math.c.

fixed FIXED_MAX = 16383.99999

Definiert in Zeile 26 der Datei cordic_math.c.

fixed FULL_CIRCLE[] = {0xc90fd, 0x2d00000}

Definiert in Zeile 22 der Datei cordic_math.c.

fixed HALF_CIRCLE[] = {0x6487e, 0x1680000}

Definiert in Zeile 23 der Datei cordic_math.c.

fixed INV_GAIN_CIRCLE[] = {0x136e9, 0x136e8}

Definiert in Zeile 21 der Datei cordic_math.c.

fixed QUART_CIRCLE[] = {0x3243f, 0xb40000}

Definiert in Zeile 24 der Datei cordic_math.c.