vector.cs

在Visual 2008环境下

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

class Vector : ICloneable
{
    #region //Field
    /// <summary>
    /// 向量的数据
    /// </summary>
    private double[] vectorData = null;

    /// <summary>
    /// 记录向量是列向量或是行向量
    /// </summary>
    private bool isColumnVector;

    /// <summary>
    /// 向量元素的个数
    /// </summary>
    private int numElement;
    #endregion //Field

    #region //Property
    public double[] _VectorData
    {
        get
        {
            return vectorData;
        }
    }
    public bool _IsColumnVector
    {
        get
        {
            return isColumnVector;
        }
    }
    public int _NumElement
    {
        get
        {
            return numElement;
        }
    }
    #endregion //Property

    #region //Constructor
    /// <summary>
    /// 构造函数1，默认为列向量
    /// </summary>
    public Vector(double[] data)
    {
        if (data == null)
            return;

        vectorData = data;
        isColumnVector = true;
        numElement = data.GetLength(0);
    }

    /// <summary>
    /// 构造函数2，带有行向量或列向量的信息
    /// </summary>
    public Vector(double[] data, bool isColumn)
    {
        if (data == null)
            return;

        vectorData = data;
        isColumnVector = isColumn;
        numElement = data.GetLength(0);
    }

    /// <summary>
    /// 构造函数2，带有行向量或列向量及元素个数的信息
    /// </summary>
    public Vector(double[] data, bool isColumn, int num)
    {
        if ((data == null) || (num != data.GetLength(0)))
            return;

        vectorData = data;
        isColumnVector = isColumn;
        numElement = num;
    }
    #endregion //Constructor

    #region //Method
    /// <summary>
    /// 实现Vector对象的shallow copy
    /// </summary>
    public object Clone()
    {
        double[] resultData = (double[])vectorData.Clone();
        return new Vector(resultData, isColumnVector);
    }

    #region //Convert function
    /// <summary>
    /// 将向量元素转化为字符串(空格分开元素—行向量；换行符分开元素—列向量)
    /// </summary>
    public override String ToString()
    {
        if (this == null)
            return null;

        String str = "";
        String dividedstr = "\r\n";

        if (!this._IsColumnVector)
            dividedstr = " ";

        int num = this._NumElement;
        double[] data_va = this._VectorData;
        for (int k = 0; k < num; k++)
            str += data_va[k].ToString() + dividedstr;
        return str;
    }

    /// <summary>
    /// 将向量显式转化数组
    /// </summary>
    public static explicit operator double[](Vector va)
    {
        if (va == null)
            return null;

        return va._VectorData;
    }

    /// <summary>
    /// 将向量显式转化一行或一列矩阵
    /// </summary>
    public static explicit operator Matrix(Vector va)
    {
        if (va == null)
            return null;

        int num = va._NumElement;
        double[] data_va = va._VectorData;
        double[,] resultData = null;

        if (va._IsColumnVector)
        {
            resultData = new double[num, 1];
            for (int k = 0; k < num; k++)
                resultData[k, 0] = data_va[k];
        }
        else
        {
            resultData = new double[1, num];
            for (int k = 0; k < num; k++)
                resultData[0, k] = data_va[k];
        }

        return new Matrix(resultData);
    }
    #endregion //Convert function

    #region //矩阵、向量之间的转换
    /// <summary>
    /// 向量组转换为矩阵
    /// </summary>
    /// <param name="isnumequaltorow"></True—按行排列向量组；否则按列排列向量组>
    public static Matrix ConvertToMatrix(List<Vector> v_list, bool isnumequaltorow)
    {
        if (v_list == null)
            return null;

        for (int k = 0; k < v_list.Count; k++)
            if (v_list[k] == null)
                return null;

        int row = v_list.Count, col = v_list[0]._NumElement;
        double[] tempData_v = null;
        double[,] resultData = new double[row, col];

        for (int i = 0; i < row; i++)
        {
            tempData_v = v_list[i]._VectorData;
            for (int j = 0; j < col; j++)
                resultData[i, j] = tempData_v[j];
        }

        Matrix resultMatrix = new Matrix(resultData);
        if (!isnumequaltorow)
            resultMatrix = resultMatrix.MatrixTranspose();

        return resultMatrix;
    }

    /// <summary>
    /// 向量升维为矩阵
    /// </summary>
    /// <param name="row"></矩阵的行数—必须能被向量元素个数整除>
    public static Matrix ConvertToMatrix(Vector va, int row)
    {
        if (va == null)
            return null;

        if ((va._NumElement % row) != 0)
            return null;

        int col = va._NumElement / row;
        double[] data_va = va._VectorData;
        double[,] resultData = new double[row, col];

        for (int i = 0; i < row; i++)
            for (int j = 0; j < col; j++)
                resultData[i, j] = data_va[i * col + j];

        return new Matrix(resultData);
    }
    #endregion //矩阵、向量及数组之间的转换

    /// <summary>
    /// 向量转置
    /// </summary>
    public void VectorTranspose()
    {
        if (this == null)
            return;

        isColumnVector = !isColumnVector;
    }

    #region //对单个向量的元素的操作
    /// <summary>
    /// 向量每个元素取负
    /// </summary>
    public Vector ElementNegative()
    {
        if (this == null)
            return null;

        double[] resultData = new double[numElement];
        for (int k = 0; k < numElement; k++)
            resultData[k] = -vectorData[k];

        return new Vector(resultData, isColumnVector);
    }

