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 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 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.Scale(-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.Subtract(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.Subtract(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.Add(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.Add(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.MADD(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.MADD(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.MADD(array1, 2.0);
            }

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

                DenseVector expected = new Scalar[] { };

                {
                    var actual2 = array2.Clone();

                    actual2.MADD(array1, 2.0);

                    CheckEqual(expected, actual2);
                }

                {
                    var actual2 = array1.Clone();

                    actual2.MADD(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.MADD(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.MADD(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.MADD(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.MADD(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.MADD(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.MADD(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.MADD(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.MADD(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.Multiply(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.Multiply(array1);
            }

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

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

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

                DenseVector expected = new Scalar[] { };

                {
                    var actual2 = array2.Clone();

                    actual2.Multiply(array1);

                    CheckEqual(expected, actual2);
                }

                {
                    var actual2 = array1.Clone();

                    actual2.Multiply(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.Multiply(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.Multiply(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.Multiply(array2, 0, 0, -1);
            }

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

                CheckThrow(typeof(Exception));
                array1.Multiply(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.Multiply(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.Multiply(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.Multiply(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.Multiply(array2, 0, 2, 1);
            }
        }

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

                DenseVector expected = new Scalar[] { 1.0/3, 2.0/4.0, };

                array1.Divide(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.Divide(array1);
            }

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

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

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

                DenseVector expected = new Scalar[] { };

                {
                    var actual2 = array2.Clone();

                    actual2.Divide(array1);

                    CheckEqual(expected, actual2);
                }

                {
                    var actual2 = array1.Clone();

                    actual2.Divide(array2);

                    CheckEqual(expected, actual2);
                }
            }
        }

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

                DenseVector expected = new Scalar[] { 1, 2.0/3.0, 3.0/4.0, };

                array1.Divide(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.Divide(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.Divide(array2, 0, 0, -1);
            }

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

                CheckThrow(typeof(Exception));
                array1.Divide(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.Divide(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.Divide(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.Divide(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.Divide(array2, 0, 2, 1);
            }
        }

        public class SumTests : TestFixture
        {
            public void Basic()
            {
                var values = new DenseVector(new Scalar[]
                    { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, }
                );

                CheckEqual(55, values.Sum());
            }
        }

        public class PartialSumTests : TestFixture
        {
            public void Basic()
            {
                var values = new DenseVector(new Scalar[] 
                    { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, }
                );

                CheckEqual(49, values.Sum(3, 7));
            }

            public void NegativeRunLength()
            {
                var values = new DenseVector(new Scalar[] 
                    { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, }
                );

                CheckThrow(typeof(Exception));
                values.Sum(3, -1);
            }

            public void NegativeStartingOffset()
            {
                var values = new DenseVector(new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, }
                );

                CheckThrow(typeof(Exception));
                values.Sum(-1, 4);
            }

            public void LargeRunLength()
            {
                var values = new DenseVector(new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, }
                );

                CheckThrow(typeof(Exception));
                values.Sum(0, 11);
            }

            public void LargeStartingOffset()
            {
                var values = new DenseVector(new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, }
                );

                CheckThrow(typeof(Exception));
                values.Sum(10, 1);
            }

            public void ZeroRunLength()
            {
                var values = new DenseVector(new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, }
                );

                CheckEqual(0, values.Sum(0, 0));
            }
        }

        public class FlushTests : TestFixture
        {
            public void Basic()
            {
                var values = new DenseVector(new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, }
                );

                int runLength = values.Length;

                values.Flush(-2);

                for(int i = 0; i < runLength; ++i)
                {
                    CheckEqual(-2, values[i]);
                }
            }

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

                values.Flush(-2);
            }
        }

        public class PartialFlushTests : TestFixture
        {
            public void Basic()
            {
                var values = new DenseVector(new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, }
                );

                values.Flush(-2, 5, 4);

                for (int i = 0; i < 5; ++i)
                {
                    CheckEqual(i, values[i]);
                }

                for (int i = 5; i < 9; ++i)
                {
                    CheckEqual(-2, values[i]);
                }

                CheckEqual(9, values[9]);
            }

            public void NegativeRunLength()
            {
                var values = new DenseVector(new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, }
                );

                CheckThrow(typeof(Exception));
                values.Flush(-2, 5, -1);
            }

            public void NegativeStartingOffset()
            {
                var values = new DenseVector(new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, }
                );

                CheckThrow(typeof(Exception));
                values.Flush(-2, -1, 4);
            }

            public void LargeRunLength()
            {
                var values = new DenseVector(new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, }
                );

                CheckThrow(typeof(Exception));
                values.Flush(-2, 0, 11);
            }

            public void LargeStartingOffset()
            {
                var values = new DenseVector(new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, }
                );

                CheckThrow(typeof(Exception));
                values.Flush(-2, 10, 1);
            }

            public void ZeroRunLength()
            {
                var values = new DenseVector(new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, }
                );

                values.Flush(-2, 1, 0);

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

        public class AssignmentAddTests : TestFixture
        {
            public void Basic()
            {
                var values = new DenseVector(new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, }
                );

                int runLength = values.Length;

                values.Add(-2);

                for (int i = 0; i < runLength; ++i)
                {
                    CheckEqual(-2 + i + 1, values[i]);
                }
            }
        }

        public class PartialAssignmentAddTests : TestFixture
        {
            public void Basic()
            {
                var values = new DenseVector(new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, }
                );

                values.Add(-2, 5, 4);

                for (int i = 0; i < 5; ++i)
                {
                    CheckEqual(i, values[i]);
                }

                for (int i = 5; i < 9; ++i)
                {
                    CheckEqual(-2 + i, values[i]);
                }

                CheckEqual(9, values[9]);
            }

            public void NegativeRunLength()
            {
                var values = new DenseVector(new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, }
                );

                CheckThrow(typeof(Exception));
                values.Add(-2, 5, -1);
            }

            public void NegativeStartingOffset()
            {
                var values = new DenseVector(new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, }
                );

                CheckThrow(typeof(Exception));
                values.Add(-2, -1, 4);
            }

            public void LargeRunLength()
            {
                var values = new DenseVector(new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, }
                );

                CheckThrow(typeof(Exception));
                values.Add(-2, 0, 11);
            }

            public void LargeStartingOffset()
            {
                var values = new DenseVector(new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, }
                );

                CheckThrow(typeof(Exception));
                values.Add(-2, 10, 1);
            }

            public void ZeroRunLength()
            {
                var values = new DenseVector(new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, }
                );

                values.Add(-2, 1, 0);

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

        public class NaturalLogTests : TestFixture
        {
            public void Basic()
            {
                var vector = new DenseVector(new Scalar[]
                {
                    Math.Pow(Math.E, 0),
                    Math.Pow(Math.E, 1),
                    Math.Pow(Math.E, 2),
                    Math.Pow(Math.E, 3),
                    Math.Pow(Math.E, 4),
                    Math.Pow(Math.E, 5),
                    Math.Pow(Math.E, 6),
                    Math.Pow(Math.E, 7),
                    Math.Pow(Math.E, 8),
                    Math.Pow(Math.E, 9),
                });

                var expected = new DenseVector(new Scalar[]
                {
                    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 
                });

                DenseVector.NaturalLog(vector, ref vector);

                CheckEqual(expected, vector);
            }

            public void Negative()
            {
                var vector = new DenseVector(new Scalar[]
                {
                    -1
                });

                DenseVector.NaturalLog(vector, ref vector);

                Check(Scalar.IsNaN(vector[0]));
            }

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

                DenseVector.NaturalLog(vector, ref vector);

                // If it doesn't crash, it's a win
            }

            public void DifferentLengths()
            {
                var vector = new DenseVector(new Scalar[]
                {
                    1, 2, 3,
                });

                var results = new DenseVector(2);

                CheckThrow(typeof(Exception));
                DenseVector.NaturalLog(vector, ref results);
            }
        }

        public class Atan2 : TestFixture
        {
            public void Basic()
            {
                var num = new DenseVector(new Scalar[]
                {
                    0, 1, 2, 3, 4, 5,
                });

                var denom = new DenseVector(new Scalar[]
                {
                    -3, -2, -1, 0, 1, 2,
                });

                var expected = new DenseVector(new Scalar[]
                {
                    Math.Atan2(0, -3),
                    Math.Atan2(1, -2),
                    Math.Atan2(2, -1),
                    Math.Atan2(3, 0),
                    Math.Atan2(4, 1),
                    Math.Atan2(5, 2),
                });

                DenseVector.Atan2(num, denom, ref num);

                CheckEqual(expected, num);
            }

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

                DenseVector.Atan2(vector, vector, ref vector);

                // If it doesn't crash, it's a win
            }

            public void DifferentLengths_Num()
            {
                var num = new DenseVector(new Scalar[]
                {
                    0, 1, 2, 3, 4,
                });

                var denom = new DenseVector(new Scalar[]
                {
                    -3, -2, -1, 0, 1, 2,
                });

                CheckThrow(typeof(Exception));
                DenseVector.Atan2(num, denom, ref denom);
            }

            public void DifferentLengths_Denom()
            {
                var num = new DenseVector(new Scalar[]
                {
                    0, 1, 2, 3, 4,
                });

                var denom = new DenseVector(new Scalar[]
                {
                    -3, -2, -1, 0, 1, 2,
                });

                CheckThrow(typeof(Exception));
                DenseVector.Atan2(num, denom, ref num);
            }

            public void DifferentLengths_Results()
            {
                var results = new DenseVector(2);
                
                var num = new DenseVector(new Scalar[]
                {
                    0, 1, 2, 3, 4,
                });

                var denom = new DenseVector(new Scalar[]
                {
                    -3, -2, -1, 0, 1, 2,
                });

                CheckThrow(typeof(Exception));
                DenseVector.Atan2(num, denom, ref results);
            }
        }

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

                var b = new DenseVector(new Scalar[]
                {
                    2, 3, 5, 1, 2,
                });

                var c = new DenseVector(new Scalar[]
                {
                    -1, -1, -1, -1, -1,
                });

                c.FMA(a, b);

                var expected = new DenseVector(new Scalar[]
                {
                    1, 5, 14, 3, 9,
                });

                CheckEqual(expected, c);
            }

            public void DifferentLength_A()
            {
                var a = new DenseVector(new Scalar[]
                {
                    1, 2, 3, 4, 5, 6,
                });

                var b = new DenseVector(new Scalar[]
                {
                    2, 3, 5, 1, 2,
                });

                var c = new DenseVector(new Scalar[]
                {
                    -1, -1, -1, -1, -1,
                });

                CheckThrow(typeof(Exception));
                c.FMA(a, b);
            }

            public void DifferentLength_B()
            {
                var a = new DenseVector(new Scalar[]
                {
                    1, 2, 3, 4, 5,
                });

                var b = new DenseVector(new Scalar[]
                {
                    2, 3, 5, 1, 2, 6,
                });

                var c = new DenseVector(new Scalar[]
                {
                    -1, -1, -1, -1, -1,
                });

                CheckThrow(typeof(Exception));
                c.FMA(a, b);
            }

            public void DifferentLength_C()
            {
                var a = new DenseVector(new Scalar[]
                {
                    1, 2, 3, 4, 5,
                });

                var b = new DenseVector(new Scalar[]
                {
                    2, 3, 5, 1, 2,
                });

                var c = new DenseVector(new Scalar[]
                {
                    -1, -1, -1, -1, -1, -1,
                });

                CheckThrow(typeof(Exception));
                c.FMA(a, b);
            }

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

                var b = new DenseVector(new Scalar[]
                {
                    
                });

                var c = new DenseVector(new Scalar[]
                {
                    
                });

                c.FMA(a, b);

                CheckEqual(0, c.Length);
            }
        }

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

                var b = new DenseVector(new Scalar[]
                {
                    3, 4, 2, 3, 5, 1, 2,
                });

                var c = new DenseVector(new Scalar[]
                {
                    -1, -1, -1, -1, -1, -1,
                });

                c.FMA(a, b, 1, 2, 3, 3);

                var expected = new DenseVector(new Scalar[]
                {
                    -1, 5, 14, 3, -1, -1,
                });

                CheckEqual(expected, c);
            }

            public void LargeRunLength_A()
            {
                var a = new DenseVector(new Scalar[]
                {
                    1, 2, 3, 4, 5,
                });

                var b = new DenseVector(new Scalar[]
                {
                    2, 3, 5, 1, 2,
                });

                var c = new DenseVector(new Scalar[]
                {
                    -1, -1, -1, -1, -1,
                });

                CheckThrow(typeof(Exception));
                c.FMA(a, b, 0, 1, 0, 5);
            }

            public void LargeRunLength_B()
            {
                var a = new DenseVector(new Scalar[]
                {
                    1, 2, 3, 4, 5,
                });

                var b = new DenseVector(new Scalar[]
                {
                    2, 3, 5, 1, 2,
                });

                var c = new DenseVector(new Scalar[]
                {
                    -1, -1, -1, -1, -1,
                });

                CheckThrow(typeof(Exception));
                c.FMA(a, b, 0, 0, 1, 5);
            }

            public void LargeRunLength_C()
            {
                var a = new DenseVector(new Scalar[]
                {
                    1, 2, 3, 4, 5,
                });

                var b = new DenseVector(new Scalar[]
                {
                    2, 3, 5, 1, 2,
                });

                var c = new DenseVector(new Scalar[]
                {
                    -1, -1, -1, -1, -1,
                });

                CheckThrow(typeof(Exception));
                c.FMA(a, b, 1, 0, 0, 5);
            }

            public void NegativeRunLength()
            {
                var a = new DenseVector(new Scalar[]
                {
                    1, 2, 3,
                });

                var b = new DenseVector(new Scalar[]
                {
                    2, 3, 4,
                });

                var c = new DenseVector(new Scalar[]
                {
                    1, 1, 1,
                });

                CheckThrow(typeof(Exception));
                c.FMA(a, b, 1, 1, 1, -1);
            }

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

                var b = new DenseVector(new Scalar[]
                {
                    
                });

                var c = new DenseVector(new Scalar[]
                {
                    
                });

                c.FMA(a, b, 0, 0, 0, 0);

                CheckEqual(0, c.Length);
            }

            public void LargeStartingOffset_A()
            {
                var a = new DenseVector(new Scalar[]
                {
                    1, 2, 3, 4, 5,
                });

                var b = new DenseVector(new Scalar[]
                {
                    2, 3, 5, 1, 2,
                });

                var c = new DenseVector(new Scalar[]
                {
                    -1, -1, -1, -1, -1,
                });

                CheckThrow(typeof(Exception));
                c.FMA(a, b, 0, 5, 0, 1);
            }

            public void LargeStartingOffset_B()
            {
                var a = new DenseVector(new Scalar[]
                {
                    1, 2, 3, 4, 5,
                });

                var b = new DenseVector(new Scalar[]
                {
                    2, 3, 5, 1, 2,
                });

                var c = new DenseVector(new Scalar[]
                {
                    -1, -1, -1, -1, -1,
                });

                CheckThrow(typeof(Exception));
                c.FMA(a, b, 0, 0, 5, 1);
            }

            public void LargeStartingOffset_C()
            {
                var a = new DenseVector(new Scalar[]
                {
                    1, 2, 3, 4, 5,
                });

                var b = new DenseVector(new Scalar[]
                {
                    2, 3, 5, 1, 2,
                });

                var c = new DenseVector(new Scalar[]
                {
                    -1, -1, -1, -1, -1,
                });

                CheckThrow(typeof(Exception));
                c.FMA(a, b, 5, 0, 0, 1);
            }
        }
    }
}