mirror
/
libdspl-2.0
kopia lustrzana https://github.com/Dsplib/libdspl-2.0
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

modified dox and some c-files

pull/6/merge
Dsplib 2019-08-28 21:19:25 +03:00
rodzic eebe14a493
commit 52a6a38c03
27 zmienionych plików z 1068 dodań i 1001 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

2
dox/doxy_stylesheet.css
Wyświetl plik

@ -12,7 +12,7 @@ code{
}
p.reference, p.definition {
font: 400 14px/22px Roboto,sans-serif;
//font: 400 14px/22px Roboto,sans-serif;
}
/* @group Heading Levels */

69
dspl.project.win.geany 100644
Wyświetl plik

@ -0,0 +1,69 @@
[editor]
line_wrapping=false
line_break_column=72
auto_continue_multiline=true
[file_prefs]
final_new_line=true
ensure_convert_new_lines=false
strip_trailing_spaces=false
replace_tabs=false
[indentation]
indent_width=2
indent_type=0
indent_hard_tab_width=8
detect_indent=false
detect_indent_width=false
indent_mode=2
[project]
name=libdspl
base_path=F:\\dsplib.org\\libdspl-2.0
description=
file_patterns=
[long line marker]
long_line_behaviour=1
long_line_column=72
[files]
current_page=0
FILE_NAME_0=4479;C;0;EUTF-8;1;1;0;F%3A%5Cdsplib.org%5Clibdspl-2.0%5Cdspl%5Csrc%5Carray.c;0;4
FILE_NAME_1=4251;C;0;EUTF-8;1;1;0;F%3A%5Cdsplib.org%5Clibdspl-2.0%5Cdspl%5Csrc%5Ccheby.c;0;4
FILE_NAME_2=14822;C;0;EUTF-8;1;1;0;F%3A%5Cdsplib.org%5Clibdspl-2.0%5Cdspl%5Csrc%5Ccomplex.c;0;4
FILE_NAME_3=204;C;0;EUTF-8;1;1;0;F%3A%5Cdsplib.org%5Clibdspl-2.0%5Cdspl%5Csrc%5Cconv.c;0;4
FILE_NAME_4=6950;C;0;EUTF-8;1;1;0;F%3A%5Cdsplib.org%5Clibdspl-2.0%5Cdspl%5Csrc%5Cdft.c;0;4
FILE_NAME_5=0;C++;0;EUTF-8;1;1;0;F%3A%5Cdsplib.org%5Clibdspl-2.0%5Cdspl%5Csrc%5Cdspl_internal.h;0;4
FILE_NAME_6=0;C;0;EUTF-8;1;1;0;F%3A%5Cdsplib.org%5Clibdspl-2.0%5Cdspl%5Csrc%5Cellipj.c;0;4
FILE_NAME_7=2079;C;0;EUTF-8;1;1;0;F%3A%5Cdsplib.org%5Clibdspl-2.0%5Cdspl%5Csrc%5Cfft.c;0;4
FILE_NAME_8=0;C;0;EUTF-8;1;1;0;F%3A%5Cdsplib.org%5Clibdspl-2.0%5Cdspl%5Csrc%5Cfft_subkernel.c;0;4
FILE_NAME_9=766;C;0;EUTF-8;1;1;0;F%3A%5Cdsplib.org%5Clibdspl-2.0%5Cdspl%5Csrc%5Cfillarray.c;0;4
FILE_NAME_10=0;C;0;EUTF-8;1;1;0;F%3A%5Cdsplib.org%5Clibdspl-2.0%5Cdspl%5Csrc%5Cfilter_an.c;0;4
FILE_NAME_11=1286;C;0;EUTF-8;1;1;0;F%3A%5Cdsplib.org%5Clibdspl-2.0%5Cdspl%5Csrc%5Cfilter_ap.c;0;4
FILE_NAME_12=0;C;0;EUTF-8;1;1;0;F%3A%5Cdsplib.org%5Clibdspl-2.0%5Cdspl%5Csrc%5Cfilter_fir.c;0;4
FILE_NAME_13=5715;C;0;EUTF-8;1;1;0;F%3A%5Cdsplib.org%5Clibdspl-2.0%5Cdspl%5Csrc%5Cfilter_ft.c;0;4
FILE_NAME_14=2837;C;0;EUTF-8;1;1;0;F%3A%5Cdsplib.org%5Clibdspl-2.0%5Cdspl%5Csrc%5Cfilter_iir.c;0;4
FILE_NAME_15=0;C;0;EUTF-8;1;1;0;F%3A%5Cdsplib.org%5Clibdspl-2.0%5Cdspl%5Csrc%5Cfourier_series.c;0;4
FILE_NAME_16=0;C;0;EUTF-8;1;1;0;F%3A%5Cdsplib.org%5Clibdspl-2.0%5Cdspl%5Csrc%5Cgoertzel.c;0;4
FILE_NAME_17=0;C;0;EUTF-8;1;1;0;F%3A%5Cdsplib.org%5Clibdspl-2.0%5Cdspl%5Csrc%5Cinout.c;0;4
FILE_NAME_18=0;C;0;EUTF-8;1;1;0;F%3A%5Cdsplib.org%5Clibdspl-2.0%5Cdspl%5Csrc%5Cmath.c;0;4
FILE_NAME_19=0;C;0;EUTF-8;1;1;0;F%3A%5Cdsplib.org%5Clibdspl-2.0%5Cdspl%5Csrc%5Cmatrix.c;0;4
FILE_NAME_20=0;C;0;EUTF-8;1;1;0;F%3A%5Cdsplib.org%5Clibdspl-2.0%5Cdspl%5Csrc%5Cpolyval.c;0;4
FILE_NAME_21=0;C;0;EUTF-8;1;1;0;F%3A%5Cdsplib.org%5Clibdspl-2.0%5Cdspl%5Csrc%5Crandgen.c;0;4
FILE_NAME_22=0;C;0;EUTF-8;1;1;0;F%3A%5Cdsplib.org%5Clibdspl-2.0%5Cdspl%5Csrc%5Cresampling.c;0;4
FILE_NAME_23=0;C;0;EUTF-8;1;1;0;F%3A%5Cdsplib.org%5Clibdspl-2.0%5Cdspl%5Csrc%5Csignals.c;0;4
FILE_NAME_24=0;C;0;EUTF-8;1;1;0;F%3A%5Cdsplib.org%5Clibdspl-2.0%5Cdspl%5Csrc%5Cstatistic.c;0;4
FILE_NAME_25=0;C;0;EUTF-8;1;1;0;F%3A%5Cdsplib.org%5Clibdspl-2.0%5Cdspl%5Csrc%5Ctrapint.c;0;4
FILE_NAME_26=0;C;0;EUTF-8;1;1;0;F%3A%5Cdsplib.org%5Clibdspl-2.0%5Cdspl%5Csrc%5Cwin.c;0;4
[build-menu]
NF_00_LB=_Собрать
NF_00_CM=mingw32-make
NF_00_WD=%p
NF_01_LB=Собрать заданную _цель...
NF_01_CM=mingw32-make
NF_01_WD=%p
NF_02_LB=Очистить
NF_02_CM=mingw32-make clean
NF_02_WD=%p

144
dspl/dox/ru/conv.dox
Wyświetl plik

@ -6,25 +6,25 @@
Функция рассчитывает линейную свертку двух векторов \f$ c = a * b\f$.
\param[in] a Указатель на первый вектор \f$a\f$.<BR>
Размер вектора `[na x 1]`.<BR><BR>
\param[in] a Указатель на первый вектор \f$a\f$. \n
Размер вектора `[na x 1]`. \n \n
\param[in] na Размер первого вектора.<BR><BR>
\param[in] na Размер первого вектора. \n \n
\param[in] b Указатель на второй вектор \f$b\f$.<BR>
Размер вектора `[nb x 1]`.<BR><BR>
\param[in] b Указатель на второй вектор \f$b\f$. \n
Размер вектора `[nb x 1]`. \n \n
\param[in] nb Размер второго вектора.<BR><BR>
\param[in] nb Размер второго вектора. \n \n
\param[out] c Указатель на вектор свертки \f$ c = a * b\f$.<BR>
Размер вектора `[na + nb - 1 x 1]`.<BR>
Память должна быть выделена.<BR><BR>
\param[out] c Указатель на вектор свертки \f$ c = a * b\f$. \n
Размер вектора `[na + nb - 1 x 1]`. \n
Память должна быть выделена. \n \n
\return
`RES_OK` если свертка расчитана успешно.<BR>
`RES_OK` если свертка расчитана успешно. \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки".
\note Если вектора `a` и `b` представляют собой коэффициенты двух полиномов,
\n ote Если вектора `a` и `b` представляют собой коэффициенты двух полиномов,
то результат линейной свертки представляет собой коэффициенты произведения
исходных полиномов.
@ -40,10 +40,10 @@
conv(ar, 3, br, 4, cr);
for(n = 0; n < 6; n++)
printf("cr[%d] = %5.1f\n", n, cr[n]);
printf("cr[%d] = %5.1f \n ", n, cr[n]);
\endcode
<BR>
\n
Результат работы:
\verbatim
@ -73,26 +73,26 @@ cr[5] = 12.0
\param[in] a Указатель на первый вектор \f$a\f$.<BR>
Размер вектора `[na x 1]`.<BR><BR>
\param[in] a Указатель на первый вектор \f$a\f$. \n
Размер вектора `[na x 1]`. \n \n
\param[in] na Размер первого вектора.<BR><BR>
\param[in] na Размер первого вектора. \n \n
\param[in] b Указатель на второй вектор \f$b\f$.<BR>
Размер вектора `[nb x 1]`.<BR><BR>
\param[in] b Указатель на второй вектор \f$b\f$. \n
Размер вектора `[nb x 1]`. \n \n
\param[in] nb Размер второго вектора.<BR><BR>
\param[in] nb Размер второго вектора. \n \n
\param[out] c Указатель на вектор свертки \f$ c = a * b\f$.<BR>
Размер вектора `[na + nb - 1 x 1]`.<BR>
Память должна быть выделена.<BR><BR>
\param[out] c Указатель на вектор свертки \f$ c = a * b\f$. \n
Размер вектора `[na + nb - 1 x 1]`. \n
Память должна быть выделена. \n \n
\return
`RES_OK` если свертка рассчитана успешно.<BR>
`RES_OK` если свертка рассчитана успешно. \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки".
\note Если вектора `a` и `b` представляют собой коэффициенты двух полиномов,
\n ote Если вектора `a` и `b` представляют собой коэффициенты двух полиномов,
то результат линейной свертки представляет собой коэффициенты произведения
исходных полиномов.
@ -108,10 +108,10 @@ cr[5] = 12.0
conv_cmplx(ac, 3, bc, 4, cc);
for(n = 0; n < 6; n++)
printf("cc[%d] = %5.1f%+5.1fj\n", n, RE(cc[n]),IM(cc[n]));
printf("cc[%d] = %5.1f%+5.1fj \n ", n, RE(cc[n]),IM(cc[n]));
\endcode
<BR>
\n
Результат работы:
\verbatim
@ -147,28 +147,28 @@ cc[5] = 0.0+24.0j
\param[in] a Указатель на первый вектор \f$a\f$.<BR>
Размер вектора `[na x 1]`.<BR><BR>
\param[in] a Указатель на первый вектор \f$a\f$. \n
Размер вектора `[na x 1]`. \n \n
\param[in] na Размер первого вектора.<BR><BR>
\param[in] na Размер первого вектора. \n \n
\param[in] b Указатель на второй вектор \f$b\f$.<BR>
Размер вектора `[nb x 1]`.<BR><BR>
\param[in] b Указатель на второй вектор \f$b\f$. \n
Размер вектора `[nb x 1]`. \n \n
\param[in] nb Размер второго вектора.<BR><BR>
\param[in] nb Размер второго вектора. \n \n
\param[in] pfft Указатель на структуру `fft_t` алгоритма
быстрого преобразования Фурье.<BR>
быстрого преобразования Фурье. \n
Функция изменит состояние полей структуры `fft_t`,
поэтому структура должна быть очищена перед выходом из
программы для исключения утечек памяти.<BR>
программы для исключения утечек памяти. \n
\param[in] nfft Размер алгоритма БПФ который будет использован для расчета
секционной свертки с перекрытием.<BR>
секционной свертки с перекрытием. \n
Данный параметр должен быть больше чем минимальное значение
размеров сворачиваемых векторов.<BR>
размеров сворачиваемых векторов. \n
Например если `na=10`, а `nb=4`, то параметр `nfft` должен
быть больше 4.<BR>
быть больше 4. \n
Библиотека поддерживает алгоритмы БПФ составной длины
\f$n = n_0 \times n_1 \times n_2 \times n_3 \times \ldots \times n_p \times m\f$,
где \f$n_i = 2,3,5,7\f$, а \f$m \f$ --
@ -177,16 +177,16 @@ cc[5] = 0.0+24.0j
быстродействие достигается при использовании длин равных
степени двойки.
\param[out] c Указатель на вектор свертки \f$ c = a * b\f$.<BR>
Размер вектора `[na + nb - 1 x 1]`.<BR>
Память должна быть выделена.<BR><BR>
\param[out] c Указатель на вектор свертки \f$ c = a * b\f$. \n
Размер вектора `[na + nb - 1 x 1]`. \n
Память должна быть выделена. \n \n
\return
`RES_OK` если свертка рассчитана успешно.<BR>
`RES_OK` если свертка рассчитана успешно. \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки".
\note Данная функция наиболее эффективна при вычислении длинных сверток.
\n ote Данная функция наиболее эффективна при вычислении длинных сверток.
Пример использования функции:
@ -241,28 +241,28 @@ c[ 18] = 72.00 d[ 18] = 72.00
\param[in] a Указатель на первый вектор \f$a\f$.<BR>
Размер вектора `[na x 1]`.<BR><BR>
\param[in] a Указатель на первый вектор \f$a\f$. \n
Размер вектора `[na x 1]`. \n \n
\param[in] na Размер первого вектора.<BR><BR>
\param[in] na Размер первого вектора. \n \n
\param[in] b Указатель на второй вектор \f$b\f$.<BR>
Размер вектора `[nb x 1]`.<BR><BR>
\param[in] b Указатель на второй вектор \f$b\f$. \n
Размер вектора `[nb x 1]`. \n \n
\param[in] nb Размер второго вектора.<BR><BR>
\param[in] nb Размер второго вектора. \n \n
\param[in] pfft Указатель на структуру `fft_t` алгоритма
быстрого преобразования Фурье.<BR>
быстрого преобразования Фурье. \n
Функция изменит состояние полей структуры `fft_t`,
поэтому структура должна быть очищена перед выходом из
программы для исключения утечек памяти.<BR>
программы для исключения утечек памяти. \n
\param[in] nfft Размер алгоритма БПФ который будет использован для расчета
секционной свертки с перекрытием.<BR>
секционной свертки с перекрытием. \n
Данный параметр должен быть больше чем минимальное значение
размеров сворачиваемых векторов.<BR>
размеров сворачиваемых векторов. \n
Например если `na=10`, а `nb=4`, то параметр `nfft` должен
быть больше 4.<BR>
быть больше 4. \n
Библиотека поддерживает алгоритмы БПФ составной длины
\f$n = n_0 \times n_1 \times n_2 \times n_3 \times \ldots \times n_p \times m\f$,
где \f$n_i = 2,3,5,7\f$, а \f$m \f$ --
@ -271,16 +271,16 @@ c[ 18] = 72.00 d[ 18] = 72.00
быстродействие достигается при использовании длин равных
степени двойки.
\param[out] c Указатель на вектор свертки \f$ c = a * b\f$.<BR>
Размер вектора `[na + nb - 1 x 1]`.<BR>
Память должна быть выделена.<BR><BR>
\param[out] c Указатель на вектор свертки \f$ c = a * b\f$. \n
Размер вектора `[na + nb - 1 x 1]`. \n
Память должна быть выделена. \n \n
\return
`RES_OK` если свертка рассчитана успешно.<BR>
`RES_OK` если свертка рассчитана успешно. \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки".
\note Данная функция наиболее эффективна при вычислении длинных сверток.
\n ote Данная функция наиболее эффективна при вычислении длинных сверток.
Пример использования функции:
@ -331,31 +331,31 @@ c[ 18] = -37.00 +484.00j d[ 18] = -37.00 +484.00j
\param[in] b Указатель на вектор коэффициентов числителя
передаточной функции БИХ-фильтра.<BR>
Размер вектора `[ord + 1 x 1]`.<BR><BR>
передаточной функции БИХ-фильтра. \n
Размер вектора `[ord + 1 x 1]`. \n \n
\param[in] a Указатель на вектор коэффициентов знаменателя
передаточной функции БИХ-фильтра.<BR>
Размер вектора `[ord + 1 x 1]`.<BR>
передаточной функции БИХ-фильтра. \n
Размер вектора `[ord + 1 x 1]`. \n
Этот указатель может быть `NULL`,
тогда фильтрация производится без использования
рекурсивной части.<BR><BR>
рекурсивной части. \n \n
\param[in] ord Порядок фильтра. Количество коэффициентов числителя
и знаменателя передаточной функции
БИХ-фильтра равно `ord + 1`.<BR><BR>
БИХ-фильтра равно `ord + 1`. \n \n
\param[in] x Указатель на вектор отсчетов входного сигнала.<BR>
Размер вектора `[n x 1]`.<BR><BR>
\param[in] x Указатель на вектор отсчетов входного сигнала. \n
Размер вектора `[n x 1]`. \n \n
\param[in] n Длина входного сигнала.<BR><BR>
\param[in] n Длина входного сигнала. \n \n
\param[out] y Указатель на вектор выходных отсчетов фильтра.<BR>
Размер вектора `[n x 1]`.<BR>
Память должна быть выделена заранее.<BR><BR>
\param[out] y Указатель на вектор выходных отсчетов фильтра. \n
Размер вектора `[n x 1]`. \n
Память должна быть выделена заранее. \n \n
\return
`RES_OK` Если фильтрация произведена успешно.<BR>
В противном случае \ref ERROR_CODE_GROUP "код ошибки":<BR>
`RES_OK` Если фильтрация произведена успешно. \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки": \n
\author Бахурин Сергей www.dsplib.org
***************************************************************************** */

48
dspl/dox/ru/dft.dox
Wyświetl plik

