/*
 * HCL.java
 *
 * Created on January 1, 2002, 1:27 AM
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */

package medusa.georgios.ClusteringAlgorithms;


import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;

/**
 *
 * @author Georgios
 */
public class HCL {
    static float[][] matrix;
    static ArrayList labels;
    int INCREMENT;
    int x,y;
    ArrayList Stored_Nodes_Map = new ArrayList();
    Node Tree;
    float Infinite = -9999999;
     
     
    /** Creates a new instance of HCL */
    public HCL(float[][] Matrix,ArrayList labels ) {
        this.matrix=Matrix;
        this.labels=labels;
        
         for (int i = 0; i < Matrix.length; i++) {
            for (int j = i + 1; j < Matrix.length; j++) {
                Infinite = Math.max(Matrix[i][j], Infinite);
            }
        }Infinite++;
        //Infinite=Math.max(Infinite, 9999999);

        for (int i = 0; i < Matrix.length; i++) {
            for (int j = i + 1; j < Matrix.length; j++) {
                if (Matrix[i][j] == 0) 
                    Matrix[i][j]= Infinite;
                 Matrix[j][i]=Matrix[i][j] ;
            }
        }
        
        this.INCREMENT=labels.size();
       //  print_matrix();
        this.run_hierarchical_clustering();
        
    }
    
    
    
  void find_minimum()
{
    int i,j;
    
	float minimum=Infinite;
	for (i = 0; i < INCREMENT; i++)
        for (j = i+1; j < INCREMENT; j++) {
		  if(matrix[i][j]<=minimum)
		  {
                     minimum=matrix[i][j];
                     x=i;
                     y=j;
                  }
    }
        
      //  System.out.println("111111111111111111");
        
        for (i = 0; i <  this.INCREMENT; i++){
            matrix[x][i]=matrix[i][x]=Math.min(matrix[i][x],matrix[i][y]);
            if(matrix[x][i]==0) break;
        }
        for (i = 0; i <  this.INCREMENT; i++){
            matrix[y][i]=matrix[i][y]=Math.min(matrix[i][y],matrix[i][y]);
            if(matrix[y][i]==0) break;
        }
        
         for (j = 0; j <  this.INCREMENT; j++){
            matrix[j][x]=matrix[x][j]=Math.min(matrix[x][j],matrix[y][j]);
            if(matrix[j][x]==0) break;
         }
        for (j = 0; i <  this.INCREMENT; j++){
            matrix[y][j]=matrix[j][y]=Math.min(matrix[x][j],matrix[y][j]);
            if(matrix[y][j]==0) break;
        }
         
      
        
     //  System.out.println("2222222222222222\t"+ x+"\t"+y);
       matrix[x][y]=matrix[y][x]=Infinite;
   
  //  print_matrix();
}
  
   
  void print_matrix()
  {
      for (int i = 0; i < matrix.length; i++) {
          for (int j = 0; j < matrix.length; j++)
             if(i<=j)
             System.out.print(matrix[i][j]+"\t\t");
             else
                 System.out.print("\t\t");
          System.out.println("");
      }
  }
  
  
  
    void run_hierarchical_clustering()
{
        
   Tree = new Node(labels);     
   int i,counter=0, tree_nodes=INCREMENT;
   int roots_found=0; 
   Node node1,node2, source_parent,destination_parent1,destination_parent2;
 

   for(i=0;i