⭐ 欢迎来到虫虫下载站! | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站

📄 frank.cs

📁 svm 多类分类 输入多种色点
💻 CS
字号:
using System;
using System.Collections.Generic;
using System.Text;

namespace olsvm
{
    class Frank
    {
        protected int NN;
        protected int MM;
        protected double precision;
        protected int k;
        protected double[][] H;
        protected double[] C;
        protected double[] B;
        protected double[][] A;
        protected double[] X;
        protected double[] XBASIC;
        protected double[] Y;
        protected double[] grand;
        protected double step;

        public Frank(int n, int m)
        {
            NN = n;
            MM = m;
            H = new double[n][];
            for (int i = 0; i < n; i++)
            {
                H[i] = new double[n];
            }
            C = new double[n];
            B = new double[m];
            A = new double[m][];
            for (int i = 0; i < m; i++)
            {
                A[i] = new double[n];
            }
            X = new double[n];
            XBASIC = new double[n];
            Y = new double[n];
            grand = new double[n];
        }

        public void master(double pre, int K, double[][] h, double[] c, double[] b, double[][] a, double[] x, double[] xbasic, double[] y, double[] gra, double STEP)
        {
            getData(pre, K, h, c, b, a, x, xbasic, y, gra, STEP);
            basicAnswer();
            for (int i = 0; i < NN; i++)
                X[i] = XBASIC[i];
            while(true)
            {
                caculateGrand();
                linearPrg();
                if(stop())
                    break;
                caculateStep();
                if (step <= 0.001 && step >= 0 || step >= -0.001 && step <= 0)
                {
                    break;
                }
                nextX();
            }
            double sum = 0;
            for (int i = 0; i < NN; i++)
            {
                for (int j = 0; j < NN; j++)
                    sum += X[i] * X[j] * H[i][j];
            }
            sum = sum / 2.0;
            for (int i = 0; i < NN; i++)
                sum += X[i] * C[i];
            for (int i = 0; i < MM; i++)
            {
                double dd = 0;
                for (int j = 0; j < NN; j++)
                    dd += A[i][j] * X[j];
            }
        }

        public void getData(double pre, int K, double[][] h, double[] c, double[] b, double[][] a, double[] x, double[] xbasic, double[] y, double[] gra, double STEP)
        {
            precision = pre;
            k = K;
            step = 0;
            for (int i = 0; i < NN; i++)
            {
                C[i] = c[i];
                X[i] = 0;
                XBASIC[i] = 0;
                Y[i] = 0;
                grand[i] = 0;
                for (int j = 0; j < NN; j++)
                {
                    H[i][j] = h[i][j];
                }
            }
            for (int i = 0; i < MM; i++)
            {
                B[i] = b[i];
                for (int j = 0; j < NN; j++)
                {
                    A[i][j] = a[i][j];
                }
            }
        }

        public void basicAnswer()
        { 
            double[][] table;//动态分配
	        table=new double[MM+1][];
	        for(int i=0;i<MM+1;i++)
	        {
		        table[i]=new double[NN+MM+3];
	        }
	        for(int i=0;i<MM+1;i++)
	        {
		        for(int j=0;j<NN+MM+3;j++)
		        {
			        table[i][j]=0;
		        }
	        }
	        for(int i=0; i<MM; i++)
		        table[0][i+3+NN]=1;
	        for(int i=0; i<MM; i++)
	        {
		        table[i+1][0]=NN+i+1;
		        table[i+1][1]=0;
		        table[i+1][2]=B[i];
	        }
	        for(int i=0; i<MM; i++)
	        {
		        for(int j=0; j<NN; j++)
		        {
			        table[i+1][j+3]=A[i][j];
		        }
		        table[i+1][NN+3+i]=1;
	        }
	        for(int i=0; i<MM; i++)
		        table[i+1][1]=1;
	        int col=0;
	        int row=0;
	        while(true)
	        {
		        col=ba_findcol(table);
		        if(col == -1)
			        break;
		        row=ba_findrow(table, col);
		        ba_trans(table, col, row);
	        }
	        for(int i=0; i<MM; i++)
	        {
		        XBASIC[(int)(table[i+1][0])-1]=table[i+1][2];
	        }
        }