@ -5,7 +5,7 @@
\brief Дискретное преобразование Фурье вещественного сигнала.
Функция рассчитывает \f$ n \f$-точечное дискретное преобразование Фурье
вещественного сигнала \f$ x(m) \f$, \f$ m = 0 \ldots n-1 \f$.<BR>
вещественного сигнала \f$ x(m) \f$, \f$ m = 0 \ldots n-1 \f$. \n
\f[
Y(k) = \sum_{m = 0}^{n-1} x(m)
\exp \left( -j \frac{2\pi}{n} m k \right),
@ -14,21 +14,21 @@
\param[in] x Указатель на вектор вещественного
входного сигнала \f$x(m)\f$,
\f$ m = 0 \ldots n-1 \f$. <BR>
Размер вектора `[n x 1]`. <BR><BR>
\f$ m = 0 \ldots n-1 \f$. \n
Размер вектора `[n x 1]`. \n \n
\param[in] n Размер ДПФ \f$n\f$ (размер векторов
входного сигнала и результата ДПФ).<BR><BR>
входного сигнала и результата ДПФ). \n \n
\param[out] y Указатель на комплексный вектор
результата ДПФ \f$Y(k)\f$,
\f$ k = 0 \ldots n-1 \f$.
Размер вектора `[n x 1]`. <BR>
Память должна быть выделена.<BR><BR>
Размер вектора `[n x 1]`. \n
Память должна быть выделена. \n \n
\return
`RES_OK` если ДПФ рассчитана успешно. <BR>
`RES_OK` если ДПФ рассчитана успешно. \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки".
Пример использования функции `dft`:
@ -58,7 +58,7 @@
\note
Данная функция выполняет расчет ДПФ наивным методом
и требует \f$ n^2 \f$ комплексных умножений.<BR>
и требует \f$ n^2 \f$ комплексных умножений. \n
Для увеличения скорости расчета рекомендуется
использовать алгоритмы быстрого преобразования Фурье.
@ -73,7 +73,7 @@
\brief Дискретное преобразование Фурье комплексного сигнала.
Функция рассчитывает \f$ n \f$-точечное дискретное преобразование Фурье
комплексного сигнала \f$ x(m) \f$, \f$ m = 0 \ldots n-1 \f$.<BR>
комплексного сигнала \f$ x(m) \f$, \f$ m = 0 \ldots n-1 \f$. \n
\f[
Y(k) = \sum_{m = 0}^{n-1} x(m)
\exp \left( -j \frac{2\pi}{n} m k \right),
@ -82,21 +82,21 @@
\param[in] x Указатель на вектор комплексного
входного сигнала \f$x(m)\f$,
\f$ m = 0 \ldots n-1 \f$. <BR>
Размер вектора `[n x 1]`. <BR><BR>
\f$ m = 0 \ldots n-1 \f$. \n
Размер вектора `[n x 1]`. \n \n
\param[in] n Размер ДПФ \f$n\f$ (размер векторов входного
сигнала и результата ДПФ).<BR><BR>
сигнала и результата ДПФ). \n \n
\param[out] y Указатель на комплексный вектор
результата ДПФ \f$Y(k)\f$,
\f$ k = 0 \ldots n-1 \f$.
Размер вектора `[n x 1]`. <BR>
Память должна быть выделена.<BR><BR>
Размер вектора `[n x 1]`. \n
Память должна быть выделена. \n \n
\return
`RES_OK` если ДПФ рассчитана успешно. <BR>
`RES_OK` если ДПФ рассчитана успешно. \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки".
Пример использования функции `dft_cmplx`:
@ -126,7 +126,7 @@
\note
Данная функция выполняет расчет ДПФ наивным методом
и требует \f$ n^2 \f$ комплексных умножений.<BR>
и требует \f$ n^2 \f$ комплексных умножений. \n
Для увеличения скорости расчета рекомендуется
использовать алгоритмы быстрого преобразования Фурье.
@ -142,7 +142,7 @@
\brief Обратное дискретное преобразование Фурье комплексного спектра.
Функция рассчитывает \f$ n \f$-точечное обратное дискретное преобразование Фурье
комплексного спектра \f$ x(m) \f$, \f$ m = 0 \ldots n-1 \f$.<BR>
комплексного спектра \f$ x(m) \f$, \f$ m = 0 \ldots n-1 \f$. \n
\f[
y(k) = \sum_{m = 0}^{n-1} x(m)
\exp \left( j \frac{2\pi}{n} m k \right),
@ -151,21 +151,21 @@
\param[in] x Указатель на вектор входного комплексного
спектра сигнала \f$x(m)\f$,
\f$ m = 0 \ldots n-1 \f$. <BR>
Размер вектора `[n x 1]`. <BR><BR>
\f$ m = 0 \ldots n-1 \f$. \n
Размер вектора `[n x 1]`. \n \n
\param[in] n Размер ОДПФ \f$n\f$ (размер векторов входного
спектра и результата ОДПФ).<BR><BR>
спектра и результата ОДПФ). \n \n
\param[out] y Указатель на комплексный вектор
результата ОДПФ \f$y(k)\f$,
\f$ k = 0 \ldots n-1 \f$.
Размер вектора `[n x 1]`. <BR>
Память должна быть выделена.<BR><BR>
Размер вектора `[n x 1]`. \n
Память должна быть выделена. \n \n
\return
`RES_OK` если ОДПФ рассчитана успешно. <BR>
`RES_OK` если ОДПФ рассчитана успешно. \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки".
Пример использования функции `dft_cmplx`:
@ -195,7 +195,7 @@ x[15] = 15.000 +0.000j, z[15] = 15.000 -0.000
\note
Данная функция выполняет расчет ОДПФ наивным методом
и требует \f$ n^2 \f$ комплексных умножений.<BR>
и требует \f$ n^2 \f$ комплексных умножений. \n
Для увеличения скорости расчета рекомендуется
использовать алгоритмы быстрого преобразования Фурье.

144
dspl/dox/ru/fft.dox
Wyświetl plik

