BooleanMatrix.cs

using System.Collections.Generic;
using System.Text;
using Waher.Script.Abstraction.Sets;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Exceptions;
using Waher.Script.Model;
using Waher.Script.Objects.VectorSpaces;
using Waher.Script.Operators.Matrices;
 
namespace Waher.Script.Objects.Matrices
{
    public sealed class BooleanMatrix : RingElement, IMatrix
    {
        private bool[,] values;
        private IElement[,] matrixElements;
        private ICollection<IElement> elements;
        private readonly int rows;
        private readonly int columns;
 
        public BooleanMatrix(bool[,] Values)
        {
            this.values = Values;
            this.elements = null;
            this.matrixElements = null;
            this.rows = Values.GetLength(0);
            this.columns = Values.GetLength(1);
        }
 
        public BooleanMatrix(int Rows, int Columns, ICollection<IElement> Elements)
        {
            this.values = null;
            this.elements = Elements;
            this.matrixElements = null;
            this.rows = Rows;
            this.columns = Columns;
        }
 
        public bool[,] Values
        {
            get
            {
                if (this.values is null)
                {
                    bool[,] v = new bool[this.rows, this.columns];
                    int x = 0;
                    int y = 0;
 
                    foreach (IElement Element in this.elements)
                    {
                        if (!(Element.AssociatedObjectValue is bool b))
                            b = false;
 
                        v[y, x++] = b;
                        if (x >= this.columns)
                        {
                            y++;
                            x = 0;
                        }
                    }
 
                    this.values = v;
                }
 
                return this.values;
            }
        }
 
        public ICollection<IElement> Elements
        {
            get
            {
                if (this.elements is null)
                {
                    int x, y, i = 0;
                    IElement[] v = new IElement[this.rows * this.columns];
 
                    for (y = 0; y < this.rows; y++)
                    {
                        for (x = 0; x < this.columns; x++)
                            v[i++] = new BooleanValue(this.values[y, x]);
                    }
 
                    this.elements = v;
                }
 
                return this.elements;
            }
        }
 
        public IElement[,] MatrixElements
        {
            get
            {
                if (this.matrixElements is null)
                {
                    IElement[,] v = new IElement[this.rows, this.columns];
                    int x = 0;
                    int y = 0;
 
                    foreach (IElement E in this.Elements)
                    {
                        v[y, x++] = E;
                        if (x >= this.columns)
                        {
                            y++;
                            x = 0;
                        }
                    }
 
                    this.matrixElements = v;
                }
 
                return this.matrixElements;
            }
        }
 
        public int Rows => this.rows;
 
        public int Columns => this.columns;
 
        public override string ToString()
        {
            bool[,] v = this.Values;
            StringBuilder sb = null;
            bool First;
            int x, y;
 
            for (y = 0; y < this.rows; y++)
            {
                if (sb is null)
                    sb = new StringBuilder("[[");
                else
                    sb.Append(",\r\n [");
 
                First = true;
                for (x = 0; x < this.columns; x++)
                {
                    if (First)
                        First = false;
                    else
                        sb.Append(", ");
 
                    sb.Append(Expression.ToString(v[y, x]));
                }
 
                sb.Append(']');
            }
 
            if (sb is null)
                sb = new StringBuilder("[[]]");
            else
                sb.Append(']');
 
            return sb.ToString();
        }
 
        public override IRing AssociatedRing
        {
            get
            {
                if (this.associatedMatrixSpace is null)
                    this.associatedMatrixSpace = new BooleanMatrices(this.rows, this.columns);
 
                return this.associatedMatrixSpace;
            }
        }
 
        private BooleanMatrices associatedMatrixSpace = null;
 
        public override object AssociatedObjectValue => this;
 
        public override IRingElement MultiplyLeft(IRingElement Element)
        {
            return this.ToDoubleMatrix().MultiplyLeft(Element);
        }
 
        public override IRingElement MultiplyRight(IRingElement Element)
        {
            return this.ToDoubleMatrix().MultiplyRight(Element);
        }
 
        public override IRingElement Invert()
        {
            if (this.rows != this.columns)
                return null;
 
            return this.ToDoubleMatrix().Invert();
        }
 
        public IMatrix Reduce(bool Eliminate, bool BreakIfZero, out int Rank, out ICommutativeRingWithIdentityElement Factor)
        {
            return this.ToDoubleMatrix().Reduce(Eliminate, BreakIfZero, out Rank, out Factor);
        }
 
        public DoubleMatrix ToDoubleMatrix()
        {
            bool[,] Values = this.Values;
            double[,] v = new double[this.rows, this.columns];
            int x, y;
 
            for (y = 0; y < this.rows; y++)
            {
                for (x = 0; x < this.columns; x++)
                    v[y, x] = Values[y, x] ? 1 : 0;
            }
 
            return new DoubleMatrix(v);
        }
 
        public override IAbelianGroupElement Add(IAbelianGroupElement Element)
        {
            return this.ToDoubleMatrix().Add(Element);
        }
 
        public override IGroupElement Negate()
        {
            return this;
        }
 
        public override bool Equals(object obj)
        {
            if (!(obj is BooleanMatrix Matrix))
                return false;
 
            if (this.columns != Matrix.columns || this.rows != Matrix.rows)
                return false;
 
            bool[,] V1 = this.Values;
            bool[,] V2 = Matrix.Values;
            int x, y;
 
            for (y = 0; y < this.rows; y++)
            {
                for (x = 0; x < this.columns; x++)
                {
                    if (V1[y, x] != V2[y, x])
                        return false;
                }
            }
 
            return true;
        }
 
