online.cs

svm 多类分类 输入多种色点

		        {
			        Q[i+1][j+1]=getQ(i,j);
		        }
	        }
	        Matrix_ni(R,Q,3);
        }

        public void UpdateR(int k)
        { 
            double[][] temp;
	        temp=new double [numS+2][];
            int i;
            int j;
	        for(i=0;i<numS+2;i++)
	        {
		        temp[i]=new double [numS+2];
	        }
	        temp[0][0]=BetaB*BetaB;
	        for(i=1;i<numS+1;i++)
	        {
		        temp[0][i]=BetaB*Beta[S[i-1]];
	        }
	        temp[0][i]=BetaB;
	        for(i=1;i<numS+1;i++)
	        {
		        temp[i][0]=Beta[S[i-1]]*BetaB;
		        for(j=1;j<numS+1;j++)
		        {
			        temp[i][j]=Beta[S[i-1]]*Beta[S[j-1]];
		        }
		        temp[i][j]=Beta[S[i-1]];
	        }
	        temp[i][0]=BetaB;
	        for(j=1;j<numS+1;j++)
	        {
		        temp[i][j]=Beta[S[j-1]];
	        }
	        temp[i][j]=1;
	        for(i=0;i<numS+2;i++)
	        {
		        for(j=0;j<numS+2;j++)
		        {
			        temp[i][j]/=Gama[k];
		        }
	        }
	        for(i=0;i<numS+2;i++)
	        {
		        for(j=0;j<numS+2;j++)
		        {
			        R[i][j]=R[i][j]+temp[i][j];
		        }
	        }
        }

        public bool isInS(int s)
        {
            int i;
            for (i = 0; i < numS; i++)
            {
                if (S[i] == s)
                    break;
            }
            if (i == numS)
                return false;
            else
                return true;
        }

        public double getPG(int s)
        {
            return Gama[s] * PAlpha;
        }

        public double getPAlpha(int s)
        {
            return Beta[s] * PAlpha;
        }

        public double getPb()
        {
            return BetaB * PAlpha;
        }

        public void setPAlpha()
        {
            double[] TempA = new double[2 + count];
            TempA[0] = -G[count] / Gama[count];
            TempA[1] = error - Alpha[count];
            for (int i = 0; i < numS; i++)
            {
                double temp1 = -Alpha[S[i]] / Beta[S[i]];
                if (temp1 > 0)
                {
                    TempA[i + 2] = temp1;
                    continue;
                }
                double temp2 = (error - Alpha[S[i]]) / Beta[S[i]];
                if (temp2 > 0)
                {
                    TempA[i + 2] = temp2;
                }
            }
            for (int i = 0; i < numE; i++)
            {
                TempA[i + 2 + numS] = -G[E[i]] / Gama[E[i]];
            }
            for (int i = 0; i < numM; i++)
            {
                TempA[i + 2 + numS + numE] = -G[M[i]] / Gama[M[i]];
            }
            int k = 1;
            double min = TempA[1];
            for (int i = 0; i < 2 + count; i++)
            {
                if (i == 1 || TempA[i] < 0 || System.Math.Abs(TempA[i]) < 0.000001)
                {
                    continue;
                }
                if (min > TempA[i])
                {
                    min = TempA[i];
                    k = i;
                }
            }
            PAlpha = min;
            if (k == 0)
            {
                kind = 1;
                k = count;
            }
            else if (k == 1)
            {
                kind = 2;
                k = count;
            }
            else if (k > 1 && k < 2 + numS)
            {
                if (System.Math.Abs(Alpha[S[k - 2]] + min * Beta[S[k - 2]]) < 0.00001)
                {
                    kind = 3;
                }
                if (System.Math.Abs(Alpha[S[k - 2]] + min * Beta[S[k - 2]] - error) < 0.00001)
                {
                    kind = 4;
                }
                k = k - 2;//S
            }
            else if (k > numS + 1 && k < 2 + numS + numE)
            {
                kind = 5;
                k = k - numS - 2;//E
            }
            else
            {
                kind = 6;
                k = k - numS - numE - 2;//M
            }
            index = k;
        }

        public void UpdateA()
        {
            for (int i = 0; i < count; i++)
            {
                Alpha[i] += getPAlpha(i);
            }
            Alpha[count] += PAlpha;
        }

        public void UpdateG()
        {
            for (int i = 0; i < count + 1; i++)
            {
                G[i] += getPG(i);
            }
        }

        public void releaseR(int k)
        {
            k = k + 1;
            for (int i = 0; i < numS + 1; i++)
            {
                if (k == i)
                    continue;
                for (int j = 0; j < numS + 1; j++)
                {
                    if (j == k)
                        continue;
                    R[i][j] -= R[i][k] * R[k][j] / R[k][k];
                }
            }
            for (int i = k; i < numS + 1; i++)
            {
                for (int j = 0; j < numS + 1; j++)
                {
                    R[j][i] = R[j][i + 1];
                }
            }
            for (int i = k; i < numS + 1; i++)
            {
                for (int j = 0; j < numS; j++)
                {
                    R[i][j] = R[i + 1][j];
                }
            }
        }

        public void StoR(int k)
        {
            M[numM] = S[k];
            numM++;
            for (int i = k; i < numS; i++)
            {
                S[i] = S[i + 1];
            }
            numS--;
        }

        public void StoE(int k)
        {
            E[numE] = S[k];
            numE++;
            for (int i = k; i < numS; i++)
            {
                S[i] = S[i + 1];
            }
            numS--;
        }

        public void EtoS(int k)
        {
            S[numS] = E[k];
            numS++;
            for (int i = k; i < numE; i++)
            {
                E[i] = E[i + 1];
            }
            numE--;
        }

        public void RtoS(int k)
        {
            S[numS] = M[k];
            numS++;
            for (int i = k; i < numM; i++)
            {
                M[i] = M[i + 1];
            }
            numM--;
        }

        public void insertOne(int c)
        {
            setB();
            setBeta();
            setGama();
            setG();
            G[c] = getG(instance[c], type[c]);
            if (G[c] > 0)
            {
                M[numM] = c;
                numM++;
                return;
            }
            else
            {
                while (true)
                {
                    setPAlpha();
                    switch (kind)
                    {
                        case 1:
                            UpdateA();
                            S[numS] = c;
                            UpdateG();
                            UpdateR(c);
                            numS++;
                            return;
                        case 2:
                            UpdateA();
                            E[numE] = c;
                            UpdateG();
                            numE++;
                            return;
                        case 3:
                            UpdateA();
                            UpdateG();
                            releaseR(index);
                            StoR(index);
                            break;
                        case 4:
                            UpdateA();
                            UpdateG();
                            releaseR(index);
                            StoE(index);
                            break;
                        case 5:
                            UpdateA();
                            UpdateG();
                            setBeta(E[index]);
                            setGama(E[index]);
                            UpdateR(E[index]);
                            EtoS(index);
                            break;
                        case 6:
                            UpdateA();
                            UpdateG();
                            setBeta(M[index]);
                            setGama(M[index]);
                            UpdateR(M[index]);
                            RtoS(index);
                            break;
                    }
                    setBeta();
                    setGama();
                }
            }
        }

        public void run()
        {
            opt.run();
            count = 2;
            numS = 2;
            S[0] = 0; S[1] = 1;
            for (int i = 0; i < count; i++)
            {
                Alpha[i] = opt.optimalValue[i];
            }
            setR();
            while (count < number)
            {
                insertOne(count);
                count++;
            }
            setB();
        }

        public int getSign(double[] x)
        {
            double y;
            y = getF(x);
            if (y > 0)
                return 1;
            else if (y < 0)
                return -1;
            else
                return 0;
        }
    }
}