@ -16,30 +16,30 @@
\param n Размер вектора БПФ, для которого выделена память
в массивах структуры. <BR>
Парметр `n` должен быть равен целой степени двойки. <BR><BR>
в массивах структуры. \n
Парметр `n` должен быть равен целой степени двойки. \n \n
\param w Указатель на вектор поворотных коэффициентов алгоритма БПФ.<BR>
Размер вектора `[n x 1]`. <BR>
\param w Указатель на вектор поворотных коэффициентов алгоритма БПФ. \n
Размер вектора `[n x 1]`. \n
Память должна быть выделена и массив поворотных коэффициентов
должен быть заполнен функцией \ref fft_create. <BR><BR>
должен быть заполнен функцией \ref fft_create. \n \n
\param t0 Указатель на вектор промежуточных вычислений алгоритма БПФ.<BR>
Размер вектора `[n x 1]`. <BR>
Память должна быть выделена функцией \ref fft_create. <BR><BR>
\param t0 Указатель на вектор промежуточных вычислений алгоритма БПФ. \n
Размер вектора `[n x 1]`. \n
Память должна быть выделена функцией \ref fft_create. \n \n
\param t1 Указатель на вектор промежуточных вычислений алгоритма БПФ.<BR>
Размер вектора `[n x 1]`. <BR>
Память должна быть выделена функцией \ref fft_create. <BR><BR>
\param t1 Указатель на вектор промежуточных вычислений алгоритма БПФ. \n
Размер вектора `[n x 1]`. \n
Память должна быть выделена функцией \ref fft_create. \n \n
Структура заполняется функцией \ref fft_create один раз
до использования алгоритма БПФ. <BR>
до использования алгоритма БПФ. \n
Указатель на объект данной структуры может быть
многократно использован при вызове функций БПФ.<BR>
многократно использован при вызове функций БПФ. \n
Перед выходом из программы выделенную память под поворотные
коэффициенты и массивы промежуточных данных
необходимо очистить функцией \ref fft_free. Например:
@ -69,7 +69,7 @@ fft_free(&pfft);
Важно отметить, что если объект `fft_t` был создан для размера БПФ равного `n`,
то он может быть использован только для БПФ размера `n`. <BR>
то он может быть использован только для БПФ размера `n`. \n
Также необходимо заметить, что функции БПФ самостоятельно контролируют размер,
@ -99,7 +99,7 @@ www.dsplib.org
\brief Обратное быстрое преобразование Фурье
Функция рассчитывает \f$ n \f$-точечное обратное быстрое преобразование Фурье
от \f$ x(m) \f$, \f$ m = 0 \ldots n-1 \f$.<BR>
от \f$ x(m) \f$, \f$ m = 0 \ldots n-1 \f$. \n
\f[
Y(k) = \frac{1}{N} \sum_{m = 0}^{n-1} x(m) \exp
\left( j \frac{2\pi}{n} m k \right),
@ -109,32 +109,32 @@ www.dsplib.org
Для расчета используется алгоритм БПФ составной длины.
\param[in] x Указатель на входной комплексный вектор \f$x(m)\f$,
\f$ m = 0 \ldots n-1 \f$. <BR>
Размер вектора `[n x 1]`. <BR><BR>
\f$ m = 0 \ldots n-1 \f$. \n
Размер вектора `[n x 1]`. \n \n
\param[in] n Размер ОБПФ \f$n\f$.<BR>
\param[in] n Размер ОБПФ \f$n\f$. \n
Размер ОБПФ может быть составным вида
\f$n = n_0 \times n_1 \times n_2 \times n_3 \times \ldots \times n_p \times m\f$,
где \f$n_i = 2,3,5,7\f$, а \f$m \f$ --
произвольный простой множитель не превосходящий 46340
(см. описание функции \ref fft_create).
<BR><BR>
\n \n
\param[in] pfft Указатель на структуру `fft_t`. <BR>
Указатель не должен быть `NULL`. <BR>
\param[in] pfft Указатель на структуру `fft_t`. \n
Указатель не должен быть `NULL`. \n
Структура \ref fft_t должна быть предварительно однократно
заполнена функцией \ref fft_create, и память должна быть
очищена перед выходом функцией \ref fft_free.
<BR><BR>
\n \n
\param[out] y Указатель на вектор результата ОБПФ \f$Y(k)\f$,
\f$ k = 0 \ldots n-1 \f$.
Размер вектора `[n x 1]`. <BR>
Память должна быть выделена.<BR><BR>
Размер вектора `[n x 1]`. \n
Память должна быть выделена. \n \n
\return
`RES_OK` если расчет произведен успешно. <BR>
В противном случае \ref ERROR_CODE_GROUP "код ошибки".<BR><BR>
`RES_OK` если расчет произведен успешно. \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки". \n \n
Пример использования функции `fft`:
@ -177,7 +177,7 @@ www.dsplib.org
\brief Быстрое преобразование Фурье вещественного сигнала
Функция рассчитывает \f$ n \f$-точечное быстрое преобразование Фурье
вещественного сигнала \f$ x(m) \f$, \f$ m = 0 \ldots n-1 \f$.<BR>
вещественного сигнала \f$ x(m) \f$, \f$ m = 0 \ldots n-1 \f$. \n
\f[
Y(k) = \sum_{m = 0}^{n-1} x(m) \exp
\left( -j \frac{2\pi}{n} m k \right),
@ -188,33 +188,33 @@ www.dsplib.org
\param[in] x Указатель на вектор вещественного
входного сигнала \f$x(m)\f$,
\f$ m = 0 \ldots n-1 \f$. <BR>
Размер вектора `[n x 1]`. <BR><BR>
\f$ m = 0 \ldots n-1 \f$. \n
Размер вектора `[n x 1]`. \n \n
\param[in] n Размер БПФ \f$n\f$.<BR>
\param[in] n Размер БПФ \f$n\f$. \n
Размер БПФ может быть составным вида
\f$n = n_0 \times n_1 \times n_2 \times n_3 \times \ldots \times n_p \times m\f$,
где \f$n_i = 2,3,5,7\f$, а \f$m \f$ --
произвольный простой множитель не превосходящий 46340
(см. описание функции \ref fft_create).
<BR><BR>
\n \n
\param[in] pfft Указатель на структуру `fft_t`. <BR>
Указатель не должен быть `NULL`. <BR>
\param[in] pfft Указатель на структуру `fft_t`. \n
Указатель не должен быть `NULL`. \n
Структура \ref fft_t должна быть предварительно однократно
заполнена функцией \ref fft_create, и память должна быть
очищена перед выходом функцией \ref fft_free.
<BR><BR>
\n \n
\param[out] y Указатель на комплексный вектор
результата БПФ \f$Y(k)\f$,
\f$ k = 0 \ldots n-1 \f$.
Размер вектора `[n x 1]`. <BR>
Память должна быть выделена.<BR><BR>
Размер вектора `[n x 1]`. \n
Память должна быть выделена. \n \n
\return
`RES_OK` если расчет произведен успешно. <BR>
В противном случае \ref ERROR_CODE_GROUP "код ошибки".<BR><BR>
`RES_OK` если расчет произведен успешно. \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки". \n \n
Пример использования функции `fft`:
@ -255,7 +255,7 @@ www.dsplib.org
\brief Быстрое преобразование Фурье комплексного сигнала
Функция рассчитывает \f$ n \f$-точечное быстрое преобразование Фурье
комплексного сигнала \f$ x(m) \f$, \f$ m = 0 \ldots n-1 \f$.<BR>
комплексного сигнала \f$ x(m) \f$, \f$ m = 0 \ldots n-1 \f$. \n
\f[
Y(k) = \sum_{m = 0}^{n-1} x(m) \exp
\left( -j \frac{2\pi}{n} m k \right),
@ -266,33 +266,33 @@ www.dsplib.org
\param[in] x Указатель на вектор комплексного
входного сигнала \f$x(m)\f$,
\f$ m = 0 \ldots n-1 \f$. <BR>
Размер вектора `[n x 1]`. <BR><BR>
\f$ m = 0 \ldots n-1 \f$. \n
Размер вектора `[n x 1]`. \n \n
\param[in] n Размер БПФ \f$n\f$.<BR>
\param[in] n Размер БПФ \f$n\f$. \n
Размер БПФ может быть составным вида
\f$n = n_0 \times n_1 \times n_2 \times n_3 \times \ldots \times n_p \times m\f$,
где \f$n_i = 2,3,5,7\f$, а \f$m \f$ --
произвольный простой множитель не превосходящий 46340
(см. описание функции \ref fft_create).
<BR><BR>
\n \n
\param[in] pfft Указатель на структуру `fft_t`. <BR>
Указатель не должен быть `NULL`. <BR>
\param[in] pfft Указатель на структуру `fft_t`. \n
Указатель не должен быть `NULL`. \n
Структура \ref fft_t должна быть предварительно однократно
заполнена функцией \ref fft_create, и память должна быть
очищена перед выходом функцией \ref fft_free.
<BR><BR>
\n \n
\param[out] y Указатель на комплексный вектор
результата БПФ \f$Y(k)\f$,
\f$ k = 0 \ldots n-1 \f$.
Размер вектора `[n x 1]`. <BR>
Память должна быть выделена.<BR><BR>
Размер вектора `[n x 1]`. \n
Память должна быть выделена. \n \n
\return
`RES_OK` если расчет произведен успешно. <BR>
В противном случае \ref ERROR_CODE_GROUP "код ошибки".<BR><BR>
`RES_OK` если расчет произведен успешно. \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки". \n \n
Пример использования функции `fft`:
@ -339,36 +339,36 @@ www.dsplib.org
\param[in,out] pfft Указатель на структуру `fft_t`. <BR>
Указатель не должен быть `NULL`. <BR><BR>
\param[in,out] pfft Указатель на структуру `fft_t`. \n
Указатель не должен быть `NULL`. \n \n
\param[in] n Размер БПФ \f$n\f$.<BR>
\param[in] n Размер БПФ \f$n\f$. \n
Размер БПФ может быть составным вида
\f$n = n_0 \times n_1 \times n_2 \times n_3 \times \ldots \times n_p \times m\f$,
где \f$n_i = 2,3,5,7\f$, а \f$m \f$ --
произвольный простой множитель не превосходящий 46340.
<BR><BR>
\n \n
Таким образом алгоритм БПФ поддерживает произвольные
длины, равные целой степени чисел 2,3,5,7,
а также различные их комбинации. <BR><BR>
а также различные их комбинации. \n \n
Так например, при \f$ n = 725760 \f$ структура
будет успешно заполнена, отому что
\f$725760 = 2 \cdot 3 \cdot 4 \cdot 5 \cdot 6 \cdot 7 \cdot 9 \cdot 16 \f$,
т.е. получается как произведение множителей 2,3,5,7.
<BR><BR>
\n \n
При \f$ n = 172804 = 43201 \cdot 4 \f$ структура также
будет успешно заполнена, потому что простой множитель
входящий в \f$n\f$ не превосходит 46340.
<BR><BR>
\n \n
Для размера
\f$ n = 13 \cdot 17 \cdot 23 \cdot 13 = 66079 \f$
функция вернет ошибку, поскольку 66079 больше 46340
и не является результатом произведения чисел 2,3,5,7.
<BR><BR>
\n \n
\return
`RES_OK` если структура заполнена успешно. <BR>
В противном случае \ref ERROR_CODE_GROUP "код ошибки".<BR><BR>
`RES_OK` если структура заполнена успешно. \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки". \n \n
\note Некоторые компиляторы при создании структуры не обнуляют ее содержимое.
Поэтому рекомендуется произвести обнуление структуры после ее объявления:
@ -392,11 +392,11 @@ www.dsplib.org
fft_free(&pfft);
\endcode
Перед выходом из программы выделенную в структуре память
необходимо очистить функцией \ref fft_free .<BR><BR>
необходимо очистить функцией \ref fft_free . \n \n
\note Магия числа 46340 заключается в том, что
\f$\sqrt{2^{31}} = 46340.95\f$.
<BR><BR>
\n \n
\author
Бахурин Сергей.
@ -419,7 +419,7 @@ www.dsplib.org
Функция производит очищение памяти промежуточных данных
и векторов поворотных коэффициентов структуры `fft_t`.
\param[in] pfft Указатель на структуру `fft_t`. <BR>
\param[in] pfft Указатель на структуру `fft_t`. \n
\author
Бахурин Сергей.
@ -441,25 +441,25 @@ www.dsplib.org
Функция производит
<a href="http://ru.dsplib.org/content/dft_freq/dft_freq.html">
перестановку спектральных отсчетов ДПФ
</a> и переносит нулевую частоту в центр вектора ДПФ. <BR>
</a> и переносит нулевую частоту в центр вектора ДПФ. \n
Данная функция обрабатывает вещественные входные и выходные вектора
и может применяться для перестановки
амплитудного или фазового спектра.
\param[in] x Указатель на исходный вектор ДПФ. <BR>
Размер вектора `[n x 1]`. <BR><BR>
\param[in] x Указатель на исходный вектор ДПФ. \n
Размер вектора `[n x 1]`. \n \n
\param[in] n Размер ДПФ \f$n\f$ (размер векторов до и после перестановки).
<BR><BR>
\n \n
\param[out] y Указатель на вектор результата перестановки.<BR>
Размер вектора `[n x 1]`. <BR>
Память должна быть выделена.<BR><BR>
\param[out] y Указатель на вектор результата перестановки. \n
Размер вектора `[n x 1]`. \n
Память должна быть выделена. \n \n
\return
`RES_OK` если перестановка произведена успешно. <BR>
В противном случае \ref ERROR_CODE_GROUP "код ошибки":<BR>
`RES_OK` если перестановка произведена успешно. \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки": \n
\author
Бахурин Сергей.

62
dspl/dox/ru/fillarray.dox
Wyświetl plik

@ -6,39 +6,39 @@
Заполняет массив `x` длиной `n` значениями в диапазоне
от \f$x_0\f$ до \f$x_1\f$. Функция поддерживает два типа заполнения
в соответствии с параметром `type`:<BR>
в соответствии с параметром `type`: \n
Симметричное заполнение согласно выражению (параметр `type=DSPL_SYMMETRIC`):<BR>
Симметричное заполнение согласно выражению (параметр `type=DSPL_SYMMETRIC`): \n
\f$x(k) = x_0 + k \cdot dx\f$,
\f$dx = \frac{x_1 - x_0}{n-1}\f$, \f$k = 0 \ldots n-1.\f$
Периодическое заполнение (параметр `type=DSPL_PERIODIC`) согласно выражению:<BR>
Периодическое заполнение (параметр `type=DSPL_PERIODIC`) согласно выражению: \n
\f$x(k) = x_0 + k \cdot dx\f$,
\f$dx = \frac{x_1 - x_0}{n}\f$, \f$k = 0 \ldots n-1.\f$
\param[in] x0 Начальное показателя \f$x_0\f$.<BR><BR>
\param[in] x0 Начальное показателя \f$x_0\f$. \n \n
\param[in] x1 Конечное значение \f$x_1\f$.<BR><BR>
\param[in] x1 Конечное значение \f$x_1\f$. \n \n
\param[in] n Количество точек массива `x`.<BR><BR>
\param[in] n Количество точек массива `x`. \n \n
\param[in] type Тип заполнения:<BR>
`DSPL_SYMMETRIC` - симметричное заполнение,<BR>
`DSPL_PERIODIC` - периодическое заполнение.<BR><BR>
\param[in] type Тип заполнения: \n
`DSPL_SYMMETRIC` - симметричное заполнение, \n
`DSPL_PERIODIC` - периодическое заполнение. \n \n
\param[in,out] x Указатель на вектор равноотстоящих значений .<BR>
Размер вектора `[n x 1]`.<BR>
Память должна быть выделена.<BR><BR>
\param[in,out] x Указатель на вектор равноотстоящих значений . \n
Размер вектора `[n x 1]`. \n
Память должна быть выделена. \n \n
\return
`RES_OK` - функция выполнена успешно. <BR>
`RES_OK` - функция выполнена успешно. \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки".
\note
Отличие периодического и симметричного заполнения можно
понять из следующих примеров. <BR>
понять из следующих примеров. \n
Пример 1. Периодическое заполнение.
\code
double x[5];
@ -48,7 +48,7 @@
\code
0, 1, 2, 3, 4
\endcode
<BR><BR>
\n \n
Пример 2. Симметричное заполнение.
\code
double x[5];
@ -76,10 +76,10 @@
\brief Функция заполняет массив значениями логарифмической шкале
Заполняет массив `x` длиной `n` значениями в диапазоне
от \f$10^{x_0}\f$ до \f$10^{x_1}\f$.<BR>
Функция поддерживает два типа заполнения в соответствии с параметром `type`:<BR>
от \f$10^{x_0}\f$ до \f$10^{x_1}\f$. \n
Функция поддерживает два типа заполнения в соответствии с параметром `type`: \n
Симметричное заполнение согласно выражению:<BR>
Симметричное заполнение согласно выражению: \n
\f$x(k) = 10^{x_0} \cdot dx^k\f$, где \f$dx = \sqrt[n-1]{10^{x_1 - x_0}}\f$,
\f$k = 0 \ldots n-1.\f$
@ -87,29 +87,29 @@
Периодическое заполнение согласно выражению:
\f$x(k) = 10^{x_0} \cdot dx^k\f$, где \f$dx = \sqrt[n]{10^{x_1 - x_0}}\f$,
\f$k = 0 \ldots n-1.\f$<BR>
\f$k = 0 \ldots n-1.\f$ \n
\param[in] x0 Начальное значение показателя \f$x_0\f$.<BR><BR>
\param[in] x0 Начальное значение показателя \f$x_0\f$. \n \n
\param[in] x1 Конечное значение показателя \f$x_1\f$.<BR><BR>
\param[in] x1 Конечное значение показателя \f$x_1\f$. \n \n
\param[in] n Количество точек массива `x`.<BR><BR>
\param[in] n Количество точек массива `x`. \n \n
\param[in] type Тип заполнения:<BR>
`DSPL_SYMMETRIC` - симметричное заполнение,<BR>
`DSPL_PERIODIC` - периодическое заполнение.<BR><BR>
\param[in] type Тип заполнения: \n
`DSPL_SYMMETRIC` - симметричное заполнение, \n
`DSPL_PERIODIC` - периодическое заполнение. \n \n
\param[in,out] x Указатель на вектор значений в логарифмической шкале.<BR>
Размер вектора `[n x 1]`.<BR>
Память должна быть выделена.<BR><BR>
\param[in,out] x Указатель на вектор значений в логарифмической шкале. \n
Размер вектора `[n x 1]`. \n
Память должна быть выделена. \n \n
\return
`RES_OK` - функция выполнена успешно. <BR>
`RES_OK` - функция выполнена успешно. \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки".
\note
Отличие периодического и симметричного заполнения можно
понять из следующих примеров. <BR>
понять из следующих примеров. \n
Пример 1. Периодическое заполнение.
\code
double x[5];
@ -119,7 +119,7 @@
\code
0.01, 0.1, 1, 10, 100
\endcode
<BR><BR>
\n \n
Пример 2. Симметричное заполнение.
\code
double x[5];

112
dspl/dox/ru/filter_an.dox
Wyświetl plik

@ -20,39 +20,39 @@
подстановки \f$ s = j \omega \f$.
\param[in] b Указатель на вектор коэффициентов числителя
передаточной функции \f$ H(s) \f$.<BR>
Размер вектора `[ord+1 x 1]`.<BR><BR>
передаточной функции \f$ H(s) \f$. \n
Размер вектора `[ord+1 x 1]`. \n \n
\param[in] a Указатель на вектор коэффициентов знаменателя
передаточной функции \f$ H(s) \f$.<BR>
Размер вектора `[ord+1 x 1]`.<BR><BR>
передаточной функции \f$ H(s) \f$. \n
Размер вектора `[ord+1 x 1]`. \n \n
\param[in] ord Порядок фильтра. Количество коэффициентов числителя и
знаменателя передаточной функции \f$ H(s) \f$
равно `ord+1`.<BR><BR>
равно `ord+1`. \n \n
\param[in] w Указатель на вектор значений циклической частоты
\f$ \omega \f$ (рад/с), для которого будет рассчитан
комплексный коэффициент передачи
\f$ H(j \omega) \f$.<BR>
Размер вектора `[n x 1]`.<BR><BR>
\f$ H(j \omega) \f$. \n
Размер вектора `[n x 1]`. \n \n
\param[in] n Размер вектора циклической частоты `w`.<BR><BR>
\param[in] n Размер вектора циклической частоты `w`. \n \n
\param[out] h Указатель на вектор комплексного коэффициента передачи
\f$ H(j \omega) \f$, рассчитанного для
циклической частоты `w`.<BR>
Размер вектора `[n x 1]`.<BR>
Память должна быть выделена.<BR> <BR>
циклической частоты `w`. \n
Размер вектора `[n x 1]`. \n
Память должна быть выделена. \n \n
\return
`RES_OK` Комплексноый коэффициент передачи рассчитан успешно.<BR>
В противном случае \ref ERROR_CODE_GROUP "код ошибки".<BR>
`RES_OK` Комплексноый коэффициент передачи рассчитан успешно. \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки". \n
\author
Бахурин Сергей
@ -79,64 +79,64 @@
\param[in] b Указатель на вектор коэффициентов числителя
передаточной функции \f$ H(s) \f$.<BR>
Размер вектора `[ord+1 x 1]`.<BR><BR>
передаточной функции \f$ H(s) \f$. \n
Размер вектора `[ord+1 x 1]`. \n \n
\param[in] a Указатель на вектор коэффициентов знаменателя
передаточной функции \f$ H(s) \f$.<BR>
Размер вектора `[ord+1 x 1]`.<BR><BR>
передаточной функции \f$ H(s) \f$. \n
Размер вектора `[ord+1 x 1]`. \n \n
\param[in] ord Порядок фильтра. Количество коэффициентов
числителя и знаменателя передаточной
функции \f$ H(s) \f$ равно `ord+1`.<BR> <BR>
функции \f$ H(s) \f$ равно `ord+1`. \n \n
\param[in] w Указатель на вектор значений циклической частоты
\f$ \omega \f$ (рад/с), для которого будет рассчитаны
АЧХ, ФЧХ и ГВЗ аналогового фильтра, если установлен
флаг `DSPL_FLAG_ANALOG`.<BR>
Размер вектора `[n x 1]`.<BR>
флаг `DSPL_FLAG_ANALOG`. \n
Размер вектора `[n x 1]`. \n
В случае если флаг `DSPL_FLAG_ANALOG` не установлен, то
вектор частоты `w` используется как нормированная частота
комплексного коэффициента передачи
\f$ H \left(\mathrm{e}^{j\omega} \right) \f$
цифрового фильтра.<BR>
цифрового фильтра. \n
В этом случае характеристика цифрового фильтра является
\f$ 2\pi \f$-периодической, и вектор частоты может содержать
произвольные значения, однако целесообразно задавать
его от 0 до \f$ \pi \f$, а такжет от 0 до \f$ 2\pi \f$, или
от \f$ -\pi \f$ до \f$ \pi \f$.<BR><BR>
от \f$ -\pi \f$ до \f$ \pi \f$. \n \n
\param[in] n Размер вектора циклической частоты `w`.<BR> <BR>
\param[in] n Размер вектора циклической частоты `w`. \n \n
\param[in] flag Комбинация флагов, которые задают расчет параметров:<BR>
\param[in] flag Комбинация флагов, которые задают расчет параметров: \n
<pre>
DSPL_FLAG_ABALOG Коэффициенты относятся к аналоговому фильтру
DSPL_FLAG_LOGMAG АЧХ рассчитывать в логарифмическом масштабе
DSPL_FLAG_UNWRAP раскрывать периодичность ФЧХ
</pre>
\param[out] mag Указатель на вектор АЧХ.<BR>
Размер вектора `[n x 1]`.<BR>
Память должна быть выделена.<BR>
\param[out] mag Указатель на вектор АЧХ. \n
Размер вектора `[n x 1]`. \n
Память должна быть выделена. \n
Если указатель `NULL`, то расчет АЧХ не производится.
<BR><BR>
\n \n
\param[out] phi Указатель на вектор ФЧХ.<BR>
Размер вектора `[n x 1]`.<BR>
Память должна быть выделена.<BR>
\param[out] phi Указатель на вектор ФЧХ. \n
Размер вектора `[n x 1]`. \n
Память должна быть выделена. \n
Если указатель `NULL`, то расчет ФЧХ не производится.
<BR><BR>
\n \n
\param[out] tau Указатель на вектор ГВЗ.<BR>
Размер вектора `[n x 1]`.<BR>
Память должна быть выделена.<BR>
\param[out] tau Указатель на вектор ГВЗ. \n
Размер вектора `[n x 1]`. \n
Память должна быть выделена. \n
Если указатель `NULL`, то расчет ГВЗ не производится.
<BR><BR>
\n \n
\return
`RES_OK` Параметры фильтра рассчитаны успешно.<BR>
В противном случае \ref ERROR_CODE_GROUP "код ошибки".<BR>
`RES_OK` Параметры фильтра рассчитаны успешно. \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки". \n
Пример использования функции `filter_freq_resp`:
@ -153,8 +153,8 @@ DSPL_FLAG_UNWRAP раскрывать периодичность ФЧХ
b[ 4] = 0.000 a[ 4] = 1.000
\endverbatim
<BR><BR>
В каталоге `dat` будут созданы три файла:<BR>
\n \n
В каталоге `dat` будут созданы три файла: \n
<pre>
butter_ap_test_mag.txt АЧХ фильтра
@ -197,41 +197,41 @@ H(z) = \frac {\sum_{k = 0}^{N} b_k z^{-k}}
{\sum_{m = 0}^{N} a_m z^{-m}},
\f]
где \f$N\f$ - порядок фильтра (параметр `ord`).<BR>
где \f$N\f$ - порядок фильтра (параметр `ord`). \n
Комплексный коэффициент передачи рассчитывается путем
подстановки \f$z = e^{j \omega} \f$.<BR>
подстановки \f$z = e^{j \omega} \f$. \n
\param[in] b Указатель на вектор коэффициентов числителя
передаточной функции \f$H(z)\f$.<BR>
Размер вектора `[ord+1 x 1]`.<BR><BR>
передаточной функции \f$H(z)\f$. \n
Размер вектора `[ord+1 x 1]`. \n \n
\param[in] a Указатель на вектор коэффициентов знаменателя
передаточной функции \f$H(z)\f$.<BR>
Размер вектора `[ord+1 x 1]`.<BR><BR>
передаточной функции \f$H(z)\f$. \n
Размер вектора `[ord+1 x 1]`. \n \n
\param[in] ord Порядок фильтра. Количество коэффициентов
числителя и знаменателя передаточной
функции \f$H(z)\f$ равно `ord+1`.<BR><BR>
функции \f$H(z)\f$ равно `ord+1`. \n \n
\param[in] w Указатель на вектор значений нормированной
циклической частоты \f$\omega\f$,
для которого будет рассчитан комплексный коэффициент
передачи \f$ H \left(e^{j \omega} \right)\f$.<BR>
Размер вектора `[n x 1]`.<BR><BR>
передачи \f$ H \left(e^{j \omega} \right)\f$. \n
Размер вектора `[n x 1]`. \n \n
\param[in] n Размер вектора нормированной циклической частоты `w`.<BR><BR>
\param[in] n Размер вектора нормированной циклической частоты `w`. \n \n
\param[out] h Указатель на вектор комплексного коэффициента передачи
\f$ H \left(e^{j \omega} \right)\f$, рассчитанного для
циклической частоты `w`.<BR>
Размер вектора `[n x 1]`.<BR>
Память должна быть выделена.<BR><BR>
циклической частоты `w`. \n
Размер вектора `[n x 1]`. \n
Память должна быть выделена. \n \n
\return
`RES_OK` Комплексный коэффициент передачи расcчитан успешно.<BR>
В противном случае \ref ERROR_CODE_GROUP "код ошибки".<BR>
`RES_OK` Комплексный коэффициент передачи расcчитан успешно. \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки". \n
\note
Комплексный коэффициент передачи \f$ H \left(e^{j \omega} \right)\f$
@ -239,7 +239,7 @@ H(z) = \frac {\sum_{k = 0}^{N} b_k z^{-k}}
нормированной циклической частоты \f$\omega\f$.
Поэтому анализ цифровых фильтров целесообразно вести на одном периоде
повторения \f$ H \left(e^{j \omega} \right)\f$, т.е. в интервале
\f$\omega\f$ от 0 до \f$2 \pi\f$, или от \f$-\pi\f$ до \f$ \pi\f$. <BR>
\f$\omega\f$ от 0 до \f$2 \pi\f$, или от \f$-\pi\f$ до \f$ \pi\f$. \n
Кроме того известно, что для фильтра с вещественными коэффициентами
\f$ H \left(e^{j \omega} \right) = H^* \left(e^{-j \omega} \right)\f$,
а значит, анализ цифрового фильтра с вещественными коэффициентами

246
dspl/dox/ru/filter_ap.dox
Wyświetl plik

@ -13,28 +13,28 @@
аналогового нормированного ФНЧ Баттерворта порядка `ord` с частотой среза
1 рад/с по уровню \f$ -R_p \f$ дБ.
\param[in] Rp Неравномерность АЧХ в полосе пропускания (дБ).<BR>
\param[in] Rp Неравномерность АЧХ в полосе пропускания (дБ). \n
Параметр задает уровень искажений
в полосе от 0 до 1 рад/с.<BR>
Значение должно быть положительным.<BR><BR>
в полосе от 0 до 1 рад/с. \n
Значение должно быть положительным. \n \n
\param[in] ord Порядок фильтра.<BR>
\param[in] ord Порядок фильтра. \n
Количество коэффициентов числителя и знаменателя
передаточной функции \f$H(s)\f$ равно `ord+1`.<BR><BR>
передаточной функции \f$H(s)\f$ равно `ord+1`. \n \n
\param[out] b Указатель на вектор коэффициентов
числителя передаточной функции \f$H(s)\f$.<BR>
Размер вектора `[ord+1 x 1]`.<BR>
Память должна быть выделена.<BR><BR>
числителя передаточной функции \f$H(s)\f$. \n
Размер вектора `[ord+1 x 1]`. \n
Память должна быть выделена. \n \n
\param[out] a Указатель на вектор коэффициентов знаменателя
передаточной функции \f$H(s)\f$.<BR>
Размер вектора `[ord+1 x 1]`.<BR>
Память должна быть выделена.<BR><BR>
передаточной функции \f$H(s)\f$. \n
Размер вектора `[ord+1 x 1]`. \n
Память должна быть выделена. \n \n
\return
`RES_OK` Фильтр рассчитан успешно.<BR><BR>
В противном случае \ref ERROR_CODE_GROUP "код ошибки".<BR>
`RES_OK` Фильтр рассчитан успешно. \n \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки". \n
\author
Бахурин Сергей
@ -58,48 +58,48 @@
Функция рассчитывает значения нулей и полюсов передаточной функции
\f$ H(s)\f$ аналогового нормированного ФНЧ Баттерворта порядка `ord`
с частотой среза 1 рад/с по уровню \f$-R_p\f$ дБ.<BR>
с частотой среза 1 рад/с по уровню \f$-R_p\f$ дБ. \n
\param[in] ord Порядок фильтра. <BR>
\param[in] ord Порядок фильтра. \n
\param[in] rp Неравномерность АЧХ в полосе пропускания (дБ).<BR>
\param[in] rp Неравномерность АЧХ в полосе пропускания (дБ). \n
Параметр задает уровень искажений в
полосе от 0 до 1 рад/с.<BR>
Значение должно быть положительным.<BR><BR>
полосе от 0 до 1 рад/с. \n
Значение должно быть положительным. \n \n
\param[out] z Указатель на массив комплексных нулей
передаточной характеристики \f$ H(s)\f$.<BR>
Максимальный размер вектора вектора `[ord x 1]`.<BR>
Память должна быть выделена.<BR><BR>
передаточной характеристики \f$ H(s)\f$. \n
Максимальный размер вектора вектора `[ord x 1]`. \n
Память должна быть выделена. \n \n
\param[out] nz Указатель на переменную количества нулей
передаточной характеристики \f$ H(s)\f$.<BR>
передаточной характеристики \f$ H(s)\f$. \n
По данному укащзателю будет записано количество
нулей фильтра, которые были рассчитны и
помещены в вектор `z`.<BR>
Память должна быть выделена.<BR><BR>
помещены в вектор `z`. \n
Память должна быть выделена. \n \n
\param[out] p Указатель на массив комплексных полюсов
передаточной характеристики \f$ H(s)\f$.<BR>
Максимальный размер вектора вектора `[ord x 1]`.<BR>
Память должна быть выделена.<BR><BR>
передаточной характеристики \f$ H(s)\f$. \n
Максимальный размер вектора вектора `[ord x 1]`. \n
Память должна быть выделена. \n \n
\param[out] np Указатель на переменную количества полюсов
передаточной характеристики \f$ H(s)\f$.<BR>
передаточной характеристики \f$ H(s)\f$. \n
По данному укащзателю будет записано количество
нулей фильтра, которые были рассчитны и
помещены в вектор `p`.<BR>
Память должна быть выделена.<BR><BR>
помещены в вектор `p`. \n
Память должна быть выделена. \n \n
\return
`RES_OK` Массивы нулей и полюсов рассчитаны успешно.<BR>
В противном случае \ref ERROR_CODE_GROUP "код ошибки".<BR>
`RES_OK` Массивы нулей и полюсов рассчитаны успешно. \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки". \n
\note
Нормированный ФНЧ Баттерворта не имеет нулей,
поэтому массив нулей `z` не будет изменен,
а по указателю `nz` будет записан 0.<BR>
а по указателю `nz` будет записан 0. \n
\author
Бахурин Сергей
@ -122,33 +122,33 @@
Функция рассчитывает коэффициенты передаточной характеристики
\f$ H(s)\f$ аналогового нормированного ФНЧ Чебышёва первого рода
порядка `ord` с частотой среза 1 рад/с по уровню \f$-R_p\f$ дБ.<BR>
порядка `ord` с частотой среза 1 рад/с по уровню \f$-R_p\f$ дБ. \n
Особенностью фильтра Чебышёва первого рода являются
равноволновые пульсации АЧХ в полосе пропускания.
\param[in] Rp Неравномерность АЧХ в полосе пропускания (дБ).<BR>
\param[in] Rp Неравномерность АЧХ в полосе пропускания (дБ). \n
Параметр задает уровень искажений
в полосе от 0 до 1 рад/с.<BR>
Значение должно быть положительным.<BR><BR>
в полосе от 0 до 1 рад/с. \n
Значение должно быть положительным. \n \n
\param[in] ord Порядок фильтра.<BR>
\param[in] ord Порядок фильтра. \n
Количество коэффициентов числителя и знаменателя
передаточной функции \f$ H(s)\f$ равно `ord+1`.<BR><BR>
передаточной функции \f$ H(s)\f$ равно `ord+1`. \n \n
\param[out] b Указатель на вектор коэффициентов числителя
передаточной функции \f$H(s)\f$.<BR>
Размер вектора `[ord+1 x 1]`.<BR>
Память должна быть выделена.<BR><BR>
передаточной функции \f$H(s)\f$. \n
Размер вектора `[ord+1 x 1]`. \n
Память должна быть выделена. \n \n
\param[out] a Указатель на вектор коэффициентов знаменателя
передаточной функции \f$H(s)\f$.<BR>
Размер вектора `[ord+1 x 1]`.<BR>
Память должна быть выделена.<BR><BR>
передаточной функции \f$H(s)\f$. \n
Размер вектора `[ord+1 x 1]`. \n
Память должна быть выделена. \n \n
\return
`RES_OK` Фильтр рассчитан успешно.<BR><BR>
В противном случае \ref ERROR_CODE_GROUP "код ошибки".<BR>
`RES_OK` Фильтр рассчитан успешно. \n \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки". \n
Пример использования функции `cheby1_ap`:
@ -165,8 +165,8 @@ b[ 3] = 0.000 a[ 3] = 0.582
b[ 4] = 0.000 a[ 4] = 1.000
\endverbatim
<BR><BR>
В каталоге `dat` будут созданы три файла:<BR>
\n \n
В каталоге `dat` будут созданы три файла: \n
<pre>
cheby1_ap_test_mag.txt АЧХ фильтра
@ -204,49 +204,49 @@ cheby1_ap_test_tau.txt ГВЗ фильтра
Функция рассчитывает значения нулей и полюсов передаточной функции
\f$ H(s)\f$ аналогового нормированного ФНЧ Чебышёва первого рода
порядка `ord` с частотой среза 1 рад/с по уровню \f$-R_p\f$ дБ, с
неравномерностью в полосе пропускания \f$ R_p \f$ дБ.<BR>
неравномерностью в полосе пропускания \f$ R_p \f$ дБ. \n
\param[in] ord Порядок фильтра. <BR>
\param[in] ord Порядок фильтра. \n
\param[in] rp Неравномерность АЧХ в полосе пропускания (дБ).<BR>
\param[in] rp Неравномерность АЧХ в полосе пропускания (дБ). \n
Параметр задает уровень искажений
в полосе от 0 до 1 рад/с.<BR>
Значение должно быть положительным.<BR><BR>
в полосе от 0 до 1 рад/с. \n
Значение должно быть положительным. \n \n
\param[out] z Указатель на массив комплексных нулей
передаточной характеристики \f$ H(s)\f$.<BR>
Максимальный размер вектора вектора `[ord x 1]`.<BR>
Память должна быть выделена.<BR><BR>
передаточной характеристики \f$ H(s)\f$. \n
Максимальный размер вектора вектора `[ord x 1]`. \n
Память должна быть выделена. \n \n
\param[out] nz Указатель на переменную количества нулей
передаточной функции \f$H(s)\f$.<BR>
передаточной функции \f$H(s)\f$. \n
По данному указателю будет записано количество
нулей фильтра, которые были
рассчитаны и помещены в вектор `z`.<BR>
Память должна быть выделена.<BR><BR>
рассчитаны и помещены в вектор `z`. \n
Память должна быть выделена. \n \n
\param[out] p Указатель на массив комплексных полюсов
передаточной характеристики \f$H(s)\f$.<BR>
Максимальный размер вектора вектора `[ord x 1]`.<BR>
Память должна быть выделена.<BR><BR>
передаточной характеристики \f$H(s)\f$. \n
Максимальный размер вектора вектора `[ord x 1]`. \n
Память должна быть выделена. \n \n
\param[out] np Указатель на переменную количества полюсов
передаточной функции \f$ H(s)\f$.<BR>
передаточной функции \f$ H(s)\f$. \n
По данному укащзателю будет записано количество
нулей фильтра, которые были
рассчитны и помещены в вектор `p`.<BR>
Память должна быть выделена.<BR><BR>
рассчитны и помещены в вектор `p`. \n
Память должна быть выделена. \n \n
\return
`RES_OK` Массивы нулей и полюсов рассчитаны успешно.<BR>
В противном случае \ref ERROR_CODE_GROUP "код ошибки".<BR>
`RES_OK` Массивы нулей и полюсов рассчитаны успешно. \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки". \n
\note
Нормированный ФНЧ Чебышёва первого рода не имеет нулей,
поэтому массив нулей `z` не будет изменен,
а по указателю `nz` будет записан 0.<BR>
а по указателю `nz` будет записан 0. \n
\author
Бахурин Сергей
@ -267,32 +267,32 @@ cheby1_ap_test_tau.txt ГВЗ фильтра
Функция рассчитывает коэффициенты передаточной характеристики \f$H(s)\f$
аналогового нормированного ФНЧ Чебышёва второго рода порядка `ord`
с частотой заграждения 1 рад/с по уровню \f$-R_s\f$ дБ.<BR>
с частотой заграждения 1 рад/с по уровню \f$-R_s\f$ дБ. \n
Особенностью фильтра Чебышёва второго рода являются: <BR>
1) равноволновые пульсации АЧХ в полосе заграждения.<BR>
2) уровень АЧХ \f$H(j\cdot 1) = -R_s\f$ дБ.<BR>
Особенностью фильтра Чебышёва второго рода являются: \n
1) равноволновые пульсации АЧХ в полосе заграждения. \n
2) уровень АЧХ \f$H(j\cdot 1) = -R_s\f$ дБ. \n
\param[in] Rs Уровень подавления в полосе пропускания (дБ).<BR>
Значение должно быть положительным.<BR><BR>
\param[in] Rs Уровень подавления в полосе пропускания (дБ). \n
Значение должно быть положительным. \n \n
\param[in] ord Порядок фильтра. <BR>
\param[in] ord Порядок фильтра. \n
Количество коэффициентов числителя и знаменателя
передаточной функции \f$H(s)\f$ равно `ord+1`.<BR><BR>
передаточной функции \f$H(s)\f$ равно `ord+1`. \n \n
\param[out] b Указатель на вектор коэффициентов числителя
передаточной функции \f$H(s)\f$.<BR>
Размер вектора `[ord+1 x 1]`.<BR>
Память должна быть выделена.<BR><BR>
передаточной функции \f$H(s)\f$. \n
Размер вектора `[ord+1 x 1]`. \n
Память должна быть выделена. \n \n
\param[out] a Указатель на вектор коэффициентов знаменателя
передаточной функции \f$H(s)\f$.<BR>
Размер вектора `[ord+1 x 1]`.<BR>
Память должна быть выделена.<BR><BR>
передаточной функции \f$H(s)\f$. \n
Размер вектора `[ord+1 x 1]`. \n
Память должна быть выделена. \n \n
\return
`RES_OK` Фильтр рассчитан успешно.<BR>
В противном случае \ref ERROR_CODE_GROUP "код ошибки".<BR>
`RES_OK` Фильтр рассчитан успешно. \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки". \n
\author
Бахурин Сергей
www.dsplib.org
@ -312,43 +312,43 @@ cheby1_ap_test_tau.txt ГВЗ фильтра
Функция рассчитывает значения нулей и полюсов передаточной функции
\f$H(s)\f$ аналогового нормированного ФНЧ Чебышёва второго рода порядка `ord` с
частотой заграждения 1 рад/с по уровню \f$-R_s\f$ дБ.<BR>
частотой заграждения 1 рад/с по уровню \f$-R_s\f$ дБ. \n
\param[in] ord Порядок фильтра. <BR>
\param[in] ord Порядок фильтра. \n
\param[in] rs Уровень подавления АЧХ в полосе загражения (дБ).<BR>
\param[in] rs Уровень подавления АЧХ в полосе загражения (дБ). \n
Параметр задает уровень подавления сигнала
в полосе частот от 1 рад/с и выше.<BR>
Значение должно быть положительным.<BR><BR>
в полосе частот от 1 рад/с и выше. \n
Значение должно быть положительным. \n \n
\param[out] z Указатель на массив комплексных нулей передаточной
характеристики \f$H(s)\f$.<BR>
Максимальный размер вектора вектора `[ord x 1]`.<BR>
Память должна быть выделена.<BR><BR>
характеристики \f$H(s)\f$. \n
Максимальный размер вектора вектора `[ord x 1]`. \n
Память должна быть выделена. \n \n
\param[out] nz Указатель на переменную количества нулей передаточной
функции \f$H(s)\f$.<BR>
функции \f$H(s)\f$. \n
По данному укащзателю будет записано количество нулей
фильтра, которые были
рассчитны и помещены в вектор `z`.<BR>
Память должна быть выделена.<BR><BR>
рассчитны и помещены в вектор `z`. \n
Память должна быть выделена. \n \n
\param[out] p Указатель на массив комплексных полюсов передаточной
характеристики \f$H(s)\f$.<BR>
Максимальный размер вектора вектора `[ord x 1]`.<BR>
Память должна быть выделена.<BR><BR>
характеристики \f$H(s)\f$. \n
Максимальный размер вектора вектора `[ord x 1]`. \n
Память должна быть выделена. \n \n
\param[out] np Указатель на переменную количества полюсов передаточной
функции \f$H(s)\f$.<BR>
функции \f$H(s)\f$. \n
По данному укащзателю будет записано количество нулей
фильтра, которые были
рассчитны и помещены в вектор `p`.<BR>
Память должна быть выделена.<BR><BR>
рассчитны и помещены в вектор `p`. \n
Память должна быть выделена. \n \n
\return
`RES_OK` Массивы нулей и полюсов рассчитаны успешно.<BR>
В противном случае \ref ERROR_CODE_GROUP "код ошибки".<BR>
`RES_OK` Массивы нулей и полюсов рассчитаны успешно. \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки". \n
Пример использования функции `cheby2_ap_zp`:
@ -406,41 +406,41 @@ H(s) =
\f]
\param[in] z Указатель на массив нулей
передаточной характеристики.<BR>
Размер вектора `[nz x 1]`.<BR>
передаточной характеристики. \n
Размер вектора `[nz x 1]`. \n
Указатель может быть `NULL` если фильтр не
имеет конечных нулей (`nz=0`).<BR><BR>
имеет конечных нулей (`nz=0`). \n \n
\param[in] nz Размер вектора нулей передаточной характеристики
(может быть равен 0).<BR><BR>
(может быть равен 0). \n \n
\param[in] p Указатель на массив полюсов
передаточной характеристики.<BR>
Размер вектора `[np x 1]`.<BR>
Указатель не может быть `NULL`.<BR>
Память должна быть выделена.<BR><BR>
передаточной характеристики. \n
Размер вектора `[np x 1]`. \n
Указатель не может быть `NULL`. \n
Память должна быть выделена. \n \n
\param[in] np Размер вектора полюсов передаточной характеристики
(не может быть равен 0).<BR><BR>
(не может быть равен 0). \n \n
\param[in] ord Порядок фильтра для которого
рассчитаны нули и полюса. <BR>
рассчитаны нули и полюса. \n
Количество коэффициентов числителя и знаменателя
передаточной функции \f$H(s)\f$ равно `ord+1`.<BR><BR>
передаточной функции \f$H(s)\f$ равно `ord+1`. \n \n
\param[out] b Указатель на вектор коэффициентов числителя
передаточной функции \f$H(s)\f$.<BR>
Размер вектора `[ord+1 x 1]`.<BR>
Память должна быть выделена.<BR><BR>
передаточной функции \f$H(s)\f$. \n
Размер вектора `[ord+1 x 1]`. \n
Память должна быть выделена. \n \n
\param[out] a Указатель на вектор коэффициентов знаменателя
передаточной функции \f$H(s)\f$.<BR>
Размер вектора `[ord+1 x 1]`.<BR>
Память должна быть выделена.<BR><BR>
передаточной функции \f$H(s)\f$. \n
Размер вектора `[ord+1 x 1]`. \n
Память должна быть выделена. \n \n
\return
`RES_OK` Пересчет произведен успешно.<BR>
В противном случае \ref ERROR_CODE_GROUP "код ошибки".<BR>
`RES_OK` Пересчет произведен успешно. \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки". \n
\note Функция возвращает вещественные значения коэффициентов `b` и
`a` передаточной функции. Это означает, что вектора нулей и полюсов

