using
System;
using
System. Collections. Generic;
using
System. Text;
using
System. Collections;
namespace
Matrix_ADT
{
enum
MatrixType
{
identity ,
random ,
zero ,
}
class
Matrix : IEnumerable
{
float [ , ] mat;
readonly int row;
readonly int column;
//////////////////////////////////////////////////////////////////////
public Matrix ( int r
, int c )
{
this. row = r;
this. column = c;
mat = new float
[ row , column ];
}
public Matrix ( int r
, int c , float
val )
{
row = r;
column = c;
mat = new float
[ row , column ];
for ( int i = 0 ; i
< row ; i++ )
{
for ( int
j = 0 ; j < column ; j++ )
{
mat [ i , j ] = val;
}
}
}
public Matrix ( int r
, int c , MatrixType type )
{
row = r;
column = c;
mat = new float
[ row , column ];
switch ( type )
{
case MatrixType. identity:
if ( row == column )
{
for ( int
i = 0 ; i < row ; i++ )
{
mat [ i , i ] = 1;
}
//break;
}
else
{
Console. WriteLine ( "this matrix isn't square matrix so can not be
an identity" );
}
break;
case MatrixType. random:
Random ran = new Random ( );
for ( int
i = 0 ; i < row ; i++ )
{
for ( int
j = 0 ; j < column ; j++ )
{
mat [ i , j ] = ran. Next ( );
}
}
break;
case MatrixType. zero:
break;
}
}
public Matrix ( float
[ , ] arr )
{
row = arr. GetLength ( 0 );
column = arr. GetLength ( 1 );
mat = new float
[ row , column ];
for ( int i = 0 ; i
< row ; i++ )
{
for ( int
j = 0 ; j < column ; j++ )
{
mat [ i , j ] = arr [ i , j ];
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public float this [ int r , int c ]
{
get
{
if ( r < 0 || r > row - 1 || c
< 0 || c > column - 1 )
{
Console. WriteLine ( "out of range" );
return -100000;
}
return mat [ r , c ];
}
set
{
if ( r < 0 || r > row - 1 || c
< 0 || c > column - 1 )
{
Console. WriteLine ( "out of range" );
}
else
{
this. mat [ r , c ] = value;
}
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public int Row
{
get
{
return this.
row;
}
}
public int Column
{
get
{
return this.
column;
}
}
//////////////////////////////////////////////////////////////////////
public static Matrix operator + ( Matrix lhs , Matrix rhs )
{
if ( lhs. row == rhs. row && lhs. column ==
rhs. column )
{
float [ , ] newMat = new float [ lhs. row
, lhs. column ];
for ( int
i = 0 ; i < lhs. row ; i++ )
{
for ( int
j = 0 ; j < lhs. column ; j++ )
{
newMat [ i , j ] =(float)Math.Round(
lhs. mat [ i , j ] + rhs. mat [ i , j ],6);
}
}
return new
Matrix ( newMat );
}
return null;
}
public static Matrix operator - ( Matrix lhs , Matrix rhs )
{
if ( lhs. row == rhs. row && lhs. column ==
rhs. column )
{
float [ , ] newMat = new float [ lhs. row
, lhs. column ];
for ( int
i = 0 ; i < lhs. row ; i++ )
{
for ( int
j = 0 ; j < lhs. column ; j++ )
{
newMat [ i , j ] = ( float ) Math. Round
( lhs. mat [ i , j ] - rhs. mat [ i , j ] , 6 );
}
}
return new
Matrix ( newMat );
}
return null;
}
public static bool operator == (
Matrix lhs , Matrix rhs )
{
if ( lhs. row == rhs. row && lhs. column ==
rhs. column )
{
for ( int
i = 0 ; i < lhs. row ; i++ )
{
for ( int
j = 0 ; j < lhs. column ; j++ )
{
if ( Math. Abs ( lhs. mat [ i , j ] -
rhs. mat [ i , j ] ) > .00001 )
{
return false;
}
}
}
return true;
}
return false;
}
public static bool operator != (
Matrix lhs , Matrix rhs )
{
return !( lhs == rhs );
}
public static Matrix operator * ( Matrix lhs , Matrix rhs )
{
if ( lhs. column == rhs. row )
{
float [ , ] newMat = new float [ lhs. row
, rhs. column ];
for ( int
i = 0 ; i < lhs. row ; i++ )
{
for ( int
x = 0 ; x < rhs. column ; x++ )
{
for ( int
j = 0 ; j < lhs. column ; j++ )
{
newMat [ i , x ] += ( float ) Math.
Round ( lhs. mat [ i , j ] * rhs. mat [ j , x ] , 6 );
}
}
}
return new
Matrix ( newMat );
}
return null;
}
public static Matrix operator * ( float
lhs , Matrix m )
{
float [ , ] matr = new
float [ m. row , m. column ];
for ( int i = 0 ; i
< m. row ; i++ )
{
for ( int j = 0 ; j
< m. column ; j++ )
{
matr [ i , j ] = ( float ) Math. Round (
m. mat [ i , j ] * lhs , 6 );
}
}
return new Matrix (
matr );
}
public static Matrix operator / ( Matrix m , double
lhs )
{
float [ , ] matr = new
float [ m. row , m. column ];
for ( int i = 0 ; i
< m. row ; i++ )
{
for ( int
j = 0 ; j < m. column ; j++ )
{
matr [ i , j ] = ( float )Math.Round( (
m .mat[ i , j ] / lhs ),6);
}
}
return new Matrix (
matr );
}
public static Matrix operator / ( Matrix lhs , Matrix rhs )
{
return lhs * rhs. Inverse ( );
}
//////////////////////////////////////////////////////////////////////
public Matrix Transpose ( )
{
float [ , ] newMat = new
float [ this.
column , this. row ];
for ( int i = 0 ; i
< this. row ; i++ )
{
for ( int
j = 0 ; j < this. column ; j++ )
{
newMat [ j , i ] = this.mat[ i , j ];
}
}
return new Matrix (
newMat );
}
public float
MaxElement ( )
{
float max = this.mat[
0 , 0 ];
for ( int i = 0 ; i
< this. row ; i++ )
{
for ( int
j = 0 ; j < this. column ; j++ )
{
if ( this.mat[
i , j ] > max )
{
max = this.mat[ i , j ];
}
}
}
return max;
}
public float
MinElement ( )
{
float min = this.mat[
0 , 0 ];
for ( int i = 0 ; i
< this. row ; i++ )
{
for ( int
j = 0 ; j < this. column ; j++ )
{
if ( this.mat[
i , j ] < min )
{
min = this.mat[ i , j ];
}
}
}
return min;
}
//////////////////////////////////////////////////////////////////////
public IEnumerator GetEnumerator ( )
{
return ( IEnumerator ) new
MatrixEnum ( this );
}
private class
MatrixEnum : IEnumerator
{
private Matrix m;
private int i;
private int j;
public MatrixEnum ( Matrix mat )
{
m = mat;
i = 0;
j = -1;
}
public object Current
{
get
{
return m [ i , j ];
}
}
public bool MoveNext
( )
{
if ( j == m. column - 1 )
{
j = 0;
i++;
}
else
{
j++;
}
if ( i >= m. row )
{
return false;
}
return true;
}
public void Reset ( )
{
j = -1;
i = 0;
}
}
//////////////////////////////////////////////////////////////////////
public bool
IsIdentity
{
get
{
if ( this.
column == this. row )
{
for ( int
i = 0 ; i < this. row ; i++ )
{
for ( int
j = 0 ; j < this. column ; j++ )
{
if ( i == j )
{
if (Math.Abs(( this.mat[
i , j ] - 1))>.0001 )
{
return false;
}
}
else if
(Math.Abs( this.mat[ i , j ]) > 0.0001 )
{
return false;
}
}
}
return true;
}
return false;
}
}
public bool
IsIdempotent
{
get
{
if ( this.
row == this. column )
{
if ( this == this * this )
{
return true;
}
}
return false;
}
}
public bool IsSquare
{
get
{
if ( this.
row == this. column )
{
return true;
}
return false;
}
}
public bool
IsSymmetric
{
get
{
if ( this.
column == this. row )
{
for ( int
i = 0 ; i < this. row ; i++ )
{
for ( int
j = 0 ; j < this. column ; j++ )
{
if ( Math.Abs((this.mat[
i , j ] - this.mat[ j , i ]))>.0001 )
{
return false;
}
}
}
return true;
}
return false;
}
}
public bool
IsUpperTringle
{
get
{
if ( this.
column == this. row )
{
for ( int i = 0 ; i
< this. row ; i++ )
{
for ( int
j = 0 ; j < i ; j++ )
{
if (Math.Abs( this.mat[
i , j ]) > 0.0001 )
{
return false;
}
}
}
return true;
}
return false;
}
}
public bool IsVector
{
get
{
return this.
row == 1;
}
}
public bool Iscolumn
{
get
{
return this.column
== 1;
}
}
public bool
IsInvertable
{
get
{
return ((this.Determinate
( ) != 0)&& (this.Determinate()!=-100000));
}
}
//////////////////////////////////////////////////////////////////////
public double
Determinate ( )
{
if ( this. column != this. row )
{
Console. WriteLine ( "ERROR>>>>>Array doesnt
Square" );
return -100000;
}
int i = 0;
double output = 0;
for ( int j = 0 ; j
< this. column ; j++ )
{
output += Math. Pow ( -1 , j ) * this.mat[
0 , j ] * Val ( this. mat , i , j );
}
return output;
}
private double Val ( float [ , ] p , int k
, int j )
{
if ( p. GetLength ( 0 ) == 1 )
{
return 1;
}
float [ , ] ass = new
float [ p. GetLength ( 0 ) - 1 , p. GetLength (
1 ) - 1 ];
int y;
int n = 0;
///make new array (ass)
without the row and the coulmn of k,j
for ( int i = 0 ; i
< p. GetLength ( 0 ) ; i++ )
{
y = 0;
if ( i == k )
{
n = 1;
continue;
}
for ( int
x = 0 ; x < p. GetLength ( 1 ) ; x++ )
{
if ( x == j )
{
y = 1;
continue;
}
ass [ i - n , x - y ] = p [ i , x ];
}
}
// calculate the determante of (ass)
double output = 0;
for ( int i = 0 ; i
< ass. GetLength ( 1 ) ; i++ )
{
output += Math. Pow ( -1 , i ) * ass [ 0 , i ] * Val ( ass , 0 , i );
}
return output;
}
public Matrix Inverse ( )
{
if ( this. column != this. row )
{
Console. WriteLine ( "ERROR>>>>>Array doesnt
Square" );
return null;
}
//calculate the adjacent array
float [ , ] arr = new
float [ this.
row , this. column ];
for ( int i = 0 ; i
< this. row ; i++ )
{
for ( int
j = 0 ; j < this. column ; j++ )
{
arr [ i , j ] = ( float ) Math.Round(( Math. Pow ( -1 , i + j ) * Val (
this. mat , i , j ) ),6);
}
}
Matrix kh = new Matrix ( arr );
//Console. WriteLine ( kh );
kh = kh. Transpose ( );
//Console. WriteLine ( kh );
if ( this.
Determinate() != 0 )
{
return kh / this.
Determinate ( );
}
Console. WriteLine (
"ERROR>>>>>>>>>>>>>>> Not
Invertable" );
return null;
}
public Double TriDeterminate ( )
{
if ( this. column != this. row )
{
Console. WriteLine ( "ERROR>>>>>Array doesnt have
diagonal" );
return -100000;
}
double output = 1;
for ( int i = 0 ; i
< this. row ; i++ )
{
output *= this.mat[ i , i ];
}
return output;
}
//////////////////////////////////////////////////////////////////////
public void Fill ( float val )
{
for ( int i = 0 ; i
< this. row ; i++ )
{
for ( int
j = 0 ; j < this. column ; j++ )
{
this.mat[ i , j ] = val;
}
}
}
public override string ToString ( )
{
StringBuilder output = new StringBuilder
( );
output. Append ( "\n" );
for ( int i = 0 ; i
< this. row ; i++ )
{
output. Append ( "| " );
for ( int
j = 0 ; j < this. column ; j++ )
{
output. Append ( Math.Round( this.mat[ i
, j ],3).ToString().PadRight(9) );
output. Append ( "
" );
}
output. Append ( "|\n\n" );
}
return output. ToString ( );
}
}
class
Program
{
static void Main ( string [ ] args )
{
Matrix m = new Matrix ( 3 , 3 , 9 );
float [ , ] asd ={ { 1 , 5 , 3 } , { 4 , 8 ,6 } , {
77 , 08 , 9 } };
Matrix zz = new Matrix ( asd );
//Console.WriteLine(zz);
//m[2, 1] = 5;
//foreach (float f in m)
{zz.Fill(9);
Console. WriteLine ("{0} {1}",zz,m);
Console. WriteLine ( Math.ReferenceEquals( zz,m));
}
}
}
}