// -*- C++ -*-

// automatically generated by autodoc

// ========== HEADER FILE src/dctdst/dctdst.h: ==========

// cosine and sine transforms

// ----- SRCFILE=src/dctdst/cosrot.cc: -----
void cos_rot(const double *x, double *y, ulong n); // aux
// Auxiliary routine for dcth() and dct4()
// x and y may be identical
// Self-inverse.

// ----- SRCFILE=src/dctdst/dcth.cc: -----

void dcth(double *x, ulong ldn, double *tmp/*=nullptr*/);
// transform wrt. basis:
// cos( 2*Pi * 0.5 * k * (i+0.5)/n ) * (k==0?1.0:sqrt(2))
// where k is the index of the basis
// the basis:
// 0: [* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *] ( 0)
// 1: [* * * * * * * * * * * * * * * * ] ( 1)
// 2: [* * * * * * * * * * * * * * * *] ( 2)
// 3: [* * * * * * * * * * * * * * * * ] ( 3)
// 4: [* * * * * * * * * * * * * * * *] ( 4)
// 5: [* * * * * * * * * * * * * * * * ] ( 5)
// 6: [* * * * * * * * * * * * * * * *] ( 6)
// 7: [* * * * * * * * * * * * * * * * ] ( 7)
// 8: [* * * * * * * * * * * * * * * *] ( 8)
// 9: [* * * * * * * * * * * * * * * * ] ( 9)
// 10: [* * * * * * * * * * * * * * * *] (10)
// 11: [* * * * * * * * * * * * * * * * ] (11)
// 12: [* * * * * * * * * * * * * * * *] (12)
// 13: [* * * * * * * * * * * * * * * * ] (13)
// 14: [* * * * * * * * * * * * * * * *] (14)
// 15: [* * * * * * * * * * * * * * * * ] (15)
// 16: [* * * * * * * * * * * * * * * *] (16)
// 17: [* * * * * * * * * * * * * * * * ] (17)
// 18: [* * * * * * * * * * * * * * * *] (18)
// 19: [* * * * * * * * * * * * * * * * ] (19)
// 20: [* * * * * * * * * * * * * * * *] (20)
// 21: [* * * * * * * * * * * * * * * * ] (21)
// 22: [* * * * * * * * * * * * * * * *] (22)
// 23: [* * * * * * * * * * * * * * * * ] (23)
// 24: [* * * * * * * * * * * * * * * *] (24)
// 25: [* * * * * * * * * * * * * * * * ] (25)
// 26: [* * * * * * * * * * * * * * * *] (26)
// 27: [* * * * * * * * * * * * * * * * ] (27)
// 28: [* * * * * * * * * * * * * * * *] (28)
// 29: [* * * * * * * * * * * * * * * * ] (29)
// 30: [* * * * * * * * * * * * * * * *] (30)
// 31: [* * * * * * * * * * * * * * * * ] (31)
// H.Malvars algorithm: dct by fht
// ldn := base-2 logarithm of the array length
// tmp := (optional) pointer to scratch space
// if a (size-n) srcatch space is supplied (tmp!=0)
// then the slightly faster version of unzip_rev is used

void idcth(double *x, ulong ldn, double *tmp/*=nullptr*/);

// inverse transform wrt. basis: cos(k*(i+0.5)*PI/n) * (k==0?1.0:sqrt(2))
// H.Malvars algorithm: idct by fht
// if a (size-n) srcatch space is supplied (tmp!=0)
// then the slightly faster version of zip_rev is used

void dcth_basis(double *f, ulong n, ulong k);

// ----- SRCFILE=src/dctdst/dctzapata.cc: -----

static void coseno(double *x, ulong ldn);
// Auxiliary routine called by dct_zapata().
// Input:
// x[k] = \sum_{m=0}^{n-1}{ \prod_{i=0}^{ldn-1}{ 2^{b_i} \cos(b_i 2^i \Theta_m)
x(m)} }
// where n=2^ldn, \Theta_m=\pi (1+4m)/(2n)
// and b_i is bit #i of k
// Output:
// x[k] = \sum_{m=0}^{n-1}{ \cos(\Theta_m) x(m)}

void dcth_zapata(double *x, ulong ldn, double *tmp/*=nullptr*/);