112
dspl/dox/ru/filter_ft.dox
Wyświetl plik

@ -13,40 +13,40 @@
\param[in] b Указатель на вектор коэффициентов
числителя передаточной функции \f$H(s)\f$
исходного аналогового ФНЧ.<BR>
Размер вектора `[ord+1 x 1]`.<BR>
Память должна быть выделена.<BR><BR>
исходного аналогового ФНЧ. \n
Размер вектора `[ord+1 x 1]`. \n
Память должна быть выделена. \n \n
\param[in] a Указатель на вектор коэффициентов знаменателя
передаточной функции \f$H(s)\f$
исходного аналогового ФНЧ.<BR>
Размер вектора `[ord+1 x 1]`.<BR>
Память должна быть выделена.<BR><BR>
исходного аналогового ФНЧ. \n
Размер вектора `[ord+1 x 1]`. \n
Память должна быть выделена. \n \n
\param[in] ord Порядок исходного фильтра и
фильтра после переобразования.<BR><BR>
фильтра после переобразования. \n \n
\param[in] w0 Частота среза исходного ФНЧ.<BR><BR>
\param[in] w0 Частота среза исходного ФНЧ. \n \n
\param[in] w1 Требуемая частота среза ФВЧ
после преобразования.<BR><BR>
после преобразования. \n \n
\param[in,out] beta Указатель на вектор коэффициентов
числителя передаточной функции \f$F(s)\f$
ФВЧ после преобразования.<BR>
Размер вектора `[ord+1 x 1]`.<BR>
Память должна быть выделена.<BR><BR>
ФВЧ после преобразования. \n
Размер вектора `[ord+1 x 1]`. \n
Память должна быть выделена. \n \n
\param[in,out] alpha Указатель на вектор коэффициентов знаменателя
передаточной функции \f$F(s)\f$
аналогового ФВЧ после преобразования.<BR>
Размер вектора `[ord+1 x 1]`.<BR>
Память должна быть выделена.<BR><BR>
аналогового ФВЧ после преобразования. \n
Размер вектора `[ord+1 x 1]`. \n
Память должна быть выделена. \n \n
\return
`RES_OK` Преоборазование расчитано успешно.<BR><BR>
В противном случае \ref ERROR_CODE_GROUP "код ошибки".<BR>
`RES_OK` Преоборазование расчитано успешно. \n \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки". \n
\author
Бахурин Сергей
@ -74,39 +74,39 @@
\param[in] b Указатель на вектор коэффициентов
числителя передаточной функции \f$H(s)\f$
исходного аналогового ФНЧ.<BR>
Размер вектора `[ord+1 x 1]`.<BR>
Память должна быть выделена.<BR><BR>
исходного аналогового ФНЧ. \n
Размер вектора `[ord+1 x 1]`. \n
Память должна быть выделена. \n \n
\param[in] a Указатель на вектор коэффициентов знаменателя
передаточной функции \f$H(s)\f$
исходного аналогового ФНЧ.<BR>
Размер вектора `[ord+1 x 1]`.<BR>
Память должна быть выделена.<BR><BR>
исходного аналогового ФНЧ. \n
Размер вектора `[ord+1 x 1]`. \n
Память должна быть выделена. \n \n
\param[in] ord Порядок исходного фильтра и
фильтра после переобразования.<BR><BR>
фильтра после переобразования. \n \n
\param[in] w0 Частота среза исходного ФНЧ.<BR><BR>
\param[in] w0 Частота среза исходного ФНЧ. \n \n
\param[in] w1 Требуемая частота среза ФНЧ
после преобразования.<BR><BR>
после преобразования. \n \n
\param[in,out] beta Указатель на вектор коэффициентов
числителя передаточной функции \f$F(s)\f$
ФНЧ после преобразования.<BR>
Размер вектора `[ord+1 x 1]`.<BR>
Память должна быть выделена.<BR><BR>
ФНЧ после преобразования. \n
Размер вектора `[ord+1 x 1]`. \n
Память должна быть выделена. \n \n
\param[in,out] alpha Указатель на вектор коэффициентов знаменателя
передаточной функции \f$F(s)\f$
аналогового ФНЧ после преобразования.<BR>
Размер вектора `[ord+1 x 1]`.<BR>
Память должна быть выделена.<BR><BR>
аналогового ФНЧ после преобразования. \n
Размер вектора `[ord+1 x 1]`. \n
Память должна быть выделена. \n \n
\return
`RES_OK` Преоборазование расчитано успешно.<BR><BR>
В противном случае \ref ERROR_CODE_GROUP "код ошибки".<BR>
`RES_OK` Преоборазование расчитано успешно. \n \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки". \n
\author
Бахурин Сергей
@ -142,45 +142,45 @@ Y(s) = \frac{\sum\limits_{m = 0}^{n p} \beta_m s^m}{\sum\limits_{k = 0}^{n p} \
фильтров в соответствующие передаточные характеристики цифровых фильтров.
\param[in] b Указатель на вектор коэффициентов
числителя функции \f$H(s)\f$.<BR>
Размер вектора `[n+1 x 1]`.<BR>
Память должна быть выделена.<BR><BR>
числителя функции \f$H(s)\f$. \n
Размер вектора `[n+1 x 1]`. \n
Память должна быть выделена. \n \n
\param[in] a Указатель на вектор коэффициентов знаменателя
функции \f$H(s)\f$.<BR>
Размер вектора `[n+1 x 1]`.<BR>
Память должна быть выделена.<BR><BR>
функции \f$H(s)\f$. \n
Размер вектора `[n+1 x 1]`. \n
Память должна быть выделена. \n \n
\param[in] n Порядок полиномов рациональной
функции \f$H(s)\f$.<BR><BR>
функции \f$H(s)\f$. \n \n
\param[in] c Указатель на вектор коэффициентов
числителя функции \f$F(s)\f$.<BR>
Размер вектора `[p+1 x 1]`.<BR>
Память должна быть выделена.<BR><BR>
числителя функции \f$F(s)\f$. \n
Размер вектора `[p+1 x 1]`. \n
Память должна быть выделена. \n \n
\param[in] d Указатель на вектор коэффициентов знаменателя
функции \f$F(s)\f$.<BR>
Размер вектора `[p+1 x 1]`.<BR>
Память должна быть выделена.<BR><BR>
функции \f$F(s)\f$. \n
Размер вектора `[p+1 x 1]`. \n
Память должна быть выделена. \n \n
\param[in] p Порядок полиномов рациональной
функции \f$F(s)\f$.<BR><BR>
функции \f$F(s)\f$. \n \n
\param[in,out] beta Указатель на вектор коэффициентов
числителя функции \f$Y(s) = (H \circ F)(s)\f$.<BR>
Размер вектора `[n*p+1 x 1]`.<BR>
Память должна быть выделена.<BR><BR>
числителя функции \f$Y(s) = (H \circ F)(s)\f$. \n
Размер вектора `[n*p+1 x 1]`. \n
Память должна быть выделена. \n \n
\param[in,out] alpha Указатель на вектор коэффициентов знаменателя
функции \f$Y(s) = (H \circ F)(s)\f$.<BR>
Размер вектора `[n*p+1 x 1]`.<BR>
Память должна быть выделена.<BR><BR>
функции \f$Y(s) = (H \circ F)(s)\f$. \n
Размер вектора `[n*p+1 x 1]`. \n
Память должна быть выделена. \n \n
\return
`RES_OK` Рациональная композиция рассчитана успешно.<BR><BR>
В противном случае \ref ERROR_CODE_GROUP "код ошибки".<BR>
`RES_OK` Рациональная композиция рассчитана успешно. \n \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки". \n
\author
Бахурин Сергей

32
dspl/dox/ru/filter_iir.dox
Wyświetl plik

@ -26,36 +26,36 @@ s \leftarrow \frac{1 - z^{-1}}{1 - z^{-1}}.
\param[in] bs Указатель на вектор коэффициентов
числителя передаточной функции \f$H(s)\f$
исходного аналогового фильтра.<BR>
Размер вектора `[ord+1 x 1]`.<BR>
Память должна быть выделена.<BR><BR>
исходного аналогового фильтра. \n
Размер вектора `[ord+1 x 1]`. \n
Память должна быть выделена. \n \n
\param[in] as Указатель на вектор коэффициентов
знаменателя передаточной функции \f$H(s)\f$
исходного аналогового фильтра.<BR>
Размер вектора `[ord+1 x 1]`.<BR>
Память должна быть выделена.<BR><BR>
исходного аналогового фильтра. \n
Размер вектора `[ord+1 x 1]`. \n
Память должна быть выделена. \n \n
\param[in] ord Порядок фильтра.<BR>
\param[in] ord Порядок фильтра. \n
Количество коэффициентов числителя и знаменателя
передаточных функций \f$H(s)\f$ и \f$H(z)\f$
аналогового и цифрового фильтров равно `ord+1`.<BR><BR>
аналогового и цифрового фильтров равно `ord+1`. \n \n
\param[out] bz Указатель на вектор коэффициентов
числителя передаточной функции \f$H(z)\f$
полученного цифрового фильтра.<BR>
Размер вектора `[ord+1 x 1]`.<BR>
Память должна быть выделена.<BR><BR>
полученного цифрового фильтра. \n
Размер вектора `[ord+1 x 1]`. \n
Память должна быть выделена. \n \n
\param[out] az Указатель на вектор коэффициентов
знаменателя передаточной функции \f$H(z)\f$
полученного цифрового фильтра.<BR>
Размер вектора `[ord+1 x 1]`.<BR>
Память должна быть выделена.<BR><BR>
полученного цифрового фильтра. \n
Размер вектора `[ord+1 x 1]`. \n
Память должна быть выделена. \n \n
\return
`RES_OK` Фильтр рассчитан успешно.<BR><BR>
В противном случае \ref ERROR_CODE_GROUP "код ошибки".<BR>
`RES_OK` Фильтр рассчитан успешно. \n \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки". \n
<h3>Пример использования функции `bilinear`</h3>

78
dspl/dox/ru/fourier_series.dox
Wyświetl plik

@ -5,40 +5,40 @@
\brief Расчет коэффициентов разложения в ряд Фурье
Функция рассчитывает спектр периодического сигнала при усечении ряда Фурье<BR>
Функция рассчитывает спектр периодического сигнала при усечении ряда Фурье \n
\param[in] t Указатель на массив моментов времени дискретизации
исходного сигнала `s`<BR>
размер вектора вектора `[nt x 1]`.<BR>
Память должна быть выделена.<BR><BR>
исходного сигнала `s` \n
размер вектора вектора `[nt x 1]`. \n
Память должна быть выделена. \n \n
\param[in] s Указатель на массив значений исходного сигнала`s`.<BR>
Размер вектора `[nt x 1]`.<BR>
Память должна быть выделена.<BR><BR>
\param[in] s Указатель на массив значений исходного сигнала`s`. \n
Размер вектора `[nt x 1]`. \n
Память должна быть выделена. \n \n
\param[in] nt Размер выборки исходного сигнала.<BR>
Значение должно быть положительным.<BR><BR>
\param[in] nt Размер выборки исходного сигнала. \n
Значение должно быть положительным. \n \n
\param[in] period Период повторения сигнала.<BR><BR>
\param[in] period Период повторения сигнала. \n \n
\param[in] nw Размер усеченного ряда Фурье.<BR><BR>
\param[in] nw Размер усеченного ряда Фурье. \n \n
\param[out] w Указатель на массив частот спектра
периодического сигнала.<BR>
Размер вектора `[nw x 1]`.<BR>
Память должна быть выделена.<BR><BR>
периодического сигнала. \n
Размер вектора `[nw x 1]`. \n
Память должна быть выделена. \n \n
\param[out] y Указатель массив комплексных значений спектра
периодического сигнала.<BR>
Размер вектора `[nw x 1]`.<BR>
Память должна быть выделена.<BR><BR>
периодического сигнала. \n
Размер вектора `[nw x 1]`. \n
Память должна быть выделена. \n \n
\return
`RES_OK` Коэффициенты ряда Фурье рассчитаны успешно.<BR>
`RES_OK` Коэффициенты ряда Фурье рассчитаны успешно. \n
В противном случае
\ref ERROR_CODE_GROUP "код ошибки".<BR>
\ref ERROR_CODE_GROUP "код ошибки". \n
\note
Для расчета спектра сигнала используется численное интегрирование
@ -46,7 +46,7 @@
эффективной. Для увеличения скорости расчета спектра сигнала
целесообразнее использовать алгоритмы дискретного
и быстрого преобразования Фурье.
<BR>
\n
\author
Бахурин Сергей
@ -72,35 +72,35 @@ s(t) = \sum\limits_{n = 0}^{n_{\omega}-1} S(\omega_n) \exp(j\omega_n t)
\f]
\param[in] w Указатель на массив частот \f$\omega_n\f$
усеченного ряда Фурье.<BR>
Размер вектора `[nw x 1]`.<BR>
Память должна быть выделена и заполнена.<BR><BR>
усеченного ряда Фурье. \n
Размер вектора `[nw x 1]`. \n
Память должна быть выделена и заполнена. \n \n
\param[in] s Указатель на массив значений спектра
\f$S(\omega_n)\f$.<BR>
Размер вектора `[nw x 1]`.<BR>
Память должна быть выделена и заполнена.<BR><BR>
\f$S(\omega_n)\f$. \n
Размер вектора `[nw x 1]`. \n
Память должна быть выделена и заполнена. \n \n
\param[in] nw Количество членов усеченного ряда Фурье.<BR>
Значение должно быть положительным.<BR><BR>
\param[in] nw Количество членов усеченного ряда Фурье. \n
Значение должно быть положительным. \n \n
\param[in] t Указатель на массив временных отсчетов
восстановленного сигнала.<BR>
Размер вектора `[nt x 1]`.<BR>
Память должна быть выделена и заполнена.<BR><BR>
<BR><BR>
восстановленного сигнала. \n
Размер вектора `[nt x 1]`. \n
Память должна быть выделена и заполнена. \n \n
\n \n
\param[in] nt Размер вектора времени и восстановленного сигнала.<BR><BR>
\param[in] nt Размер вектора времени и восстановленного сигнала. \n \n
\param[out] y Указатель на массив восстановленного сигнала.<BR>
Размер вектора `[nt x 1]`.<BR>
Память должна быть выделена.<BR><BR>
\param[out] y Указатель на массив восстановленного сигнала. \n
Размер вектора `[nt x 1]`. \n
Память должна быть выделена. \n \n
\return
`RES_OK` Массивы нулей и полюсов рассчитаны успешно.<BR>
`RES_OK` Массивы нулей и полюсов рассчитаны успешно. \n
В противном случае
\ref ERROR_CODE_GROUP "код ошибки".<BR>
\ref ERROR_CODE_GROUP "код ошибки". \n
\note
Выходной восстановленный сигнал в общем случае является комплексным.
@ -108,7 +108,7 @@ s(t) = \sum\limits_{n = 0}^{n_{\omega}-1} S(\omega_n) \exp(j\omega_n t)
нулевой частоты получим мнимую часть элементов вектора `y` на уровне ошибок
округления числа с двойной точностью. Ничтожно малую мнимую часть в этом случае
можно игнорировать.
<BR>
\n
\author
Бахурин Сергей

