program.cs

C#2.0宝典源码,C#经典书籍,很多例子

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Globalization;

namespace Example16_3
{
    /// <summary>
    /// Program类，主要用于演示矩阵的用法
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            Matrix myMatrix1 = Matrix.Random(3, 3);
            Matrix myMatrix2 = Matrix.Random(3, 3);

            Matrix myMatrix3 = myMatrix1 + myMatrix2;
            Matrix myMatrix4 = myMatrix1 - myMatrix2;
            Matrix myMatrix5 = -myMatrix1;
            Matrix myMatrix6 = myMatrix1 * 2;
            Matrix myMatrix7 = myMatrix1 * myMatrix2;
            
            bool myBool1 = (myMatrix1 == myMatrix2);
            bool myBool2 = myMatrix1.Square;
            bool myBool3 = myMatrix1.Symmetric;

            Console.WriteLine("myMatrix1矩阵为：\n{0}", myMatrix1.ToString());
            Console.WriteLine("myMatrix2矩阵为：\n{0}", myMatrix2.ToString());
            Console.WriteLine("myMatrix1矩阵与myMatrix2矩阵相加为：\n{0}", myMatrix3.ToString());
            Console.WriteLine("myMatrix1矩阵与myMatrix2矩阵相减为：\n{0}", myMatrix4.ToString());
            Console.WriteLine("myMatrix1矩阵的负矩阵为：\n{0}", myMatrix5.ToString());
            Console.WriteLine("myMatrix1矩阵与2相乘为：\n{0}", myMatrix6.ToString());
            Console.WriteLine("myMatrix1矩阵与myMatrix2矩阵相乘为：\n{0}", myMatrix7.ToString());

            Console.WriteLine("myMatrix1矩阵与myMatrix2是否相等？：{0}", myBool1);
            Console.WriteLine("myMatrix1是否正方形矩阵？：{0}", myBool2);
            Console.WriteLine("myMatrix1是否对称矩阵？：{0}", myBool3);

