快速傅里叶变换Java版本

随手翻起大学时代自己手写的代码，代码写的不是很好，请参考。不喜勿喷。只能进行整的快速傅里叶变换

import java.util.*;
import java.lang.Math;
public class fastft
{
    public static void main(String[] args)
    {
        double[] c={2,3,4,5,6,7,8,9};
        fft ft=new fft(c);
        /*Rotator rt=new Rotator(8);
        Complex[] cpx=rt.getW();
        for(int i=0;i<cpx.length;i++){
            System.out.println(cpx[i].Output());
        }*/
        //ft.output();
        //System.out.println("");
        //ft.execute();
        //ft.proSeq(ft.getSeq(26));

        //ft.proSeq(8);

    }
}
class fft 
{
    private double[] orgdata;
    private double length;
    private double flags;
    public fft(double[] indata)
    {

        //double i=0;
        final double LENGTH=indata.length;
        this.orgdata=indata;
        if(!canFFT(LENGTH)){
            throw new RuntimeException("不能进行快速傅立叶变换");
        }
        length=LENGTH;
        System.out.println("已经传入可以进行fft的数组");
        output(indata);
        System.out.println("初级处理");
        indata=execute(indata);
        output(indata);
        //proSeq(16);




    }
    public void output()
    {
        for(int i=0;i<length;i++)
        {
            System.out.print(orgdata[i]+" ");

        }   
        System.out.println("");
    }
    public void output(double[] data)
    {
        for(int i=0;i<data.length;i++)
        {
            System.out.print(data[i]+" ");

        }   
        System.out.println("");
    }
    private boolean canFFT(double length){
        //传入数组的长度，并判断能不能进行快速傅立叶变换
        double flag=getStep(length);
        return isInt(flag);

    }
    private double getStep(double dat_len){
        return Math.log(dat_len)/Math.log(2);
    }
    public double[] executePro(double[] data){
        int step=(int)getStep(data.length);
        int stepNow=1;
        //ArrayList ar=data2arlst(data);
        Complex[] cpx=data2cpx(data);
        while(stepNow!=step){


        }
        return null;
    }
    private Complex[] mulRot(Complex[] al,int step){
        int N=(int)Math.pow(2,step+1);              //首先是乘以旋转因子
        Rotator rt=new Rotator(N);
        return null;
    }
    /*private ArrayList mulRot(ArrayList al,int step){
        int N=(int)Math.pow(2,step+1);
        Rotator rt=new Rotator(N);
        return null;
    }*/

    /*private ArrayList data2arlst(double[] data)
    {
        //This functiob should not be use
        int LENGTH=data.length;
        ArrayList<Complex>  al=new ArrayList<Complex>();
        for(int i=0;i<LENGTH;i++)
        {
            al.add(new Complex(data[i]));
        }
        return al;
    }*/
    public Complex[] data2cpx(double[] data)
    {
        int LENGTH=data.length;
        Complex[] cpx=new Complex[LENGTH];
        for(int i=0;i<LENGTH;i++)
        {
            cpx[i]=new Complex(data[i]);
        }

        return cpx;
    }
    public Complex[] proData(Complex[] data){
        return null;
    }
    private double[] rerank(double[] data)
    {
        int dat_len=data.length;
        double[] outdata=new double[dat_len];
        int[] seq=proSeq(dat_len);
        for(int i=0;i<dat_len;i++)
        {
            outdata[i]=data[seq[i]];
        }
        /*
        for(int i=0;i<data.length;i+=2)
        {
            t[i/2]=data[i];
        }
        for(int i=1;i<data.length;i+=2)
        {
            t[4+(i-1)/2]=data[i];
        }*/
        //System.out.println("rerank");
        //output(outdata);
        return outdata;
    }
    private int[] getSeq(int length){
        int[] seq=new int[length];
        for(int i=0;i<length;i++)
        {
            seq[i]=i;
        }
        return seq;
    }
    private int[] proSeq(int length){
        int[] seq =getSeq(length);
        int binary_len;
        int seq_len=seq.length;
        String[] data=new String[seq_len];
        //Integer temp=new Integer(0);
        for(int i=0;i<seq.length;i++){
            data[i]=Integer.toBinaryString(seq[i]);
            //System.out.println(str[i]);
        }
        binary_len=data[seq_len-1].length();    
        char[] reg=new char[binary_len];
        int[] outdata=new int[seq_len];
        for(int j=0;j<data.length;j++)
        {
            for(int p=0;p<reg.length;p++)
                reg[p]='0';//此功能是将寄存器清零
                //System.out.println(reg);
                //System.out.println(str[j]);
            for(int i=0;i<data[j].length();i++){
                reg[i]=data[j].charAt(data[j].length()-1-i);
            }
            data[j]=new String(reg);
            //System.out.println(reg);
        }
        for(int i=0;i<data.length;i++)
        {
            //This process transfer data to out data
            outdata[i]=Integer.parseInt(data[i],2);
            //sop(outdata[i]);
            //sop(data[i]);
        }
        return outdata;
    }

