Класс "вещественная матрица"

class main
{
    static void Main(string[] args)
    {
        matrix m1 = new matrix(5,5);
        matrix m2 = new matrix(5,5);
        m1.create();
        m2.create();
 
        Console.WriteLine("m1=");
        m1.show();
        Console.WriteLine("m2=");
        m2.show();
 
        Console.WriteLine("Матрицы равны "+m1.equals(m2));
        Console.WriteLine("Матрица квадратная " +m1.quad());
        Console.WriteLine("Матрица нулевая " + m1.nulle());
        Console.WriteLine("Матрица единичная " + m1.frs());
        Console.WriteLine("Матрица диагональная " + m1.diagon());
        Console.WriteLine("Матрица [1,3] = {0}", m1.Matrix[0,2]);
        Console.WriteLine("Матрица [2,2] = {0}", m1.Matrix[1,1]);
        Console.ReadKey();
 
    }
}
 
class matrix
{
    public double[,] Matrix = new Double[10,10];
    int lengthx, lengthy;
    static Random r = new Random();
 
    public bool diagon()
    {
        int count = 0; ;
        for (int i = 0; i < lengthx; i++)
        {
            for (int j = 0; j < lengthx; j++)
            {
 
                if (i == j)
                {
                    count++;
                }
 
                if (Matrix[i, j] != 0 && i != j)
                {
                    return false;
                }
 
            }
        }
 
        if (count == lengthx)
            return true;
        return false;
 
    
    }
    
    public bool frs()
    {
        int count = 0; ;
        for (int i = 0; i < lengthx; i++)
        {
            for (int j = 0; j < lengthx; j++)
            {
 
                if (Matrix[i, j] == 1 && i==j)
                {
                    count++;
                }
 
                if (Matrix[i, j] == 1 && i != j)
                {
                    return false;
                }
 
            }
        }
 
        if (count == lengthx)
            return true;
        return false;
 
    }
 
 
    public bool nulle()
    {
        int count = 0;
 
        for (int i = 0; i < lengthx; i++)
        {
            for (int j = 0; j < lengthx; j++)
            {
 
                if (Matrix[i,j]==0)
                {
                    count++;
                }
 
            }
        }
 
        if (count == lengthx * lengthy)
        {
            return true;
        }
        return false;
    }
 
    public void create()
    {
        for (int i = 0; i < lengthx; i++)
        {
            for (int j = 0; j < lengthx; j++)
            {
                Matrix[i, j] = Math.Round( r.Next(0, 250)/3.3 ,2);
            }
        }
 
 
    }
 
    public bool quad()
    {
        if (lengthx == lengthy)
        {
            return true;
        }
        return false;
 
    }
 
    public void show()
    {
        for (int i = 0; i < lengthx; i++)
        {
            for (int j = 0; j < lengthx; j++)
            {
                
                Console.Write("\t"+Matrix[i, j]);
 
            }
            Console.WriteLine();
        }
    }
 
    public bool equals(matrix a)
    {
        int count = 0;
        for (int i = 0; i < lengthx; i++)
        {
            for (int j = 0; j < lengthx; j++)
            {
 
                if (a.Matrix[i, j] == Matrix[i, j])
                {
                    count++;
                }
 
            }
            Console.WriteLine();
        }
 
        if (count == lengthx * lengthy)
        {
            return true;
        }
        return false;
    }
 
    public matrix(int lengthx,int lengthy)
    {
        this.lengthx = lengthx;
        this.lengthy = lengthy;
    }
}

public double[,] Matrix = new Double[10,10];
int lengthx, lengthy;

public double[,] Matrix = new Double[lengthx,lengthy];
int lengthx, lengthy;

using System;
using System.Collections.Generic;
 
