Media Android

The remaining complex FFT coefficients can be obtained by the
     * symmetry relation: the (n-k)-th complex FFT coefficient is the
     * conjugate of n-th complex FFT coefficient.
     *
     * @param   x       An array which contains the sequence to be
     *                  transformed.
     */
    public void ft(double[] x) {
        if (x.length != ndim)
            throw new IllegalArgumentException("The length of data can not match that of the wavetable");
        rfftf(ndim, x, wavetable);
    }
    
    /**
     * Forward real FFT transform. It computes the discrete transform of a real data sequence.
     *
     * @param x an array which contains the sequence to be transformed. After FFT,
     * x contains the transform coeffients used to construct n complex FFT coeffients.
     * 

     * @param y the first complex (n+1)/2 (when n is odd) or (n/2+1) (when 
     * n is even) FFT coefficients.
     * The remaining complex FFT coefficients can be obtained by the symmetry relation:
     * the (n-k)-th complex FFT coefficient is the conjugate of n-th complex FFT coeffient.
     *
     */
    public void ft(double x[], Complex1D y) {
        if (x.length != ndim)
            throw new IllegalArgumentException("The length of data can not match that of the wavetable");
        rfftf(ndim, x, wavetable);
        if(ndim%2 == 0) 
        {
            y.x = new double[ndim/2 + 1];
            y.y = new double[ndim/2 + 1];
        }
        else
        {
            y.x = new double[(ndim+1)/2];
            y.y = new double[(ndim+1)/2];
        }
        y.x[0] = x[0];
        y.y[0] = 0.0D;
        for(int i=1; i<(ndim+1)/2; i++)
        {
            y.x[i] = x[2*i-1];
            y.y[i] = x[2*i];
        }
        if(ndim%2 == 0)
        {
            y.x[ndim/2] = x[ndim-1];
            y.y[ndim/2] = 0.0D;
        }
    }
    /**
     * Backward real FFT transform. It is the unnormalized inverse transform of ft(double[]).
     *
     * @param x an array which contains the sequence to be transformed. After FFT,
     * x contains the transform coeffients. Also see the comments of ft(double[])
     * for the relation between x and complex FFT coeffients.
     */
    public void bt(double x[])
    {
        if(x.length != ndim)
            throw new IllegalArgumentException("The length of data can not match that of the wavetable");
        rfftb(ndim, x, wavetable);
    }
    
    
    /**
     * Backward real FFT transform. It is the unnormalized inverse transform of ft(Complex1D, double[]).
     *
     * @param x  an array which contains the sequence to be transformed. When n is odd, it contains the first 
     * (n+1)/2 complex data; when n is even, it contains (n/2+1) complex data.
     * @param y  the real FFT coeffients.
     * 

     * Also see the comments of ft(double[]) for the relation
     * between x and complex FFT coeffients.
     */
    public void bt(Complex1D x, double y[])
    {
        if(ndim%2 == 0)
        {
            if(x.x.length != ndim/2+1)
                throw new IllegalArgumentException("The length of data can not match that of the wavetable");
        }
        else
        {
            if(x.x.length != (ndim+1)/2)
                throw new IllegalArgumentException("The length of data can not match that of the wavetable");
        }
        y[0] = x.x[0];
        for(int i=1; i<(ndim+1)/2; i++)
        {
            y[2*i-1]=x.x[i];
            y[2*i]=x.y[i];
        }
        if(ndim%2 == 0)
        {
            y[ndim-1]=x.x[ndim/2];
        }
        rfftb(ndim, y, wavetable);
    }
    
    /**
     * norm_factor can be used to normalize this FFT transform. This is because
     * a call of forward transform (ft) followed by a call of backward transform
     * (bt) will multiply the input sequence by norm_factor.
     */
    public double norm_factor;
    private double wavetable[];
    private int ndim;
}
package ca.uol.aig.fftpack;
/**
 * cosine FFT transform of a real even sequence.
 * @author Baoshe Zhang
 * @author Astronomical Instrument Group of University of Lethbridge.
 */
