Esempio n. 1
0
        public EMD()
        {
			
            X = new Node2Content[MAX_SIG_SIZE];
            for (var i = 0; i < X.Length; i++)
            {
                X[i] = new Node2Content();
                X[i].Pos = i;
            }
			
            rowsX = new Node2Content[MAX_SIG_SIZE];
            for (var i = 0; i < rowsX.Length; i++)
            {
                rowsX[i] = new Node2Content();
                rowsX[i].Pos = i;
                rowsX[i].LastNode = true;
            }
			
            colsX = new Node2Content[MAX_SIG_SIZE];
            for (var i = 0; i < colsX.Length; i++)
            {
                colsX[i] = new Node2Content();
                colsX[i].Pos = i;
                colsX[i].LastNode = true;
            }
        }
Esempio n. 2
0
        /// <param name="minI">
        /// </param>
        /// <param name="minJ">
        /// </param>
        /// <param name="prevUMinI">
        /// </param>
        /// <param name="prevVMinJ">
        /// </param>
        /// <param name="headU">
        /// </param>
        private void  addBasicVariable(int minI, int minJ, double[] s, double[] d, Node1Content prevUMinI, Node1Content prevVMinJ, Node1Content headU)
        {
            // TODO Auto-generated method stub
            double t;
			
			
            //passaggi per associare i nuovi valori agli array s e d
            if (System.Math.Abs(s[minI] - d[minJ]) <= EPSILON * maxW)
            {
                t = s[minI];
                s[minI] = 0;
                d[minJ] = d[minJ] - t;
            }
            else
            {
                if (s[minI] < d[minJ])
                {
                    t = s[minI];
                    s[minI] = 0;
                    d[minJ] = d[minJ] - t;
                }
                else
                {
                    t = d[minJ];
                    d[minJ] = 0;
                    s[minI] = s[minI] - t;
                }
            }
			
            isX[minI][minJ] = 1;
			
            endx.Val = t;
            endx.I = minI;
            endx.J = minJ;
            endx.NC = rowsX[minI];
            endx.NR = colsX[minJ];
			
            rowsX[minI] = endx;
            colsX[minJ] = endx;
            endx = X[endx.Pos + 1];
			
            if ((s[minI] == 0) && (headU.getNext().getNext().IsLast != true))
            {
                prevUMinI.setNext(prevUMinI.getNext().getNext());
            }
            else
            {
                prevVMinJ.setNext(prevVMinJ.getNext().getNext());
            }
        }