/// <summary>
/// Вещественная матрица
/// </summary>
class Matrix
{
    /// <summary>
    /// Количество строк
    /// </summary>
    uint n;
    /// <summary>
    /// Количество столбцов
    /// </summary>
    uint m;
    /// <summary>
    /// Матрица
    /// </summary>
    double[,] array;
    /// <summary>
    /// Конструктор
    /// </summary>
    /// <param name="n">Количество строк в матрице</param>
    /// <param name="m">Количество столбцов в матрице</param>
    public Matrix(uint n, uint m)
    {
        this.n = n;
        this.m = m;
        Random random = new Random();
        array = new double[n, m];
        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++)
                array[i, j] = random.NextDouble();
    }
    /// <summary>
    /// Свойство, показывающее является ли матрица квадратной.
    /// </summary>
    public bool IsSquare
    {
        get
        {
            if (n == m)
                return true;
            return false;
        }
    }
    /// <summary>
    /// Свойство, показывающее является ли матрица единичной.
    /// </summary>
    public bool IsIdentity
    {
        get
        {
            if (n != m)
                return false;
            for (int i = 0; i < n; i++)
                if (array[i, i] != 1.0)
                    return false;
            for (int i = 0; i < n; i++)
                for (int j = 0; j < m; j++)
                    if (i != j)
                    {
                        if (array[i, j] != 0.0)
                            return false;
                    }
                    else
                        continue;
            return true;
        }
    }
    /// <summary>
    /// Свойство, показывающее является ли матрица нулевой.
    /// </summary>
    public bool IsZero
    {
        get
        {
            for (int i = 0; i < n; i++)
                for (int j = 0; j < m; j++)
                    if (array[i, j] != 0.0)
                        return false;
            return true;
        }
    }
    /// <summary>
    /// Свойство, показывающее является ли матрица диагональной.
    /// </summary>
    public bool IsDiagonalic
    {
        get
        {
            for (int i = 0; i < n; i++)
                for (int j = 0; j < m; j++)
                    if (i != j)
                    {
                        if (array[i, j] != 0.0)
                            return false;
                    }
                    else
                        continue;
            return true;
        }
    }
    /// <summary>
    /// Свойство, показывающее является ли матрица симметричной.
    /// </summary>
    public bool IsSimmetric
    {
        get
        {
            if (n != m)
                return false;
            if (this.IsDiagonalic || this.IsIdentity || this.IsZero)
                return true;
            for (int i = 0; i < n; i++)
                for (int j = 0; j < m; j++)
                    if (i - j < 0)
                        if (array[i, j] != array[j, i])
                            return false;
            return true;
        }
    }
    public double this[int i, int j]
    {
        get
        {
            return array[i, j];
        }
        set
        {
            array[i, j] = value;
        }
    }
    /// <summary>
    /// Метод, создающий нулевую матрицу.
    /// </summary>
    public void MakeZero()
    {
        if (!this.IsSquare)
            throw new Exception("Матрица должна быть квадратной.");
        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++)
                array[i, j] = 0.0;
    }
    /// <summary>
    /// Метод, создающий единичную матрицу.
    /// </summary>
    public void MakeIdentity()
    {
        if (!this.IsSquare)
            throw new Exception("Матрица должна быть квадратной.");
        MakeZero();
        for (int i = 0; i < n; i++)
            array[i, i] = 1.0;
    }
    /// <summary>
    /// Вывод матрицы на экран
    /// </summary>
    /// <param name="spliter">Разделитель между элементами массива</param>
    /// <param name="d">Количество символов после запятой.</param>
    public void ShowMatrix(string spliter, uint d)
    {
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < m; j++)
                Console.Write(array[i, j].ToString("F" + d.ToString()) + spliter);
            Console.WriteLine();
        }
    }
    /// <summary>
    /// Вывод матрицы на экран.
    /// </summary>
    public void ShowMatrix()
    {
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < m; j++)
                Console.Write(array[i, j].ToString("F2") + " ");
            Console.WriteLine();
        }
    }
    /// <summary>
    /// Метод создающий диагональную матрицу.
    /// </summary>
    public void MakeDiagonalic()
    {
        if (!this.IsSquare)
            throw new Exception("Матрица должна быть квадратной.");
        MakeZero();
        Random random = new Random();
        for (int i = 0; i < n; i++)
            array[i, i] = random.NextDouble();
    }
    /// <summary>
    /// Метод создающий симметричную матрицу.
    /// </summary>
    public void MakeSimmetric()
    {
        if (!this.IsSquare)
            throw new Exception("Матрица должна быть квадратной.");
        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++)
                if (i - j < 0)
                    array[i, j] = array[j, i];
    }
    /// <summary>
    /// Метод, перезаполняющий исходную матрицу.
    /// </summary>
    public void MakeRandom()
    {
        Random random = new Random();
        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++)
                array[i, j] = random.NextDouble();
    }
    /// <summary>
    /// Возвращает колечество строк матрицы
    /// </summary>
    public uint RowCount
    {
        get
        {
            return n;
        }
    }
    /// <summary>
    /// Возвращает количество столбцов матрицы
    /// </summary>
    public uint ColumnCount
    {
        get
        {
            return m;
        }
    }
    public static bool operator !=(Matrix m1, Matrix m2)
    {
        if (m1.RowCount != m2.RowCount)
            return true;
        if (m1.ColumnCount != m2.ColumnCount)
            return true;
        for (int i = 0; i < m1.RowCount; i++)
            for (int j = 0; j < m2.ColumnCount; j++)
                if (m1[i, j] != m2[i, j])
                    return true;
        return false;
    }
    public static bool operator ==(Matrix m1, Matrix m2)
    {
        if (m1.RowCount != m2.RowCount)
            return false;
        if (m1.ColumnCount != m2.ColumnCount)
            return false;
        for (int i = 0; i < m1.RowCount; i++)
            for (int j = 0; j < m2.ColumnCount; j++)
                if (m1[i, j] != m2[i, j])
                    return false;
        return true;
    }
    /// <summary>
    /// Изменение размеров матрицы.
    /// </summary>
    /// <param name="n">Количество строк.</param>
    /// <param name="m">Количество столбцов.</param>
    public void Resize(uint n, uint m)
    {
        this.n = n;
        this.m = m;
        array = new double[n, m];
        MakeRandom();
    }
    /// <summary>
    /// Получение двумерного массива
    /// </summary>
    /// <returns></returns>
    public double[,] ToArray()
    {
        double[,] buf = new double[n, m];
        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++)
                buf[i, j] = array[i, j];
        return buf;
    }
    /// <summary>
    /// Получение одномерного массива.
    /// </summary>
    /// <returns></returns>
    public double[] ToArrayOne()
    {
        double[] buf = new double[n * m];
        int index = 0;
        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++)
            {
                buf[index] = array[i, j];
                index++;
            }
        return buf;
    }
}
 
