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