56
dspl/dox/ru/goertzel.dox
Wyświetl plik

@ -8,36 +8,36 @@
Данный алгоритм позволяет рассчитать `k` спектральных отсчетов `n`-точечного ДПФ,
заданных вектором индексов `ind`.
\param[in] x Указатель на вектор вещественного входного сигнала.<BR>
Размер вектора `[n x 1]`.<BR><BR>
\param[in] x Указатель на вектор вещественного входного сигнала. \n
Размер вектора `[n x 1]`. \n \n
\param[in] n Размер вектора входного сигнала.<BR><BR>
\param[in] n Размер вектора входного сигнала. \n \n
\param[in] ind Указатель на вектор индексов спектральных отсчетов для расчета которых
будет использоваться алгоритм Герцеля.<BR>
Размер вектора `[k x 1]`.<BR><BR>
будет использоваться алгоритм Герцеля. \n
Размер вектора `[k x 1]`. \n \n
\param[in] k Размер вектора индексов спектральных отсчетов `ind`.<BR><BR>
\param[in] k Размер вектора индексов спектральных отсчетов `ind`. \n \n
\param[out] y Указатель на вектор спектральных отсчетов,
соответствующих номерам `ind`.<BR>
Размер вектора `[k x 1]`.<BR>
Память должна быть выделена.<BR><BR>
соответствующих номерам `ind`. \n
Размер вектора `[k x 1]`. \n
Память должна быть выделена. \n \n
\return
`RES_OK` Функция выполнена успешно. <BR>
В противном случае \ref ERROR_CODE_GROUP "код ошибки".<BR>
`RES_OK` Функция выполнена успешно. \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки". \n
\note
Алгоритм Герцеля эффективен когда необходимо рассчитать несколько спектральных отсчетов
сигнала большой длительности. <BR>
сигнала большой длительности. \n
Однако, размер `k` вектора индексов `ind` может быть произвольным,
в том числе больше длины сигнала `n`. В этом случае некоторые спектральные отсчеты
будут повторяться, но это не повлечет за собой ошибки выполнения.<BR>
будут повторяться, но это не повлечет за собой ошибки выполнения. \n
Значения индексов спектральных отсчетов `ind` также могут быть произвольными целыми,
в том числе и отрицательными. В этом случае будут рассчитаны спектральные отсчеты с индексами
по модулю `n`.<BR>
по модулю `n`. \n
\author
@ -59,36 +59,36 @@
Данный алгоритм позволяет рассчитать `k` спектральных отсчетов `n`-точечного ДПФ,
заданных вектором индексов `ind`.
\param[in] x Указатель на вектор комплексного входного сигнала.<BR>
Размер вектора `[n x 1]`.<BR><BR>
\param[in] x Указатель на вектор комплексного входного сигнала. \n
Размер вектора `[n x 1]`. \n \n
\param[in] n Размер вектора входного сигнала.<BR><BR>
\param[in] n Размер вектора входного сигнала. \n \n
\param[in] ind Указатель на вектор индексов спектральных отсчетов для расчета которых
будет использоваться алгоритм Герцеля.<BR>
Размер вектора `[k x 1]`.<BR><BR>
будет использоваться алгоритм Герцеля. \n
Размер вектора `[k x 1]`. \n \n
\param[in] k Размер вектора индексов спектральных отсчетов `ind`.<BR><BR>
\param[in] k Размер вектора индексов спектральных отсчетов `ind`. \n \n
\param[out] y Указатель на вектор спектральных отсчетов,
соответствующих номерам `ind`.<BR>
Размер вектора `[k x 1]`.<BR>
Память должна быть выделена.<BR><BR>
соответствующих номерам `ind`. \n
Размер вектора `[k x 1]`. \n
Память должна быть выделена. \n \n
\return
`RES_OK` Функция выполнена успешно. <BR>
В противном случае \ref ERROR_CODE_GROUP "код ошибки".<BR>
`RES_OK` Функция выполнена успешно. \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки". \n
\note
Алгоритм Герцеля эффективен когда необходимо рассчитать несколько спектральных отсчетов
сигнала большой длительности. <BR>
сигнала большой длительности. \n
Однако, размер `k` вектора индексов `ind` может быть произвольным,
в том числе больше длины сигнала `n`. В этом случае некоторые спектральные отсчеты
будут повторяться, но это не повлечет за собой ошибки выполнения.<BR>
будут повторяться, но это не повлечет за собой ошибки выполнения. \n
Значения индексов спектральных отсчетов `ind` также могут быть произвольными целыми,
в том числе и отрицательными. В этом случае будут рассчитаны спектральные отсчеты с индексами
по модулю `n`.<BR><BR>
по модулю `n`. \n \n
\author

76
dspl/dox/ru/inout.dox
Wyświetl plik

@ -4,48 +4,48 @@
\brief Сохранить данные в бинарный файл
Функция сохраняет реальный или комплексный вектор данных
размера `[n x 1]` в бинарный файл `fn`. <BR><BR>
размера `[n x 1]` в бинарный файл `fn`. \n \n
Файл является универсальным для хранения как одномерных,
так и двумерных массивов и имеет следующий формат: <BR><BR>
так и двумерных массивов и имеет следующий формат: \n \n
type 4 байта типа `int`. <BR>
Может принимать значение:<BR>
`DAT_DOUBLE`, если адрес `x` указывает на вектор вещественных чисел; <BR>
`DAT_COMPLEX`, если адрес `x` указывает на вектор комплексных чисел.<BR><BR>
type 4 байта типа `int`. \n
Может принимать значение: \n
`DAT_DOUBLE`, если адрес `x` указывает на вектор вещественных чисел; \n
`DAT_COMPLEX`, если адрес `x` указывает на вектор комплексных чисел. \n \n
`n` 4 байта типа `int`. <BR>
Количество строк данных. <BR><BR>
`n` 4 байта типа `int`. \n
Количество строк данных. \n \n
`m` 4 байта типа `int`.<BR>
Количество столбцов данных. <BR>
При сохранении вектора всегда равно 1.<BR><BR>
`m` 4 байта типа `int`. \n
Количество столбцов данных. \n
При сохранении вектора всегда равно 1. \n \n
data после идут данные в бинарном виде.<BR>
Размер данных:<BR>
`n * sizeof(double)`, если `dtype==DAT_DOUBLE`;<BR>
`n * sizeof(complex_t)`, если `dtype==DAT_COMPLEX`.<BR><BR>
data после идут данные в бинарном виде. \n
Размер данных: \n
`n * sizeof(double)`, если `dtype==DAT_DOUBLE`; \n
`n * sizeof(complex_t)`, если `dtype==DAT_COMPLEX`. \n \n
Файл может быть использован для верификации алгоритмов сторонними пакетами,
такими как GNU Octave или Matlab.<BR><BR>
такими как GNU Octave или Matlab. \n \n
\param[in] x Указатель на массив данных. <BR>
Размер вектора `[n x 1]`.<BR><BR>
\param[in] x Указатель на массив данных. \n
Размер вектора `[n x 1]`. \n \n
\param[in] n Размер вектора данных.<BR><BR>
\param[in] n Размер вектора данных. \n \n
\param[in] dtype Тип данных.<BR>
Может принимать значения: `DAT_DOUBLE` или `DAT_COMPLEX`.<BR><BR>
\param[in] dtype Тип данных. \n
Может принимать значения: `DAT_DOUBLE` или `DAT_COMPLEX`. \n \n
\param[in] fn Имя файла.<BR><BR>
\param[in] fn Имя файла. \n \n
\return
`RES_OK` Файл сохранен успешно.<BR>
В противном случае \ref ERROR_CODE_GROUP "код ошибки":<BR>
`RES_OK` Файл сохранен успешно. \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки": \n
\note
Данная функция производит запись в файл без потери точности,
поэтому рекомендуется использовать ее для верификации данных DSPL.<BR><BR>
поэтому рекомендуется использовать ее для верификации данных DSPL. \n \n
Функция для чтения бинарного файла в GNU Octave и Matlab:
@ -94,9 +94,9 @@
\fn int writetxt(double* x, double *y, int n, char* fn)
\brief Сохранить вещественные данные в текстовый файл
Функция сохраняет вещественные данные в текстовый файл `fn`. <BR>
Функция сохраняет вещественные данные в текстовый файл `fn`. \n
Файл имеет следующий формат<BR>
Файл имеет следующий формат \n
\verbatim
x[0] y[0]
@ -105,25 +105,25 @@
x[n-1] y[n-1]
\endverbatim
Файл может быть использован для построения графика сторонней программой.<BR><BR>
Файл может быть использован для построения графика сторонней программой. \n \n
\param[in] x Указатель на первый вектор. <BR>
Размер вектора `[n x 1]`.<BR><BR>
\param[in] x Указатель на первый вектор. \n
Размер вектора `[n x 1]`. \n \n
\param[in] y Указатель на второй вектор. <BR>
Размер вектора `[n x 1]`. <BR>
Может быть `NULL`. <BR>
\param[in] y Указатель на второй вектор. \n
Размер вектора `[n x 1]`. \n
Может быть `NULL`. \n
Файл будет содержать только один столбец соответствующий
вектору `x` если `y == NULL`.<BR><BR>
вектору `x` если `y == NULL`. \n \n
\param[in] n Размер входных векторов.<BR><BR>
\param[in] n Размер входных векторов. \n \n
\param[in] fn Имя файла.<BR><BR>
\param[in] fn Имя файла. \n \n
\return
`RES_OK` Файл сохранен успешно.<BR>
В противном случае \ref ERROR_CODE_GROUP "код ошибки":<BR>
`RES_OK` Файл сохранен успешно. \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки": \n
\note
Данная функция производит округление данных при записи в файл.

66
dspl/dox/ru/math.dox
Wyświetl plik

@ -5,27 +5,27 @@
Функция рассчитывает значения функции для вещественного вектора `x`,
который должен принимать неотрицательные значения.
<BR>
\n
\param[in] x Указатель на вектор переменной \f$ x \f$.<BR>
Размер вектора `[n x 1]`.<BR>
Память должна быть выделена.<BR><BR>
\param[in] x Указатель на вектор переменной \f$ x \f$. \n
Размер вектора `[n x 1]`. \n
Память должна быть выделена. \n \n
\param[in] n Размер входного вектора `x`. <BR><BR>
\param[in] n Размер входного вектора `x`. \n \n
\param[out] y Указатель на вектор значений функции \f$ I_0(x)\f$.<BR>
Размер вектора `[n x 1]`.<BR>
Память должна быть выделена.<BR><BR>
\param[out] y Указатель на вектор значений функции \f$ I_0(x)\f$. \n
Размер вектора `[n x 1]`. \n
Память должна быть выделена. \n \n
\return
`RES_OK` Расчет произведен успешно.<BR>
В противном случае \ref ERROR_CODE_GROUP "код ошибки".<BR>
`RES_OK` Расчет произведен успешно. \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки". \n
\note Для расчета используется аппроксимация приведенная в статье:<BR>
\note Для расчета используется аппроксимация приведенная в статье: \n
<a href="https://www.advanpix.com/2015/11/11/rational-approximations-for-the-modified-bessel-function-of-the-first-kind-i0-computations-double-precision/">
Rational Approximations for the Modified Bessel Function
of the First Kind – I0(x) for Computations with Double Precision<BR>
by PAVEL HOLOBORODKO on NOVEMBER 11, 2015<BR>
of the First Kind – I0(x) for Computations with Double Precision
by PAVEL HOLOBORODKO on NOVEMBER 11, 2015
</a>
@ -56,25 +56,25 @@ www.dsplib.org
\brief Функция \f$ \textrm{sinc}(x,a) = \frac{\sin(ax)}{ax}\f$
Функция рассчитывает значения функции для вещественного вектора `x`.
<BR>
\n
\param[in] x Указатель на вектор переменной \f$ x \f$.<BR>
Размер вектора `[n x 1]`.<BR>
Память должна быть выделена.<BR><BR>
\param[in] x Указатель на вектор переменной \f$ x \f$. \n
Размер вектора `[n x 1]`. \n
Память должна быть выделена. \n \n
\param[in] n Размер входного вектора `x`. <BR><BR>
\param[in] n Размер входного вектора `x`. \n \n
\param[in] a Параметр функции
\f$ \textrm{sinc}(x,a) = \frac{\sin(ax)}{ax}\f$
\param[out] y Указатель на вектор значений функции.<BR>
Размер вектора `[n x 1]`.<BR>
Память должна быть выделена.<BR><BR>
\param[out] y Указатель на вектор значений функции. \n
Размер вектора `[n x 1]`. \n
Память должна быть выделена. \n \n
\return
`RES_OK` Расчет произведен успешно.<BR>
В противном случае \ref ERROR_CODE_GROUP "код ошибки".<BR>
`RES_OK` Расчет произведен успешно. \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки". \n
\author
Бахурин Сергей
@ -92,23 +92,23 @@ www.dsplib.org
Функция рассчитывает значения функции для интегрального синуса
для произвольного вещественного вектора `x`.
<BR>
\n
\param[in] x Указатель на вектор переменной \f$ x \f$.<BR>
Размер вектора `[n x 1]`.<BR>
Память должна быть выделена.<BR><BR>
\param[in] x Указатель на вектор переменной \f$ x \f$. \n
Размер вектора `[n x 1]`. \n
Память должна быть выделена. \n \n
\param[in] n Размер входного вектора `x`. <BR><BR>
\param[in] n Размер входного вектора `x`. \n \n
\param[out] si Указатель на вектор значений функции интегрального синуса.<BR>
Размер вектора `[n x 1]`.<BR>
Память должна быть выделена.<BR><BR>
\param[out] si Указатель на вектор значений функции интегрального синуса. \n
Размер вектора `[n x 1]`. \n
Память должна быть выделена. \n \n
\return
`RES_OK` Расчет произведен успешно.<BR>
`RES_OK` Расчет произведен успешно. \n
В противном случае
\ref ERROR_CODE_GROUP "код ошибки".<BR>
\ref ERROR_CODE_GROUP "код ошибки". \n
Пример использования функции `sine_int`:

8
dspl/dox/ru/matrix.dox
Wyświetl plik

@ -6,13 +6,13 @@
Структура описывает вещественные и комплексные матрицы и векторы.
\param dat Указатель на область памяти, которая
хранит матрицу или вектор <BR><BR>
хранит матрицу или вектор \n \n
\param n Количество строк матрицы. <BR><BR>
\param n Количество строк матрицы. \n \n
\param m Количество столбцов матрицы. <BR><BR>
\param m Количество столбцов матрицы. \n \n
\param type Тип матрицы. <BR><BR>
\param type Тип матрицы. \n \n
Параметр `dat` преставляет собой указатель типа `void*` ввиду того, что матрица

56
dspl/dox/ru/polyval.dox
Wyświetl plik

