/*
 * SpectralCluster.java
 *
 * Created on February 23, 2007, 11:00 AM
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */
package medusa.spectral;

import cern.colt.matrix.DoubleMatrix2D;
import cern.colt.matrix.impl.SparseDoubleMatrix2D;
import cern.colt.matrix.linalg.Algebra;
import cern.colt.matrix.linalg.EigenvalueDecomposition;
import java.io.IOException;
import java.text.DecimalFormat;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.Vector;
import medusa.graph.Edge;
import medusa.graph.Graph;

/**
 *
 * @author shooper
 */
public class SparseSpectralCluster {

    private SparseSimilarityCollection sc;
    private IndexedValue[] ivs;
    private DoubleMatrix2D Y;
    private DoubleMatrix2D S;
    private double secondEig = 0.0;

    public double getSecondEig() {
        return secondEig;
    }

    /** Creates a new instance of SpectralCluster */
    public SparseSpectralCluster() {
    }

    // methods we need
    private IndexedValue[] sortDesc(final double[] arr) {
        // first index the data
        IndexedValue[] ivs = new IndexedValue[arr.length];
        for (int i = 0; i < arr.length; i++) {
            ivs[i] = new IndexedValue(arr[i], i);
        }

        // then reorder
        Arrays.sort(ivs, Collections.reverseOrder());
        return ivs;
    }

    private IndexedValue[] sortAsc(final double[] arr) {
        // first index the data
        IndexedValue[] ivs = new IndexedValue[arr.length];
        for (int i = 0; i < arr.length; i++) {
            ivs[i] = new IndexedValue(arr[i], i);
        }

        // then reorder
        Arrays.sort(ivs);
        return ivs;
    }

//      private double EigenSum(IndexedValue[] ivs){
//          double absSum=0.o;
//      }
//          for (int i=0; i getVector(DoubleMatrix2D a, IndexedValue[] ivs){
//        Vector v = new Vector();
//        //double[][] data=a.getArrayCopy();
//        String label;
//        for (int i=0; i getVector(Matrix a, IndexedValue[] ivs){
//        Vector v = new Vector();
//        double[][] data=a.getArrayCopy();
//        String label;
//        for (int i=0; i epsilon
        return 0;

    }

    private int nPositiveEvals(IndexedValue[] ivs) {
        // assume the ivs are sorted
        int pos = 0;
        for (int k = 0; k < ivs.length; k++) {
            if (ivs[k].getValue() < 0.00) {
                return pos;
            }
            pos++;
        }
        return pos;
    }

//    private DoubleMatrix2D symmetric(DoubleMatrix2D S){
//        // make sure matrix is symmetric
//        for (int row=0; row < S.rows(); row++) {
//            for (int column=0; column < S.columns(); column++) {
//                S.setQuick(column,row,S.get(row,column));
//            }
//        }
//        double[][] data= S.getArrayCopy();
//        for (int i=0; i getVector(int k) {
        Vector v = new Vector();
        //System.out.println(k+" "+Y.getRowDimension());

        // get k best evecs
        //Matrix subY=Y.getMatrix(0,Y.getRowDimension()-1,0,k-1);
        DoubleMatrix2D subY = Y.viewPart(0, 0, Y.rows(), k);
        Y = null;

        normalizeToUnitLength(subY);


        //double[][] data=subY.getArrayCopy();
        double[][] data = subY.toArray();
        //System.out.println("");
        String label;

        KMeansPoint dmd;
        for (int i = 0; i < data.length; i++) {
            label = (new Integer(i)).toString();
            dmd = new KMeansPoint(label, data[i]);
            //System.out.println("Adding datapoint "+label+" "+dmd.toString());
            v.add(dmd);
        }
        return v;
    }

    public void cluster(int k) {
        //System.out.println("debug 335");
        int nClusters = k;
        if (k == 0) {
            nClusters = nPositiveEvals(ivs);
        //System.out.println("Determining number of clusters to "+nClusters);
        }
        //Y.print(3,3);
        // convert to datapoints
        //System.out.println("convert to datapoints");
        Vector dataPoints = getVector(nClusters);
        // k-means clustering of eigenvectors

        KMeans km = new KMeans(nClusters, dataPoints);

        // and run the kmeans
        km.runKMeans();

        //System.out.println(km);
        niceReport(km.getClusters(), sc);
        
        
        // play with coloring
       
//        Vector result=km.getVector();
//        for (int i=0; i ");
        System.out.println("If clusters are omitted, all positive eigenvalues will ");
        System.out.println("be considered");
        System.out.println("HINT: For memory-intense use, set the heap sizes");
        System.out.println("with -Xmx800m (max size) and -Xms250m (initial size).");
        System.out.println("Change these parameters according to your system.");
        System.out.println("");
        System.out.println("Sean Hooper 2007");
    }

    public boolean isDebug() {
        return debug;
    }

    public void setDebug(boolean debug) {
        this.debug = debug;
    }

// private helper class for spectral clusterer
    private class IndexedValue implements Comparable {

        double value;
        int index;

        public IndexedValue(double value, int index) {
            this.value = value;
            this.index = index;
        }

        public double getValue() {
            return value;
        }

        public double getAbsoluteValue() {
            return Math.abs(value);
        }

        public int getIndex() {
            return index;
        }

        public int compareTo(Object o2) {
            // compare by absolute values!
            IndexedValue i2 = (IndexedValue) o2;
//        if (getAbsoluteValue()