// -*- 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);