    public double[] execute(double[] data){
        //flags--;
        data=rerank(data);
        //output(data);
        for(int i=0;i<length;i+=2)
        {
            double temp;
            temp=data[i]+data[i+1];
            data[i+1]=data[i]-data[i+1];
            data[i]=temp;

        }
        //System.out.println("exe后");
        //output(data);
        //orgdata[
        return data;
    }
    public boolean isInt(double num){
        //判断传入参数是不是整数
        num=num%1;
        if(num==0)
            return true;
        return false;
    }
    public static void sop(Object Obj){
        //简单的输出语句
        System.out.println(Obj);
    }
}
// 复数， 因为是demo, 其精度就按double的精度来设计
class Complex {
    private double real = 0;
    private double imaginary = 0;
    /*public Complex(double[] reali){
        double[] realp=reali;
    }*/

    public Complex(double real){
        this.real=real;
        this.imaginary=0;
    }
    public Complex(double real, double imaginary) {
        this.real = real;
        this.imaginary = imaginary;
    }

    /**
     * 返回绝对值
     * 
     * @return
     */
    public double getAbs() {
        return Math.sqrt(real * real + imaginary * imaginary);
    }

    /**
     * 返回夹角
     * @return
     */
    public double getAngle() {
        return Math.atan2(imaginary, real);
    }

    /**
     * 返回实数
     * @return
     */
    public double getRealpart() {
        return real;
    }

    /**
     * 返回虚数
     * @return
     */
    public double getImaginarypart() {
        return imaginary;
    }

    // 复数相加
    public Complex add(Complex c){
        return new Complex( this.real + c.real, this.imaginary + c.imaginary);
    }
    // 相反数
    public Complex negtive(){
        return new Complex( -this.real , -this.imaginary );
    }
    public Complex multiply(Complex c){
        return new Complex(this.real*c.real-this.imaginary*c.imaginary,this.real*c.imaginary+this.imaginary+c.real);
    }

    public Complex multiply(double c){
        return new Complex(this.real*c,this.imaginary*c);
    }

    public Complex multiply(int c){
        return new Complex(this.real*c,this.imaginary*c);
    }
    public String output(){
        String str;
        if(this.imaginary>0)
            str=this.real+"+"+this.imaginary+"i";
            else if(this.imaginary==0)
            {
                str=this.real+"";
            }
        else
            str=this.real+""+this.imaginary+"i";
        return str;

    }

    // 其他略
}

class Rotator{
    private double real,imaginary;
    private int N;
    private Complex[] cpx;
    public Rotator(int N)
    {
        this.N=N;
        cpx=new Complex[N];
        for(int i=0;i<N;i++){
            real=Math.cos(2*Math.PI*i/N);
            imaginary=Math.sin(2*Math.PI*i/N);
            cpx[i]=new Complex(real,imaginary);
        }
    }
    public Complex[] getW(){
        return cpx;
    }

    /*for(int i=0;i<N,i++)
    {

    }*/

}