@ -5,34 +5,34 @@
\brief Расчет вещественного полинома
Функция рассчитывает полином \f$P_N(x)\f$ \f$N-\f$ого порядка для вещественного
аргумента, заданного вектором `x`.<BR>
аргумента, заданного вектором `x`. \n
\f[
P_N(x) = a_0 + a_1 \cdot x + a_2 \cdot x^2 + a_3 \cdot x^3 + ... a_N \cdot x^N.
\f]
Для расчета используется формула Горнера:<BR>
Для расчета используется формула Горнера: \n
\f[
P_N(x) = a_0 + x \cdot (a_1 + x \cdot (a_2 + \cdot ( \ldots x \cdot (a_{N-1} + x\cdot a_N) \ldots )))
\f]
\param[in] a Указатель на вектор вещественных коэффициентов полинома. <BR>
Размер вектора `[ord+1 x 1]`.<BR>
Коэффициент `a[0]` соответствует коэффициенту полинома \f$a_0\f$.<BR><BR>
\param[in] a Указатель на вектор вещественных коэффициентов полинома. \n
Размер вектора `[ord+1 x 1]`. \n
Коэффициент `a[0]` соответствует коэффициенту полинома \f$a_0\f$. \n \n
\param[in] ord Порядок полинома \f$N\f$. <BR><BR>
\param[in] ord Порядок полинома \f$N\f$. \n \n
\param[in] x Указатель на вектор аргумента полинома. <BR>
Размер вектора `[n x 1]`.<BR>
\param[in] x Указатель на вектор аргумента полинома. \n
Размер вектора `[n x 1]`. \n
Значения полинома будут расчитаны для всех
значений аргумента вектора `x`.<BR><BR>
значений аргумента вектора `x`. \n \n
\param[in] n Размер вектора агрумента полинома. <BR><BR>
\param[in] n Размер вектора агрумента полинома. \n \n
\param[out] y Указатель на значения полинома для аргумента `x`. <BR>
Размер вектора `[n x 1]`.<BR>
Память должна быть выделена.<BR><BR>
\param[out] y Указатель на значения полинома для аргумента `x`. \n
Размер вектора `[n x 1]`. \n
Память должна быть выделена. \n \n
\return
`RES_OK` Полином расчитан успешно. <BR>
`RES_OK` Полином расчитан успешно. \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки".
\author
@ -49,36 +49,36 @@
\brief Расчет комплексного полинома
Функция рассчитывает полином \f$P_N(x)\f$ \f$N-\f$ого порядка комплексного аргумента
аргумента, заданного вектором `x`.<BR>
аргумента, заданного вектором `x`. \n
\f[
P_N(x) = a_0 + a_1 \cdot x + a_2 \cdot x^2 + a_3 \cdot x^3 + ... a_N \cdot x^N.
\f]
Для расчета используется формула Горнера:<BR>
Для расчета используется формула Горнера: \n
\f[
P_N(x) = a_0 + x \cdot (a_1 + x \cdot (a_2 + \cdot ( \ldots x \cdot (a_{N-1} + x\cdot a_N) \ldots )))
\f]
\param[in] a Указатель на вектор комплексных коэффициентов полинома. <BR>
Размер вектора `[ord+1 x 1]`.<BR>
Коэффициент `a[0]` соответствует коэффициенту полинома \f$a_0\f$.<BR><BR>
\param[in] a Указатель на вектор комплексных коэффициентов полинома. \n
Размер вектора `[ord+1 x 1]`. \n
Коэффициент `a[0]` соответствует коэффициенту полинома \f$a_0\f$. \n \n
\param[in] ord Порядок полинома \f$N\f$. <BR><BR>
\param[in] ord Порядок полинома \f$N\f$. \n \n
\param[in] x Указатель на вектор аргумента полинома. <BR>
Размер вектора `[n x 1]`.<BR>
\param[in] x Указатель на вектор аргумента полинома. \n
Размер вектора `[n x 1]`. \n
Значения полинома будут расчитаны для всех
значений аргумента вектора `x`.<BR><BR>
значений аргумента вектора `x`. \n \n
\param[in] n Размер вектора агрумента полинома. <BR><BR>
\param[in] n Размер вектора агрумента полинома. \n \n
\param[out] y Указатель вектор значения полинома для аргумента `x`. <BR>
Размер вектора `[n x 1]`.<BR>
Память должна быть выделена.<BR><BR>
\param[out] y Указатель вектор значения полинома для аргумента `x`. \n
Размер вектора `[n x 1]`. \n
Память должна быть выделена. \n \n
\return
`RES_OK` Полином расчитан успешно. <BR>
`RES_OK` Полином расчитан успешно. \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки".
\author

28
dspl/dox/ru/randgen.dox
Wyświetl plik

@ -7,22 +7,22 @@
заданным математическим ожиданием и среднеквадратическим отклонением.
Генерация производится при помощи преобразования Бокса — Мюллера равномерно-распределенной
случайной величины в нормально распределенную.<BR>
случайной величины в нормально распределенную. \n
\param[in,out] x Указатель на вектор нормальной распределенных случайных чисел. <BR>
Размер вектора `[n x 1]`.<BR>
Память должна быть выделена.<BR><BR>
\param[in,out] x Указатель на вектор нормальной распределенных случайных чисел. \n
Размер вектора `[n x 1]`. \n
Память должна быть выделена. \n \n
\param[in] n Размер вектора случайных чисел.<BR><BR>
\param[in] n Размер вектора случайных чисел. \n \n
\param[in] mu Математическое ожидание.<BR><BR>
\param[in] mu Математическое ожидание. \n \n
\param[in] sigma Среднеквадратическое отклонение (СКО).<BR><BR>
\param[in] sigma Среднеквадратическое отклонение (СКО). \n \n
\return
`RES_OK` Вектор случайных чисел сгенерирован успешно.<BR>
`RES_OK` Вектор случайных чисел сгенерирован успешно. \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки".
\author
@ -40,17 +40,17 @@
\fn int randu(double* x, int n);
\brief Генерация вектора равномерно-распределенных в интервале от 0 до 1 псевдослучайных чисел.
Генерация производится при помощи рекурсивного алгоритма L'Ecluyer. Период датчика порядка \f$10^{56}\f$.<BR>
Генерация производится при помощи рекурсивного алгоритма L'Ecluyer. Период датчика порядка \f$10^{56}\f$. \n
\param[in,out] x Указатель на вектор случайных чисел. <BR>
Размер вектора `[n x 1]`.<BR>
Память должна быть выделена.<BR><BR>
\param[in,out] x Указатель на вектор случайных чисел. \n
Размер вектора `[n x 1]`. \n
Память должна быть выделена. \n \n
\param[in] n Размер вектора случайных чисел.<BR><BR>
\param[in] n Размер вектора случайных чисел. \n \n
\return
`RES_OK` Вектор случайных чисел сгенерирован успешно.<BR>
`RES_OK` Вектор случайных чисел сгенерирован успешно. \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки".
\author

64
dspl/dox/ru/resampling.dox
Wyświetl plik

@ -6,38 +6,38 @@
\brief Передискретизация вещественного сигнала на основе полиномиальной Лагранжевой интерполяции.
Данная функция осуществляет передискретизацию входного сигнала `s` в `p/q` раз со смещением дробной
задержки. <BR>
задержки. \n
Для передискретизации используется
<a href = "http://ru.dsplib.org/content/resampling_lagrange/resampling_lagrange.html">
полиномиальная Лагранжева интерполяция
</a>
(структура Фарроу для полиномиальной интерполяции).<BR>
(структура Фарроу для полиномиальной интерполяции). \n
\param [in] s Указатель на вектор входного вещественного сигнала.<BR>
Размер вектора `[n x 1]`.<BR><BR>
\param [in] s Указатель на вектор входного вещественного сигнала. \n
Размер вектора `[n x 1]`. \n \n
\param [in] n Размер вектора входного сигнала.<BR><BR>
\param [in] n Размер вектора входного сигнала. \n \n
\param [in] p Числитель коэффициента передискретизации.<BR><BR>
\param [in] p Числитель коэффициента передискретизации. \n \n
\param [in] q Знаменатель коэффициента передискретизации.<BR><BR>
\param [in] q Знаменатель коэффициента передискретизации. \n \n
\param [in] frd Значение смещения дробной задержки в пределах одного отсчета.<BR>
Значение должно быть от 0 до 1.<BR><BR>
\param [in] frd Значение смещения дробной задержки в пределах одного отсчета. \n
Значение должно быть от 0 до 1. \n \n
\param [out] y Указатель на адрес результата передискретизации.<BR>
\param [out] y Указатель на адрес результата передискретизации. \n
По данному адресу будет произведено динамическое выделение памяти
для результата передискретизации.<BR>
Будет выделено памяти под `n*q/p` отсчетов выходного сигнала.<BR>
Данный указатель не может быть `NULL`.<BR><BR>
для результата передискретизации. \n
Будет выделено памяти под `n*q/p` отсчетов выходного сигнала. \n
Данный указатель не может быть `NULL`. \n \n
\param [in] ny Указатель на переменную, в которую будет записан
размер вектора `(*y)` после выделения памяти.<BR><BR>
размер вектора `(*y)` после выделения памяти. \n \n
\return
`RES_OK` если передискретизация успешно. <BR>
В противном случае \ref ERROR_CODE_GROUP "код ошибки". <BR>
`RES_OK` если передискретизация успешно. \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки". \n
\author
Бахурин Сергей.
@ -58,38 +58,38 @@
\brief Передискретизация вещественного сигнала на основе сплайн интерполяции.
Данная функция осуществляет передискретизацию входного сигнала `s` в `p/q` раз со смещением дробной
задержки. <BR>
задержки. \n
Для передискретизации используются
<a href = "http://ru.dsplib.org/content/resampling_spline/resampling_spline.html">
кубические сплайны Эрмита
</a>
(структура Фарроу для для сплайн-интерполяции).<BR>
(структура Фарроу для для сплайн-интерполяции). \n
\param [in] s Указатель на вектор входного вещественного сигнала.<BR>
Размер вектора `[n x 1]`.<BR><BR>
\param [in] s Указатель на вектор входного вещественного сигнала. \n
Размер вектора `[n x 1]`. \n \n
\param [in] n Размер вектора входного сигнала.<BR><BR>
\param [in] n Размер вектора входного сигнала. \n \n
\param [in] p Числитель коэффициента передискретизации.<BR><BR>
\param [in] p Числитель коэффициента передискретизации. \n \n
\param [in] q Знаменатель коэффициента передискретизации.<BR><BR>
\param [in] q Знаменатель коэффициента передискретизации. \n \n
\param [in] frd Значение смещения дробной задержки в пределах одного отсчета.<BR>
Значение должно быть от 0 до 1.<BR><BR>
\param [in] frd Значение смещения дробной задержки в пределах одного отсчета. \n
Значение должно быть от 0 до 1. \n \n
\param [out] y Указатель на адрес результата передискретизации.<BR>
\param [out] y Указатель на адрес результата передискретизации. \n
По данному адресу будет произведено динамическое выделение памяти
для результата передискретизации.<BR>
Будет выделено памяти под `n*q/p` отсчетов выходного сигнала.<BR>
Данный указатель не может быть `NULL`.<BR><BR>
для результата передискретизации. \n
Будет выделено памяти под `n*q/p` отсчетов выходного сигнала. \n
Данный указатель не может быть `NULL`. \n \n
\param [in] ny Указатель на переменную, в которую будет записан
размер вектора `(*y)` после выделения памяти.<BR><BR>
размер вектора `(*y)` после выделения памяти. \n \n
\return
`RES_OK` если передискретизация успешно. <BR>
В противном случае \ref ERROR_CODE_GROUP "код ошибки". <BR>
`RES_OK` если передискретизация успешно. \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки". \n
\author
Бахурин Сергей.

34
dspl/dox/ru/win.dox
Wyświetl plik

@ -4,27 +4,27 @@
\brief Расчет функции оконного взвешивания
Функция рассчитывает периодическую или симметричную оконную функцию
в соответствии с параметром `win_type`.<BR>
в соответствии с параметром `win_type`. \n
Периодическая оконная функция используется для спектрального анализа,
а симметричная оконная функция может быть использована для синтеза
КИХ-фильтров.<BR>
КИХ-фильтров. \n
\param [in,out] w Указатель на вектор оконной функции.<BR>
Размер вектора `[n x 1]`.<BR>
Память должна быть выделена.<BR>
\param [in,out] w Указатель на вектор оконной функции. \n
Размер вектора `[n x 1]`. \n
Память должна быть выделена. \n
Рассчитанная оконная функция будет
помещена по данному адресу.<BR><BR>
помещена по данному адресу. \n \n
\param [in] n Размер вектора `w` оконной функции.<BR><BR>
\param [in] n Размер вектора `w` оконной функции. \n \n
\param [in] win_type Комбинация флагов для задания типа оконной
функции.<BR>
функции. \n
Для задания типа окна используется
комбинация битовых масок
`DSPL_WIN_MASK | DSPL_WIN_SYM_MASK`.<BR>
`DSPL_WIN_MASK | DSPL_WIN_SYM_MASK`. \n
Маска `DSPL_WIN_MASK` задает тип оконной функции.
Может принимать следующие значения:<BR>
Может принимать следующие значения: \n
Значение `DSPL_WIN_MASK` | Описание
-----------------------------|----------------------------
`DSPL_WIN_BARTLETT` |Непараметрическое окно Бартлетта
@ -42,20 +42,20 @@
`DSPL_WIN_LANCZOS` |Непараметрическое окно Ланкзоса
`DSPL_WIN_NUTTALL` |Непараметрическое окно Натталла
`DSPL_WIN_RECT` |Непараметрическое прямоугольное окно
<BR><BR>Маска `DSPL_WIN_SYM_MASK` задает симметричное
или периодическое окно:<BR><BR>
\n \nМаска `DSPL_WIN_SYM_MASK` задает симметричное
или периодическое окно: \n \n
Значение `DSPL_WIN_SYM_MASK` | Описание
--------------------------------|----------------------------
`DSPL_WIN_SYMMETRIC` |Симметричное окно (по умолчанию)
`DSPL_WIN_PERIODIC` |Периодическое окно
<BR><BR>
\n \n
\param [in] param Параметр окна.<BR>
\param [in] param Параметр окна. \n
Данный параметр применяется только
для параметрических оконных функций. <BR>
Для непараметрических окон игнорируется.<BR><BR>
для параметрических оконных функций. \n
Для непараметрических окон игнорируется. \n \n
\return `RES_OK` если оконная функция рассчитана успешно.<BR>
\return `RES_OK` если оконная функция рассчитана успешно. \n
В противном случае \ref ERROR_CODE_GROUP "код ошибки".
\author Бахурин Сергей. www.dsplib.org

172
dspl/src/array.c
Wyświetl plik

