libdspl-2.0
Библиотека алгоритмов цифровой обработки сигналов
psd.c
1 /*
2 * Copyright (c) 2015-2019 Sergey Bakhurin
3 * Digital Signal Processing Library [http://dsplib.org]
4 *
5 * This file is part of libdspl-2.0.
6 *
7 * is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * DSPL is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with Foobar. If not, see <http://www.gnu.org/licenses/>.
19 */
20 
21 #include <stdlib.h>
22 #include <stdio.h>
23 #include <string.h>
24 #include <float.h>
25 #include "dspl.h"
26 
27 
28 
29 
30 
31 
32 #ifdef DOXYGEN_ENGLISH
33 
34 #endif
35 #ifdef DOXYGEN_RUSSIAN
36 
148 #endif
149 int DSPL_API psd_bartlett(double* x, int n, int nfft,
150  fft_t* pfft, double fs,
151  int flag, double* ppsd, double* pfrq)
152 {
153  int err, pos, k;
154  double *pdgr = NULL;
155  double *tmp = NULL;
156  fft_t *ptr_fft = NULL;
157 
158  pos = 0;
159 
160  pdgr = (double*)malloc(nfft * sizeof(double));
161  if(!pdgr)
162  return ERROR_MALLOC;
163 
164  if(!pfft)
165  {
166  ptr_fft = (fft_t*)malloc(sizeof(fft_t));
167  memset(ptr_fft, 0, sizeof(fft_t));
168  }
169  else
170  ptr_fft = pfft;
171 
172  memset(ppsd, 0, nfft * sizeof(double));
173  while(pos + nfft <= n)
174  {
175  err = fft_mag(x + pos, nfft, ptr_fft, fs,
176  flag & DSPL_FLAG_FFT_SHIFT, pdgr, NULL);
177  if(err != RES_OK)
178  goto exit_label;
179  for(k = 0; k < nfft; k++)
180  ppsd[k] += pdgr[k];
181  pos += nfft;
182  }
183 
184  if(pos < n)
185  {
186  tmp = (double*)malloc(nfft * sizeof(double));
187  if(!tmp)
188  {
189  err = ERROR_MALLOC;
190  goto exit_label;
191  }
192  memset(tmp ,0, nfft * sizeof(double));
193  memcpy(tmp, x + pos, (n - pos)*sizeof(double));
194 
195  err = fft_mag(tmp, nfft, ptr_fft, fs,
196  flag & DSPL_FLAG_FFT_SHIFT, pdgr, NULL);
197  if(err != RES_OK)
198  goto exit_label;
199 
200  for(k = 0; k < nfft; k++)
201  ppsd[k] += pdgr[k];
202  }
203 
204  /* fill frequency */
205  if(pfrq)
206  {
207  if(flag & DSPL_FLAG_FFT_SHIFT)
208  if(n%2)
209  err = linspace(-fs*0.5 + fs*0.5/(double)nfft,
210  fs*0.5 - fs*0.5/(double)nfft,
211  n, DSPL_SYMMETRIC, pfrq);
212  else
213  err = linspace(-fs*0.5, fs*0.5, nfft, DSPL_PERIODIC, pfrq);
214  else
215  err = linspace(0, fs, nfft, DSPL_PERIODIC, pfrq);
216  }
217 
218  /* scale magnitude */
219  if(flag & DSPL_FLAG_LOGMAG)
220  {
221  for(k = 0; k < nfft; k++)
222  ppsd[k] = 10.0 * log10(ppsd[k] / (double)n / fs);
223  }
224  else
225  {
226  for(k = 0; k < nfft; k++)
227  ppsd[k] /= (double)n * fs;
228  }
229 
230 
231 exit_label:
232  if(pdgr)
233  free(pdgr);
234  if(tmp)
235  free(tmp);
236  if(ptr_fft && (ptr_fft != pfft))
237  {
238  fft_free(ptr_fft);
239  free(ptr_fft);
240  }
241  return err;
242 }
243 
244 
245 
246 
247 
248 
249 
250 #ifdef DOXYGEN_ENGLISH
251 
252 #endif
253 #ifdef DOXYGEN_RUSSIAN
254 
366 #endif
367 int DSPL_API psd_bartlett_cmplx(complex_t* x, int n, int nfft,
368  fft_t* pfft, double fs,
369  int flag, double* ppsd, double* pfrq)
370 {
371  int err, pos, k;
372  double *pdgr = NULL;
373  complex_t *tmp = NULL;
374  fft_t *ptr_fft = NULL;
375 
376  pos = 0;
377 
378  pdgr = (double*)malloc(nfft * sizeof(double));
379  if(!pdgr)
380  return ERROR_MALLOC;
381 
382  if(!pfft)
383  {
384  ptr_fft = (fft_t*)malloc(sizeof(fft_t));
385  memset(ptr_fft, 0, sizeof(fft_t));
386  }
387  else
388  ptr_fft = pfft;
389 
390  memset(ppsd, 0, nfft * sizeof(double));
391  while(pos + nfft <= n)
392  {
393  err = fft_mag_cmplx(x + pos, nfft, ptr_fft, fs,
394  flag & DSPL_FLAG_FFT_SHIFT, pdgr, NULL);
395  if(err != RES_OK)
396  goto exit_label;
397  for(k = 0; k < nfft; k++)
398  ppsd[k] += pdgr[k];
399  pos += nfft;
400  }
401 
402  if(pos < n)
403  {
404  tmp = (complex_t*)malloc(nfft * sizeof(complex_t));
405  if(!tmp)
406  {
407  err = ERROR_MALLOC;
408  goto exit_label;
409  }
410  memset(tmp ,0, nfft * sizeof(complex_t));
411  memcpy(tmp, x + pos, (n - pos)*sizeof(complex_t));
412 
413  err = fft_mag_cmplx(tmp, nfft, ptr_fft, fs,
414  flag & DSPL_FLAG_FFT_SHIFT, pdgr, NULL);
415  if(err != RES_OK)
416  goto exit_label;
417 
418  for(k = 0; k < nfft; k++)
419  ppsd[k] += pdgr[k];
420  }
421 
422  /* fill frequency */
423  if(pfrq)
424  {
425  if(flag & DSPL_FLAG_FFT_SHIFT)
426  if(n%2)
427  err = linspace(-fs*0.5 + fs*0.5/(double)nfft,
428  fs*0.5 - fs*0.5/(double)nfft,
429  n, DSPL_SYMMETRIC, pfrq);
430  else
431  err = linspace(-fs*0.5, fs*0.5, nfft, DSPL_PERIODIC, pfrq);
432  else
433  err = linspace(0, fs, nfft, DSPL_PERIODIC, pfrq);
434  }
435 
436  /* scale magnitude */
437  if(flag & DSPL_FLAG_LOGMAG)
438  {
439  for(k = 0; k < nfft; k++)
440  ppsd[k] = 10.0 * log10(ppsd[k] / (double)n / fs);
441  }
442  else
443  {
444  for(k = 0; k < nfft; k++)
445  ppsd[k] /= (double)n * fs;
446  }
447 
448 
449 exit_label:
450  if(pdgr)
451  free(pdgr);
452  if(tmp)
453  free(tmp);
454  if(ptr_fft && (ptr_fft != pfft))
455  {
456  fft_free(ptr_fft);
457  free(ptr_fft);
458  }
459  return err;
460 }
461 
462 
463 
464 
465 
466 
467 #ifdef DOXYGEN_ENGLISH
468 
469 #endif
470 #ifdef DOXYGEN_RUSSIAN
471 
589 #endif
590 int DSPL_API psd_periodogram(double* x, int n,
591  int win_type, double win_param,
592  fft_t* pfft, double fs,
593  int flag, double* ppsd, double* pfrq)
594 {
595  double *w = NULL;
596  double *s = NULL;
597  double u, wn;
598  int err, k;
599  fft_t *ptr_fft = NULL;
600 
601  if(!x || !ppsd)
602  return ERROR_PTR;
603 
604  if(n<1 )
605  return ERROR_SIZE;
606 
607  if(fs < 0.0)
608  return ERROR_FS;
609 
610  if(!pfft)
611  {
612  ptr_fft = (fft_t*)malloc(sizeof(fft_t));
613  memset(ptr_fft, 0, sizeof(fft_t));
614  }
615  else
616  ptr_fft = pfft;
617 
618 
619  if(win_type != DSPL_WIN_RECT)
620  {
621  /* Modified periodogram calculation */
622 
623  /* window malloc */
624  w = (double*)malloc(n*sizeof(double));
625  if(!w)
626  {
627  err = ERROR_MALLOC;
628  goto exit_label;
629  }
630 
631  /* create window */
632  err = window(w, n, win_type, win_param);
633  if(err != RES_OK)
634  goto exit_label;
635 
636  /* window normalization wn = sum(w.^2) */
637  wn = 0;
638  for(k = 0; k < n; k++)
639  wn += w[k]*w[k];
640 
641  /* signal buffer malloc */
642  s = (double*)malloc(n*sizeof(double));
643  if(!s)
644  {
645  err = ERROR_MALLOC;
646  goto exit_label;
647  }
648 
649  /* windowing */
650  for(k = 0; k < n; k++)
651  s[k] = x[k] * w[k];
652  }
653  else
654  {
655  /* classic periodogram without windowing */
656  s = x;
657  wn = (double)n;
658  }
659 
660  /* calculate FFT */
661  err = fft_mag(s, n, ptr_fft, fs, flag, ppsd, pfrq);
662  if(err != RES_OK)
663  goto exit_label;
664 
665 
666  if(flag & DSPL_FLAG_LOGMAG)
667  {
668  /* normalization in log scale */
669  u = 10.0 * log10(wn * fs);
670  for(k = 0; k < n; k++)
671  ppsd[k] -= u;
672  }
673  else
674  {
675  /* normalization in linear scale */
676  u = 1.0 / (wn * fs);
677  for(k = 0; k < n; k++)
678  ppsd[k] *= u;
679  }
680 
681 exit_label:
682  if(w)
683  free(w);
684  if(s && s != x)
685  free(s);
686  if(ptr_fft && (ptr_fft != pfft))
687  {
688  fft_free(ptr_fft);
689  free(ptr_fft);
690  }
691  return err;
692 }
693 
694 
695 
696 #ifdef DOXYGEN_ENGLISH
697 
698 #endif
699 #ifdef DOXYGEN_RUSSIAN
700 
817 #endif
818 int DSPL_API psd_periodogram_cmplx(complex_t* x, int n,
819  int win_type, double win_param,
820  fft_t* pfft, double fs,
821  int flag, double* ppsd, double* pfrq)
822 {
823  double *w = NULL;
824  complex_t *s = NULL;
825  double u, wn;
826  int err, k;
827  fft_t *ptr_fft = NULL;
828 
829  if(!x || !ppsd)
830  return ERROR_PTR;
831 
832  if(n<1 )
833  return ERROR_SIZE;
834 
835  if(fs < 0.0)
836  return ERROR_FS;
837 
838  if(!pfft)
839  {
840  ptr_fft = (fft_t*)malloc(sizeof(fft_t));
841  memset(ptr_fft, 0, sizeof(fft_t));
842  }
843  else
844  ptr_fft = pfft;
845 
846 
847  if(win_type != DSPL_WIN_RECT)
848  {
849  /* Modified periodogram calculation */
850 
851  /* window malloc */
852  w = (double*)malloc(n*sizeof(double));
853  if(!w)
854  {
855  err = ERROR_MALLOC;
856  goto exit_label;
857  }
858 
859  /* create window */
860  err = window(w, n, win_type, win_param);
861  if(err != RES_OK)
862  goto exit_label;
863 
864  /* window normalization wn = sum(w.^2) */
865  wn = 0;
866  for(k = 0; k < n; k++)
867  wn += w[k]*w[k];
868 
869  /* signal buffer malloc */
870  s = (complex_t*)malloc(n*sizeof(complex_t));
871  if(!s)
872  {
873  err = ERROR_MALLOC;
874  goto exit_label;
875  }
876 
877  /* windowing */
878  for(k = 0; k < n; k++)
879  {
880  RE(s[k]) = RE(x[k]) * w[k];
881  IM(s[k]) = IM(x[k]) * w[k];
882  }
883  }
884  else
885  {
886  /* classic periodogram without windowing */
887  s = x;
888  wn = (double)n;
889  }
890 
891  /* calculate FFT */
892  err = fft_mag_cmplx(s, n, ptr_fft, fs, flag, ppsd, pfrq);
893  if(err != RES_OK)
894  goto exit_label;
895 
896 
897  if(flag & DSPL_FLAG_LOGMAG)
898  {
899  /* normalization in log scale */
900  u = 10.0 * log10(wn * fs);
901  for(k = 0; k < n; k++)
902  ppsd[k] -= u;
903  }
904  else
905  {
906  /* normalization in linear scale */
907  u = 1.0 / (wn * fs);
908  for(k = 0; k < n; k++)
909  ppsd[k] *= u;
910  }
911 
912 exit_label:
913  if(w)
914  free(w);
915  if(s && s != x)
916  free(s);
917  if(ptr_fft && (ptr_fft != pfft))
918  {
919  fft_free(ptr_fft);
920  free(ptr_fft);
921  }
922  return err;
923 }
924 
925 
926 
927 
928 #ifdef DOXYGEN_ENGLISH
929 
930 #endif
931 #ifdef DOXYGEN_RUSSIAN
932 
1059 #endif
1060 int DSPL_API psd_welch(double* x, int n,
1061  int win_type, double win_param,
1062  int nfft, int noverlap, fft_t* pfft, double fs,
1063  int flag, double* ppsd, double* pfrq)
1064 {
1065  int err, pos, cnt, k;
1066  double *pdgr = NULL;
1067  double *tmp = NULL;
1068  double *w = NULL;
1069  fft_t *ptr_fft = NULL;
1070  double wn;
1071 
1072  pos = cnt = 0;
1073 
1074  pdgr = (double*)malloc(nfft * sizeof(double));
1075  if(!pdgr)
1076  return ERROR_MALLOC;
1077 
1078  tmp = (double*) malloc(nfft * sizeof(double));
1079  if(!tmp)
1080  return ERROR_MALLOC;
1081 
1082  /* window malloc */
1083  w = (double*)malloc(nfft*sizeof(double));
1084  if(!w)
1085  {
1086  err = ERROR_MALLOC;
1087  goto exit_label;
1088  }
1089 
1090  /* create window */
1091  err = window(w, nfft, win_type, win_param);
1092  if(err != RES_OK)
1093  goto exit_label;
1094 
1095  /* window normalization wn = sum(w.^2) */
1096  wn = 0.0;
1097  for(k = 0; k < nfft; k++)
1098  wn += w[k]*w[k];
1099 
1100 
1101  if(!pfft)
1102  {
1103  ptr_fft = (fft_t*)malloc(sizeof(fft_t));
1104  memset(ptr_fft, 0, sizeof(fft_t));
1105  }
1106  else
1107  ptr_fft = pfft;
1108 
1109 
1110 
1111 
1112  memset(ppsd, 0, nfft * sizeof(double));
1113  while(pos + nfft <= n)
1114  {
1115  for(k = 0; k < nfft; k++)
1116  tmp[k] = x[pos+k] * w[k];
1117  err = fft_mag(tmp, nfft, ptr_fft, fs,
1118  flag & DSPL_FLAG_FFT_SHIFT, pdgr, NULL);
1119  if(err != RES_OK)
1120  goto exit_label;
1121  for(k = 0; k < nfft; k++)
1122  ppsd[k] += pdgr[k];
1123  pos += noverlap;
1124  cnt++;
1125  }
1126 
1127  if(pos < n)
1128  {
1129 
1130  memset(tmp ,0, nfft * sizeof(double));
1131  for(k = 0; k < n - pos; k++)
1132  tmp[k] = x[pos+k] * w[k];
1133 
1134 
1135  err = fft_mag(tmp, nfft, ptr_fft, fs,
1136  flag & DSPL_FLAG_FFT_SHIFT, pdgr, NULL);
1137  if(err != RES_OK)
1138  goto exit_label;
1139 
1140  for(k = 0; k < nfft; k++)
1141  ppsd[k] += pdgr[k];
1142 
1143  cnt++;
1144  }
1145 
1146  /* fill frequency */
1147  if(pfrq)
1148  {
1149  if(flag & DSPL_FLAG_FFT_SHIFT)
1150  if(n%2)
1151  err = linspace(-fs*0.5 + fs*0.5/(double)nfft,
1152  fs*0.5 - fs*0.5/(double)nfft,
1153  n, DSPL_SYMMETRIC, pfrq);
1154  else
1155  err = linspace(-fs*0.5, fs*0.5, nfft, DSPL_PERIODIC, pfrq);
1156  else
1157  err = linspace(0, fs, nfft, DSPL_PERIODIC, pfrq);
1158  }
1159 
1160  /* scale magnitude */
1161  if(flag & DSPL_FLAG_LOGMAG)
1162  {
1163  printf("wn = %f\n", wn);
1164  for(k = 0; k < nfft; k++)
1165  ppsd[k] = 10.0 * log10(ppsd[k] / (fs * wn * (double)cnt));
1166  }
1167  else
1168  {
1169  for(k = 0; k < nfft; k++)
1170  ppsd[k] /= fs * wn * (double)cnt;
1171  }
1172 
1173 
1174 exit_label:
1175  if(pdgr)
1176  free(pdgr);
1177  if(tmp)
1178  free(tmp);
1179  if(w)
1180  free(w);
1181  if(ptr_fft && (ptr_fft != pfft))
1182  {
1183  fft_free(ptr_fft);
1184  free(ptr_fft);
1185  }
1186  return err;
1187 }
1188 
1189 
1190 #ifdef DOXYGEN_ENGLISH
1191 
1192 #endif
1193 #ifdef DOXYGEN_RUSSIAN
1194 
1320 #endif
1321 int DSPL_API psd_welch_cmplx(complex_t* x, int n,
1322  int win_type, double win_param,
1323  int nfft, int noverlap, fft_t* pfft, double fs,
1324  int flag, double* ppsd, double* pfrq)
1325 {
1326  int err, pos, cnt, k;
1327  double *pdgr = NULL;
1328  complex_t *tmp = NULL;
1329  double *w = NULL;
1330  fft_t *ptr_fft = NULL;
1331  double wn;
1332 
1333  pos = cnt = 0;
1334 
1335  pdgr = (double*)malloc(nfft * sizeof(double));
1336  if(!pdgr)
1337  return ERROR_MALLOC;
1338 
1339  tmp = (complex_t*) malloc(nfft * sizeof(complex_t));
1340  if(!tmp)
1341  return ERROR_MALLOC;
1342 
1343 
1344  /* window malloc */
1345  w = (double*)malloc(nfft*sizeof(double));
1346  if(!w)
1347  {
1348  err = ERROR_MALLOC;
1349  goto exit_label;
1350  }
1351 
1352  /* create window */
1353  err = window(w, nfft, win_type, win_param);
1354  if(err != RES_OK)
1355  goto exit_label;
1356 
1357  /* window normalization wn = sum(w.^2) */
1358  wn = 0.0;
1359  for(k = 0; k < nfft; k++)
1360  wn += w[k]*w[k];
1361 
1362 
1363  if(!pfft)
1364  {
1365  ptr_fft = (fft_t*)malloc(sizeof(fft_t));
1366  memset(ptr_fft, 0, sizeof(fft_t));
1367  }
1368  else
1369  ptr_fft = pfft;
1370 
1371 
1372 
1373 
1374  memset(ppsd, 0, nfft * sizeof(double));
1375  while(pos + nfft <= n)
1376  {
1377  for(k = 0; k < nfft; k++)
1378  {
1379  RE(tmp[k]) = RE(x[pos+k]) * w[k];
1380  IM(tmp[k]) = IM(x[pos+k]) * w[k];
1381  }
1382  err = fft_mag_cmplx(tmp, nfft, ptr_fft, fs,
1383  flag & DSPL_FLAG_FFT_SHIFT, pdgr, NULL);
1384  if(err != RES_OK)
1385  goto exit_label;
1386  for(k = 0; k < nfft; k++)
1387  ppsd[k] += pdgr[k];
1388  pos += noverlap;
1389  cnt++;
1390  }
1391 
1392  if(pos < n)
1393  {
1394 
1395  memset(tmp ,0, nfft * sizeof(complex_t));
1396  for(k = 0; k < n - pos; k++)
1397  {
1398  RE(tmp[k]) = RE(x[pos+k]) * w[k];
1399  IM(tmp[k]) = IM(x[pos+k]) * w[k];
1400  }
1401 
1402  err = fft_mag_cmplx(tmp, nfft, ptr_fft, fs,
1403  flag & DSPL_FLAG_FFT_SHIFT, pdgr, NULL);
1404  if(err != RES_OK)
1405  goto exit_label;
1406 
1407  for(k = 0; k < nfft; k++)
1408  ppsd[k] += pdgr[k];
1409 
1410  cnt++;
1411  }
1412 
1413  /* fill frequency */
1414  if(pfrq)
1415  {
1416  if(flag & DSPL_FLAG_FFT_SHIFT)
1417  if(n%2)
1418  err = linspace(- fs * 0.5 + fs * 0.5 / (double)nfft,
1419  fs * 0.5 - fs * 0.5 / (double)nfft,
1420  n, DSPL_SYMMETRIC, pfrq);
1421  else
1422  err = linspace(-fs*0.5, fs*0.5, nfft, DSPL_PERIODIC, pfrq);
1423  else
1424  err = linspace(0, fs, nfft, DSPL_PERIODIC, pfrq);
1425  }
1426 
1427  /* scale magnitude */
1428  if(flag & DSPL_FLAG_LOGMAG)
1429  {
1430  for(k = 0; k < nfft; k++)
1431  ppsd[k] = 10.0 * log10(ppsd[k] / (fs * wn * (double)cnt));
1432  }
1433  else
1434  {
1435  for(k = 0; k < nfft; k++)
1436  ppsd[k] /= fs * wn * (double)cnt;
1437  }
1438 
1439 
1440 exit_label:
1441  if(pdgr)
1442  free(pdgr);
1443  if(tmp)
1444  free(tmp);
1445  if(w)
1446  free(w);
1447  if(ptr_fft && (ptr_fft != pfft))
1448  {
1449  fft_free(ptr_fft);
1450  free(ptr_fft);
1451  }
1452  return err;
1453 }
1454 
window
int window(double *w, int n, int win_type, double param)
Расчет функции оконного взвешивания
Definition: win.c:308
RE
#define RE(x)
Макрос определяющий реальную часть комплексного числа.
Definition: dspl.h:359
ERROR_PTR
#define ERROR_PTR
Ошибка указателя. Данная ошибка означает, что один из обязательных указателей (память под который дол...
Definition: dspl.h:549
ERROR_SIZE
#define ERROR_SIZE
Ошибка при передаче размера массива. Данная ошибка возникает когда помимо указателя на массив входных...
Definition: dspl.h:557
psd_welch_cmplx
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
psd_bartlett_cmplx
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
fft_free
void fft_free(fft_t *pfft)
Очистить структуру fft_t алгоритма БПФ
Definition: fft.c:1009
psd_periodogram_cmplx
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
psd_welch
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
psd_bartlett
int psd_bartlett(double *x, int n, int nfft, fft_t *pfft, double fs, int flag, double *ppsd, double *pfrq)
Непараметрическая оценка спектральной плотности мощности (СПМ) вещественного сигнала методом Бартлетт...
Definition: psd.c:149
fft_t
Структура данных объекта быстрого преобразования Фурье
Definition: dspl.h:227
complex_t
double complex_t[2]
Описание комплексного типа данных.
Definition: dspl.h:86
RES_OK
#define RES_OK
Функция завершилась корректно. Ошибки отсутствуют.
Definition: dspl.h:497
linspace
int linspace(double x0, double x1, int n, int type, double *x)
Функция заполняет массив линейно-нарастающими, равноотстоящими значениями от x0 до x1
Definition: array.c:1009
psd_periodogram
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
IM
#define IM(x)
Макрос определяющий мнимую часть комплексного числа.
Definition: dspl.h:417
ERROR_MALLOC
#define ERROR_MALLOC
Ошибка динамического выделения памяти. Данная ошибка означает, что при динамическом выделении памяти ...
Definition: dspl.h:538
Документация по libdspl-2.0. Последние изменения: Ср 14 Окт 2020 20:24:16. Создано системой   doxygen 1.8.20
Документация libdspl-2.0 доступна по лицензии Creative Commons «Attribution-ShareAlike» («Атрибуция-СохранениеУсловий») 4.0 Всемирная.