public class RealDoubleFFT_Even extends RealDoubleFFT_Mixed
{
    /**
     * norm_factor can be used to normalize this FFT transform. This is because
     * a call of forward transform (ft) followed by a call of backward transform
     * (bt) will multiply the input sequence by norm_factor.
     */
    public double norm_factor;
    private double wavetable[];
    private int ndim;
    /**
     * Construct a wavenumber table with size n.
     * The sequences with the same size can share a wavenumber table. The prime
     * factorization of n together with a tabulation of the trigonometric functions
     * are computed and stored.
     *
     * @param  n  the size of a real data sequence. When (n-1) is a multiplication of small
     * numbers (4, 2, 3, 5), this FFT transform is very efficient.
     */
    public RealDoubleFFT_Even(int n)
    {
        ndim = n;
        norm_factor = 2 * (n - 1);
        if (wavetable == null || wavetable.length != (3 * ndim + 15))
            wavetable = new double[3 * ndim + 15];
        costi(ndim, wavetable);
    }
    /**
     * Forward cosine FFT transform. It computes the discrete sine transform of
     * an odd sequence.
     *
     * @param x an array which contains the sequence to be transformed. After FFT,
     * x contains the transform coeffients.
     */
    public void ft(double[] x) {
        cost(ndim, x, wavetable);
    }
    /**
     * Backward cosine FFT transform. It is the unnormalized inverse transform of ft.
     *
     * @param x an array which contains the sequence to be transformed. After FFT,
     * x contains the transform coeffients.
     */
    public void bt(double[] x) {
        cost(ndim, x, wavetable);
    }
    /*-------------------------------------------------------------
   cost: cosine FFT. Backward and forward cos-FFT are the same.
  ------------------------------------------------------------*/
    void cost(int n, double x[], final double wtable[])
    {
        int     modn, i, k;
        double  c1, t1, t2;
        int     kc;
        double  xi;
        int     nm1;
        double  x1h;
        int     ns2;
        double  tx2, x1p3, xim2;
        nm1=n-1;
        ns2=n / 2;
        if(n-2<0) return;
        else if(n==2)
        {
            x1h=x[0]+x[1];
            x[1]=x[0]-x[1];
            x[0]=x1h;
        }
        else if(n==3)
        {
            x1p3=x[0]+x[2];
            tx2=x[1]+x[1];
            x[1]=x[0]-x[2];
            x[0]=x1p3+tx2;
            x[2]=x1p3-tx2;
        }
        else
        {
            c1=x[0]-x[n-1];
            x[0]+=x[n-1];
            for(k=1; k            {
                kc=nm1-k;
                t1=x[k]+x[kc];
                t2=x[k]-x[kc];
                c1+=wtable[kc]*t2;
                t2=wtable[k]*t2;
                x[k]=t1-t2;
                x[kc]=t1+t2;
            }
            modn=n%2;
            if(modn !=0) x[ns2]+=x[ns2];
            rfftf1(nm1, x, wtable, n);
            xim2=x[1];
            x[1]=c1;
            for(i=3; i            {
                xi=x[i];
                x[i]=x[i-2]-x[i-1];
                x[i-1]=xim2;
                xim2=xi;
            }
            if(modn !=0) x[n-1]=xim2;
        }
    } 
    /*----------------------------------
   costi: initialization of cos-FFT
  ---------------------------------*/
    void costi(int n, double wtable[])
    {
        final double pi=Math.PI; //3.14159265358979;
        int     k, kc, ns2;
        double  dt;
        if(n<=3) return;
        ns2=n / 2;
        dt=pi /(double)(n-1);
        for(k=1; k        {
            kc=n-k-1;
            wtable[k]=2*Math.sin(k*dt);
            wtable[kc]=2*Math.cos(k*dt);
        }
        rffti1(n-1, wtable, n);
    }
    
}
package ca.uol.aig.fftpack;
/**
 * cosine FFT transform with odd wave numbers.
 * @author Baoshe Zhang
 * @author Astronomical Instrument Group of University of Lethbridge.
 */
public class RealDoubleFFT_Even_Odd extends RealDoubleFFT_Mixed
{
    /**
     * norm_factor can be used to normalize this FFT transform. This is because
     * a call of forward transform (ft) followed by a call of backward transform 
     * (bt) will multiply the input sequence by norm_factor.
     */
    public double norm_factor;
    
    double wavetable[];
    int ndim;
    /**
     * Construct a wavenumber table with size n.
     * The sequences with the same size can share a wavenumber table. The prime
     * factorization of n together with a tabulation of the trigonometric functions
     * are computed and stored.
     *
     * @param  n  the size of a real data sequence. When n is a multiplication of small
     * numbers(4, 2, 3, 5), this FFT transform is very efficient.
     */
    public RealDoubleFFT_Even_Odd(int n) {
        ndim = n;
        norm_factor = 4*n;
        if(wavetable == null || wavetable.length !=(3*ndim+15))
        {
            wavetable = new double[3*ndim + 15];
        }
        cosqi(ndim, wavetable);
    }
    /**
     * Forward FFT transform of quarter wave data. It computes the coeffients in 
     * cosine series representation with only odd wave numbers.
     *
     * @param x an array which contains the sequence to be transformed. After FFT,
     * x contains the transform coeffients.
     */
    public void ft(double x[]) {
        cosqf(ndim, x, wavetable);
    }
    /**
     * Backward FFT transform of quarter wave data. It is the unnormalized inverse transform
     * of ft.
     *
     * @param x an array which contains the sequence to be tranformed. After FFT, x contains
     * the transform coeffients.
     */
    public void bt(double x[]) {
        cosqb(ndim, x, wavetable);
    }
    /*----------------------------------------------------------------------
   cosqf1: further processing of forward cos-FFT with odd wave numbers.
  ----------------------------------------------------------------------*/
    void cosqf1(int n, double x[], double wtable[])
    {
        int     modn, i, k;
        int     kc, ns2;
        double  xim1;
        ns2=(n+1)/ 2;
        for(k=1; k        {
            kc=n-k;
            wtable[k+n]=x[k]+x[kc];
            wtable[kc+n]=x[k]-x[kc];
        }
        modn=n%2;
        if(modn==0) wtable[ns2+n]=x[ns2]+x[ns2];
        for(k=1; k        {
            kc=n-k;
            x[k]=wtable[k-1]*wtable[kc+n]+wtable[kc-1]*wtable[k+n];
            x[kc]=wtable[k-1]*wtable[k+n]-wtable[kc-1]*wtable[kc+n];
        }
        if(modn==0) x[ns2]=wtable[ns2-1]*wtable[ns2+n];
        rfftf1(n, x, wtable, n);
        for(i=2; i        {
            xim1=x[i-1]-x[i];
            x[i]=x[i-1]+x[i];
            x[i-1]=xim1;
        }
    } 
    /*----------------------------------------------------------------------
   cosqb1: further processing of backward cos-FFT with odd wave numbers.
  ----------------------------------------------------------------------*/
    void cosqb1(int n, double x[], double wtable[])
    {
        int     modn, i, k;
        int     kc, ns2;
        double  xim1;
        ns2=(n+1)/ 2;
        for(i=2; i        {
            xim1=x[i-1]+x[i];
            x[i]-=x[i-1];
            x[i-1]=xim1;
        }
        x[0]+=x[0];
        modn=n%2;
        if(modn==0) x[n-1]+=x[n-1];
        rfftb1(n, x, wtable, n);
        for(k=1; k        {
            kc=n-k;
            wtable[k+n]=wtable[k-1]*x[kc]+wtable[kc-1]*x[k];
            wtable[kc+n]=wtable[k-1]*x[k]-wtable[kc-1]*x[kc];
        }
        if(modn==0) x[ns2]=wtable[ns2-1]*(x[ns2]+x[ns2]);
        for(k=1; k        {
            kc=n-k;
            x[k]=wtable[k+n]+wtable[kc+n];
            x[kc]=wtable[k+n]-wtable[kc+n];
        }
        x[0]+=x[0];
    }
    /*-----------------------------------------------
   cosqf: forward cosine FFT with odd wave numbers.
  ----------------------------------------------*/
    void cosqf(int n, double x[], final double wtable[])
    {
        final double sqrt2=1.4142135623731;
        double  tsqx;
        if(n<2)
        {
            return;
        }
        else if(n==2)
        {
            tsqx=sqrt2*x[1];
            x[1]=x[0]-tsqx;
            x[0]+=tsqx;
        }
        else
        {
            cosqf1(n, x, wtable);
        }
    } 
    /*-----------------------------------------------
   cosqb: backward cosine FFT with odd wave numbers.
  ----------------------------------------------*/
    void cosqb(int n, double x[], double wtable[])
    {
        final double tsqrt2=2.82842712474619;
        double  x1;
        if(n<2)
        {
            x[0]*=4;
        }
        else if(n==2)
        {
            x1=4*(x[0]+x[1]);
            x[1]=tsqrt2*(x[0]-x[1]);
            x[0]=x1;
        }
        else
        {
            cosqb1(n, x, wtable);
        }
    }
    /*-----------------------------------------------------------
   cosqi: initialization of cosine FFT with odd wave numbers.
  ----------------------------------------------------------*/
    void cosqi(int n, double wtable[])
    {
        final double pih=Math.PI/2.0D; //1.57079632679491;
        int     k;
        double  dt;
        dt=pih / (double)n;
        for(k=0; k        rffti1(n, wtable, n);
    }
}
package ca.uol.aig.fftpack;
/**
 * sine FFT transform with odd wave numbers.
 * @author Baoshe Zhang
 * @author Astronomical Instrument Group of University of Lethbridge.
 */
public class RealDoubleFFT_Odd_Odd extends RealDoubleFFT_Even_Odd
{
    /**
     * norm_factor can be used to normalize this FFT transform. This is because
     * a call of forward transform (ft) followed by a call of backward transform
     * (bt) will multiply the input sequence by norm_factor.
     */
    /**
     * Construct a wavenumber table with size n.
     * The sequences with the same size can share a wavenumber table. The prime
     * factorization of n together with a tabulation of the trigonometric functions
     * are computed and stored.
     *
     * @param  n  the size of a real data sequence. When n is a multiplication of small
     * numbers (4, 2, 3, 5), this FFT transform is very efficient.
     */
    public RealDoubleFFT_Odd_Odd(int n)
    {
        super(n);
    }
    /**
     * Forward FFT transform of quarter wave data. It computes the coeffients in 
     * sine series representation with only odd wave numbers.
     * 
     * @param x an array which contains the sequence to be transformed. After FFT,
     * x contains the transform coeffients.
     */
    @Override
    public void ft(double x[])
    {
        sinqf(ndim, x, wavetable);
    }
    /**
     * Backward FFT transform of quarter wave data. It is the unnormalized inverse transform
     * of ft. 
     *
     * @param x an array which contains the sequence to be tranformed. After FFT, x contains
     * the transform coeffients.
     */
    @Override
    public void bt(double x[])
    {
        sinqb(ndim, x, wavetable);
    }
    /*-----------------------------------------------
   sinqf: forward sine FFT with odd wave numbers.
  ----------------------------------------------*/
    void sinqf(int n, double x[], double wtable[])
    {
        int     k;
        double  xhold;
        int     kc, ns2;
        if(n==1) return;
        ns2=n / 2;
        for(k=0; k        {
            kc=n-k-1;
            xhold=x[k];
            x[k]=x[kc];
            x[kc]=xhold;
        }
        cosqf(n, x, wtable);
        for(k=1; k    } 
    /*-----------------------------------------------
   sinqb: backward sine FFT with odd wave numbers.
  ----------------------------------------------*/
    void sinqb(int n, double x[], double wtable[])
    {
        int     k;
        double  xhold;
        int     kc, ns2;
        if(n<=1)
        {
            x[0]*=4;
            return;
        }
        ns2=n / 2;
        for(k=1; k        cosqb(n, x, wtable);
        for(k=0; k        {
            kc=n-k-1;
            xhold=x[k];
            x[k]=x[kc];
            x[kc]=xhold;
        }
    } 
    /*
     void sinqi(int n, double wtable[])
     {
          cosqi(n, wtable);
     }
     */
}