Esempio n. 3
0
        /// <param name="s1">
        /// </param>
        /// <param name="s2">
        /// </param>
        /// <returns>
        /// </returns>
        /// <throws>  SignatureSizeException  </throws>
        private double init(Signature s1, Signature s2, double[][] Dist)
        {
			
            int i, j;
            double sSum, dSum, diff;
			
			
            //n1 e n2 prendono la dimensione delle signature ( numero di cluster)
            n1 = s1.N;
            n2 = s2.N;
            isX = new int[MAX_SIG_SIZE1][];
            for (var i2 = 0; i2 < MAX_SIG_SIZE1; i2++)
            {
                isX[i2] = new int[MAX_SIG_SIZE1];
            }
            //creo una matrice n1xn2 per contenere i costi
            costMatrix = new float[MAX_SIG_SIZE1][];
            for (var i3 = 0; i3 < MAX_SIG_SIZE1; i3++)
            {
                costMatrix[i3] = new float[MAX_SIG_SIZE1];
            }
            //creo due array 
            s = new double[MAX_SIG_SIZE1];
            d = new double[MAX_SIG_SIZE1];
            //se il numero dei cluster delle signature � maggiore di MAX_SIG_SIZE1 
            //lancio un'eccezione
            if ((n1 > MAX_SIG_SIZE1) || (n2 > MAX_SIG_SIZE1))
            {
                throw new SignatureSizeException();
            }
            maxC = 0.0f;
			
            //per ogni i (da 0 a n1-1) ovvero per il numero di cluster della prima signature
            for (i = 0; i < n1; i++)
            {
                //per ogni j (da 0 a n2-1) ovvero per il numero di cluster della seconda signature
                for (j = 0; j < n2; j++)
                {
                    //UPGRADE_WARNING: Data types in Visual C# might be different.  Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
                    costMatrix[i][j] = (float) Dist[i][j];
                    //assegno a maxC il valore piu' grande della costMatrix 
                    if (costMatrix[i][j] > maxC)
                    {
                        maxC = costMatrix[i][j];
                    }
                }
            }
			
			
            var nodenull = new Node2Content();
            nodenull.LastNode = true;
			
			
            //Inizializzo a 0.0f sSum 
            sSum = 0.0f;
            //per ogni cluster della signature 1 assegno ad s[i] il peso associato al cluster i-esimo
            // e sSum prende la somma di tutti i pesi;
            for (i = 0; i < n1; i++)
            {
                s[i] = s1.getWeight(i);
                sSum = sSum + s[i];
                //			rowsX[i] = null;
            }
			
            //Inizializzo a 0.0f dSum 
            dSum = 0.0f;
            //per ogni cluster della signature 2 assegno ad d[j] il peso associato al cluster j-esimo
            // e dSum prende la somma di tutti i pesi;
            for (j = 0; j < n2; j++)
            {
                d[j] = s2.getWeight(j);
                dSum = dSum + d[j];
                //			colsX[j]=null;
            }
			
            // la variabile diff prende la differenza delle somme dei pesi (tot) della signature1 e signature2
            diff = sSum - dSum;
			
            if ((System.Math.Abs(diff)) >= (EPSILON * sSum))
            {
                if (diff < 0.0f)
                {
                    //per ogni cluster della signature2 costMatrix n1-j prende 0
                    for (j = 0; j < n2; j++)
                    {
                        costMatrix[n1][j] = 0;
                    }
                    s[n1] = - diff;
                    rowsX[n1] = nodenull;
                    n1++;
                }
                else
                {
                    //per ogni cluster della signature1 costMatrix n2-j prende 0
                    for (i = 0; i < n1; i++)
                    {
                        costMatrix[i][n2] = 0;
                    }
                    d[n2] = diff;
                    colsX[n2] = nodenull;
                    n2 = n2 + 1;
                }
            }
			
            //Inizializzo a 0 tutto l'array bidimensionale n1xn2 isX
            for (i = 0; i < n1; i++)
            {
                for (j = 0; j < n2; j++)
                {
                    isX[i][j] = 0;
                }
            }
            endx = X[0];
			
			
            //assegno a maxW il maggiore tra il totale dei pesi tra la signature1 e signature2
            maxW = sSum > dSum?sSum:dSum;
			
            //chiamo la funzione russel
            russel(s, d);
			
			
            //  _EnterX = _EndX++;  /* AN EMPTY SLOT (ONLY _n1+_n2-1 BASIC VARIABLES) */
            enterX = X[endx.Pos];
            endx = X[endx.Pos + 1];
			
			
			
            //ritorno il minimo tra le somme dei pesi tra la signature1 e signature2
            return sSum > dSum?dSum:sSum;
        }
