// -*- C++ -*-

// ===== FUNCTIONS declared in include/fxt.h: =====
// ... matching "slow"



// ----- SRCFILE=slow/slowht.cc: -----
void slow_ht(double *f, ulong n);
// (slow) hartley transform

// ----- SRCFILE=slow/slowtwodimht.cc: -----
void slow_twodim_ht(double *f, ulong r, ulong c);
// slow 2dim hartley transform

// ----- SRCFILE=slow/slowrowcolht.cc: -----
void slow_row_column_ht(double *f, ulong r, ulong c);

// ----- SRCFILE=slow/slowtwodimft.cc: -----
void slow_twodim_ft(double *fr, double *fi, ulong r, ulong c, int is);

// ----- SRCFILE=slow/slowcnvl.cc: -----
void slow_convolution(const double *f, const double *g, double *r, ulong nu);
// _cyclic_ convolution
// result in g

void slow_convolution0(const double *f, const double *g, double *r, ulong nu);
// linear convolution
// (zero padded data expected)

void slow_auto_convolution(const double *f, double *r, ulong nu);
// _cyclic_ self-convolution

void slow_auto_convolution0(const double *f, double *r, ulong nu);
// linear self-convolution
// (zero padded data expected)

// ----- SRCFILE=slow/slowtwodimcnvl.cc: -----
void slow_twodim_convolution(const double *f, double *g, ulong ru, ulong cu);
// _cyclic_ convolution
// result in g

// ----- SRCFILE=slow/slowcorr.cc: -----
void slow_correlation(const double *f, double *g, ulong nu);
// _cyclic_ correlation
// (use zero padded data for usual co.)
// result in g

void slow_correlation0(const double *f, double *g, ulong nu);
// correlation
// (expects zero padded data)
// result in g

void slow_auto_correlation(double *f, ulong nu);
// _cyclic_ self-correlation

void slow_auto_correlation0(double *f, ulong nu);
// _cyclic_ self-correlation
// (expects zero padded data)

// ----- SRCFILE=slow/slowcocorr.cc: -----
void slow_complex_correlation(const double *wr, const double *wi,
                         double *fr, double *fi, ulong nu);
// _cyclic_ correlation
// (use zero padded data for usual co.)
// result in fr,fi

void slow_complex_auto_correlation(double *fr, double *fi, ulong nu);
// _cyclic_ self-correlation
// (use zero padded data for usual co.)

// ----- SRCFILE=slow/slowcocnvl.cc: -----
void slow_convolution(const Complex *w , Complex *f, ulong nu);
// _cyclic_ convolution
// (use zero padded data for usual co.)
// result in f

void slow_complex_convolution(const double *wr, const double *wi,
                         double *fr, double *fi, ulong nu);
// _cyclic_ convolution
// (use zero padded data for usual co.)
// result in fr,fi

void slow_complex_auto_convolution(double *fr, double *fi, ulong nu);
// _cyclic_ self-convolution
// (use zero padded data for usual co.)

void slow_auto_convolution(Complex *f, ulong nu);
// _cyclic_ self-convolution
// (use zero padded data for usual co.)

// ----- SRCFILE=slow/slowft.cc: -----
void slow_ft(double *fr, double *fi, ulong n, int is);
// (slow) fourier transform

void slow_rotated_ft(double *fr, double *fi, ulong n, int is, int r);
// (slow) rotated fourier transform

void slow_ft(Complex *f, long n, int is);
// (slow) fourier transform

// ----- SRCFILE=slow/slowfracft.cc: -----
void slow_fract_ft(double *fr, double *fi, ulong n, double v);
// (slow) fractional fourier transform
// (for v=+-1 this is the usual fourier transform)

void slow_fract_ft(Complex *f, ulong n, double v);
// (slow) fractional fourier transform
// (for v=+-1 this is the usual fourier transform)

// ----- SRCFILE=slow/slowwalsh.cc: -----
void dit2_walsh_wak_slow(double *f, ulong ldn);
// transform wrt. to walsh-kronecker basis (wak-functions)
// same result as dit2_walsh_wak() but the loops
//  with loop variables j and r are swapped (as in ffts)
// ==> nonlocal ==> SLOW!

void dif2_walsh_wak_slow(double *f, ulong ldn);
// transform wrt. to walsh-kronecker basis (wak-functions)
// same result as dif2_walsh_wak() but the loops
//  with loop variables j and r are swapped (as in ffts)
// ==> nonlocal ==> SLOW!

// ----- SRCFILE=slow/slowzt.cc: -----
void slow_zt(double *f, ulong n, double z);
// (slow) z-transform

