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_FS 0x06190000
525 #define ERROR_FWRITE_SIZE 0x06231820
526 /* G 0x07xxxxxx*/
527 #define ERROR_GNUPLOT_CREATE 0x07161203
528 #define ERROR_GNUPLOT_FNPNG 0x07161206
529 #define ERROR_GNUPLOT_TERM 0x07161220
530 /* H 0x08xxxxxx*/
531 /* I 0x09xxxxxx*/
532 #define ERROR_INF 0x09140600
533 /* J 0x10xxxxxx*/
534 /* K 0x11xxxxxx*/
535 /* L 0x12xxxxxx*/
536 #define ERROR_LAPACK 0x12011601
537 /* M 0x13xxxxxx*/
538 #define ERROR_MALLOC 0x13011212
539 #define ERROR_MATRIX_SIZE 0x13011926
540 #define ERROR_MIN_MAX 0x13091413
541 /* N 0x14xxxxxx*/
542 #define ERROR_NAN 0x14011400
543 #define ERROR_NEGATIVE 0x14050701
544 /* O 0x15xxxxxx*/
545 #define ERROR_OVERLAP 0x15220412
546 /* P 0x16xxxxxx*/
547 #define ERROR_POLY_AN 0x16150114
548 #define ERROR_POLY_ORD 0x16151518
549 #define ERROR_PTR 0x16201800
550 /* Q 0x17xxxxxx*/
551 /* R 0x18xxxxxx*/
552 #define ERROR_RAND_SIGMA 0x18011909
553 #define ERROR_RAND_TYPE 0x18012009
554 #define ERROR_RESAMPLE_RATIO 0x18051801
555 #define ERROR_RESAMPLE_FRAC_DELAY 0x18050604
556 /* S 0x19xxxxxx*/
557 #define ERROR_SIZE 0x19092605
558 #define ERROR_SYM_TYPE 0x19251320
559 /* T 0x20xxxxxx*/
560 /* U 0x21xxxxxx*/
561 #define ERROR_UNWRAP 0x21142318
562 /* V 0x22xxxxxx*/
563 /* W 0x23xxxxxx*/
564 #define ERROR_WIN_PARAM 0x23091601
565 #define ERROR_WIN_SYM 0x23091925
566 #define ERROR_WIN_TYPE 0x23092025
567 /* X 0x24xxxxxx*/
568 #define ERROR_XCORR_FLAG 0x24031518
569 /* Y 0x25xxxxxx*/
570 /* Z 0x26xxxxxx*/
571 
572 #define DAT_MASK 0x00000001
573 #define DAT_DOUBLE 0x00000000
574 #define DAT_COMPLEX 0x00000001
575 
576 #define DSPL_MATRIX_BLOCK 32
577 
578 
579 #define DSPL_SYMMETRIC 0x00000000
580 #define DSPL_PERIODIC 0x00000001
581 
582 #define DSPL_FLAG_DIGITAL 0x00000000
583 #define DSPL_FLAG_ANALOG 0x00000001
584 #define DSPL_FLAG_LOGMAG 0x00000002
585 #define DSPL_FLAG_UNWRAP 0x00000004
586 #define DSPL_FLAG_FFT_SHIFT 0x00000008
587 #define DSPL_FLAG_PSD_TWOSIDED DSPL_FLAG_FFT_SHIFT
588 
589 
590 
591 
592 #define DSPL_WIN_SYM_MASK 0x00000001
593 #define DSPL_WIN_MASK 0x00FFFFFE
594 
595 #define DSPL_WIN_SYMMETRIC DSPL_SYMMETRIC
596 #define DSPL_WIN_PERIODIC DSPL_PERIODIC
597 
598 
599 #define DSPL_WIN_BARTLETT 0x00000004
600 #define DSPL_WIN_BARTLETT_HANN 0x00000008
601 #define DSPL_WIN_BLACKMAN 0x00000010
602 #define DSPL_WIN_BLACKMAN_HARRIS 0x00000040
603 #define DSPL_WIN_BLACKMAN_NUTTALL 0x00000080
604 #define DSPL_WIN_FLAT_TOP 0x00000100
605 #define DSPL_WIN_GAUSSIAN 0x00000400
606 #define DSPL_WIN_HAMMING 0x00000800
607 #define DSPL_WIN_HANN 0x00001000
608 #define DSPL_WIN_LANCZOS 0x00004000
609 #define DSPL_WIN_NUTTALL 0x00008000
610 #define DSPL_WIN_RECT 0x00010000
611 #define DSPL_WIN_COS 0x00040000
612 #define DSPL_WIN_CHEBY 0x00080000
613 #define DSPL_WIN_KAISER 0x00100000
614 
615 
616 #define DSPL_FILTER_TYPE_MASK 0x000000FF
617 #define DSPL_FILTER_LPF 0x00000001
618 #define DSPL_FILTER_HPF 0x00000002
619 #define DSPL_FILTER_BPASS 0x00000004
620 #define DSPL_FILTER_BSTOP 0x00000008
621 
622 #define DSPL_FILTER_APPROX_MASK 0x0000FF00
623 #define DSPL_FILTER_BUTTER 0x00000100
624 #define DSPL_FILTER_CHEBY1 0x00000200
625 #define DSPL_FILTER_CHEBY2 0x00000400
626 #define DSPL_FILTER_ELLIP 0x00000800
627 
628 
629 #define DSPL_XCORR_NOSCALE 0x00000000
630 #define DSPL_XCORR_BIASED 0x00000001
631 #define DSPL_XCORR_UNBIASED 0x00000002
632 
633 
634 
635 #define ELLIP_ITER 16
636 #define ELLIP_MAX_ORD 24
637 
638 #define DSPL_VERIF_FAILED 1
639 #define DSPL_VERIF_SUCCESS 0
640 
641 #define PLOT_HOLD 0x00000001
642 
643 #define VERIF_STR_BUF 128
644 #define VERIF_STR_LEN 48
645 #define VERIF_CHAR_POINT 46
646 #define VERIF_LEVEL_COMPLEX 1E-11
647 #define VERIF_LEVEL_DOUBLE 1E-12
648 
649 
650 
651 #ifdef __cplusplus
652  extern "C" {
653 #endif
654 
655 
656 
657 #ifdef BUILD_LIB
658  /* Declare DSPL_API for Windows OS */
659  #ifdef WIN_OS
660  #define DSPL_API __declspec(dllexport)
661  #endif /* WIN_OS */
662  /* Declare DSPL_API for LINUX OS */
663  #ifdef LINUX_OS
664  #define DSPL_API
665  #endif /* LINUX_OS */
666 #endif /* BUILD_DLL */
667 
668 #define COMMA ,
669 
670 
671 #ifdef BUILD_LIB
672  #define DECLARE_FUNC(type, fn, param)\
673  type DSPL_API fn(param);
674 #endif
675 
676 #ifndef BUILD_LIB
677  #define DECLARE_FUNC( type, fn, param)\
678  typedef type (*p_##fn)(param);\
679  extern p_##fn fn;
680 
681 #endif
682 
683 
684 
685 /*----------------------------------------------------------------------------*/
686 DECLARE_FUNC(int, acos_cmplx, complex_t*
687  COMMA int
688  COMMA complex_t*);
689 /*----------------------------------------------------------------------------*/
690 DECLARE_FUNC(int, addlog, char* str
691  COMMA char* fn);
692 /*----------------------------------------------------------------------------*/
693 DECLARE_FUNC(int, array_scale_lin, double* x
694  COMMA int n
695  COMMA double xmin
696  COMMA double xmax
697  COMMA double dx
698  COMMA double h
699  COMMA double* y);
700 /*----------------------------------------------------------------------------*/
701 DECLARE_FUNC(int, asin_cmplx, complex_t*
702  COMMA int
703  COMMA complex_t*);
704 /*----------------------------------------------------------------------------*/
705 DECLARE_FUNC(int, bessel_i0, double* x
706  COMMA int n
707  COMMA double* y);
708 /*----------------------------------------------------------------------------*/
709 DECLARE_FUNC(int, bilinear, double* bs
710  COMMA double* as
711  COMMA int ord
712  COMMA double* bz
713  COMMA double* az);
714 /*----------------------------------------------------------------------------*/
715 DECLARE_FUNC(int, butter_ap, double
716  COMMA int
717  COMMA double*
718  COMMA double*);
719 /*----------------------------------------------------------------------------*/
720 DECLARE_FUNC(int, butter_ap_zp, int
721  COMMA double
722  COMMA complex_t*
723  COMMA int*
724  COMMA complex_t*
725  COMMA int*);
726 /*----------------------------------------------------------------------------*/
727 DECLARE_FUNC(int, cheby_poly1, double*
728  COMMA int
729  COMMA int
730  COMMA double*);
731 /*----------------------------------------------------------------------------*/
732 DECLARE_FUNC(int, cheby_poly2, double*
733  COMMA int
734  COMMA int
735  COMMA double*);
736 /*----------------------------------------------------------------------------*/
737 DECLARE_FUNC(int, cheby1_ap, double
738  COMMA int
739  COMMA double*
740  COMMA double*);
741 /*----------------------------------------------------------------------------*/
742 DECLARE_FUNC(int, cheby1_ap_zp, int
743  COMMA double
744  COMMA complex_t*
745  COMMA int*
746  COMMA complex_t*
747  COMMA int*);
748 /*----------------------------------------------------------------------------*/
749 DECLARE_FUNC(int, cheby2_ap, double rs
750  COMMA int ord
751  COMMA double* b
752  COMMA double* a);
753 /*----------------------------------------------------------------------------*/
754 DECLARE_FUNC(int, cheby2_ap_wp1, double rp
755  COMMA double rs
756  COMMA int ord
757  COMMA double* b
758  COMMA double* a);
759 /*----------------------------------------------------------------------------*/
760 DECLARE_FUNC(int, cheby2_ap_zp, int
761  COMMA double
762  COMMA complex_t*
763  COMMA int*
764  COMMA complex_t*
765  COMMA int*);
766 /*----------------------------------------------------------------------------*/
767 DECLARE_FUNC(int, cmplx2re, complex_t*
768  COMMA int
769  COMMA double*
770  COMMA double*);
771 /*----------------------------------------------------------------------------*/
772 DECLARE_FUNC(int, concat, void*
773  COMMA size_t
774  COMMA void*
775  COMMA size_t
776  COMMA void*);
777 /*----------------------------------------------------------------------------*/
778 DECLARE_FUNC(int, conv, double*
779  COMMA int
780  COMMA double*
781  COMMA int
782  COMMA double*);
783 /*----------------------------------------------------------------------------*/
784 DECLARE_FUNC(int, conv_cmplx, complex_t*
785  COMMA int
786  COMMA complex_t*
787  COMMA int
788  COMMA complex_t*);
789 /*----------------------------------------------------------------------------*/
790 DECLARE_FUNC(int, conv_fft, double* a
791  COMMA int na
792  COMMA double* b
793  COMMA int nb
794  COMMA fft_t* pfft
795  COMMA int nfft
796  COMMA double* c);
797 /*----------------------------------------------------------------------------*/
798 DECLARE_FUNC(int, conv_fft_cmplx, complex_t* a
799  COMMA int na
800  COMMA complex_t* b
801  COMMA int nb
802  COMMA fft_t* pfft
803  COMMA int nfft
804  COMMA complex_t* c);
805 /*----------------------------------------------------------------------------*/
806 DECLARE_FUNC(int, cos_cmplx, complex_t*
807  COMMA int
808  COMMA complex_t*);
809 /*----------------------------------------------------------------------------*/
810 DECLARE_FUNC(int, decimate, double* x
811  COMMA int n
812  COMMA int d
813  COMMA double* y
814  COMMA int* cnt);
815 /*----------------------------------------------------------------------------*/
816 DECLARE_FUNC(int, decimate_cmplx, complex_t* x
817  COMMA int n
818  COMMA int d
819  COMMA complex_t* y
820  COMMA int* cnt);
821 /*----------------------------------------------------------------------------*/
822 DECLARE_FUNC(int, dft, double*
823  COMMA int
824  COMMA complex_t*);
825 /*----------------------------------------------------------------------------*/
826 DECLARE_FUNC(int, dft_cmplx, complex_t*
827  COMMA int
828  COMMA complex_t*);
829 /*----------------------------------------------------------------------------*/
830 DECLARE_FUNC(double, dmod, double
831  COMMA double);
832 /*----------------------------------------------------------------------------*/
833 DECLARE_FUNC(void, dspl_info, void);
834 /*----------------------------------------------------------------------------*/
835 DECLARE_FUNC(int, ellip_acd, double* w
836  COMMA int n
837  COMMA double k
838  COMMA double* u);
839 /*----------------------------------------------------------------------------*/
840 DECLARE_FUNC(int, ellip_acd_cmplx, complex_t* w
841  COMMA int n
842  COMMA double k
843  COMMA complex_t* u);
844 /*----------------------------------------------------------------------------*/
845 DECLARE_FUNC(int, ellip_ap, double rp
846  COMMA double rs
847  COMMA int ord
848  COMMA double* b
849  COMMA double* a);
850 /*----------------------------------------------------------------------------*/
851 DECLARE_FUNC(int, ellip_ap_zp, int ord
852  COMMA double rp
853  COMMA double rs
854  COMMA complex_t* z
855  COMMA int* nz
856  COMMA complex_t* p
857  COMMA int* np);
858 /*----------------------------------------------------------------------------*/
859 DECLARE_FUNC(int, ellip_asn, double* w
860  COMMA int n
861  COMMA double k
862  COMMA double* u);
863 /*----------------------------------------------------------------------------*/
864 DECLARE_FUNC(int, ellip_asn_cmplx, complex_t* w
865  COMMA int n
866  COMMA double k
867  COMMA complex_t* u);
868 /*----------------------------------------------------------------------------*/
869 DECLARE_FUNC(int, ellip_cd, double* u
870  COMMA int n
871  COMMA double k
872  COMMA double* y);
873 /*----------------------------------------------------------------------------*/
874 DECLARE_FUNC(int, ellip_cd_cmplx, complex_t* u
875  COMMA int n
876  COMMA double k
877  COMMA complex_t* y);
878 /*----------------------------------------------------------------------------*/
879 DECLARE_FUNC(int, ellip_landen, double k
880  COMMA int n
881  COMMA double* y);
882 /*----------------------------------------------------------------------------*/
883 DECLARE_FUNC(int, ellip_modulareq, double rp
884  COMMA double rs
885  COMMA int ord
886  COMMA double* k);
887 /*----------------------------------------------------------------------------*/
888 DECLARE_FUNC(int, ellip_rat, double* w
889  COMMA int n
890  COMMA int ord
891  COMMA double k
892  COMMA double* u);
893 /*----------------------------------------------------------------------------*/
894 DECLARE_FUNC(int, ellip_sn, double* u
895  COMMA int n
896  COMMA double k
897  COMMA double* y);
898 /*----------------------------------------------------------------------------*/
899 DECLARE_FUNC(int, ellip_sn_cmplx, complex_t* u
900  COMMA int n
901  COMMA double k
902  COMMA complex_t* y);
903 /*----------------------------------------------------------------------------*/
904 DECLARE_FUNC(int, farrow_lagrange, double*
905  COMMA int
906  COMMA double
907  COMMA double
908  COMMA double
909  COMMA double**
910  COMMA int*);
911 /*----------------------------------------------------------------------------*/
912 DECLARE_FUNC(int, farrow_spline, double*
913  COMMA int
914  COMMA double
915  COMMA double
916  COMMA double
917  COMMA double**
918  COMMA int*);
919 /*----------------------------------------------------------------------------*/
920 DECLARE_FUNC(int, fft, double*
921  COMMA int
922  COMMA fft_t*
923  COMMA complex_t* );
924 /*----------------------------------------------------------------------------*/
925 DECLARE_FUNC(int, fft_abs, double* x
926  COMMA int n
927  COMMA fft_t* pfft
928  COMMA double fs
929  COMMA int flag
930  COMMA double* mag
931  COMMA double* freq);
932 /*----------------------------------------------------------------------------*/
933 DECLARE_FUNC(int, fft_abs_cmplx, complex_t* x
934  COMMA int n
935  COMMA fft_t* pfft
936  COMMA double fs
937  COMMA int flag
938  COMMA double* mag
939  COMMA double* freq);
940 /*----------------------------------------------------------------------------*/
941 DECLARE_FUNC(int, fft_cmplx, complex_t*
942  COMMA int
943  COMMA fft_t*
944  COMMA complex_t* );
945 /*----------------------------------------------------------------------------*/
946 DECLARE_FUNC(int, fft_create, fft_t*
947  COMMA int);
948 /*----------------------------------------------------------------------------*/
949 DECLARE_FUNC(void, fft_free, fft_t*);
950 /*----------------------------------------------------------------------------*/
951 DECLARE_FUNC(int, fft_mag, double* x
952  COMMA int n
953  COMMA fft_t* pfft
954  COMMA double fs
955  COMMA int flag
956  COMMA double* mag
957  COMMA double* freq);
958 /*----------------------------------------------------------------------------*/
959 DECLARE_FUNC(int, fft_mag_cmplx, complex_t* x
960  COMMA int n
961  COMMA fft_t* pfft
962  COMMA double fs
963  COMMA int flag
964  COMMA double* mag
965  COMMA double* freq);
966 /*----------------------------------------------------------------------------*/
967 DECLARE_FUNC(int, fft_shift, double*
968  COMMA int n
969  COMMA double*);
970 /*----------------------------------------------------------------------------*/
971 DECLARE_FUNC(int, fft_shift_cmplx, complex_t*
972  COMMA int
973  COMMA complex_t*);
974 /*----------------------------------------------------------------------------*/
975 DECLARE_FUNC(int, filter_freq_resp, double* b
976  COMMA double* a
977  COMMA int ord
978  COMMA double* w
979  COMMA int n
980  COMMA int flag
981  COMMA double* mag
982  COMMA double* phi
983  COMMA double* tau);
984 /*----------------------------------------------------------------------------*/
985 DECLARE_FUNC(int, filter_iir, double*
986  COMMA double*
987  COMMA int
988  COMMA double*
989  COMMA int
990  COMMA double*);
991 /*----------------------------------------------------------------------------*/
992 DECLARE_FUNC(double, filter_ws1, int ord
993  COMMA double rp
994  COMMA double rs
995  COMMA int type);
996 /*----------------------------------------------------------------------------*/
997 DECLARE_FUNC(int, filter_zp2ab, complex_t*
998  COMMA int
999  COMMA complex_t*
1000  COMMA int
1001  COMMA int
1002  COMMA double*
1003  COMMA double*);
1004 /*----------------------------------------------------------------------------*/
1005 DECLARE_FUNC(int, find_max_abs, double* a
1006  COMMA int n
1007  COMMA double* m
1008  COMMA int* ind);
1009 /*----------------------------------------------------------------------------*/
1010 DECLARE_FUNC(int, fir_linphase, int ord
1011  COMMA double w0
1012  COMMA double w1
1013  COMMA int filter_type
1014  COMMA int wintype
1015  COMMA double winparam
1016  COMMA double* h);
1017 /*----------------------------------------------------------------------------*/
1018 DECLARE_FUNC(int, flipip, double*
1019  COMMA int);
1020 /*----------------------------------------------------------------------------*/
1021 DECLARE_FUNC(int, flipip_cmplx, complex_t*
1022  COMMA int);
1023 /*----------------------------------------------------------------------------*/
1024 DECLARE_FUNC(int, fourier_integral_cmplx, double* t
1025  COMMA complex_t* s
1026  COMMA int nt
1027  COMMA int nw
1028  COMMA double* w
1029  COMMA complex_t* y);
1030 /*----------------------------------------------------------------------------*/
1031 DECLARE_FUNC(int, fourier_series_dec, double*
1032  COMMA double*
1033  COMMA int
1034  COMMA double
1035  COMMA int
1036  COMMA double*
1037  COMMA complex_t*);
1038 /*----------------------------------------------------------------------------*/
1039 DECLARE_FUNC(int, fourier_series_dec_cmplx, double* t
1040  COMMA complex_t* s
1041  COMMA int nt
1042  COMMA double period
1043  COMMA int nw
1044  COMMA double* w
1045  COMMA complex_t* y);
1046 /*----------------------------------------------------------------------------*/
1047 DECLARE_FUNC(int, fourier_series_rec, double*
1048  COMMA complex_t*
1049  COMMA int
1050  COMMA double*
1051  COMMA int
1052  COMMA complex_t*);
1053 /*----------------------------------------------------------------------------*/
1054 DECLARE_FUNC(int, freqs, double*
1055  COMMA double*
1056  COMMA int
1057  COMMA double*
1058  COMMA int
1059  COMMA complex_t*);
1060 /*----------------------------------------------------------------------------*/
1061 DECLARE_FUNC(int, freqs_cmplx, double* b
1062  COMMA double* a
1063  COMMA int ord
1064  COMMA complex_t* s
1065  COMMA int n
1066  COMMA complex_t* h);
1067 /*----------------------------------------------------------------------------*/
1068 DECLARE_FUNC(int, freqs2time, double*
1069  COMMA double*
1070  COMMA int
1071  COMMA double
1072  COMMA int
1073  COMMA fft_t*
1074  COMMA double*
1075  COMMA double*);
1076 /*----------------------------------------------------------------------------*/
1077 DECLARE_FUNC(int, freqz, double*
1078  COMMA double*
1079  COMMA int
1080  COMMA double*
1081  COMMA int
1082  COMMA complex_t*);
1083 /*----------------------------------------------------------------------------*/
1084 DECLARE_FUNC(void, gnuplot_close, void* h);
1085 /*----------------------------------------------------------------------------*/
1086 DECLARE_FUNC(void, gnuplot_cmd, void* h
1087  COMMA char* cmd);
1088 /*----------------------------------------------------------------------------*/
1089 DECLARE_FUNC(int, gnuplot_create, int argc
1090  COMMA char* argv[]
1091  COMMA int w
1092  COMMA int h
1093  COMMA char* fn_png
1094  COMMA void** hplot);
1095 /*----------------------------------------------------------------------------*/
1096 DECLARE_FUNC(int, gnuplot_open, void** hplot);
1097 /*----------------------------------------------------------------------------*/
1098 DECLARE_FUNC(int, goertzel, double*
1099  COMMA int
1100  COMMA int*
1101  COMMA int
1102  COMMA complex_t*);
1103 /*----------------------------------------------------------------------------*/
1104 DECLARE_FUNC(int, goertzel_cmplx, complex_t*
1105  COMMA int
1106  COMMA int*
1107  COMMA int
1108  COMMA complex_t*);
1109 /*----------------------------------------------------------------------------*/
1110 DECLARE_FUNC(int, group_delay, double* b
1111  COMMA double* a
1112  COMMA int ord
1113  COMMA int flag
1114  COMMA double* w
1115  COMMA int n
1116  COMMA double* tau);
1117 /*----------------------------------------------------------------------------*/
1118 DECLARE_FUNC(int, histogram, double* x
1119  COMMA int n
1120  COMMA int nh
1121  COMMA double* pedges
1122  COMMA double* ph);
1123 /*----------------------------------------------------------------------------*/
1124 DECLARE_FUNC(int, histogram_norm, double* y
1125  COMMA int n
1126  COMMA int nh
1127  COMMA double* x
1128  COMMA double* w);
1129 /*----------------------------------------------------------------------------*/
1130 DECLARE_FUNC(int, idft_cmplx, complex_t*
1131  COMMA int
1132  COMMA complex_t*);
1133 /*----------------------------------------------------------------------------*/
1134 DECLARE_FUNC(int, ifft_cmplx, complex_t*
1135  COMMA int
1136  COMMA fft_t*
1137  COMMA complex_t* );
1138 /*----------------------------------------------------------------------------*/
1139 DECLARE_FUNC(int, iir, double rp
1140  COMMA double rs
1141  COMMA int ord
1142  COMMA double w0
1143  COMMA double w1
1144  COMMA int type
1145  COMMA double* b
1146  COMMA double* a);
1147 /*----------------------------------------------------------------------------*/
1148 DECLARE_FUNC(int, linspace, double
1149  COMMA double
1150  COMMA int
1151  COMMA int
1152  COMMA double*);
1153 /*----------------------------------------------------------------------------*/
1154 DECLARE_FUNC(int, log_cmplx, complex_t*
1155  COMMA int
1156  COMMA complex_t*);
1157 /*----------------------------------------------------------------------------*/
1158 DECLARE_FUNC(int, logspace, double
1159  COMMA double
1160  COMMA int
1161  COMMA int
1162  COMMA double*);
1163 /*----------------------------------------------------------------------------*/
1164 DECLARE_FUNC(int, low2bp, double* b
1165  COMMA double* a
1166  COMMA int ord
1167  COMMA double w0
1168  COMMA double wpl
1169  COMMA double wph
1170  COMMA double* beta
1171  COMMA double* alpha);
1172 /*----------------------------------------------------------------------------*/
1173 DECLARE_FUNC(int, low2bs, double* b
1174  COMMA double* a
1175  COMMA int ord
1176  COMMA double w0
1177  COMMA double wsl
1178  COMMA double wsh
1179  COMMA double* beta
1180  COMMA double* alpha);
1181 /*----------------------------------------------------------------------------*/
1182 DECLARE_FUNC(int, low2high, double* b
1183  COMMA double* a
1184  COMMA int ord
1185  COMMA double w0
1186  COMMA double w1
1187  COMMA double* beta
1188  COMMA double* alpha);
1189 /*----------------------------------------------------------------------------*/
1190 DECLARE_FUNC(int, low2low, double* b
1191  COMMA double* a
1192  COMMA int ord
1193  COMMA double w0
1194  COMMA double w1
1195  COMMA double* beta
1196  COMMA double* alpha);
1197 /*----------------------------------------------------------------------------*/
1198 DECLARE_FUNC(int, matrix_eig_cmplx, complex_t* a
1199  COMMA int n
1200  COMMA complex_t* v
1201  COMMA int* info);
1202 /*----------------------------------------------------------------------------*/
1203 DECLARE_FUNC(int, matrix_eye, double* a
1204  COMMA int n
1205  COMMA int m);
1206 /*----------------------------------------------------------------------------*/
1207 DECLARE_FUNC(int, matrix_eye_cmplx, complex_t* a
1208  COMMA int n
1209  COMMA int m);
1210 /*----------------------------------------------------------------------------*/
1211 DECLARE_FUNC(int, matrix_mul, double* a
1212  COMMA int na
1213  COMMA int ma
1214  COMMA double* b
1215  COMMA int nb
1216  COMMA int mb
1217  COMMA double* c);
1218 /*----------------------------------------------------------------------------*/
1219 DECLARE_FUNC(int, matrix_print, double* a
1220  COMMA int n
1221  COMMA int m
1222  COMMA const char* name
1223  COMMA const char* format);
1224 /*----------------------------------------------------------------------------*/
1225 DECLARE_FUNC(int, matrix_print_cmplx, complex_t* a
1226  COMMA int n
1227  COMMA int m
1228  COMMA const char* name
1229  COMMA const char* format);
1230 /*----------------------------------------------------------------------------*/
1231 DECLARE_FUNC(int, matrix_transpose, double* a
1232  COMMA int n
1233  COMMA int m
1234  COMMA double* b);
1235 /*----------------------------------------------------------------------------*/
1236 DECLARE_FUNC(int, matrix_transpose_cmplx, complex_t* a
1237  COMMA int n
1238  COMMA int m
1239  COMMA complex_t* b);
1240 /*----------------------------------------------------------------------------*/
1241 DECLARE_FUNC(int, matrix_transpose_hermite, complex_t* a
1242  COMMA int n
1243  COMMA int m
1244  COMMA complex_t* b);
1245 /*----------------------------------------------------------------------------*/
1246 DECLARE_FUNC(int, mean, double* x
1247  COMMA int n
1248  COMMA double* m);
1249 /*----------------------------------------------------------------------------*/
1250 DECLARE_FUNC(int, mean_cmplx, complex_t* x
1251  COMMA int n
1252  COMMA complex_t* m);
1253 /*----------------------------------------------------------------------------*/
1254 DECLARE_FUNC(int, minmax, double* x
1255  COMMA int n
1256  COMMA double* xmin
1257  COMMA double* xmax);
1258 /*----------------------------------------------------------------------------*/
1259 DECLARE_FUNC(int, ones, double* x
1260  COMMA int n);
1261 /*----------------------------------------------------------------------------*/
1262 DECLARE_FUNC(int, phase_delay, double* b
1263  COMMA double* a
1264  COMMA int ord
1265  COMMA int flag
1266  COMMA double* w
1267  COMMA int n
1268  COMMA double* tau);
1269 /*----------------------------------------------------------------------------*/
1270 DECLARE_FUNC(int, poly_z2a_cmplx, complex_t*
1271  COMMA int
1272  COMMA int
1273  COMMA complex_t*);
1274 /*----------------------------------------------------------------------------*/
1275 DECLARE_FUNC(int, polyroots, double* a
1276  COMMA int ord
1277  COMMA complex_t* r
1278  COMMA int* info);
1279 /*----------------------------------------------------------------------------*/
1280 DECLARE_FUNC(int, polyval, double*
1281  COMMA int
1282  COMMA double*
1283  COMMA int
1284  COMMA double*);
1285 /*----------------------------------------------------------------------------*/
1286 DECLARE_FUNC(int, polyval_cmplx, complex_t*
1287  COMMA int
1288  COMMA complex_t*
1289  COMMA int
1290  COMMA complex_t*);
1291 /*----------------------------------------------------------------------------*/
1292 DECLARE_FUNC(int, psd_bartlett, double* x
1293  COMMA int n
1294  COMMA int nfft
1295  COMMA fft_t* pfft
1296  COMMA double fs
1297  COMMA int flag
1298  COMMA double* ppsd
1299  COMMA double* pfrq);
1300 /*----------------------------------------------------------------------------*/
1301 DECLARE_FUNC(int, psd_bartlett_cmplx, complex_t* x
1302  COMMA int n
1303  COMMA int nfft
1304  COMMA fft_t* pfft
1305  COMMA double fs
1306  COMMA int flag
1307  COMMA double* ppsd
1308  COMMA double* pfrq);
1309 /*----------------------------------------------------------------------------*/
1310 DECLARE_FUNC(int, psd_periodogram, double* x
1311  COMMA int n
1312  COMMA int win_type
1313  COMMA double win_param
1314  COMMA fft_t* pfft
1315  COMMA double fs
1316  COMMA int flag
1317  COMMA double* ppsd
1318  COMMA double* pfrq);
1319 /*----------------------------------------------------------------------------*/
1320 DECLARE_FUNC(int, psd_periodogram_cmplx, complex_t* x
1321  COMMA int n
1322  COMMA int win_type
1323  COMMA double win_param
1324  COMMA fft_t* pfft
1325  COMMA double fs
1326  COMMA int flag
1327  COMMA double* ppsd
1328  COMMA double* pfrq);
1329 /*----------------------------------------------------------------------------*/
1330 DECLARE_FUNC(int, psd_welch, double* x
1331  COMMA int n
1332  COMMA int win_type
1333  COMMA double win_param
1334  COMMA int npsd
1335  COMMA int noverlap
1336  COMMA fft_t* pfft
1337  COMMA double fs
1338  COMMA int flag
1339  COMMA double* ppsd
1340  COMMA double* pfrq);
1341 /*----------------------------------------------------------------------------*/
1342 DECLARE_FUNC(int, psd_welch_cmplx, complex_t* x
1343  COMMA int n
1344  COMMA int win_type
1345  COMMA double win_param
1346  COMMA int npsd
1347  COMMA int noverlap
1348  COMMA fft_t* pfft
1349  COMMA double fs
1350  COMMA int flag
1351  COMMA double* ppsd
1352  COMMA double* pfrq);
1353 /*----------------------------------------------------------------------------*/
1354 DECLARE_FUNC(int, randb, double* x
1355  COMMA int n
1356  COMMA random_t* prnd);
1357 /*----------------------------------------------------------------------------*/
1358 DECLARE_FUNC(int, randb2, double* x
1359  COMMA int n
1360  COMMA random_t* prnd);
1361 /*----------------------------------------------------------------------------*/
1362 DECLARE_FUNC(int, randi, int* x
1363  COMMA int n
1364  COMMA int start
1365  COMMA int stop
1366  COMMA random_t* prnd);
1367 /*----------------------------------------------------------------------------*/
1368 DECLARE_FUNC(int, randn, double* x
1369  COMMA int n
1370  COMMA double mu
1371  COMMA double sigma
1372  COMMA random_t* prnd);
1373 /*----------------------------------------------------------------------------*/
1374 DECLARE_FUNC(int, randn_cmplx, complex_t* x
1375  COMMA int n
1376  COMMA complex_t* mu
1377  COMMA double sigma
1378  COMMA random_t* prnd);
1379 /*----------------------------------------------------------------------------*/
1380 DECLARE_FUNC(int, random_init, random_t* prnd
1381  COMMA int type
1382  COMMA void* seed);
1383 /*----------------------------------------------------------------------------*/
1384 DECLARE_FUNC(int, randu, double*
1385  COMMA int
1386  COMMA random_t* prnd);
1387 /*----------------------------------------------------------------------------*/
1388 DECLARE_FUNC(int, ratcompos, double* b
1389  COMMA double* a
1390  COMMA int n
1391  COMMA double* c
1392  COMMA double* d
1393  COMMA int p
1394  COMMA double* beta
1395  COMMA double* alpha);
1396 /*----------------------------------------------------------------------------*/
1397 DECLARE_FUNC(int, re2cmplx, double*
1398  COMMA int
1399  COMMA complex_t*);
1400 /*----------------------------------------------------------------------------*/
1401 DECLARE_FUNC(int, readbin, char* fn
1402  COMMA void** x
1403  COMMA int* k
1404  COMMA int* dtype);
1405 /*----------------------------------------------------------------------------*/
1406 DECLARE_FUNC(int, signal_pimp, double*
1407  COMMA size_t
1408  COMMA double
1409  COMMA double
1410  COMMA double
1411  COMMA double
1412  COMMA double*);
1413 /*----------------------------------------------------------------------------*/
1414 DECLARE_FUNC(int, signal_saw, double* t
1415  COMMA size_t n
1416  COMMA double amp
1417  COMMA double dt
1418  COMMA double period
1419  COMMA double* y);
1420 /*----------------------------------------------------------------------------*/
1421 DECLARE_FUNC(int, sin_cmplx, complex_t*
1422  COMMA int
1423  COMMA complex_t*);
1424 /*----------------------------------------------------------------------------*/
1425 DECLARE_FUNC(int, sinc, double* x
1426  COMMA int n
1427  COMMA double a
1428  COMMA double* y);
1429 /*----------------------------------------------------------------------------*/
1430 DECLARE_FUNC(int, sine_int, double* x
1431  COMMA int n
1432  COMMA double* si);
1433 /*----------------------------------------------------------------------------*/
1434 DECLARE_FUNC(int, sqrt_cmplx, complex_t*
1435  COMMA int
1436  COMMA complex_t*);
1437 /*----------------------------------------------------------------------------*/
1438 DECLARE_FUNC(int, std, double* x
1439  COMMA int n
1440  COMMA double* s);
1441 /*----------------------------------------------------------------------------*/
1442 DECLARE_FUNC(int, std_cmplx, complex_t* x
1443  COMMA int n
1444  COMMA double* s);
1445 /*----------------------------------------------------------------------------*/
1446 DECLARE_FUNC(int, trapint, double*
1447  COMMA double*
1448  COMMA int
1449  COMMA double*);
1450 /*----------------------------------------------------------------------------*/
1451 DECLARE_FUNC(int, trapint_cmplx, double*
1452  COMMA complex_t*
1453  COMMA int
1454  COMMA complex_t*);
1455 /*----------------------------------------------------------------------------*/
1456 DECLARE_FUNC(int, unwrap, double*
1457  COMMA int
1458  COMMA double
1459  COMMA double);
1460 /*----------------------------------------------------------------------------*/
1461 DECLARE_FUNC(int, vector_dot, double* x
1462  COMMA double* y
1463  COMMA int n
1464  COMMA double* p);
1465 /*----------------------------------------------------------------------------*/
1466 DECLARE_FUNC(int, verif, double* x
1467  COMMA double* y
1468  COMMA size_t n
1469  COMMA double eps
1470  COMMA double* err);
1471 /*----------------------------------------------------------------------------*/
1472 DECLARE_FUNC(int, verif_data_gen, int len
1473  COMMA int type
1474  COMMA char* fn);
1475 /*----------------------------------------------------------------------------*/
1476 DECLARE_FUNC(int, verif_cmplx, complex_t* x
1477  COMMA complex_t* y
1478  COMMA size_t n
1479  COMMA double eps
1480  COMMA double* err);
1481 /*----------------------------------------------------------------------------*/
1482 DECLARE_FUNC(void, verif_str, double* yout
1483  COMMA int nout
1484  COMMA char* str_msg
1485  COMMA char* outfn
1486  COMMA char* logfn);
1487 /*----------------------------------------------------------------------------*/
1488 DECLARE_FUNC(void, verif_str_cmplx, complex_t* yout
1489  COMMA int nout
1490  COMMA char* str_msg
1491  COMMA char* outfn
1492  COMMA char* logfn);
1493 /*----------------------------------------------------------------------------*/
1494 DECLARE_FUNC(int, window, double* w
1495  COMMA int n
1496  COMMA int win_type
1497  COMMA double param);
1498 /*----------------------------------------------------------------------------*/
1499 DECLARE_FUNC(int, writebin, void*
1500  COMMA int
1501  COMMA int
1502  COMMA char*);
1503 /*----------------------------------------------------------------------------*/
1504 DECLARE_FUNC(int, writetxt, double*
1505  COMMA double*
1506  COMMA int
1507  COMMA char* );
1508 /*----------------------------------------------------------------------------*/
1509 DECLARE_FUNC(int, writetxt_3d, double* x
1510  COMMA int nx
1511  COMMA double* y
1512  COMMA int ny
1513  COMMA double* z
1514  COMMA char* fn);
1515 /*----------------------------------------------------------------------------*/
1516 DECLARE_FUNC(int, writetxt_3dline, double* x
1517  COMMA double* y
1518  COMMA double* z
1519  COMMA int n
1520  COMMA char* fn);
1521 /*----------------------------------------------------------------------------*/
1522 DECLARE_FUNC(int, writetxt_cmplx, complex_t* x
1523  COMMA int n
1524  COMMA char* fn);
1525 /*----------------------------------------------------------------------------*/
1526 DECLARE_FUNC(int, writetxt_cmplx_im, double*
1527  COMMA complex_t*
1528  COMMA int
1529  COMMA char*);
1530 /*----------------------------------------------------------------------------*/
1531 DECLARE_FUNC(int, writetxt_cmplx_re, double*
1532  COMMA complex_t*
1533  COMMA int
1534  COMMA char*);
1535 /*----------------------------------------------------------------------------*/
1536 DECLARE_FUNC(int, writetxt_int, int*
1537  COMMA int*
1538  COMMA int
1539  COMMA char*);
1540 /*----------------------------------------------------------------------------*/
1541 DECLARE_FUNC(int, xcorr, double* x
1542  COMMA int nx
1543  COMMA double* y
1544  COMMA int ny
1545  COMMA int flag
1546  COMMA int nr
1547  COMMA double* r
1548  COMMA double* t);
1549 /*----------------------------------------------------------------------------*/
1550 DECLARE_FUNC(int, xcorr_cmplx, complex_t* x
1551  COMMA int nx
1552  COMMA complex_t* y
1553  COMMA int ny
1554  COMMA int flag
1555  COMMA int nr
1556  COMMA complex_t* r
1557  COMMA double* t);
1558 /*----------------------------------------------------------------------------*/
1559 
1560 
1561 #ifdef __cplusplus
1562  }
1563 #endif
1564 
1565 
1566 #ifdef DOXYGEN_ENGLISH
1567 
1619 #endif
1620 #ifdef DOXYGEN_RUSSIAN
1621 
1673 #endif
1674 void* dspl_load();
1675 
1676 
1677 
1678 
1679 
1680 #ifdef DOXYGEN_ENGLISH
1681 
1697 #endif
1698 #ifdef DOXYGEN_RUSSIAN
1699 
1715 #endif
1716 void dspl_free(void* handle);
1717 
1718 
1719 
1720 #endif /* DSPL_H */
1721 
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:594
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:664
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:1153
int psd_welch_cmplx(complex_t *x, int n, int win_type, double win_param, int nfft, int noverlap, fft_t *pfft, double fs, int flag, double *ppsd, double *pfrq)
Непараметрическая оценка спектральной плотности мощности (СПМ) комплексного сигнала методом Уэлча.
Definition: psd.c:1321
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:892
int fft_cmplx(complex_t *x, int n, fft_t *pfft, complex_t *y)
Быстрое преобразование Фурье комплексного сигнала
Definition: fft.c:645
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 std_cmplx(complex_t *x, int n, double *s)
Выборочная оценка стандартного отклонения комплексного вектора x
Definition: statistic.c:662
int psd_bartlett_cmplx(complex_t *x, int n, int nfft, fft_t *pfft, double fs, int flag, double *ppsd, double *pfrq)
Непараметрическая оценка спектральной плотности мощности (СПМ) комплексного сигнала методом Бартлетта...
Definition: psd.c:367
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:1009
int phase_delay(double *b, double *a, int ord, int flag, double *w, int n, double *tau)
Расчет фазовой задержки цифрового или аналогового фильтра.
Definition: filter_an.c:1190
int psd_periodogram_cmplx(complex_t *x, int n, int win_type, double win_param, fft_t *pfft, double fs, int flag, double *ppsd, double *pfrq)
Непараметрическая оценка спектральной плотности мощности (СПМ) комплексного сигнала методом модифицир...
Definition: psd.c:818
int psd_welch(double *x, int n, int win_type, double win_param, int nfft, int noverlap, fft_t *pfft, double fs, int flag, double *ppsd, double *pfrq)
Непараметрическая оценка спектральной плотности мощности (СПМ) вещественного сигнала методом Уэлча.
Definition: psd.c:1060
int psd_bartlett(double *x, int n, int nfft, fft_t *pfft, double fs, int flag, double *ppsd, double *pfrq)
Непараметрическая оценка спектральной плотности мощности (СПМ) вещественного сигнала методом Бартлетт...
Definition: psd.c:149
int type
Definition: dspl.h:299
void * dspl_load()
Произвести динамическую линковку и загрузить функции libdspl-2.0.
int ellip_sn_cmplx(complex_t *u, int n, double k, complex_t *y)
Эллиптическая функция Якоби комплексного аргумента
Definition: ellipj.c:1216
int ellip_sn(double *u, int n, double k, double *y)
Эллиптическая функция Якоби вещественного аргумента
Definition: ellipj.c:1111
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:727
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:880
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 std(double *x, int n, double *s)
Выборочная оценка стандартного отклонения вещественного вектора x
Definition: statistic.c:556
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
void dspl_free(void *handle)
Очищает связанную ранее динамическую библиотеку DSPL-2.0.
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 mean_cmplx(complex_t *x, int n, complex_t *m)
Выборочная оценка математического ожидания комплексного вектора x
Definition: statistic.c:407
int ellip_cd_cmplx(complex_t *u, int n, double k, complex_t *y)
Эллиптическая функция Якоби комплексного аргумента
Definition: ellipj.c:701
int psd_periodogram(double *x, int n, int win_type, double win_param, fft_t *pfft, double fs, int flag, double *ppsd, double *pfrq)
Непараметрическая оценка спектральной плотности мощности (СПМ) вещественного сигнала методом модифици...
Definition: psd.c:590
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:889
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 mean(double *x, int n, double *m)
Выборочная оценка математического ожидания вещественного вектора x
Definition: statistic.c:309
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