using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using UnitTestSharp;
using Azimuth.DenseLinearAlgebra;

namespace Azimuth.UnitTests.DenseLinearAlgebra
{
    class DenseVectorTests : TestFixture
    {
        public class Ctor_Tests : TestFixture
        {
            public void FromArray()
            {
                var array = new Scalar[] { 1, 2, 3, 4, 5 };

                var vector = new DenseVector(array);

                for (int i = 0; i < array.Length; ++i)
                    CheckEqual(array[i], vector[i]);

                CheckEqual(array.Length, vector.Length);
            }

            public void FromArray_DoesntWrap()
            {
                var array = new Scalar[] { 1, 2, 3, 4, 5 };

                var vector = new DenseVector(array);

                array[0] = 10;

                CheckNotEqual(10, vector[0]);
                CheckEqual(array.Length, vector.Length);
            }

            public void FromArray_Copies()
            {
                var array = new Scalar[] { 1, 2, 3, 4, 5 };

                var vector = new DenseVector((Scalar[])array.Clone());

                array[0] = 10;

                CheckEqual(1, vector[0]);
                CheckEqual(array.Length, vector.Length);
            }

            public void Reserve_Size()
            {
                var vector = new DenseVector(10);

                for (int i = 0; i < 10; ++i)
                    CheckEqual(0, vector[i]);

                CheckEqual(10, vector.Length);
            }

            public void Reserve_Size_ThrowsOnOutOfBounds()
            {
                var vector = new DenseVector(10);

                CheckThrow(typeof(System.IndexOutOfRangeException));
                Scalar b = vector[10];
            }

            public void FromIVector()
            {
                IVector vec = new DenseVector(new Scalar[] { 1, 2, 3, 4, 5 });

                var copy = new DenseVector(vec);

                CheckEqual(vec.Length, copy.Length);
                CheckEqual(vec[0], copy[0]);
                CheckEqual(vec[1], copy[1]);
                CheckEqual(vec[2], copy[2]);
                CheckEqual(vec[3], copy[3]);
                CheckEqual(vec[4], copy[4]);
            }

            public void FromIVector_ZeroSize()
            {
                IVector vec = new DenseVector(new Scalar[] { });

                var copy = new DenseVector(vec);

                CheckEqual(vec.Length, copy.Length);
            }
        }

        public class Array_Operator : TestFixture
        {
            public void Basic()
            {
                var array = new Scalar[] { 1, 2, 3, 4, 5 };

                var vector = new DenseVector(array);

                for (int i = 0; i < array.Length; ++i)
                    CheckEqual(array[i], vector[i]);
            }

            public void OutOfBounds_Positive()
            {
                var array = new Scalar[] { 1 };

                var vector = new DenseVector(array);

                CheckThrow(typeof(System.IndexOutOfRangeException));
                var a = vector[1];
            }

            public void OutOfBounds_Negative()
            {
                var array = new Scalar[] { 1 };

                var vector = new DenseVector(array);

                CheckThrow(typeof(System.IndexOutOfRangeException));
                var a = vector[-1];
            }
        }

        public class ToStringTests : TestFixture
        {
            public void Works()
            {
                DenseVector vec = new Scalar[] { 1, 2, 3 };

                CheckEqual("<1 : 2 : 3>", vec.ToString());
            }

            public void Empty()
            {
                DenseVector vec = new Scalar[] { };

                CheckEqual("<{empty}>", vec.ToString());
            }
        }

        public class DotProduct : TestFixture
        {
            public void Basic()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7 };
                DenseVector array2 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7 };

