ObjectVector.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 ObjectVector : VectorSpaceElement
    {
        private IElement[] values = null;
        private ICollection<IElement> elements;
        private readonly int dimension;
 
        public ObjectVector(ICollection<IElement> Elements)
        {
            this.elements = Elements;
            this.dimension = Elements.Count;
        }
 
        public ObjectVector(ICollection<object> Elements)
        {
            ChunkedList<IElement> Elements2 = new ChunkedList<IElement>();
 
            foreach (object Obj in Elements)
                Elements2.Add(Expression.Encapsulate(Obj));
 
            this.elements = Elements2;
            this.dimension = Elements2.Count;
        }
 
        public ObjectVector(Array Elements)
        {
            ChunkedList<IElement> Elements2 = new ChunkedList<IElement>();
 
            foreach (object Obj in Elements)
                Elements2.Add(Expression.Encapsulate(Obj));
 
            this.elements = Elements2;
            this.dimension = Elements2.Count;
        }
 
        public ObjectVector(params IElement[] Elements)
            : this((ICollection<IElement>)Elements)
        {
        }
 
        public ObjectVector(params object[] Elements)
            : this((ICollection<object>)Elements)
        {
        }
 
        public IElement[] Values
        {
            get
            {
                if (this.values is null)
                {
                    IElement[] v = new IElement[this.dimension];
                    this.elements.CopyTo(v, 0);
                    this.values = v;
                }
 
                return this.values;
            }
        }
 
        public ICollection<IElement> Elements => this.elements;
 
        public override int Dimension => this.dimension;
 
        public override string ToString()
        {
            StringBuilder sb = null;
 
            foreach (IElement Element in this.elements)
            {
                if (sb is null)
                    sb = new StringBuilder("[");
                else
                    sb.Append(", ");
 
                if (!(Element is null))
                    sb.Append(Element.ToString());
            }
 
            if (sb is null)
                return "[]";
            else
            {
                sb.Append(']');
                return sb.ToString();
            }
        }
 
        public override IVectorSpace AssociatedVectorSpace
        {
            get
            {
                if (this.associatedVectorSpace is null)
                    this.associatedVectorSpace = new ObjectVectors(this);
 
                return this.associatedVectorSpace;
            }
        }
 
        private ObjectVectors associatedVectorSpace = null;
 
        public override object AssociatedObjectValue
        {
            get
            {
                if (!(this.associatedObjectValue is null))
                    return this.associatedObjectValue;
 
                object[] V = new object[this.dimension];
                int i = 0;
 
                foreach (IElement E in this.elements)
                {
                    if (E is null)
                        V[i++] = null;
                    else
                        V[i++] = E.AssociatedObjectValue;
                }
 
                this.associatedObjectValue = V;
                return this.associatedObjectValue;
            }
        }
 
        private object[] associatedObjectValue = null;
 
        public override IVectorSpaceElement MultiplyScalar(IFieldElement Scalar)
        {
            ChunkedList<IElement> Elements = new ChunkedList<IElement>();
 
            foreach (IElement Element in this.elements)
                Elements.Add(Operators.Arithmetics.Multiply.EvaluateMultiplication(Scalar, Element, null));
 
            return new ObjectVector(Elements);
        }
 
        public override IAbelianGroupElement Add(IAbelianGroupElement Element)
        {
            ChunkedList<IElement> Elements = new ChunkedList<IElement>();
 
            if (Element.IsScalar)
                return null;
 
            ICollection<IElement> ChildElements = Element.ChildElements;
            IEnumerator<IElement> e1 = this.elements.GetEnumerator();
            IEnumerator<IElement> e2 = ChildElements.GetEnumerator();
 
            try
            {
                while (e1.MoveNext() && e2.MoveNext())
                    Elements.Add(Operators.Arithmetics.Add.EvaluateAddition(e1.Current, e2.Current, null));
            }
            finally
            {
                e1.Dispose();
                e2.Dispose();
            }
 
            return new ObjectVector(Elements);
        }
 
        public override IGroupElement Negate()
        {
            ChunkedList<IElement> Elements = new ChunkedList<IElement>();
 
            foreach (IElement Element in this.elements)
                Elements.Add(Operators.Arithmetics.Negate.EvaluateNegation(Element));
 
            return new ObjectVector(Elements);
        }
 
        public override bool Equals(object obj)
        {
            ObjectVector ObjectVector = obj as ObjectVector;
            if (ObjectVector is null)
                return false;
 
            if (ObjectVector.dimension != this.dimension)
                return false;
 
            IEnumerator<IElement> e1 = this.elements.GetEnumerator();
            IEnumerator<IElement> e2 = ObjectVector.elements.GetEnumerator();
 
            try
            {
                while (e1.MoveNext() && e2.MoveNext())
                {
                    if (!e1.Current.Equals(e2.Current))
                        return false;
                }
            }
            finally
            {
                e1.Dispose();
                e2.Dispose();
            }
 
            return true;
        }
 
        public override int GetHashCode()
        {
            int Result = 0;
 
            foreach (IElement Element in this.elements)
                Result ^= Element.GetHashCode();
 
            return Result;
        }
 
        public override bool IsScalar
        {
            get { return 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
            {
                return this.AssociatedVectorSpace.Zero;
            }
        }
 
        public override IElement GetElement(int Index)
        {
            if (Index < 0 || Index >= this.dimension)
                throw new ScriptException("Index out of bounds.");
 
            IElement[] V = this.Values;
            return V[Index];
        }
 
        public override void SetElement(int Index, IElement Value)
        {
            if (Index < 0 || Index >= this.dimension)
                throw new ScriptException("Index out of bounds.");
 
            IElement[] Values = this.Values;
            this.elements = null;
 
            Values[Index] = Value;
        }
 
        public override bool TryConvertTo(Type DesiredType, out object Value)
        {
            if (DesiredType == typeof(object[]))
            {
                Value = this.Values;
                return true;
            }
            else if (DesiredType.IsAssignableFrom(typeof(ObjectVector).GetTypeInfo()))
            {
                Value = this;
                return true;
            }
            else if (DesiredType.IsArray)
            {
                Type ElementType = DesiredType.GetElementType();
                Array Result = Array.CreateInstance(ElementType, this.dimension);
                IElement[] Values = this.Values;
                int i;
 
                for (i = 0; i < this.dimension; i++)
                {
                    if (!Values[i].TryConvertTo(ElementType, out Value))
                    {
                        Value = null;
                        return false;
                    }
 
                    Result.SetValue(Value, i);
                }
 
                Value = Result;
                return true;
            }
            else
                return Expression.TryConvert(this.Values, DesiredType, true, out Value);
        }
 
    }
}