fasttransforms.h

Go to the documentation of this file.
1 /*************************************************************************
2 ALGLIB 3.11.0 (source code generated 2017-05-11)
3 Copyright (c) Sergey Bochkanov (ALGLIB project).
4 
5 >>> SOURCE LICENSE >>>
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation (www.fsf.org); either version 2 of the
9 License, or (at your option) any later version.
10 
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15 
16 A copy of the GNU General Public License is available at
17 http://www.fsf.org/licensing/licenses
18 >>> END OF LICENSE >>>
19 *************************************************************************/
20 #ifndef _fasttransforms_pkg_h
21 #define _fasttransforms_pkg_h
22 #include "ap.h"
23 #include "alglibinternal.h"
24 
26 //
27 // THIS SECTION CONTAINS COMPUTATIONAL CORE DECLARATIONS (DATATYPES)
28 //
30 namespace alglib_impl
31 {
32 
33 }
34 
36 //
37 // THIS SECTION CONTAINS C++ INTERFACE
38 //
40 namespace alglib
41 {
42 
43 
44 /*************************************************************************
45 1-dimensional complex FFT.
46 
47 Array size N may be arbitrary number (composite or prime). Composite N's
48 are handled with cache-oblivious variation of a Cooley-Tukey algorithm.
49 Small prime-factors are transformed using hard coded codelets (similar to
50 FFTW codelets, but without low-level optimization), large prime-factors
51 are handled with Bluestein's algorithm.
52 
53 Fastests transforms are for smooth N's (prime factors are 2, 3, 5 only),
54 most fast for powers of 2. When N have prime factors larger than these,
55 but orders of magnitude smaller than N, computations will be about 4 times
56 slower than for nearby highly composite N's. When N itself is prime, speed
57 will be 6 times lower.
58 
59 Algorithm has O(N*logN) complexity for any N (composite or prime).
60 
61 INPUT PARAMETERS
62  A - array[0..N-1] - complex function to be transformed
63  N - problem size
64 
65 OUTPUT PARAMETERS
66  A - DFT of a input array, array[0..N-1]
67  A_out[j] = SUM(A_in[k]*exp(-2*pi*sqrt(-1)*j*k/N), k = 0..N-1)
68 
69 
70  -- ALGLIB --
71  Copyright 29.05.2009 by Bochkanov Sergey
72 *************************************************************************/
73 void fftc1d(complex_1d_array &a, const ae_int_t n);
74 void fftc1d(complex_1d_array &a);
75 
76 
77 /*************************************************************************
78 1-dimensional complex inverse FFT.
79 
80 Array size N may be arbitrary number (composite or prime). Algorithm has
81 O(N*logN) complexity for any N (composite or prime).
82 
83 See FFTC1D() description for more information about algorithm performance.
84 
85 INPUT PARAMETERS
86  A - array[0..N-1] - complex array to be transformed
87  N - problem size
88 
89 OUTPUT PARAMETERS
90  A - inverse DFT of a input array, array[0..N-1]
91  A_out[j] = SUM(A_in[k]/N*exp(+2*pi*sqrt(-1)*j*k/N), k = 0..N-1)
92 
93 
94  -- ALGLIB --
95  Copyright 29.05.2009 by Bochkanov Sergey
96 *************************************************************************/
97 void fftc1dinv(complex_1d_array &a, const ae_int_t n);
98 void fftc1dinv(complex_1d_array &a);
99 
100 
101 /*************************************************************************
102 1-dimensional real FFT.
103 
104 Algorithm has O(N*logN) complexity for any N (composite or prime).
105 
106 INPUT PARAMETERS
107  A - array[0..N-1] - real function to be transformed
108  N - problem size
109 
110 OUTPUT PARAMETERS
111  F - DFT of a input array, array[0..N-1]
112  F[j] = SUM(A[k]*exp(-2*pi*sqrt(-1)*j*k/N), k = 0..N-1)
113 
114 NOTE:
115  F[] satisfies symmetry property F[k] = conj(F[N-k]), so just one half
116 of array is usually needed. But for convinience subroutine returns full
117 complex array (with frequencies above N/2), so its result may be used by
118 other FFT-related subroutines.
119 
120 
121  -- ALGLIB --
122  Copyright 01.06.2009 by Bochkanov Sergey
123 *************************************************************************/
124 void fftr1d(const real_1d_array &a, const ae_int_t n, complex_1d_array &f);
125 void fftr1d(const real_1d_array &a, complex_1d_array &f);
126 
127 
128 /*************************************************************************
129 1-dimensional real inverse FFT.
130 
131 Algorithm has O(N*logN) complexity for any N (composite or prime).
132 
133 INPUT PARAMETERS
134  F - array[0..floor(N/2)] - frequencies from forward real FFT
135  N - problem size
136 
137 OUTPUT PARAMETERS
138  A - inverse DFT of a input array, array[0..N-1]
139 
140 NOTE:
141  F[] should satisfy symmetry property F[k] = conj(F[N-k]), so just one
142 half of frequencies array is needed - elements from 0 to floor(N/2). F[0]
143 is ALWAYS real. If N is even F[floor(N/2)] is real too. If N is odd, then
144 F[floor(N/2)] has no special properties.
145 
146 Relying on properties noted above, FFTR1DInv subroutine uses only elements
147 from 0th to floor(N/2)-th. It ignores imaginary part of F[0], and in case
148 N is even it ignores imaginary part of F[floor(N/2)] too.
149 
150 When you call this function using full arguments list - "FFTR1DInv(F,N,A)"
151 - you can pass either either frequencies array with N elements or reduced
152 array with roughly N/2 elements - subroutine will successfully transform
153 both.
154 
155 If you call this function using reduced arguments list - "FFTR1DInv(F,A)"
156 - you must pass FULL array with N elements (although higher N/2 are still
157 not used) because array size is used to automatically determine FFT length
158 
159 
160  -- ALGLIB --
161  Copyright 01.06.2009 by Bochkanov Sergey
162 *************************************************************************/
163 void fftr1dinv(const complex_1d_array &f, const ae_int_t n, real_1d_array &a);
164 void fftr1dinv(const complex_1d_array &f, real_1d_array &a);
165 
166 /*************************************************************************
167 1-dimensional Fast Hartley Transform.
168 
169 Algorithm has O(N*logN) complexity for any N (composite or prime).
170 
171 INPUT PARAMETERS
172  A - array[0..N-1] - real function to be transformed
173  N - problem size
174 
175 OUTPUT PARAMETERS
176  A - FHT of a input array, array[0..N-1],
177  A_out[k] = sum(A_in[j]*(cos(2*pi*j*k/N)+sin(2*pi*j*k/N)), j=0..N-1)
178 
179 
180  -- ALGLIB --
181  Copyright 04.06.2009 by Bochkanov Sergey
182 *************************************************************************/
183 void fhtr1d(real_1d_array &a, const ae_int_t n);
184 
185 
186 /*************************************************************************
187 1-dimensional inverse FHT.
188 
189 Algorithm has O(N*logN) complexity for any N (composite or prime).
190 
191 INPUT PARAMETERS
192  A - array[0..N-1] - complex array to be transformed
193  N - problem size
194 
195 OUTPUT PARAMETERS
196  A - inverse FHT of a input array, array[0..N-1]
197 
198 
199  -- ALGLIB --
200  Copyright 29.05.2009 by Bochkanov Sergey
201 *************************************************************************/
202 void fhtr1dinv(real_1d_array &a, const ae_int_t n);
203 
204 /*************************************************************************
205 1-dimensional complex convolution.
206 
207 For given A/B returns conv(A,B) (non-circular). Subroutine can automatically
208 choose between three implementations: straightforward O(M*N) formula for
209 very small N (or M), overlap-add algorithm for cases where max(M,N) is
210 significantly larger than min(M,N), but O(M*N) algorithm is too slow, and
211 general FFT-based formula for cases where two previois algorithms are too
212 slow.
213 
214 Algorithm has max(M,N)*log(max(M,N)) complexity for any M/N.
215 
216 INPUT PARAMETERS
217  A - array[0..M-1] - complex function to be transformed
218  M - problem size
219  B - array[0..N-1] - complex function to be transformed
220  N - problem size
221 
222 OUTPUT PARAMETERS
223  R - convolution: A*B. array[0..N+M-2].
224 
225 NOTE:
226  It is assumed that A is zero at T<0, B is zero too. If one or both
227 functions have non-zero values at negative T's, you can still use this
228 subroutine - just shift its result correspondingly.
229 
230  -- ALGLIB --
231  Copyright 21.07.2009 by Bochkanov Sergey
232 *************************************************************************/
233 void convc1d(const complex_1d_array &a, const ae_int_t m, const complex_1d_array &b, const ae_int_t n, complex_1d_array &r);
234 
235 
236 /*************************************************************************
237 1-dimensional complex non-circular deconvolution (inverse of ConvC1D()).
238 
239 Algorithm has M*log(M)) complexity for any M (composite or prime).
240 
241 INPUT PARAMETERS
242  A - array[0..M-1] - convolved signal, A = conv(R, B)
243  M - convolved signal length
244  B - array[0..N-1] - response
245  N - response length, N<=M
246 
247 OUTPUT PARAMETERS
248  R - deconvolved signal. array[0..M-N].
249 
250 NOTE:
251  deconvolution is unstable process and may result in division by zero
252 (if your response function is degenerate, i.e. has zero Fourier coefficient).
253 
254 NOTE:
255  It is assumed that A is zero at T<0, B is zero too. If one or both
256 functions have non-zero values at negative T's, you can still use this
257 subroutine - just shift its result correspondingly.
258 
259  -- ALGLIB --
260  Copyright 21.07.2009 by Bochkanov Sergey
261 *************************************************************************/
262 void convc1dinv(const complex_1d_array &a, const ae_int_t m, const complex_1d_array &b, const ae_int_t n, complex_1d_array &r);
263 
264 
265 /*************************************************************************
266 1-dimensional circular complex convolution.
267 
268 For given S/R returns conv(S,R) (circular). Algorithm has linearithmic
269 complexity for any M/N.
270 
271 IMPORTANT: normal convolution is commutative, i.e. it is symmetric -
272 conv(A,B)=conv(B,A). Cyclic convolution IS NOT. One function - S - is a
273 signal, periodic function, and another - R - is a response, non-periodic
274 function with limited length.
275 
276 INPUT PARAMETERS
277  S - array[0..M-1] - complex periodic signal
278  M - problem size
279  B - array[0..N-1] - complex non-periodic response
280  N - problem size
281 
282 OUTPUT PARAMETERS
283  R - convolution: A*B. array[0..M-1].
284 
285 NOTE:
286  It is assumed that B is zero at T<0. If it has non-zero values at
287 negative T's, you can still use this subroutine - just shift its result
288 correspondingly.
289 
290  -- ALGLIB --
291  Copyright 21.07.2009 by Bochkanov Sergey
292 *************************************************************************/
293 void convc1dcircular(const complex_1d_array &s, const ae_int_t m, const complex_1d_array &r, const ae_int_t n, complex_1d_array &c);
294 
295 
296 /*************************************************************************
297 1-dimensional circular complex deconvolution (inverse of ConvC1DCircular()).
298 
299 Algorithm has M*log(M)) complexity for any M (composite or prime).
300 
301 INPUT PARAMETERS
302  A - array[0..M-1] - convolved periodic signal, A = conv(R, B)
303  M - convolved signal length
304  B - array[0..N-1] - non-periodic response
305  N - response length
306 
307 OUTPUT PARAMETERS
308  R - deconvolved signal. array[0..M-1].
309 
310 NOTE:
311  deconvolution is unstable process and may result in division by zero
312 (if your response function is degenerate, i.e. has zero Fourier coefficient).
313 
314 NOTE:
315  It is assumed that B is zero at T<0. If it has non-zero values at
316 negative T's, you can still use this subroutine - just shift its result
317 correspondingly.
318 
319  -- ALGLIB --
320  Copyright 21.07.2009 by Bochkanov Sergey
321 *************************************************************************/
322 void convc1dcircularinv(const complex_1d_array &a, const ae_int_t m, const complex_1d_array &b, const ae_int_t n, complex_1d_array &r);
323 
324 
325 /*************************************************************************
326 1-dimensional real convolution.
327 
328 Analogous to ConvC1D(), see ConvC1D() comments for more details.
329 
330 INPUT PARAMETERS
331  A - array[0..M-1] - real function to be transformed
332  M - problem size
333  B - array[0..N-1] - real function to be transformed
334  N - problem size
335 
336 OUTPUT PARAMETERS
337  R - convolution: A*B. array[0..N+M-2].
338 
339 NOTE:
340  It is assumed that A is zero at T<0, B is zero too. If one or both
341 functions have non-zero values at negative T's, you can still use this
342 subroutine - just shift its result correspondingly.
343 
344  -- ALGLIB --
345  Copyright 21.07.2009 by Bochkanov Sergey
346 *************************************************************************/
347 void convr1d(const real_1d_array &a, const ae_int_t m, const real_1d_array &b, const ae_int_t n, real_1d_array &r);
348 
349 
350 /*************************************************************************
351 1-dimensional real deconvolution (inverse of ConvC1D()).
352 
353 Algorithm has M*log(M)) complexity for any M (composite or prime).
354 
355 INPUT PARAMETERS
356  A - array[0..M-1] - convolved signal, A = conv(R, B)
357  M - convolved signal length
358  B - array[0..N-1] - response
359  N - response length, N<=M
360 
361 OUTPUT PARAMETERS
362  R - deconvolved signal. array[0..M-N].
363 
364 NOTE:
365  deconvolution is unstable process and may result in division by zero
366 (if your response function is degenerate, i.e. has zero Fourier coefficient).
367 
368 NOTE:
369  It is assumed that A is zero at T<0, B is zero too. If one or both
370 functions have non-zero values at negative T's, you can still use this
371 subroutine - just shift its result correspondingly.
372 
373  -- ALGLIB --
374  Copyright 21.07.2009 by Bochkanov Sergey
375 *************************************************************************/
376 void convr1dinv(const real_1d_array &a, const ae_int_t m, const real_1d_array &b, const ae_int_t n, real_1d_array &r);
377 
378 
379 /*************************************************************************
380 1-dimensional circular real convolution.
381 
382 Analogous to ConvC1DCircular(), see ConvC1DCircular() comments for more details.
383 
384 INPUT PARAMETERS
385  S - array[0..M-1] - real signal
386  M - problem size
387  B - array[0..N-1] - real response
388  N - problem size
389 
390 OUTPUT PARAMETERS
391  R - convolution: A*B. array[0..M-1].
392 
393 NOTE:
394  It is assumed that B is zero at T<0. If it has non-zero values at
395 negative T's, you can still use this subroutine - just shift its result
396 correspondingly.
397 
398  -- ALGLIB --
399  Copyright 21.07.2009 by Bochkanov Sergey
400 *************************************************************************/
401 void convr1dcircular(const real_1d_array &s, const ae_int_t m, const real_1d_array &r, const ae_int_t n, real_1d_array &c);
402 
403 
404 /*************************************************************************
405 1-dimensional complex deconvolution (inverse of ConvC1D()).
406 
407 Algorithm has M*log(M)) complexity for any M (composite or prime).
408 
409 INPUT PARAMETERS
410  A - array[0..M-1] - convolved signal, A = conv(R, B)
411  M - convolved signal length
412  B - array[0..N-1] - response
413  N - response length
414 
415 OUTPUT PARAMETERS
416  R - deconvolved signal. array[0..M-N].
417 
418 NOTE:
419  deconvolution is unstable process and may result in division by zero
420 (if your response function is degenerate, i.e. has zero Fourier coefficient).
421 
422 NOTE:
423  It is assumed that B is zero at T<0. If it has non-zero values at
424 negative T's, you can still use this subroutine - just shift its result
425 correspondingly.
426 
427  -- ALGLIB --
428  Copyright 21.07.2009 by Bochkanov Sergey
429 *************************************************************************/
430 void convr1dcircularinv(const real_1d_array &a, const ae_int_t m, const real_1d_array &b, const ae_int_t n, real_1d_array &r);
431 
432 /*************************************************************************
433 1-dimensional complex cross-correlation.
434 
435 For given Pattern/Signal returns corr(Pattern,Signal) (non-circular).
436 
437 Correlation is calculated using reduction to convolution. Algorithm with
438 max(N,N)*log(max(N,N)) complexity is used (see ConvC1D() for more info
439 about performance).
440 
441 IMPORTANT:
442  for historical reasons subroutine accepts its parameters in reversed
443  order: CorrC1D(Signal, Pattern) = Pattern x Signal (using traditional
444  definition of cross-correlation, denoting cross-correlation as "x").
445 
446 INPUT PARAMETERS
447  Signal - array[0..N-1] - complex function to be transformed,
448  signal containing pattern
449  N - problem size
450  Pattern - array[0..M-1] - complex function to be transformed,
451  pattern to search withing signal
452  M - problem size
453 
454 OUTPUT PARAMETERS
455  R - cross-correlation, array[0..N+M-2]:
456  * positive lags are stored in R[0..N-1],
457  R[i] = sum(conj(pattern[j])*signal[i+j]
458  * negative lags are stored in R[N..N+M-2],
459  R[N+M-1-i] = sum(conj(pattern[j])*signal[-i+j]
460 
461 NOTE:
462  It is assumed that pattern domain is [0..M-1]. If Pattern is non-zero
463 on [-K..M-1], you can still use this subroutine, just shift result by K.
464 
465  -- ALGLIB --
466  Copyright 21.07.2009 by Bochkanov Sergey
467 *************************************************************************/
468 void corrc1d(const complex_1d_array &signal, const ae_int_t n, const complex_1d_array &pattern, const ae_int_t m, complex_1d_array &r);
469 
470 
471 /*************************************************************************
472 1-dimensional circular complex cross-correlation.
473 
474 For given Pattern/Signal returns corr(Pattern,Signal) (circular).
475 Algorithm has linearithmic complexity for any M/N.
476 
477 IMPORTANT:
478  for historical reasons subroutine accepts its parameters in reversed
479  order: CorrC1DCircular(Signal, Pattern) = Pattern x Signal (using
480  traditional definition of cross-correlation, denoting cross-correlation
481  as "x").
482 
483 INPUT PARAMETERS
484  Signal - array[0..N-1] - complex function to be transformed,
485  periodic signal containing pattern
486  N - problem size
487  Pattern - array[0..M-1] - complex function to be transformed,
488  non-periodic pattern to search withing signal
489  M - problem size
490 
491 OUTPUT PARAMETERS
492  R - convolution: A*B. array[0..M-1].
493 
494 
495  -- ALGLIB --
496  Copyright 21.07.2009 by Bochkanov Sergey
497 *************************************************************************/
498 void corrc1dcircular(const complex_1d_array &signal, const ae_int_t m, const complex_1d_array &pattern, const ae_int_t n, complex_1d_array &c);
499 
500 
501 /*************************************************************************
502 1-dimensional real cross-correlation.
503 
504 For given Pattern/Signal returns corr(Pattern,Signal) (non-circular).
505 
506 Correlation is calculated using reduction to convolution. Algorithm with
507 max(N,N)*log(max(N,N)) complexity is used (see ConvC1D() for more info
508 about performance).
509 
510 IMPORTANT:
511  for historical reasons subroutine accepts its parameters in reversed
512  order: CorrR1D(Signal, Pattern) = Pattern x Signal (using traditional
513  definition of cross-correlation, denoting cross-correlation as "x").
514 
515 INPUT PARAMETERS
516  Signal - array[0..N-1] - real function to be transformed,
517  signal containing pattern
518  N - problem size
519  Pattern - array[0..M-1] - real function to be transformed,
520  pattern to search withing signal
521  M - problem size
522 
523 OUTPUT PARAMETERS
524  R - cross-correlation, array[0..N+M-2]:
525  * positive lags are stored in R[0..N-1],
526  R[i] = sum(pattern[j]*signal[i+j]
527  * negative lags are stored in R[N..N+M-2],
528  R[N+M-1-i] = sum(pattern[j]*signal[-i+j]
529 
530 NOTE:
531  It is assumed that pattern domain is [0..M-1]. If Pattern is non-zero
532 on [-K..M-1], you can still use this subroutine, just shift result by K.
533 
534  -- ALGLIB --
535  Copyright 21.07.2009 by Bochkanov Sergey
536 *************************************************************************/
537 void corrr1d(const real_1d_array &signal, const ae_int_t n, const real_1d_array &pattern, const ae_int_t m, real_1d_array &r);
538 
539 
540 /*************************************************************************
541 1-dimensional circular real cross-correlation.
542 
543 For given Pattern/Signal returns corr(Pattern,Signal) (circular).
544 Algorithm has linearithmic complexity for any M/N.
545 
546 IMPORTANT:
547  for historical reasons subroutine accepts its parameters in reversed
548  order: CorrR1DCircular(Signal, Pattern) = Pattern x Signal (using
549  traditional definition of cross-correlation, denoting cross-correlation
550  as "x").
551 
552 INPUT PARAMETERS
553  Signal - array[0..N-1] - real function to be transformed,
554  periodic signal containing pattern
555  N - problem size
556  Pattern - array[0..M-1] - real function to be transformed,
557  non-periodic pattern to search withing signal
558  M - problem size
559 
560 OUTPUT PARAMETERS
561  R - convolution: A*B. array[0..M-1].
562 
563 
564  -- ALGLIB --
565  Copyright 21.07.2009 by Bochkanov Sergey
566 *************************************************************************/
567 void corrr1dcircular(const real_1d_array &signal, const ae_int_t m, const real_1d_array &pattern, const ae_int_t n, real_1d_array &c);
568 }
569 
571 //
572 // THIS SECTION CONTAINS COMPUTATIONAL CORE DECLARATIONS (FUNCTIONS)
573 //
575 namespace alglib_impl
576 {
577 void fftc1d(/* Complex */ ae_vector* a, ae_int_t n, ae_state *_state);
578 void fftc1dinv(/* Complex */ ae_vector* a, ae_int_t n, ae_state *_state);
579 void fftr1d(/* Real */ ae_vector* a,
580  ae_int_t n,
581  /* Complex */ ae_vector* f,
582  ae_state *_state);
583 void fftr1dinv(/* Complex */ ae_vector* f,
584  ae_int_t n,
585  /* Real */ ae_vector* a,
586  ae_state *_state);
587 void fftr1dinternaleven(/* Real */ ae_vector* a,
588  ae_int_t n,
589  /* Real */ ae_vector* buf,
590  fasttransformplan* plan,
591  ae_state *_state);
592 void fftr1dinvinternaleven(/* Real */ ae_vector* a,
593  ae_int_t n,
594  /* Real */ ae_vector* buf,
595  fasttransformplan* plan,
596  ae_state *_state);
597 void fhtr1d(/* Real */ ae_vector* a, ae_int_t n, ae_state *_state);
598 void fhtr1dinv(/* Real */ ae_vector* a, ae_int_t n, ae_state *_state);
599 void convc1d(/* Complex */ ae_vector* a,
600  ae_int_t m,
601  /* Complex */ ae_vector* b,
602  ae_int_t n,
603  /* Complex */ ae_vector* r,
604  ae_state *_state);
605 void convc1dinv(/* Complex */ ae_vector* a,
606  ae_int_t m,
607  /* Complex */ ae_vector* b,
608  ae_int_t n,
609  /* Complex */ ae_vector* r,
610  ae_state *_state);
611 void convc1dcircular(/* Complex */ ae_vector* s,
612  ae_int_t m,
613  /* Complex */ ae_vector* r,
614  ae_int_t n,
615  /* Complex */ ae_vector* c,
616  ae_state *_state);
617 void convc1dcircularinv(/* Complex */ ae_vector* a,
618  ae_int_t m,
619  /* Complex */ ae_vector* b,
620  ae_int_t n,
621  /* Complex */ ae_vector* r,
622  ae_state *_state);
623 void convr1d(/* Real */ ae_vector* a,
624  ae_int_t m,
625  /* Real */ ae_vector* b,
626  ae_int_t n,
627  /* Real */ ae_vector* r,
628  ae_state *_state);
629 void convr1dinv(/* Real */ ae_vector* a,
630  ae_int_t m,
631  /* Real */ ae_vector* b,
632  ae_int_t n,
633  /* Real */ ae_vector* r,
634  ae_state *_state);
635 void convr1dcircular(/* Real */ ae_vector* s,
636  ae_int_t m,
637  /* Real */ ae_vector* r,
638  ae_int_t n,
639  /* Real */ ae_vector* c,
640  ae_state *_state);
641 void convr1dcircularinv(/* Real */ ae_vector* a,
642  ae_int_t m,
643  /* Real */ ae_vector* b,
644  ae_int_t n,
645  /* Real */ ae_vector* r,
646  ae_state *_state);
647 void convc1dx(/* Complex */ ae_vector* a,
648  ae_int_t m,
649  /* Complex */ ae_vector* b,
650  ae_int_t n,
651  ae_bool circular,
652  ae_int_t alg,
653  ae_int_t q,
654  /* Complex */ ae_vector* r,
655  ae_state *_state);
656 void convr1dx(/* Real */ ae_vector* a,
657  ae_int_t m,
658  /* Real */ ae_vector* b,
659  ae_int_t n,
660  ae_bool circular,
661  ae_int_t alg,
662  ae_int_t q,
663  /* Real */ ae_vector* r,
664  ae_state *_state);
665 void corrc1d(/* Complex */ ae_vector* signal,
666  ae_int_t n,
667  /* Complex */ ae_vector* pattern,
668  ae_int_t m,
669  /* Complex */ ae_vector* r,
670  ae_state *_state);
671 void corrc1dcircular(/* Complex */ ae_vector* signal,
672  ae_int_t m,
673  /* Complex */ ae_vector* pattern,
674  ae_int_t n,
675  /* Complex */ ae_vector* c,
676  ae_state *_state);
677 void corrr1d(/* Real */ ae_vector* signal,
678  ae_int_t n,
679  /* Real */ ae_vector* pattern,
680  ae_int_t m,
681  /* Real */ ae_vector* r,
682  ae_state *_state);
683 void corrr1dcircular(/* Real */ ae_vector* signal,
684  ae_int_t m,
685  /* Real */ ae_vector* pattern,
686  ae_int_t n,
687  /* Real */ ae_vector* c,
688  ae_state *_state);
689 
690 }
691 #endif
692 
alglib::convc1dcircular
void convc1dcircular(const complex_1d_array &s, const ae_int_t m, const complex_1d_array &r, const ae_int_t n, complex_1d_array &c)
alglib_impl::fftr1dinv
void fftr1dinv(ae_vector *f, ae_int_t n, ae_vector *a, ae_state *_state)
alglib_impl::convr1dx
void convr1dx(ae_vector *a, ae_int_t m, ae_vector *b, ae_int_t n, ae_bool circular, ae_int_t alg, ae_int_t q, ae_vector *r, ae_state *_state)
alglib_impl::convc1dinv
void convc1dinv(ae_vector *a, ae_int_t m, ae_vector *b, ae_int_t n, ae_vector *r, ae_state *_state)
alglib_impl::fhtr1dinv
void fhtr1dinv(ae_vector *a, ae_int_t n, ae_state *_state)
alglib::complex_1d_array
Definition: ap.h:1254
alglib::corrc1dcircular
void corrc1dcircular(const complex_1d_array &signal, const ae_int_t m, const complex_1d_array &pattern, const ae_int_t n, complex_1d_array &c)
alglib::fftr1d
void fftr1d(const real_1d_array &a, const ae_int_t n, complex_1d_array &f)
alglib_impl::convr1dcircularinv
void convr1dcircularinv(ae_vector *a, ae_int_t m, ae_vector *b, ae_int_t n, ae_vector *r, ae_state *_state)
alglib_impl::fftr1d
void fftr1d(ae_vector *a, ae_int_t n, ae_vector *f, ae_state *_state)
alglib_impl::convr1d
void convr1d(ae_vector *a, ae_int_t m, ae_vector *b, ae_int_t n, ae_vector *r, ae_state *_state)
alglib::fhtr1dinv
void fhtr1dinv(real_1d_array &a, const ae_int_t n)
alglib_impl::convr1dinv
void convr1dinv(ae_vector *a, ae_int_t m, ae_vector *b, ae_int_t n, ae_vector *r, ae_state *_state)
alglib_impl::convr1dcircular
void convr1dcircular(ae_vector *s, ae_int_t m, ae_vector *r, ae_int_t n, ae_vector *c, ae_state *_state)
alglib_impl::corrc1dcircular
void corrc1dcircular(ae_vector *signal, ae_int_t m, ae_vector *pattern, ae_int_t n, ae_vector *c, ae_state *_state)
alglib::fhtr1d
void fhtr1d(real_1d_array &a, const ae_int_t n)
alglib_impl::convc1dx
void convc1dx(ae_vector *a, ae_int_t m, ae_vector *b, ae_int_t n, ae_bool circular, ae_int_t alg, ae_int_t q, ae_vector *r, ae_state *_state)
alglib::convr1dcircularinv
void convr1dcircularinv(const real_1d_array &a, const ae_int_t m, const real_1d_array &b, const ae_int_t n, real_1d_array &r)
alglib::convr1d
void convr1d(const real_1d_array &a, const ae_int_t m, const real_1d_array &b, const ae_int_t n, real_1d_array &r)
ae_bool
#define ae_bool
Definition: ap.h:193
alglib::corrc1d
void corrc1d(const complex_1d_array &signal, const ae_int_t n, const complex_1d_array &pattern, const ae_int_t m, complex_1d_array &r)
alglib_impl::fftr1dinternaleven
void fftr1dinternaleven(ae_vector *a, ae_int_t n, ae_vector *buf, fasttransformplan *plan, ae_state *_state)
alglib_impl::fasttransformplan
Definition: alglibinternal.h:160
alglib::convc1dcircularinv
void convc1dcircularinv(const complex_1d_array &a, const ae_int_t m, const complex_1d_array &b, const ae_int_t n, complex_1d_array &r)
alglib_impl::ae_state
Definition: ap.h:347
alglib_impl
Definition: alglibinternal.h:31
alglib::convr1dinv
void convr1dinv(const real_1d_array &a, const ae_int_t m, const real_1d_array &b, const ae_int_t n, real_1d_array &r)
alglib::fftr1dinv
void fftr1dinv(const complex_1d_array &f, const ae_int_t n, real_1d_array &a)
alglib_impl::fftc1dinv
void fftc1dinv(ae_vector *a, ae_int_t n, ae_state *_state)
alglib::convr1dcircular
void convr1dcircular(const real_1d_array &s, const ae_int_t m, const real_1d_array &r, const ae_int_t n, real_1d_array &c)
alglib_impl::convc1dcircular
void convc1dcircular(ae_vector *s, ae_int_t m, ae_vector *r, ae_int_t n, ae_vector *c, ae_state *_state)
alglib::fftc1dinv
void fftc1dinv(complex_1d_array &a, const ae_int_t n)
alglib_impl::fftr1dinvinternaleven
void fftr1dinvinternaleven(ae_vector *a, ae_int_t n, ae_vector *buf, fasttransformplan *plan, ae_state *_state)
alglib_impl::fhtr1d
void fhtr1d(ae_vector *a, ae_int_t n, ae_state *_state)
alglib::convc1d
void convc1d(const complex_1d_array &a, const ae_int_t m, const complex_1d_array &b, const ae_int_t n, complex_1d_array &r)
alglib::fftc1d
void fftc1d(complex_1d_array &a, const ae_int_t n)
alglib::ae_int_t
alglib_impl::ae_int_t ae_int_t
Definition: ap.h:965
alglib::corrr1dcircular
void corrr1dcircular(const real_1d_array &signal, const ae_int_t m, const real_1d_array &pattern, const ae_int_t n, real_1d_array &c)
alglib_impl::convc1dcircularinv
void convc1dcircularinv(ae_vector *a, ae_int_t m, ae_vector *b, ae_int_t n, ae_vector *r, ae_state *_state)
alglib::convc1dinv
void convc1dinv(const complex_1d_array &a, const ae_int_t m, const complex_1d_array &b, const ae_int_t n, complex_1d_array &r)
alglib::corrr1d
void corrr1d(const real_1d_array &signal, const ae_int_t n, const real_1d_array &pattern, const ae_int_t m, real_1d_array &r)
alglib_impl::corrc1d
void corrc1d(ae_vector *signal, ae_int_t n, ae_vector *pattern, ae_int_t m, ae_vector *r, ae_state *_state)
alglib_impl::ae_vector
Definition: ap.h:469
alglib_impl::convc1d
void convc1d(ae_vector *a, ae_int_t m, ae_vector *b, ae_int_t n, ae_vector *r, ae_state *_state)
alglib_impl::fftc1d
void fftc1d(ae_vector *a, ae_int_t n, ae_state *_state)
alglib_impl::corrr1d
void corrr1d(ae_vector *signal, ae_int_t n, ae_vector *pattern, ae_int_t m, ae_vector *r, ae_state *_state)
alglib_impl::ae_int_t
ptrdiff_t ae_int_t
Definition: ap.h:185
alglib::real_1d_array
Definition: ap.h:1231
alglib_impl::corrr1dcircular
void corrr1dcircular(ae_vector *signal, ae_int_t m, ae_vector *pattern, ae_int_t n, ae_vector *c, ae_state *_state)
Page URL: http://wiki.math.ethz.ch/bin/view/Concepts/WebHome
21 August 2020
© 2020 Eidgenössische Technische Hochschule Zürich