                CheckEqual(140, array1.DotProduct(array2));
                CheckEqual(140, array2.DotProduct(array1));
            }

            public void Empty()
            {
                DenseVector array1 = new Scalar[] { };
                DenseVector array2 = new Scalar[] { };

                CheckEqual(0, array1.DotProduct(array2));
                CheckEqual(0, array2.DotProduct(array1));
            }

            public void DifferentLength()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                array1.DotProduct(array2);

                CheckThrow(typeof(Exception));
                array2.DotProduct(array1);
            }
        }

        public class Magnitude : TestFixture
        {
            public void Works()
            {
                DenseVector vec = new Scalar[] {
                    0,
                    -1,
                    2,
                    -3,
                    4,
                    -5,
                };

                CheckEqual(55, vec.MagnitudeSquared());
                CheckEqual(Math.Sqrt(55), vec.Magnitude());
            }

            public void Zero()
            {
                DenseVector vec = new Scalar[] {
                    0,
                    0,
                    0,
                };

                CheckEqual(0, vec.MagnitudeSquared());
                CheckEqual(0, vec.Magnitude());
            }

            public void ZeroLength()
            {
                DenseVector vec = new Scalar[] { };

                CheckEqual(0, vec.MagnitudeSquared());
                CheckEqual(0, vec.Magnitude());
            }
        }

        public class SubMagnitude : TestFixture
        {
            DenseVector vec = new Scalar[] {
                0,
                -1,
                2,
                -3,
                4,
                -5,
            };

            public void Works()
            {
                CheckEqual(29, vec.MagnitudeSquared(2, 3));
                CheckEqual(Math.Sqrt(29), vec.Magnitude(2, 3));
            }

            public void Zero()
            {
                DenseVector vec = new Scalar[] {
                    0,
                    0,
                    0,
                };

                CheckEqual(0, vec.MagnitudeSquared(1, 2));
                CheckEqual(0, vec.Magnitude(1, 2));
            }

            public void ZeroLength()
            {
                DenseVector vec = new Scalar[] { };

                CheckEqual(0, vec.MagnitudeSquared(0, 0));
                CheckEqual(0, vec.Magnitude(0, 0));
            }

            public void NegativeStart_Squared()
            {
                CheckThrow(typeof(Exception));
                vec.MagnitudeSquared(-1, 2);
            }

            public void NegativeStart()
            {
                CheckThrow(typeof(Exception));
                vec.Magnitude(-1, 2);
            }

            public void StartTooBig_Squared()
            {
                CheckThrow(typeof(Exception));
                vec.MagnitudeSquared(6, 2);
            }

            public void StartTooBig()
            {
                CheckThrow(typeof(Exception));
                vec.Magnitude(6, 2);
            }

            public void NegativeRunLength_Squared()
            {
                CheckThrow(typeof(Exception));
                vec.MagnitudeSquared(0, -1);
            }

            public void NegativeRunLength()
            {
                CheckThrow(typeof(Exception));
                vec.Magnitude(0, -1);
            }

            public void RunLengthTooBig()
            {
                CheckThrow(typeof(Exception));
                vec.Magnitude(0, 7);
            }

            public void RunLengthTooBig_Squared()
            {
                CheckThrow(typeof(Exception));
                vec.MagnitudeSquared(0, 7);
            }
        }

        public class Normalize : TestFixture
        {
            public void Works()
            {
                DenseVector vec = new Scalar[] {
                    0,
                    -3,
                    4,
                };

                DenseVector expected = new Scalar[] {
                    0,
                    -3.0/5.0,
                    4.0/5.0,
                };

                vec.Normalize();

                CheckEqual(expected, vec);
            }

            public void Works_Seeded()
            {
                DenseVector vec = new Scalar[] {
                    0,
                    -3,
                    4,
                };

                DenseVector expected = new Scalar[] {
                    0,
                    -3.0/5.0,
                    4.0/5.0,
                };

                vec.Normalize(5);

                CheckEqual(expected, vec);
            }

            public void ZeroVector()
            {
                DenseVector vec = new Scalar[] {
                    0,
                    0,
                    0,
                };

                CheckThrow(typeof(Exception));
                vec.Normalize();
            }

            public void ZeroLength()
            {
                DenseVector vec = new Scalar[] { };

                CheckThrow(typeof(Exception));
                vec.Normalize();
            }

            public void Seeded0()
            {
                DenseVector vec = new Scalar[] {
                    1,
                    2,
                    3,
                };

                CheckThrow(typeof(Exception));
                vec.Normalize(0);
            }

            public void ZeroLength_Seeded()
            {
                DenseVector vec = new Scalar[] { };

                CheckThrow(typeof(Exception));
                vec.Normalize(0);
            }

            public void SeededNegative()
            {
                DenseVector vec = new Scalar[] {
                    0,
                    4,
                    3,
                };

                CheckThrow(typeof(Exception));
                vec.Normalize(-5);
            }

            public void ZeroLength_SeededNegative()
            {
                DenseVector vec = new Scalar[] { };

                CheckThrow(typeof(Exception));
                vec.Normalize(-5);
            }
        }

        public class ForwardPermute : TestFixture
        {
            public void Identity()
            {
                var permutations = new int[] { 0, 1, 2 };
                DenseVector actual = new DenseVector(new Scalar[] { 0, 1, 2 });
                DenseVector expected = new DenseVector(new Scalar[] { 0, 1, 2 });

                actual = actual.ForwardPermute(permutations);

                CheckEqual(expected, actual);
            }

            public void Reverse()
            {
                var permutations = new int[] { 2, 1, 0 };
                DenseVector actual = new DenseVector(new Scalar[] { 0, 1, 2 });
                DenseVector expected = new DenseVector(new Scalar[] { 2, 1, 0 });

                actual = actual.ForwardPermute(permutations);

                CheckEqual(expected, actual);
            }

            public void Duplicate()
            {
                var permutations = new int[] { 2, 2, 0 };
                DenseVector actual = new DenseVector(new Scalar[] { 0, 1, 2 });

                CheckThrow(typeof(Exception));
                actual = actual.ForwardPermute(permutations);
            }

            public void WrongLength()
            {
                var permutations = new int[] { 0, 1, 2 };
                DenseVector actual = new DenseVector(new Scalar[] { 0, 1 });

                CheckThrow(typeof(Exception));
                actual = actual.ForwardPermute(permutations);
            }

            public void IndexTooHigh()
            {
                var permutations = new int[] { 0, 1, 4 };
                DenseVector actual = new DenseVector(new Scalar[] { 0, 1, 2 });

                CheckThrow(typeof(Exception));
                actual = actual.ForwardPermute(permutations);
            }

            public void NegativeIndex()
            {
                var permutations = new int[] { 0, -1, 2 };
                DenseVector actual = new DenseVector(new Scalar[] { 0, 1, 2 });

                CheckThrow(typeof(Exception));
                actual = actual.ForwardPermute(permutations);
            }

            public void Mix_n_Match()
            {
                var permutations = new int[] { 2, 0, 1 };
                DenseVector actual = new DenseVector(new Scalar[] { 0, 1, 2 });
                DenseVector expected = new DenseVector(new Scalar[] { 2, 0, 1 });

                actual = actual.ForwardPermute(permutations);

                CheckEqual(expected, actual);
            }
        }

        public class BackPermute : TestFixture
        {
            public void Identity()
            {
                var permutations = new int[] { 0, 1, 2 };
                DenseVector actual = new DenseVector(new Scalar[] { 0, 1, 2 });
                DenseVector expected = new DenseVector(new Scalar[] { 0, 1, 2 });

                actual = actual.BackPermute(permutations);

                CheckEqual(expected, actual);
            }

            public void Reverse()
            {
                var permutations = new int[] { 2, 1, 0 };
                DenseVector actual = new DenseVector(new Scalar[] { 0, 1, 2 });
                DenseVector expected = new DenseVector(new Scalar[] { 2, 1, 0 });

                actual = actual.BackPermute(permutations);

                CheckEqual(expected, actual);
            }

            public void Duplicate()
            {
                var permutations = new int[] { 2, 2, 0 };
                DenseVector actual = new DenseVector(new Scalar[] { 0, 1, 2 });

                CheckThrow(typeof(Exception));
                actual = actual.BackPermute(permutations);
            }

            public void WrongLength()
            {
                var permutations = new int[] { 0, 1, 2 };
                DenseVector actual = new DenseVector(new Scalar[] { 0, 1 });

                CheckThrow(typeof(Exception));
                actual = actual.BackPermute(permutations);
            }

            public void IndexTooHigh()
            {
                var permutations = new int[] { 0, 1, 4 };
                DenseVector actual = new DenseVector(new Scalar[] { 0, 1, 2 });

                CheckThrow(typeof(Exception));
                actual = actual.BackPermute(permutations);
            }

            public void NegativeIndex()
            {
                var permutations = new int[] { 0, -1, 2 };
                DenseVector actual = new DenseVector(new Scalar[] { 0, 1, 2 });

                CheckThrow(typeof(Exception));
                actual = actual.BackPermute(permutations);
            }

            public void Mix_n_Match()
            {
                var permutations = new int[] { 2, 0, 1 };
                DenseVector actual = new DenseVector(new Scalar[] { 0, 1, 2 });
                DenseVector expected = new DenseVector(new Scalar[] { 1, 2, 0 });

                actual = actual.BackPermute(permutations);

                CheckEqual(expected, actual);
            }
        }

        public class NegateTests : TestFixture
        {
            public void Basic()
            {
                DenseVector x = new DenseVector(new Scalar[] { 1, 2, -3, 4, 0, });
                DenseVector expected = new DenseVector(new Scalar[] { -1, -2, 3, -4, 0, });

                x.Negate();
                CheckEqual(expected, x);
            }
        }

        public class Scale : TestFixture
        {
            public void Basic()
            {
                DenseVector x = new DenseVector(new Scalar[] { 1, 2, -3, 4, 0, });
                DenseVector expected = new DenseVector(new Scalar[] { -2, -4, 6, -8, 0, });

                x.AssignmentScale(-2.0);
                CheckEqual(expected, x);
            }
        }

        public class AssignSubtract : TestFixture
        {
            public void Basic()
            {
                DenseVector s1 = new DenseVector(new Scalar[] { 1, 2, -3, 4, 0, });
                DenseVector s2 = new DenseVector(new Scalar[] { 1, 1, 1, 1, -1, });
                DenseVector expected = new DenseVector(new Scalar[] { 0, 1, -4, 3, 1, } );

                s1.AssignSubtract(s2);
                CheckEqual(expected, s1);
            }

            public void BadDims()
            {
                DenseVector s1 = new DenseVector(new Scalar[] { 1, 2, -3, 4, 0, });
                DenseVector s2 = new DenseVector(new Scalar[] { 1, 1, 1, });

                CheckThrow(typeof(Exception));
                s1.AssignSubtract(s2);                
            }
        }

        public class AssignAdd : TestFixture
        {
            public void Basic()
            {
                DenseVector s1 = new DenseVector(new Scalar[] { 1, 2, -3, 4, 0, });
                DenseVector s2 = new DenseVector(new Scalar[] { 1, 1, 1, 1, -1, });
                DenseVector expected = new DenseVector(new Scalar[] { 2, 3, -2, 5, -1, });

                s1.AssignAdd(s2);
                CheckEqual(expected, s1);
            }

            public void BadDims()
            {
                DenseVector s1 = new DenseVector(new Scalar[] { 1, 2, -3, 4, 0, });
                DenseVector s2 = new DenseVector(new Scalar[] { 1, 1, 1, });

                CheckThrow(typeof(Exception));
                s1.AssignAdd(s2);
            }
        }

        public class PartialDotProduct : TestFixture
        {
            public void Basic()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7 };
                DenseVector array2 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7 };

                CheckEqual(140, array1.DotProduct(array2, 0, 0, array1.Length));
                CheckEqual(140, array2.DotProduct(array1, 0, 0, array1.Length));
            }

            public void Empty()
            {
                DenseVector array1 = new Scalar[] { };
                DenseVector array2 = new Scalar[] { };

                CheckEqual(0, array1.DotProduct(array2, 0, 0, array1.Length));
                CheckEqual(0, array2.DotProduct(array1, 0, 0, array1.Length));
            }

            public void DifferentLength()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };

                CheckEqual(18, array1.DotProduct(array2, 1, 0, 2));
                CheckEqual(18, array2.DotProduct(array1, 0, 1, 2));
            }

            public void NegativeRunLength()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                CheckEqual(18, array1.DotProduct(array2, 1, 0, -1));
            }

            public void LargeRunLength()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                CheckEqual(18, array1.DotProduct(array2, 1, 0, 100));
            }

            public void NegativeStart_This()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                CheckEqual(18, array1.DotProduct(array2, -1, 0, 1));
            }

            public void NegativeStart_Other()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                CheckEqual(18, array1.DotProduct(array2, 0, -1, 1));
            }

            public void LargeStart_This()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                CheckEqual(18, array1.DotProduct(array2, 100, 0, 1));
            }

            public void LargeStart_Other()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                CheckEqual(18, array1.DotProduct(array2, 0, 100, 1));
            }
        }

        public class AssignmentMAD : TestFixture
        {
            public void Basic()
            {
                DenseVector array1 = new Scalar[] { 1, 2, };
                DenseVector array2 = new Scalar[] { 3, 4 };

                DenseVector expected = new Scalar[] { 5, 8, };

                var actual2 = array2.Clone();

                actual2.AssignmentMADD(array1, 2.0);

                CheckEqual(expected, actual2);
            }

            public void DifferentLength_1()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 7, };
                DenseVector array2 = new Scalar[] { 3, 4 };

                DenseVector expected = new Scalar[] { 5, 8, };

                var actual2 = array2.Clone();

                CheckThrow(typeof(Exception));
                actual2.AssignmentMADD(array1, 2.0);
            }

            public void DifferentLength_2()
            {
                DenseVector array1 = new Scalar[] { 1, 2, };
                DenseVector array2 = new Scalar[] { 3, 4, 7, };

                DenseVector expected = new Scalar[] { 5, 8, };

                var actual2 = array2.Clone();

                CheckThrow(typeof(Exception));
                actual2.AssignmentMADD(array1, 2.0);
            }

            public void ZeroLength()
            {
                DenseVector array1 = new Scalar[] { };
                DenseVector array2 = new Scalar[] { };

                DenseVector expected = new Scalar[] { };

                {
                    var actual2 = array2.Clone();

                    actual2.AssignmentMADD(array1, 2.0);

                    CheckEqual(expected, actual2);
                }

                {
                    var actual2 = array1.Clone();

                    actual2.AssignmentMADD(array2, 2.0);

                    CheckEqual(expected, actual2);
                }
            }
        }

        public class PartialMAD : TestFixture
        {
            public void DifferentLength()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };

                DenseVector expected = new Scalar[] { 1, 8, 11 };

                var actual1 = array1.Clone();

                actual1.AssignmentMADD(array2, 2, 1, 0, 2);

                CheckEqual(expected, actual1);
            }

            public void ZeroRunLength()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };

                DenseVector expected = new Scalar[] { 1, 8, 11 };

                var actual1 = array1.Clone();

                actual1.AssignmentMADD(array2, 2, 1, 0, 0);

                CheckEqual(array1, actual1);
            }

            public void NegativeRunLength()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                array1.AssignmentMADD(array2, 1.0, 0, 0, -1);
            }

            public void LargeRunLength()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                array1.AssignmentMADD(array2, 1.0, 0, 0, 3);
            }

            public void NegativeStart_This()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                array1.AssignmentMADD(array2, 1.0, -1, 0, 1);
            }

            public void NegativeStart_Other()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                array1.AssignmentMADD(array2, 1.0, 0, -1, 1);
            }

            public void LargeStart_This()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                array1.AssignmentMADD(array2, 1.0, 3, 0, 1);
            }

            public void LargeStart_Other()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                array1.AssignmentMADD(array2, 1.0, 0, 2, 1);
            }
        }

        public class PartialTripleDotProduct : TestFixture
        {
            public void DifferentLength()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };
                DenseVector array3 = new Scalar[] { 3, 4 };

                Scalar actual = DenseVector.TripleDotProduct(
                    array1, array2, array3, 1, 0, 0, 2);
                
                CheckEqual(66, actual);
            }

            public void ZeroRunLength()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };
                DenseVector array3 = new Scalar[] { 3, 4 };

                Scalar actual = DenseVector.TripleDotProduct(
                    array1, array2, array3, 1, 0, 0, 0);

                CheckEqual(0, actual);
            }

            public void NegativeRunLength()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };
                DenseVector array3 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                Scalar actual = DenseVector.TripleDotProduct(
                    array1, array2, array3, 1, 0, 0, -1);
            }

            public void LargeRunLength()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };
                DenseVector array3 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                Scalar actual = DenseVector.TripleDotProduct(
                    array1, array2, array3, 1, 0, 0, 3);
            }

            public void NegativeStart_A()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };
                DenseVector array3 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                Scalar actual = DenseVector.TripleDotProduct(
                    array1, array2, array3, -1, 0, 0, 1);
            }

            public void NegativeStart_B()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };
                DenseVector array3 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                Scalar actual = DenseVector.TripleDotProduct(
                    array1, array2, array3, 0, -1, 0, 1);
            }

            public void NegativeStart_C()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };
                DenseVector array3 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                Scalar actual = DenseVector.TripleDotProduct(
                    array1, array2, array3, 0, 0, -1, 1);
            }

            public void LargeStart_A()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };
                DenseVector array3 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                Scalar actual = DenseVector.TripleDotProduct(
                    array1, array2, array3, 3, 0, 0, 1);
            }

            public void LargeStart_B()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };
                DenseVector array3 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                Scalar actual = DenseVector.TripleDotProduct(
                    array1, array2, array3, 0, 3, 0, 1);
            }

            public void LargeStart_C()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };
                DenseVector array3 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                Scalar actual = DenseVector.TripleDotProduct(
                    array1, array2, array3, 0, 0, 3, 1);
            }
        }

        public class TripleDotProduct : TestFixture
        {
            public void Basic()
            {
                DenseVector A = new Scalar[] { 1, 2, 3, 4, 5, 6, 7 };
                DenseVector B = new Scalar[] { 1, 2, 3, 4, 5, 6, 7 };
                DenseVector C = new Scalar[] { -1, -1, -1, -1, -1, -1, -1 };

                CheckEqual(-140, DenseVector.TripleDotProduct(A, B, C));
                CheckEqual(-140, DenseVector.TripleDotProduct(A, C, B));

                CheckEqual(-140, DenseVector.TripleDotProduct(B, A, C));
                CheckEqual(-140, DenseVector.TripleDotProduct(B, C, A));
                
                CheckEqual(-140, DenseVector.TripleDotProduct(C, A, B));
                CheckEqual(-140, DenseVector.TripleDotProduct(C, B, A));
            }

            public void Empty()
            {
                DenseVector A = new Scalar[] { };
                DenseVector B = new Scalar[] { };
                DenseVector C = new Scalar[] { };

                CheckEqual(0, DenseVector.TripleDotProduct(A, B, C));
                CheckEqual(0, DenseVector.TripleDotProduct(A, C, B));

                CheckEqual(0, DenseVector.TripleDotProduct(B, A, C));
                CheckEqual(0, DenseVector.TripleDotProduct(B, C, A));

                CheckEqual(0, DenseVector.TripleDotProduct(C, A, B));
                CheckEqual(0, DenseVector.TripleDotProduct(C, B, A));
            }

            DenseVector A = new Scalar[] { 1, 2, 3 };
            DenseVector B = new Scalar[] { 3, 4 };
            DenseVector C = new Scalar[] { 3, 4 };

            public void DifferentLength_1()
            {
                CheckThrow(typeof(Exception));
                DenseVector.TripleDotProduct(A, B, C);
            }

            public void DifferentLength_2()
            {
                CheckThrow(typeof(Exception));
                DenseVector.TripleDotProduct(A, C, B);
            }

            public void DifferentLength_3()
            {
                CheckThrow(typeof(Exception));
                DenseVector.TripleDotProduct(B, A, C);
            }

            public void DifferentLength_4()
            {
                CheckThrow(typeof(Exception));
                DenseVector.TripleDotProduct(B, C, A);
            }

            public void DifferentLength_5()
            {
                CheckThrow(typeof(Exception));
                DenseVector.TripleDotProduct(C, A, B);
            }

            public void DifferentLength_6()
            {
                CheckThrow(typeof(Exception));
                DenseVector.TripleDotProduct(C, B, A);
            }
        }

        public class Assignment : TestFixture
        {
            public void Basic()
            {
                DenseVector array1 = new Scalar[] { 1, 2, };
                DenseVector array2 = new Scalar[] { 3, 4 };

                DenseVector expected = new Scalar[] { 3, 4, };

                array1.Assignment(array2);

                CheckEqual(expected, array1);
            }

            public void DifferentLength_1()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 7, };
                DenseVector array2 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                array2.Assignment(array1);
            }

            public void DifferentLength_2()
            {
                DenseVector array1 = new Scalar[] { 1, 2, };
                DenseVector array2 = new Scalar[] { 3, 4, 7, };

                CheckThrow(typeof(Exception));
                array2.Assignment(array1);
            }

            public void ZeroLength()
            {
                DenseVector array1 = new Scalar[] { };
                DenseVector array2 = new Scalar[] { };

                DenseVector expected = new Scalar[] { };

                {
                    var actual2 = array2.Clone();

                    actual2.Assignment(array1);

                    CheckEqual(expected, actual2);
                }

                {
                    var actual2 = array1.Clone();

                    actual2.Assignment(array2);

                    CheckEqual(expected, actual2);
                }
            }
        }

        public class PartialAssignment : TestFixture
        {
            public void DifferentLength()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };

                DenseVector expected = new Scalar[] { 1, 3, 4, };

                array1.Assignment(array2, 1, 0, 2);

                CheckEqual(expected, array1);
            }

            public void ZeroRunLength()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };

                DenseVector expected = new Scalar[] { 1, 2, 3 };

                array1.Assignment(array2, 1, 0, 0);

                CheckEqual(expected, array1);
            }

            public void NegativeRunLength()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                array1.Assignment(array2, 0, 0, -1);
            }

            public void LargeRunLength()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                array1.Assignment(array2, 0, 0, 3);
            }

            public void NegativeStart_This()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                array1.Assignment(array2, -1, 0, 1);
            }

            public void NegativeStart_Other()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                array1.Assignment(array2, 0, -1, 1);
            }

            public void LargeStart_This()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                array1.Assignment(array2, 3, 0, 1);
            }

            public void LargeStart_Other()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                array1.Assignment(array2, 0, 2, 1);
            }
        }

        public class AssignmentMultiply : TestFixture
        {
            public void Basic()
            {
                DenseVector array1 = new Scalar[] { 1, 2, };
                DenseVector array2 = new Scalar[] { 3, 4 };

                DenseVector expected = new Scalar[] { 3, 8, };

                array1.AssignmentMultiply(array2);

                CheckEqual(expected, array1);
            }

            public void DifferentLength_1()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 7, };
                DenseVector array2 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                array2.AssignmentMultiply(array1);
            }

            public void DifferentLength_2()
            {
                DenseVector array1 = new Scalar[] { 1, 2, };
                DenseVector array2 = new Scalar[] { 3, 4, 7, };

                CheckThrow(typeof(Exception));
                array2.AssignmentMultiply(array1);
            }

            public void ZeroLength()
            {
                DenseVector array1 = new Scalar[] { };
                DenseVector array2 = new Scalar[] { };

                DenseVector expected = new Scalar[] { };

                {
                    var actual2 = array2.Clone();

                    actual2.AssignmentMultiply(array1);

                    CheckEqual(expected, actual2);
                }

                {
                    var actual2 = array1.Clone();

                    actual2.AssignmentMultiply(array2);

                    CheckEqual(expected, actual2);
                }
            }
        }

        public class PartialAssignmentMultiply : TestFixture
        {
            public void DifferentLength()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };

                DenseVector expected = new Scalar[] { 1, 6, 12, };

                array1.AssignmentMultiply(array2, 1, 0, 2);

                CheckEqual(expected, array1);
            }

            public void ZeroRunLength()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };

                DenseVector expected = new Scalar[] { 1, 2, 3 };

                array1.AssignmentMultiply(array2, 1, 0, 0);

                CheckEqual(expected, array1);
            }

            public void NegativeRunLength()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                array1.AssignmentMultiply(array2, 0, 0, -1);
            }

            public void LargeRunLength()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                array1.AssignmentMultiply(array2, 0, 0, 3);
            }

            public void NegativeStart_This()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                array1.AssignmentMultiply(array2, -1, 0, 1);
            }

            public void NegativeStart_Other()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                array1.AssignmentMultiply(array2, 0, -1, 1);
            }

            public void LargeStart_This()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                array1.AssignmentMultiply(array2, 3, 0, 1);
            }

            public void LargeStart_Other()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                array1.AssignmentMultiply(array2, 0, 2, 1);
            }
        }
    }
}