import java.util.ArrayList;

public class LVQ_Example2
{
    private static final int MAX_PATTERNS = 12;    // Total input patterns. 
    private static final int VECTOR_LENGTH = 2;    // Size of each input pattern.
    private static final int MAX_CLUSTERS = 10;
    private static final double THRESHOLD = 2.0;
    
    private static ArrayList<cCluster> cluster = null;
    private static int numClusters = 0;
    
    private static double pattern[][] = new double[][] {{0.0, 0.0}, 
                                                        {1.0, 0.0}, 
                                                        {0.0, 1.0}, 
                                                        {1.0, 1.0}, 
                                                        {0.0, 3.0}, 
                                                        {1.0, 3.0}, 
                                                        {0.0, 4.0}, 
                                                        {1.0, 4.0}, 
                                                        {4.0, 0.0}, 
                                                        {5.0, 0.0}, 
                                                        {4.0, 1.0}, 
                                                        {5.0, 1.0}};
    
    private static void initialize()
    {
        cluster = new ArrayList<cCluster>();
        for(int i = 0; i < MAX_CLUSTERS; i++)
        {
            cCluster aCluster = new cCluster(VECTOR_LENGTH, MAX_PATTERNS);
            cluster.add(aCluster);
        }
        
        return;
    }
    
    public static void runAlgorithm()
    {
        int winner = 0;
        double dist = 0.0;

        for(int pat = 0; pat < MAX_PATTERNS; pat++)
        {
            // Attach the current input to closest cluster.
            winner = findClosestCluster(pat);
            if(winner == -1){
                winner = allocateCluster();
            }else{
                dist = eucNorm(pat, winner);
                dist = Math.sqrt(dist);                // get root of the distance measure.
                if(dist > THRESHOLD){
                    winner = allocateCluster();        // Allocate new cluster.
                    System.out.println("\n>>> Creating NEW cluster number: " + winner);
                }
            }
            System.out.println("\nPattern " + pat + " assigned to cluster " + winner);
            attach(winner, pat);                       // Attach pattern to winner.
            calcNewClustCenter(winner);                // Adapt cluster center.
        }

        return;

    }
    
    private static int allocateCluster()
    {
        int n = numClusters;
        numClusters += 1;
        return n;
    }
    
    private static double eucNorm(int p, int c)
    {
        // Calculate Euclidean norm of vector, p.
        cCluster aCluster = null;
        double dist = 0.0;  // dist is the difference between pattern vector, p, and cluster center, c.
        
        aCluster = cluster.get(c);
        for(int i = 0; i < VECTOR_LENGTH; i++)
        {
            //Square the difference between p and c
            dist += (aCluster.getCenter(i) - pattern[p][i]) * (aCluster.getCenter(i) - pattern[p][i]);
        }
        
        return dist;
    }
    
    private static int findClosestCluster(int pat)
    {
        double minDist = Math.pow(10, 10);   //Just some large number.
        int clustID = -1;
        for(int i = 0; i < numClusters; i++)
        {
            double d = eucNorm(pat, i);
            if(d < minDist){
                minDist = d;
                clustID = i;
            }
        }
        
        return clustID;
    }
    
    private static void attach(int c, int p)
    {
        cCluster aCluster = cluster.get(c);

        int memberIndex = aCluster.getNumMembers();
        aCluster.setMember(memberIndex, p);
        aCluster.setNumMembers(aCluster.getNumMembers() + 1);

        return;
    }
    
    private static void calcNewClustCenter(int c)
    {
        int vecID = 0;
        int nMembers = 0;
        cCluster aCluster = cluster.get(c);
        double tmp[] = new double[VECTOR_LENGTH];
        
        for(int j = 0; j < VECTOR_LENGTH; j++)
        {
            tmp[j] = 0.0;
        }
        
        nMembers = aCluster.getNumMembers();
        for(int j = 0; j < nMembers; j++)                  // cycle through member vectors
        {
            vecID = aCluster.getMember(j);
            for(int k = 0; k < VECTOR_LENGTH; k++)         // cycle through elements of vector
            {
                System.out.println("Cluster " + c + " Pattern[" + vecID + "][" + k + "] = " + pattern[vecID][k] + ", Member_ID = " + vecID);
                tmp[k] += pattern[vecID][k];               // add (member) pattern element into temp
            } // k
        } // j
        
        for(int k = 0; k < VECTOR_LENGTH; k++)             //cycle through elements of vector
        {
            tmp[k] = tmp[k] / aCluster.getNumMembers();
            aCluster.setCenter(k, tmp[k]);
        } // k
        
        return;
    }
    
    private static class cCluster
    {
        private double mCenter[] = null;
        private int mMember[] = null;    // Index of vectors belonging to this cluster.
        private int mNumMembers = 0;

        public cCluster(int vSize, int nPattern)
        {
            mCenter = new double[vSize];
            mMember = new int[nPattern];
        }

        public double getCenter(int index)
        {
            return mCenter[index];
        }
        
        public void setCenter(int index, double cValue)
        {
            mCenter[index] = cValue;
        }

        public int getMember(int index)
        {
            return mMember[index];
        }

        public void setMember(int index, int cValue)
        {
            mMember[index] = cValue;
        }

        public int getNumMembers()
        {
            return mNumMembers;
        }

        public void setNumMembers(int cValue)
        {
            mNumMembers = cValue;
        }
    }
    
    public static void main(String[] args)
    {
        initialize();
        runAlgorithm();

        // Show clusters.
        System.out.println("\nCluster Centers:");
        for(int i = 0; i < numClusters; i++)
        {
            System.out.println("\n\tCLUSTER " + i + " ==>[" + cluster.get(i).getCenter(0) + ", " + cluster.get(i).getCenter(1) + "]");
        }
        return;
    }
    
}