pralg.cs

模式识别--VISUAL C++环境下编写的贝叶斯分类器（bayes）,值得收藏

using System;
using System.Data;

namespace PRAlg
{
	/// <summary>
	/// Summary description for Class1.
	/// </summary>
	public class PRAlgClass
	{
		private double[][] FemaleSample;
		private double[][] MaleSample;
		private int length1;
		private int length2;
		private double[] a;

		public PRAlgClass(DataSet dt1,DataSet dt2)
		{
			length1=dt1.Tables[0].Rows.Count;
			length2=dt2.Tables[0].Rows.Count;

			FemaleSample=new double[length1][];
			MaleSample=new double[length2][];
			for(int i=0;i<length1;i++)
			{
				FemaleSample[i]=new double[2];
				FemaleSample[i][0]=double.Parse((String)dt1.Tables[0].Rows[i]["height"]);
				FemaleSample[i][1]=double.Parse((String)dt1.Tables[0].Rows[i]["weight"]);			
			}
			for(int i=0;i<length2;i++)
			{
				MaleSample[i]=new double[2];
				MaleSample[i][0]=double.Parse((String)dt2.Tables[0].Rows[i]["height"]);
				MaleSample[i][1]=double.Parse((String)dt2.Tables[0].Rows[i]["weight"]);			
			}

			a=new double[2];
			a[0]=4;
			a[1]=6;
		}
		private double[] GetU(double[][] TrainSample)
		{
			double[] u=new double[2];
			u[0]=0;
			u[1]=0;
			for(int i=0;i<TrainSample.Length;i++)
			{
				u[0]+=TrainSample[i][0];
				u[1]+=TrainSample[i][1];
			}
			u[0]=u[0]/TrainSample.Length;
			u[1]=u[1]/TrainSample.Length;
			return u;
		}	
		private double GetU(double[][] TrainSample,int k)
		{
			double u=0;
			for(int i=0;i<TrainSample.Length;i++)
			{
				u+=TrainSample[i][k];
			}
			u=u/TrainSample.Length;
			return u;
		}		
		private double[][] GetSigma(double[] u,double[][] TrainSample)
		{
			double[][] sigma=new double[2][];
			sigma[0]=new double[2];
			sigma[0][0]=0;
			sigma[0][1]=0;
			sigma[1]=new double[2];
			sigma[1][0]=0;
			sigma[1][1]=0;

			for(int i=0;i<TrainSample.Length;i++)
			{
				double[] temp1=ArrayMinuse(TrainSample[i],u);
				double[][] temp2=ArrayMux(temp1,temp1);
				sigma=ArrayAdd(sigma,temp2);
			}
			sigma[0][0]=sigma[0][0]/TrainSample.Length;
			sigma[0][1]=sigma[0][1]/TrainSample.Length;
			sigma[1][0]=sigma[1][0]/TrainSample.Length;
			sigma[1][1]=sigma[1][1]/TrainSample.Length;

			return sigma;
		}
		private double[][] GetSigma2(double[] u,double[][] TrainSample)
		{
			double[][] sigma=new double[2][];
			sigma[0]=new double[2];
			sigma[0][0]=0;
			sigma[0][1]=0;
			sigma[1]=new double[2];
			sigma[1][0]=0;
			sigma[1][1]=0;

			for(int i=0;i<TrainSample.Length;i++)
			{
				double[] temp1=ArrayMinuse(TrainSample[i],u);
				double[][] temp2=ArrayMux(temp1,temp1);
				sigma=ArrayAdd(sigma,temp2);
			}
			sigma[0][0]=sigma[0][0]/TrainSample.Length;
			sigma[0][1]=0;
			sigma[1][0]=0;
			sigma[1][1]=sigma[1][1]/TrainSample.Length;

			return sigma;
		}
		private double GetSigma(double u,double[][] TrainSample,int k)
		{
			double sigma=0;

			for(int i=0;i<TrainSample.Length;i++)
			{
				sigma+=(TrainSample[i][k]-u)*(TrainSample[i][k]-u);
			}
			sigma=sigma/TrainSample.Length;
			return sigma;
		}
		private double[][] GetT(double[][] array)
		{
			double[][] array1=(double[][])array.Clone();
			double temp=array1[0][1];
			array1[0][1]=array1[1][0];
			array1[1][0]=temp;
			return array1;
		}
		private double[][] GetInvers(double[][] array)
		{
			double fenmu=GetAbs(array);
			double[][] array1=(double[][])array.Clone();
			double temp=array1[0][0];

			array1[0][0]=array1[1][1]/fenmu;
			array1[1][1]=temp/fenmu;
			array1[0][1]=-array1[0][1]/fenmu;
			array1[1][0]=-array1[1][0]/fenmu;
			
			return array1;
		}
		private double[][] ArrayAdd(double[][] array1,double[][] array2)
		{
			double[][] array3=(double[][])array1.Clone();
			array3[0][0]=array3[0][0]+array2[0][0];
			array3[0][1]=array3[0][1]+array2[0][1];
			array3[1][0]=array3[1][0]+array2[1][0];
			array3[1][1]=array3[1][1]+array2[1][1];
			return array3;

		}
		private double[] ArrayMinuse(double[] array1,double[] array2)
		{
			double[] array3=(double[])array1.Clone();
			array3[0]=array3[0]-array2[0];
			array3[1]=array3[1]-array2[1];
			return array3;
		}
		private double GetAbs(double[][] array)
		{
			double re=array[0][0]*array[1][1]-array[0][1]*array[1][0];
			return re;
		}