        public int ba_findcol(double[][] table)
        {
            int col = -1;
            double minval = 0.0;
            double val = 0.0;
            for (int i = 0; i < MM + NN; i++)
            {
                double sum = 0;
                for (int j = 1; j < MM + 1; j++)
                    sum += table[j][1] * table[j][i + 3];
                val = table[0][i + 3] - sum;
                if (minval > val)
                {
                    minval = val;
                    col = i + 3;
                }
            }
            return col;
        }

        public int ba_findrow(double[][] table, int col)
        {
            int row = -1;
            double minval = 0.0;
            double val = 0.0;
            bool firstval = true;
            for (int i = 0; i < MM; i++)
            {
                if (table[i + 1][col] < 0)
                    continue;
                val = table[i + 1][2] / table[i + 1][col];
                if (firstval)
                {
                    row = i + 1;
                    minval = val;
                    firstval = false;
                }
                else
                {
                    if (val < minval)
                    {
                        row = i + 1;
                        minval = val;
                    }
                }
            }
            return row;
        }

        public void ba_trans(double[][] table, int col, int row)
        {
            table[row][0] = (double)(col - 2);
            table[row][1] = table[0][col];
            table[row][2] = table[row][2] / table[row][col];
            double a = table[row][col];
            for (int i = 0; i < MM + NN; i++)
            {
                table[row][i + 3] = table[row][i + 3] / a;
            }
            for (int i = 0; i < MM; i++)
            {
                if (i == row - 1)
                    continue;
                double t = table[i + 1][col];
                for (int j = 0; j < MM + NN + 1; j++)
                {
                    table[i + 1][j + 2] = table[i + 1][j + 2] - t * table[row][j + 2];
                }
            }
        }

        public void linearPrg()
        { 
            double[][] btable;
	        btable=new double[MM+1][];
	        for(int i=0;i<MM+1;i++)
	        {
		        btable[i]=new double[NN+MM+3];
	        }
	        for(int i=0;i<MM+1;i++)
	        {
		        for(int j=0;j<NN+MM+3;j++)
		        {
			        btable[i][j]=0;
		        }
	        }
	        for(int i=0; i<MM; i++)
		        btable[0][i+3+NN]=1;
	        for(int i=0; i<MM; i++)
	        {
		        btable[i+1][0]=NN+i+1;
		        btable[i+1][1]=0;
		        btable[i+1][2]=B[i];
	        }
	        for(int i=0; i<MM; i++)
	        {
		        for(int j=0; j<NN; j++)
		        {
			        btable[i+1][j+3]=A[i][j];
		        }
		        btable[i+1][NN+3+i]=1;
	        }
	        for(int i=0; i<MM; i++)
		        btable[i+1][1]=1;
	        int col=0;
	        int row=0;
	        while(true)
	        {
		        col=ba_findcol(btable);
		        if(col == -1)
			        break;
		        row=ba_findrow(btable, col);
		        ba_trans(btable, col, row);
	        }

	        double[][] table;
	        table=new double[MM+1][];
	        for(int i=0;i<MM+1;i++)
	        {
		        table[i]=new double[NN+3];
	        }
	        for(int i=0;i<MM+1;i++)
	        {
		        for(int j=0;j<NN+3;j++)
		        {
			        table[i][j]=0;
		        }
	        }
	        for(int i=0; i<NN; i++)
		        table[0][i+3]=grand[i];
	        for(int i=0; i<NN+3; i++)
	        {
		        if(i == 1)
		        {
			        for(int j=0; j<MM; j++)
			        {
				        table[j+1][i]=table[0][(int)table[j+1][0]+2];
			        }
		        }
		        else
		        {
			        for(int j=0; j<MM; j++)
			        {
				        table[j+1][i]=btable[j+1][i];
			        }
		        }
	        }
	        //单纯性迭代
	        row=0;
	        col=0;
	        while(true)
	        {
		        col=lp_findcol(table);
		        if(col == -1)
			        break;
		        row=lp_findrow(table,col);
		        lp_trans(table, col, row);
	        }
	        for(int i=0; i<NN; i++)
		        Y[i]=0;
	        for(int i=0; i<MM; i++)
	        {
		        Y[(int)table[i+1][0]-1]=table[i+1][2];
	        }
        }

