import java.io.*;
import java.util.*;
public class OntoData{
   double[][] data;
   double[][] coordinates;
   final int dimcount=2;
   final double maxcoord=100;
   double[] perspective;
   String[] parameters;
   String[] names;
   
   public static void main(String[] arg){
       OntoData m=new OntoData();
//       m.readDataFromFile("Creatures2.txt");
       m.readDataFromFile("aj.txt");
       m.normalizeData();
      // m.perspective=new double[]{0, 0, 1, 0,0, 0, 0, 0};
       m.randomCoordinates();
      // m.position(0);
       m.writeDataToFile("test1.txt");
       m.writeCoordinatesToFile("con");
   }
   
   String getDataAsText(){
      StringBuffer sb=new StringBuffer();
          for(int i=0; i<parameters.length; i++){
             sb.append("\t"+parameters[i]);
          }
          sb.append("\n");
          for(int j=0; j<names.length; j++){
             sb.append(names[j]);
             for(int i=0; i<parameters.length; i++){
                double d=((int)(data[j][i]*1000))/1000.0;
//                sb.append("\t"+data[j][i]);
                sb.append("\t"+d);
             }
             sb.append("\n");
          }
      return sb.toString();      
   }

   void writeDataToFile(String filename){
      try{
          PrintWriter pw=new PrintWriter(new FileWriter(filename));
          String s=getDataAsText();
          pw.print(s);
          pw.close();
      }catch(Exception ex){
         ex.printStackTrace();
      }
   }

   
   void writeCoordinatesToFile(String filename){
      try{
          PrintWriter pw=new PrintWriter(new FileWriter(filename));
          for(int i=0; i<dimcount; i++){
             pw.print("\tc"+i);
          }
          pw.println();
          for(int j=0; j<names.length; j++){
             pw.print(names[j]);
             for(int i=0; i<dimcount; i++){
                //double d=((int)(coordinates[j][i]*1000))/1000.0;
                pw.print("\t"+coordinates[j][i]);
             }
             pw.println();
          }
          pw.close();
      }catch(Exception ex){
         ex.printStackTrace();
      }   
   }
   
   void readDataFromText(String text){
     double[][] olddata=data;
     String[]  oldnames=names;
     String[]  oldparameters=parameters;
     double[]  oldperspective=perspective;
     try{
       StringTokenizer stk=new StringTokenizer(text, "\n");
       Vector rows=new Vector();
       Vector vnames=new Vector();
       Vector vparameters=new Vector();
       while(stk.hasMoreTokens()){
          String s=stk.nextToken();
          if(s.trim().length()>0){
             Vector row=new Vector();
             StringTokenizer stk2=new StringTokenizer(s, " \t,");
             while(stk2.hasMoreTokens()){
                String s2=stk2.nextToken();
                row.add(s2);
             }
             rows.add(row);
          }           
       }
       if(rows.size()==0){
          parameters=new String[0];
          names=new String[0];
          data=new double[0][0];
          return;
       }
       Vector v0=(Vector)rows.get(0);
       if(v0.size()<2){throw new RuntimeException("invalid data");}
       boolean parametersExists=false;
       try{
         Double.parseDouble((String)v0.get(1));
       }catch(Exception ex){
         parametersExists=true;
       }
       if(parametersExists){
          parameters=new String[v0.size()];
          for(int i=0; i<v0.size(); i++){
             parameters[i]=(String)v0.get(i);
          }
          rows.removeElementAt(0);
       }
       data=new double[rows.size()][((Vector)rows.get(0)).size()-1];
       names=new String[rows.size()];
       if(!parametersExists){
          parameters=new String[((Vector)rows.get(0)).size()-1];
          for(int i=0; i<parameters.length; i++){
             parameters[i]="xx"+i;
          }
       }
       for(int j=0; j<rows.size(); j++){
          Vector v=(Vector)rows.get(j);
          if(v.size()!=parameters.length+1){
             throw new RuntimeException("Incorrect row size "+j);
          }
          names[j]=(String)v.get(0);
          for(int i=1; i<v.size(); i++){
             data[j][i-1]=Double.parseDouble((String)v.get(i));
          }
       }
       perspective=new double[data[0].length];
       Arrays.fill(perspective, 1);
       if(perspective.length!=parameters.length || parameters.length!=data[0].length){
         throw new RuntimeException("Incorrect column count");
       }
       if(names.length!=data.length){
         throw new RuntimeException("Incorrect row count");
       }
       randomCoordinates();
     }catch(RuntimeException ex){
        data=olddata;
        perspective=oldperspective;
        names=oldnames;
        parameters=oldparameters;
        throw ex;
     }
   }

