Array2D.cs

using MPewsey.Common.Mathematics;
using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Text;
 
namespace MPewsey.Common.Collections
{
    [DataContract(Name = "Array2D", Namespace = Constants.DataContractNamespace)]
    public class Array2D<T>
    {
        [DataMember(Order = 1)]
        public int Rows { get; private set; }
 
        [DataMember(Order = 2)]
        public int Columns { get; private set; }
 
        [DataMember(Order = 3)]
        public T[] Array { get; private set; } = System.Array.Empty<T>();
 
        public Array2D()
        {
 
        }
 
        public Array2D(int rows, int columns)
        {
            if (rows < 0)
                throw new ArgumentException($"Rows cannot be negative: {rows}.");
            if (columns < 0)
                throw new ArgumentException($"Columns cannot be negative: {columns}.");
 
            if (rows > 0 && columns > 0)
            {
                Rows = rows;
                Columns = columns;
                Array = new T[rows * columns];
            }
        }
 
        public Array2D(Array2D<T> other)
        {
            if (other.Rows > 0 && other.Columns > 0)
            {
                Rows = other.Rows;
                Columns = other.Columns;
                Array = new T[Rows * Columns];
                other.Array.CopyTo(Array, 0);
            }
        }
 
        public Array2D(T[,] array)
        {
            if (array.Length > 0)
            {
                Rows = array.GetLength(0);
                Columns = array.GetLength(1);
                Array = FlattenArray(array);
            }
        }
 
        public T this[int row, int column]
        {
            get
            {
                if (!IndexExists(row, column))
                    throw new IndexOutOfRangeException($"Index out of range: ({row}, {column}).");
                return Array[Index(row, column)];
            }
            set
            {
                if (!IndexExists(row, column))
                    throw new IndexOutOfRangeException($"Index out of range: ({row}, {column}).");
                Array[Index(row, column)] = value;
            }
        }
 
        public T this[Vector2DInt index]
        {
            get => this[index.X, index.Y];
            set => this[index.X, index.Y] = value;
        }
 
        public static implicit operator Array2D<T>(T[,] array) => new Array2D<T>(array);
 
        public override string ToString()
        {
            return $"Array2D<{typeof(T)}>(Rows = {Rows}, Columns = {Columns})";
        }
 
        public Array2D<T> Copy()
        {
            return new Array2D<T>(this);
        }
 
        public string ToArrayString()
        {
            var size = 2 + 2 * Array.Length + 4 * Rows;
            var builder = new StringBuilder(size);
            builder.Append('[');
 
            for (int i = 0; i < Rows; i++)
            {
                builder.Append('[');
 
                for (int j = 0; j < Columns; j++)
                {
                    builder.Append(this[i, j]);
 
                    if (j < Columns - 1)
                        builder.Append(", ");
                }
 
                builder.Append(']');
 
                if (i < Rows - 1)
                    builder.Append("\n ");
            }
 
            builder.Append(']');
            return builder.ToString();
        }
 
        public void Clear()
        {
            System.Array.Clear(Array, 0, Array.Length);
        }
 
        public void Fill(T value)
        {
            for (int i = 0; i < Array.Length; i++)
            {
                Array[i] = value;
            }
        }
 
        public static bool ValuesAreEqual(Array2D<T> x, Array2D<T> y)
        {
            return ValuesAreEqual(x, y, EqualityComparer<T>.Default.Equals);
        }
 
        public static bool ValuesAreEqual(Array2D<T> x, Array2D<T> y, Func<T, T, bool> comparer)
        {
            if (x == y)
                return true;
 
            if (x == null || y == null)
                return false;
 
            return x.ValuesAreEqual(y, comparer);
        }
 
        public bool ValuesAreEqual(Array2D<T> other)
        {
            return ValuesAreEqual(other, EqualityComparer<T>.Default.Equals);
        }
 
        public bool ValuesAreEqual(Array2D<T> other, Func<T, T, bool> comparer)
        {
            if (Array.Length != other.Array.Length || Rows != other.Rows || Columns != other.Columns)
                return false;
 
            for (int i = 0; i < Array.Length; i++)
            {
                if (!comparer.Invoke(Array[i], other.Array[i]))
                    return false;
            }
 
            return true;
        }
 
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public bool IndexExists(int row, int column)
        {
            return (uint)row < (uint)Rows && (uint)column < (uint)Columns;
        }
 
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private int Index(int row, int column)
        {
            return row * Columns + column;
        }
 
        public Vector2DInt InverseIndex(int index)
        {
            if ((uint)index < (uint)Array.Length)
            {
                var row = index / Columns;
                var column = index - row * Columns;
                return new Vector2DInt(row, column);
            }
 
            throw new IndexOutOfRangeException($"Index out of range: {index}.");
        }
 
        public Vector2DInt FindIndex(Func<T, bool> predicate)
        {
            for (int i = 0; i < Rows; i++)
            {
                for (int j = 0; j < Columns; j++)
                {
                    if (predicate.Invoke(Array[Index(i, j)]))
                        return new Vector2DInt(i, j);
                }
            }
 
            return new Vector2DInt(-1, -1);
        }
 