        public bool stop()
        {
            double sum = 0;
            for (int i = 0; i < NN; i++)
            {
                sum = sum + grand[i] * (Y[i] - X[i]);
            }
            if (System.Math.Abs(sum) >= precision)
                return false;
            else
                return true;
        }

        public void caculateStep()
        {
            double[] a;
            a = new double[NN];
            double[] b;
            b = new double[NN];
            for (int i = 0; i < NN; i++)
            {
                a[i] = 0;
                b[i] = 0;
            }
            double m = 0.0;
            double n = 0.0;
            for (int i = 0; i < NN; i++)
            {
                a[i] = Y[i] - X[i];
                b[i] = X[i];
            }
            for (int i = 0; i < NN; i++)
            {
                for (int j = 0; j < NN; j++)
                {
                    m = m + H[i][j] * a[i] * a[j];
                    n = n + H[i][j] * (a[i] * b[j] + a[j] * b[i]);
                }
            }
            for (int i = 0; i < NN; i++)
            {
                n = n + 2 * a[i] * C[i];
            }
            if (m >= 0)
            {
                if (-1.0 * n / (2.0 * m) <= 0)
                    step = 0;
                else if (-1.0 * n / (2.0 * m) >= 1)
                    step = 1;
                else
                    step = -1.0 * n / (2.0 * m);
            }
            else
            {
                if (-1.0 * n / (2.0 * m) <= 0)
                    step = 1;
                else if (-1.0 * n / (2.0 * m) >= 1)
                    step = 0;
                else if (-1.0 * n / (2.0 * m) <= 0.5)
                    step = 1;
                else
                    step = 0;
            }
        }

        public void nextX()
        {
	        for(int i=0; i<NN; i++)
	        {
		        X[i]=X[i]+step*(Y[i]-X[i]);
	        }
	        k=k+1;
        }

        public void caculateGrand()
        {
            for (int i = 0; i < NN; i++)
            {
                grand[i] = 0;
                for (int j = 0; j < NN; j++)
                    grand[i] = grand[i] + H[i][j] * X[j];
                grand[i] = grand[i] + C[i];
            }
        }

        public int lp_findcol(double[][] table)
        {
	        int col=-1;
	        double minval=0.0;
	        double val=0.0;
	        for(int i=0; i<NN; i++)
	        {
		        double sum=0;
		        for(int j=1; j<MM+1; j++)
			        sum += table[j][1]*table[j][i+3];
		        val=table[0][i+3]-sum;
		        if(val < minval)
		        {
			        minval=val;
			        col=i+3;
		        }
	        }
	        return col;
        }

        public int lp_findrow(double[][] table, int col)
        {
	        int row=-1;
	        double minval=0.0;
	        double val=0.0;
	        bool firstval=true;
	        for(int i=0; i<MM; i++)
	        {
		        if(table[i+1][col] < 0)
			        continue;
		        val=table[i+1][2]/table[i+1][col];
		        if(firstval)
		        {
			        row=i+1;
			        minval=val;
			        firstval=false;
		        }
		        else
		        {
			        if(val < minval)
			        {
				        row=i+1;
				        minval=val;
			        }
		        }
	        }
	        return row;
        }

        public void lp_trans(double[][] table, int col, int row)
        {
	        table[row][0]=(double)(col-2);
	        table[row][1]=table[0][col];
	        table[row][2]=table[row][2]/table[row][col];
	        double a=table[row][col];
	        for(int i=0; i<NN; i++)
	        {
		        table[row][i+3]=table[row][i+3]/a;
	        }
	        for(int i=0; i<MM; i++)
	        {
		        if(i == row-1) 
			        continue;
		        double t=table[i+1][col];
		        for(int j=0; j<NN+1; j++)
		        {
			        table[i+1][j+2]=table[i+1][j+2]-t*table[row][j+2];
		        }
	        }
        }
    }
}

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -