You are here: Concepts>Concepts Web>Class documentation

Class documentation of Concepts

Loading...
Searching...
No Matches
fasttransforms.h
1/*************************************************************************
2ALGLIB 3.11.0 (source code generated 2017-05-11)
3Copyright (c) Sergey Bochkanov (ALGLIB project).
4
5>>> SOURCE LICENSE >>>
6This program is free software; you can redistribute it and/or modify
7it under the terms of the GNU General Public License as published by
8the Free Software Foundation (www.fsf.org); either version 2 of the
9License, or (at your option) any later version.
10
11This program is distributed in the hope that it will be useful,
12but WITHOUT ANY WARRANTY; without even the implied warranty of
13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14GNU General Public License for more details.
15
16A copy of the GNU General Public License is available at
17http://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//
30namespace alglib_impl
31{
32
33}
34
36//
37// THIS SECTION CONTAINS C++ INTERFACE
38//
40namespace alglib
41{
42
43
44/*************************************************************************
451-dimensional complex FFT.
46
47Array size N may be arbitrary number (composite or prime). Composite N's
48are handled with cache-oblivious variation of a Cooley-Tukey algorithm.
49Small prime-factors are transformed using hard coded codelets (similar to
50FFTW codelets, but without low-level optimization), large prime-factors
51are handled with Bluestein's algorithm.
52
53Fastests transforms are for smooth N's (prime factors are 2, 3, 5 only),
54most fast for powers of 2. When N have prime factors larger than these,
55but orders of magnitude smaller than N, computations will be about 4 times
56slower than for nearby highly composite N's. When N itself is prime, speed
57will be 6 times lower.
58
59Algorithm has O(N*logN) complexity for any N (composite or prime).
60
61INPUT PARAMETERS
62 A - array[0..N-1] - complex function to be transformed
63 N - problem size
64
65OUTPUT 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*************************************************************************/
73void fftc1d(complex_1d_array &a, const ae_int_t n);
74void fftc1d(complex_1d_array &a);
75
76
77/*************************************************************************
781-dimensional complex inverse FFT.
79
80Array size N may be arbitrary number (composite or prime). Algorithm has
81O(N*logN) complexity for any N (composite or prime).
82
83See FFTC1D() description for more information about algorithm performance.
84
85INPUT PARAMETERS
86 A - array[0..N-1] - complex array to be transformed
87 N - problem size
88
89OUTPUT 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*************************************************************************/
97void fftc1dinv(complex_1d_array &a, const ae_int_t n);
98void fftc1dinv(complex_1d_array &a);
99
100
101/*************************************************************************
1021-dimensional real FFT.
103
104Algorithm has O(N*logN) complexity for any N (composite or prime).
105
106INPUT PARAMETERS
107 A - array[0..N-1] - real function to be transformed
108 N - problem size
109
110OUTPUT 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
114NOTE:
115 F[] satisfies symmetry property F[k] = conj(F[N-k]), so just one half
116of array is usually needed. But for convinience subroutine returns full
117complex array (with frequencies above N/2), so its result may be used by
118other FFT-related subroutines.
119
120
121 -- ALGLIB --
122 Copyright 01.06.2009 by Bochkanov Sergey
123*************************************************************************/
124void fftr1d(const real_1d_array &a, const ae_int_t n, complex_1d_array &f);
125void fftr1d(const real_1d_array &a, complex_1d_array &f);
126
127
128/*************************************************************************
1291-dimensional real inverse FFT.
130
131Algorithm has O(N*logN) complexity for any N (composite or prime).
132
133INPUT PARAMETERS
134 F - array[0..floor(N/2)] - frequencies from forward real FFT
135 N - problem size
136
137OUTPUT PARAMETERS
138 A - inverse DFT of a input array, array[0..N-1]
139
140NOTE:
141 F[] should satisfy symmetry property F[k] = conj(F[N-k]), so just one
142half of frequencies array is needed - elements from 0 to floor(N/2). F[0]
143is ALWAYS real. If N is even F[floor(N/2)] is real too. If N is odd, then
144F[floor(N/2)] has no special properties.
145
146Relying on properties noted above, FFTR1DInv subroutine uses only elements
147from 0th to floor(N/2)-th. It ignores imaginary part of F[0], and in case
148N is even it ignores imaginary part of F[floor(N/2)] too.
149
150When 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
152array with roughly N/2 elements - subroutine will successfully transform
153both.
154
155If 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
157not used) because array size is used to automatically determine FFT length
158
159
160 -- ALGLIB --
161 Copyright 01.06.2009 by Bochkanov Sergey
162*************************************************************************/
163void fftr1dinv(const complex_1d_array &f, const ae_int_t n, real_1d_array &a);
164void fftr1dinv(const complex_1d_array &f, real_1d_array &a);
165
166/*************************************************************************
1671-dimensional Fast Hartley Transform.
168
169Algorithm has O(N*logN) complexity for any N (composite or prime).
170
171INPUT PARAMETERS
172 A - array[0..N-1] - real function to be transformed
173 N - problem size
174
175OUTPUT 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*************************************************************************/
183void fhtr1d(real_1d_array &a, const ae_int_t n);
184
185
186/*************************************************************************
1871-dimensional inverse FHT.
188
189Algorithm has O(N*logN) complexity for any N (composite or prime).
190
191INPUT PARAMETERS
192 A - array[0..N-1] - complex array to be transformed
193 N - problem size
194
195OUTPUT 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*************************************************************************/
202void fhtr1dinv(real_1d_array &a, const ae_int_t n);
203
204/*************************************************************************
2051-dimensional complex convolution.
206
207For given A/B returns conv(A,B) (non-circular). Subroutine can automatically
208choose between three implementations: straightforward O(M*N) formula for
209very small N (or M), overlap-add algorithm for cases where max(M,N) is
210significantly larger than min(M,N), but O(M*N) algorithm is too slow, and
211general FFT-based formula for cases where two previois algorithms are too
212slow.
213
214Algorithm has max(M,N)*log(max(M,N)) complexity for any M/N.
215
216INPUT 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
222OUTPUT PARAMETERS
223 R - convolution: A*B. array[0..N+M-2].
224
225NOTE:
226 It is assumed that A is zero at T<0, B is zero too. If one or both
227functions have non-zero values at negative T's, you can still use this
228subroutine - just shift its result correspondingly.
229
230 -- ALGLIB --
231 Copyright 21.07.2009 by Bochkanov Sergey
232*************************************************************************/
233void 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/*************************************************************************
2371-dimensional complex non-circular deconvolution (inverse of ConvC1D()).
238
239Algorithm has M*log(M)) complexity for any M (composite or prime).
240
241INPUT 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
247OUTPUT PARAMETERS
248 R - deconvolved signal. array[0..M-N].
249
250NOTE:
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
254NOTE:
255 It is assumed that A is zero at T<0, B is zero too. If one or both
256functions have non-zero values at negative T's, you can still use this
257subroutine - just shift its result correspondingly.
258
259 -- ALGLIB --
260 Copyright 21.07.2009 by Bochkanov Sergey
261*************************************************************************/
262void 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/*************************************************************************
2661-dimensional circular complex convolution.
267
268For given S/R returns conv(S,R) (circular). Algorithm has linearithmic
269complexity for any M/N.
270
271IMPORTANT: normal convolution is commutative, i.e. it is symmetric -
272conv(A,B)=conv(B,A). Cyclic convolution IS NOT. One function - S - is a
273signal, periodic function, and another - R - is a response, non-periodic
274function with limited length.
275
276INPUT 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
282OUTPUT PARAMETERS
283 R - convolution: A*B. array[0..M-1].
284
285NOTE:
286 It is assumed that B is zero at T<0. If it has non-zero values at
287negative T's, you can still use this subroutine - just shift its result
288correspondingly.
289
290 -- ALGLIB --
291 Copyright 21.07.2009 by Bochkanov Sergey
292*************************************************************************/
293void 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/*************************************************************************
2971-dimensional circular complex deconvolution (inverse of ConvC1DCircular()).
298
299Algorithm has M*log(M)) complexity for any M (composite or prime).
300
301INPUT 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
307OUTPUT PARAMETERS
308 R - deconvolved signal. array[0..M-1].
309
310NOTE:
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
314NOTE:
315 It is assumed that B is zero at T<0. If it has non-zero values at
316negative T's, you can still use this subroutine - just shift its result
317correspondingly.
318
319 -- ALGLIB --
320 Copyright 21.07.2009 by Bochkanov Sergey
321*************************************************************************/
322void 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/*************************************************************************
3261-dimensional real convolution.
327
328Analogous to ConvC1D(), see ConvC1D() comments for more details.
329
330INPUT 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
336OUTPUT PARAMETERS
337 R - convolution: A*B. array[0..N+M-2].
338
339NOTE:
340 It is assumed that A is zero at T<0, B is zero too. If one or both
341functions have non-zero values at negative T's, you can still use this
342subroutine - just shift its result correspondingly.
343
344 -- ALGLIB --
345 Copyright 21.07.2009 by Bochkanov Sergey
346*************************************************************************/
347void 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/*************************************************************************
3511-dimensional real deconvolution (inverse of ConvC1D()).
352
353Algorithm has M*log(M)) complexity for any M (composite or prime).
354
355INPUT 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
361OUTPUT PARAMETERS
362 R - deconvolved signal. array[0..M-N].
363
364NOTE:
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
368NOTE:
369 It is assumed that A is zero at T<0, B is zero too. If one or both
370functions have non-zero values at negative T's, you can still use this
371subroutine - just shift its result correspondingly.
372
373 -- ALGLIB --
374 Copyright 21.07.2009 by Bochkanov Sergey
375*************************************************************************/
376void 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/*************************************************************************
3801-dimensional circular real convolution.
381
382Analogous to ConvC1DCircular(), see ConvC1DCircular() comments for more details.
383
384INPUT 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
390OUTPUT PARAMETERS
391 R - convolution: A*B. array[0..M-1].
392
393NOTE:
394 It is assumed that B is zero at T<0. If it has non-zero values at
395negative T's, you can still use this subroutine - just shift its result
396correspondingly.
397
398 -- ALGLIB --
399 Copyright 21.07.2009 by Bochkanov Sergey
400*************************************************************************/
401void 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/*************************************************************************
4051-dimensional complex deconvolution (inverse of ConvC1D()).
406
407Algorithm has M*log(M)) complexity for any M (composite or prime).
408
409INPUT 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
415OUTPUT PARAMETERS
416 R - deconvolved signal. array[0..M-N].
417
418NOTE:
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
422NOTE:
423 It is assumed that B is zero at T<0. If it has non-zero values at
424negative T's, you can still use this subroutine - just shift its result
425correspondingly.
426
427 -- ALGLIB --
428 Copyright 21.07.2009 by Bochkanov Sergey
429*************************************************************************/
430void 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/*************************************************************************
4331-dimensional complex cross-correlation.
434
435For given Pattern/Signal returns corr(Pattern,Signal) (non-circular).
436
437Correlation is calculated using reduction to convolution. Algorithm with
438max(N,N)*log(max(N,N)) complexity is used (see ConvC1D() for more info
439about performance).
440
441IMPORTANT:
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
446INPUT 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
454OUTPUT 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
461NOTE:
462 It is assumed that pattern domain is [0..M-1]. If Pattern is non-zero
463on [-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*************************************************************************/
468void 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/*************************************************************************
4721-dimensional circular complex cross-correlation.
473
474For given Pattern/Signal returns corr(Pattern,Signal) (circular).
475Algorithm has linearithmic complexity for any M/N.
476
477IMPORTANT:
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
483INPUT 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
491OUTPUT PARAMETERS
492 R - convolution: A*B. array[0..M-1].
493
494
495 -- ALGLIB --
496 Copyright 21.07.2009 by Bochkanov Sergey
497*************************************************************************/
498void 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/*************************************************************************
5021-dimensional real cross-correlation.
503
504For given Pattern/Signal returns corr(Pattern,Signal) (non-circular).
505
506Correlation is calculated using reduction to convolution. Algorithm with
507max(N,N)*log(max(N,N)) complexity is used (see ConvC1D() for more info
508about performance).
509
510IMPORTANT:
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
515INPUT 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
523OUTPUT 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
530NOTE:
531 It is assumed that pattern domain is [0..M-1]. If Pattern is non-zero
532on [-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*************************************************************************/
537void 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/*************************************************************************
5411-dimensional circular real cross-correlation.
542
543For given Pattern/Signal returns corr(Pattern,Signal) (circular).
544Algorithm has linearithmic complexity for any M/N.
545
546IMPORTANT:
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
552INPUT 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
560OUTPUT PARAMETERS
561 R - convolution: A*B. array[0..M-1].
562
563
564 -- ALGLIB --
565 Copyright 21.07.2009 by Bochkanov Sergey
566*************************************************************************/
567void 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//
575namespace alglib_impl
576{
577void fftc1d(/* Complex */ ae_vector* a, ae_int_t n, ae_state *_state);
578void fftc1dinv(/* Complex */ ae_vector* a, ae_int_t n, ae_state *_state);
579void fftr1d(/* Real */ ae_vector* a,
580 ae_int_t n,
581 /* Complex */ ae_vector* f,
582 ae_state *_state);
583void fftr1dinv(/* Complex */ ae_vector* f,
584 ae_int_t n,
585 /* Real */ ae_vector* a,
586 ae_state *_state);
587void fftr1dinternaleven(/* Real */ ae_vector* a,
588 ae_int_t n,
589 /* Real */ ae_vector* buf,
590 fasttransformplan* plan,
591 ae_state *_state);
592void fftr1dinvinternaleven(/* Real */ ae_vector* a,
593 ae_int_t n,
594 /* Real */ ae_vector* buf,
595 fasttransformplan* plan,
596 ae_state *_state);
597void fhtr1d(/* Real */ ae_vector* a, ae_int_t n, ae_state *_state);
598void fhtr1dinv(/* Real */ ae_vector* a, ae_int_t n, ae_state *_state);
599void 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);
605void 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);
611void 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);
617void 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);
623void 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);
629void 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);
635void 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);
641void 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);
647void 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);
656void 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);
665void 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);
671void 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);
677void 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);
683void 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
Generated on Wed Sep 13 2023 21:06:16 for Concepts by doxygen 1.9.8