        public List<Vector2DInt> FindIndexes(Func<T, bool> predicate)
        {
            var result = new List<Vector2DInt>();
 
            for (int i = 0; i < Rows; i++)
            {
                for (int j = 0; j < Columns; j++)
                {
                    if (predicate.Invoke(Array[Index(i, j)]))
                        result.Add(new Vector2DInt(i, j));
                }
            }
 
            return result;
        }
 
        public static T[] FlattenArray(T[,] array)
        {
            var result = new T[array.Length];
            int k = 0;
 
            for (int i = 0; i < array.GetLength(0); i++)
            {
                for (int j = 0; j < array.GetLength(1); j++)
                {
                    result[k++] = array[i, j];
                }
            }
 
            return result;
        }
 
        public T GetOrDefault(int row, int column, T fallback = default)
        {
            if (IndexExists(row, column))
                return Array[Index(row, column)];
            return fallback;
        }
 
        public T GetOrDefault(Vector2DInt index, T fallback = default)
        {
            return GetOrDefault(index.X, index.Y, fallback);
        }
 
        public Vector2DInt IndexRotated90(Vector2DInt index)
        {
            return IndexRotated90(index.X, index.Y);
        }
 
        public Vector2DInt IndexRotated90(int row, int column)
        {
            return new Vector2DInt(column, Rows - 1 - row);
        }
 
        public Array2D<T> Rotated90()
        {
            var rotation = new Array2D<T>(Columns, Rows);
 
            for (int i = 0; i < Rows; i++)
            {
                for (int j = 0; j < Columns; j++)
                {
                    rotation[IndexRotated90(i, j)] = this[i, j];
                }
            }
 
            return rotation;
        }
 
        public Vector2DInt IndexRotated180(Vector2DInt index)
        {
            return IndexRotated180(index.X, index.Y);
        }
 
        public Vector2DInt IndexRotated180(int row, int column)
        {
            return new Vector2DInt(Rows - 1 - row, Columns - 1 - column);
        }
 
        public Array2D<T> Rotated180()
        {
            var rotation = new Array2D<T>(Rows, Columns);
 
            for (int i = 0; i < Rows; i++)
            {
                for (int j = 0; j < Columns; j++)
                {
                    rotation[IndexRotated180(i, j)] = this[i, j];
                }
            }
 
            return rotation;
        }
 
        public Vector2DInt IndexRotated270(Vector2DInt index)
        {
            return IndexRotated270(index.X, index.Y);
        }
 
        public Vector2DInt IndexRotated270(int row, int column)
        {
            return new Vector2DInt(Columns - 1 - column, row);
        }
 
        public Array2D<T> Rotated270()
        {
            var rotation = new Array2D<T>(Columns, Rows);
 
            for (int i = 0; i < Rows; i++)
            {
                for (int j = 0; j < Columns; j++)
                {
                    rotation[IndexRotated270(i, j)] = this[i, j];
                }
            }
 
            return rotation;
        }
 
        public Vector2DInt IndexMirroredHorizontally(Vector2DInt index)
        {
            return IndexMirroredHorizontally(index.X, index.Y);
        }
 
        public Vector2DInt IndexMirroredHorizontally(int row, int column)
        {
            return new Vector2DInt(row, Columns - 1 - column);
        }
 
        public Array2D<T> MirroredHorizontally()
        {
            var mirror = new Array2D<T>(Rows, Columns);
 
            for (int i = 0; i < Rows; i++)
            {
                for (int j = 0; j < Columns; j++)
                {
                    mirror[IndexMirroredHorizontally(i, j)] = this[i, j];
                }
            }
 
            return mirror;
        }
 
        public Vector2DInt IndexMirroredVertically(Vector2DInt index)
        {
            return IndexMirroredVertically(index.X, index.Y);
        }
 
        public Vector2DInt IndexMirroredVertically(int row, int column)
        {
            return new Vector2DInt(Rows - 1 - row, column);
        }
 
        public Array2D<T> MirroredVertically()
        {
            var mirror = new Array2D<T>(Rows, Columns);
 
            for (int i = 0; i < Rows; i++)
            {
                for (int j = 0; j < Columns; j++)
                {
                    mirror[IndexMirroredVertically(i, j)] = this[i, j];
                }
            }
 
            return mirror;
        }
 
        public Array2D<int> FindDistances(int row, int column, Func<T, bool> predicate = null)
        {
            if (predicate == null)
                predicate = x => EqualityComparer<T>.Default.Equals(x, default);
 
            var distances = new Array2D<int>(Rows, Columns);
            distances.Fill(-1);
            SearchDistances(row, column, 0, distances, predicate);
            return distances;
        }
 
        private void SearchDistances(int row, int column, int distance, Array2D<int> distances, Func<T, bool> predicate)
        {
            if (IndexExists(row, column) && !predicate.Invoke(this[row, column]))
            {
                var currentDistance = distances[row, column];
 
                if (currentDistance > distance || currentDistance < 0)
                {
                    distances[row, column] = distance++;
                    SearchDistances(row, column - 1, distance, distances, predicate);
                    SearchDistances(row, column + 1, distance, distances, predicate);
                    SearchDistances(row - 1, column, distance, distances, predicate);
                    SearchDistances(row + 1, column, distance, distances, predicate);
                }
            }
        }
    }
}