            Console.ReadLine();
        }
    }

    /// <summary>
    /// 矩阵类
    /// </summary>
    public class Matrix
    {
        /// <summary>
        /// 矩阵的数据
        /// </summary>
        private double[][] data;

        /// <summary>
        /// 行数
        /// </summary>
        private int rows;

        /// <summary>
        /// 列数
        /// </summary>
        private int columns;

        /// <summary>
        /// 随机数
        /// </summary>
        private static Random random = new Random();

        /// <summary>
        /// 创建一个空矩阵
        /// </summary>
        /// <param name="rows">行数</param>
        /// <param name="columns">列数</param>
        public Matrix(int rows, int columns)
        {
            this.rows = rows;
            this.columns = columns;
            this.data = new double[rows][];
            for (int i = 0; i < rows; i++)
            {
                this.data[i] = new double[columns];
            }
        }

        /// <summary>
        /// 参数为行数和列数以及一个给定的值，创建一个矩阵。
        /// </summary>
        /// <param name="rows">行数</param>
        /// <param name="columns">列数</param>
        /// <param name="value">所有矩阵元素的值</param>
        public Matrix(int rows, int columns, double value)
        {
            this.rows = rows;
            this.columns = columns;
            this.data = new double[rows][];

            for (int i = 0; i < rows; i++)
            {
                data[i] = new double[columns];
            }

            for (int i = 0; i < rows; i++)
            {
                data[i][i] = value;
            }
        }

        /// <summary>
        /// 参数为一个二维数组，表示所有的矩阵元素值，创建一个空矩阵。
        /// </summary>
        /// <param name="value">二维数组，表示所有的矩阵元素值</param>
        public Matrix(double[][] value)
        {
            this.rows = value.Length;
            this.columns = value[0].Length;

            for (int i = 0; i < rows; i++)
            {
                if (value[i].Length != columns)
                {
                    throw new ArgumentException("参数超出范围");
                }
            }

            this.data = value;
        }

        /// <summary>
        /// 哈希函数，对“＝＝”运算符进行重载时，必须对次方法进行重载
        /// </summary>
        public override int GetHashCode()
        {
            return (this.Rows + this.Columns);
        }

        /// <summary>
        /// 判断给定的矩阵对象是否与当前实例相等
        /// </summary>
        /// <param name="obj">要进行判断的矩阵对象</param>
        public override bool Equals(object obj)
        {
            return Equals(this, (Matrix)obj);
        }

        /// <summary>
        /// 判断两个矩阵对象是否相等
        /// </summary>
        /// <param name="left">矩阵对象1</param>
        /// <param name="right">矩阵对象2</param>
        public static bool Equals(Matrix left, Matrix right)
        {
            if (((object)left) == ((object)right))
            {
                return true;
            }

            if ((((object)left) == null) || (((object)right) == null))
            {
                return false;
            }

            if ((left.Rows != right.Rows) || (left.Columns != right.Columns))
            {
                return false;
            }

            for (int i = 0; i < left.Rows; i++)
            {
                for (int j = 0; j < left.Columns; j++)
                {
                    if (left[i, j] != right[i, j])
                    {
                        return false;
                    }
                }
            }

            return true;
        }

        /// <summary>
        /// 用于返回一个数组，该数组的值是当前矩阵所有元素的值
        /// </summary>
        internal double[][] Array
        {
            get
            {
                return this.data;
            }
        }

        /// <summary>
        /// 行数
        /// </summary>
        public int Rows
        {
            get
            {
                return this.rows;
            }
        }

        /// <summary>
        /// 列数
        /// </summary>
        public int Columns
        {
            get
            {
                return this.columns;
            }
        }

        /// <summary>
        /// 判断矩阵的行数和列数是否相等
        /// </summary>
        public bool Square
        {
            get
            {
                return (rows == columns);
            }
        }

        /// <summary>
        /// 判断矩阵是否自对称
        /// </summary>
        public bool Symmetric
        {
            get
            {
                if (this.Square)
                {
                    for (int i = 0; i < rows; i++)
                    {
                        for (int j = 0; j <= i; j++)
                        {
                            if (data[i][j] != data[j][i])
                            {
                                return false;
                            }
                        }
                    }

                    return true;
                }

                return false;
            }
        }

        /// <summary>
        /// 获取给定位置的元素值
        /// </summary>
        public double this[int row, int column]
        {
            set
            {
                this.data[row][column] = value;
            }

            get
            {
                return this.data[row][column];
            }
        }

        /// <summary>
        /// 获取当前矩阵的子矩阵
        /// </summary>
        /// <param name="startRow">开始的行数</param>
        /// <param name="endRow">结束的行数</param>
        /// <param name="startColumn">开始列数</param>
        /// <param name="endColumn">结束列数</param>
        /// <returns>子矩阵</returns>
        public Matrix Submatrix(int startRow, int endRow, int startColumn, int endColumn)
        {
            if ((startRow > endRow) || (startColumn > endColumn) || (startRow < 0) || (startRow >= this.rows) || (endRow < 0) || (endRow >= this.rows) || (startColumn < 0) || (startColumn >= this.columns) || (endColumn < 0) || (endColumn >= this.columns))
            {
                throw new ArgumentException("参数超出范围");
            }

            Matrix X = new Matrix(endRow - startRow + 1, endColumn - startColumn + 1);
            double[][] x = X.Array;
            for (int i = startRow; i <= endRow; i++)
            {
                for (int j = startColumn; j <= endColumn; j++)
                {
                    x[i - startRow][j - startColumn] = data[i][j];
                }
            }

            return X;
        }

        /// <summary>
        /// 获取当前矩阵的子矩阵
        /// </summary>
        /// <param name="rowIndexes">选取的特定行数组</param>
        /// <param name="columnIndexes">选取的特定列数组</param>
        /// <returns>子矩阵</returns>
        public Matrix Submatrix(int[] rowIndexes, int[] columnIndexes)
        {
            Matrix X = new Matrix(rowIndexes.Length, columnIndexes.Length);
            double[][] x = X.Array;
            for (int i = 0; i < rowIndexes.Length; i++)
            {
                for (int j = 0; j < columnIndexes.Length; j++)
                {
                    if ((rowIndexes[i] < 0) || (rowIndexes[i] >= rows) || (columnIndexes[j] < 0) || (columnIndexes[j] >= columns))
                    {
                        throw new ArgumentException("参数超出范围");
                    }

                    x[i][j] = data[rowIndexes[i]][columnIndexes[j]];
                }
            }

            return X;
        }

        /// <summary>
        /// 获取当前矩阵的子矩阵
        /// </summary>
        /// <param name="i0">开始的行数</param>
        /// <param name="i1">结束的行数</param>
        /// <param name="c">选取的特定行数组</param>
        /// <returns>子矩阵</returns>
        public Matrix Submatrix(int i0, int i1, int[] c)
        {
            if ((i0 > i1) || (i0 < 0) || (i0 >= this.rows) || (i1 < 0) || (i1 >= this.rows))
            {
                throw new ArgumentException("参数超出范围");
            }

            Matrix X = new Matrix(i1 - i0 + 1, c.Length);
            double[][] x = X.Array;
            for (int i = i0; i <= i1; i++)
            {
                for (int j = 0; j < c.Length; j++)
                {
                    if ((c[j] < 0) || (c[j] >= columns))
                    {
                        throw new ArgumentException("参数超出范围");
                    }

                    x[i - i0][j] = data[i][c[j]];
                }
            }

            return X;
        }

        /// <summary>
        /// 获取当前矩阵的子矩阵
        /// </summary>
        /// <param name="r">选取的特定行数组</param>
        /// <param name="j0">开始行</param>
        /// <param name="j1">结束行</param>
        public Matrix Submatrix(int[] r, int j0, int j1)
        {
            if ((j0 > j1) || (j0 < 0) || (j0 >= columns) || (j1 < 0) || (j1 >= columns))
            {
                throw new ArgumentException("参数超出范围");
            }

            Matrix X = new Matrix(r.Length, j1 - j0 + 1);
            double[][] x = X.Array;
            for (int i = 0; i < r.Length; i++)
            {
                for (int j = j0; j <= j1; j++)
                {
                    if ((r[i] < 0) || (r[i] >= this.rows))
                    {
                        throw new ArgumentException("参数超出范围");
                    }