Hugging Face's logo

Datasets:
introvoyz041
/
Dwsim

Modalities:
Image
Formats:
imagefolder
Size:
< 1K
Libraries:
Datasets
License:
Dataset card Data Studio Files
xet
 Community
Dwsim / data /DWSIM.Math.DotNumerics /LinearAlgebra /ComplexMatrix.cs
introvoyz041's picture
introvoyz041
Migrated from GitHub
b1b3bae verified
Raw History Blame Contribute Delete
25.7 kB
#region Copyright � 2009, De Santiago-Castillo JA. All rights reserved.
//Copyright � 2009 Jose Antonio De Santiago-Castillo
//E-mail:JAntonioDeSantiago@gmail.com
//Web: www.DotNumerics.com
//
#endregion
using System;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics;
using System.IO;
using DotNumerics.FortranLibrary;
namespace DotNumerics.LinearAlgebra
{
//[DebuggerDisplay("[{RowCount},{ColumnCount}]", Name = "MatrixComplex")]
/// <summary>
/// Represents a Complex Matrix.
/// </summary>
[DebuggerDisplay("[{RowCount},{ColumnCount}]")]
[DebuggerTypeProxy(typeof(MatrixComplexDebuggerDisplay))]
public class ComplexMatrix : IMatrix<Complex>
{
#region Fields
/// <summary>
/// Los datos de la matriz, los datos se almacenan en un un array unidimensional,
/// Los elementos se almacenan por columnas, esto para que sean compatible con los Arrays de Fortran
/// </summary>
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
protected Complex[] _Data;
/// <summary>
/// El numero de renglones
/// </summary>
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
protected int _RowCount;
/// <summary>
/// El numero de columnas
/// </summary>
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
protected int _ColumnCount;
#endregion
#region Public Constructors
/// <summary>
/// Initializes a new instance of the MatrixComplex class of the given size.
/// </summary>
/// <param name="rows">Number of rows.</param>
/// <param name="columns">Number of columns.</param>
public ComplexMatrix(int rows, int columns)
{
if (rows < 1) throw new System.ArgumentException("rows < 1");
if (columns < 1) throw new System.ArgumentException("columns < 1");
this._Data = new Complex[rows * columns];
this._RowCount = rows;
this._ColumnCount = columns;
}
/// <summary>
/// Initializes a new instance of the MatrixComplex class of the given size using a array
/// </summary>
/// <param name="rows">Number of rows.</param>
/// <param name="columns">Number of columns.</param>
/// <param name="Data">The data</param>
internal ComplexMatrix(int rows, int columns, Complex[] Data)
{
if (rows < 1) throw new System.ArgumentException("rows < 1");
if (columns < 1) throw new System.ArgumentException("columns < 1");
this._Data = new Complex[rows * columns];
this._RowCount = rows;
this._ColumnCount = columns;
//Si incluye la posibilidad de que los datos tengan menos valores que la matriz a crear
for (int i = 0; i < Math.Min(this._Data.Length, Data.Length); i++)
{
this._Data[i] = Data[i];
}
}
/// <summary>
/// Initializes a new instance of the MatrixComplex class of the given size.
/// </summary>
/// <param name="size">Size</param>
public ComplexMatrix(int size)
{
if (size < 1) throw new System.ArgumentException("size < 1");
this._Data = new Complex[size * size];
this._RowCount = size;
this._ColumnCount = size;
}
/// <summary>
/// Initializes a new instance of the MatrixComplex class of the given size using a array
/// </summary>
/// <param name="size">Size</param>
/// <param name="Data">The data</param>
internal ComplexMatrix(int size, Complex[] Data)
{
if (size < 1) throw new System.ArgumentException("size < 1");
this._Data = new Complex[size * size];
this._RowCount = size;
this._ColumnCount = size;
//Si incluye la posibilidad de que los datos tengan menos valores que la matriz a crear
for (int i = 0; i < Math.Min(this._Data.Length, Data.Length); i++)
{
this._Data[i] = Data[i];
}
}
#endregion
#region Public Properties
/// <summary>
/// Los datos de la matriz
/// </summary>
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
internal Complex[] Data
{
get { return this._Data; }
}
/// <summary>
/// Returns the number of rows.
/// </summary>
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
public int RowCount
{
get { return _RowCount; }
set { _RowCount = value; }
}
/// <summary>
/// Returns the number of columns.
/// </summary>
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
public int ColumnCount
{
get { return _ColumnCount; }
set { _ColumnCount = value; }
}
/// <summary>
/// Gets a value indicating if the matrix is square.
/// </summary>
public bool IsSquare
{
get
{
bool isSquare = false;
if (this._ColumnCount == this.RowCount) isSquare = true;
return isSquare;
}
}
/// <summary>
/// Returns the value of a element of the matrix.
/// </summary>
/// <param name="row">The row value (zero-based).</param>
/// <param name="column">The column value (zero-based).</param>
/// <returns>The matrix value at (row, column).</returns>
public virtual Complex this[int row, int column]
{
get
{
if (column >= this._ColumnCount)
{
throw new ArgumentException("Index was outside the bounds of the matrix.");
}
return this._Data[row + column * this._RowCount];
}
set
{
if (column >= this._ColumnCount)
{
throw new ArgumentException("Index was outside the bounds of the matrix.");
}
this._Data[row + column * this._RowCount] = value;
}
}
#endregion
#region Private Methods
/// <summary>Check if size(this) == size(B) </summary>
private void CheckMatrixDimensions(ComplexMatrix B)
{
if (this._RowCount != B.RowCount || B.ColumnCount != this._ColumnCount)
{
throw new System.ArgumentException("Matrix dimensions must agree.");
}
}
/// <summary>Check if size(this) == size(B) </summary>
private void CheckMatrixDimensions(Matrix B)
{
if (this._RowCount != B.RowCount || B.ColumnCount != this._ColumnCount)
{
throw new System.ArgumentException("Matrix dimensions must agree.");
}
}
#endregion // Private Methods
#region Elementary linear operations
///// <summary>
///// aij=Math.Abs(aij)
///// </summary>
//public virtual void ElementsAbs()
//{
// for (int i = 0; i < this.MeData.Length; i++)
// {
// this.MeData[i] =Complex. Math.Abs(this.MeData[i]);
// }
//}
///// <summary>
///// Element-by-element division: aij = aij/bij
///// </summary>
///// <param name="B"></param>
//public virtual void ElemntsDiv(MatrixComplex B)
//{
// CheckMatrixDimensions(B);
// Complex[] BData = B.Data;
// for (int i = 0; i < this.MeData.Length; i++)
// {
// this.MeData[i] /= BData[i];
// }
//}
/// <summary>
/// Element-by-element multiplication: aij = aij*bij
/// </summary>
/// <param name="B">The B MatrixComplex</param>
public virtual void ElemntsMult(ComplexMatrix B)
{
CheckMatrixDimensions(B);
Complex[] BData = B.Data;
for (int i = 0; i < this._Data.Length; i++)
{
this._Data[i] = this._Data[i] * BData[i];
}
}
/// <summary>
/// In place addition A=A+B
/// </summary>
/// <param name="B">The B MatrixComplex</param>
public virtual void Add(ComplexMatrix B)
{
CheckMatrixDimensions(B);
Complex[] BData = B.Data;
for (int i = 0; i < this._Data.Length; i++)
{
this._Data[i] = this._Data[i] + BData[i];
}
}
/// <summary>
/// In place scalar-matrix multiplication, A=s*A
/// </summary>
/// <param name="s">The scalar s.</param>
public virtual void Multiply(double s)
{
for (int i = 0; i < this._Data.Length; i++)
{
this._Data[i].Real = s * this._Data[i].Real;
this._Data[i].Imaginary = s * this._Data[i].Imaginary;
}
}
/// <summary>
/// In place scalar-matrix multiplication, A=c*A
/// </summary>
/// <param name="s">The scalar s.</param>
public virtual void MultiplyC(Complex c)
{
for (int i = 0; i < this._Data.Length; i++)
{
this._Data[i] = c * this._Data[i];
}
}
/// <summary>
/// In place matrix subtraction, A=A-B.
/// </summary>
/// <param name="B">The B MatrixComplex.</param>
public virtual void Subtract(ComplexMatrix B)
{
CheckMatrixDimensions(B);
Complex[] BData = B.Data;
for (int i = 0; i < this._Data.Length; i++)
{
this._Data[i].Real = this._Data[i].Real - BData[i].Real;
this._Data[i].Imaginary = this._Data[i].Imaginary - BData[i].Imaginary;
}
}
/// <summary>
/// In place unary minus -A.
/// </summary>
public virtual void UnaryMinus()
{
for (int i = 0; i < this._Data.Length; i++)
{
this._Data[i].Real = -this._Data[i].Real;
this._Data[i].Imaginary = -this._Data[i].Imaginary;
}
}
#endregion
#region Methods
/// <summary>
/// Gets the column vectors of this matrix.
/// </summary>
/// <returns>The columns vectors.</returns>
public ComplexVector[] GetColumnVectors()
{
ComplexVector[] columnVects = new ComplexVector[this._ColumnCount];
Complex[] VectData;
for (int j = 0; j < this._ColumnCount; j++)
{
columnVects[j] = new ComplexVector(VectorType.Column, this._RowCount);
VectData = columnVects[j].Data;
for (int i = 0; i < VectData.Length; i++)
{
VectData[i] = this._Data[i + j * this._RowCount];
}
}
return columnVects;
}
/// <summary>
/// Gets the row vectors of this matrix.
/// </summary>
/// <returns>The row vectors.</returns>
public ComplexVector[] GetRowVectors()
{
ComplexVector[] rowVects = new ComplexVector[this.RowCount];
Complex[] VectData;
for (int i = 0; i < this._RowCount; i++)
{
rowVects[i] = new ComplexVector(VectorType.Row, this._ColumnCount);
VectData = rowVects[i].Data;
for (int j = 0; j < VectData.Length; j++)
{
VectData[j] = this._Data[i + j * this._RowCount];
}
}
return rowVects;
}
/// <summary>
/// Gets a matrix that contains the real part of this matrix.
/// </summary>
/// <returns>A matrix that contains the real part of this matrix. </returns>
public Matrix GetReal()
{
Matrix RealMatrix = new Matrix(this.RowCount, this.ColumnCount);
double[] RealData = RealMatrix.Data;
for (int i = 0; i < this._Data.Length; i++)
{
RealData[i] = this._Data[i].Real;
}
return RealMatrix;
}
/// <summary>
/// Gets a matrix that contains the imaginary part of this matrix.
/// </summary>
/// <returns>A matrix that contains the imaginary part of this matrix. </returns>
public Matrix GetImag()
{
Matrix ImagMatrix = new Matrix(this.RowCount, this.ColumnCount);
double[] ImagData = ImagMatrix.Data;
for (int i = 0; i < this._Data.Length; i++)
{
ImagData[i] = this._Data[i].Imaginary;
}
return ImagMatrix;
}
/// <summary>
/// Sets the real part of the elements of this matrix equal to the elemnets of a real matrix.
/// </summary>
/// <param name="RM">A matrix that contains the values of the real part.</param>
public void SetReal(Matrix RM)
{
this.CheckMatrixDimensions(RM);
double[] RealData = RM.Data;
for (int i = 0; i < this._Data.Length; i++)
{
this._Data[i].Real = RealData[i];
}
}
/// <summary>
/// Sets the imaginary part of the elements of this matrix equal to the elemnets of a real matrix.
/// </summary>
/// <param name="IM">A matrix that contains the values of the imaginary part.</param>
public void SetImag(Matrix IM)
{
this.CheckMatrixDimensions(IM);
double[] ImagData = IM.Data;
for (int i = 0; i < this._Data.Length; i++)
{
this._Data[i].Imaginary = ImagData[i];
}
}
/// <summary>
/// Returns the string of the matrix.
/// </summary>
/// <returns>The string of the matrix.</returns>
public string MatrixToString()
{
using (StringWriter writer = new StringWriter())
{
for (int i = 0; i < this._RowCount; i++)
{
for (int j = 0; j < this._ColumnCount; j++)
writer.Write(this[i, j] + ", ");
writer.WriteLine();
}
return writer.ToString();
}
}
/// <summary>
/// Returns the string of the matrix.
/// </summary>
/// <param name="format">A numeric format string.</param>
/// <returns>The string of the matrix.</returns>
public string MatrixToString(string format)
{
using (StringWriter writer = new StringWriter())
{
for (int i = 0; i < this._RowCount; i++)
{
for (int j = 0; j < this._ColumnCount; j++)
writer.Write(this[i, j].ToString(format) + ", ");
writer.WriteLine();
}
return writer.ToString();
}
}
///// <summary>
///// maximum column sum.
///// </summary>
///// <returns>maximum column sum.</returns>
//public double Norm1()
//{
// double n = 0.0;
// double ColSum = 0.0;
// int NRows = this.MeRowCount;
// for (int j = 0; j < this.MeColumnCount; j++)
// {
// ColSum = 0.0;
// for (int i = 0; i < this.MeRowCount; i++)
// {
// ColSum += Math.Abs(this.MeData[i + j * NRows]);
// }
// n = Math.Max(n, ColSum);
// }
// return n;
//}
///// <summary>
/////
///// </summary>
///// <returns></returns>
//public double InfinityNorm()
//{
// double n = 0.0;
// double RowSum = 0.0;
// int NRows = this.MeRowCount;
// for (int i = 0; i < this.MeRowCount; i++)
// {
// RowSum = 0.0;
// for (int j = 0; j < this.MeColumnCount; j++)
// {
// RowSum += Math.Abs(this.MeData[i + j * NRows]);
// }
// n = Math.Max(n, RowSum);
// }
// return n;
//}
///// <summary>Frobenius norm</summary>
///// <returns>Sqrt of sum of squares of all elements.</returns>
//public double FrobeniusNorm()
//{
// double n=0;
// for(int i=0; i<this.MeData.Length; i++)
// {
// n=this.Hypot(n,this.MeData[i]);
// }
// return n;
//}
///// <summary>sqrt(a^2 + b^2) without under/overflow.</summary>
//private double Hypot(double a, double b)
//{
// double r;
// if (Math.Abs(a) > Math.Abs(b))
// {
// r = b/a;
// r = Math.Abs(a) * Math.Sqrt(1 + r * r);
// }
// else if (b != 0)
// {
// r = a/b;
// r = Math.Abs(b) * Math.Sqrt(1 + r * r);
// }
// else
// {
// r = 0.0;
// }
// return r;
//}
#endregion
#region Matrix-Matrix Multiplication
/// <summary>
/// Matrix multiplication.
/// </summary>
/// <param name="A"> The left side matrix of the multiplication operator.</param>
/// <param name="B">The right side matrix of the multiplication operator.</param>
/// <returns>A matrix that represents the result of the matrix multiplication.</returns>
public static ComplexMatrix operator *(ComplexMatrix A, ComplexMatrix B)
{
if (B.RowCount != A.ColumnCount)
{
throw new System.ArgumentException("Matrix dimensions are not valid.");
}
ComplexMatrix C = new ComplexMatrix(A.RowCount, B.ColumnCount);
Complex[] AData = A.Data;
Complex[] BData = B.Data;
Complex[] CData = C.Data;
int ARows = A.RowCount;
int AColumns = A.ColumnCount;
int BRows = B.RowCount;
int BColumns = B.ColumnCount;
Complex Sum = new Complex(0.0, 0.0);
for (int j = 0; j < BColumns; j++)
{
for (int i = 0; i < ARows; i++)
{
Sum.Imaginary = 0.0;
Sum.Real = 0.0;
for (int k = 0; k < AColumns; k++)
{
Sum += AData[i + k * ARows] * BData[k + j * BRows];
}
CData[i + j * ARows] = Sum;
}
}
return C;
}
/// <summary>
/// Matrix multiplication.
/// </summary>
/// <param name="A"> The left side matrix of the multiplication operator.</param>
/// <param name="B">The right side matrix of the multiplication operator.</param>
/// <returns>A matrix that represents the result of the matrix multiplication.</returns>
public static ComplexMatrix operator *(BaseMatrix A, ComplexMatrix B)
{
if (B.RowCount != A.ColumnCount)
{
throw new System.ArgumentException("Matrix dimensions are not valid.");
}
ComplexMatrix C = new ComplexMatrix(A.RowCount, B.ColumnCount);
double[] AData = A.Data;
Complex[] BData = B.Data;
Complex[] CData = C.Data;
int ARows = A.RowCount;
int AColumns = A.ColumnCount;
int BRows = B.RowCount;
int BColumns = B.ColumnCount;
Complex Sum = new Complex(0.0, 0.0);
for (int j = 0; j < BColumns; j++)
{
for (int i = 0; i < ARows; i++)
{
Sum.Imaginary = 0.0;
Sum.Real = 0.0;
for (int k = 0; k < AColumns; k++)
{
Sum += AData[i + k * ARows] * BData[k + j * BRows];
}
CData[i + j * ARows] = Sum;
}
}
return C;
}
/// <summary>complex-Matrix multiplication.</summary>
/// <param name="c"> The left side scalar of the multiplication operator.</param>
/// <param name="B">The right side matrix of the multiplication operator.</param>
/// <returns>A matrix that represents the result of the multiplication.</returns>
public static ComplexMatrix operator *(Complex c, ComplexMatrix B)
{
ComplexMatrix C = new ComplexMatrix(B.RowCount, B.ColumnCount);
Complex[] BData = B.Data;
Complex[] CData = C.Data;
for (int i = 0; i < BData.Length; i++)
{
CData[i] = c * BData[i];
}
return C;
}
#endregion
#region Matrix-Matrix Addition
/// <summary>
/// Matrix addition.
/// </summary>
/// <param name="A">The left side matrix of the addition operator.</param>
/// <param name="B">The right side matrix of the addition operator.</param>
/// <returns>A matrix that represents the result of the matrix addition.</returns>
public static ComplexMatrix operator +(ComplexMatrix A, ComplexMatrix B)
{
if (B.RowCount != A.RowCount || B.ColumnCount != A.ColumnCount)
{
throw new System.ArgumentException("Matrix dimensions are not valid.");
}
ComplexMatrix C = new ComplexMatrix(A.RowCount, A.ColumnCount);
Complex[] AData = A.Data;
Complex[] BData = B.Data;
Complex[] CData = C.Data;
for (int i = 0; i < AData.Length; i++)
{
CData[i] = AData[i] + BData[i];
}
return C;
}
#endregion
#region Matrix-Matrix Subtraction
///// <summary>Matrix Subtraction</summary>
/// <summary>
/// Matrix subtraction.
/// </summary>
/// <param name="A"> The left side matrix of the subtraction operator.</param>
/// <param name="B">The right side matrix of the subtraction operator.</param>
/// <returns>A matrix that represents the result of the matrix subtraction.</returns>
public static ComplexMatrix operator -(ComplexMatrix A, ComplexMatrix B)
{
if (B.RowCount != A.RowCount || B.ColumnCount != A.ColumnCount)
{
throw new System.ArgumentException("Matrix dimensions are not valid.");
}
ComplexMatrix C = new ComplexMatrix(A.RowCount, A.ColumnCount);
Complex[] AData = A.Data;
Complex[] BData = B.Data;
Complex[] CData = C.Data;
for (int i = 0; i < AData.Length; i++)
{
CData[i] = AData[i] - BData[i];
}
return C;
}
#endregion
#region IMatrix<Complex> Members
/// <summary>
/// Copy all elements of this matrix to a rectangular 2D array.
/// </summary>
/// <returns>A rectangular 2D array.</</returns>
public Complex[,] CopyToArray()
{
Complex[,] matrixData = new Complex[this._RowCount, this._ColumnCount];
for (int j = 0; j < this._ColumnCount; j++)
{
for (int i = 0; i < this._RowCount; i++)
{
matrixData[i, j] = this._Data[i + j * this._RowCount];
}
}
return matrixData;
}
/// <summary>
/// Copy all elements of this matrix to a jagged array.
/// </summary>
/// <returns>A jagged array.</returns>
public Complex[][] CopyToJaggedArray()
{
Complex[][] newData = new Complex[this._RowCount][];
for (int i = 0; i < this._RowCount; i++)
{
Complex[] row = new Complex[this._ColumnCount];
for (int j = 0; j < this._ColumnCount; j++)
{
row[j] = this._Data[i + j * this._RowCount];
}
newData[i] = row;
}
return newData;
}
#endregion
}
}