// Transform wrt. basis: cos(k*(i+0.5)*PI/n) * (k==0?1.0:sqrt(2))
// Algorithm as described in F.Arguello, E.L.Zapata:
// "Fast Cosine Transform on the Successive Doubling Method"
// If a (size-n) srcatch space is supplied (tmp!=0)
// then the slightly faster version of unzip_rev() is used.
// Note the unzip_rev() step is not mentioned in the paper!

// ----- SRCFILE=src/dctdst/dct4.cc: -----

void dct4(double *f, ulong ldn);
// Cosine transform wrt. the basis
// cos( 2*Pi * 0.25 * (4*k + 1) * i / n )
// == cos( Pi * (2*k + 0.5) * i / n )
// where k is the index of the basis
// the basis:
// 0: [* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *] ( 0)
// 1: [* * * * * * * * * * * * * * * * * * *] ( 2)
// 2: [* * * * * * * * * * * * * * * * * *] ( 4)
// 3: [* * * * * * * * * * * * * * * * *] ( 6)
// 4: [* * * * * * * * * * * * * * * *] ( 8)
// 5: [* * * * * * * * * * * * * * * * *] (10)
// 6: [* * * * * * * * * * * * * * * *] (12)
// 7: [* * * * * * * * * * * * * * * * *] (14)
// 8: [* * * * * * * * * * * * * * * *] (16)
// 9: [* * * * * * * * * * * * * * * * *] (18)
// 10: [* * * * * * * * * * * * * * * *] (20)
// 11: [* * * * * * * * * * * * * * * * *] (22)
// 12: [* * * * * * * * * * * * * * * *] (24)
// 13: [* * * * * * * * * * * * * * * * *] (26)
// 14: [* * * * * * * * * * * * * * * * * *] (28)
// 15: [* * * * * * * * * * * * * * * * *] (30)
// 16: [* * * * * * * * * * * * * * * * ] (31)
// 17: [* * * * * * * * * * * * * * * * * ] (29)
// 18: [* * * * * * * * * * * * * * ] (27)
// 19: [* * * * * * * * * * * * * * * * * * * ] (25)
// 20: [* * * * * * * * * * * * * * * * ] (23)
// 21: [* * * * * * * * * * * ] (21)
// 22: [* * * * * * * * * * * * * * * * ] (19)
// 23: [* * * * * * * * * * * * * * * ] (17)
// 24: [* * * * * * * * * * * * * * * * ] (15)
// 25: [* * * * * * * * * * * * * * * ] (13)
// 26: [* * * * * * * * * * * * * * * * ] (11)
// 27: [* * * * * * * * * * * * * * * ] ( 9)
// 28: [* * * * * * * * * * * * * * * * ] ( 7)
// 29: [* * * * * * * * * * * * * * * ] ( 5)
// 30: [* * * * * * * * * * * * * * ] ( 3)
// 31: [* * * * * * * * * * * ] ( 1)
// The mean value of all basis functions is nonzero
// therefore the DC part has to be treated separately

void idct4(double *f, ulong ldn);

// Inverse of dct4()
// ... which is a transform wrt. the basis
// cos( Pi * k * (2*i+0.5) / n )
// where k is the index of the basis

void dct4_basis(double *f, ulong n, ulong k);

// ----- SRCFILE=src/dctdst/dst.cc: -----

