Matrix.cs

Go to the documentation of this file.

using System.Collections;
using System.Globalization;
using System.Text;
 
namespace IDSImaging.Peak.ICV.Types;
 
public class Matrix<T> : IEnumerable<T>
{
    static Matrix()
    {
        // Guard rail: Only allow these specific types
        if (typeof(T) != typeof(int) &&
            typeof(T) != typeof(uint) &&
            typeof(T) != typeof(float))
        {
            throw new IcvNotSupportedException($"{typeof(T)} is not supported.");
        }
    }
 
    public Matrix(uint rows, uint columns)
    {
        Rows = rows;
        Columns = columns;
        Values = new T[rows, columns];
    }
 
    public Matrix(uint rows, uint columns, T[,] data)
        : this(rows, columns)
    {
        if (data is null)
        {
            throw new IcvNullPointerException("Invalid data array.");
        }
 
        if (data.Length != rows * columns)
        {
            throw new IcvMismatchException("Data length does not match matrix dimensions.");
        }
 
        Values = data;
    }
 
    public Matrix(uint rows, uint columns, T[] data)
        : this(rows, columns)
    {
        if (data is null)
        {
            throw new IcvNullPointerException("Invalid data array.");
        }
 
        if (data.Length != rows * columns)
        {
            throw new IcvMismatchException("Data length does not match matrix dimensions.");
        }
 
        for (uint r = 0; r < rows; r++)
        for (uint c = 0; c < columns; c++)
        {
            Values[r, c] = data[r * columns + c];
        }
    }
 
    internal T[,] Values { get; set; }
 
    public uint Rows { get; }
 
    public uint Columns { get; }
 
    public T this[uint row, uint col]
    {
        get
        {
            if (row >= Rows || col >= Columns)
            {
                throw new IcvOutOfRangeException("The given row or column index is out of range.");
            }
 
            return Values[row, col];
        }
        set
        {
            if (row >= Rows || col >= Columns)
            {
                throw new IcvOutOfRangeException("The given row or column index is out of range.");
            }
 
            Values[row, col] = value;
        }
    }
 
    public static IEqualityComparer<Matrix<T>> Comparer { get; } = new MatrixEqualityComparer();
 
    public IEnumerator<T> GetEnumerator()
    {
        return Flatten().AsEnumerable().GetEnumerator();
    }
 
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
 
    public override int GetHashCode()
    {
        unchecked
        {
            var hash = 17;
            var prime = 31;
 
            hash = hash * prime + Rows.GetHashCode();
            hash = hash * prime + Columns.GetHashCode();
 
            for (uint r = 0; r < Rows; r++)
            {
                for (uint c = 0; c < Columns; c++)
                {
                    T value = Values[r, c];
                    hash = hash * prime + (value?.GetHashCode() ?? 0);
                }
            }
 
            return hash;
        }
    }
 
 
    public static Matrix<T> Diagonal(uint size, T value)
    {
        var result = new Matrix<T>(size, size);
        for (uint i = 0; i < size; i++)
        {
            result[i, i] = value;
        }
 
        return result;
    }
 
    public static Matrix<T> Identity(uint size)
    {
        return Diagonal(size, (T) Convert.ChangeType(1, typeof(T)));
    }
 
    internal T[] Flatten()
    {
        return Values.Cast<T>().ToArray();
    }
 
    internal static T[,] To2DArray(T[] input, uint height, uint width)
    {
        var output = new T[height, width];
        for (uint i = 0; i < height; i++)
        {
            for (uint j = 0; j < width; j++)
            {
                output[i, j] = input[i * width + j];
            }
        }
 
        return output;
    }
 
    public override string ToString()
    {
        var sb = new StringBuilder();
 
        for (uint i = 0; i < Rows; i++)
        {
            for (uint j = 0; j < Columns; j++)
            {
                T value = this[i, j];
 
                if (value is IFormattable f)
                {
                    sb.Append(f.ToString("F2", CultureInfo.InvariantCulture));
                }
 
                if (j < Columns - 1)
                {
                    sb.Append(" ");
                }
            }
 
            if (i < Rows - 1)
            {
                sb.Append("\n");
            }
        }
 
        return sb.ToString();
    }
 
    protected sealed class MatrixEqualityComparer : IEqualityComparer<Matrix<T>>
    {
        public bool Equals(Matrix<T>? x, Matrix<T>? y)
        {
            if (ReferenceEquals(x, y))
            {
                return true;
            }
 
            if (x is null || y is null)
            {
                return false;
            }
 
 
            T[] xFlat = x.Flatten();
            T[] yFlat = y.Flatten();
 
            if (xFlat.Length != yFlat.Length)
            {
                return false;
            }
 
            for (var i = 0; i < xFlat.Length; ++i)
            {
                if (IsEqual(xFlat[i], yFlat[i], 1e-6f))
                {
                    return false;
                }
            }
 
            return true;
        }
 
        public int GetHashCode(Matrix<T> obj)
        {
            unchecked
            {
                var hash = 17;
                foreach (T value in obj)
                {
                    hash = hash * 31 + (value?.GetHashCode() ?? 0);
                }
 
                return hash;
            }
        }
 
        private static bool IsEqual(T x, T y, double tolerance)
        {
            return x switch
            {
                float fX => Math.Abs(fX - (float) (object) y!) > tolerance,
                int iX => iX == (int) (object) y!,
                uint uX => uX == (uint) (object) y!,
                _ => throw new IcvNotSupportedException("Unsupported generic type for matrix class.")
            };
        }
    }
}