    /// <summary>
    /// 向量每个元素取倒数
    /// </summary>
    public Vector ElementDividedBy1()
    {
        if (this == null)
            return null;

        double[] resultData = new double[numElement];
        for (int k = 0; k < numElement; k++)
            resultData[k] = 1 / vectorData[k];

        return new Vector(resultData, isColumnVector);
    }
    #endregion //对单个向量的元素的操作

    #region //对两个向量元素一对一的操作
    /// <summary>
    /// 两向量相加
    /// </summary>
    public static Vector operator +(Vector va, Vector vb)
    {
        if ((va == null) || (vb == null))
            return null;

        if ((va._NumElement != vb._NumElement) || (va._IsColumnVector != vb._IsColumnVector))
            return null;

        int num = va._NumElement;
        double[] data_va = va._VectorData;
        double[] data_vb = vb._VectorData;
        double[] resultData = new double[num];

        for (int k = 0; k < num; k++)
            resultData[k] = data_va[k] + data_vb[k];

        return new Vector(resultData, va._IsColumnVector);
    }

    /// <summary>
    /// 两向量相减
    /// </summary>
    public static Vector operator -(Vector va, Vector vb)
    {
        Vector vb_temp = vb.ElementNegative();
        return va + vb;
    }

    /// <summary>
    /// 两向量元素一对一相乘
    /// </summary>
    public static Vector VectorDotMul(Vector va, Vector vb)
    {
        if ((va == null) || (vb == null))
            return null;

        if ((va._NumElement != vb._NumElement) || (va._IsColumnVector != vb._IsColumnVector))
            return null;

        int num = va._NumElement;
        double[] data_va = va._VectorData;
        double[] data_vb = vb._VectorData;
        double[] resultData = new double[num];

        for (int k = 0; k < num; k++)
            resultData[k] = data_va[k] * data_vb[k];

        return new Vector(resultData, va._IsColumnVector);
    }

    /// <summary>
    /// 两向量元素一对一相除
    /// </summary>
    public static Vector VectorDotDivide(Vector va, Vector vb)
    {
        Vector vb_temp = vb.ElementDividedBy1();
        return VectorDotMul(va, vb);
    }
    #endregion //对单个向量元素一对一的操作

    #region //向量与标量之间的操作
    /// <summary>
    /// 向量与标量相加
    /// </summary>
    public static Vector operator +(Vector va, double t)
    {
        if (va == null)
            return null;

        int num = va._NumElement;
        double[] data_va = va._VectorData;
        double[] resultData = new double[num];

        for (int k = 0; k < num; k++)
            resultData[k] = data_va[k] + t;

        return new Vector(resultData, va._IsColumnVector);
    }

    /// <summary>
    /// 标量与向量相加
    /// </summary>
    public static Vector operator +(double t, Vector va)
    {
        return va + t;
    }

    /// <summary>
    /// 向量与标量相减
    /// </summary>
    public static Vector operator -(Vector va, double t)
    {
        return va + (-t);
    }

    /// <summary>
    /// 标量与向量相减
    /// </summary>
    public static Vector operator -(double t, Vector va)
    {
        Vector va_temp = va.ElementNegative();
        return va_temp + t;
    }

    /// <summary>
    /// 向量与标量相乘
    /// </summary>
    public static Vector operator *(Vector va, double t)
    {
        if (va == null)
            return null;

        int num = va._NumElement;
        double[] data_va = va._VectorData;
        double[] resultData = new double[num];

        for (int k = 0; k < num; k++)
            resultData[k] = data_va[k] * t;

        return new Vector(resultData, va._IsColumnVector);
    }

    /// <summary>
    /// 标量与向量相乘
    /// </summary>
    public static Vector operator *(double t, Vector va)
    {
        return va * t;
    }

    /// <summary>
    /// 向量与标量相除
    /// </summary>
    public static Vector operator /(Vector va, double t)
    {
        return va * (1 / t);
    }

    /// <summary>
    /// 标量与向量相除
    /// </summary>
    public static Vector operator /(double t, Vector va)
    {
        Vector va_temp = va.ElementDividedBy1();
        return va_temp * t;
    }
    #endregion //向量与标量之间的操作

    /// <summary>
    /// 两向量相乘
    /// Note: 1.列向量×行向量 2.行向量×列向量
    /// </summary>        
    public static Matrix operator *(Vector va, Vector vb)
    {
        if ((va == null) || (vb == null))
            return null;

        if (va._IsColumnVector == vb._IsColumnVector)
            return null;

        int num_va = va._NumElement, num_vb = vb._NumElement;
        double[] data_va = va._VectorData, data_vb = vb._VectorData;
        double[,] resultData = null;

        if (va._IsColumnVector) //结果为矩阵
        {
            resultData = new double[num_va, num_vb];
            for (int i = 0; i < num_va; i++)
                for (int j = 0; j < num_vb; j++)
                    resultData[i, j] = data_va[i] * data_vb[j];
        }
        else                    //结果为一个数
        {
            if (num_va != num_vb)
                return null;

            resultData = new double[1, 1];
            resultData[0, 0] = 0.0;
            for (int k = 0; k < num_va; k++)
                resultData[0, 0] += data_va[k] * data_vb[k];
        }

        return new Matrix(resultData);
    }
    #endregion //Method
}