matrix.cs

在Visual 2008环境下

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

class Matrix : ICloneable
{
    /// <summary>
    /// smallest such that 1.0+DBL_EPSILON != 1.0
    /// </summary>
    private const double DBL_EPSILON = 2.2204460492503131e-016;

    #region //Field
    /// <summary>
    /// 矩阵的数据
    /// </summary>
    private double[,] matrixData = null;

    /// <summary>
    /// 矩阵的行数
    /// </summary>
    private int row;

    /// <summary>
    /// 矩阵的列数
    /// </summary>
    private int col;
    #endregion //Field

    #region //Property
    public double[,] _MatrixData
    {
        get
        {
            return matrixData;
        }
        set
        {
            matrixData = value;
        }
    }
    public int _Row
    {
        get
        {
            return row;
        }
    }
    public int _Col
    {
        get
        {
            return col;
        }
    }
    #endregion //Property

    #region //Contructor
    /// <summary>
    /// 构造函数1
    /// </summary>
    public Matrix(double[,] data)
    {
        if (data == null)
            return;

        matrixData = data;
        row = data.GetLength(0);
        col = data.GetLength(1);
    }

    /// <summary>
    /// 构造函数2
    /// </summary>
    public Matrix(int Row, int Col)
    {
        this.row = Row;
        this.col = Col;

        this.matrixData = new double[this.row, this.col];
    }

    /// <summary>
    /// 构造函数3
    /// </summary>
    public Matrix(double[,] data, int Row, int Col)
    {
        if (data == null)
            return;

        if ((Row != data.GetLength(0)) || (Col != data.GetLength(1)))
            return;

        matrixData = data;
        row = Row;
        col = Col;
    }
    #endregion //Contructor

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

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

        String str = "";
        String divideStr1 = " ";
        String divideStr2 = "\r\n";

        for (int i = 0; i < row; i++)
        {
            for (int j = 0; j < col; j++)
                str += matrixData[i, j].ToString() + divideStr1;
            str += divideStr2;
        }

