//private function
void Filters::convolve(double *x, int m, double *y, int n, double *xy)
{
ap::real_1d_array input_vector_x;
input_vector_x.setlength(m);
ap::real_1d_array input_vector_y;
input_vector_y.setlength(n);
ap::real_1d_array output_vector_xy;
output_vector_xy.setlength(n+m-1);
int i;
for(i = 0; i < m; ++i)
{
input_vector_x(i) = x[i];
}
for(i = 0; i < n; ++i)
{
input_vector_y(i) = y[i];
}
convr1d(input_vector_x, m, input_vector_y,n, output_vector_xy);
for(i = 0; i < m+n-1; ++i)
{
xy[i]=output_vector_xy(i);
}
}
/*************************************************************************
1-dimensional real cross-correlation.
For given Pattern/Signal returns corr(Pattern,Signal) (non-circular).
Correlation is calculated using reduction to convolution. Algorithm with
max(N,N)*log(max(N,N)) complexity is used (see ConvC1D() for more info
about performance).
IMPORTANT:
for historical reasons subroutine accepts its parameters in reversed
order: CorrR1D(Signal, Pattern) = Pattern x Signal (using traditional
definition of cross-correlation, denoting cross-correlation as "x").
INPUT PARAMETERS
Signal - array[0..N-1] - real function to be transformed,
signal containing pattern
N - problem size
Pattern - array[0..M-1] - real function to be transformed,
pattern to search withing signal
M - problem size
OUTPUT PARAMETERS
R - cross-correlation, array[0..N+M-2]:
* positive lags are stored in R[0..N-1],
R[i] = sum(pattern[j]*signal[i+j]
* negative lags are stored in R[N..N+M-2],
R[N+M-1-i] = sum(pattern[j]*signal[-i+j]
NOTE:
It is assumed that pattern domain is [0..M-1]. If Pattern is non-zero
on [-K..M-1], you can still use this subroutine, just shift result by K.
-- ALGLIB --
Copyright 21.07.2009 by Bochkanov Sergey
*************************************************************************/
void corrr1d(const ap::real_1d_array& signal,
int n,
const ap::real_1d_array& pattern,
int m,
ap::real_1d_array& r)
{
ap::real_1d_array p;
ap::real_1d_array b;
int i;
ap::ap_error::make_assertion(n>0&&m>0, "CorrR1D: incorrect N or M!");
p.setlength(m);
for(i = 0; i <= m-1; i++)
{
p(m-1-i) = pattern(i);
}
convr1d(p, m, signal, n, b);
r.setlength(m+n-1);
ap::vmove(&r(0), &b(m-1), ap::vlen(0,n-1));
if( m+n-2>=n )
{
ap::vmove(&r(n), &b(0), ap::vlen(n,m+n-2));
}
}
