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 #include <math.h>
26 
27 /* math const definition */
28 #ifndef M_PI
29  #define M_PI 3.1415926535897932384626433832795
30 #endif
31 
32 #ifndef M_2PI
33  #define M_2PI 6.283185307179586476925286766559
34 #endif
35 
36 
37 #ifdef DOXYGEN_ENGLISH
38 
60 #endif
61 #ifdef DOXYGEN_RUSSIAN
62 
85 #endif
86 typedef double complex_t[2];
87 
88 
89 
90 #ifdef DOXYGEN_ENGLISH
91 
158 #endif
159 #ifdef DOXYGEN_RUSSIAN
160 
225 #endif
226 typedef struct
227 {
231  int n;
232 } fft_t;
233 
234 
235 
236 #define RAND_TYPE_MRG32K3A 0x00000001
237 #define RAND_TYPE_MT19937 0x00000002
238 #define RAND_MT19937_NN 312
239 
240 #ifdef DOXYGEN_ENGLISH
241 
242 #endif
243 #ifdef DOXYGEN_RUSSIAN
244 
287 #endif
288 typedef struct
289 {
290 
292  double mrg32k3a_x[3];
293  double mrg32k3a_y[3];
294 
295  /* The array for the MT19937 state vector */
296  unsigned long long mt19937_mt[RAND_MT19937_NN];
298 
299  int type;
300 
301 }random_t;
302 
303 
304 
305 #ifdef DOXYGEN_ENGLISH
306 
331 #endif
332 #ifdef DOXYGEN_RUSSIAN
333 
358 #endif
359 #define RE(x) (x[0])
360 
361 
362 
363 #ifdef DOXYGEN_ENGLISH
364 
390 #endif
391 #ifdef DOXYGEN_RUSSIAN
392 
416 #endif
417 #define IM(x) (x[1])
418 
419 
420 
421 #define SQR(x) ((x) * (x))
422 
423 
424 #ifdef DOXYGEN_ENGLISH
425 
448 #endif
449 #ifdef DOXYGEN_RUSSIAN
450 
472 #endif
473 #define ABSSQR(x) ((SQR(RE(x))) + (SQR(IM(x))))
474 
475 
476 
477 
478 #define ABS(x) sqrt((ABSSQR(x)))
479 
480 
481 #define ARG(x) atan2(IM(x), RE(x))
482 
483 
484 #define CMRE(a,b) ((RE(a)) * (RE(b)) - (IM(a)) * (IM(b)))
485 
486 
487 #define CMIM(a,b) ((RE(a)) * (IM(b)) + (IM(a)) * (RE(b)))
488 
489 
490 #define CMCONJRE(a, b) ((RE(a)) * (RE(b)) + (IM(a)) * (IM(b)))
491 
492 
493 #define CMCONJIM(a, b) ((IM(a)) * (RE(b)) - (RE(a)) * (IM(b)))
494 
495 
496 
497 #define RES_OK 0
498 
499 /* Error codes */
500 /* A 0x01xxxxxx*/
501 #define ERROR_ARG_PARAM 0x01180716
502 /* B 0x02xxxxxx*/
503 /* C 0x03xxxxxx*/
504 /* D 0x04xxxxxx*/
505 #define ERROR_DAT_TYPE 0x04012020
506 #define ERROR_DIV_ZERO 0x04102226
507 /* E 0x05xxxxxx*/
508 #define ERROR_ELLIP_MODULE 0x05121315
509 /* F 0x06xxxxxx*/
510 #define ERROR_FFT_SIZE 0x06062021
511 #define ERROR_FILTER_A0 0x06090100
512 #define ERROR_FILTER_APPROX 0x06090116
513 #define ERROR_FILTER_FT 0x06090620
514 #define ERROR_FILTER_ORD 0x06091518
515 #define ERROR_FILTER_ORD_BP 0x06091519
516 #define ERROR_FILTER_RP 0x06091816
517 #define ERROR_FILTER_RS 0x06091819
518 #define ERROR_FILTER_TYPE 0x06092025
519 #define ERROR_FILTER_WP 0x06092316
520 #define ERROR_FILTER_WS 0x06092319
521 #define ERROR_FNAME 0x06140113
522 #define ERROR_FOPEN 0x06151605
523 #define ERROR_FREAD_SIZE 0x06180501
524 #define ERROR_FWRITE_SIZE 0x06231820
525 /* G 0x07xxxxxx*/
526 #define ERROR_GNUPLOT_CREATE 0x07161203
527 #define ERROR_GNUPLOT_FNPNG 0x07161206
528 #define ERROR_GNUPLOT_TERM 0x07161220
529 /* H 0x08xxxxxx*/
530 /* I 0x09xxxxxx*/
531 /* J 0x10xxxxxx*/
532 /* K 0x11xxxxxx*/
533 /* L 0x12xxxxxx*/
534 #define ERROR_LAPACK 0x12011601
535 /* M 0x13xxxxxx*/
536 #define ERROR_MALLOC 0x13011212
537 #define ERROR_MATRIX_SIZE 0x13011926
538 #define ERROR_MIN_MAX 0x13091413
539 /* N 0x14xxxxxx*/
540 #define ERROR_NEGATIVE 0x14050701
541 /* O 0x15xxxxxx*/
542 /* P 0x16xxxxxx*/
543 #define ERROR_POLY_AN 0x16150114
544 #define ERROR_POLY_ORD 0x16151518
545 #define ERROR_PTR 0x16201800
546 /* Q 0x17xxxxxx*/
547 /* R 0x18xxxxxx*/
548 #define ERROR_RAND_SIGMA 0x18011909
549 #define ERROR_RAND_TYPE 0x18012009
550 #define ERROR_RESAMPLE_RATIO 0x18051801
551 #define ERROR_RESAMPLE_FRAC_DELAY 0x18050604
552 /* S 0x19xxxxxx*/
553 #define ERROR_SIZE 0x19092605
554 #define ERROR_SYM_TYPE 0x19251320
555 /* T 0x20xxxxxx*/
556 /* U 0x21xxxxxx*/
557 #define ERROR_UNWRAP 0x21142318
558 /* V 0x22xxxxxx*/
559 /* W 0x23xxxxxx*/
560 #define ERROR_WIN_PARAM 0x23091601
561 #define ERROR_WIN_SYM 0x23091925
562 #define ERROR_WIN_TYPE 0x23092025
563 /* X 0x24xxxxxx*/
564 #define ERROR_XCORR_FLAG 0x24031518
565 /* Y 0x25xxxxxx*/
566 /* Z 0x26xxxxxx*/
567 
568 #define DAT_MASK 0x00000001
569 #define DAT_DOUBLE 0x00000000
570 #define DAT_COMPLEX 0x00000001
571 
572 #define DSPL_MATRIX_BLOCK 32
573 
574 
575 #define DSPL_SYMMETRIC 0x00000000
576 #define DSPL_PERIODIC 0x00000001
577 
578 #define DSPL_FLAG_DIGITAL 0x00000000
579 #define DSPL_FLAG_ANALOG 0x00000001
580 #define DSPL_FLAG_LOGMAG 0x00000002
581 #define DSPL_FLAG_UNWRAP 0x00000004
582 #define DSPL_FLAG_FFT_SHIFT 0x00000008
583 
584 
585 
586 #define DSPL_WIN_SYM_MASK 0x00000001
587 #define DSPL_WIN_MASK 0x00FFFFFE
588 
589 #define DSPL_WIN_SYMMETRIC DSPL_SYMMETRIC
590 #define DSPL_WIN_PERIODIC DSPL_PERIODIC
591 
592 
593 #define DSPL_WIN_BARTLETT 0x00000004
594 #define DSPL_WIN_BARTLETT_HANN 0x00000008
595 #define DSPL_WIN_BLACKMAN 0x00000010
596 #define DSPL_WIN_BLACKMAN_HARRIS 0x00000040
597 #define DSPL_WIN_BLACKMAN_NUTTALL 0x00000080
598 #define DSPL_WIN_FLAT_TOP 0x00000100
599 #define DSPL_WIN_GAUSSIAN 0x00000400
600 #define DSPL_WIN_HAMMING 0x00000800
601 #define DSPL_WIN_HANN 0x00001000
602 #define DSPL_WIN_LANCZOS 0x00004000
603 #define DSPL_WIN_NUTTALL 0x00008000
604 #define DSPL_WIN_RECT 0x00010000
605 #define DSPL_WIN_COS 0x00040000
606 #define DSPL_WIN_CHEBY 0x00080000
607 #define DSPL_WIN_KAISER 0x00100000
608 
609 
610 #define DSPL_FILTER_TYPE_MASK 0x000000FF
611 #define DSPL_FILTER_LPF 0x00000001
612 #define DSPL_FILTER_HPF 0x00000002
613 #define DSPL_FILTER_BPASS 0x00000004
614 #define DSPL_FILTER_BSTOP 0x00000008
615 
616 #define DSPL_FILTER_APPROX_MASK 0x0000FF00
617 #define DSPL_FILTER_BUTTER 0x00000100
618 #define DSPL_FILTER_CHEBY1 0x00000200
619 #define DSPL_FILTER_CHEBY2 0x00000400
620 #define DSPL_FILTER_ELLIP 0x00000800
621 
622 
623 #define DSPL_XCORR_NOSCALE 0x00000000
624 #define DSPL_XCORR_BIASED 0x00000001
625 #define DSPL_XCORR_UNBIASED 0x00000002
626 
627 
628 
629 #define ELLIP_ITER 16
630 #define ELLIP_MAX_ORD 24
631 
632 #define DSPL_VERIF_FAILED 1
633 #define DSPL_VERIF_SUCCESS 0
634 
635 #define PLOT_HOLD 0x00000001
636 
637 
638 
639 #define VERIF_STR_BUF 128
640 #define VERIF_STR_LEN 48
641 #define VERIF_CHAR_POINT 46
642 #define VERIF_LEVEL_COMPLEX 1E-11
643 #define VERIF_LEVEL_DOUBLE 1E-12
644 
645 
646 
647 #ifdef __cplusplus
648  extern "C" {
649 #endif
650 
651 
652 
653 #ifdef BUILD_LIB
654  /* Declare DSPL_API for Windows OS */
655  #ifdef WIN_OS
656  #define DSPL_API __declspec(dllexport)
657  #endif /* WIN_OS */
658  /* Declare DSPL_API for LINUX OS */
659  #ifdef LINUX_OS
660  #define DSPL_API
661  #endif /* LINUX_OS */
662 #endif /* BUILD_DLL */
663 
664 #define COMMA ,
665 
666 
667 #ifdef BUILD_LIB
668  #define DECLARE_FUNC(type, fn, param)\
669  type DSPL_API fn(param);
670 #endif
671 
672 #ifndef BUILD_LIB
673  #define DECLARE_FUNC( type, fn, param)\
674  typedef type (*p_##fn)(param);\
675  extern p_##fn fn;
676 
677 #endif
678 
679 
680 
681 /*----------------------------------------------------------------------------*/
682 DECLARE_FUNC(int, acos_cmplx, complex_t*
683  COMMA int
684  COMMA complex_t*);
685 /*----------------------------------------------------------------------------*/
686 DECLARE_FUNC(int, addlog, char* str
687  COMMA char* fn);
688 /*----------------------------------------------------------------------------*/
689 DECLARE_FUNC(int, array_scale_lin, double* x
690  COMMA int n
691  COMMA double xmin
692  COMMA double xmax
693  COMMA double dx
694  COMMA double h
695  COMMA double* y);
696 /*----------------------------------------------------------------------------*/
697 DECLARE_FUNC(int, asin_cmplx, complex_t*
698  COMMA int
699  COMMA complex_t*);
700 /*----------------------------------------------------------------------------*/
701 DECLARE_FUNC(int, bessel_i0, double* x
702  COMMA int n
703  COMMA double* y);
704 /*----------------------------------------------------------------------------*/
705 DECLARE_FUNC(int, bilinear, double* bs
706  COMMA double* as
707  COMMA int ord
708  COMMA double* bz
709  COMMA double* az);
710 /*----------------------------------------------------------------------------*/
711 DECLARE_FUNC(int, butter_ap, double
712  COMMA int
713  COMMA double*
714  COMMA double*);
715 /*----------------------------------------------------------------------------*/
716 DECLARE_FUNC(int, butter_ap_zp, int
717  COMMA double
718  COMMA complex_t*
719  COMMA int*
720  COMMA complex_t*
721  COMMA int*);
722 /*----------------------------------------------------------------------------*/
723 DECLARE_FUNC(int, cheby_poly1, double*
724  COMMA int
725  COMMA int
726  COMMA double*);
727 /*----------------------------------------------------------------------------*/
728 DECLARE_FUNC(int, cheby_poly2, double*
729  COMMA int
730  COMMA int
731  COMMA double*);
732 /*----------------------------------------------------------------------------*/
733 DECLARE_FUNC(int, cheby1_ap, double
734  COMMA int
735  COMMA double*
736  COMMA double*);
737 /*----------------------------------------------------------------------------*/
738 DECLARE_FUNC(int, cheby1_ap_zp, int
739  COMMA double
740  COMMA complex_t*
741  COMMA int*
742  COMMA complex_t*
743  COMMA int*);
744 /*----------------------------------------------------------------------------*/
745 DECLARE_FUNC(int, cheby2_ap, double rs
746  COMMA int ord
747  COMMA double* b
748  COMMA double* a);
749 /*----------------------------------------------------------------------------*/
750 DECLARE_FUNC(int, cheby2_ap_wp1, double rp
751  COMMA double rs
752  COMMA int ord
753  COMMA double* b
754  COMMA double* a);
755 /*----------------------------------------------------------------------------*/
756 DECLARE_FUNC(int, cheby2_ap_zp, int
757  COMMA double
758  COMMA complex_t*
759  COMMA int*
760  COMMA complex_t*
761  COMMA int*);
762 /*----------------------------------------------------------------------------*/
763 DECLARE_FUNC(int, cmplx2re, complex_t*
764  COMMA int
765  COMMA double*
766  COMMA double*);
767 /*----------------------------------------------------------------------------*/
768 DECLARE_FUNC(int, concat, void*
769  COMMA size_t
770  COMMA void*
771  COMMA size_t
772  COMMA void*);
773 /*----------------------------------------------------------------------------*/
774 DECLARE_FUNC(int, conv, double*
775  COMMA int
776  COMMA double*
777  COMMA int
778  COMMA double*);
779 /*----------------------------------------------------------------------------*/
780 DECLARE_FUNC(int, conv_cmplx, complex_t*
781  COMMA int
782  COMMA complex_t*
783  COMMA int
784  COMMA complex_t*);
785 /*----------------------------------------------------------------------------*/
786 DECLARE_FUNC(int, conv_fft, double* a
787  COMMA int na
788  COMMA double* b
789  COMMA int nb
790  COMMA fft_t* pfft
791  COMMA int nfft
792  COMMA double* c);
793 /*----------------------------------------------------------------------------*/
794 DECLARE_FUNC(int, conv_fft_cmplx, complex_t* a
795  COMMA int na
796  COMMA complex_t* b
797  COMMA int nb
798  COMMA fft_t* pfft
799  COMMA int nfft
800  COMMA complex_t* c);
801 /*----------------------------------------------------------------------------*/
802 DECLARE_FUNC(int, cos_cmplx, complex_t*
803  COMMA int
804  COMMA complex_t*);
805 /*----------------------------------------------------------------------------*/
806 DECLARE_FUNC(int, decimate, double* x
807  COMMA int n
808  COMMA int d
809  COMMA double* y
810  COMMA int* cnt);
811 /*----------------------------------------------------------------------------*/
812 DECLARE_FUNC(int, decimate_cmplx, complex_t* x
813  COMMA int n
814  COMMA int d
815  COMMA complex_t* y
816  COMMA int* cnt);
817 /*----------------------------------------------------------------------------*/
818 DECLARE_FUNC(int, dft, double*
819  COMMA int
820  COMMA complex_t*);
821 /*----------------------------------------------------------------------------*/
822 DECLARE_FUNC(int, dft_cmplx, complex_t*
823  COMMA int
824  COMMA complex_t*);
825 /*----------------------------------------------------------------------------*/
826 DECLARE_FUNC(double, dmod, double
827  COMMA double);
828 /*----------------------------------------------------------------------------*/
829 DECLARE_FUNC(void, dspl_info, void);
830 /*----------------------------------------------------------------------------*/
831 DECLARE_FUNC(int, ellip_acd, double* w
832  COMMA int n
833  COMMA double k
834  COMMA double* u);
835 /*----------------------------------------------------------------------------*/
836 DECLARE_FUNC(int, ellip_acd_cmplx, complex_t* w
837  COMMA int n
838  COMMA double k
839  COMMA complex_t* u);
840 /*----------------------------------------------------------------------------*/
841 DECLARE_FUNC(int, ellip_ap, double rp
842  COMMA double rs
843  COMMA int ord
844  COMMA double* b
845  COMMA double* a);
846 /*----------------------------------------------------------------------------*/
847 DECLARE_FUNC(int, ellip_ap_zp, int ord
848  COMMA double rp
849  COMMA double rs
850  COMMA complex_t* z
851  COMMA int* nz
852  COMMA complex_t* p
853  COMMA int* np);
854 /*----------------------------------------------------------------------------*/
855 DECLARE_FUNC(int, ellip_asn, double* w
856  COMMA int n
857  COMMA double k
858  COMMA double* u);
859 /*----------------------------------------------------------------------------*/
860 DECLARE_FUNC(int, ellip_asn_cmplx, complex_t* w
861  COMMA int n
862  COMMA double k
863  COMMA complex_t* u);
864 /*----------------------------------------------------------------------------*/
865 DECLARE_FUNC(int, ellip_cd, double* u
866  COMMA int n
867  COMMA double k
868  COMMA double* y);
869 /*----------------------------------------------------------------------------*/
870 DECLARE_FUNC(int, ellip_cd_cmplx, complex_t* u
871  COMMA int n
872  COMMA double k
873  COMMA complex_t* y);
874 /*----------------------------------------------------------------------------*/
875 DECLARE_FUNC(int, ellip_landen, double k
876  COMMA int n
877  COMMA double* y);
878 /*----------------------------------------------------------------------------*/
879 DECLARE_FUNC(int, ellip_modulareq, double rp
880  COMMA double rs
881  COMMA int ord
882  COMMA double* k);
883 /*----------------------------------------------------------------------------*/
884 DECLARE_FUNC(int, ellip_rat, double* w
885  COMMA int n
886  COMMA int ord
887  COMMA double k
888  COMMA double* u);
889 /*----------------------------------------------------------------------------*/
890 DECLARE_FUNC(int, ellip_sn, double* u
891  COMMA int n
892  COMMA double k
893  COMMA double* y);
894 /*----------------------------------------------------------------------------*/
895 DECLARE_FUNC(int, ellip_sn_cmplx, complex_t* u
896  COMMA int n
897  COMMA double k
898  COMMA complex_t* y);
899 /*----------------------------------------------------------------------------*/
900 DECLARE_FUNC(int, farrow_lagrange, double*
901  COMMA int
902  COMMA double
903  COMMA double
904  COMMA double
905  COMMA double**
906  COMMA int*);
907 /*----------------------------------------------------------------------------*/
908 DECLARE_FUNC(int, farrow_spline, double*
909  COMMA int
910  COMMA double
911  COMMA double
912  COMMA double
913  COMMA double**
914  COMMA int*);
915 /*----------------------------------------------------------------------------*/
916 DECLARE_FUNC(int, fft, double*
917  COMMA int
918  COMMA fft_t*
919  COMMA complex_t* );
920 /*----------------------------------------------------------------------------*/
921 DECLARE_FUNC(int, fft_cmplx, complex_t*
922  COMMA int
923  COMMA fft_t*
924  COMMA complex_t* );
925 /*----------------------------------------------------------------------------*/
926 DECLARE_FUNC(int, fft_create, fft_t*
927  COMMA int);
928 /*----------------------------------------------------------------------------*/
929 DECLARE_FUNC(void, fft_free, fft_t*);
930 /*----------------------------------------------------------------------------*/
931 DECLARE_FUNC(int, fft_mag, double* x
932  COMMA int n
933  COMMA fft_t* pfft
934  COMMA double fs
935  COMMA int flag
936  COMMA double* mag
937  COMMA double* freq);
938 /*----------------------------------------------------------------------------*/
939 DECLARE_FUNC(int, fft_mag_cmplx, complex_t* x
940  COMMA int n
941  COMMA fft_t* pfft
942  COMMA double fs
943  COMMA int flag
944  COMMA double* mag
945  COMMA double* freq);
946 /*----------------------------------------------------------------------------*/
947 DECLARE_FUNC(int, fft_shift, double*
948  COMMA int n
949  COMMA double*);
950 /*----------------------------------------------------------------------------*/
951 DECLARE_FUNC(int, fft_shift_cmplx, complex_t*
952  COMMA int
953  COMMA complex_t*);
954 /*----------------------------------------------------------------------------*/
955 DECLARE_FUNC(int, filter_freq_resp, double* b
956  COMMA double* a
957  COMMA int ord
958  COMMA double* w
959  COMMA int n
960  COMMA int flag
961  COMMA double* mag
962  COMMA double* phi
963  COMMA double* tau);
964 /*----------------------------------------------------------------------------*/
965 DECLARE_FUNC(int, filter_iir, double*
966  COMMA double*
967  COMMA int
968  COMMA double*
969  COMMA int
970  COMMA double*);
971 /*----------------------------------------------------------------------------*/
972 DECLARE_FUNC(double, filter_ws1, int ord
973  COMMA double rp
974  COMMA double rs
975  COMMA int type);
976 /*----------------------------------------------------------------------------*/
977 DECLARE_FUNC(int, filter_zp2ab, complex_t*
978  COMMA int
979  COMMA complex_t*
980  COMMA int
981  COMMA int
982  COMMA double*
983  COMMA double*);
984 /*----------------------------------------------------------------------------*/
985 DECLARE_FUNC(int, find_max_abs, double* a
986  COMMA int n
987  COMMA double* m
988  COMMA int* ind);
989 /*----------------------------------------------------------------------------*/
990 DECLARE_FUNC(int, fir_linphase, int ord
991  COMMA double w0
992  COMMA double w1
993  COMMA int filter_type
994  COMMA int wintype
995  COMMA double winparam
996  COMMA double* h);
997 /*----------------------------------------------------------------------------*/
998 DECLARE_FUNC(int, flipip, double*
999  COMMA int);
1000 /*----------------------------------------------------------------------------*/
1001 DECLARE_FUNC(int, flipip_cmplx, complex_t*
1002  COMMA int);
1003 /*----------------------------------------------------------------------------*/
1004 DECLARE_FUNC(int, fourier_integral_cmplx, double* t
1005  COMMA complex_t* s
1006  COMMA int nt
1007  COMMA int nw
1008  COMMA double* w
1009  COMMA complex_t* y);
1010 /*----------------------------------------------------------------------------*/
1011 DECLARE_FUNC(int, fourier_series_dec, double*
1012  COMMA double*
1013  COMMA int
1014  COMMA double
1015  COMMA int
1016  COMMA double*
1017  COMMA complex_t*);
1018 /*----------------------------------------------------------------------------*/
1019 DECLARE_FUNC(int, fourier_series_dec_cmplx, double* t
1020  COMMA complex_t* s
1021  COMMA int nt
1022  COMMA double period
1023  COMMA int nw
1024  COMMA double* w
1025  COMMA complex_t* y);
1026 /*----------------------------------------------------------------------------*/
1027 DECLARE_FUNC(int, fourier_series_rec, double*
1028  COMMA complex_t*
1029  COMMA int
1030  COMMA double*
1031  COMMA int
1032  COMMA complex_t*);
1033 /*----------------------------------------------------------------------------*/
1034 DECLARE_FUNC(int, freqs, double*
1035  COMMA double*
1036  COMMA int
1037  COMMA double*
1038  COMMA int
1039  COMMA complex_t*);
1040 /*----------------------------------------------------------------------------*/
1041 DECLARE_FUNC(int, freqs_cmplx, double* b
1042  COMMA double* a
1043  COMMA int ord
1044  COMMA complex_t* s
1045  COMMA int n
1046  COMMA complex_t* h);
1047 /*----------------------------------------------------------------------------*/
1048 DECLARE_FUNC(int, freqs2time, double*
1049  COMMA double*
1050  COMMA int
1051  COMMA double
1052  COMMA int
1053  COMMA fft_t*
1054  COMMA double*
1055  COMMA double*);
1056 /*----------------------------------------------------------------------------*/
1057 DECLARE_FUNC(int, freqz, double*
1058  COMMA double*
1059  COMMA int
1060  COMMA double*
1061  COMMA int
1062  COMMA complex_t*);
1063 /*----------------------------------------------------------------------------*/
1064 DECLARE_FUNC(void, gnuplot_close, void* h);
1065 /*----------------------------------------------------------------------------*/
1066 DECLARE_FUNC(void, gnuplot_cmd, void* h
1067  COMMA char* cmd);
1068 /*----------------------------------------------------------------------------*/
1069 DECLARE_FUNC(int, gnuplot_create, int argc
1070  COMMA char* argv[]
1071  COMMA int w
1072  COMMA int h
1073  COMMA char* fn_png
1074  COMMA void** hplot);
1075 /*----------------------------------------------------------------------------*/
1076 DECLARE_FUNC(int, gnuplot_open, void** hplot);
1077 /*----------------------------------------------------------------------------*/
1078 DECLARE_FUNC(int, goertzel, double*
1079  COMMA int
1080  COMMA int*
1081  COMMA int
1082  COMMA complex_t*);
1083 /*----------------------------------------------------------------------------*/
1084 DECLARE_FUNC(int, goertzel_cmplx, complex_t*
1085  COMMA int
1086  COMMA int*
1087  COMMA int
1088  COMMA complex_t*);
1089 /*----------------------------------------------------------------------------*/
1090 DECLARE_FUNC(int, group_delay, double* b
1091  COMMA double* a
1092  COMMA int ord
1093  COMMA int flag
1094  COMMA double* w
1095  COMMA int n
1096  COMMA double* tau);
1097 /*----------------------------------------------------------------------------*/
1098 DECLARE_FUNC(int, histogram, double* x
1099  COMMA int n
1100  COMMA int nh
1101  COMMA double* pedges
1102  COMMA double* ph);
1103 /*----------------------------------------------------------------------------*/
1104 DECLARE_FUNC(int, histogram_norm, double* y
1105  COMMA int n
1106  COMMA int nh
1107  COMMA double* x
1108  COMMA double* w);
1109 /*----------------------------------------------------------------------------*/
1110 DECLARE_FUNC(int, idft_cmplx, complex_t*
1111  COMMA int
1112  COMMA complex_t*);
1113 /*----------------------------------------------------------------------------*/
1114 DECLARE_FUNC(int, ifft_cmplx, complex_t*
1115  COMMA int
1116  COMMA fft_t*
1117  COMMA complex_t* );
1118 /*----------------------------------------------------------------------------*/
1119 DECLARE_FUNC(int, iir, double rp
1120  COMMA double rs
1121  COMMA int ord
1122  COMMA double w0
1123  COMMA double w1
1124  COMMA int type
1125  COMMA double* b
1126  COMMA double* a);
1127 /*----------------------------------------------------------------------------*/
1128 DECLARE_FUNC(int, linspace, double
1129  COMMA double
1130  COMMA int
1131  COMMA int
1132  COMMA double*);
1133 /*----------------------------------------------------------------------------*/
1134 DECLARE_FUNC(int, log_cmplx, complex_t*
1135  COMMA int
1136  COMMA complex_t*);
1137 /*----------------------------------------------------------------------------*/
1138 DECLARE_FUNC(int, logspace, double
1139  COMMA double
1140  COMMA int
1141  COMMA int
1142  COMMA double*);
1143 /*----------------------------------------------------------------------------*/
1144 DECLARE_FUNC(int, low2bp, double* b
1145  COMMA double* a
1146  COMMA int ord
1147  COMMA double w0
1148  COMMA double wpl
1149  COMMA double wph
1150  COMMA double* beta
1151  COMMA double* alpha);
1152 /*----------------------------------------------------------------------------*/
1153 DECLARE_FUNC(int, low2bs, double* b
1154  COMMA double* a
1155  COMMA int ord
1156  COMMA double w0
1157  COMMA double wsl
1158  COMMA double wsh
1159  COMMA double* beta
1160  COMMA double* alpha);
1161 /*----------------------------------------------------------------------------*/
1162 DECLARE_FUNC(int, low2high, double* b
1163  COMMA double* a
1164  COMMA int ord
1165  COMMA double w0
1166  COMMA double w1
1167  COMMA double* beta
1168  COMMA double* alpha);
1169 /*----------------------------------------------------------------------------*/
1170 DECLARE_FUNC(int, low2low, double* b
1171  COMMA double* a
1172  COMMA int ord
1173  COMMA double w0
1174  COMMA double w1
1175  COMMA double* beta
1176  COMMA double* alpha);
1177 /*----------------------------------------------------------------------------*/
1178 DECLARE_FUNC(int, matrix_eig_cmplx, complex_t* a
1179  COMMA int n
1180  COMMA complex_t* v
1181  COMMA int* info);
1182 /*----------------------------------------------------------------------------*/
1183 DECLARE_FUNC(int, matrix_eye, double* a
1184  COMMA int n
1185  COMMA int m);
1186 /*----------------------------------------------------------------------------*/
1187 DECLARE_FUNC(int, matrix_eye_cmplx, complex_t* a
1188  COMMA int n
1189  COMMA int m);
1190 /*----------------------------------------------------------------------------*/
1191 DECLARE_FUNC(int, matrix_mul, double* a
1192  COMMA int na
1193  COMMA int ma
1194  COMMA double* b
1195  COMMA int nb
1196  COMMA int mb
1197  COMMA double* c);
1198 /*----------------------------------------------------------------------------*/
1199 DECLARE_FUNC(int, matrix_print, double* a
1200  COMMA int n
1201  COMMA int m
1202  COMMA const char* name
1203  COMMA const char* format);
1204 /*----------------------------------------------------------------------------*/
1205 DECLARE_FUNC(int, matrix_print_cmplx, complex_t* a
1206  COMMA int n
1207  COMMA int m
1208  COMMA const char* name
1209  COMMA const char* format);
1210 /*----------------------------------------------------------------------------*/
1211 DECLARE_FUNC(int, matrix_transpose, double* a
1212  COMMA int n
1213  COMMA int m
1214  COMMA double* b);
1215 /*----------------------------------------------------------------------------*/
1216 DECLARE_FUNC(int, matrix_transpose_cmplx, complex_t* a
1217  COMMA int n
1218  COMMA int m
1219  COMMA complex_t* b);
1220 /*----------------------------------------------------------------------------*/
1221 DECLARE_FUNC(int, matrix_transpose_hermite, complex_t* a
1222  COMMA int n
1223  COMMA int m
1224  COMMA complex_t* b);
1225 /*----------------------------------------------------------------------------*/
1226 DECLARE_FUNC(int, mean, double* x
1227  COMMA int n
1228  COMMA double* m);
1229 /*----------------------------------------------------------------------------*/
1230 DECLARE_FUNC(int, mean_cmplx, complex_t* x
1231  COMMA int n
1232  COMMA complex_t* m);
1233 /*----------------------------------------------------------------------------*/
1234 DECLARE_FUNC(int, minmax, double* x
1235  COMMA int n
1236  COMMA double* xmin
1237  COMMA double* xmax);
1238 /*----------------------------------------------------------------------------*/
1239 DECLARE_FUNC(int, ones, double* x
1240  COMMA int n);
1241 /*----------------------------------------------------------------------------*/
1242 DECLARE_FUNC(int, phase_delay, double* b
1243  COMMA double* a
1244  COMMA int ord
1245  COMMA int flag
1246  COMMA double* w
1247  COMMA int n
1248  COMMA double* tau);
1249 /*----------------------------------------------------------------------------*/
1250 DECLARE_FUNC(int, poly_z2a_cmplx, complex_t*
1251  COMMA int
1252  COMMA int
1253  COMMA complex_t*);
1254 /*----------------------------------------------------------------------------*/
1255 DECLARE_FUNC(int, polyroots, double* a
1256  COMMA int ord
1257  COMMA complex_t* r
1258  COMMA int* info);
1259 /*----------------------------------------------------------------------------*/
1260 DECLARE_FUNC(int, polyval, double*
1261  COMMA int
1262  COMMA double*
1263  COMMA int
1264  COMMA double*);
1265 /*----------------------------------------------------------------------------*/
1266 DECLARE_FUNC(int, polyval_cmplx, complex_t*
1267  COMMA int
1268  COMMA complex_t*
1269  COMMA int
1270  COMMA complex_t*);
1271 /*----------------------------------------------------------------------------*/
1272 DECLARE_FUNC(int, randb, double* x
1273  COMMA int n
1274  COMMA random_t* prnd);
1275 /*----------------------------------------------------------------------------*/
1276 DECLARE_FUNC(int, randb2, double* x
1277  COMMA int n
1278  COMMA random_t* prnd);
1279 /*----------------------------------------------------------------------------*/
1280 DECLARE_FUNC(int, randi, int* x
1281  COMMA int n
1282  COMMA int start
1283  COMMA int stop
1284  COMMA random_t* prnd);
1285 /*----------------------------------------------------------------------------*/
1286 DECLARE_FUNC(int, randn, double*
1287  COMMA int
1288  COMMA double
1289  COMMA double
1290  COMMA random_t* prnd);
1291 /*----------------------------------------------------------------------------*/
1292 DECLARE_FUNC(int, random_init, random_t* prnd
1293  COMMA int type
1294  COMMA void* seed);
1295 /*----------------------------------------------------------------------------*/
1296 DECLARE_FUNC(int, randu, double*
1297  COMMA int
1298  COMMA random_t* prnd);
1299 /*----------------------------------------------------------------------------*/
1300 DECLARE_FUNC(int, ratcompos, double* b
1301  COMMA double* a
1302  COMMA int n
1303  COMMA double* c
1304  COMMA double* d
1305  COMMA int p
1306  COMMA double* beta
1307  COMMA double* alpha);
1308 /*----------------------------------------------------------------------------*/
1309 DECLARE_FUNC(int, re2cmplx, double*
1310  COMMA int
1311  COMMA complex_t*);
1312 /*----------------------------------------------------------------------------*/
1313 DECLARE_FUNC(int, readbin, char* fn
1314  COMMA void** x
1315  COMMA int* k
1316  COMMA int* dtype);
1317 /*----------------------------------------------------------------------------*/
1318 DECLARE_FUNC(int, signal_pimp, double*
1319  COMMA size_t
1320  COMMA double
1321  COMMA double
1322  COMMA double
1323  COMMA double
1324  COMMA double*);
1325 /*----------------------------------------------------------------------------*/
1326 DECLARE_FUNC(int, signal_saw, double* t
1327  COMMA size_t n
1328  COMMA double amp
1329  COMMA double dt
1330  COMMA double period
1331  COMMA double* y);
1332 /*----------------------------------------------------------------------------*/
1333 DECLARE_FUNC(int, sin_cmplx, complex_t*
1334  COMMA int
1335  COMMA complex_t*);
1336 /*----------------------------------------------------------------------------*/
1337 DECLARE_FUNC(int, sinc, double* x
1338  COMMA int n
1339  COMMA double a
1340  COMMA double* y);
1341 /*----------------------------------------------------------------------------*/
1342 DECLARE_FUNC(int, sine_int, double* x
1343  COMMA int n
1344  COMMA double* si);
1345 /*----------------------------------------------------------------------------*/
1346 DECLARE_FUNC(int, sqrt_cmplx, complex_t*
1347  COMMA int
1348  COMMA complex_t*);
1349 /*----------------------------------------------------------------------------*/
1350 DECLARE_FUNC(int, std, double* x
1351  COMMA int n
1352  COMMA double* s);
1353 /*----------------------------------------------------------------------------*/
1354 DECLARE_FUNC(int, std_cmplx, complex_t* x
1355  COMMA int n
1356  COMMA double* s);
1357 /*----------------------------------------------------------------------------*/
1358 DECLARE_FUNC(int, trapint, double*
1359  COMMA double*
1360  COMMA int
1361  COMMA double*);
1362 /*----------------------------------------------------------------------------*/
1363 DECLARE_FUNC(int, trapint_cmplx, double*
1364  COMMA complex_t*
1365  COMMA int
1366  COMMA complex_t*);
1367 /*----------------------------------------------------------------------------*/
1368 DECLARE_FUNC(int, unwrap, double*
1369  COMMA int
1370  COMMA double
1371  COMMA double);
1372 /*----------------------------------------------------------------------------*/
1373 DECLARE_FUNC(int, vector_dot, double* x
1374  COMMA double* y
1375  COMMA int n
1376  COMMA double* p);
1377 /*----------------------------------------------------------------------------*/
1378 DECLARE_FUNC(int, verif, double* x
1379  COMMA double* y
1380  COMMA size_t n
1381  COMMA double eps
1382  COMMA double* err);
1383 /*----------------------------------------------------------------------------*/
1384 DECLARE_FUNC(int, verif_data_gen, int len
1385  COMMA int type
1386  COMMA char* fn);
1387 /*----------------------------------------------------------------------------*/
1388 DECLARE_FUNC(int, verif_cmplx, complex_t* x
1389  COMMA complex_t* y
1390  COMMA size_t n
1391  COMMA double eps
1392  COMMA double* err);
1393 /*----------------------------------------------------------------------------*/
1394 DECLARE_FUNC(void, verif_str, double* yout
1395  COMMA int nout
1396  COMMA char* str_msg
1397  COMMA char* outfn
1398  COMMA char* logfn);
1399 /*----------------------------------------------------------------------------*/
1400 DECLARE_FUNC(void, verif_str_cmplx, complex_t* yout
1401  COMMA int nout
1402  COMMA char* str_msg
1403  COMMA char* outfn
1404  COMMA char* logfn);
1405 /*----------------------------------------------------------------------------*/
1406 DECLARE_FUNC(int, window, double* w
1407  COMMA int n
1408  COMMA int win_type
1409  COMMA double param);
1410 /*----------------------------------------------------------------------------*/
1411 DECLARE_FUNC(int, writebin, void*
1412  COMMA int
1413  COMMA int
1414  COMMA char*);
1415 /*----------------------------------------------------------------------------*/
1416 DECLARE_FUNC(int, writetxt, double*
1417  COMMA double*
1418  COMMA int
1419  COMMA char*);
1420 /*----------------------------------------------------------------------------*/
1421 DECLARE_FUNC(int, writetxt_3d, double* x
1422  COMMA int nx
1423  COMMA double* y
1424  COMMA int ny
1425  COMMA double* z
1426  COMMA char* fn);
1427 /*----------------------------------------------------------------------------*/
1428 DECLARE_FUNC(int, writetxt_3dline, double* x
1429  COMMA double* y
1430  COMMA double* z
1431  COMMA int n
1432  COMMA char* fn);
1433 /*----------------------------------------------------------------------------*/
1434 DECLARE_FUNC(int, writetxt_cmplx, complex_t* x
1435  COMMA int n
1436  COMMA char* fn);
1437 /*----------------------------------------------------------------------------*/
1438 DECLARE_FUNC(int, writetxt_cmplx_im, double*
1439  COMMA complex_t*
1440  COMMA int
1441  COMMA char*);
1442 /*----------------------------------------------------------------------------*/
1443 DECLARE_FUNC(int, writetxt_cmplx_re, double*
1444  COMMA complex_t*
1445  COMMA int
1446  COMMA char*);
1447 /*----------------------------------------------------------------------------*/
1448 DECLARE_FUNC(int, writetxt_int, int*
1449  COMMA int*
1450  COMMA int
1451  COMMA char*);
1452 /*----------------------------------------------------------------------------*/
1453 DECLARE_FUNC(int, xcorr, double* x
1454  COMMA int nx
1455  COMMA double* y
1456  COMMA int ny
1457  COMMA int flag
1458  COMMA int nr
1459  COMMA double* r
1460  COMMA double* t);
1461 /*----------------------------------------------------------------------------*/
1462 DECLARE_FUNC(int, xcorr_cmplx, complex_t* x
1463  COMMA int nx
1464  COMMA complex_t* y
1465  COMMA int ny
1466  COMMA int flag
1467  COMMA int nr
1468  COMMA complex_t* r
1469  COMMA double* t);
1470 /*----------------------------------------------------------------------------*/
1471 
1472 
1473 #ifdef __cplusplus
1474  }
1475 #endif
1476 
1477 
1478 void* dspl_load();
1479 void dspl_free(void* handle);
1480 
1481 
1482 
1483 #endif /* DSPL_H */
1484 
int window(double *w, int n, int win_type, double param)
Расчет функции оконного взвешивания
Definition: win.c:308
int ellip_ap_zp(int ord, double rp, double rs, complex_t *z, int *nz, complex_t *p, int *np)
Расчет массивов нулей и полюсов передаточной функции аналогового нормированного эллиптического ФНЧ.
Definition: filter_ap.c:1786
int sine_int(double *x, int n, double *si)
Функция интегрального синуса
Definition: math.c:1043
int cheby1_ap(double rp, int ord, double *b, double *a)
Расчет передаточной характеристики аналогового нормированного ФНЧ Чебышёва первого рода.
Definition: filter_ap.c:601
int flipip_cmplx(complex_t *x, int n)
Функция отражения комплексного вектора x
Definition: array.c:842
int ellip_cd(double *u, int n, double k, double *y)
Эллиптическая функция Якоби вещественного аргумента
Definition: ellipj.c:577
int butter_ap_zp(int ord, double rp, complex_t *z, int *nz, complex_t *p, int *np)
Расчет массивов нулей и полюсов передаточной функции аналогового нормированного ФНЧ Баттерворта.
Definition: filter_ap.c:402
int filter_iir(double *b, double *a, int ord, double *x, int n, double *y)
Фильтрация вещественного сигнала вещественным БИХ-фильтром
Definition: conv.c:993
int ratcompos(double *b, double *a, int n, double *c, double *d, int p, double *beta, double *alpha)
Рациональная композиця
Definition: filter_ft.c:602
int fourier_series_rec(double *w, complex_t *s, int nw, double *t, int nt, complex_t *y)
Восстановление сигнала при усечении ряда Фурье
complex_t * t1
Definition: dspl.h:230
Структура параметров датчиков псевдослучайных чисел.
Definition: dspl.h:289
int writebin(void *x, int n, int dtype, char *fn)
Сохранить данные в бинарный файл
Definition: inout.c:328
int low2low(double *b, double *a, int ord, double w0, double w1, double *beta, double *alpha)
Частотное преобразование ФНЧ-ФНЧ
Definition: filter_ft.c:426
int flipip(double *x, int n)
Функция отражения вещественного вектора x
Definition: array.c:719
int bilinear(double *bs, double *as, int ord, double *bz, double *az)
Билинейное преобразование передаточной характеристики аналогового фильтра , в передаточную характерис...
Definition: filter_iir.c:210
int writetxt_int(int *x, int *y, int n, char *fn)
Сохранить целочисленные данные в текстовый файл
Definition: inout.c:637
int conv(double *a, int na, double *b, int nb, double *c)
Линейная свертка двух вещественных векторов
Definition: conv.c:157
complex_t * t0
Definition: dspl.h:229
int cheby_poly2(double *x, int n, int ord, double *y)
Многочлен Чебышева второго рода порядка ord
Definition: cheby.c:285
int log_cmplx(complex_t *x, int n, complex_t *y)
Натуральный логарифм комплексного аргумента x.
Definition: math.c:718
int polyval(double *a, int ord, double *x, int n, double *y)
Расчет вещественного полинома
Definition: polyval.c:219
int acos_cmplx(complex_t *x, int n, complex_t *y)
Арккосинус комплексного аргумента x.
Definition: math.c:141
int idft_cmplx(complex_t *x, int n, complex_t *y)
Обратное дискретное преобразование Фурье комплексного спектра.
Definition: dft.c:500
int polyroots(double *a, int ord, complex_t *r, int *info)
Расчет корней вещественного полинома
Definition: polyval.c:135
int fft_shift(double *x, int n, double *y)
Перестановка спектральных отсчетов дискретного преобразования Фурье
Definition: fft.c:1098
int n
Definition: dspl.h:231
void gnuplot_close(void *h)
Закрыть хэндл GNUPLOT.
Definition: gnuplot.c:325
int randn(double *x, int n, double mu, double sigma, random_t *prnd)
Генерация вектора нормально распределенных псевдослучайных чисел.
Definition: randgen.c:589
int iir(double rp, double rs, int ord, double w0, double w1, int type, double *b, double *a)
Функция расчета коэффициентов передаточной характеристики цифрового фильтра БИХ.
Definition: filter_iir.c:404
int low2high(double *b, double *a, int ord, double w0, double w1, double *beta, double *alpha)
Частотное преобразование ФНЧ-ФВЧ
Definition: filter_ft.c:280
int fft_create(fft_t *pfft, int n)
Заполнение структуры fft_t для алгоритма БПФ
Definition: fft.c:775
int fft_cmplx(complex_t *x, int n, fft_t *pfft, complex_t *y)
Быстрое преобразование Фурье комплексного сигнала
Definition: fft.c:528
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:179
int logspace(double x0, double x1, int n, int type, double *x)
Функция заполняет массив значениями логарифмической шкале
Definition: array.c:1192
int ellip_acd(double *w, int n, double k, double *u)
Обратная эллиптическая функция Якоби вещественного аргумента
Definition: ellipj.c:103
int polyval_cmplx(complex_t *a, int ord, complex_t *x, int n, complex_t *y)
Расчет комплексного полинома
Definition: polyval.c:293
void fft_free(fft_t *pfft)
Очистить структуру fft_t алгоритма БПФ
Definition: fft.c:892
int phase_delay(double *b, double *a, int ord, int flag, double *w, int n, double *tau)
Расчет фазовой задержки цифрового или аналогового фильтра.
Definition: filter_an.c:1190
int type
Definition: dspl.h:299
int ellip_sn_cmplx(complex_t *u, int n, double k, complex_t *y)
Эллиптическая функция Якоби комплексного аргумента
Definition: ellipj.c:1179
int ellip_sn(double *u, int n, double k, double *y)
Эллиптическая функция Якоби вещественного аргумента
Definition: ellipj.c:1074
int xcorr_cmplx(complex_t *x, int nx, complex_t *y, int ny, int flag, int nr, complex_t *r, double *t)
Оценка вектора взаимной корреляции для дискретных комплексных последовательностей x и y.
Definition: xcorr.c:449
int xcorr(double *x, int nx, double *y, int ny, int flag, int nr, double *r, double *t)
Оценка вектора взаимной корреляции для дискретных вещественных последовательностей x и y.
Definition: xcorr.c:214
Структура данных объекта быстрого преобразования Фурье
Definition: dspl.h:227
void gnuplot_cmd(void *h, char *cmd)
Функция посылает команду cmd пакету GNUPLOT, для построения или оформления графика,...
Definition: gnuplot.c:390
int goertzel(double *x, int n, int *ind, int k, complex_t *y)
Алгоритм Гёрцеля для расчета отдельных спектральных отсчетов дискретного преобразования Фурье веществ...
Definition: goertzel.c:125
int randu(double *x, int n, random_t *prnd)
Генерация вектора равномерно-распределенных в интервале от 0 до 1 псевдослучайных чисел.
Definition: randgen.c:698
int randi(int *x, int n, int start, int stop, random_t *prnd)
Генерация целочисленного вектора равномерно распределенных псевдослучайных чисел.
Definition: randgen.c:498
int fft(double *x, int n, fft_t *pfft, complex_t *y)
Быстрое преобразование Фурье вещественного сигнала
Definition: fft.c:356
int writetxt_3d(double *x, int nx, double *y, int ny, double *z, char *fn)
Сохранить данные для построения 3D графика
Definition: inout.c:853
int ellip_asn_cmplx(complex_t *w, int n, double k, complex_t *u)
Обратная эллиптическая функция Якоби комплексного аргумента
Definition: ellipj.c:447
int butter_ap(double rp, int ord, double *b, double *a)
Расчет передаточной характеристики аналогового нормированного ФНЧ Баттерворта.
Definition: filter_ap.c:175
int cheby_poly1(double *x, int n, int ord, double *y)
Многочлен Чебышева первого рода порядка ord
Definition: cheby.c:134
int re2cmplx(double *x, int n, complex_t *y)
Преобразование массива вещественных данных в массив комплексных данных.
Definition: complex.c:246
int mt19937_mti
Definition: dspl.h:297
int writetxt(double *x, double *y, int n, char *fn)
Сохранить вещественные данные в текстовый файл
Definition: inout.c:491
int random_init(random_t *prnd, int type, void *seed)
Инициализация датчиков псевдослучайных чисел.
Definition: randgen.c:121
int cmplx2re(complex_t *x, int n, double *re, double *im)
Преобразование массива комплексных данных в два массива вещественных данных, содержащих реальную и мн...
Definition: complex.c:130
int conv_cmplx(complex_t *a, int na, complex_t *b, int nb, complex_t *c)
Линейная свертка двух комплексных векторов
Definition: conv.c:327
int freqz(double *b, double *a, int ord, double *w, int n, complex_t *h)
Расчет комплексного коэффициента передачи цифрового фильтра.
Definition: filter_an.c:980
int matrix_eig_cmplx(complex_t *a, int n, complex_t *v, int *info)
Расчет собственных значений квадратной комплексной матрицы.
Definition: matrix.c:90
int ones(double *x, int n)
Функция заполнения вещественного массива единицами
Definition: array.c:1302
int randb(double *x, int n, random_t *prnd)
Генерация бинарного униполярного [0, 1] псевдослучайного вектора
Definition: randgen.c:244
double complex_t[2]
Описание комплексного типа данных.
Definition: dspl.h:86
int cheby1_ap_zp(int ord, double rp, complex_t *z, int *nz, complex_t *p, int *np)
Расчет массивов нулей и полюсов передаточной функции аналогового нормированного ФНЧ Чебышёва первого...
Definition: filter_ap.c:832
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:463
int decimate(double *x, int n, int d, double *y, int *cnt)
Децимация вещественного вектора данных
Definition: array.c:445
int find_max_abs(double *a, int n, double *m, int *ind)
Поиск максимального по модулю элемента вещественного вектора a
Definition: statistic.c:123
int ellip_ap(double rp, double rs, int ord, double *b, double *a)
Расчет передаточной характеристики аналогового нормированного эллиптического ФНЧ.
Definition: filter_ap.c:1538
int farrow_lagrange(double *s, int n, double p, double q, double frd, double **y, int *ny)
Передискретизация вещественного сигнала на основе полиномиальной Лагранжевой интерполяции.
Definition: resampling.c:87
int matrix_eye(double *a, int n, int m)
Генерирование единичной вещественой матрицы размерности n x m.
Definition: matrix.c:153
int verif(double *x, double *y, size_t n, double eps, double *err)
Верификация вещественных массивов
Definition: verification.c:130
int farrow_spline(double *s, int n, double p, double q, double frd, double **y, int *ny)
Передискретизация вещественного сигнала на основе сплайн интерполяции.
Definition: resampling.c:218
int sqrt_cmplx(complex_t *x, int n, complex_t *y)
Квадратный корень из комплексного вектора x (поэлементный).
Definition: math.c:1307
int concat(void *a, size_t na, void *b, size_t nb, void *c)
Конкатенация двух массивов данных
Definition: array.c:315
int sin_cmplx(complex_t *x, int n, complex_t *y)
Синус комплексного аргумента x.
Definition: math.c:849
int freqs(double *b, double *a, int ord, double *w, int n, complex_t *h)
Расчет комплексного коэффициента передачи аналогового фильтра.
Definition: filter_an.c:659
int array_scale_lin(double *x, int n, double xmin, double xmax, double dx, double h, double *y)
Линейное растяжение вектора данных x Функция производит преобразование значений , в значения ,...
Definition: array.c:171
int goertzel_cmplx(complex_t *x, int n, int *ind, int k, complex_t *y)
Алгоритм Гёрцеля для расчета отдельных спектральных отсчетов дискретного преобразования Фурье комплек...
Definition: goertzel.c:263
int ellip_asn(double *w, int n, double k, double *u)
Обратная эллиптическая функция Якоби вещественного аргумента
Definition: ellipj.c:339
int linspace(double x0, double x1, int n, int type, double *x)
Функция заполняет массив линейно-нарастающими, равноотстоящими значениями от x0 до x1
Definition: array.c:1009
int dft_cmplx(complex_t *x, int n, complex_t *y)
Дискретное преобразование Фурье комплексного сигнала.
Definition: dft.c:329
int bessel_i0(double *x, int n, double *y)
Модифицированная функция Бесселя первого рода .
Definition: math.c:386
complex_t * w
Definition: dspl.h:228
int ellip_cd_cmplx(complex_t *u, int n, double k, complex_t *y)
Эллиптическая функция Якоби комплексного аргумента
Definition: ellipj.c:684
int asin_cmplx(complex_t *x, int n, complex_t *y)
Арксинус комплексного аргумента x.
Definition: math.c:271
int cos_cmplx(complex_t *x, int n, complex_t *y)
Косинус комплексного аргумента x.
Definition: math.c:585
int sinc(double *x, int n, double a, double *y)
Функция .
Definition: math.c:936
int ellip_acd_cmplx(complex_t *w, int n, double k, complex_t *u)
Обратная эллиптическая функция Якоби комплексного аргумента
Definition: ellipj.c:211
int ellip_landen(double k, int n, double *y)
Расчет коэффициентов ряда полного эллиптического интеграла.
Definition: ellipj.c:872
int gnuplot_open(void **hplot)
Открыть пакет GNUPLOT.
Definition: gnuplot.c:482
int fir_linphase(int ord, double w0, double w1, int filter_type, int win_type, double win_param, double *h)
Расчет коэффициентов линейно-фазового КИХ-фильтра методом оконного взвешивания.
Definition: filter_fir.c:321
int cheby2_ap_zp(int ord, double rs, complex_t *z, int *nz, complex_t *p, int *np)
Расчет массивов нулей и полюсов передаточной функции аналогового нормированного ФНЧ Чебышёва второго...
Definition: filter_ap.c:1304
int verif_cmplx(complex_t *x, complex_t *y, size_t n, double eps, double *err)
Верификация комплексных массивов
Definition: verification.c:347
int dft(double *x, int n, complex_t *y)
Дискретное преобразование Фурье вещественного сигнала.
Definition: dft.c:163
double mrg32k3a_seed
Definition: dspl.h:291
int gnuplot_create(int argc, char *argv[], int w, int h, char *fn_png, void **hplot)
Создать график GNUPLOT.
Definition: gnuplot.c:200
int cheby2_ap(double rs, int ord, double *b, double *a)
Расчет передаточной характеристики аналогового нормированного ФНЧ Чебышёва второго рода.
Definition: filter_ap.c:1037
int decimate_cmplx(complex_t *x, int n, int d, complex_t *y, int *cnt)
Децимация комплексного вектора данных
Definition: array.c:587
int group_delay(double *pb, double *pa, int ord, int flag, double *w, int n, double *tau)
Расчет группового времени запаздывания цифрового или аналогового фильтра.
Definition: filter_an.c:166
int randb2(double *x, int n, random_t *prnd)
Генерация бинарного биполярного [-1, 1] псевдослучайного вектора
Definition: randgen.c:358