shixi.java

饼状图的描述 ~统计的分配问题。输入数据后得到各个数据所占百分比

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class Shixi extends JFrame implements ActionListener{
	JTextField fieldAmount = new JTextField(10);
	JTextField fieldBegin = new JTextField(10);
	JTextField fieldEnd = new JTextField(10);
	JTextField result = new JTextField(60);
	JButton buttonOperate = new JButton("最小二乘法: ");
	JTextField fieldResult = new JTextField(13);
	JTable table = new JTable(20,6);

	Shixi(){
		Container con = this.getContentPane();
		JScrollPane scrollPane = new JScrollPane(table);
		con.add(scrollPane, BorderLayout.CENTER);
		JPanel northPanel = new JPanel();
		JPanel southPanel = new JPanel();
		northPanel.setLayout(new FlowLayout());
		northPanel.add(new JLabel("请输入自变量数目(1--10)："));
		northPanel.add(fieldAmount);
		northPanel.add(new JLabel("请输入数据条数(1--20)"));
		northPanel.add(fieldBegin);
		//northPanel.add(new JLabel("终点号(从0计数)"));
		//northPanel.add(fieldEnd);
		northPanel.add(buttonOperate);
		buttonOperate.addActionListener(this);
		southPanel.add(new JLabel("计算结果:"));
		southPanel.add(result);
		con.add(northPanel, BorderLayout.NORTH);
		con.add(southPanel, BorderLayout.SOUTH);
		//con.add(result, BorderLayout.SOUTH);
		setSize(800, 320);
		setTitle("最小二乘");
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setVisible(true);
	}
	public void actionPerformed(ActionEvent e){
		JButton current = (JButton)e.getSource();
		if (current == buttonOperate){
			String strAmount = fieldAmount.getText();
			strAmount = strAmount.trim();
			int amount = 0;
			try{
				amount = Integer.valueOf(strAmount).intValue();
			}
			catch(NumberFormatException ne){
				JOptionPane.showMessageDialog(this, "您所输入数据不合法，请重新输入！");
				return;
			}
			if (amount <1 || amount >6){
				JOptionPane.showMessageDialog(this, "您所输入的自变量的个数不满足定义的大小");
				return;
			}
			String strLines = fieldBegin.getText();
			strLines = strLines.trim();
			int lines = 0;
			try{
				lines = Integer.valueOf(strLines).intValue();
			}
			catch(NumberFormatException ne){
				JOptionPane.showMessageDialog(this, "您所输入数据不合法，请重新输入！");
				return;
			}			
			if (lines <0 || lines>20){
				JOptionPane.showMessageDialog(this, "您所输入的数据条数不满足定义的大小");
				return;
			}	
			double [][] x = new double[lines][amount];  
			double [][] Y = new double[lines][1];
			double [][] X = new double[lines][amount+1];
			for (int i=0; i<lines; i++){
				for (int j=0; j<amount; j++){
					try{
						String strValue = (String)table.getValueAt(i, j);
						x[i][j] = Integer.parseInt(strValue);
						}
					catch(NumberFormatException ne){
						String info = "第 " + i + "行第 " + j + " 列的输入是负数，请修改为非负数！";
						JOptionPane.showMessageDialog(this, info);
						}
					}
				}
			
			/*for(int i = 0; i<lines;i++){
				for(int j = 0; j<amount;j++){
					System.out.print(x[i][j]+"   ");
				}
				System.out.println();
			}*/
			
			
			}
	}
	public static void main(String[] args){
		new Shixi();
	}
}
class Matrix{
	public double[][] data; //二维数组表示矩阵的数据
//构造方法1：构造一个data为null的矩阵。（data为空可以作为一种判断条件）：
	public Matrix(){
           data=null;
	}
//构造方法2：构造一个lines行，columns列的矩阵，元素均初始化为0.0：
	public Matrix(int lines, int columns){
		int i,j;
           for(i=0;i<lines;i++)
        	   for(j=0;j<columns;j++)
        		   data[i][j]=0.0;
	}
//构造方法3：把一个矩阵model构造作为构造方法的数据来源，初始化的结果是得到一个规模以及内容都一样的矩阵：
	public Matrix(Matrix model){
			this.data=new double[model.data.length][model.data[0].length];
			   for(int i=0;i<data.length;i++)
				  for(int j=0;j<model.data[0].length;j++)
					this.data[i][j]=model.data[i][j];
	}
//构造方法4：从一个二维数组构造data构造一个矩阵。注意数据要进行深拷贝。
	public Matrix(double[][] data){
		this.data=new double[data.length][data[0].length];
		for(int i=0;i<data.length;i++)
			this.data[i]=(double[])data[i].clone();
	}
//要求：矩阵本身和另一个矩阵addend是规模相同的矩阵，要把这两个矩阵相加，结果放在本矩阵中。当minus为真时，需要相减：
	public void addMatrix(Matrix addend, boolean minus){
            if(minus==false)
            	for(int i=0;i<addend.data.length;i++)
            		for(int j=0;j<addend.data[0].length;j++)
            			this.data[i][j]=this.data[i][j]+addend.data[i][j];
            else
              	for(int i=0;i<addend.data.length;i++)
            		for(int j=0;j<addend.data[0].length;j++)
            			this.data[i][j]=this.data[i][j]-addend.data[i][j];
	}
//矩阵的每一个元素都乘以系数coeff：
	public void multiplyNumber(double coeff){
           for(int i=0;i<this.data.length;i++)
        	   for(int j=0;j<this.data[0].length;j++)
        		   this.data[i][j]=coeff*this.data[i][j];
	}
//矩阵的第line行的每个元素都和系数coeff相乘：
	public void multiplyLine(int line, double coeff){
            for(int j=0;j<this.data[0].length;j++)
            	this.data[line][j]=coeff*this.data[line][j];
	}
//矩阵的第column列的每个元素都和系数coeff相乘：
	public void multiplyColumn(int column, double coeff){
		   for(int i=0;i<this.data.length;i++)
           	this.data[i][column]=coeff*this.data[i][column];
	}
//本矩阵和另外一个矩阵multiplier相乘，结果相乘的结果
	public Matrix multiplyMatrix(Matrix multiplier){
		Matrix mulResult=new Matrix(this.data.length,multiplier.data[0].length);
            for(int i=0;i<this.data.length;i++)
            	for(int j=0;j<multiplier.data[0].length;j++)
            		for(int k=0;k<this.data[0].length;k++)
            			mulResult.data[i][j]+=this.data[i][k]*multiplier.data[k][j];
            return mulResult;
	}
//矩阵初等变换：把矩阵的第source行的coeff倍加到第destine行：
	public void mergeLine(int source,  double coeff, int destine){
            for(int j=0;j<this.data[0].length;j++)
            	this.data[destine][j]+=coeff*this.data[source][j];
	}
//矩阵初等变换：把矩阵的第source列的coeff倍加到第destine列：
	public void mergeColumn(int source, double coeff, int destine){
            for(int i=0;i<this.data.length;i++)
            	this.data[i][destine]+=coeff*this.data[i][source];
	}
//交换矩阵的两行line1和line2：
	public void exchangeLines(int line1, int line2){
		double temp=0.0;
			for(int j=0;j<this.data[0].length;j++)
			{
				temp=this.data[line1][j];
				this.data[line1][j]=this.data[line2][j];
				this.data[line2][j]=temp;
			}
	}
//交换矩阵的两column1和column2：
	public void exchangeColumns(int column1, int column2){
		double temp=0.0;
		for(int i=0;i<this.data.length;i++)
		{
			temp=this.data[i][column1];
			this.data[i][column1]=this.data[i][column2];
			this.data[i][column2]=temp;
		}
	}
//矩阵拷贝（深拷贝）：把本矩阵的内容形成一个新矩阵，并返回：
	public Matrix copy(){
		Matrix newCopy=new Matrix(this.data.length,this.data[0].length);
		for(int i=0;i<data.length;i++)
			newCopy.data[i]=(double[])this.data[i].clone();
		return newCopy;
	}
//矩阵拷贝（深拷贝）：把本矩阵的内容拷贝给另一个新的矩阵destine：
	public void copyTo(Matrix destine){
		for(int i=0;i<data.length;i++)
			destine.data[i]=(double[])this.data[i].clone();
	}
//矩阵拷贝（深拷贝）：把矩阵source的内容拷贝到本矩阵，在拷贝前要把本矩阵的规模设置为source矩阵的规模：
	public void copyFrom(Matrix source){
            this.data=new double[source.data.length][source.data[0].length];
            for(int i=0;i<this.data.length;i++)
               this.data[i]=(double[])source.data[i].clone();
	}
//寻找从第beginLine行开始到最后一行中所有的第column列中元素最大的一个，并返回相应的行
	public int findMaxLine(int column, int beginLine){
		   double max;
		   max=this.data[beginLine][column];
           for(int i=beginLine;i<this.data.length;i++)
        	   if(max<this.data[i][column])
        		   max=this.data[i][column]; 
           return column;
	}
//矩阵转置：
	public Matrix turn(){
		Matrix newTurn=new Matrix(this.data[0].length,this.data.length);
		for(int i=0;i<this.data.length;i++)
			for(int j=0;j<this.data[0].length;j++)
				newTurn.data[j][i]=this.data[i][j];
		return newTurn;
	}
//矩阵求逆：
	public Matrix reverse(){
		int i ,j;
		Matrix result = new Matrix(this.data.length,this.data[0].length);
		for(i=0; i<this.data.length; i++){
			for(j=0 ; j<this.data[0].length;j++){
				if(i==j)
					result.data[i][j] = 1;
				else
					result.data[i][j] = 0;
			} 
		}
		//得到上三角矩阵
		for(i = 0; i<this.data.length; i++){
			int maxLine ;
			maxLine = this.findMaxLine(i, i);
			result.exchangeLines(i, maxLine);
			this.exchangeLines(i, maxLine);
			for(j = i+1; j<this.data.length; j++){
				result.mergeLine(i,  -this.data[j][i]/this.data[i][i], j);
				this.mergeLine(i,  -this.data[j][i]/this.data[i][i], j);
			}
		}	
		//将对角线变为1
		for(i = 0; i<this.data.length; i++){
			result.multiplyLine(i, 1/this.data[i][i]);
			this.multiplyLine(i, 1/this.data[i][i]);
			}	
		//将上三角矩阵变为单位矩阵
		for(i = this.data.length-1 ;i>=1;i--){
			for(j=i-1;j>=0; j--){
				result.mergeLine(i, -this.data[j][i], j);
				this.mergeLine(i, -this.data[j][i], j);
			}
		}
		return result;
	}
//矩阵元素显示（测试和调试程序时用）：
	public void show(){
		for(int i=0;i<this.data.length;i++)
		{
			for(int j=0;j<this.data[0].length;j++)
				System.out.print(this.data[i][j]+" ");
		    System.out.println();
		}
	}
//静态方法：两个矩阵augend和addend相加（如果minus为true则相减），返回结果矩阵：
	public static Matrix staticMatrixAdd(Matrix augend, Matrix addend, boolean minus){
		Matrix p=new Matrix(augend.data.length,augend.data[0].length);
		if(minus==false)
        	for(int i=0;i<augend.data.length;i++)
        		for(int j=0;j<augend.data[0].length;j++)
        			p.data[i][j]=augend.data[i][j]+addend.data[i][j];
        else
        	for(int i=0;i<augend.data.length;i++)
        		for(int j=0;j<addend.data[0].length;j++)
        			p.data[i][j]=augend.data[i][j]+addend.data[i][j];
		return p;
		
	}
//静态方法：矩阵basic和系数coeff相乘，返回结果矩阵：
	public static Matrix staticMultiplyNumber(Matrix basic, double coeff){
		Matrix p=new Matrix(basic.data.length,basic.data[0].length);
		  for(int i=0;i<basic.data.length;i++)
       	   for(int j=0;j<basic.data[0].length;j++)
       		  p.data[i][j]=coeff*basic.data[i][j];
		  return p;
		
	}
//静态方法：两个矩阵left和right相乘，返回结果矩阵：
	public static Matrix staticMultiplyMatrix(Matrix left, Matrix right){
           //可以调用public Matrix multiplyMatrix(Matrix multiplier)
		Matrix p=new Matrix(left.data.length,right.data[0].length);
		p=left.multiplyMatrix(right);
		return p;
	}
//最小二乘法：xBlock中存放自变量数据，yVertical中存放因变量数据，结果是由系数构成的矩阵：
	//public static Matrix regress(double[][] xBlock, double[] yVertical){
         
	//}
}