   void readSampleData(){
      String s=
        "	length	weight\n"+
        "metalsphere	0.05	1\n"+
        "cherry	0.05	0.01\n"+
        "paper	0.5	0.01\n"+
        "book	0.5	1\n";
      readDataFromText(s);  
   }


   void readDataFromFile(String filename){
      try{
         BufferedReader br=new BufferedReader(new FileReader(filename));
         String s=br.readLine();
         StringBuffer buf=new StringBuffer();
         while(s!=null){
            buf.append("\n"+s);
            s=br.readLine();
         }
         br.close();
         readDataFromText(buf.toString());

      } catch(Exception ex){
         ex.printStackTrace();
      }
   }

   
/*
   void normalizeData(){
      for(int i=0; i<data[0].length; i++){
         double max=0;
         for(int j=0; j<data.length; j++){
            if(data[j][i]>max){max=data[j][i];}
         }
         if(max>1){
            for(int j=0; j<data.length; j++){
               data[j][i]=data[j][i]/max;
            }
         }
      }
   }
*/   
   void normalizeData(){
      for(int i=0; i<data[0].length; i++){
         double max=0;
         double min=0;
         for(int j=0; j<data.length; j++){
            if(j==0){min=max=data[j][i];}
            if(data[j][i]>max){max=data[j][i];}
            if(data[j][i]<min){min=data[j][i];}
         }
         for(int j=0; j<data.length; j++){
               data[j][i]=(data[j][i]-min)/(max-min);
         }
      }
   }


   void normalizeCoordinates(){
      for(int i=0; i<coordinates[0].length; i++){
         double min=coordinates[0][i];
         double max=min;
         for(int j=0; j<coordinates.length; j++){
            if(coordinates[j][i]<min){min=coordinates[j][i];}
            if(coordinates[j][i]>max){max=coordinates[j][i];
            }
         }
         double koef=2*maxcoord/(max-min);
         double centre=(max+min)/2;
         for(int j=0; j<coordinates.length; j++){
            coordinates[j][i]=(coordinates[j][i]-centre)*koef;
         }
      }
   }
   
   void randomCoordinates(){
      coordinates=new double[data.length][dimcount];
      for(int i=0; i<dimcount; i++){
         for(int j=0; j<data.length; j++){
            coordinates[j][i]=(Math.random()-0.5)*2*maxcoord;
         }
      }
   }
   
   int randomIterate(){
       int a=(int)(data.length*Math.random());
       if(a!=5){
       position(a);
       }
       return a;
   }
   
   void position(int a){
      double scaler=100;
      double step=0.001;
      int m=data.length;
      for(int b=0; b<m; b++){
         double targetdistance=scaler*(ontodistance(a, b));
         
         double delta=ddistance(a, b)-targetdistance;
         //if(delta<-100){delta=-100;}
         //if(delta>100){delta=100;}
         double[] newloc=approach(a, b, delta*step);
         for(int i=0; i<newloc.length; i++){
            coordinates[a][i]=newloc[i];
         }         
      }
//      normalizeCoordinates();
   }
   
   double[] approach(int a, int b, double step){
      double[] aloc=coordinates[a];
      double[] bloc=coordinates[b];
      int dimensions=aloc.length;
      double[] newloc=new double[dimensions];
      for(int d=0; d<dimensions; d++){
         double ad=aloc[d];
         double bd=bloc[d];
         double ddist=ad-bd;
         double newd=ad-ddist*step;
         newloc[d]=newd;
      }
      return newloc;
   }
   
   double ontodistance(int a, int b){
      double[] aloc=ontovector(a);
      double[] bloc=ontovector(b);
      int dimensions=aloc.length;
      double dcum=0;
      for(int d=0; d<dimensions; d++){
         double ad=aloc[d];
         double bd=bloc[d];
         dcum+=Math.pow(ad-bd, 2);
      }
      return Math.sqrt(dcum);
   }
   
   double[] ontovector(int i){
      double[] ivector=new double[data[i].length];
      for(int w=0; w<ivector.length; w++){
        ivector[w]=data[i][w]*perspective[w];
      }
      return ivector;
   }
   
   double ddistance(int a, int b){
      double[] aloc=coordinates[a];
      double[] bloc=coordinates[b];
      int dimensions=aloc.length;
      double dcum=0;
      for(int d=0; d<dimensions; d++){
         double ad=aloc[d];
         double bd=bloc[d];
         dcum+=Math.pow(Math.abs(ad-bd), 2);
      }
      return Math.sqrt(dcum);
   }  
}