@ -29,33 +29,33 @@
\fn int concat(void* a, size_t na, void* b, size_t nb, void* c)
\brief Concatenate arrays `a` and `b`
Let's arrays `a` and `b` are vectors:<BR>
`a = [a(0), a(1), ... a(na-1)]`, <BR>
`b = [b(0), b(1), ... b(nb-1)]`, <BR>
concatenation of these arrays will be array `c` size `na+nb`:<BR>
Let's arrays `a` and `b` are vectors: \n
`a = [a(0), a(1), ... a(na-1)]`, \n
`b = [b(0), b(1), ... b(nb-1)]`, \n
concatenation of these arrays will be array `c` size `na+nb`: \n
`c = [a(0), a(1), ... a(na-1), b(0), b(1), ... b(nb-1)]`.
\param[in] a Pointer to the first array `a`.<BR>
Array `a` size is `na` bytes.<BR><BR>
\param[in] a Pointer to the first array `a`. \n
Array `a` size is `na` bytes. \n \n
\param[in] na Array `a` size (bytes).<BR><BR>
\param[in] na Array `a` size (bytes). \n \n
\param[in] b Pointer to the second array `b`.<BR>
Array `b` size is `nb` bytes.<BR><BR>
\param[in] b Pointer to the second array `b`. \n
Array `b` size is `nb` bytes. \n \n
\param[in] nb Array `a` size (bytes).<BR><BR>
\param[in] nb Array `a` size (bytes). \n \n
\param[out] c Pointer to the concatenation result array `c`.<BR>
Array `c` size is `na + nb` bytes.<BR>
Memory must be allocated.<BR><BR>
\param[out] c Pointer to the concatenation result array `c`. \n
Array `c` size is `na + nb` bytes. \n
Memory must be allocated. \n \n
\return
`RES_OK` if function returns successfully.<BR>
`RES_OK` if function returns successfully. \n
Else \ref ERROR_CODE_GROUP "code error".
Function uses pointer type `void*` and can be useful for an arrays
concatenation with different types.<BR>
concatenation with different types. \n
For example two `double` arrays concatenation:
\code{.cpp}
double a[3] = {1.0, 2.0, 3.0};
@ -94,29 +94,29 @@ int DSPL_API concat(void* a, size_t na, void* b, size_t nb, void* c)
\fn int decimate(double* x, int n, int d, double* y, int* cnt)
\brief Real vector decimation
Function `d` times decimates real vector `x`.<BR>
Function `d` times decimates real vector `x`. \n
Output vector `y` keeps values corresponds to:
`y(k) = x(k*d), k = 0...n/d-1`<BR>
`y(k) = x(k*d), k = 0...n/d-1` \n
\param[in] x Pointer to the input real vector `x`.<BR>
Vector `x` size is `[n x 1]`.<BR><BR>
\param[in] x Pointer to the input real vector `x`. \n
Vector `x` size is `[n x 1]`. \n \n
\param[in] n Size of input vector `x`.<BR><BR>
\param[in] n Size of input vector `x`. \n \n
\param[in] d Decimation coefficient.<BR>
\param[in] d Decimation coefficient. \n
Each d-th vector will be copy from vector `x` to the
output vector `y`.<BR><BR>
output vector `y`. \n \n
\param[out] y Pointer to the output decimated vector `y`.<BR>
\param[out] y Pointer to the output decimated vector `y`. \n
Output vector size is `[n/d x 1]` will be copy
to the address `cnt`.<BR>
to the address `cnt`. \n
\param[out] cnt Address which will keep decimated vector `y` size.<BR>
\param[out] cnt Address which will keep decimated vector `y` size. \n
Pointer can be `NULL`, vector `y` will not return
in this case.<BR><BR>
in this case. \n \n
\return
`RES_OK` if function calculated successfully.<BR>
`RES_OK` if function calculated successfully. \n
Else \ref ERROR_CODE_GROUP "code error".
Two-times decimation example:
@ -167,30 +167,30 @@ int DSPL_API decimate(double* x, int n, int d, double* y, int* cnt)
\fn int decimate_cmplx(complex_t* x, int n, int d, complex_t* y, int* cnt)
\brief Complex vector decimation
Function `d` times decimates a complex vector `x`.<BR>
Function `d` times decimates a complex vector `x`. \n
Output vector `y` keeps values corresponds to:
`y(k) = x(k*d), k = 0...n/d-1`<BR>
`y(k) = x(k*d), k = 0...n/d-1` \n
\param[in] x Pointer to the input complex vector `x`.<BR>
Vector `x` size is `[n x 1]`.<BR><BR>
\param[in] x Pointer to the input complex vector `x`. \n
Vector `x` size is `[n x 1]`. \n \n
\param[in] n Size of input vector `x`.<BR><BR>
\param[in] n Size of input vector `x`. \n \n
\param[in] d Decimation coefficient.<BR>
\param[in] d Decimation coefficient. \n
Each d-th vector will be copy from vector `x` to the
output vector `y`.<BR><BR>
output vector `y`. \n \n
\param[out] y Pointer to the output decimated vector `y`.<BR>
\param[out] y Pointer to the output decimated vector `y`. \n
Output vector size is `[n/d x 1]` will be copy
to the address `cnt`.<BR>
Memory must be allocated.<BR><BR>
to the address `cnt`. \n
Memory must be allocated. \n \n
\param[out] cnt Address which will keep decimated vector `y` size.<BR>
\param[out] cnt Address which will keep decimated vector `y` size. \n
Pointer can be `NULL`, vector `y` will not return
in this case.<BR><BR>
in this case. \n \n
\return
`RES_OK` if function calculated successfully.<BR>
`RES_OK` if function calculated successfully. \n
Else \ref ERROR_CODE_GROUP "code error".
Two-times complex vector decimation example:
@ -245,21 +245,21 @@ int DSPL_API decimate_cmplx(complex_t* x, int n, int d, complex_t* y, int* cnt)
Function searches maximum absolute value in the real vector `a`.
This value writes to the address `m` and index keeps to te address `ind`.
\param[in] a Pointer to the real vector `a`.<BR>
Vector size is `[n x 1]`.<BR><BR>
\param[in] a Pointer to the real vector `a`. \n
Vector size is `[n x 1]`. \n \n
\param[in] n Size of the input vector `a`.<BR><BR>
\param[in] n Size of the input vector `a`. \n \n
\param[out] m Pointer to the variable which keeps vector `a`
maximum absolute value.<BR>
maximum absolute value. \n
Pointer can be `NULL`, maximum value will not return
in this case.<BR><BR>
in this case. \n \n
\param[out] ind Pointer to the variable which keeps index of a
maximum absolute value inside vector `a`.<BR>
maximum absolute value inside vector `a`. \n
Pointer can be `NULL`, index will not return
in this case.<BR><BR>
in this case. \n \n
\return
`RES_OK` if function calculates successfully,
else \ref ERROR_CODE_GROUP "code error".
@ -310,8 +310,8 @@ int DSPL_API find_max_abs(double* a, int n, double* m, int* ind)
\brief Flip real vector `x` in place
Function flips real vector `x` length `n` in the memory
<BR>
For example real vector `x` length 6:<BR>
\n
For example real vector `x` length 6: \n
\verbatim
x = [0, 1, 2, 3, 4, 5]
\endverbatim
@ -320,14 +320,14 @@ After flipping it will be as follow:
x = [5, 4, 3, 2, 1, 0]
\endverbatim
\param[in, out] x Pointer to the real vector `x`.<BR>
Vector size is `[n x 1]`.<BR>
Flipped vector will be on the same address.<BR>
\param[in, out] x Pointer to the real vector `x`. \n
Vector size is `[n x 1]`. \n
Flipped vector will be on the same address. \n
\param[in] n Length of the vector `x`.<BR><BR>
\param[in] n Length of the vector `x`. \n \n
\return
`RES_OK` if function returns successfully.<BR>
`RES_OK` if function returns successfully. \n
Else \ref ERROR_CODE_GROUP "error code".
Example:
@ -341,7 +341,7 @@ printf("\n");
for(i = 0; i < 5; i++)
printf("%6.1f ", x[i]);
\endcode
<BR>
\n
Program result:
\verbatim
0.0 1.0 2.0 3.0 4.0
@ -366,6 +366,7 @@ int DSPL_API flipip(double* x, int n)
x[n-1-k] = tmp;
}
return RES_OK;
}
@ -376,8 +377,8 @@ int DSPL_API flipip(double* x, int n)
\brief Flip complex vector `x` in place
Function flips complex vector `x` length `n` in the memory
<BR>
For example complex vector `x` length 6:<BR>
\n
For example complex vector `x` length 6: \n
\verbatim
x = [0+0j, 1+1j, 2+2j, 3+3j, 4+4j, 5+5j]
\endverbatim
@ -386,14 +387,14 @@ After flipping it will be as follow:
x = [5+5j, 4+4j, 3+3j, 2+2j, 1+1j, 0+0j]
\endverbatim
\param[in, out] x Pointer to the complex vector `x`.<BR>
Vector size is `[n x 1]`.<BR>
Flipped vector will be on the same address.<BR>
\param[in, out] x Pointer to the complex vector `x`. \n
Vector size is `[n x 1]`. \n
Flipped vector will be on the same address. \n
\param[in] n Length of the vector `x`.<BR><BR>
\param[in] n Length of the vector `x`. \n \n
\return
`RES_OK` if function returns successfully.<BR>
`RES_OK` if function returns successfully. \n
Else \ref ERROR_CODE_GROUP "error code".
Example:
@ -406,7 +407,7 @@ printf("\n");
for(i = 0; i < 5; i++)
printf("%6.1f%+.1fj ", RE(y[i]), IM(y[i]));
\endcode
<BR>
\n
Program result:
\verbatim
0.0+0.0j 1.0+1.0j 2.0+2.0j 3.0+3.0j 4.0+4.0j
@ -439,7 +440,6 @@ int DSPL_API flipip_cmplx(complex_t* x, int n)
/******************************************************************************
\ingroup SPEC_MATH_COMMON_GROUP
\fn int verif(double* x, double* y, size_t n, double eps, double* err)
@ -456,30 +456,30 @@ or
e = \max(|x(k) - y(k)| ), ~\qquad if \quad~|x(k)| = 0,
\f]
Return `DSPL_VERIF_SUCCESS` if maximum relative error \f$ e\f$ less than `eps`.
Else returns `DSPL_VERIF_FAILED`.<BR>
Else returns `DSPL_VERIF_FAILED`. \n
This function can be used for algorithms verification if vector `x` is user
algorithm result and vector `y` -- reference vector.
\param[in] x Pointer to the first vector `x`.<BR>
Vector size is `[n x 1]`.<BR><BR>
\param[in] x Pointer to the first vector `x`. \n
Vector size is `[n x 1]`. \n \n
\param[in] y Pointer to the second vector `y`.<BR>
Vector size is `[n x 1]`.<BR><BR>
\param[in] y Pointer to the second vector `y`. \n
Vector size is `[n x 1]`. \n \n
\param[in] n Size of vectors `x` and `y`.<BR><BR>
\param[in] n Size of vectors `x` and `y`. \n \n
\param[in] eps Relative error threshold.<BR>
\param[in] eps Relative error threshold. \n
If error less than `eps`, then function returns
`DSPL_VERIF_SUCCESS`, else `DSPL_VERIF_FAILED`. <BR><BR>
`DSPL_VERIF_SUCCESS`, else `DSPL_VERIF_FAILED`. \n \n
\param[in, out] err Pointer to the variable which keep
maximum relative error.<BR>
maximum relative error. \n
Pointer can be `NULL`, maximum error will not be returned
in this case.<BR><BR>
in this case. \n \n
\return
`DSPL_VERIF_SUCCESS` if maximum relative error less than `eps`.<BR>
`DSPL_VERIF_SUCCESS` if maximum relative error less than `eps`. \n
Otherwise `DSPL_VERIF_FAILED`.
\author Sergey Bakhurin www.dsplib.org
@ -538,30 +538,30 @@ or
e = \max(|x(k) - y(k)| ), ~\qquad if \quad~|x(k)| = 0,
\f]
Return `DSPL_VERIF_SUCCESS` if maximum relative error \f$ e\f$ less than `eps`.
Else returns `DSPL_VERIF_FAILED`.<BR>
Else returns `DSPL_VERIF_FAILED`. \n
This function can be used for algorithms verification if vector `x` is user
algorithm result and vector `y` -- reference vector.
\param[in] x Pointer to the first vector `x`.<BR>
Vector size is `[n x 1]`.<BR><BR>
\param[in] x Pointer to the first vector `x`. \n
Vector size is `[n x 1]`. \n \n
\param[in] y Pointer to the second vector `y`.<BR>
Vector size is `[n x 1]`.<BR><BR>
\param[in] y Pointer to the second vector `y`. \n
Vector size is `[n x 1]`. \n \n
\param[in] n Size of vectors `x` and `y`.<BR><BR>
\param[in] n Size of vectors `x` and `y`. \n \n
\param[in] eps Relative error threshold.<BR>
\param[in] eps Relative error threshold. \n
If error less than `eps`, then function returns
`DSPL_VERIF_SUCCESS`, else `DSPL_VERIF_FAILED`. <BR><BR>
`DSPL_VERIF_SUCCESS`, else `DSPL_VERIF_FAILED`. \n \n
\param[in, out] err Pointer to the variable which keep
maximum relative error.<BR>
maximum relative error. \n
Pointer can be `NULL`, maximum error will not be returned
in this case.<BR><BR>
in this case. \n \n
\return
`DSPL_VERIF_SUCCESS` if maximum relative error less than `eps`.<BR>
`DSPL_VERIF_SUCCESS` if maximum relative error less than `eps`. \n
Otherwise `DSPL_VERIF_FAILED`.
\author Sergey Bakhurin www.dsplib.org

44
dspl/src/cheby.c
Wyświetl plik

@ -36,28 +36,28 @@ C_ord(x) = 2 x C_{ord-1}(x) - C_{ord-2}(x),
\f]
where \f$ C_0(x) = 1 \f$, \f$ C_1(x) = x\f$
\param[in] x Pointer to the real argument vector `x`.<BR>
Vector size is `[n x 1]`.<BR><BR>
\param[in] x Pointer to the real argument vector `x`. \n
Vector size is `[n x 1]`. \n \n
\param[in] n Size of vectors `x` and `y`.<BR><BR>
\param[in] n Size of vectors `x` and `y`. \n \n
\param[in] ord Chebyshev polynomial order.<BR><BR>
\param[in] ord Chebyshev polynomial order. \n \n
\param[out] y Pointer to the Chebyshev polynomial values,
corresponds to the argument `x`.<BR>
Vector size is `[n x 1]`.<BR>
Memory must be allocated.<BR><BR>
corresponds to the argument `x`. \n
Vector size is `[n x 1]`. \n
Memory must be allocated. \n \n
\return
`RES_OK` if Chebyshev polynomial is calculated successfully.<BR>
Else \ref ERROR_CODE_GROUP "code error".<BR>
`RES_OK` if Chebyshev polynomial is calculated successfully. \n
Else \ref ERROR_CODE_GROUP "code error". \n
Example:
\include cheby_poly1_test.c
<BR><BR>
Text files will be created in `dat` directory:<BR>
\n \n
Text files will be created in `dat` directory: \n
<pre>
cheby_poly1_ord1.txt
@ -132,28 +132,28 @@ U_ord(x) = 2 x U_{ord-1}(x) - U_{ord-2}(x),
\f]
where \f$ U_0(x) = 1 \f$, \f$ U_1(x) = 2x\f$
\param[in] x Pointer to the real argument vector `x`.<BR>
Vector size is `[n x 1]`.<BR><BR>
\param[in] x Pointer to the real argument vector `x`. \n
Vector size is `[n x 1]`. \n \n
\param[in] n Size of vectors `x` and `y`.<BR><BR>
\param[in] n Size of vectors `x` and `y`. \n \n
\param[in] ord Chebyshev polynomial order.<BR><BR>
\param[in] ord Chebyshev polynomial order. \n \n
\param[out] y Pointer to the Chebyshev polynomial values,
corresponds to the argument `x`.<BR>
Vector size is `[n x 1]`.<BR>
Memory must be allocated.<BR><BR>
corresponds to the argument `x`. \n
Vector size is `[n x 1]`. \n
Memory must be allocated. \n \n
\return
`RES_OK` if Chebyshev polynomial is calculated successfully.<BR>
Else \ref ERROR_CODE_GROUP "code error".<BR>
`RES_OK` if Chebyshev polynomial is calculated successfully. \n
Else \ref ERROR_CODE_GROUP "code error". \n
Example:
\include cheby_poly2_test.c
<BR><BR>
Text files will be created in `dat` directory:<BR>
\n \n
Text files will be created in `dat` directory: \n
<pre>
cheby_poly2_ord1.txt

186
dspl/src/complex.c
Wyświetl plik

@ -30,7 +30,7 @@
\fn int acos_cmplx(complex_t* x, int n, complex_t *y)
\brief The inverse of the cosine function the complex vector argument `x`
Function calculates the inverse of the cosine function as:<BR>
Function calculates the inverse of the cosine function as: \n
\f[
\textrm{Arccos}(x) = \frac{\pi}{2} - \textrm{Arcsin}(x) =
@ -38,22 +38,22 @@ Function calculates the inverse of the cosine function as:<BR>
\f]
\param[in] x Pointer to the argument vector `x`.<BR>
Vector size is `[n x 1]`. <BR><BR>
\param[in] x Pointer to the argument vector `x`. \n
Vector size is `[n x 1]`. \n \n
\param[in] n Input vector `x` and the inverse cosine vector `y` size.<BR><BR>
\param[in] n Input vector `x` and the inverse cosine vector `y` size. \n \n
\param[out] y Pointer to the output complex vector `y`,
corresponds to the input vector `x`.<BR>
Vector size is `[n x 1]`. <BR>
Memory must be allocated. <BR><BR>
corresponds to the input vector `x`. \n
Vector size is `[n x 1]`. \n
Memory must be allocated. \n \n
\return
`RES_OK` if function calculated successfully. <BR>
Else \ref ERROR_CODE_GROUP "code error".<BR>
`RES_OK` if function calculated successfully. \n
Else \ref ERROR_CODE_GROUP "code error". \n
Example:<BR>
Example: \n
\code{.cpp}
complex_t x[3] = {{1.0, 2.0}, {3.0, 4.0}, {5.0, 6.0}};
complex_t y[3];
@ -65,9 +65,9 @@ Example:<BR>
printf("acos_cmplx(%.1f%+.1fj) = %.3f%+.3fj\n",
RE(x[k]), IM(x[k]), RE(y[k]), IM(y[k]));
\endcode
<BR>
\n
Output is:<BR>
Output is: \n
\verbatim
acos_cmplx(1.0+2.0j) = 1.144-1.529j
acos_cmplx(3.0+4.0j) = 0.937-2.306j
@ -102,29 +102,29 @@ int DSPL_API acos_cmplx(complex_t* x, int n, complex_t *y)
\fn int asin_cmplx(complex_t* x, int n, complex_t *y)
\brief The inverse of the sine function the complex vector argument `x`
Function calculates the inverse of the sine function as:<BR>
Function calculates the inverse of the sine function as: \n
\f[
\textrm{Arcsin}(x) = j \textrm{Ln}\left( j x + \sqrt{1 - x^2} \right)
\f]
\param[in] x Pointer to the argument vector `x`.<BR>
Vector size is `[n x 1]`. <BR><BR>
\param[in] x Pointer to the argument vector `x`. \n
Vector size is `[n x 1]`. \n \n
\param[in] n Input vector `x` and the inverse sine vector `y` size.<BR><BR>
\param[in] n Input vector `x` and the inverse sine vector `y` size. \n \n
\param[out] y Pointer to the output complex vector `y`,
corresponds to the input vector `x`.<BR>
Vector size is `[n x 1]`. <BR>
Memory must be allocated. <BR><BR>
corresponds to the input vector `x`. \n
Vector size is `[n x 1]`. \n
Memory must be allocated. \n \n
\return
`RES_OK` if function calculated successfully. <BR>
Else \ref ERROR_CODE_GROUP "code error".<BR>
`RES_OK` if function calculated successfully. \n
Else \ref ERROR_CODE_GROUP "code error". \n
Example:<BR>
Example: \n
\code{.cpp}
complex_t x[3] = {{1.0, 2.0}, {3.0, 4.0}, {5.0, 6.0}};
complex_t y[3];
@ -136,9 +136,9 @@ Example:<BR>
RE(x[k]), IM(x[k]), RE(y[k]), IM(y[k]));
\endcode
<BR>
\n
Output is:<BR>
Output is: \n
\verbatim
asin_cmplx(1.0+2.0j) = 0.427+1.529j
asin_cmplx(3.0+4.0j) = 0.634+2.306j
@ -180,28 +180,28 @@ int DSPL_API asin_cmplx(complex_t* x, int n, complex_t *y)
\brief Separate complex vector to the real and image vectors
Function fills `re` and `im` vectors corresponds to real and image
parts of the input complex array `x`. <BR>
parts of the input complex array `x`. \n
\param[in] x Pointer to the real complex vector.<BR>
Vector size is `[n x 1]`. <BR><BR>
\param[in] x Pointer to the real complex vector. \n
Vector size is `[n x 1]`. \n \n
\param[in] n Size of the input complex vector `x` and real and image
vectors `re` and `im`.<BR><BR>
vectors `re` and `im`. \n \n
\param[out] re Pointer to the real part vector.<BR>
Vector size is `[n x 1]`. <BR>
Memory must be allocated. <BR><BR>
\param[out] re Pointer to the real part vector. \n
Vector size is `[n x 1]`. \n
Memory must be allocated. \n \n
\param[out] im Pointer to the image part vector.<BR>
Vector size is `[n x 1]`. <BR>
Memory must be allocated. <BR><BR>
\param[out] im Pointer to the image part vector. \n
Vector size is `[n x 1]`. \n
Memory must be allocated. \n \n
\return
`RES_OK` if function converts complex vector successfully. <BR>
Else \ref ERROR_CODE_GROUP "code error".<BR>
`RES_OK` if function converts complex vector successfully. \n
Else \ref ERROR_CODE_GROUP "code error". \n
Example:<BR>
Example: \n
\code{.cpp}
complex_t x[3] = {{1.0, 2.0}, {3.0, 4.0}, {5.0, 6.0}};
double re[3], im[3];
@ -249,29 +249,29 @@ int DSPL_API cmplx2re(complex_t* x, int n, double* re, double* im)
\fn int cos_cmplx(complex_t* x, int n, complex_t *y)
\brief The cosine function the complex vector argument `x`
Function calculates the cosine function as:<BR>
Function calculates the cosine function as: \n
\f[
\textrm{cos}(x) = \frac{\exp(jx) + \exp(-jx)}{2}
\f]
\param[in] x Pointer to the argument vector `x`.<BR>
Vector size is `[n x 1]`. <BR><BR>
\param[in] x Pointer to the argument vector `x`. \n
Vector size is `[n x 1]`. \n \n
\param[in] n Input vector `x` and the cosine vector `y` size.<BR><BR>
\param[in] n Input vector `x` and the cosine vector `y` size. \n \n
\param[out] y Pointer to the output complex vector `y`,
corresponds to the input vector `x`.<BR>
Vector size is `[n x 1]`. <BR>
Memory must be allocated. <BR><BR>
corresponds to the input vector `x`. \n
Vector size is `[n x 1]`. \n
Memory must be allocated. \n \n
\return
`RES_OK` if function calculated successfully. <BR>
Else \ref ERROR_CODE_GROUP "code error".<BR>
`RES_OK` if function calculated successfully. \n
Else \ref ERROR_CODE_GROUP "code error". \n
Example:<BR>
Example: \n
\code{.cpp}
complex_t x[3] = {{1.0, 2.0}, {3.0, 4.0}, {5.0, 6.0}};
complex_t y[3];
@ -284,9 +284,9 @@ Example:<BR>
RE(x[k]), IM(x[k]), RE(y[k]), IM(y[k]));
\endcode
<BR>
\n
Output is:<BR>
Output is: \n
\verbatim
cos_cmplx(1.0+2.0j) = 2.033 -3.052j
cos_cmplx(3.0+4.0j) = -27.035 -3.851j
@ -325,29 +325,29 @@ int DSPL_API cos_cmplx(complex_t* x, int n, complex_t *y)
\fn int log_cmplx(complex_t* x, int n, complex_t *y)
\brief The logarithm function the complex vector argument `x`
Function calculates the logarithm function as:<BR>
Function calculates the logarithm function as: \n
\f[
\textrm{Ln}(x) = j \varphi + \ln(|x|),
\f]
here \f$\varphi\f$ - the complex number phase.
\param[in] x Pointer to the argument vector `x`.<BR>
Vector size is `[n x 1]`. <BR><BR>
\param[in] x Pointer to the argument vector `x`. \n
Vector size is `[n x 1]`. \n \n
\param[in] n Input vector `x` and the logarithm vector `y` size.<BR><BR>
\param[in] n Input vector `x` and the logarithm vector `y` size. \n \n
\param[out] y Pointer to the output complex vector `y`,
corresponds to the input vector `x`.<BR>
Vector size is `[n x 1]`. <BR>
Memory must be allocated. <BR><BR>
corresponds to the input vector `x`. \n
Vector size is `[n x 1]`. \n
Memory must be allocated. \n \n
\return
`RES_OK` if function calculated successfully. <BR>
Else \ref ERROR_CODE_GROUP "code error".<BR>
`RES_OK` if function calculated successfully. \n
Else \ref ERROR_CODE_GROUP "code error". \n
Example:<BR>
Example: \n
\code{.cpp}
complex_t x[3] = {{1.0, 2.0}, {3.0, 4.0}, {5.0, 6.0}};
complex_t y[3];
@ -359,9 +359,9 @@ Example:<BR>
printf("log_cmplx(%.1f%+.1fj) = %.3f%+.3fj\n",
RE(x[k]), IM(x[k]), RE(y[k]), IM(y[k]));
\endcode
<BR>
\n
Output is:<BR>
Output is: \n
\verbatim
log_cmplx(1.0+2.0j) = 0.805+1.107j
log_cmplx(3.0+4.0j) = 1.609+0.927j
@ -399,24 +399,24 @@ int DSPL_API log_cmplx(complex_t* x, int n, complex_t *y)
\brief Convert real array to the complex array.
Function copies the vector `x` to the real part of vector `y`.
Image part of the vector `y` sets as zero.<BR>
So complex vector contains data:<BR>
Image part of the vector `y` sets as zero. \n
So complex vector contains data: \n
`y[i] = x[i] + j0, here i = 0,1,2 ... n-1`
\param[in] x Pointer to the real vector `x`.<BR>
Vector size is `[n x 1]`. <BR><BR>
\param[in] x Pointer to the real vector `x`. \n
Vector size is `[n x 1]`. \n \n
\param[in] n Size of the real vector `x` and complex vector `y`.<BR><BR>
\param[in] n Size of the real vector `x` and complex vector `y`. \n \n
\param[out] y Pointer to the complex vector `y`.<BR>
Vector size is `[n x 1]`. <BR>
Memory must be allocated. <BR><BR>
\param[out] y Pointer to the complex vector `y`. \n
Vector size is `[n x 1]`. \n
Memory must be allocated. \n \n
\return
`RES_OK` if function returns successfully. <BR>
Else \ref ERROR_CODE_GROUP "code error":<BR>
`RES_OK` if function returns successfully. \n
Else \ref ERROR_CODE_GROUP "code error": \n
@ -463,29 +463,29 @@ int DSPL_API re2cmplx(double* x, int n, complex_t* y)
\fn int sin_cmplx(complex_t* x, int n, complex_t *y)
\brief The sine function the complex vector argument `x`
Function calculates the sine function as:<BR>
Function calculates the sine function as: \n
\f[
\textrm{cos}(x) = \frac{\exp(jx) - \exp(-jx)}{2j}
\f]
\param[in] x Pointer to the argument vector `x`.<BR>
Vector size is `[n x 1]`. <BR><BR>
\param[in] x Pointer to the argument vector `x`. \n
Vector size is `[n x 1]`. \n \n
\param[in] n Input vector `x` and the sine vector `y` size.<BR><BR>
\param[in] n Input vector `x` and the sine vector `y` size. \n \n
\param[out] y Pointer to the output complex vector `y`,
corresponds to the input vector `x`.<BR>
Vector size is `[n x 1]`. <BR>
Memory must be allocated. <BR><BR>
corresponds to the input vector `x`. \n
Vector size is `[n x 1]`. \n
Memory must be allocated. \n \n
\return
`RES_OK` if function calculated successfully. <BR>
Else \ref ERROR_CODE_GROUP "code error".<BR>
`RES_OK` if function calculated successfully. \n
Else \ref ERROR_CODE_GROUP "code error". \n
Example:<BR>
Example: \n
\code{.cpp}
complex_t x[3] = {{1.0, 2.0}, {3.0, 4.0}, {5.0, 6.0}};
complex_t y[3];
@ -498,9 +498,9 @@ Example:<BR>
RE(x[k]), IM(x[k]), RE(y[k]), IM(y[k]));
\endcode
<BR>
\n
Output is:<BR>
Output is: \n
\verbatim
sin_cmplx(1.0+2.0j) = 3.166 +1.960j
sin_cmplx(3.0+4.0j) = 3.854 -27.017j
@ -541,24 +541,24 @@ int DSPL_API sin_cmplx(complex_t* x, int n, complex_t *y)
\fn int sqrt_cmplx(complex_t* x, int n, complex_t *y)
\brief Square root of the complex vector argguument `x`.
Function calculates square root value of vector `x` length `n`: <BR>
Function calculates square root value of vector `x` length `n`: \n
\f[
y(k) = \sqrt{x(k)}, \qquad k = 0 \ldots n-1.
\f]
\param[in] x Pointer to the input complex vector `x`.<BR>
Vector size is `[n x 1]`. <BR><BR>
\param[in] x Pointer to the input complex vector `x`. \n
Vector size is `[n x 1]`. \n \n
\param[in] n Size of input and output vectors `x` and `y`.<BR><BR>
\param[in] n Size of input and output vectors `x` and `y`. \n \n
\param[out] y Pointer to the square root vector `y`.<BR>
Vector size is `[n x 1]`. <BR>
Memory must be allocated. <BR><BR>
\param[out] y Pointer to the square root vector `y`. \n
Vector size is `[n x 1]`. \n
Memory must be allocated. \n \n
\return `RES_OK` if function is calculated successfully. <BR>
Else \ref ERROR_CODE_GROUP "code error".<BR>
\return `RES_OK` if function is calculated successfully. \n
Else \ref ERROR_CODE_GROUP "code error". \n
Example
\code{.cpp}
@ -573,7 +573,7 @@ Example
RE(x[k]), IM(x[k]), RE(y[k]), IM(y[k]));
\endcode
<BR>
\n
Результатом работы будет

138
dspl/src/conv.c
Wyświetl plik

@ -18,14 +18,12 @@
* along with Foobar. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdlib.h>
#include <string.h>
#include "dspl.h"
/*******************************************************************************
\ingroup FILTER_CONV_GROUP
\fn int conv(double* a, int na, double* b, int nb, double* c)
@ -34,21 +32,21 @@
Function convolves two real vectors \f$ c = a * b\f$ length `na` and `nb`.
The output convolution is a vector `c` with length equal to `na + nb - 1`.
\param[in] a Pointer to the first vector `a`.<BR>
Vector size is `[na x 1]`.<BR><BR>
\param[in] a Pointer to the first vector `a`. /n
Vector size is `[na x 1]`. /n /n
\param[in] na Size of the first vector `a`.<BR><BR>
\param[in] na Size of the first vector `a`. /n /n
\param[in] b Pointer to the second vector `b`.<BR>
Vector size is `[nb x 1]`.<BR><BR>
\param[in] b Pointer to the second vector `b`. /n
Vector size is `[nb x 1]`. /n /n
\param[in] nb Size of the second vector `b`.<BR><BR>
\param[in] nb Size of the second vector `b`. /n /n
\param[out] c Pointer to the convolution output vector \f$ c = a * b\f$.<BR>
Vector size is `[na + nb - 1 x 1]`.<BR>
Memory must be allocated.<BR><BR>
\param[out] c Pointer to the convolution output vector \f$ c = a * b\f$. /n
Vector size is `[na + nb - 1 x 1]`. /n
Memory must be allocated. /n /n
\return `RES_OK` if convolution is calculated successfully.<BR>
\return `RES_OK` if convolution is calculated successfully. /n
Else \ref ERROR_CODE_GROUP "code error".
\note If vectors `a` and `b` are coefficients of two polynomials,
@ -69,7 +67,7 @@ Example:
printf("cr[%d] = %5.1f\n", n, cr[n]);
\endcode
<BR>
/n
Output:
\verbatim
@ -131,21 +129,21 @@ int DSPL_API conv(double* a, int na, double* b, int nb, double* c)
Function convolves two complex vectors \f$ c = a * b\f$ length `na` and `nb`.
The output convolution is a vector `c` with length equal to `na + nb - 1`.
\param[in] a Pointer to the first vector `a`.<BR>
Vector size is `[na x 1]`.<BR><BR>
\param[in] a Pointer to the first vector `a`. /n
Vector size is `[na x 1]`. /n /n
\param[in] na Size of the first vector `a`.<BR><BR>
\param[in] na Size of the first vector `a`. /n /n
\param[in] b Pointer to the second vector `b`.<BR>
Vector size is `[nb x 1]`.<BR><BR>
\param[in] b Pointer to the second vector `b`. /n
Vector size is `[nb x 1]`. /n /n
\param[in] nb Size of the second vector `b`.<BR><BR>
\param[in] nb Size of the second vector `b`. /n /n
\param[out] c Pointer to the convolution output vector \f$ c = a * b\f$.<BR>
Vector size is `[na + nb - 1 x 1]`.<BR>
Memory must be allocated.<BR><BR>
\param[out] c Pointer to the convolution output vector \f$ c = a * b\f$. /n
Vector size is `[na + nb - 1 x 1]`. /n
Memory must be allocated. /n /n
\return `RES_OK` if convolution is calculated successfully.<BR>
\return `RES_OK` if convolution is calculated successfully. /n
Else \ref ERROR_CODE_GROUP "code error".
\note If vectors `a` and `b` are coefficients of two polynomials,
@ -166,7 +164,7 @@ Example:
printf("cc[%d] = %5.1f%+5.1fj\n", n, RE(cc[n]),IM(cc[n]));
\endcode
<BR>
/n
Output:
\verbatim
@ -237,33 +235,33 @@ in the frequency domain by using FFT algorithms. This approach provide
high-performance convolution which increases with `na` and `nb` increasing.
The output convolution is a vector `c` with length equal to `na + nb - 1`.
\param[in] a Pointer to the first vector `a`.<BR>
Vector size is `[na x 1]`.<BR><BR>
\param[in] a Pointer to the first vector `a`. /n
Vector size is `[na x 1]`. /n /n
\param[in] na Size of the first vector `a`.<BR><BR>
\param[in] na Size of the first vector `a`. /n /n
\param[in] b Pointer to the second vector `b`.<BR>
Vector size is `[nb x 1]`.<BR><BR>
\param[in] b Pointer to the second vector `b`. /n
Vector size is `[nb x 1]`. /n /n
\param[in] nb Size of the second vector `b`.<BR><BR>
\param[in] nb Size of the second vector `b`. /n /n
\param[in] pfft Pointer to the structure `fft_t`.<BR>
\param[in] pfft Pointer to the structure `fft_t`. /n
Function changes `fft_t` structure fields so `fft_t` must
be clear before program returns.<BR><BR>
be clear before program returns. /n /n
\param[in] nfft FFT size. <BR>
\param[in] nfft FFT size. /n
This parameter set which FFT size will be used
for overlapped frequency domain convolution.<BR>
for overlapped frequency domain convolution. /n
FFT size must be more of minimal `na` and `nb` value.
For example if `na = 10`, `nb = 4` then `nfft` parameter must
be more than 4. <BR>
be more than 4. /n
\param[out] c Pointer to the convolution output vector \f$ c = a * b\f$.<BR>
Vector size is `[na + nb - 1 x 1]`.<BR>
Memory must be allocated.<BR><BR>
\param[out] c Pointer to the convolution output vector \f$ c = a * b\f$. /n
Vector size is `[na + nb - 1 x 1]`. /n
Memory must be allocated. /n /n
\return `RES_OK` if convolution is calculated successfully.<BR>
Else \ref ERROR_CODE_GROUP "code error". <BR><BR>
\return `RES_OK` if convolution is calculated successfully. /n
Else \ref ERROR_CODE_GROUP "code error". /n /n
Example:
\include conv_fft_test.c
@ -345,33 +343,33 @@ in the frequency domain by using FFT algorithms. This approach provide
high-performance convolution which increases with `na` and `nb` increasing.
The output convolution is a vector `c` with length equal to `na + nb - 1`.
\param[in] a Pointer to the first vector `a`.<BR>
Vector size is `[na x 1]`.<BR><BR>
\param[in] a Pointer to the first vector `a`. /n
Vector size is `[na x 1]`. /n /n
\param[in] na Size of the first vector `a`.<BR><BR>
\param[in] na Size of the first vector `a`. /n /n
\param[in] b Pointer to the second vector `b`.<BR>
Vector size is `[nb x 1]`.<BR><BR>
\param[in] b Pointer to the second vector `b`. /n
Vector size is `[nb x 1]`. /n /n
\param[in] nb Size of the second vector `b`.<BR><BR>
\param[in] nb Size of the second vector `b`. /n /n
\param[in] pfft Pointer to the structure `fft_t`.<BR>
\param[in] pfft Pointer to the structure `fft_t`. /n
Function changes `fft_t` structure fields so `fft_t` must
be clear before program returns.<BR><BR>
be clear before program returns. /n /n
\param[in] nfft FFT size. <BR>
\param[in] nfft FFT size. /n
This parameter set which FFT size will be used
for overlapped frequency domain convolution.<BR>
for overlapped frequency domain convolution. /n
FFT size must be more of minimal `na` and `nb` value.
For example if `na = 10`, `nb = 4` then `nfft` parameter must
be more than 4. <BR>
be more than 4. /n
\param[out] c Pointer to the convolution output vector \f$ c = a * b\f$.<BR>
Vector size is `[na + nb - 1 x 1]`.<BR>
Memory must be allocated.<BR><BR>
\param[out] c Pointer to the convolution output vector \f$ c = a * b\f$. /n
Vector size is `[na + nb - 1 x 1]`. /n
Memory must be allocated. /n /n
\return `RES_OK` if convolution is calculated successfully.<BR>
Else \ref ERROR_CODE_GROUP "code error". <BR><BR>
\return `RES_OK` if convolution is calculated successfully. /n
Else \ref ERROR_CODE_GROUP "code error". /n /n
Example:
\include conv_fft_cmplx_test.c
@ -527,29 +525,29 @@ here \f$a_0\f$ cannot be equals zeros, \f$N=M=\f$`ord`.
\param[in] b Pointer to the vector \f$b\f$ of IIR filter
transfer function numerator coefficients.<BR>
Vector size is `[ord + 1 x 1]`.<BR><BR>
transfer function numerator coefficients. /n
Vector size is `[ord + 1 x 1]`. /n /n
\param[in] a Pointer to the vector \f$a\f$ of IIR filter
transfer function denominator coefficients.<BR>
Vector size is `[ord + 1 x 1]`.<BR>
This pointer can be `NULL` if filter is FIR.<BR><BR>
transfer function denominator coefficients. /n
Vector size is `[ord + 1 x 1]`. /n
This pointer can be `NULL` if filter is FIR. /n /n
\param[in] ord Filter order. Number of the transfer function
numerator and denominator coefficients
(length of vectors `b` and `a`) is `ord + 1`.<BR><BR>
(length of vectors `b` and `a`) is `ord + 1`. /n /n
\param[in] x Pointer to the input signal vector.<BR>
Vector size is `[n x 1]`.<BR><BR>
\param[in] x Pointer to the input signal vector. /n
Vector size is `[n x 1]`. /n /n
\param[in] n Size of the input signal vector `x`.<BR><BR>
\param[in] n Size of the input signal vector `x`. /n /n
\param[out] y Pointer to the IIR filter output vector.<BR>
Vector size is `[n x 1]`.<BR>
Memory must be allocated.<BR><BR>
\param[out] y Pointer to the IIR filter output vector. /n
Vector size is `[n x 1]`. /n
Memory must be allocated. /n /n
\return
`RES_OK` if filter output is calculted successfully.<BR>
Else \ref ERROR_CODE_GROUP "code error":<BR>
`RES_OK` if filter output is calculted successfully. /n
Else \ref ERROR_CODE_GROUP "code error": /n
\author Sergey Bakhurin www.dsplib.org
*******************************************************************************/