		private double[][] ArrayMux(double[] array1,double[] array2)
		{
			double[][] temp=new double[2][];
			temp[0]=new double[2];
			temp[0][0]=array1[0]*array2[0];
			temp[0][1]=array1[0]*array2[1];
			temp[1]=new double[2];
			temp[1][0]=array1[1]*array2[0];
			temp[1][1]=array1[1]*array2[1];
			return temp;
		}
		
		private double GI(double[] x,double[] ui,double[][] sigmai,double wi)
		{
			double re=0;
			double[] x_ui=ArrayMinuse(x,ui);
			double[] temp=new double[2];
			double[][] sigma=(double[][])sigmai.Clone();
			sigma=GetInvers(sigma);
			temp[0]=x_ui[0]*sigma[0][0]+x_ui[1]*sigma[1][0];
			temp[1]=x_ui[0]*sigma[0][1]+x_ui[1]*sigma[1][1];
			re=(-0.5)*(temp[0]*x_ui[0]+temp[1]*x_ui[1]);
			re=re-Math.Log(2*Math.PI,Math.E);
			re=re-Math.Log(GetAbs(sigmai),Math.E)*(0.5);
			re=re+Math.Log(wi,Math.E);
			return re;			
		}
		
		private double GI(double x,double ui,double sigmai,double wi)
		{
			double re=0;
			re=re-(0.5)*(x-ui)*(x-ui)/sigmai;
			re=re-Math.Log(2*Math.PI,Math.E);
			re=re-Math.Log(sigmai,Math.E)*(0.5);
			re=re+Math.Log(wi,Math.E);
			return re;			
		}
		
		public bool IsMale(double[] sample,double wi)
		{
			double male=GI(sample,GetU(MaleSample),GetSigma(GetU(MaleSample),MaleSample),wi);
			double female=GI(sample,GetU(FemaleSample),GetSigma(GetU(FemaleSample),FemaleSample),(1-wi));
			if(male>female) return true;
			else return false;
		}
		public bool IsMale(double[] sample,int k,double wi)
		{
			double male=GI(sample[k],GetU(MaleSample,k),GetSigma(GetU(MaleSample,k),MaleSample,k),wi);
			double female=GI(sample[k],GetU(FemaleSample,k),GetSigma(GetU(FemaleSample,k),FemaleSample,k),(1-wi));
			if(male>female) return true;
			else return false;
		}
		public bool IsMale2(double[] sample,double wi)
		{
			double male=GI(sample,GetU(MaleSample),GetSigma2(GetU(MaleSample),MaleSample),wi);
			double female=GI(sample,GetU(FemaleSample),GetSigma2(GetU(FemaleSample),FemaleSample),(1-wi));
			if(male>female) return true;
			else return false;
		}
		public bool IsMale3(double[] sample,double wi)
		{
			double male=Math.Exp(GI(sample,GetU(MaleSample),GetSigma2(GetU(MaleSample),MaleSample),wi));
			double female=Math.Exp(GI(sample,GetU(FemaleSample),GetSigma2(GetU(FemaleSample),FemaleSample),(1-wi)));
			double p=male+female;
			male=male/p*a[0];
			female=female/p*a[1];
			if(male>female) return true;
			else return false;
		}
		public bool IsMale3(double[] sample,int k,double wi)
		{
			double male=Math.Exp(GI(sample[k],GetU(MaleSample,k),GetSigma(GetU(MaleSample,k),MaleSample,k),wi));
			double female=Math.Exp(GI(sample[k],GetU(FemaleSample,k),GetSigma(GetU(FemaleSample,k),FemaleSample,k),(1-wi)));
			if(male*a[0]>female*a[1]) return true;
			else return false;
		}
	}
}