import SVDC_j.*;
import Blas_j.*;
import Blas_j2.*;
//import gt_util9.*;

public class gt2 extends Object
{
// The variables with "static" exist as long as the class exists.
  static double gt_world[][];
  static double gt_proj[][];
  static double gt_plot[][]; 
  static double shift[];
  static double xi[][], xi0[][], xi1[][];
  double u[][], u_init[][];
  static double u0[][], u1[][];
  static double v0[][], v1[][], w[][], w0[][], w1[][];
  static double b[][];
// Structure lim in C--->
  static double lims_min[];
  static double lims_max[];
  int tour_vars[];
//int active[];
  int ntour_vars; 
  static double tv[][], tmat[][];
  static double s[];
  static double coss[], sins[]; 
  static double tau[], tinc[]; // tinc should be radian
  static double step, dv, delta;
//  static double dv, delta;
  static int spandim, ds;
  static int generate_new_path;
  int got_new_target_plane;
  static int count;
  int pdim, tourlength;
  int ncols, nrows, ndim, ndim2;
  static double raw_data[][];
/* VARIABLES TO BE DEFINED IN READ.JAVA :
  ncols, ncols_used, nrows, raw_data[][], vgroup_ids[]
  VARIABLES TO BE DEFINED ELSEWHERE :
  collab[][], color_name[];                    */

// In JAVA, we cannot declare "static" variables in the method (run_tour() ).
  static double uold[][];
  static int firsttime=1;

/*****************
 CONSTRUCTOR OF GT CLASS TO INITIALIZE ARRAYS AND VARIABLES
**********/

  //  public gt2(int nc, int nr, int nd) 
  public gt2(int nc, int nr, int nd, double st) 
  {
    ncols = nc;
    nrows = nr;
    ndim = nd;
    ndim2 = ndim * 2;
    step = st;
    //    step = 0.1;
    s = new double[nd];
    coss = new double[nd];
    sins = new double[nd];
    generate_new_path=0;
    count = 0;
    delta = 0.0; 
//    step = 0.0; 
    spandim=0; 
    ds = 0; 
// d_alloc_gt()
    gt_world = new double[nrows][ncols];  
    gt_proj = new double[nrows][ncols];
    gt_plot = new double[nrows][ncols];
    shift = new double[ncols];
    lims_min = new double[ncols];  //ncols=ntour_vars
    lims_max = new double[ncols]; 
    tour_vars = new int[ncols];
    xi = new double[ndim2][nrows];  // 2*PROJ_DIM=4
    xi1 = new double[ndim][nrows];
    u = new double[ndim][ncols];
    u_init = new double[ndim][ncols];
    u0 = new double[ndim][ncols];  
    u1 = new double[ndim][ncols];
    v0 = new double[ndim][ncols];
    v1 = new double[ndim][ncols];
    b = new double[ndim2][ncols];
    w = new double[ndim2][ndim];
    w0 = new double[ndim2][ndim];
    w1 = new double[ndim2][ndim];    
    tv = new double[ndim][ncols];
    tmat = new double[ndim][ncols];
    tau = new double[ndim];
    tinc = new double[ndim]; 
    raw_data = new double[nrows][ncols];  
  }

/* This only gives the correct result if the vgroups vector is
   of the form {0,1,2,.....,ngroups-1} */
/*
  public static int numvargroups() 
  {
    int nvgroups=0;
    for (int j=0; i<ncols; j++) 
    {
      if (read.vgroup_ids[j] > nvgroups) {nvgroups = read.vgroup_idsp[j];
    }
    nvgroup=nvgroups+1;
    return nvgroups;
  }*/

/* Find the minimum and maximum values of each column or variable group
   scaling by mean and std_width standard deviations */ 

  public void mean_lgdist(double data[][], double min, double max) 
  {
    double dx, sumxi;
    double sumdist=0.0;
    double mean[];
    double lgdist=0.0;            
    int nvgroups;

    nvgroups = 3;
    mean = new double[ncols];    
    for (int j=0; j<ncols; j++) 
    {
      sumxi=0.0;
      for (int i=0; i<nrows; i++) 
      {
        dx = data[i][j];
        sumxi += dx;
      }
    mean[j]=sumxi/nrows;
    }
  
//for (int k=0; k<nvgroups; k++) {
    for (int i=0; i<nrows; i++) 
    {
      sumdist = 0.0;
      for (int j=0; j<ncols; j++) 
      {
        dx = data[i][j]-mean[j];
        dx = dx*dx;
        sumdist += dx;
      }
      if (sumdist > lgdist) 
      {
        lgdist = sumdist;
      }
    }  
    lgdist = Math.sqrt(lgdist);
    for (int j=0; j<ncols; j++) 
    {
      min = mean[j]-lgdist;
      max = mean[j]+lgdist;
      lims_min[j] = min;
      lims_max[j] = max;
    } 
//}
    for (int j=0; j<ncols; j++) 
    {
      mean[j] = 0.0;
    }
  }

/* This routine preprojects the data into the subspace spanned by the starting 
and ending basis to speed computation during the interpolation stage of 
the tour */

  public void preproject_data() 
  {
    Blas_j2 Bj2;
    Bj2 = new Blas_j2();

// static int firsttime = 1;
    firsttime=1;
    //  System.out.println("gt_world= "+gt_world[0][0]+" "+gt_world[0][1]+" "+gt_world[0][2]); 
    //  System.out.println("gt_world= "+gt_world[1][0]+" "+gt_world[1][1]+" "+gt_world[1][2]); 
    //  System.out.println("gt_world= "+gt_world[2][0]+" "+gt_world[2][1]+" "+gt_world[2][2]); 
    for (int k=0; k<ds; k++) 
    {
      for (int i=0; i<nrows; i++) 
      {
        xi[k][i] = Bj2.inner_prod(gt_world[i],b[k],ncols);
	//        if (i==8) 
	//        {
	//          firsttime=0;
	//        }
      }
    }

    //    for (int i=0; i<ds; i++) 
    //    {
      //   System.out.println("xi["+Integer.toString(i)+"]= "+xi[i][0]+" "+xi[i][1]+" "+xi[i][2]);
    //    }
  }

  public void increment_tour() 
  {
    tour_reproject(); 
  }

  public void finishing_step(double tinc[], double tau[], int sdim) 
  {
    int do_final_step=0;

    for (int k=0; k<sdim; k++) 
    {
      if (tinc[k] != tau[k]) 
      {
        tinc[k]=tau[k]; 
        do_final_step=1;
      }
      if (do_final_step>0) 
      {
        tour_reproject(); 
      }
    }
  }

/* This routine uses the data projected into the span of the starting basis
and ending basis, and then rotates in this space*/

  public void tour_reproject() 
  {
    double tmpf;
    double costf[], sintf[];
    costf = new double[ndim];
    sintf = new double[ndim];
// static int firsttime=1;
    firsttime=1;
    int firstvar[];
    firstvar = new int[ndim];

    for (int i=0; i<spandim; i++) 
    {
      //   System.out.println("tinc="+tinc[i]+"tau="+tau[i]);
      costf[i] = Math.cos(tinc[i]);
      sintf[i] = Math.sin(tinc[i]);
    }  
/* Basically do calculations ready for use in drawing segments in various
   spheres */

    for (int i=0; i<spandim; i++) 
    {
      for (int k=0; k<ndim; k++) 
      {
        w[2*i][k] = costf[i]*(w0[2*i][k])-sintf[i]*(w0[2*i+1][k]);

        w[2*i+1][k] = sintf[i]*(w0[2*i][k])+costf[i]*(w0[2*i+1][k]);

      }
    }
    for (int i=2*spandim; i<ds; i++) 
    {
      for (int k=0; k<ndim; k++) 
      { 
        w[i][k] = w0[i][k]; 

      }
    }
// Generate data projection
    for (int i=0; i<nrows; i++) 
    {
      for (int j=0; j<ndim; j++) 
      {
        tmpf = 0.0;
        for (int k=0; k<ds; k++) 
        { 
          tmpf += (w[k][j]*xi[k][i]); 
        }
        gt_proj[i][j] = tmpf;
      }  
    } 
    //    System.out.println("gt_proj[0][0]="+gt_proj[0][0]);
// Generate projection coordinates
    for (int j=0; j<ncols; j++) 
    {
      for (int k=0; k<ndim; k++) 
      {
        tmpf = 0.0;
        for (int i=0; i<ds; i++) 
        { 
          tmpf += (b[i][j]*w[i][k]); 
        }
        u[k][j] = tmpf;
      }
    }
  }

/* This routine take the raw data and scales it into a -1 to +1 2-dim'l box */
  public void gt_pipeline() 
  {
    double min, max;
    min=0.0; max=0.0;
  
    double rdiff;
    double pow[];
    mean_lgdist(raw_data,min,max);
    for (int j=0; j<ncols; j++) 
    {
      rdiff = lims_max[j]-lims_min[j]; 
      for (int i=0; i<nrows; i++) 
      {
        gt_world[i][j] = -1.0 + 2.0*(raw_data[i][j]-lims_min[j])/rdiff;
//    System.out.println("gt_world["+Integer.toString(i)+"]["+
//                            Integer.toString(j)+"]"+gt_world[i][j]); 
      }
    } 
  }

