spandsp  0.0.6
complex.h
Go to the documentation of this file.
1 /*
2  * SpanDSP - a series of DSP components for telephony
3  *
4  * complex.h
5  *
6  * Written by Steve Underwood <steveu@coppice.org>
7  *
8  * Copyright (C) 2003 Steve Underwood
9  *
10  * All rights reserved.
11  *
12  * This program is free software; you can redistribute it and/or modify
13  * it under the terms of the GNU Lesser General Public License version 2.1,
14  * as published by the Free Software Foundation.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19  * GNU Lesser General Public License for more details.
20  *
21  * You should have received a copy of the GNU Lesser General Public
22  * License along with this program; if not, write to the Free Software
23  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24  */
25 
26 /*! \file */
27 
28 /*! \page complex_page Complex number support
29 \section complex_page_sec_1 What does it do?
30 Complex number support is part of the C99 standard. However, support for this
31 in C compilers is still patchy. A set of complex number feaures is provided as
32 a "temporary" measure, until native C language complex number support is
33 widespread.
34 */
35 
36 #if !defined(_SPANDSP_COMPLEX_H_)
37 #define _SPANDSP_COMPLEX_H_
38 
39 /*!
40  Floating complex type.
41 */
42 typedef struct
43 {
44  /*! \brief Real part. */
45  float re;
46  /*! \brief Imaginary part. */
47  float im;
48 } complexf_t;
49 
50 /*!
51  Floating complex type.
52 */
53 typedef struct
54 {
55  /*! \brief Real part. */
56  double re;
57  /*! \brief Imaginary part. */
58  double im;
59 } complex_t;
60 
61 #if defined(HAVE_LONG_DOUBLE)
62 /*!
63  Long double complex type.
64 */
65 typedef struct
66 {
67  /*! \brief Real part. */
68  long double re;
69  /*! \brief Imaginary part. */
70  long double im;
71 } complexl_t;
72 #endif
73 
74 /*!
75  Complex integer type.
76 */
77 typedef struct
78 {
79  /*! \brief Real part. */
80  int re;
81  /*! \brief Imaginary part. */
82  int im;
83 } complexi_t;
84 
85 /*!
86  Complex 16 bit integer type.
87 */
88 typedef struct
89 {
90  /*! \brief Real part. */
91  int16_t re;
92  /*! \brief Imaginary part. */
93  int16_t im;
94 } complexi16_t;
95 
96 /*!
97  Complex 32 bit integer type.
98 */
99 typedef struct
100 {
101  /*! \brief Real part. */
102  int32_t re;
103  /*! \brief Imaginary part. */
104  int32_t im;
105 } complexi32_t;
106 
107 #if defined(__cplusplus)
108 extern "C"
109 {
110 #endif
111 
112 static __inline__ complexf_t complex_setf(float re, float im)
113 {
114  complexf_t z;
115 
116  z.re = re;
117  z.im = im;
118  return z;
119 }
120 /*- End of function --------------------------------------------------------*/
121 
122 static __inline__ complex_t complex_set(double re, double im)
123 {
124  complex_t z;
125 
126  z.re = re;
127  z.im = im;
128  return z;
129 }
130 /*- End of function --------------------------------------------------------*/
131 
132 #if defined(HAVE_LONG_DOUBLE)
133 static __inline__ complexl_t complex_setl(long double re, long double im)
134 {
135  complexl_t z;
136 
137  z.re = re;
138  z.im = im;
139  return z;
140 }
141 /*- End of function --------------------------------------------------------*/
142 #endif
143 
144 static __inline__ complexi_t complex_seti(int re, int im)
145 {
146  complexi_t z;
147 
148  z.re = re;
149  z.im = im;
150  return z;
151 }
152 /*- End of function --------------------------------------------------------*/
153 
154 static __inline__ complexi16_t complex_seti16(int16_t re, int16_t im)
155 {
156  complexi16_t z;
157 
158  z.re = re;
159  z.im = im;
160  return z;
161 }
162 /*- End of function --------------------------------------------------------*/
163 
164 static __inline__ complexi32_t complex_seti32(int32_t re, int32_t im)
165 {
166  complexi32_t z;
167 
168  z.re = re;
169  z.im = im;
170  return z;
171 }
172 /*- End of function --------------------------------------------------------*/
173 
174 static __inline__ complexf_t complex_addf(const complexf_t *x, const complexf_t *y)
175 {
176  complexf_t z;
177 
178  z.re = x->re + y->re;
179  z.im = x->im + y->im;
180  return z;
181 }
182 /*- End of function --------------------------------------------------------*/
183 
184 static __inline__ complex_t complex_add(const complex_t *x, const complex_t *y)
185 {
186  complex_t z;
187 
188  z.re = x->re + y->re;
189  z.im = x->im + y->im;
190  return z;
191 }
192 /*- End of function --------------------------------------------------------*/
193 
194 #if defined(HAVE_LONG_DOUBLE)
195 static __inline__ complexl_t complex_addl(const complexl_t *x, const complexl_t *y)
196 {
197  complexl_t z;
198 
199  z.re = x->re + y->re;
200  z.im = x->im + y->im;
201  return z;
202 }
203 /*- End of function --------------------------------------------------------*/
204 #endif
205 
206 static __inline__ complexi_t complex_addi(const complexi_t *x, const complexi_t *y)
207 {
208  complexi_t z;
209 
210  z.re = x->re + y->re;
211  z.im = x->im + y->im;
212  return z;
213 }
214 /*- End of function --------------------------------------------------------*/
215 
216 static __inline__ complexi16_t complex_addi16(const complexi16_t *x, const complexi16_t *y)
217 {
218  complexi16_t z;
219 
220  z.re = x->re + y->re;
221  z.im = x->im + y->im;
222  return z;
223 }
224 /*- End of function --------------------------------------------------------*/
225 
226 static __inline__ complexi32_t complex_addi32(const complexi32_t *x, const complexi32_t *y)
227 {
228  complexi32_t z;
229 
230  z.re = x->re + y->re;
231  z.im = x->im + y->im;
232  return z;
233 }
234 /*- End of function --------------------------------------------------------*/
235 
236 static __inline__ complexf_t complex_subf(const complexf_t *x, const complexf_t *y)
237 {
238  complexf_t z;
239 
240  z.re = x->re - y->re;
241  z.im = x->im - y->im;
242  return z;
243 }
244 /*- End of function --------------------------------------------------------*/
245 
246 static __inline__ complex_t complex_sub(const complex_t *x, const complex_t *y)
247 {
248  complex_t z;
249 
250  z.re = x->re - y->re;
251  z.im = x->im - y->im;
252  return z;
253 }
254 /*- End of function --------------------------------------------------------*/
255 
256 #if defined(HAVE_LONG_DOUBLE)
257 static __inline__ complexl_t complex_subl(const complexl_t *x, const complexl_t *y)
258 {
259  complexl_t z;
260 
261  z.re = x->re - y->re;
262  z.im = x->im - y->im;
263  return z;
264 }
265 /*- End of function --------------------------------------------------------*/
266 #endif
267 
268 static __inline__ complexi_t complex_subi(const complexi_t *x, const complexi_t *y)
269 {
270  complexi_t z;
271 
272  z.re = x->re - y->re;
273  z.im = x->im - y->im;
274  return z;
275 }
276 /*- End of function --------------------------------------------------------*/
277 
278 static __inline__ complexi16_t complex_subi16(const complexi16_t *x, const complexi16_t *y)
279 {
280  complexi16_t z;
281 
282  z.re = x->re - y->re;
283  z.im = x->im - y->im;
284  return z;
285 }
286 /*- End of function --------------------------------------------------------*/
287 
288 static __inline__ complexi32_t complex_subi32(const complexi32_t *x, const complexi32_t *y)
289 {
290  complexi32_t z;
291 
292  z.re = x->re - y->re;
293  z.im = x->im - y->im;
294  return z;
295 }
296 /*- End of function --------------------------------------------------------*/
297 
298 static __inline__ complexf_t complex_mulf(const complexf_t *x, const complexf_t *y)
299 {
300  complexf_t z;
301 
302  z.re = x->re*y->re - x->im*y->im;
303  z.im = x->re*y->im + x->im*y->re;
304  return z;
305 }
306 /*- End of function --------------------------------------------------------*/
307 
308 static __inline__ complex_t complex_mul(const complex_t *x, const complex_t *y)
309 {
310  complex_t z;
311 
312  z.re = x->re*y->re - x->im*y->im;
313  z.im = x->re*y->im + x->im*y->re;
314  return z;
315 }
316 /*- End of function --------------------------------------------------------*/
317 
318 #if defined(HAVE_LONG_DOUBLE)
319 static __inline__ complexl_t complex_mull(const complexl_t *x, const complexl_t *y)
320 {
321  complexl_t z;
322 
323  z.re = x->re*y->re - x->im*y->im;
324  z.im = x->re*y->im + x->im*y->re;
325  return z;
326 }
327 /*- End of function --------------------------------------------------------*/
328 #endif
329 
330 static __inline__ complexi_t complex_muli(const complexi_t *x, const complexi_t *y)
331 {
332  complexi_t z;
333 
334  z.re = x->re*y->re - x->im*y->im;
335  z.im = x->re*y->im + x->im*y->re;
336  return z;
337 }
338 /*- End of function --------------------------------------------------------*/
339 
340 static __inline__ complexi16_t complex_muli16(const complexi16_t *x, const complexi16_t *y)
341 {
342  complexi16_t z;
343 
344  z.re = (int16_t) ((int32_t) x->re*(int32_t) y->re - (int32_t) x->im*(int32_t) y->im);
345  z.im = (int16_t) ((int32_t) x->re*(int32_t) y->im + (int32_t) x->im*(int32_t) y->re);
346  return z;
347 }
348 /*- End of function --------------------------------------------------------*/
349 
350 static __inline__ complexi16_t complex_mul_q1_15(const complexi16_t *x, const complexi16_t *y)
351 {
352  complexi16_t z;
353 
354  z.re = (int16_t) (((int32_t) x->re*(int32_t) y->re - (int32_t) x->im*(int32_t) y->im) >> 15);
355  z.im = (int16_t) (((int32_t) x->re*(int32_t) y->im + (int32_t) x->im*(int32_t) y->re) >> 15);
356  return z;
357 }
358 /*- End of function --------------------------------------------------------*/
359 
360 static __inline__ complexi32_t complex_muli32i16(const complexi32_t *x, const complexi16_t *y)
361 {
362  complexi32_t z;
363 
364  z.re = x->re*(int32_t) y->re - x->im*(int32_t) y->im;
365  z.im = x->re*(int32_t) y->im + x->im*(int32_t) y->re;
366  return z;
367 }
368 /*- End of function --------------------------------------------------------*/
369 
370 static __inline__ complexi32_t complex_muli32(const complexi32_t *x, const complexi32_t *y)
371 {
372  complexi32_t z;
373 
374  z.re = x->re*y->re - x->im*y->im;
375  z.im = x->re*y->im + x->im*y->re;
376  return z;
377 }
378 /*- End of function --------------------------------------------------------*/
379 
380 static __inline__ complexf_t complex_divf(const complexf_t *x, const complexf_t *y)
381 {
382  complexf_t z;
383  float f;
384 
385  f = y->re*y->re + y->im*y->im;
386  z.re = ( x->re*y->re + x->im*y->im)/f;
387  z.im = (-x->re*y->im + x->im*y->re)/f;
388  return z;
389 }
390 /*- End of function --------------------------------------------------------*/
391 
392 static __inline__ complex_t complex_div(const complex_t *x, const complex_t *y)
393 {
394  complex_t z;
395  double f;
396 
397  f = y->re*y->re + y->im*y->im;
398  z.re = ( x->re*y->re + x->im*y->im)/f;
399  z.im = (-x->re*y->im + x->im*y->re)/f;
400  return z;
401 }
402 /*- End of function --------------------------------------------------------*/
403 
404 #if defined(HAVE_LONG_DOUBLE)
405 static __inline__ complexl_t complex_divl(const complexl_t *x, const complexl_t *y)
406 {
407  complexl_t z;
408  long double f;
409 
410  f = y->re*y->re + y->im*y->im;
411  z.re = ( x->re*y->re + x->im*y->im)/f;
412  z.im = (-x->re*y->im + x->im*y->re)/f;
413  return z;
414 }
415 /*- End of function --------------------------------------------------------*/
416 #endif
417 
418 static __inline__ complexf_t complex_conjf(const complexf_t *x)
419 {
420  complexf_t z;
421 
422  z.re = x->re;
423  z.im = -x->im;
424  return z;
425 }
426 /*- End of function --------------------------------------------------------*/
427 
428 static __inline__ complex_t complex_conj(const complex_t *x)
429 {
430  complex_t z;
431 
432  z.re = x->re;
433  z.im = -x->im;
434  return z;
435 }
436 /*- End of function --------------------------------------------------------*/
437 
438 #if defined(HAVE_LONG_DOUBLE)
439 static __inline__ complexl_t complex_conjl(const complexl_t *x)
440 {
441  complexl_t z;
442 
443  z.re = x->re;
444  z.im = -x->im;
445  return z;
446 }
447 /*- End of function --------------------------------------------------------*/
448 #endif
449 
450 static __inline__ complexi_t complex_conji(const complexi_t *x)
451 {
452  complexi_t z;
453 
454  z.re = x->re;
455  z.im = -x->im;
456  return z;
457 }
458 /*- End of function --------------------------------------------------------*/
459 
460 static __inline__ complexi16_t complex_conji16(const complexi16_t *x)
461 {
462  complexi16_t z;
463 
464  z.re = x->re;
465  z.im = -x->im;
466  return z;
467 }
468 /*- End of function --------------------------------------------------------*/
469 
470 static __inline__ complexi32_t complex_conji32(const complexi32_t *x)
471 {
472  complexi32_t z;
473 
474  z.re = x->re;
475  z.im = -x->im;
476  return z;
477 }
478 /*- End of function --------------------------------------------------------*/
479 
480 static __inline__ int32_t poweri16(const complexi16_t *x)
481 {
482  return (int32_t) x->re*x->re + (int32_t) x->im*x->im;
483 }
484 /*- End of function --------------------------------------------------------*/
485 
486 static __inline__ float powerf(const complexf_t *x)
487 {
488  return x->re*x->re + x->im*x->im;
489 }
490 /*- End of function --------------------------------------------------------*/
491 
492 static __inline__ double power(const complex_t *x)
493 {
494  return x->re*x->re + x->im*x->im;
495 }
496 /*- End of function --------------------------------------------------------*/
497 
498 #if defined(HAVE_LONG_DOUBLE)
499 static __inline__ long double powerl(const complexl_t *x)
500 {
501  return x->re*x->re + x->im*x->im;
502 }
503 /*- End of function --------------------------------------------------------*/
504 #endif
505 
506 #if defined(__cplusplus)
507 }
508 #endif
509 
510 #endif
511 /*- End of file ------------------------------------------------------------*/
int32_t re
Real part.
Definition: complex.h:102
Definition: complex.h:88
Definition: complex.h:53
double im
Imaginary part.
Definition: complex.h:58
int32_t im
Imaginary part.
Definition: complex.h:104
int16_t re
Real part.
Definition: complex.h:91
Definition: complex.h:77
int im
Imaginary part.
Definition: complex.h:82
float im
Imaginary part.
Definition: complex.h:47
Definition: complex.h:42
int re
Real part.
Definition: complex.h:80
double re
Real part.
Definition: complex.h:56
float re
Real part.
Definition: complex.h:45
Definition: complex.h:99
int16_t im
Imaginary part.
Definition: complex.h:93