matrix.c

贝叶斯分类程序,iris数据集,很有用,已测试

#include <math.h>
#include "global.h"

/////操作矩阵

void RangeValue()////行列式 
{
	int i,j,k,l,flag;
	
	double tempt_matrix[ATTRIBUTENUM][ATTRIBUTENUM];

	double tempt_value;

	for(i=0;i<CLASSTYPENUM;i++)
	{
		for(j=0;j<ATTRIBUTENUM;j++)
		{
			for(k=0;k<ATTRIBUTENUM;k++)
			{
				tempt_matrix[j][k]=covariance_estimation[i].covariance_estimation[j][k];
			}
		}		

		for(j=0;j<ATTRIBUTENUM;j++)
		{
			if(tempt_matrix[j][j]==0)
			{
				for(flag=j+1;flag<ATTRIBUTENUM;flag++)
				{
			    	if(tempt_matrix[flag][j]!=0)
					{
		    			break;
					}
				}
				
				if(flag<ATTRIBUTENUM)
				{
					for(l=j;l<ATTRIBUTENUM;l++)
					{
						tempt_value=tempt_matrix[j][l];
	    	    		tempt_matrix[j][l]=tempt_matrix[flag][l];
		        		tempt_matrix[flag][l]=tempt_value;
					}

				}
		    	else 
				{
	    			break;
				}
			}

			for(k=j+1;k<ATTRIBUTENUM;k++)
			{
		
				for(l=j+1;l<ATTRIBUTENUM;l++)
				{
					tempt_matrix[k][l]-=((double)(tempt_matrix[k][j]/tempt_matrix[j][j]))*((double)(tempt_matrix[j][l]));
				}
				
				  tempt_matrix[k][j]=0;
			}
		}
		
		if(flag==ATTRIBUTENUM)
		{
			range_value[i]=0;
		}

    	else
		{
			range_value[i]=1;
    		for (j=0;j<ATTRIBUTENUM;j++)
			{
	     		range_value[i]=((double)(tempt_matrix[j][j]))*((double)(range_value[i]));
			}

		}
	}
}

void StandardRangeValue()///完全可以投入使用
{
	float tempt_matrix[ATTRIBUTENUM][ATTRIBUTENUM];
	float tempt_value;
	float range_value;
	
	int i,j,k,l,flag;

	for(i=0;i<ATTRIBUTENUM;i++)
	{
		for(j=0;j<ATTRIBUTENUM;j++)
		{
			scanf("%f",&(tempt_matrix[i][j]));
		}
	}

	for(j=0;j<ATTRIBUTENUM;j++)
	{
		if(tempt_matrix[j][j]==0)
		{
			for(flag=j+1;flag<ATTRIBUTENUM;flag++)
			{
				if(tempt_matrix[flag][j]!=0)
				{
					break;
				}
			}

			if(flag<ATTRIBUTENUM)
			{
				for(l=j;l<ATTRIBUTENUM;l++)
				{
					tempt_value=tempt_matrix[j][l];
		    		tempt_matrix[j][l]=tempt_matrix[flag][l];
		    		tempt_matrix[flag][l]=tempt_value;
				}

			}
			else 
			{
				break;
			}
			
		}
		
		for(k=j+1;k<ATTRIBUTENUM;k++)
		{		//	
			for(l=j+1;l<ATTRIBUTENUM;l++)
			{
				tempt_matrix[k][l]-=((float)(tempt_matrix[k][j]/tempt_matrix[j][j]))*((float)(tempt_matrix[j][l]));
			}
				
				tempt_matrix[k][j]=0;
			
		}
	}	

	for(i=0;i<ATTRIBUTENUM;i++)
	{
		for(j=0;j<ATTRIBUTENUM;j++)
		{
			printf("%f   ",tempt_matrix[i][j]);
		}
		printf("\n");
	}

	if(flag==ATTRIBUTENUM)
	{
		range_value=0;
		printf("%f\n",range_value);
	}

	else
	{
		range_value=1;
		for (j=0;j<ATTRIBUTENUM;j++)
		{
			range_value*=tempt_matrix[j][j];
		}

		printf("%f\n",range_value);
	}
	
}