  public void init_gt() throws SVDCException
  {
    gt_util9 GT7;
    GT7 = new gt_util9();
    for (int k=0; k<ndim; k++) 
    {
      for (int j=0; j<ncols; j++) 
      {
        u_init[k][j]=0.0;
      }
    }

    for (int k=0; k<ndim; k++) 
    { 
      u_init[k][k] = 1.0;
    }

    GT7.u0_gets_current_pos(u,u_init,ncols,ncols,ndim); //ncols=ntour_vars,pdim=2

// Set tour_vars vector
    for (int j=0; j<ncols; j++) 
    {
      tour_vars[j]=j;
    }
    delta = 0.0;
    dv = 1.0;
//    step = 0.1;  /* 0.01*10= Set the speed parameter, you need to change this
//                               if you want the tour to run faster or slower */
// stepscale=10;
    for (int k=0; k<ndim; k++) 
    {
      tau[k] = tinc[k] = 0.0;
    }
    clear_vars();

    spandim=Math.min(ncols,ndim);

    gt_pipeline();


    run_tour(step);  
    got_new_target_plane=1;
  }

  public void clear_vars() 
  {
    for (int k=0; k<ndim; k++) 
    {
      for (int j=0; j<ncols; j++) 
      {
        v0[k][j]=0.0;
        v1[k][j]=0.0;
        b[2*k][j]=0.0;
        b[2*k+1][j]=0.0;
      }
    }
    for (int k=0; k<ndim; k++) 
    {
      for (int j=0; j<ndim; j++) 
      {
        w0[2*k][j] = 0.0;
        w0[2*k+1][j]=0.0;
        w1[2*k][j] = 0.0;
        w1[2*k+1][j]=0.0;
      }
    }
  }

/* This is the engine which drives the tour */
  public void run_tour(double st) throws SVDCException
  {
    step = st;
    double tmpf;
    firsttime=1;
    count++;
//  System.out.println("count in run_tour= "+Integer.toString(count));
//  System.out.println("firsttime= "+Integer.toString(firsttime));
    if (firsttime == 1) 
    {
      uold = new double[ndim][ncols];
      for (int i=0; i<ncols; i++) 
      {
        for (int j=0; j<ndim; j++) 
        {
          uold[j][i] = u[j][i];
        }
      }
      firsttime = 0;
    }
//  System.out.println("firsttime= "+Integer.toString(firsttime));
    gt_util9 GT7;
    GT7 = new gt_util9();
//  System.out.println("delta before path="+delta);
    if (GT7.reached_target_plane(ncols,tinc,tau,delta,spandim,  // start IF
      got_new_target_plane) == 0)
    {

//  System.out.println("reached_target_plane==0");
//  System.out.println("tinc[0]="+tinc[0]);
//  System.out.println("tinc[1]="+tinc[1]);
      tour_reproject();
// Print projection vectors
//   for (int i=0; i<ncols; i++) {
//    for (int j=0; j<ndim; j++) {
//     System.out.println(u[j][i]);
//    }
//   }
      for (int i=0; i<ncols; i++) 
      {
        for (int j=0; j<ndim; j++) 
        { 
          uold[j][i] = u[j][i];
        }
      }

    } 
    else 
    {
//   System.out.println("reached_target_plane==1");
      finishing_step(tinc, tau, spandim);  
      GT7.u0_gets_current_pos(u0,u,ncols,ncols,ndim);
      GT7.new_random_basis(u1,ncols,ncols,tour_vars,ndim);

      clear_vars();
      for (int j=0; j<ndim; j++)
        tau[j] = 0.0;
//      tau[0]=0.0;tau[1]=0.0;

      for (int j=0; j<ndim; j++)
        tinc[j] = 0.0;
//      tinc[0]=0.0;tinc[1]=0.0;

  
      GT7.path(u0,u1,v0,v1,b,w0,w1,ncols,tour_vars,ndim,tau,tv,step);
      dv=GT7.pdv;
      //      System.out.println("dv="+dv);
      delta=GT7.pdelta;
      spandim=GT7.pspandim;   
      ds=GT7.pds;

      preproject_data();
      for (int i=0; i<ncols; i++) 
      {
        for (int j=0; j<ndim; j++) 
        { 
          uold[j][i] = u[j][i];
        }
      }
      tour_reproject();
      generate_new_path=0;
      got_new_target_plane=1;
    }            // end IF
  }

}