BooleanVector.cs

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Text;
using Waher.Runtime.Collections;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Abstraction.Sets;
using Waher.Script.Exceptions;
using Waher.Script.Model;
using Waher.Script.Operators.Vectors;
 
namespace Waher.Script.Objects.VectorSpaces
{
    public sealed class BooleanVector : VectorSpaceElement
    {
        private bool[] values;
        private ICollection<IElement> elements;
        private readonly int dimension;
 
        public BooleanVector(params bool[] Values)
        {
            this.values = Values;
            this.elements = null;
            this.dimension = Values.Length;
        }
 
        public BooleanVector(ICollection<IElement> Elements)
        {
            this.values = null;
            this.elements = Elements;
            this.dimension = Elements.Count;
        }
 
        public bool[] Values
        {
            get
            {
                if (this.values is null)
                {
                    bool[] v = new bool[this.dimension];
                    int i = 0;
                    
                    if (this.elements is ChunkedList<IElement> Values)
                    {
                        ChunkNode<IElement> Loop = Values.FirstChunk;
                        int j, c;
 
                        while (!(Loop is null))
                        {
                            for (j = Loop.Start, c = Loop.Pos; j < c; j++)
                            {
                                if (!(Loop[j].AssociatedObjectValue is bool b))
                                    b = false;
 
                                v[i++] = b;
                            }
 
                            Loop = Loop.Next;
                        }
                    }
                    else
                    {
                        foreach (IElement Element in this.elements)
                        {
                            if (!(Element.AssociatedObjectValue is bool b))
                                b = false;
 
                            v[i++] = b;
                        }
                    }
                
                    this.values = v;
                }
 
                return this.values;
            }
        }
 
        public ICollection<IElement> Elements
        {
            get
            {
                if (this.elements is null)
                {
                    int i;
                    IElement[] v = new IElement[this.dimension];
 
                    for (i = 0; i < this.dimension; i++)
                        v[i] = new BooleanValue(this.values[i]);
 
                    this.elements = v;
                }
 
                return this.elements;
            }
        }
 
        public override int Dimension => this.dimension;
 
        public override string ToString()
        {
            StringBuilder sb = null;
 
            foreach (bool d in this.Values)
            {
                if (sb is null)
                    sb = new StringBuilder("[");
                else
                    sb.Append(", ");
 
                sb.Append(Expression.ToString(d));
            }
 
            if (sb is null)
                return "[]";
            else
            {
                sb.Append(']');
                return sb.ToString();
            }
        }
 
        public override IVectorSpace AssociatedVectorSpace
        {
            get
            {
                if (this.associatedVectorSpace is null)
                    this.associatedVectorSpace = new BooleanVectors(this.dimension);
 
                return this.associatedVectorSpace;
            }
        }
 
        private BooleanVectors associatedVectorSpace = null;
 
        public override object AssociatedObjectValue => this.Values;
 
        public override IVectorSpaceElement MultiplyScalar(IFieldElement Scalar)
        {
            BooleanValue BooleanValue = Scalar as BooleanValue;
            if (BooleanValue is null)
                return null;
 
            bool d = BooleanValue.Value;
            int i;
            bool[] Values = this.Values;
            bool[] v = new bool[this.dimension];
 
            for (i = 0; i < this.dimension; i++)
                v[i] = d && Values[i];
 
            return new BooleanVector(v);
        }
 
        public override IAbelianGroupElement Add(IAbelianGroupElement Element)
        {
            BooleanVector BooleanVector = Element as BooleanVector;
            if (BooleanVector is null)
                return null;
 
            int i;
            if (BooleanVector.dimension != this.dimension)
                return null;
 
            bool[] Values = this.Values;
            bool[] Values2 = BooleanVector.Values;
            bool[] v = new bool[this.dimension];
            for (i = 0; i < this.dimension; i++)
                v[i] = Values[i] ^ Values2[i];
 
            return new BooleanVector(v);
        }
 
        public override IGroupElement Negate()
        {
            return this;
        }
 
        public override bool Equals(object obj)
        {
            BooleanVector BooleanVector = obj as BooleanVector;
            if (BooleanVector is null)
                return false;
 
            int i;
            if (BooleanVector.dimension != this.dimension)
                return false;
 
            bool[] Values = this.Values;
            bool[] Values2 = BooleanVector.Values;
            for (i = 0; i < this.dimension; i++)
            {
                if (Values[i] != Values2[i])
                    return false;
            }
 
            return true;
        }
 
        public override int GetHashCode()
        {
            bool[] Values = this.Values;
            int Result = 0;
            int i;
 
            for (i = 0; i < this.dimension; i++)
                Result ^= Values[i].GetHashCode();
 
            return Result;
        }
 
        public override bool IsScalar => false;
 
        public override ICollection<IElement> ChildElements => this.Elements;
 
        public override IElement Encapsulate(ChunkedList<IElement> Elements, ScriptNode Node)
        {
            return VectorDefinition.Encapsulate(Elements, true, Node);
        }
 
        public override IElement Encapsulate(ICollection<IElement> Elements, ScriptNode Node)
        {
            return VectorDefinition.Encapsulate(Elements, true, Node);
        }
 
        public override IAbelianGroupElement Zero
        {
            get
            {
                if (this.zero is null)
                    this.zero = new BooleanVector(new bool[this.dimension]);
 
                return this.zero;
            }
        }
 
        private BooleanVector zero = null;
 
        public override IElement GetElement(int Index)
        {
            if (Index < 0 || Index >= this.dimension)
                throw new ScriptException("Index out of bounds.");
 
            bool[] V = this.Values;
 
            return new BooleanValue(V[Index]);
        }
 
        public override void SetElement(int Index, IElement Value)
        {
            if (Index < 0 || Index >= this.dimension)
                throw new ScriptException("Index out of bounds.");
 
            if (!(Value.AssociatedObjectValue is bool V))
                throw new ScriptException("Elements in a boolean vector are required to be boolean values.");
 
            bool[] Values = this.Values;
            this.elements = null;
 
            Values[Index] = V;
        }
 
        public override bool TryConvertTo(Type DesiredType, out object Value)
        {
            if (DesiredType == typeof(bool[]))
            {
                Value = this.Values;
                return true;
            }
            else if (DesiredType.IsAssignableFrom(typeof(BooleanVector).GetTypeInfo()))
            {
                Value = this;
                return true;
            }
            else
                return Expression.TryConvert(this.Values, DesiredType, true, out Value);
        }
 
    }
}