        public override int GetHashCode()
        {
            int Result = 0;
            int x, y;
            int i = 0;
 
            for (y = 0; y < this.rows; y++)
            {
                for (x = 0; x < this.columns; x++)
                {
                    if (this.values[y, x])
                        Result ^= (1 << i);
 
                    i++;
                    i &= 31;
                }
            }
 
            return Result;
        }
 
        public override bool IsScalar => false;
 
        public override ICollection<IElement> ChildElements => this.Elements;
 
        public override IElement Encapsulate(ICollection<IElement> Elements, ScriptNode Node)
        {
            return MatrixDefinition.Encapsulate(Elements, this.rows, this.columns, Node);
        }
 
        public override IAbelianGroupElement Zero
        {
            get
            {
                if (this.zero is null)
                    this.zero = new BooleanMatrix(new bool[this.rows, this.columns]);
 
                return this.zero;
            }
        }
 
        private BooleanMatrix zero = null;
 
        public int Dimension => this.rows;
 
        public ICollection<IElement> VectorElements
        {
            get
            {
                if (!(this.rowVectors is null))
                    return this.rowVectors;
 
                bool[,] v = this.Values;
                LinkedList<IElement> Rows = new LinkedList<IElement>();
                int x, y;
                bool[] r;
 
                for (y = 0; y < this.rows; y++)
                {
                    r = new bool[this.columns];
 
                    for (x = 0; x < this.columns; x++)
                        r[x] = v[y, x];
 
                    Rows.AddLast(new BooleanVector(r));
                }
 
                this.rowVectors = Rows;
                return Rows;
            }
        }
 
        private LinkedList<IElement> rowVectors = null;
 
        public IMatrix Transpose()
        {
            bool[,] v = new bool[this.columns, this.rows];
            bool[,] Values = this.Values;
            int x, y;
 
            for (y = 0; y < this.rows; y++)
            {
                for (x = 0; x < this.columns; x++)
                    v[x, y] = Values[y, x];
            }
 
            return new BooleanMatrix(v);
        }
 
        public IMatrix ConjugateTranspose()
        {
            return this.Transpose();
        }
 
        public IElement GetElement(int Index)
        {
            if (Index < 0 || Index >= this.rows)
                throw new ScriptException("Index out of bounds.");
 
            bool[,] M = this.Values;
            bool[] V = new bool[this.columns];
            int i;
 
            for (i = 0; i < this.columns; i++)
                V[i] = M[Index, i];
 
            return new BooleanVector(V);
        }
 
        public void SetElement(int Index, IElement Value)
        {
            if (Index < 0 || Index >= this.rows)
                throw new ScriptException("Index out of bounds.");
 
            if (!(Value is BooleanVector V))
                throw new ScriptException("Row vectors in a boolean matrix are required to be boolean vectors.");
 
            if (V.Dimension != this.columns)
                throw new ScriptException("Dimension mismatch.");
 
            bool[] V2 = V.Values;
            bool[,] M = this.Values;
            this.elements = null;
 
            int i;
 
            for (i = 0; i < this.columns; i++)
                M[Index, i] = V2[i];
        }
 
        public IElement GetElement(int Column, int Row)
        {
            if (Column < 0 || Column >= this.columns || Row < 0 || Row >= this.rows)
                throw new ScriptException("Index out of bounds.");
 
            return new BooleanValue(this.Values[Row, Column]);
        }
 
        public void SetElement(int Column, int Row, IElement Value)
        {
            if (Column < 0 || Column >= this.columns || Row < 0 || Row >= this.rows)
                throw new ScriptException("Index out of bounds.");
 
            if (!(Value.AssociatedObjectValue is bool V))
                throw new ScriptException("Elements in a boolean matrix must be boolean values.");
 
            bool[,] M = this.Values;
            this.elements = null;
 
            M[Row, Column] = V;
        }
 
        public IVector GetRow(int Row)
        {
            if (Row < 0 || Row >= this.rows)
                throw new ScriptException("Index out of bounds.");
 
            bool[,] M = this.Values;
            bool[] V = new bool[this.columns];
            int i;
 
            for (i = 0; i < this.columns; i++)
                V[i] = M[Row, i];
 
            return new BooleanVector(V);
        }
 
        public IVector GetColumn(int Column)
        {
            if (Column < 0 || Column >= this.columns)
                throw new ScriptException("Index out of bounds.");
 
            bool[,] M = this.Values;
            bool[] V = new bool[this.rows];
            int i;
 
            for (i = 0; i < this.rows; i++)
                V[i] = M[i, Column];
 
            return new BooleanVector(V);
        }
 
        public void SetRow(int Row, IVector Vector)
        {
            if (Row < 0 || Row >= this.rows)
                throw new ScriptException("Index out of bounds.");
 
            if (Vector.Dimension != this.columns)
                throw new ScriptException("Vector dimension does not match number of columns");
 
            if (!(Vector is BooleanVector V))
                throw new ScriptException("Row vectors in a boolean matrix must be boolean vectors.");
 
            bool[] V2 = V.Values;
            bool[,] M = this.Values;
            this.elements = null;
            int i;
 
            for (i = 0; i < this.columns; i++)
                M[Row, i] = V2[i];
        }
 
        public void SetColumn(int Column, IVector Vector)
        {
            if (Column < 0 || Column >= this.columns)
                throw new ScriptException("Index out of bounds.");
 
            if (Vector.Dimension != this.rows)
                throw new ScriptException("Vector dimension does not match number of rows");
 
            if (!(Vector is BooleanVector V))
                throw new ScriptException("Column vectors in a boolean matrix must be boolean vectors.");
 
            bool[] V2 = V.Values;
            bool[,] M = this.Values;
            this.elements = null;
            int i;
 
            for (i = 0; i < this.rows; i++)
                M[i, Column] = V2[i];
        }
 
    }
}