java矩阵类的Vector支持

这个是写java版本Matrix的Vector，即向量类，提供了一些方法，当然某些算法还存在着错误。

线性代数啊，大学的线性代数很有用啊！！！！这个和数据结构有些关系，如果你感兴趣的话，可以尝试写下Stack。

package Matrix;

import java.io.Serializable;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

public class Vector implements Serializable{
	/**
	 * 
	 */
	private static final long serialVersionUID = 1259301592893280580L;
	private int MaxSize;
	private double[] vectorArray;
	private int cursor;
	public Vector(int MaxSize){
		this.MaxSize=MaxSize;
		vectorArray=new double[this.MaxSize];
		this.cursor=-1;
	}
	public double[] add(double s){
		vectorArray[++cursor]=s;
		return vectorArray;
	}
	public double add(int cursors,double s){
		return vectorArray[cursors]=s;
	}
	public double peek(int cursor){
		return vectorArray[cursor];
	}
	public double[] remove(double s){
		Map<Double,Integer> map=new HashMap<Double,Integer>();
		for(int i=0;i<vectorArray.length;i++){
			int count=0;
			for(int j=0;j<vectorArray.length;j++){
				if(vectorArray[j]==s){
					map.put((double)i, count++);
				}
			}
		}
		for(int i=0;i<vectorArray.length;i++){
			for(int j=0;j<i;j++){
				if(vectorArray[j]==s){
					double temp=vectorArray[i];
					vectorArray[i]=vectorArray[j];
					vectorArray[j]=temp;
				}
			}
		}
		double[] newvectorArray=new double[map.size()];
		System.out.println(map.size());
		for(int i=0;i<newvectorArray.length;i++){
			newvectorArray[i]=vectorArray[i];
		}
		System.out.println(Arrays.toString(vectorArray));
		return newvectorArray;
	}
	public Vector vecAdd(Vector vector){
		Vector newVector=new Vector(this.length());
		if(this.length()==vector.length()){
			for(int i=0;i<vector.length();i++){
				newVector.add(i, (this.peek(i)+vector.peek(i)));
			}
		}else{
			try{
				throw new Exception("请确认该向量的长度");
			}catch(Exception e){
				e.printStackTrace();
			}
		}
		return newVector;
	}
	public Vector vecMinus(Vector vector){
		Vector newVector=new Vector(this.length());
		if(this.length()==vector.length()){
			for(int i=0;i<vector.length();i++){
				newVector.add(i, (this.peek(i)-vector.peek(i)));
			}
		}else{
			try{
				throw new Exception("请确认该向量的长度");
			}catch(Exception e){
				e.printStackTrace();
			}
		}
		return newVector;
	}
	/**
	 * mutiple 
	 * */
	public Vector vecMutipleConstant(double K){
		Vector vector=new Vector(this.length());
		for(int i=0;i<this.length();i++){
			vector.add(i, this.peek(i)*K);
		}
		return vector;
	}
	/**
	 * mutiple by vector
	 * */
	public double vecMutipleVector(Vector vector){
		double d=0;
		if(this.length()==vector.length()){
			for(int i=0;i<this.length();i++){
				d+=this.peek(i)*vector.peek(i);
			}
		}
		return d;
	}
	/**
	 * the following method is to get the ABS of the vector
	 * */
	public Vector vecABS(){
		Vector vector=new Vector(this.length());
		for(int i=0;i<this.length();i++){
			vector.add(Math.abs(this.peek(i)));
		}
		return vector;
	}
	/**
	 * 求两个向量之间的夹角
	 * */
	public double getAngle(Vector vector){
		Vector vectorOne=this;
		double V1=vectorOne.FormVector(vectorOne);
		double V2=vector.FormVector(vector);
		double v3=vectorOne.vecMutipleVector(vector);
		if(V1*V2==0){
			try{
				throw new Exception("不好意思，出现了0向量");
			}catch(Exception e){
				e.printStackTrace();
			}
		}
		double e=(v3)/(V1*V2);
		double sita=Math.acos(e);
		return sita;
	}
	/**
	 * 向量的范数
	 * @param vector 待求的向量
	 * */
	public double FormVector(Vector vector){
		double e=vector.vecMutipleVector(vector);
		return Math.sqrt(e);
	}
	/**
	 * 向量的单位化
	 * 
	 * */
	public Vector formVector(){
		Vector vector=this.clone();
		double e=vector.FormVector(vector);
		if(e==0){
			try{
				throw new Exception("不好意思，零向量无法单位化");
			}catch(Exception E){
				E.printStackTrace();
			}
		}
		
		Vector newVector=vector.vecMutipleConstant(1/e);
		
		return newVector;
	}
	/**
	 * 将double 数组转换为vector
	 * */
	public static Vector toVector(double[] datas){
		Vector vector=new Vector(datas.length);
		vector.vectorArray=datas.clone();
		return vector;
	}
	
	/**
	 * 转换为double数组
	 * */
	public double[] toDoubleArray(){
		return this.vectorArray;
	}
	public Vector clone(){
		Vector vector=this;
		return vector;
	}
	public boolean isFull(){
		return (MaxSize==cursor);
	}
	public boolean isEmpty(){
		return (cursor==-1);
	}
	public String toString(){
		return Arrays.toString(vectorArray)+"\n";
	}
	public int length(){
		return vectorArray.length;
	}
}