Esempio n. 4
0
        /// <param name="loop">
        /// </param>
        /// <returns>
        /// </returns>
        /// <throws>  FindLoopException  </throws>
        private int findLoop(Node2Content[] loop)
        {
			
            int i, steps;
            Node2Content newX;
            Node2Content curX;
			
            int[] isUsed;
            var pos = 0;
			
            isUsed = new int[2 * MAX_SIG_SIZE1];
			
            for (i = 0; i < n1 + n2; i++)
            {
                isUsed[i] = 0;
            }
			
			
			
            curX = loop[0] = enterX;
            //		curX=enterX;
            newX = curX;
			
            isUsed[enterX.Pos] = 1;
            steps = 1;
			
            do 
            {
                //			printArray(loop,steps);
                if (steps % 2 == 1)
                {
                    newX = rowsX[newX.I];
                    //				newX.setPos(pos);
                    while ((newX.IsLast != true) && (isUsed[newX.Pos] != 0))
                    {
                        newX = newX.NC;
                    }
                }
                else
                {
                    newX = colsX[newX.J];
                    //				newX.setPos(pos);
                    while ((newX.IsLast != true) && (isUsed[newX.Pos] != 0) && (!(newX.Equals(enterX))))
                    {
                        newX = newX.NR;
                    }
                    if (newX.Equals(enterX))
                    {
                        break;
                    }
                }
				
                if (!newX.IsLast)
                {
                    loop[pos + 1] = newX;
                    curX = loop[pos + 1];
                    pos++;
                    isUsed[newX.Pos] = 1;
                    steps = steps + 1;
                }
                else
                {
					
                    do 
                    {
                        newX = curX;
                        do 
                        {
                            if (steps % 2 == 1)
                            {
                                newX = newX.NR;
                            }
                            else
                            {
                                newX = newX.NC;
                            }
                        }
                        while ((newX.IsLast != true) && (isUsed[newX.Pos] != 0));
						
                        if (newX.IsLast == true)
                        {
                            isUsed[curX.Pos] = 0;
                            curX = loop[pos - 1];
                            pos--;
							
                            steps = steps - 1;
                        }
                    }
                    while ((newX.IsLast == true) && (pos >= 0));
					
                    isUsed[curX.Pos] = 0;
                    curX = loop[pos] = newX;
                    isUsed[newX.Pos] = 1;
                }
            }
            while (pos >= 0);
			
            if (pos == 0)
            {
                throw new FindLoopException();
            }
			
            return steps;
        }
Esempio n. 5
0
        private void  printArray(Node2Content[] loop, int steps)
        {
			
            System.Console.Out.Write("Loop= {");
            for (var i = 0; i < steps; i++)
            {
                System.Console.Out.Write("( ");
                System.Console.Out.Write(loop[i].I);
                System.Console.Out.Write(" ");
                System.Console.Out.Write(loop[i].J);
                System.Console.Out.Write(" ");
                System.Console.Out.Write(loop[i].Val);
                System.Console.Out.Write(" )");
            }
            System.Console.Out.WriteLine("}");
        }
Esempio n. 6
0
        /// <throws>  FindLoopException  </throws>
        /// <summary> 
        /// </summary>
        private void  newSol()
        {
			
            int i, j, k;
            double xMin;
            int steps;
            Node2Content[] Loop;
            Node2Content curX, leaveX = null;
			
			
            i = enterX.I;
            j = enterX.J;
            isX[i][j] = 1;
            enterX.NC = rowsX[i];
            enterX.NR = colsX[j];
            enterX.Val = 0;
            rowsX[i] = enterX;
            colsX[j] = enterX;
			
			
            Loop = new Node2Content[MAX_SIG_SIZE1];
            for (i = 0; i < n1 + n2; i++)
            {
				
                Loop[i] = new Node2Content();
                Loop[i].Pos = i;
            }
			
            steps = findLoop(Loop);
			
            xMin = INFINITY;
            for (k = 1; k < steps; k = k + 2)
            {
                if (Loop[k].Val < xMin)
                {
                    leaveX = Loop[k];
                    xMin = Loop[k].Val;
                }
            }
			
            for (k = 0; k < steps; k = k + 2)
            {
                Loop[k].Val = Loop[k].Val + xMin;
                Loop[k + 1].Val = Loop[k + 1].Val - xMin;
            }
			
			
            i = leaveX.I;
            j = leaveX.J;
            isX[i][j] = 0;
            if (rowsX[i].Equals(leaveX))
            {
                rowsX[i] = leaveX.NC;
            }
            else
            {
                for (curX = rowsX[i]; curX.IsLast != true; curX = curX.NC)
                {
                    if (curX.NC.Equals(leaveX))
                    {
                        curX.NC = curX.NC.NC;
                        break;
                    }
                }
            }
            if (colsX[j].Equals(leaveX))
            {
                colsX[j] = leaveX.NR;
            }
            else
            {
                for (curX = colsX[j]; curX.IsLast != true; curX = curX.NR)
                {
                    if (curX.NR.Equals(leaveX))
                    {
                        curX.NR = curX.NR.NR;
                        break;
                    }
                }
            }
            enterX = leaveX;
        }