        return str;
    }

    /// <summary>
    /// 将矩阵显式转化数组
    /// </summary>
    public static explicit operator double[,](Matrix ma)
    {
        return ma._MatrixData;
    }
    #endregion //Convert function

    #region //矩阵、向量之间的转换
    /// <summary>
    /// 矩阵转换为向量组
    /// </summary>
    /// <param name="isToColumnVectors"></若为true, 则矩阵按列划分；否则按行划分>
    public static List<Vector> ConvertToVectors(Matrix ma, bool isToColumnVectors)
    {
        if (ma == null)
            return null;

        int row = ma._Row, col = ma._Col;
        double[,] data_ma = ma._MatrixData;

        List<Vector> v_list = new List<Vector>();
        int num_vector = col, num_vectorelement = row;
        if (!isToColumnVectors)
        {
            num_vector = row;
            num_vectorelement = col;
        }

        for (int k = 0; k < num_vector; k++)
        {
            double[] data_temp = new double[num_vectorelement];
            for (int j = 0; j < num_vectorelement; j++)
            {
                if (isToColumnVectors)
                    data_temp[j] = data_ma[j, k];
                else
                    data_temp[j] = data_ma[k, j];
            }
            v_list.Add(new Vector(data_temp, isToColumnVectors));
        }

        return v_list;
    }

    /// <summary>
    /// 矩阵降维为向量
    /// </summary>
    /// <param name="isToColumnVector"></若为true, 则矩阵按列划分；否则按行划分>
    public static Vector ConvertToVector(Matrix ma, bool isToColumnVector)
    {
        if (ma == null)
            return null;

        int row = ma._Row, col = ma._Col;
        double[,] data_ma = ma._MatrixData;

        double[] resultData = new double[row * col];

        int index1 = col, index2 = row;
        if (!isToColumnVector)
        {
            index1 = row;
            index2 = col;
        }

        for (int i = 0; i < index1; i++)
        {
            for (int j = 0; j < index2; j++)
            {
                if (isToColumnVector)
                    resultData[i * index2 + j] = data_ma[j, i];
                else
                    resultData[i * index2 + j] = data_ma[i, j];
            }
        }

        return new Vector(resultData, isToColumnVector);
    }

    #endregion //矩阵、向量及数组之间的转换

    #region //矩阵元素的变换及置换
    /// <summary>
    /// 用同一矩阵的部分元素来设置部分元素
    /// </summary>
    /// <param name="startrow_end"></被设置元素的开始行>
    /// <param name="endcol_end"></被设置元素的开始列>
    /// <param name="startrow_sourse"></设置元素的开始行>
    /// <param name="endcol_sourse"></设置元素的开始列>
    /// <param name="num_row"></共几行元素>
    /// <param name="num_col"></共几列元素>
    /// <returns></returns>
    public Matrix SetElement(int startrow_end, int endcol_end, int startrow_sourse, int endcol_sourse, int num_row, int num_col)
    {
        if (this == null)
            return null;

        if ((num_row < 0) || (num_row > (row - 1)) || (num_col < 0) || (num_col > (col - 1)))
            return null;

        double[,] resultData = (double[,])matrixData.Clone();
        for (int i = 0; i < num_row; i++)
            for (int j = 0; j < num_col; j++)
                resultData[startrow_end - 1 + i, endcol_end - 1 + j] = matrixData[startrow_sourse - 1 + i, endcol_sourse - 1 + j];

        return new Matrix(resultData);
    }
    #endregion //矩阵元素的变换及置换

    #region //算术运算、逻辑运算
    #region //对单个矩阵的元素的操作
    /// <summary>
    /// 矩阵每个元素取负
    /// </summary>
    public Matrix ElementNegative()
    {
        if (this == null)
            return null;

        double[,] resultData = new double[row, col];
        for (int i = 0; i < row; i++)
            for (int j = 0; j < col; j++)
                resultData[i, j] = -matrixData[i, j];

        return new Matrix(resultData);
    }

    /// <summary>
    /// 矩阵每个元素取倒数
    /// </summary>
    public Matrix ElementDividedBy1()
    {
        if (this == null)
            return null;

        double[,] resultData = new double[row, col];
        for (int i = 0; i < row; i++)
            for (int j = 0; j < col; j++)
                resultData[i, j] = 1 / matrixData[i, j];

        return new Matrix(resultData);
    }

    /// <summary>
    /// 矩阵每个元素取平方
    /// </summary>
    public Matrix ElementSqure()
    {
        if (this == null)
            return null;

        double[,] resultData = new double[row, col];
        for (int i = 0; i < row; i++)
            for (int j = 0; j < col; j++)
                resultData[i, j] = Math.Pow(matrixData[i, j], 2);

        return new Matrix(resultData);
    }

    /// <summary>
    /// 矩阵每个元素取开方
    /// </summary>
    public Matrix ElementSqrt()
    {
        if (this == null)
            return null;

        double[,] resultData = new double[row, col];
        for (int i = 0; i < row; i++)
            for (int j = 0; j < col; j++)
                resultData[i, j] = Math.Sqrt(matrixData[i, j]);

        return new Matrix(resultData);
    }
    #endregion //对单个矩阵的元素的操作

    #region //对两个矩阵元素一对一的操作
    /// <summary>
    /// 两矩阵相加
    /// </summary>
    public static Matrix operator +(Matrix ma, Matrix mb)
    {
        if ((ma == null) || (mb == null))
            return null;

        if ((ma._Row != mb._Row) || (ma._Col != mb._Col))
            return null;

        int row = ma._Row, col = ma._Col;
        double[,] data_ma = ma._MatrixData;
        double[,] data_mb = mb._MatrixData;
        double[,] resultData = new double[row, col];

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

        return new Matrix(resultData);

    }

    /// <summary>
    /// 两矩阵相减
    /// </summary>
    public static Matrix operator -(Matrix ma, Matrix mb)
    {
        Matrix mb_temp = mb.ElementNegative();
        return ma + mb_temp;
    }

    /// <summary>
    /// 两矩阵点乘
    /// </summary>