fft.java

This is a example about programming a neural network

/*
 * fft.java
 *
 * Created on 3 de febrero de 2008, 6:23
 *
 */

package rah;

public class fft {
    
    private double[] vector;
    private double[][] vectorValido;
    private int n;
    double vAux[][]=null;
    double[][] vectO=null ;
    
    public fft(double[] vector) {
    
        this.vector=vector;
        n=vector.length;
    }
    
    public void validarVector(){
        
        int i=0;
        double num=0.0;
        boolean cambiarVec=false;
        
        while(num < n){
            
            i++;
            num=Math.pow(2,i);                        
            
            if(num > n)
                
                cambiarVec=true;                        
        }
        if(cambiarVec==true){
            
            vectorValido= new double[(int)num][2];
            double [] temp=null;
            int j=0;
            double media,var;
            
            for(i=0;i<n;i++ ){
                
                vectorValido[i][0]=vector[i];
                vectorValido[i][1]=0;
            }
            temp=new double[5];

            for(i=n-5; i<n; i++){
                
                temp[j]=vector[i];
                j++;
            }
            media=media(temp);
            var=varianza(temp,media);
            j=(int)num-n;
                           
            for(i=n;i<num;i++ ){
                
                vectorValido[i][0]=0;                
               // vectorValido[i][0]=vectorValido[i-1][0] - (j*Math.sqrt(var))/100.0;
                j++;
                vectorValido[i][1]=0;
            }
        }
        else{
            
            vectorValido= new double[n][2];
            
            for(i=0;i<n;i++ ){
                
                vectorValido[i][0]=vector[i];
                vectorValido[i][1]=0;
            }
        }
    }
    
    public double[][] computarFactor(int tamanyo){
        
        int factor=tamanyo/2;
        double vectFactor[][] =new double[factor][2];
        int i;
        double W,Q,a,b;
        
        W=(2 * Math.PI)/tamanyo;
        
        for(i=0; i<factor; i++){
            
            Q= W*i;
            a= Math.cos(Q);
            b= Math.sin(Q);
            
            if (b==0){
            
                vectFactor[i][0] = a ;
                vectFactor[i][1] = 0 ;
            }
            else{
                
                vectFactor[i][0] = a;
                vectFactor[i][1] = -b;
            }
        }
        return vectFactor;
    }
    
    public void fftDiezmado(){
        
        int numVeces=vectorValido.length;
        int i,j,sgt,m,p,l;
        double W[][];
        double real,imag;
        
        for(i=numVeces; i>1; i=i/2){
            
            vAux= new double[numVeces][2];
            sgt=0;
            W=computarFactor(i);
            l=1;
            
            while(l <= numVeces/i){ 
                
                p=0;
                j=sgt;
                
                for(m=sgt; m< j+(i/2); m++){ 
                    
                    vAux[m][0] = vectorValido[m][0] + vectorValido[m+(i/2)][0];
                    vAux[m][1] = vectorValido[m][1] + vectorValido[m+(i/2)][1];
                    
                    real = (vectorValido[m][0]  - vectorValido[m+(i/2)][0]);
                    imag= (vectorValido[m][1]  - vectorValido[m+(i/2)][1]);
                    
                    vAux[m+(i/2)][0] = (real*W[p][0]) - (imag*W[p][1]);
                    vAux[m+(i/2)][1] = (real*W[p][1]) + (imag*W[p][0]);
                   
                    p++;
                }
                sgt=sgt+(i/2)+p;
                l=l+1;
            }
            for(p=0; p<numVeces; p++){
                
                vectorValido[p][0]=vAux[p][0];
                vectorValido[p][1]=vAux[p][1];
            }
            
        }

    }
    
    public void ordenarVector(double[][] m){
        
        int tamanyoBin=0,longitudVect,i,l,j;
        String temp;
        vectO = new double[m.length][m[0].length];
                
        longitudVect=m.length;
        j=(int)(longitudVect/2);
        
        while(j>1){
           
            tamanyoBin=tamanyoBin+1;
            j=(int)(j/2);
        }
        tamanyoBin=tamanyoBin+1;
        String[] vectBinario = new String[longitudVect];
        
        // Convirtiendo de Decimal Binario
        for (i=0; i<longitudVect; i++){
            
            vectBinario[i]=Integer.toBinaryString(i);
            l=vectBinario[i].length();
            
            if( l<tamanyoBin ){
                
                j=0;
                temp="";
                
                for(j=0; j<tamanyoBin-l; j++){
                    
                    temp=temp+"0";
                }
                vectBinario[i]=temp + vectBinario[i];
            }
        }
        
        //Ordenando vectBinario: cambiando de lugar los bits, ponerlos al reves
        for(i=0; i<longitudVect; i++){
            
            temp=vectBinario[i];
            vectBinario[i]="";
            
            for(j=tamanyoBin; j>0; j--){
                
                vectBinario[i]=vectBinario[i]+temp.substring(j-1,j);
            }
        }
        
        //Convirtiendo a decimal el indice binario corregido
        for(i=0; i<longitudVect; i++){
            
            temp=vectBinario[i];
            l=0;
            String w="1";
            for(j=1; j<tamanyoBin+1; j++){
                
               if( vectBinario[i].substring(j-1,j).compareTo(w)==0)
                
                   l=l+(int)(Math.pow(2,tamanyoBin-j));               
            }
            
            //cambiando al lugar correcto el elemento de la matriz m
            vectO[i][0]=m[l][0];
            vectO[i][1]=m[l][1]; 
        }
       // mostrarVector(vectO);
    }
    
    public double[] obtenerVectorSalida(){
        
        double[] vectSalida= new double[vectO.length];
        int i;
        
        for(i=0; i<vectO.length; i++){
            
            if(vectO[i][1]!=0){
                
                vectSalida[i]=Math.sqrt(   Math.pow( Math.round(vectO[i][0]) ,2) + Math.pow( Math.round(vectO[i][1]) ,2)   );
            }
            else{
                
                vectSalida[i]=Math.abs(vectO[i][0]);
            }
        }
        //mostrarVector(vectSalida);
        
        return vectSalida;        
    }
      
    public void mostrarVector(double[][] vect){
        
        int i;
        
        for (i=0; i<vect.length; i++){
            
            System.out.println(vect[i][0]+"  "+vect[i][1]);
        }
        System.out.println("***************");
    }
    
    public void mostrarVector(double[] vect){
        
        int i;
        
        for (i=0; i<vect.length; i++){
            
            System.out.println(vect[i]);
        }
        System.out.println("***************");
    }

    public double[][] getVectorValido() {
        
        return vectorValido ;
    } 
    
    //******************************************************************************************
// Operaciones estadisticas     

    public static double media(double arr[ ]){
        
        double sum = 0.0;

        for(int i = 0; i < arr.length ; i++)
        {
            sum += arr[i];
        }

        return sum / arr.length;
    }    
    
    public static double varianza(double arr[ ], double media){
        
        double sum = 0.0;

        for(int i = 0; i < arr.length ; i++)
        {
            sum += Math.pow(arr[i] - media, 2);
        }
        
        return sum / (arr.length - 1);
    }
//******************************************************************************************    
    
}