void dst(double *f, ulong ldn, double *tmp/*=nullptr*/);
// basis: sin(k*i*M_PI/n)
// almost self-inverse: dst(dst(f[])) = 0.5*f[]
// ldn := base-2 logarithm of the array length
// tmp := (optional) pointer to scratch space
// the basis:
// 0: [* ] ( 1)
// 1: [ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *] ( 2)
// 2: [ * * * * * * * * * * * * * * * ] ( 3)
// 3: [ * * * * * * * * * * * * * * * * * * * *] ( 4)
// 4: [ * * * * * * * * * * * * * * ] ( 5)
// 5: [ * * * * * * * * * * * * * * * * * * *] ( 6)
// 6: [ * * * * * * * * * * * * * * * ] ( 7)
// 7: [ * * * * * * * * * * * * * * * *] ( 8)
// 8: [ * * * * * * * * * * * * ] ( 9)
// 9: [ * * * * * * * * * * * * * * *] (10)
// 10: [ * * * * * * * * * * * * * * * ] (11)
// 11: [ * * * * * * * * * * * * * * * *] (12)
// 12: [ * * * * * * * * * * * * * * ] (13)
// 13: [ * * * * * * * * * * * * * * * * * * *] (14)
// 14: [ * * * * * * * * * * * * * * * ] (15)
// 15: [ * * * * * * * * * * * * * * * *] (16)
// 16: [ * * * * * * * * ] (17)
// 17: [ * * * * * * * * * * * * * * *] (18)
// 18: [ * * * * * * * * * * * * * * * ] (19)
// 19: [ * * * * * * * * * * * * * * * *] (20)
// 20: [ * * * * * * * * * * * * * * ] (21)
// 21: [ * * * * * * * * * * *] (22)
// 22: [ * * * * * * * * * * * * * * * ] (23)
// 23: [ * * * * * * * * * * * * * * * *] (24)
// 24: [ * * * * * * * * * * * * ] (25)
// 25: [ * * * * * * * * * * * * * * *] (26)
// 26: [ * * * * * * * * * * * * * * * ] (27)
// 27: [ * * * * * * * * * * * * * * * *] (28)
// 28: [ * * * * * * * * * * * * * * ] (29)
// 29: [ * * * * * * * * * * * * * * *] (30)
// 30: [ * * * * * * * * * * * * * * * ] (31)
// 31: [ * * * * * * * * * * * * * * * *] (32)

void dst_basis(double *f, ulong n, ulong k);

// ----- SRCFILE=src/dctdst/dsth.cc: -----

void dsth(double *x, ulong ldn, double *tmp/*=nullptr*/);
// Compute (discrete) sine transform (DST) with
// basis sin((k+1)*(i+0.5)*M_PI/n) * sqrt(2)
// ldn := base-2 logarithm of the array length
// tmp := (optional) pointer to scratch space
// the basis:
// 0: [* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *] ( 0)
// 1: [* * * * * * * * * * * * * * * * ] ( 1)
// 2: [* * * * * * * * * * * * * * * * * * * * * *] ( 2)
// 3: [* * * * * * * * * * * * * * * * ] ( 3)
// 4: [* * * * * * * * * * * * * * * * * *] ( 4)
// 5: [* * * * * * * * * * * * * * * * ] ( 5)
// 6: [* * * * * * * * * * * * * * * * * * * *] ( 6)
// 7: [* * * * * * * * * * * * * * * * ] ( 7)
// 8: [* * * * * * * * * * * * * * * * * * * *] ( 8)
// 9: [* * * * * * * * * * * * * * * * ] ( 9)
// 10: [* * * * * * * * * * * * * * * * * *] (10)
// 11: [* * * * * * * * * * * * * * * * ] (11)
// 12: [* * * * * * * * * * * * * *] (12)
// 13: [* * * * * * * * * * * * * * * * ] (13)
// 14: [* * * * * * * * * * * * * * * *] (14)
// 15: [* * * * * * * * * * * * * * * * ] (15)
// 16: [* * * * * * * * * * * * * * * *] (16)
// 17: [* * * * * * * * * * * * * * * * ] (17)
// 18: [* * * * * * * * * * * * * * * * * *] (18)
// 19: [* * * * * * * * * * * * * * * * ] (19)
// 20: [* * * * * * * * * * * * * * * * * * * * * *] (20)
// 21: [* * * * * * * * * * * * * * * * ] (21)
// 22: [* * * * * * * * * * * * * * * *] (22)
// 23: [* * * * * * * * * * * * * * * * ] (23)
// 24: [* * * * * * * * * * * * * * * *] (24)
// 25: [* * * * * * * * * * * * * * * * ] (25)
// 26: [* * * * * * * * * * * * * * * * * *] (26)
// 27: [* * * * * * * * * * * * * * * * ] (27)
// 28: [* * * * * * * * * * * * * * * * * *] (28)
// 29: [* * * * * * * * * * * * * * * * ] (29)
// 30: [* * * * * * * * * * * * * * * *] (30)
// 31: [* * * * * * * * * * * * * * * * ] (31)

void idsth(double *x, ulong ldn, double *tmp/*=nullptr*/);

// Inverse of dsth()
// ldn := base-2 logarithm of the array length
// tmp := (optional) pointer to scratch space

void dsth_basis(double *f, ulong n, ulong k);