libdspl-2.0
Библиотека алгоритмов цифровой обработки сигналов
dspl.h
1 /*
2 * Copyright (c) 2015-2019 Sergey Bakhurin
3 * Digital Signal Processing Library [http://dsplib.org]
4 *
5 * This file is part of libdspl-2.0.
6 *
7 * is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * DSPL is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with Foobar. If not, see <http://www.gnu.org/licenses/>.
19 */
20 
21 
22 #ifndef DSPL_H
23 #define DSPL_H
24 
25 
26 
27 #include <math.h>
28 
29 
30 /* math const definition */
31 #ifndef M_PI
32  #define M_PI 3.1415926535897932384626433832795
33 #endif
34 
35 #ifndef M_2PI
36  #define M_2PI 6.283185307179586476925286766559
37 #endif
38 
39 
40 
41 typedef double complex_t[2];
42 
43 
44 
45 
46 typedef struct
47 {
51  int n;
52 } fft_t;
53 
54 
55 #define RAND_TYPE_MRG32K3A 0x00000001
56 #define RAND_TYPE_MT19937 0x00000002
57 
58 #define RAND_MT19937_NN 312
59 typedef struct
60 {
61 
62  double mrg32k3a_seed;
63  double mrg32k3a_x[3];
64  double mrg32k3a_y[3];
65 
66  /* The array for the MT19937 state vector */
67  unsigned long long mt19937_mt[RAND_MT19937_NN];
69 
70  int type;
71 
72 }random_t;
73 
74 
75 
76 
77 #define RE(x) (x[0])
78 #define IM(x) (x[1])
79 
80 
81 #define SQR(x) ((x) * (x))
82 #define ABSSQR(x) ((SQR(RE(x))) + (SQR(IM(x))))
83 #define ABS(x) sqrt((ABSSQR(x)))
84 #define ARG(x) atan2(IM(x), RE(x))
85 
86 #define CMRE(a,b) ((RE(a)) * (RE(b)) - (IM(a)) * (IM(b)))
87 #define CMIM(a,b) ((RE(a)) * (IM(b)) + (IM(a)) * (RE(b)))
88 
89 #define CMCONJRE(a, b) ((RE(a)) * (RE(b)) + (IM(a)) * (IM(b)))
90 #define CMCONJIM(a, b) ((IM(a)) * (RE(b)) - (RE(a)) * (IM(b)))
91 
92 
93 
94 #define RES_OK 0
95 
96 /* Error codes */
97 /* A 0x01xxxxxx*/
98 /* B 0x02xxxxxx*/
99 /* C 0x03xxxxxx*/
100 /* D 0x04xxxxxx*/
101 #define ERROR_DAT_TYPE 0x04012020
102 #define ERROR_DIV_ZERO 0x04102226
103 /* E 0x05xxxxxx*/
104 #define ERROR_ELLIP_MODULE 0x05121315
105 /* F 0x06xxxxxx*/
106 #define ERROR_FFT_CREATE 0x06060318
107 #define ERROR_FFT_SIZE 0x06062021
108 #define ERROR_FILTER_A0 0x06090100
109 #define ERROR_FILTER_APPROX 0x06090116
110 #define ERROR_FILTER_FT 0x06090620
111 #define ERROR_FILTER_ORD 0x06091518
112 #define ERROR_FILTER_ORD_BP 0x06091519
113 #define ERROR_FILTER_RP 0x06091816
114 #define ERROR_FILTER_RS 0x06091819
115 #define ERROR_FILTER_TYPE 0x06092025
116 #define ERROR_FILTER_WP 0x06092316
117 #define ERROR_FILTER_WS 0x06092319
118 #define ERROR_FNAME 0x06140113
119 #define ERROR_FOPEN 0x06151605
120 #define ERROR_FREAD_SIZE 0x06180501
121 #define ERROR_FWRITE_SIZE 0x06231820
122 /* G 0x07xxxxxx*/
123 #define ERROR_GNUPLOT_TERM 0x07161220
124 /* H 0x08xxxxxx*/
125 /* I 0x09xxxxxx*/
126 #define ERROR_INC_SIZE 0x09140319
127 /* J 0x10xxxxxx*/
128 /* K 0x11xxxxxx*/
129 /* L 0x12xxxxxx*/
130 #define ERROR_LAPACK 0x12011601
131 /* M 0x13xxxxxx*/
132 #define ERROR_MATRIX_INDEX 0x13010914
133 #define ERROR_MATRIX_SINGULAR 0x13011914
134 #define ERROR_MATRIX_SIZE 0x13011926
135 /* N 0x14xxxxxx*/
136 #define ERROR_NEGATIVE 0x14050701
137 /* O 0x15xxxxxx*/
138 /* P 0x16xxxxxx*/
139 #define ERROR_POLY_ORD 0x16151518
140 #define ERROR_PTR 0x16201800
141 /* Q 0x17xxxxxx*/
142 /* R 0x18xxxxxx*/
143 #define ERROR_RAND_SIGMA 0x18011909
144 #define ERROR_RAND_TYPE 0x18012009
145 #define ERROR_RESAMPLE_RATIO 0x18051801
146 #define ERROR_RESAMPLE_FRAC_DELAY 0x18050604
147 /* S 0x19xxxxxx*/
148 #define ERROR_SIZE 0x19092605
149 #define ERROR_SYM_TYPE 0x19251320
150 /* T 0x20xxxxxx*/
151 /* U 0x21xxxxxx*/
152 #define ERROR_UNWRAP 0x21142318
153 /* V 0x22xxxxxx*/
154 /* W 0x23xxxxxx*/
155 #define ERROR_WIN_PARAM 0x23091601
156 #define ERROR_WIN_SYM 0x23091925
157 #define ERROR_WIN_TYPE 0x23092025
158 /* X 0x24xxxxxx*/
159 /* Y 0x25xxxxxx*/
160 /* Z 0x26xxxxxx*/
161 
162 #define DAT_MASK 0x00000001
163 #define DAT_DOUBLE 0x00000000
164 #define DAT_COMPLEX 0x00000001
165 
166 #define DSPL_MATRIX_BLOCK 32
167 
168 
169 #define DSPL_SYMMETRIC 0x00000000
170 #define DSPL_PERIODIC 0x00000001
171 
172 #define DSPL_FLAG_DIGITAL 0x00000000
173 #define DSPL_FLAG_ANALOG 0x00000001
174 #define DSPL_FLAG_LOGMAG 0x00000002
175 #define DSPL_FLAG_UNWRAP 0x00000004
176 #define DSPL_FLAG_FFT_SHIFT 0x00000008
177 
178 
179 
180 #define DSPL_WIN_SYM_MASK 0x00000001
181 #define DSPL_WIN_MASK 0x00FFFFFE
182 
183 #define DSPL_WIN_SYMMETRIC DSPL_SYMMETRIC
184 #define DSPL_WIN_PERIODIC DSPL_PERIODIC
185 
186 
187 #define DSPL_WIN_BARTLETT 0x00000004
188 #define DSPL_WIN_BARTLETT_HANN 0x00000008
189 #define DSPL_WIN_BLACKMAN 0x00000010
190 #define DSPL_WIN_BLACKMAN_HARRIS 0x00000040
191 #define DSPL_WIN_BLACKMAN_NUTTALL 0x00000080
192 #define DSPL_WIN_FLAT_TOP 0x00000100
193 #define DSPL_WIN_GAUSSIAN 0x00000400
194 #define DSPL_WIN_HAMMING 0x00000800
195 #define DSPL_WIN_HANN 0x00001000
196 #define DSPL_WIN_LANCZOS 0x00004000
197 #define DSPL_WIN_NUTTALL 0x00008000
198 #define DSPL_WIN_RECT 0x00010000
199 #define DSPL_WIN_COS 0x00040000
200 #define DSPL_WIN_CHEBY 0x00080000
201 #define DSPL_WIN_KAISER 0x00100000
202 
203 
204 #define DSPL_FILTER_TYPE_MASK 0x000000FF
205 #define DSPL_FILTER_LPF 0x00000001
206 #define DSPL_FILTER_HPF 0x00000002
207 #define DSPL_FILTER_BPASS 0x00000004
208 #define DSPL_FILTER_BSTOP 0x00000008
209 
210 #define DSPL_FILTER_APPROX_MASK 0x0000FF00
211 #define DSPL_FILTER_BUTTER 0x00000100
212 #define DSPL_FILTER_CHEBY1 0x00000200
213 #define DSPL_FILTER_CHEBY2 0x00000400
214 #define DSPL_FILTER_ELLIP 0x00000800
215 
216 
217 
218 #define ELLIP_ITER 16
219 #define ELLIP_MAX_ORD 24
220 
221 #define DSPL_VERIF_FAILED 1
222 #define DSPL_VERIF_SUCCESS 0
223 
224 #ifdef __cplusplus
225  extern "C" {
226 #endif
227 
228 
229 
230 #ifdef BUILD_LIB
231  /* Declare DSPL_API for Windows OS */
232  #ifdef WIN_OS
233  #define DSPL_API __declspec(dllexport)
234  #endif /* WIN_OS */
235  /* Declare DSPL_API for LINUX OS */
236  #ifdef LINUX_OS
237  #define DSPL_API
238  #endif /* LINUX_OS */
239 #endif /* BUILD_DLL */
240 
241 #define COMMA ,
242 
243 
244 #ifdef BUILD_LIB
245  #define DECLARE_FUNC(type, fn, param)\
246  type DSPL_API fn(param);
247 #endif
248 
249 #ifndef BUILD_LIB
250  #define DECLARE_FUNC( type, fn, param)\
251  typedef type (*p_##fn)(param);\
252  extern p_##fn fn;
253 
254 #endif
255 
256 
257 /*----------------------------------------------------------------------------*/
258 DECLARE_FUNC(int, acos_cmplx, complex_t*
259  COMMA int
260  COMMA complex_t*);
261 /*----------------------------------------------------------------------------*/
262 DECLARE_FUNC(int, asin_cmplx, complex_t*
263  COMMA int
264  COMMA complex_t*);
265 /*----------------------------------------------------------------------------*/
266 DECLARE_FUNC(int, bessel_i0, double* x
267  COMMA int n
268  COMMA double* y);
269 /*----------------------------------------------------------------------------*/
270 DECLARE_FUNC(int, bilinear, double* bs
271  COMMA double* as
272  COMMA int ord
273  COMMA double* bz
274  COMMA double* az);
275 /*----------------------------------------------------------------------------*/
276 DECLARE_FUNC(int, butter_ap, double
277  COMMA int
278  COMMA double*
279  COMMA double*);
280 /*----------------------------------------------------------------------------*/
281 DECLARE_FUNC(int, butter_ap_zp, int
282  COMMA double
283  COMMA complex_t*
284  COMMA int*
285  COMMA complex_t*
286  COMMA int*);
287 /*----------------------------------------------------------------------------*/
288 DECLARE_FUNC(int, cheby_poly1, double*
289  COMMA int
290  COMMA int
291  COMMA double*);
292 /*----------------------------------------------------------------------------*/
293 DECLARE_FUNC(int, cheby_poly2, double*
294  COMMA int
295  COMMA int
296  COMMA double*);
297 /*----------------------------------------------------------------------------*/
298 DECLARE_FUNC(int, cheby1_ap, double
299  COMMA int
300  COMMA double*
301  COMMA double*);
302 /*----------------------------------------------------------------------------*/
303 DECLARE_FUNC(int, cheby1_ap_zp, int
304  COMMA double
305  COMMA complex_t*
306  COMMA int*
307  COMMA complex_t*
308  COMMA int*);
309 /*----------------------------------------------------------------------------*/
310 DECLARE_FUNC(int, cheby2_ap, double rs
311  COMMA int ord
312  COMMA double* b
313  COMMA double* a);
314 /*----------------------------------------------------------------------------*/
315 DECLARE_FUNC(int, cheby2_ap_wp1, double rp
316  COMMA double rs
317  COMMA int ord
318  COMMA double* b
319  COMMA double* a);
320 /*----------------------------------------------------------------------------*/
321 DECLARE_FUNC(int, cheby2_ap_zp, int
322  COMMA double
323  COMMA complex_t*
324  COMMA int*
325  COMMA complex_t*
326  COMMA int*);
327 /*----------------------------------------------------------------------------*/
328 DECLARE_FUNC(int, cmplx2re, complex_t*
329  COMMA int
330  COMMA double*
331  COMMA double*);
332 /*----------------------------------------------------------------------------*/
333 DECLARE_FUNC(int, concat, void*
334  COMMA size_t
335  COMMA void*
336  COMMA size_t
337  COMMA void*);
338 /*----------------------------------------------------------------------------*/
339 DECLARE_FUNC(int, conv, double*
340  COMMA int
341  COMMA double*
342  COMMA int
343  COMMA double*);
344 /*----------------------------------------------------------------------------*/
345 DECLARE_FUNC(int, conv_cmplx, complex_t*
346  COMMA int
347  COMMA complex_t*
348  COMMA int
349  COMMA complex_t*);
350 /*----------------------------------------------------------------------------*/
351 DECLARE_FUNC(int, conv_fft, double* a
352  COMMA int na
353  COMMA double* b
354  COMMA int nb
355  COMMA fft_t* pfft
356  COMMA int nfft
357  COMMA double* c);
358 /*----------------------------------------------------------------------------*/
359 DECLARE_FUNC(int, conv_fft_cmplx, complex_t* a
360  COMMA int na
361  COMMA complex_t* b
362  COMMA int nb
363  COMMA fft_t* pfft
364  COMMA int nfft
365  COMMA complex_t* c);
366 /*----------------------------------------------------------------------------*/
367 DECLARE_FUNC(int, cos_cmplx, complex_t*
368  COMMA int
369  COMMA complex_t*);
370 /*----------------------------------------------------------------------------*/
371 DECLARE_FUNC(int, decimate, double* x
372  COMMA int n
373  COMMA int d
374  COMMA double* y
375  COMMA int* cnt);
376 /*----------------------------------------------------------------------------*/
377 DECLARE_FUNC(int, decimate_cmplx, complex_t* x
378  COMMA int n
379  COMMA int d
380  COMMA complex_t* y
381  COMMA int* cnt);
382 /*----------------------------------------------------------------------------*/
383 DECLARE_FUNC(int, dft, double*
384  COMMA int
385  COMMA complex_t*);
386 /*----------------------------------------------------------------------------*/
387 DECLARE_FUNC(int, dft_cmplx, complex_t*
388  COMMA int
389  COMMA complex_t*);
390 /*----------------------------------------------------------------------------*/
391 DECLARE_FUNC(double, dmod, double
392  COMMA double);
393 /*----------------------------------------------------------------------------*/
394 DECLARE_FUNC(void, dspl_info, void);
395 /*----------------------------------------------------------------------------*/
396 DECLARE_FUNC(int, ellip_acd, double* w
397  COMMA int n
398  COMMA double k
399  COMMA double* u);
400 /*----------------------------------------------------------------------------*/
401 DECLARE_FUNC(int, ellip_acd_cmplx, complex_t* w
402  COMMA int n
403  COMMA double k
404  COMMA complex_t* u);
405 /*----------------------------------------------------------------------------*/
406 DECLARE_FUNC(int, ellip_ap, double rp
407  COMMA double rs
408  COMMA int ord
409  COMMA double* b
410  COMMA double* a);
411 /*----------------------------------------------------------------------------*/
412 DECLARE_FUNC(int, ellip_ap_zp, int ord
413  COMMA double rp
414  COMMA double rs
415  COMMA complex_t* z
416  COMMA int* nz
417  COMMA complex_t* p
418  COMMA int* np);
419 /*----------------------------------------------------------------------------*/
420 DECLARE_FUNC(int, ellip_asn, double* w
421  COMMA int n
422  COMMA double k
423  COMMA double* u);
424 /*----------------------------------------------------------------------------*/
425 DECLARE_FUNC(int, ellip_asn_cmplx, complex_t* w
426  COMMA int n
427  COMMA double k
428  COMMA complex_t* u);
429 /*----------------------------------------------------------------------------*/
430 DECLARE_FUNC(int, ellip_cd, double* u
431  COMMA int n
432  COMMA double k
433  COMMA double* y);
434 /*----------------------------------------------------------------------------*/
435 DECLARE_FUNC(int, ellip_cd_cmplx, complex_t* u
436  COMMA int n
437  COMMA double k
438  COMMA complex_t* y);
439 /*----------------------------------------------------------------------------*/
440 DECLARE_FUNC(int, ellip_landen, double k
441  COMMA int n
442  COMMA double* y);
443 /*----------------------------------------------------------------------------*/
444 DECLARE_FUNC(int, ellip_modulareq, double rp
445  COMMA double rs
446  COMMA int ord
447  COMMA double* k);
448 /*----------------------------------------------------------------------------*/
449 DECLARE_FUNC(int, ellip_rat, double* w
450  COMMA int n
451  COMMA int ord
452  COMMA double k
453  COMMA double* u);
454 /*----------------------------------------------------------------------------*/
455 DECLARE_FUNC(int, ellip_sn, double* u
456  COMMA int n
457  COMMA double k
458  COMMA double* y);
459 /*----------------------------------------------------------------------------*/
460 DECLARE_FUNC(int, ellip_sn_cmplx, complex_t* u
461  COMMA int n
462  COMMA double k
463  COMMA complex_t* y);
464 /*----------------------------------------------------------------------------*/
465 DECLARE_FUNC(int, farrow_lagrange, double*
466  COMMA int
467  COMMA double
468  COMMA double
469  COMMA double
470  COMMA double**
471  COMMA int*);
472 /*----------------------------------------------------------------------------*/
473 DECLARE_FUNC(int, farrow_spline, double*
474  COMMA int
475  COMMA double
476  COMMA double
477  COMMA double
478  COMMA double**
479  COMMA int*);
480 /*----------------------------------------------------------------------------*/
481 DECLARE_FUNC(int, fft, double*
482  COMMA int
483  COMMA fft_t*
484  COMMA complex_t* );
485 /*----------------------------------------------------------------------------*/
486 DECLARE_FUNC(int, fft_cmplx, complex_t*
487  COMMA int
488  COMMA fft_t*
489  COMMA complex_t* );
490 /*----------------------------------------------------------------------------*/
491 DECLARE_FUNC(int, fft_create, fft_t*
492  COMMA int);
493 /*----------------------------------------------------------------------------*/
494 DECLARE_FUNC(void, fft_free, fft_t*);
495 /*----------------------------------------------------------------------------*/
496 DECLARE_FUNC(int, fft_mag, double* x
497  COMMA int n
498  COMMA fft_t* pfft
499  COMMA double fs
500  COMMA int flag
501  COMMA double* mag
502  COMMA double* freq);
503 /*----------------------------------------------------------------------------*/
504 DECLARE_FUNC(int, fft_mag_cmplx, complex_t* x
505  COMMA int n
506  COMMA fft_t* pfft
507  COMMA double fs
508  COMMA int flag
509  COMMA double* mag
510  COMMA double* freq);
511 /*----------------------------------------------------------------------------*/
512 DECLARE_FUNC(int, fft_shift, double*
513  COMMA int n
514  COMMA double*);
515 /*----------------------------------------------------------------------------*/
516 DECLARE_FUNC(int, fft_shift_cmplx, complex_t*
517  COMMA int
518  COMMA complex_t*);
519 /*----------------------------------------------------------------------------*/
520 DECLARE_FUNC(int, filter_freq_resp, double* b
521  COMMA double* a
522  COMMA int ord
523  COMMA double* w
524  COMMA int n
525  COMMA int flag
526  COMMA double* mag
527  COMMA double* phi
528  COMMA double* tau);
529 /*----------------------------------------------------------------------------*/
530 DECLARE_FUNC(int, filter_iir, double*
531  COMMA double*
532  COMMA int
533  COMMA double*
534  COMMA int
535  COMMA double*);
536 /*----------------------------------------------------------------------------*/
537 DECLARE_FUNC(double, filter_ws1, int ord
538  COMMA double rp
539  COMMA double rs
540  COMMA int type);
541 /*----------------------------------------------------------------------------*/
542 DECLARE_FUNC(int, filter_zp2ab, complex_t*
543  COMMA int
544  COMMA complex_t*
545  COMMA int
546  COMMA int
547  COMMA double*
548  COMMA double*);
549 /*----------------------------------------------------------------------------*/
550 DECLARE_FUNC(int, find_max_abs, double* a
551  COMMA int n
552  COMMA double* m
553  COMMA int* ind);
554 /*----------------------------------------------------------------------------*/
555 DECLARE_FUNC(int, fir_linphase, int ord
556  COMMA double w0
557  COMMA double w1
558  COMMA int filter_type
559  COMMA int wintype
560  COMMA double winparam
561  COMMA double* h);
562 /*----------------------------------------------------------------------------*/
563 DECLARE_FUNC(int, flipip, double*
564  COMMA int);
565 /*----------------------------------------------------------------------------*/
566 DECLARE_FUNC(int, flipip_cmplx, complex_t*
567  COMMA int);
568 /*----------------------------------------------------------------------------*/
569 DECLARE_FUNC(int, fourier_integral_cmplx, double* t
570  COMMA complex_t* s
571  COMMA int nt
572  COMMA int nw
573  COMMA double* w
574  COMMA complex_t* y);
575 /*----------------------------------------------------------------------------*/
576 DECLARE_FUNC(int, fourier_series_dec, double*
577  COMMA double*
578  COMMA int
579  COMMA double
580  COMMA int
581  COMMA double*
582  COMMA complex_t*);
583 /*----------------------------------------------------------------------------*/
584 DECLARE_FUNC(int, fourier_series_dec_cmplx, double* t
585  COMMA complex_t* s
586  COMMA int nt
587  COMMA double period
588  COMMA int nw
589  COMMA double* w
590  COMMA complex_t* y);
591 /*----------------------------------------------------------------------------*/
592 DECLARE_FUNC(int, fourier_series_rec, double*
593  COMMA complex_t*
594  COMMA int
595  COMMA double*
596  COMMA int
597  COMMA complex_t*);
598 /*----------------------------------------------------------------------------*/
599 DECLARE_FUNC(int, freqs, double*
600  COMMA double*
601  COMMA int
602  COMMA double*
603  COMMA int
604  COMMA complex_t*);
605 /*----------------------------------------------------------------------------*/
606 DECLARE_FUNC(int, freqs_cmplx, double* b
607  COMMA double* a
608  COMMA int ord
609  COMMA complex_t* s
610  COMMA int n
611  COMMA complex_t* h);
612 /*----------------------------------------------------------------------------*/
613 DECLARE_FUNC(int, freqs2time, double*
614  COMMA double*
615  COMMA int
616  COMMA double
617  COMMA int
618  COMMA fft_t*
619  COMMA double*
620  COMMA double*);
621 /*----------------------------------------------------------------------------*/
622 DECLARE_FUNC(int, freqz, double*
623  COMMA double*
624  COMMA int
625  COMMA double*
626  COMMA int
627  COMMA complex_t*);
628 /*----------------------------------------------------------------------------*/
629 DECLARE_FUNC(int, gnuplot_script, int argc
630  COMMA char* argv[]
631  COMMA char* fn);
632 /*----------------------------------------------------------------------------*/
633 DECLARE_FUNC(int, goertzel, double*
634  COMMA int
635  COMMA int*
636  COMMA int
637  COMMA complex_t*);
638 /*----------------------------------------------------------------------------*/
639 DECLARE_FUNC(int, goertzel_cmplx, complex_t*
640  COMMA int
641  COMMA int*
642  COMMA int
643  COMMA complex_t*);
644 /*----------------------------------------------------------------------------*/
645 DECLARE_FUNC(int, histogram, double* x
646  COMMA int n
647  COMMA int nh
648  COMMA double* pedges
649  COMMA double* ph);
650 /*----------------------------------------------------------------------------*/
651 DECLARE_FUNC(int, histogram_norm, double* y
652  COMMA int n
653  COMMA int nh
654  COMMA double* x
655  COMMA double* w);
656 /*----------------------------------------------------------------------------*/
657 DECLARE_FUNC(int, idft_cmplx, complex_t*
658  COMMA int
659  COMMA complex_t*);
660 /*----------------------------------------------------------------------------*/
661 DECLARE_FUNC(int, ifft_cmplx, complex_t*
662  COMMA int
663  COMMA fft_t*
664  COMMA complex_t* );
665 /*----------------------------------------------------------------------------*/
666 DECLARE_FUNC(int, iir, double rp
667  COMMA double rs
668  COMMA int ord
669  COMMA double w0
670  COMMA double w1
671  COMMA int type
672  COMMA double* b
673  COMMA double* a);
674 /*----------------------------------------------------------------------------*/
675 DECLARE_FUNC(int, linspace, double
676  COMMA double
677  COMMA int
678  COMMA int
679  COMMA double*);
680 /*----------------------------------------------------------------------------*/
681 DECLARE_FUNC(int, log_cmplx, complex_t*
682  COMMA int
683  COMMA complex_t*);
684 /*----------------------------------------------------------------------------*/
685 DECLARE_FUNC(int, logspace, double
686  COMMA double
687  COMMA int
688  COMMA int
689  COMMA double*);
690 /*----------------------------------------------------------------------------*/
691 DECLARE_FUNC(int, low2bp, double* b
692  COMMA double* a
693  COMMA int ord
694  COMMA double w0
695  COMMA double wpl
696  COMMA double wph
697  COMMA double* beta
698  COMMA double* alpha);
699 /*----------------------------------------------------------------------------*/
700 DECLARE_FUNC(int, low2bs, double* b
701  COMMA double* a
702  COMMA int ord
703  COMMA double w0
704  COMMA double wsl
705  COMMA double wsh
706  COMMA double* beta
707  COMMA double* alpha);
708 /*----------------------------------------------------------------------------*/
709 DECLARE_FUNC(int, low2high, double* b
710  COMMA double* a
711  COMMA int ord
712  COMMA double w0
713  COMMA double w1
714  COMMA double* beta
715  COMMA double* alpha);
716 /*----------------------------------------------------------------------------*/
717 DECLARE_FUNC(int, low2low, double* b
718  COMMA double* a
719  COMMA int ord
720  COMMA double w0
721  COMMA double w1
722  COMMA double* beta
723  COMMA double* alpha);
724 /*----------------------------------------------------------------------------*/
725 DECLARE_FUNC(int, matrix_eig_cmplx, complex_t* a
726  COMMA int n
727  COMMA complex_t* v
728  COMMA int* info);
729 /*----------------------------------------------------------------------------*/
730 DECLARE_FUNC(int, matrix_eye, double* a
731  COMMA int n
732  COMMA int m);
733 /*----------------------------------------------------------------------------*/
734 DECLARE_FUNC(int, matrix_eye_cmplx, complex_t* a
735  COMMA int n
736  COMMA int m);
737 /*----------------------------------------------------------------------------*/
738 DECLARE_FUNC(int, matrix_mul, double* a
739  COMMA int na
740  COMMA int ma
741  COMMA double* b
742  COMMA int nb
743  COMMA int mb
744  COMMA double* c);
745 /*----------------------------------------------------------------------------*/
746 DECLARE_FUNC(int, matrix_print, double* a
747  COMMA int n
748  COMMA int m
749  COMMA const char* name
750  COMMA const char* format);
751 /*----------------------------------------------------------------------------*/
752 DECLARE_FUNC(int, matrix_print_cmplx, complex_t* a
753  COMMA int n
754  COMMA int m
755  COMMA const char* name
756  COMMA const char* format);
757 /*----------------------------------------------------------------------------*/
758 DECLARE_FUNC(int, matrix_transpose, double* a
759  COMMA int n
760  COMMA int m
761  COMMA double* b);
762 /*----------------------------------------------------------------------------*/
763 DECLARE_FUNC(int, matrix_transpose_cmplx, complex_t* a
764  COMMA int n
765  COMMA int m
766  COMMA complex_t* b);
767 /*----------------------------------------------------------------------------*/
768 DECLARE_FUNC(int, matrix_transpose_hermite, complex_t* a
769  COMMA int n
770  COMMA int m
771  COMMA complex_t* b);
772 /*----------------------------------------------------------------------------*/
773 DECLARE_FUNC(int, minmax, double* x
774  COMMA int n
775  COMMA double* xmin
776  COMMA double* xmax);
777 /*----------------------------------------------------------------------------*/
778 DECLARE_FUNC(int, poly_z2a_cmplx, complex_t*
779  COMMA int
780  COMMA int
781  COMMA complex_t*);
782 /*----------------------------------------------------------------------------*/
783 DECLARE_FUNC(int, polyval, double*
784  COMMA int
785  COMMA double*
786  COMMA int
787  COMMA double*);
788 /*----------------------------------------------------------------------------*/
789 DECLARE_FUNC(int, polyval_cmplx, complex_t*
790  COMMA int
791  COMMA complex_t*
792  COMMA int
793  COMMA complex_t*);
794 /*----------------------------------------------------------------------------*/
795 DECLARE_FUNC(int, randn, double*
796  COMMA int
797  COMMA double
798  COMMA double
799  COMMA random_t* prnd);
800 /*----------------------------------------------------------------------------*/
801 DECLARE_FUNC(int, random_init, random_t* prnd
802  COMMA int type
803  COMMA void* seed);
804 /*----------------------------------------------------------------------------*/
805 DECLARE_FUNC(int, randu, double*
806  COMMA int
807  COMMA random_t* prnd);
808 /*----------------------------------------------------------------------------*/
809 DECLARE_FUNC(int, ratcompos, double* b
810  COMMA double* a
811  COMMA int n
812  COMMA double* c
813  COMMA double* d
814  COMMA int p
815  COMMA double* beta
816  COMMA double* alpha);
817 /*----------------------------------------------------------------------------*/
818 DECLARE_FUNC(int, re2cmplx, double*
819  COMMA int
820  COMMA complex_t*);
821 /*----------------------------------------------------------------------------*/
822 DECLARE_FUNC(int, readbin, char* fn
823  COMMA void** x
824  COMMA int* k
825  COMMA int* dtype);
826 /*----------------------------------------------------------------------------*/
827 DECLARE_FUNC(int, signal_pimp, double*
828  COMMA size_t
829  COMMA double
830  COMMA double
831  COMMA double
832  COMMA double
833  COMMA double*);
834 /*----------------------------------------------------------------------------*/
835 DECLARE_FUNC(int, signal_saw, double* t
836  COMMA size_t n
837  COMMA double amp
838  COMMA double dt
839  COMMA double period
840  COMMA double* y);
841 /*----------------------------------------------------------------------------*/
842 DECLARE_FUNC(int, sin_cmplx, complex_t*
843  COMMA int
844  COMMA complex_t*);
845 /*----------------------------------------------------------------------------*/
846 DECLARE_FUNC(int, sinc, double* x
847  COMMA int n
848  COMMA double a
849  COMMA double* y);
850 /*----------------------------------------------------------------------------*/
851 DECLARE_FUNC(int, sine_int, double* x
852  COMMA int n
853  COMMA double* si);
854 /*----------------------------------------------------------------------------*/
855 DECLARE_FUNC(int, sqrt_cmplx, complex_t*
856  COMMA int
857  COMMA complex_t*);
858 /*----------------------------------------------------------------------------*/
859 DECLARE_FUNC(int, trapint, double*
860  COMMA double*
861  COMMA int
862  COMMA double*);
863 /*----------------------------------------------------------------------------*/
864 DECLARE_FUNC(int, trapint_cmplx, double*
865  COMMA complex_t*
866  COMMA int
867  COMMA complex_t*);
868 /*----------------------------------------------------------------------------*/
869 DECLARE_FUNC(int, unwrap, double*
870  COMMA int
871  COMMA double
872  COMMA double);
873 /*----------------------------------------------------------------------------*/
874 DECLARE_FUNC(int, vector_dot, double* x
875  COMMA double* y
876  COMMA int n
877  COMMA double* p);
878 /*----------------------------------------------------------------------------*/
879 DECLARE_FUNC(int, verif, double* x
880  COMMA double* y
881  COMMA size_t n
882  COMMA double eps
883  COMMA double* err);
884 /*----------------------------------------------------------------------------*/
885 DECLARE_FUNC(int, verif_cmplx, complex_t* x
886  COMMA complex_t* y
887  COMMA size_t n
888  COMMA double eps
889  COMMA double* err);
890 /*----------------------------------------------------------------------------*/
891 DECLARE_FUNC(int, window, double* w
892  COMMA int n
893  COMMA int win_type
894  COMMA double param);
895 /*----------------------------------------------------------------------------*/
896 DECLARE_FUNC(int, writebin, void*
897  COMMA int
898  COMMA int
899  COMMA char*);
900 /*----------------------------------------------------------------------------*/
901 DECLARE_FUNC(int, writetxt, double*
902  COMMA double*
903  COMMA int
904  COMMA char*);
905 /*----------------------------------------------------------------------------*/
906 DECLARE_FUNC(int, writetxt_3d, double* x
907  COMMA int nx
908  COMMA double* y
909  COMMA int ny
910  COMMA double* z
911  COMMA char* fn);
912 /*----------------------------------------------------------------------------*/
913 DECLARE_FUNC(int, writetxt_3dline, double* x
914  COMMA double* y
915  COMMA double* z
916  COMMA int n
917  COMMA char* fn);
918 /*----------------------------------------------------------------------------*/
919 DECLARE_FUNC(int, writetxt_cmplx_im, double*
920  COMMA complex_t*
921  COMMA int
922  COMMA char*);
923 /*----------------------------------------------------------------------------*/
924 DECLARE_FUNC(int, writetxt_cmplx_re, double*
925  COMMA complex_t*
926  COMMA int
927  COMMA char*);
928 /*----------------------------------------------------------------------------*/
929 
930 #ifdef __cplusplus
931  }
932 #endif
933 
934 
935 void* dspl_load();
936 void dspl_free(void* handle);
937 
938 
939 
940 #endif /* DSPL_H */
941 
int decimate(double *x, int n, int d, double *y, int *cnt)
Децимация вещественного вектора данных
Definition: array.c:139
complex_t * w
Definition: dspl.h:48
int low2low(double *b, double *a, int ord, double w0, double w1, double *beta, double *alpha)
Частотное преобразование ФНЧ-ФНЧ
Definition: filter_ft.c:179
int flipip_cmplx(complex_t *x, int n)
Функция отражения комплексного вектора x
Definition: array.c:419
Структура данных объекта быстрого преобразования Фурье
Definition: dspl.h:46
double complex_t[2]
Описание комплексного типа данных.
Definition: dspl.h:41
int concat(void *a, size_t na, void *b, size_t nb, void *c)
Конкатенация двух массивов данных
Definition: array.c:74
int butter_ap(double rp, int ord, double *b, double *a)
Расчет передаточной характеристики аналогового нормированного ФНЧ Баттерворта.
Definition: filter_ap.c:33
int filter_freq_resp(double *b, double *a, int ord, double *w, int n, int flag, double *mag, double *phi, double *tau)
Расчет амплитудно-частотной (АЧХ), фазочастотной характеристик (ФЧХ), а также группового времени запа...
Definition: filter_an.c:35
int log_cmplx(complex_t *x, int n, complex_t *y)
Натуральный логарифм комплексного аргумента x
Definition: complex.c:374
int fft_cmplx(complex_t *x, int n, fft_t *pfft, complex_t *y)
Быстрое преобразование Фурье комплексного сигнала
Definition: fft.c:92
int decimate_cmplx(complex_t *x, int n, int d, complex_t *y, int *cnt)
Децимация комплексного вектора данных
Definition: array.c:214
int fourier_series_dec(double *t, double *s, int nt, double period, int nw, double *w, complex_t *y)
Расчет коэффициентов разложения в ряд Фурье
int writetxt(double *x, double *y, int n, char *fn)
Сохранить вещественные данные в текстовый файл
Definition: inout.c:236
int ellip_landen(double k, int n, double *y)
Расчет коэффициентов ряда полного эллиптического интеграла.
Definition: ellipj.c:545
int ratcompos(double *b, double *a, int n, double *c, double *d, int p, double *beta, double *alpha)
Рациональная композиця
Definition: filter_ft.c:204
int freqs(double *b, double *a, int ord, double *w, int n, complex_t *h)
Расчет комплексного коэффициента передачи аналогового фильтра.
Definition: filter_an.c:140
int ellip_acd(double *w, int n, double k, double *u)
Обратная эллиптическая функция Якоби вещественного аргумента
Definition: ellipj.c:60
int ellip_asn(double *w, int n, double k, double *u)
Обратная эллиптическая функция Якоби вещественного аргумента
Definition: ellipj.c:210
int sinc(double *x, int n, double a, double *y)
Функция .
Definition: math.c:127
int filter_iir(double *b, double *a, int ord, double *x, int n, double *y)
Фильтрация вещественного сигнала вещественным БИХ-фильтром
Definition: conv.c:577
int sin_cmplx(complex_t *x, int n, complex_t *y)
Синус комплексного аргумента x
Definition: complex.c:513
complex_t * t1
Definition: dspl.h:50
int verif_cmplx(complex_t *x, complex_t *y, size_t n, double eps, double *err)
Верификация комплексных массивов
Definition: array.c:569
int low2high(double *b, double *a, int ord, double w0, double w1, double *beta, double *alpha)
Частотное преобразование ФНЧ-ФВЧ
Definition: filter_ft.c:151
int bessel_i0(double *x, int n, double *y)
Модифицированная функция Бесселя первого рода .
Definition: math.c:36
int freqz(double *b, double *a, int ord, double *w, int n, complex_t *h)
Расчет комплексного коэффициента передачи цифрового фильтра.
Definition: filter_an.c:445
int fft_shift(double *x, int n, double *y)
Перестановка спектральных отсчетов дискретного преобразования Фурье
Definition: fft.c:437
complex_t * t0
Definition: dspl.h:49
int re2cmplx(double *x, int n, complex_t *y)
Преобразование массива вещественных данных в массив комплексных данных.
Definition: complex.c:441
int logspace(double x0, double x1, int n, int type, double *x)
Функция заполняет массив значениями логарифмической шкале
Definition: fillarray.c:68
int find_max_abs(double *a, int n, double *m, int *ind)
Поиск максимального по модулю элемента вещественного вектора a
Definition: array.c:280
int bilinear(double *bs, double *as, int ord, double *bz, double *az)
Билинейное преобразование передаточной характеристики аналогового фильтра , в передаточную характерис...
Definition: filter_iir.c:80
int ifft_cmplx(complex_t *x, int n, fft_t *pfft, complex_t *y)
Обратное быстрое преобразование Фурье
Definition: fft.c:30
int flipip(double *x, int n)
Функция отражения вещественного вектора x
Definition: array.c:353
double mrg32k3a_seed
Definition: dspl.h:62
int ellip_cd_cmplx(complex_t *u, int n, double k, complex_t *y)
Эллиптическая функция Якоби комплексного аргумента
Definition: ellipj.c:424
int gnuplot_script(int argc, char *argv[], char *fn)
Функция вызова скрипта пакета GNUPLOT для построения графика.
Definition: inout.c:48
int idft_cmplx(complex_t *x, int n, complex_t *y)
Обратное дискретное преобразование Фурье комплексного спектра.
Definition: dft.c:277
int cmplx2re(complex_t *x, int n, double *re, double *im)
Преобразование массива комплексных данных в два массива вещественных данных, содержащих реальную и мн...
Definition: complex.c:222
int writebin(void *x, int n, int dtype, char *fn)
Сохранить данные в бинарный файл
Definition: inout.c:163
int conv(double *a, int na, double *b, int nb, double *c)
Линейная свертка двух вещественных векторов
Definition: conv.c:84
int cheby1_ap(double rp, int ord, double *b, double *a)
Расчет передаточной характеристики аналогового нормированного ФНЧ Чебышёва первого рода.
Definition: filter_ap.c:129
int sqrt_cmplx(complex_t *x, int n, complex_t *y)
Квадратный корень из комплексного вектора x (поэлементный).
Definition: complex.c:588
int ellip_cd(double *u, int n, double k, double *y)
Эллиптическая функция Якоби вещественного аргумента
Definition: ellipj.c:360
int cheby_poly2(double *x, int n, int ord, double *y)
Многочлен Чебышева второго рода порядка ord
Definition: cheby.c:174
Definition: dspl.h:59
int fourier_series_rec(double *w, complex_t *s, int nw, double *t, int nt, complex_t *y)
Восстановление сигнала при усечении ряда Фурье
int ellip_sn(double *u, int n, double k, double *y)
Эллиптическая функция Якоби вещественного аргумента
Definition: ellipj.c:697
int window(double *w, int n, int win_type, double param)
Расчет функции оконного взвешивания
Definition: win.c:33
int ellip_acd_cmplx(complex_t *w, int n, double k, complex_t *u)
Обратная эллиптическая функция Якоби комплексного аргумента
Definition: ellipj.c:125
int conv_cmplx(complex_t *a, int na, complex_t *b, int nb, complex_t *c)
Линейная свертка двух комплексных векторов
Definition: conv.c:181
int goertzel_cmplx(complex_t *x, int n, int *ind, int k, complex_t *y)
Алгоритм Герцеля для расчета отдельных спектральных отсчетов дискретного преобразования Фурье комплек...
Definition: goertzel.c:70
int polyval(double *a, int ord, double *x, int n, double *y)
Расчет вещественного полинома
Definition: polyval.c:69
int dft_cmplx(complex_t *x, int n, complex_t *y)
Дискретное преобразование Фурье комплексного сигнала.
Definition: dft.c:181
int type
Definition: dspl.h:70
int n
Definition: dspl.h:51
int sine_int(double *x, int n, double *si)
Функция интегрального синуса
Definition: math.c:156
int linspace(double x0, double x1, int n, int type, double *x)
Функция заполняет массив линейно-нарастающими, равноотстоящими значениями от x0 до x1
Definition: fillarray.c:31
int cos_cmplx(complex_t *x, int n, complex_t *y)
Косинус комплексного аргумента x
Definition: complex.c:299
void fft_free(fft_t *pfft)
Очистить структуру fft_t алгоритма БПФ
Definition: fft.c:296
int cheby_poly1(double *x, int n, int ord, double *y)
Многочлен Чебышева первого рода порядка ord
Definition: cheby.c:78
int farrow_lagrange(double *s, int n, double p, double q, double frd, double **y, int *ny)
Передискретизация вещественного сигнала на основе полиномиальной Лагранжевой интерполяции.
Definition: resampling.c:35
int acos_cmplx(complex_t *x, int n, complex_t *y)
Арккосинус комплексного аргумента x
Definition: complex.c:80
int polyval_cmplx(complex_t *a, int ord, complex_t *x, int n, complex_t *y)
Расчет комплексного полинома
Definition: polyval.c:96
int mt19937_mti
Definition: dspl.h:68
int ellip_asn_cmplx(complex_t *w, int n, double k, complex_t *u)
Обратная эллиптическая функция Якоби комплексного аргумента
Definition: ellipj.c:275
int dft(double *x, int n, complex_t *y)
Дискретное преобразование Фурье вещественного сигнала.
Definition: dft.c:89
int verif(double *x, double *y, size_t n, double eps, double *err)
Верификация вещественных массивов
Definition: array.c:487
int cheby2_ap(double rs, int ord, double *b, double *a)
Расчет передаточной характеристики аналогового нормированного ФНЧ Чебышёва второго рода.
Definition: filter_ap.c:239
int ellip_sn_cmplx(complex_t *u, int n, double k, complex_t *y)
Эллиптическая функция Якоби комплексного аргумента
Definition: ellipj.c:758
int asin_cmplx(complex_t *x, int n, complex_t *y)
Арксинус комплексного аргумента x
Definition: complex.c:151
int fft_create(fft_t *pfft, int n)
Заполнение структуры fft_t для алгоритма БПФ
Definition: fft.c:208
int goertzel(double *x, int n, int *ind, int k, complex_t *y)
Алгоритм Герцеля для расчета отдельных спектральных отсчетов дискретного преобразования Фурье веществ...
Definition: goertzel.c:29
int farrow_spline(double *s, int n, double p, double q, double frd, double **y, int *ny)
Передискретизация вещественного сигнала на основе сплайн интерполяции.
Definition: resampling.c:115
int fft(double *x, int n, fft_t *pfft, complex_t *y)
Быстрое преобразование Фурье вещественного сигнала
Definition: fft.c:67