void ReverseMatrix()//矩阵求逆//可能还有bug
{
	int i,j,k,l,flag;

	double tempt_value;

	double extends_matrix[ATTRIBUTENUM][2*ATTRIBUTENUM];

	for(i=0;i<CLASSTYPENUM;i++)
	{
		for(j=0;j<ATTRIBUTENUM;j++)
		{
			for(k=0;k<ATTRIBUTENUM;k++)
			{
				extends_matrix[j][k]=covariance_estimation[i].covariance_estimation[j][k];
			}
		}

		for(j=0;j<ATTRIBUTENUM;j++)
		{
			for(k=ATTRIBUTENUM;k<2*ATTRIBUTENUM;k++)
			{
				extends_matrix[j][k]=0;
			}
		}

		for(j=0;j<ATTRIBUTENUM;j++)
		{
			extends_matrix[j][j+ATTRIBUTENUM]=1;
		}

		for(j=0;j<ATTRIBUTENUM;j++)
		{
			for(k=0;k<2*ATTRIBUTENUM;k++)
			{
	//			printf("%lf  ",extends_matrix[j][k]);
			}

//			printf("\n");
		}

	//	printf("\n");

		for(j=0;j<ATTRIBUTENUM;j++)
		{
			
				if(extends_matrix[j][j]==0)
				{
					for(flag=j+1;flag<ATTRIBUTENUM;flag++)
					{
			        	if(extends_matrix[flag][j]!=0)
						{
		        			break;
						}
					}
			 	
		    		if(flag<ATTRIBUTENUM)
					{
				    	for(l=j;l<2*ATTRIBUTENUM;l++)
						{
			    			tempt_value=extends_matrix[j][l];
	    	         		extends_matrix[j][l]=extends_matrix[flag][l];
		            		extends_matrix[flag][l]=tempt_value;
						}

					}
    		    	else 
					{
	         			break;
					}
				}
			for(k=0;k<ATTRIBUTENUM;k++)
			{
				if(k!=j)
				{
					for(l=j+1;l<2*ATTRIBUTENUM;l++)
					{
		    			extends_matrix[k][l]-=((double)(extends_matrix[k][j]/extends_matrix[j][j]))*((double)(extends_matrix[j][l]));
					}

	     		 	extends_matrix[k][j]=0;
				}
			}
		}

		if(flag<ATTRIBUTENUM)
		{
	    	for(j=0;j<ATTRIBUTENUM;j++)
			{
		    	tempt_value=extends_matrix[j][j];
			
		    	for(l=0;l<2*ATTRIBUTENUM;l++)
				{	
			    	extends_matrix[j][l]=(double)(extends_matrix[j][l]/tempt_value);

		    	//	printf("%lf  ",extends_matrix[j][l]);
				}

		    //	printf("\n");
			}

			for(j=0;j<ATTRIBUTENUM;j++)
			{
				for(l=0;l<ATTRIBUTENUM;l++)
				{
					covariance_estimation[i].covariance_estimation[j][l]=extends_matrix[j][l+ATTRIBUTENUM];

		//			printf("%lf  ",covariance_estimation[i].covariance_estimation[j][l]);
				}

	//			printf("\n");
			}
		
    //		printf("\n");
		}

		else
		{
//			printf("can't reverve");
				
//			printf("\n");
		}

	}
}


void StandardReverseMatrix()
{
	int j,k,l;
	double tempt_value;
	double extends_matrix[ATTRIBUTENUM][2*ATTRIBUTENUM];

	for(j=0;j<ATTRIBUTENUM;j++)
	{
		for(k=0;k<ATTRIBUTENUM;k++)
		{
			scanf("%lf",&(extends_matrix[j][k]));
		}
	}
	 
	for(j=0;j<ATTRIBUTENUM;j++)
	{
		for(k=ATTRIBUTENUM;k<2*ATTRIBUTENUM;k++)
		{
			extends_matrix[j][k]=0;
		}
	}

	for(j=0;j<ATTRIBUTENUM;j++)
	{
		extends_matrix[j][j+ATTRIBUTENUM]=1;
	}

	for(j=0;j<ATTRIBUTENUM;j++)
	{
		for(k=0;k<2*ATTRIBUTENUM;k++)
		{
			printf("%lf  ",extends_matrix[j][k]);
		}
		
		printf("\n");
	}

	printf("\n");

	for(j=0;j<ATTRIBUTENUM;j++)
	{
		for(k=0;k<ATTRIBUTENUM;k++)
		{
			if(k!=j)
			{
				for(l=j+1;l<2*ATTRIBUTENUM;l++)
				{
		    		extends_matrix[k][l]-=((double)(extends_matrix[k][j]/extends_matrix[j][j]))*((double)(extends_matrix[j][l]));
				}
				
				extends_matrix[k][j]=0;
			}
		}
	}

	for(j=0;j<ATTRIBUTENUM;j++)
	{
		tempt_value=extends_matrix[j][j];
		
		for(l=0;l<2*ATTRIBUTENUM;l++)
		{	
			extends_matrix[j][l]=(double)(extends_matrix[j][l]/tempt_value);

			printf("%lf  ",extends_matrix[j][l]);
		}
		
		printf("\n");
	}
}