DoubleVector.cs

using System;
using System.Collections.Generic;
using System.Reflection;
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 DoubleVector : VectorSpaceElement
    {
        private double[] values;
        private ICollection<IElement> elements;
        private readonly int dimension;
 
        public DoubleVector(params double[] Values)
        {
            this.values = Values;
            this.elements = null;
            this.dimension = Values.Length;
        }
 
        public DoubleVector(ICollection<IElement> Elements)
        {
            this.values = null;
            this.elements = Elements;
            this.dimension = Elements.Count;
        }
 
        public double[] Values
        {
            get
            {
                if (this.values is null)
                {
                    double[] v = new double[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 double d))
                                    d = 0;
 
                                v[i++] = d;
                            }
 
                            Loop = Loop.Next;
                        }
                    }
                    else
                    {
                        foreach (IElement Element in this.elements)
                        {
                            if (!(Element.AssociatedObjectValue is double d))
                                d = 0;
 
                            v[i++] = d;
                        }
                    }
 
                    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 DoubleNumber(this.values[i]);
 
                    this.elements = v;
                }
 
                return this.elements;
            }
        }
 
        public override int Dimension => this.dimension;
 
        public override string ToString()
        {
            return Expression.ToString(this.Values);
        }
 
        public override IVectorSpace AssociatedVectorSpace
        {
            get
            {
                if (this.associatedVectorSpace is null)
                    this.associatedVectorSpace = new DoubleVectors(this.dimension);
 
                return this.associatedVectorSpace;
            }
        }
 
        private DoubleVectors associatedVectorSpace = null;
 
        public override object AssociatedObjectValue => this.Values;
 
        public override IVectorSpaceElement MultiplyScalar(IFieldElement Scalar)
        {
            if (!(Scalar.AssociatedObjectValue is double d))
                return null;
 
            int i;
            double[] Values = this.Values;
            double[] v = new double[this.dimension];
 
            for (i = 0; i < this.dimension; i++)
                v[i] = d * Values[i];
 
            return new DoubleVector(v);
        }
 
        public override IAbelianGroupElement Add(IAbelianGroupElement Element)
        {
            if (!(Element is DoubleVector DoubleVector))
                return null;
 
            int i;
            if (DoubleVector.dimension != this.dimension)
                return null;
 
            double[] Values = this.Values;
            double[] Values2 = DoubleVector.Values;
            double[] v = new double[this.dimension];
            for (i = 0; i < this.dimension; i++)
                v[i] = Values[i] + Values2[i];
 
            return new DoubleVector(v);
        }
 
        public override IGroupElement Negate()
        {
            int i;
            double[] v = new double[this.dimension];
            double[] Values = this.Values;
            for (i = 0; i < this.dimension; i++)
                v[i] = -Values[i];
 
            return new DoubleVector(v);
        }
 
        public override bool Equals(object obj)
        {
            if (!(obj is DoubleVector DoubleVector))
                return false;
 
            int i;
            if (DoubleVector.dimension != this.dimension)
                return false;
 
            double[] Values = this.Values;
            double[] Values2 = DoubleVector.Values;
            for (i = 0; i < this.dimension; i++)
            {
                if (Values[i] != Values2[i])
                    return false;
            }
 
            return true;
        }
 
        public override int GetHashCode()
        {
            double[] 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
        {
            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
            {
                if (this.zero is null)
                    this.zero = new DoubleVector(new double[this.dimension]);
 
                return this.zero;
            }
        }
 
        private DoubleVector zero = null;
 
        public override IElement GetElement(int Index)
        {
            if (Index < 0 || Index >= this.dimension)
                throw new ScriptException("Index out of bounds.");
 
            double[] V = this.Values;
 
            return new DoubleNumber(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 double d))
                throw new ScriptException("Elements in a double vector are required to be double values.");
 
            double[] Values = this.Values;
            this.elements = null;
 
            Values[Index] = d;
        }
 
        public override bool TryConvertTo(Type DesiredType, out object Value)
        {
            if (DesiredType == typeof(double[]))
            {
                Value = this.Values;
                return true;
            }
            else if (DesiredType.IsAssignableFrom(typeof(DoubleVector).GetTypeInfo()))
            {
                Value = this;
                return true;
            }
            else if (DesiredType.IsArray)
            {
                Type ElementType = DesiredType.GetElementType();
                int i = 0;
 
                if (ElementType == typeof(byte))
                {
                    byte[] ba = new byte[this.dimension];
                    foreach (double d in this.Values)
                    {
                        if (d >= byte.MinValue && d <= byte.MaxValue)
                            ba[i++] = (byte)d;
                        else
                        {
                            Value = null;
                            return false;
                        }
                    }
 
                    Value = ba;
                    return true;
                }
                else if (ElementType == typeof(decimal))
                {
                    decimal[] da = new decimal[this.dimension];
                    foreach (double d in this.Values)
                        da[i++] = (decimal)d;
 
                    Value = da;
                    return true;
                }
                else if (ElementType == typeof(short))
                {
                    short[] sa = new short[this.dimension];
                    foreach (double d in this.Values)
                    {
                        if (d >= short.MinValue && d <= short.MaxValue)
                            sa[i++] = (short)d;
                        else
                        {
                            Value = null;
                            return false;
                        }
                    }
 
                    Value = sa;
                    return true;
                }
                else if (ElementType == typeof(int))
                {
                    int[] ia = new int[this.dimension];
                    foreach (double d in this.Values)
                    {
                        if (d >= int.MinValue && d <= int.MaxValue)
                            ia[i++] = (byte)d;
                        else
                        {
                            Value = null;
                            return false;
                        }
                    }
 
                    Value = ia;
                    return true;
                }
                else if (ElementType == typeof(long))
                {
                    long[] la = new long[this.dimension];
                    foreach (double d in this.Values)
                    {
                        if (d >= long.MinValue && d <= long.MaxValue)
                            la[i++] = (long)d;
                        else
                        {
                            Value = null;
                            return false;
                        }
                    }
 
                    Value = la;
                    return true;
                }
                else if (ElementType == typeof(sbyte))
                {
                    sbyte[] sba = new sbyte[this.dimension];
                    foreach (double d in this.Values)
                    {
                        if (d >= sbyte.MinValue && d <= sbyte.MaxValue)
                            sba[i++] = (sbyte)d;
                        else
                        {
                            Value = null;
                            return false;
                        }
                    }
 
                    Value = sba;
                    return true;
                }
                else if (ElementType == typeof(float))
                {
                    float[] fa = new float[this.dimension];
                    foreach (double d in this.Values)
                        fa[i++] = (float)d;
 
                    Value = fa;
                    return true;
                }
                else if (ElementType == typeof(ushort))
                {
                    ushort[] usa = new ushort[this.dimension];
                    foreach (double d in this.Values)
                    {
                        if (d >= ushort.MinValue && d <= ushort.MaxValue)
                            usa[i++] = (ushort)d;
                        else
                        {
                            Value = null;
                            return false;
                        }
                    }
 
                    Value = usa;
                    return true;
                }
                else if (ElementType == typeof(uint))
                {
                    uint[] uia = new uint[this.dimension];
                    foreach (double d in this.Values)
                    {
                        if (d >= uint.MinValue && d <= uint.MaxValue)
                            uia[i++] = (uint)d;
                        else
                        {
                            Value = null;
                            return false;
                        }
                    }
 
                    Value = uia;
                    return true;
                }
                else if (ElementType == typeof(ulong))
                {
                    ulong[] ula = new ulong[this.dimension];
                    foreach (double d in this.Values)
                    {
                        if (d >= ulong.MinValue && d <= ulong.MaxValue)
                            ula[i++] = (ulong)d;
                        else
                        {
                            Value = null;
                            return false;
                        }
                    }
 
                    Value = ula;
                    return true;
                }
                else
                {
                    Value = this;
                    return true;
                }
            }
            else
                return Expression.TryConvert(this.Values, DesiredType, true, out Value);
        }
 
    }
}