48
dspl/src/dft.c
Wyświetl plik

@ -31,7 +31,7 @@
\brief `n`-points discrete Fourier transform of the real vector `x`.
Function calculates \f$ n \f$-points discrete Fourier transform of
the real vector \f$ x(m) \f$, \f$ m = 0 \ldots n-1 \f$.<BR>
the real vector \f$ x(m) \f$, \f$ m = 0 \ldots n-1 \f$. \n
\f[
Y(k) = \sum_{m = 0}^{n-1} x(m)
\exp \left( -j \frac{2\pi}{n} m k \right),
@ -40,18 +40,18 @@ here \f$ k = 0 \ldots n-1 \f$.
\param[in] x Pointer to the real input
signal vector \f$x(m)\f$,
\f$ m = 0 \ldots n-1 \f$. <BR>
Vector size is `[n x 1]`. <BR><BR>
\f$ m = 0 \ldots n-1 \f$. \n
Vector size is `[n x 1]`. \n \n
\param[in] n DFT size \f$n\f$ (size of input and output vectors).<BR><BR>
\param[in] n DFT size \f$n\f$ (size of input and output vectors). \n \n
\param[out] y Pointer to the complex DFT output vector \f$Y(k)\f$,
\f$ k = 0 \ldots n-1 \f$. <BR>
Vector size is `[n x 1]`. <BR>
Memory must be allocated.<BR><BR>
\f$ k = 0 \ldots n-1 \f$. \n
Vector size is `[n x 1]`. \n
Memory must be allocated. \n \n
\return `RES_OK` if DFT is calculated successfully. <BR>
\return `RES_OK` if DFT is calculated successfully. \n
Else \ref ERROR_CODE_GROUP "code error".
Example:
@ -123,7 +123,7 @@ int DSPL_API dft(double* x, int n, complex_t* y)
\brief `n`-points discrete Fourier transform of the complex vector `x`.
Function calculates \f$ n \f$-points discrete Fourier transform of
the complex vector \f$ x(m) \f$, \f$ m = 0 \ldots n-1 \f$.<BR>
the complex vector \f$ x(m) \f$, \f$ m = 0 \ldots n-1 \f$. \n
\f[
Y(k) = \sum_{m = 0}^{n-1} x(m)
\exp \left( -j \frac{2\pi}{n} m k \right),
@ -132,18 +132,18 @@ here \f$ k = 0 \ldots n-1 \f$.
\param[in] x Pointer to the complex input
signal vector \f$x(m)\f$,
\f$ m = 0 \ldots n-1 \f$. <BR>
Vector size is `[n x 1]`. <BR><BR>
\f$ m = 0 \ldots n-1 \f$. \n
Vector size is `[n x 1]`. \n \n
\param[in] n DFT size \f$n\f$ (size of input and output vectors).<BR><BR>
\param[in] n DFT size \f$n\f$ (size of input and output vectors). \n \n
\param[out] y Pointer to the complex DFT output vector \f$Y(k)\f$,
\f$ k = 0 \ldots n-1 \f$. <BR>
Vector size is `[n x 1]`. <BR>
Memory must be allocated.<BR><BR>
\f$ k = 0 \ldots n-1 \f$. \n
Vector size is `[n x 1]`. \n
Memory must be allocated. \n \n
\return `RES_OK` if DFT is calculated successfully. <BR>
\return `RES_OK` if DFT is calculated successfully. \n
Else \ref ERROR_CODE_GROUP "code error".
Example:
@ -219,7 +219,7 @@ int DSPL_API dft_cmplx(complex_t* x, int n, complex_t* y)
\brief `n`-points inverse discrete Fourier transform of the complex vector `x`.
Function calculates \f$ n \f$-points inverse discrete Fourier transform of
the complex vector \f$ x(m) \f$, \f$ m = 0 \ldots n-1 \f$.<BR>
the complex vector \f$ x(m) \f$, \f$ m = 0 \ldots n-1 \f$. \n
\f[
y(k) = \sum_{m = 0}^{n-1} x(m)
\exp \left( j \frac{2\pi}{n} m k \right),
@ -228,18 +228,18 @@ here \f$ k = 0 \ldots n-1 \f$.
\param[in] x Pointer to the complex input
vector \f$x(m)\f$,
\f$ m = 0 \ldots n-1 \f$. <BR>
Vector size is `[n x 1]`. <BR><BR>
\f$ m = 0 \ldots n-1 \f$. \n
Vector size is `[n x 1]`. \n \n
\param[in] n IDFT size \f$n\f$ (size of input and output vectors).<BR><BR>
\param[in] n IDFT size \f$n\f$ (size of input and output vectors). \n \n
\param[out] y Pointer to the complex IDFT output vector \f$y(k)\f$,
\f$ k = 0 \ldots n-1 \f$. <BR>
Vector size is `[n x 1]`. <BR>
Memory must be allocated.<BR><BR>
\f$ k = 0 \ldots n-1 \f$. \n
Vector size is `[n x 1]`. \n
Memory must be allocated. \n \n
\return `RES_OK` if IDFT is calculated successfully. <BR>
\return `RES_OK` if IDFT is calculated successfully. \n
Else \ref ERROR_CODE_GROUP "code error".
Example:

2
dspl/src/filter_an.c
Wyświetl plik

@ -44,7 +44,7 @@ int DSPL_API filter_freq_resp(double* b, double* a, int ord,
double *w0 = NULL;
double *w1 = NULL;
if(!b || !a || !w)
if(!b || !w)
return ERROR_PTR;
if(ord < 1)
return ERROR_FILTER_ORD;

10
dspl/src/filter_ap.c
Wyświetl plik

@ -287,15 +287,14 @@ int DSPL_API cheby2_ap_wp1(double rp, double rs, int ord, double* b, double* a)
{
int err;
double es, gp, alpha, beta, y, wp;
if(rp <= 0)
return ERROR_FILTER_RP;
err = cheby2_ap(rs, ord, b, a);
if(err!=RES_OK)
goto exit_label;
es = sqrt(pow(10.0, rs*0.1) - 1.0);
gp = pow(10.0, -rp*0.05);
alpha = gp * es / sqrt(1.0 - gp*gp);
@ -304,7 +303,7 @@ int DSPL_API cheby2_ap_wp1(double rp, double rs, int ord, double* b, double* a)
wp = 2.0 / (exp(y) + exp(-y));
err = low2low(b, a, ord, wp, 1.0, b, a);
exit_label:
return err;
}
@ -575,6 +574,7 @@ int DSPL_API filter_zp2ab(complex_t *z, int nz, complex_t *p, int np,
goto exit_label;
exit_label:
if(acc)
free(acc);

32
dspl/src/filter_iir.c
Wyświetl plik

@ -48,32 +48,32 @@ normalized frequency \f$\omega\f$ as:
\f]
\param[in] bs Pointer to the numerator coefficients of an
analog prototype transfer function \f$H(s)\f$. <BR>
Array size is `[ord+1 x 1]`.<BR>
Memory must be allocated.<BR><BR>
analog prototype transfer function \f$H(s)\f$. \n
Array size is `[ord+1 x 1]`. \n
Memory must be allocated. \n \n
\param[in] as Pointer to the denominator coefficients of an
analog prototype transfer function \f$H(s)\f$. <BR>
Array size is `[ord+1 x 1]`.<BR>
Memory must be allocated.<BR><BR>
analog prototype transfer function \f$H(s)\f$. \n
Array size is `[ord+1 x 1]`. \n
Memory must be allocated. \n \n
\param[in] ord Filter order.<BR>
\param[in] ord Filter order. \n
Number of coefficients \f$H(s)\f$ and \f$H(z)\f$
numerator and denominator equals `ord+1`.<BR><BR>
numerator and denominator equals `ord+1`. \n \n
\param[out] bz Pointer to the numerator coefficients of a
digital filter transfer function \f$H(z)\f$. <BR>
Array size is `[ord+1 x 1]`.<BR>
Memory must be allocated.<BR><BR>
digital filter transfer function \f$H(z)\f$. \n
Array size is `[ord+1 x 1]`. \n
Memory must be allocated. \n \n
\param[out] az Pointer to the numerator coefficients of a
digital filter transfer function \f$H(z)\f$. <BR>
Array size is `[ord+1 x 1]`.<BR>
Memory must be allocated.<BR><BR>
digital filter transfer function \f$H(z)\f$. \n
Array size is `[ord+1 x 1]`. \n
Memory must be allocated. \n \n
\return
`RES_OK` if filter is calculated successfully.<BR><BR>
Else \ref ERROR_CODE_GROUP "code error".<BR>
`RES_OK` if filter is calculated successfully. \n \n
Else \ref ERROR_CODE_GROUP "code error". \n
\author Sergey Bakhurin www.dsplib.org
*******************************************************************************/