internal ArrayExpression(
   VectorType vectorType,
   EnumerableArrayWrapper<ExpressionBase, IMetadataExpression> elements
 ) {
   this.VectorType = vectorType;
   this.Elements = elements;
 }

 public static IEnumerable<int> Indices(this Matrix source, Func<Vector, bool> f, VectorType t)
 {
     int max = t == VectorType.Row ? source.Rows : source.Cols;
     for (int i = 0; i < max; i++)
         if (f(source[i, t]))
             yield return i;
 }

 public static Vector CovarianceDiag(Matrix source, VectorType t = VectorType.Col)
 {
     int length = t == VectorType.Row ? source.Rows : source.Cols;
     Vector vector = new Vector(length);
     for (int i = 0; i < length; i++)
         vector[i] = source[i, t].Variance();
     return vector;
 }

 public static Matrix Correlation(Matrix source, VectorType t = VectorType.Col)
 {
     int length = t == VectorType.Row ? source.Rows : source.Cols;
     Matrix m = new Matrix(length);
     for (int i = 0; i < length; i++)
         for (int j = i; j < length; j++) // symmetric matrix
             m[i, j] = m[j, i] = source[i, t].Correlation(source[j, t]);
     return m;
 }

 public MatrixHelper(string vector, VectorType type, int columns, int rows, bool isLinearMatrix)
 {
     this.type = type;
     vectorString = vector;
     this.columns = columns;
     this.rows = rows;
     matrix = !isLinearMatrix ? SplitVector() : SplitLinerMatrix();
     this.isLinearMatrix = isLinearMatrix;
 }

 public static Vector Mean(this Matrix source, VectorType t)
 {
     int count = t == VectorType.Row ? source.Cols : source.Rows;
     VectorType type = t == VectorType.Row ? VectorType.Column : VectorType.Row;
     Vector v = new Vector(count);
     for (int i = 0; i < count; i++)
         v[i] = source[i, type].Mean();
     return v;
 }

 /// <summary>
 /// Summarizes a given Matrix.
 /// </summary>
 /// <param name="matrix">Matrix to summarize.</param>
 /// <param name="byVector">Indicates which direction to summarize, default is <see cref="VectorType.Row"/> indicating top-down.</param>
 /// <returns></returns>
 public static Summary Summarize(Matrix matrix, VectorType byVector = VectorType.Row)
 {
     return new Summary()
     {
         Average = matrix.Mean(byVector),
         StandardDeviation = matrix.StdDev(byVector),
         Minimum = matrix.Min(byVector),
         Maximum = matrix.Max(byVector),
         Median = matrix.Median(byVector)
     };
 }

 public static Matrix Covariance(Matrix source, VectorType t = VectorType.Col)
 {
     int length = t == VectorType.Row ? source.Rows : source.Cols;
     Matrix m = new Matrix(length);
     //for (int i = 0; i < length; i++)
     Parallel.For(0, length, i =>
         //for (int j = i; j < length; j++) // symmetric matrix
         Parallel.For(i, length, j =>
             m[i, j] = m[j, i] = source[i, t].Covariance(source[j, t])));
     return m;
 }

 //Spezielle Vektoren erzeugen.
 public Vector(int _n, VectorType type)
     : base(_n, 1)
 {
     switch (type)
     {
         case VectorType.ONES:
             for (int i = 0; i < base.NoRows; i++)
             {
                 this[i] = 1.0;
             }
             break;
     }
 }

        /// <summary>
        /// Initializes a new instance of the Vector class that contains elements
        /// copied from the specified array.
        /// </summary>
        /// <param name="type">The vector type</param>
        /// <param name="data">The array whose elements are copied to the vector.</param>
        public Vector(VectorType type, double[] data)
        {
            if (data.Length < 1) throw new System.ArgumentException("data.Length < 1");
            this._Type = type;
            this._Data = new double[data.Length];

            data.CopyTo(this._Data, 0);

            //for (int i = 0; i < data.Length; i++)
            //{
            //    this.MeData[i] = data[i];
            //}
        }

 /// <summary>Covariances.</summary>
 /// <param name="source">Source for the.</param>
 /// <param name="t">(Optional) Row or Column sum.</param>
 /// <returns>A Matrix.</returns>
 public static Matrix Covariance(Matrix source, VectorType t = VectorType.Col)
 {
     int length = t == VectorType.Row ? source.Rows : source.Cols;
     Matrix m = new Matrix(length);
     //for (int i = 0; i < length; i++)
     for (int i = 0; i < length; i++)
     {
         //for (int j = i; j < length; j++) // symmetric matrix
         for (int j = i; j < length; j++)
             m[i, j] = m[j, i] = source[i, t].Covariance(source[j, t]);
     }
     return m;
 }

        /// <summary>Estimates.</summary>
        /// <param name="X">The Matrix to process.</param>
        /// <param name="type">(Optional) the type.</param>
        public void Estimate(Matrix X, VectorType type = VectorType.Row)
        {
            var n = type == VectorType.Row ? X.Rows : X.Cols;
            var s = type == VectorType.Row ? X.Cols : X.Rows;
            this.Mu = X.Sum(type) / n;
            this.Sigma = Matrix.Zeros(s);

            for (var i = 0; i < n; i++)
            {
                var x = X[i, type] - this.Mu;
                this.Sigma += x.Outer(x);
            }

            this.Sigma *= 1d / (n - 1d);
        }

        /// <summary>Estimates.</summary>
        /// <param name="X">The Matrix to process.</param>
        /// <param name="type">(Optional) the type.</param>
        public void Estimate(Matrix X, VectorType type = VectorType.Row)
        {
            int n = type == VectorType.Row ? X.Rows : X.Cols;
            int s = type == VectorType.Row ? X.Cols : X.Rows;
            Mu = X.Sum(type) / n;
            Sigma = Matrix.Zeros(s);
            
            for (int i = 0; i < n; i++)
            {
                var x = X[i, type] - Mu;
                Sigma += x.Outer(x);
            }

            Sigma *= (1d / (n - 1d));
        }

        /// <summary>
        /// Computes the sum of either the rows or columns of a matrix and returns a vector.
        /// </summary>
        /// <param name="m">Input Matrix.</param>
        /// <param name="t">Row or Column sum.</param>
        /// <returns>Vector Sum.</returns>
		public static Vector Sum(Matrix m, VectorType t)
		{
			if (t == VectorType.Row)
			{
				Vector result = new Vector(m.Cols);
				for (int i = 0; i < m.Cols; i++)
					for (int j = 0; j < m.Rows; j++)
						result[i] += m[j, i];
				return result;
			}
			else
			{
				Vector result = new Vector(m.Rows);
				for (int i = 0; i < m.Rows; i++)
					for (int j = 0; j < m.Cols; j++)
						result[i] += m[i, j];
				return result;
			}
		}

        public VectorData(string name, uint offset, uint address, VectorType type, float x, float y, float z, float a, string labels, bool degrees, uint pluginLine)
            : base(name, offset, address, pluginLine)
        {
            // Vector Components
            _x = x;
            _y = y;
            _z = z;
            _a = a;

            // Visibility for last 2 Components
            _zVis = _aVis = false;

            _labels = labels;
            _degrees = degrees;

            // Optional custom label letters for components
            if (_labels.Length < (int)type)
            {
                _xLabel = "x";
                _yLabel = "y";
                _zLabel = "z";
                _aLabel = "a";
            }
            else
            {
                switch (type)
                {
                    case VectorType.Vector4:
                        _aLabel = _labels[3].ToString();
                        goto case VectorType.Vector3;
                    case VectorType.Vector3:
                        _zLabel = _labels[2].ToString();
                        goto case VectorType.Vector2;
                    case VectorType.Vector2:
                        _yLabel = _labels[1].ToString();
                        goto default;
                    default:
                        _xLabel = _labels[0].ToString();
                        break;
                }
            }

            // Make last 2 Components visible if we need either
            switch (type)
            {
                case VectorType.Vector4:
                    _aVis = true;
                    goto case VectorType.Vector3;
                case VectorType.Vector3:
                    _zVis = true;
                    break;
            }

            // Create our Vector type name
            _typeLabel = "vector";
            switch (type)
            {
                case VectorType.Vector4:
                    _typeLabel += "4";
                    break;
                case VectorType.Vector3:
                    _typeLabel += "3";
                    break;
                case VectorType.Vector2:
                    _typeLabel += "2";
                    break;
            }

            if (_degrees)
                _typeLabel += "D";
            else
                _typeLabel += "F";
        }

        /// <summary>
        /// returns col/row vector at index j
        /// </summary>
        /// <param name="i">Col/Row</param>
        /// <param name="t">Row or Column</param>
        /// <returns>Vector</returns>
        public virtual Vector this[int i, VectorType t]
        {
            get
            {
                // switch it up if using a transposed version
                if (_asTransposeRef)
                    t = t == VectorType.Row ? VectorType.Col : VectorType.Row;

                if (t == VectorType.Row)
                {
                    if (i >= Rows)
                        throw new IndexOutOfRangeException();

                    return new Vector(_matrix, i, true);
                }
                else
                {
                    if (i >= Cols)
                        throw new IndexOutOfRangeException();

                    return new Vector(_matrix, i);
                }
            }
            set
            {
                if (_asTransposeRef)
                    throw new InvalidOperationException("Cannot modify matrix in read-only transpose mode!");

                if (t == VectorType.Row)
                {
                    if (i >= Rows)
                        throw new IndexOutOfRangeException();

                    if (value.Length > Cols)
                        throw new InvalidOperationException(string.Format("Vector has lenght larger then {0}", Cols));

                    for (int k = 0; k < Cols; k++)
                        _matrix[i][k] = value[k];
                }
                else
                {
                    if (i >= Cols)
                        throw new IndexOutOfRangeException();

                    if (value.Length > Rows)
                        throw new InvalidOperationException(string.Format("Vector has lenght larger then {0}", Cols));

                    for (int k = 0; k < Rows; k++)
                        _matrix[k][i] = value[k];
                }
            }
        }

 private static void* __CopyValue(VectorType.__Internal native)
 {
     var ret = Marshal.AllocHGlobal(20);
     global::CppSharp.Parser.AST.VectorType.__Internal.cctor_2(ret, new global::System.IntPtr(&native));
     return ret.ToPointer();
 }

 private VectorType(VectorType.__Internal native, bool skipVTables = false)
     : this(__CopyValue(native), skipVTables)
 {
     __ownsNativeInstance = true;
     NativeToManagedMap[__Instance] = this;
 }

 public static VectorType __CreateInstance(VectorType.__Internal native, bool skipVTables = false)
 {
     return new VectorType(native, skipVTables);
 }

        public void Matrix_Insert_Test(int index, bool insertAfter, VectorType vectorType, bool isTransposed)
        {
            Vector v = (vectorType == VectorType.Row) ^ isTransposed ?
                            new double[] { 1, 3, 2, 0 } :
                            new double[] { 2, 1, 0 };

            Matrix A = new[,]
            {
                { 4, 1, 3, 2 },
                { 1, 2, 3, 4 },
                { 7, 9, 8, 6 }
            };

            if (isTransposed)
                A = A.T;

            var rows = A.Rows;
            var columns = A.Cols;

            var B = A.Insert(v, index, vectorType, insertAfter);

            Assert.Equal(A.Rows, rows);
            Assert.Equal(A.Cols, columns);

            if (vectorType == VectorType.Row)
            {
                Assert.Equal(B.Rows, rows + 1);
                Assert.Equal(B.Cols, columns);
            }
            else
            {
                Assert.Equal(B.Rows, rows);
                Assert.Equal(B.Cols, columns + 1);
            }

            var dimension = vectorType == VectorType.Row ? rows : columns;

            for (var i = 0; i < dimension + 1; i++)
            {
                if (index == dimension - 1 && insertAfter)
                    Assert.Equal(v, B[dimension, vectorType]);
                else if (i == index)
                    Assert.Equal(v, B[i, vectorType]);
                else if(i < index)
                    Assert.Equal(A[i, vectorType], B[i, vectorType]);
                else
                    Assert.Equal(A[i - 1, vectorType], B[i, vectorType]);
            }
        }