class program
{
    public static void Main()
    {
        Matrix matrix = new Matrix(5, 5);
        matrix.ShowMatrix(" ", 2);
        matrix.MakeZero();
        Console.WriteLine(matrix.IsZero);
        matrix.MakeIdentity();
        matrix.ShowMatrix(" ", 2);
        Console.WriteLine(matrix.IsIdentity);
        matrix.MakeDiagonalic();
        matrix.ShowMatrix(" ", 2);
        Console.WriteLine(matrix.IsDiagonalic);
        matrix.MakeRandom();
        matrix.MakeSimmetric();
        Console.WriteLine(matrix.IsSimmetric);
        matrix.ShowMatrix();
        Matrix m2 = new Matrix(5, 5);
        if (matrix == m2)
            Console.WriteLine("Матрицы равны");
        else
            Console.WriteLine("Матрицы не равны");
        m2 = matrix;
        if (matrix == m2)
            Console.WriteLine("Матрицы равны");
        else
            Console.WriteLine("Матрицы не равны");
        Console.WriteLine(matrix.ColumnCount);
        Console.WriteLine(matrix.RowCount);
        matrix.Resize(6, 4);
        Console.WriteLine(matrix.IsSquare);
        matrix.ToArray();
        matrix.ToArrayOne();
        Console.ReadKey(true);
    }
}