using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using UnitTestSharp;
using Azimuth.DenseLinearAlgebra;
using System.Reflection;
using UnitTestSharp.Extensions;
using System.Linq.Expressions;
using Azimuth.SparseLinearAlgebra;

#if AZIMUTH_COUNT_FLOPS
    using ScalarPrimitive = Azimuth.Scalar;
#elif AZIMUTH_USE_FLOAT
    using ScalarPrimitive = System.Single;
#else
    using ScalarPrimitive = System.Double;
#endif

namespace Azimuth.UnitTests
{
    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 unsafe class NullExpander : TestFixture, ITestFixture
        {
            private unsafe static class MethodInfoFinder
            {
                private static ScalarPrimitive[] scalarPrimitive;
                private static ScalarPrimitive* ptr;
                private static int maxLength;
                public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                    () => DenseVector.NullExpander(ref scalarPrimitive, ref ptr, ref maxLength, 0));
            }

            public MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;

            public void NoExpansionNecessary()
            {
                ScalarPrimitive[] scalarPrimitive = null;
                ScalarPrimitive* ptr = null;
                int maxLength = 10;

                DenseVector.NullExpander(ref scalarPrimitive, ref ptr, ref maxLength, 5);
                CheckEqual(10, maxLength);
            }

            public void ExpansionNecessary()
            {
                ScalarPrimitive[] scalarPrimitive = null;
                ScalarPrimitive* ptr = null;
                int maxLength = 10;

                CheckThrow(typeof(Exception));
                DenseVector.NullExpander(ref scalarPrimitive, ref ptr, ref maxLength, 15);
            }
        }

        public unsafe class DefaultExpander : TestFixture, ITestFixture
        {
            private unsafe static class MethodInfoFinder
            {
                private static ScalarPrimitive[] scalarPrimitive;
                private static ScalarPrimitive* ptr;
                private static int maxLength;
                public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                    () => DenseVector.DefaultExpander(ref scalarPrimitive, ref ptr, ref maxLength, 0));
            }

            public MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;

            public void NoExpansionNecessary()
            {
                ScalarPrimitive[] scalarPrimitive = null;
                ScalarPrimitive* ptr = null;
                int maxLength = 10;

                DenseVector.DefaultExpander(ref scalarPrimitive, ref ptr, ref maxLength, 5);
                CheckEqual(10, maxLength);
            }

            public void ExpansionNecessary()
            {
                ScalarPrimitive[] scalarPrimitive = new ScalarPrimitive[10];
                ScalarPrimitive* ptr = null;
                int maxLength = 10;

                DenseVector.DefaultExpander(ref scalarPrimitive, ref ptr, ref maxLength, 15);
                CheckGreater(scalarPrimitive.Length, 15);
                CheckGreater(maxLength, 15);
                CheckEqual(maxLength, scalarPrimitive.Length);
            }

            public void DoesNotHandleNativePtrs()
            {
                ScalarPrimitive[] scalarPrimitive = null;
                ScalarPrimitive* ptr = stackalloc ScalarPrimitive[10];
                int maxLength = 10;

                CheckThrow(typeof(Exception));
                DenseVector.DefaultExpander(ref scalarPrimitive, ref ptr, ref maxLength, 15);
            }
        }

        public unsafe class DefaultAllocator : TestFixture, ITestFixture
        {
            private unsafe static class MethodInfoFinder
            {
                private static ScalarPrimitive[] scalarPrimitive;
                private static ScalarPrimitive* ptr;
                private static int maxLength;
                public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                    () => DenseVector.DefaultAllocator(ref scalarPrimitive, ref ptr, ref maxLength, 0));
            }

            public MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;

            public void Basic()
            {
                ScalarPrimitive[] scalarPrimitive = null;
                ScalarPrimitive* ptr = null;
                int maxLength = -1;

                DenseVector.DefaultAllocator(ref scalarPrimitive, ref ptr, ref maxLength, 10);
                Check(ptr == null);
                CheckNotNull(scalarPrimitive);
                CheckEqual(10, scalarPrimitive.Length);
                CheckEqual(10, maxLength);
            }

            public void NegativeLength()
            {
                ScalarPrimitive[] scalarPrimitive = null;
                ScalarPrimitive* ptr = null;
                int maxLength = -1;

                CheckThrow(typeof(Exception));
                DenseVector.DefaultAllocator(ref scalarPrimitive, ref ptr, ref maxLength, -1);
            }
        }

        public unsafe class ConstructFromNativePointer : TestFixture, ITestFixture
        {
            private unsafe static class MethodInfoFinder
            {
                private static void* ptr = null;
                public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                    () => DenseVector.ConstructFromNativePointer(ptr, 0));
            }

            public MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;

            public void Basic()
            {
                var array = stackalloc ScalarPrimitive[10];
                var vector = DenseVector.ConstructFromNativePointer(array, 10);

                Check(vector.All(x => x == 0));
                CheckEqual(10, vector.Length);
            }

            public void NegativeLength()
            {
                var array = stackalloc ScalarPrimitive[10];
                CheckThrow(typeof(ArgumentException));
                DenseVector.ConstructFromNativePointer(array, -1);
            }

            public void NullPointer()
            {
                CheckThrow(typeof(ArgumentNullException));
                DenseVector.ConstructFromNativePointer(null, 10);
            }
        }

        public class RequiredSizeForLength : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => GetMethodInfo(() => DenseVector.RequiredSizeForLength(0));

            public void Basic()
            {
                CheckEqual(sizeof(ScalarPrimitive) * 10, DenseVector.RequiredSizeForLength(10));
            }

            public void NegativeLength()
            {
                CheckThrow(typeof(ArgumentException));
                DenseVector.RequiredSizeForLength(-1);
            }
        }

        public class Clone : UnitTestSharp.TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => GetMethodInfo(() => (new DenseVector()).Clone());

            public void Basic()
            {
                DenseVector x = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector expected = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                CheckEqual(expected, x.Clone());
            }
        }

        public class GetCount : UnitTestSharp.TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => typeof(DenseVector).GetMethod("get_Count");

            public void Basic()
            {
                DenseVector x = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                CheckEqual(7, x.Count);
            }
        }

        public class GetLength : UnitTestSharp.TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => typeof(DenseVector).GetMethod("get_Length");

            public void Basic()
            {
                DenseVector x = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                CheckEqual(7, x.Length);
            }
        }

        public class GetCapacity : UnitTestSharp.TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => typeof(DenseVector).GetMethod("get_Capacity");

            public void Basic()
            {
                DenseVector x = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                CheckEqual(7, x.Capacity);
            }

            public void SetLength()
            {
                DenseVector x = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                x.SetLength(2);
                CheckEqual(7, x.Capacity);
            }
        }

        public class SetLength : UnitTestSharp.TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => typeof(DenseVector).GetMethod("SetLength");

            public void Basic()
            {
                DenseVector x = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                x.SetLength(2);
                CheckEqual(2, x.Length);
            }

            public void Zero()
            {
                DenseVector x = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                x.SetLength(0);
                CheckEqual(0, x.Length);
            }

            public void Negative()
            {
                DenseVector x = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                CheckThrow(typeof(ArgumentException));                
                x.SetLength(-1);
            }

            public void TooLarge()
            {
                DenseVector x = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                CheckThrow(typeof(Exception));                
                x.SetLength(8);
            }
        }

        public class Array_Operator_Get : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => GetMethodInfo(
                () => (new DenseVector())[(int)0]);

            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_Get()
            {
                var array = new Scalar[] { 1 };

                var vector = new DenseVector(array);

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

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

                var vector = new DenseVector(array);

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

        public class Array_Operator_Set : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => typeof(DenseVector).GetMethod("set_Item");

            public void Basic()
            {
                var vector = new DenseVector(7);

                for (int i = 0; i < 7; ++i)
                {
                    vector[i] = i;
                }

                DenseVector expected = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, };

                CheckEqual(expected, vector);
            }

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

                var vector = new DenseVector(array);

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

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

                var vector = new DenseVector(array);

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

        public class CopyTo : UnitTestSharp.TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(
                () => (new DenseVector()).CopyTo(null, (int)0));

            public void Basic()
            {
                DenseVector x = new Scalar[] { 1, 2, 4, 3, 5, 6, 7, };
                var y = new Scalar[7];
                x.CopyTo(y, 0);

                var expected = new Scalar[] { 1, 2, 4, 3, 5, 6, 7, };
                
                CheckEqual(expected, y);
            }

            public void StartingIndex()
            {
                DenseVector x = new Scalar[] { 1, 2, 4, 3, 5, 6, 7, };
                var y = new Scalar[8];
                y[0] = 100;
                x.CopyTo(y, 1);

                var expected = new Scalar[] { 100, 1, 2, 4, 3, 5, 6, 7, };
                
                CheckEqual(expected, y);
            }

            public void NegativeStartingIndex()
            {
                DenseVector x = new Scalar[] { 1, 2, 4, 3, 5, 6, 7, };
                var y = new Scalar[8];

                CheckThrow(typeof(Exception));
                x.CopyTo(y, -1);
            }

            public void StartingIndexDoesNotLeaveEnoughRoom()
            {
                DenseVector x = new Scalar[] { 1, 2, 4, 3, 5, 6, 7, };
                var y = new Scalar[8];

                CheckThrow(typeof(Exception));
                x.CopyTo(y, 2);
            }

            public void DestinationNull()
            {
                DenseVector x = new Scalar[] { 1, 2, 4, 3, 5, 6, 7, };
                CheckThrow(typeof(ArgumentNullException));
                x.CopyTo(null, 0);
            }
        }

        public class EqualsObject : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => GetMethodInfo(() =>
                (new DenseVector()).Equals(new object())
            );

            public void EqualVectors()
            {
                DenseVector x = new Scalar[] { 0, 1, 2, 3, 4, 5, 6 };
                Object y = new DenseVector(new Scalar[] { 0, 1, 2, 3, 4, 5, 6 });
                Check(x.Equals(y));
            }

            public void UnequalVectors()
            {
                DenseVector x = new Scalar[] { 0, 1, 2, 3, 4, 5, 6 };
                Object y = new DenseVector(new Scalar[] { 0, 1, 2, 100, 4, 5, 6 });
                CheckFalse(x.Equals(y));
            }

            public void IncompatibleTypes()
            {
                DenseVector x = new Scalar[] { 0, 1, 2, 3, 4, 5, 6 };
                Object y = 10;
                CheckFalse(x.Equals(y));
            }

            public void EqualCompatibleTypes()
            {
                DenseVector x = new Scalar[] { 3, 4 };
                Object y = new SparseVector(new Scalar[] { 3, 4 });
                Check(x.Equals(y));
            }

            public void UnequalCompatibleTypes()
            {
                DenseVector x = new Scalar[] { 3, 4 };
                Object y = new SparseVector(new Scalar[] { 3, 5 });
                CheckFalse(x.Equals(y));
            }

            public void CompatibleTypes_IncompatibleLength()
            {
                DenseVector x = new Scalar[] { 3, 4, 5 };
                Object y = new SparseVector(new Scalar[] { 3, 4 });
                CheckFalse(x.Equals(y));
            }
        }

        public class EqualsVector : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => GetMethodInfo(() =>
                (new DenseVector()).Equals(new DenseVector())
            );

            public void EqualVectors()
            {
                DenseVector x = new Scalar[] { 0, 1, 2, 3, 4, 5, 6 };
                DenseVector y = new DenseVector(new Scalar[] { 0, 1, 2, 3, 4, 5, 6 });
                Check(x.Equals(y));
                Check(y.Equals(x));
            }

            public void UnequalVectors()
            {
                DenseVector x = new Scalar[] { 0, 1, 2, 3, 4, 5, 6 };
                DenseVector y = new Scalar[] { 0, 1, 2, 100, 4, 5, 6 };
                CheckFalse(x.Equals(y));
                CheckFalse(y.Equals(x));
            }
        }

        public class ImplicitConversionToScalarArray : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => typeof(DenseVector).GetMethod("op_Implicit",
                BindingFlags.Public | BindingFlags.Static,
                binder: null,
                new[] { typeof(DenseVector) },
                modifiers: null);

            public void Basic()
            {
                DenseVector x = new DenseVector(2);
                x[0] = 100;
                x[1] = 101;

                Scalar[] y = x;

                CheckEqual(2, y.Length);
                CheckEqual(100, y[0]);
                CheckEqual(101, y[1]);
            }
        }

        public class ImplicitConversionFromScalarArray : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => typeof(DenseVector).GetMethod("op_Implicit",
                BindingFlags.Public | BindingFlags.Static,
                binder: null,
                new[] { typeof(Scalar[]) },
                modifiers: null);

            public void Basic()
            {
                Scalar[] x = new Scalar[] { 100, 101 };
                DenseVector y = x;

                CheckEqual(2, y.Length);
                CheckEqual(100, y[0]);
                CheckEqual(101, y[1]);
            }
        }

        public class GetEnumerator : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => GetMethodInfo(() => (new DenseVector()).GetEnumerator());

            public void ForEachWorks()
            {
                int expected = 1;
                foreach (var x in new DenseVector(new Scalar[] { 1, 2, 3, 4, 5, }))
                {
                    CheckEqual(expected, x);
                    ++expected;
                }
            }
        }

        public class ViewTests : UnitTestSharp.TestFixture
        {
            public class ManagedArray : UnitTestSharp.TestFixture, ITestFixture
            {
                public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(
                    () => (new DenseVector()).GetView((int)0, (int)0));

                public void ViewEquality()
                {
                    var x = new DenseVector(new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7 });
                    var actual = x.GetView(startingOffset: 2, length: 4);
                    var expected = new DenseVector(new Scalar[] { 2, 3, 4, 5 });
                    CheckEqual(expected, actual);
                }

                public void ArrayAccessorGet()
                {
                    var x = new DenseVector(new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7 });
                    var actual = x.GetView(startingOffset: 2, length: 4);
                    CheckEqual(4, actual[2]);
                }

                public void ArrayAccessorGet_ReflectsOriginalData()
                {
                    var x = new DenseVector(new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7 });
                    var actual = x.GetView(startingOffset: 2, length: 4);
                    x[4] = 7;
                    CheckEqual(7, actual[2]);
                }

                public void ArrayAccessorSet()
                {
                    var x = new DenseVector(new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7 });
                    var actual = x.GetView(startingOffset: 2, length: 4);
                    actual[2] = 7;
                    CheckEqual(7, actual[2]);
                }

                public void ArrayAccessorSet_ChangesOriginalData()
                {
                    var x = new DenseVector(new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7 });
                    var actual = x.GetView(startingOffset: 2, length: 4);
                    actual[2] = 7;
                    CheckEqual(7, x[4]);
                }

                public void LengthTooLong()
                {
                    var x = new DenseVector(new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7 });
                    CheckThrow(typeof(Exception));
                    var actual = x.GetView(startingOffset: 2, length: 7);
                }

                public void StartingOffsetNegative()
                {
                    var x = new DenseVector(new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7 });
                    CheckThrow(typeof(Exception));
                    var actual = x.GetView(startingOffset: -1, length: 2);
                }

                public void LengthNegative()
                {
                    var x = new DenseVector(new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7 });
                    CheckThrow(typeof(Exception));
                    var actual = x.GetView(startingOffset: 2, length: -1);
                }

                public void ChangeCapacityOnView()
                {
                    var x = new DenseVector(new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7 });
                    var actual = x.GetView(startingOffset: 2, length: 2);
                    CheckThrow(typeof(Exception));
                    actual.ChangeCapacity(desiredCapacity: 20);
                }

                public void SetLengthOnView()
                {
                    var x = new DenseVector(new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7 });
                    var actual = x.GetView(startingOffset: 2, length: 2);
                    CheckThrow(typeof(Exception));
                    actual.SetLength(4);
                }

                public void ChangeCapacityOnOriginal()
                {
                    var x = new DenseVector(new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7 });
                    var actual = x.GetView(startingOffset: 2, length: 2);
                    CheckThrow(typeof(Exception));
                    x.ChangeCapacity(desiredCapacity: 20);
                }

                public void SetLengthOnOriginal()
                {
                    var x = new DenseVector(new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7 });
                    var actual = x.GetView(startingOffset: 2, length: 2);
                    CheckThrow(typeof(Exception));
                    x.SetLength(4);
                }

                public void AssignmentManagedArray()
                {
                    var x = new DenseVector(new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7 });
                    var actual = x.GetView(startingOffset: 2, length: 4);
                    actual.Assignment(new DenseVector(new Scalar[] { -1, -2, -3, -4 }));
                    var expected = new DenseVector(new Scalar[] { -1, -2, -3, -4 });
                    CheckEqual(expected, actual);
                }

                public void AssignmentManagedArrayChangesOriginal()
                {
                    var x = new DenseVector(new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7 });
                    var actual = x.GetView(startingOffset: 2, length: 4);
                    actual.Assignment(new DenseVector(new Scalar[] { -1, -2, -3, -4 }));
                    var expected = new DenseVector(new Scalar[] { 0, 1, -1, -2, -3, -4, 6, 7 });
                    CheckEqual(expected, x);
                }
            }
        }

        public class ToStringTests : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => GetMethodInfo(() => new DenseVector().ToString());

            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 ToMatlabStringTests : UnitTestSharp.TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(
                () => new DenseVector().ToMatlabString());

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

                var expected = "[ ]";

                CheckEqual(expected, vector.ToMatlabString());
            }

            public void OneElement()
            {
                DenseVector vector = new Scalar[] { 7 };

                var expected = "[7]";

                CheckEqual(expected, vector.ToMatlabString());
            }

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

                var expected = "[1 ; 2 ; 3]";

                CheckEqual(expected, vector.ToMatlabString());
            }
        }

        public class AddElementTests : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(
                () => ((ICollection<Scalar>)new DenseVector()).Add((Scalar)0));

            public void Works_ICollection()
            {
                var actual = new DenseVector(new Scalar[] { 1, 2, 3, });
                actual.SetLength(2);

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

                ((ICollection<Scalar>)actual).Add(4);

                CheckEqual(expected, actual);
            }

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

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

                ((ICollection<Scalar>)actual).Add(4);

                CheckEqual(actual, expected);
            }

            public void Works_IList()
            {
                var actual = new DenseVector(new Scalar[] { 1, 2, 3, });
                actual.SetLength(2);

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

                ((IList)actual).Add(4);

                CheckEqual(expected, actual);
            }

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

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

                ((IList)actual).Add(4);

                CheckEqual(expected, actual);
            }

            public void CanExpandCapacityFrom0_IList()
            {
                var actual = new DenseVector();

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

                ((IList)actual).Add(1);

                CheckEqual(expected, actual);
            }

            public void WrongType_IList()
            {
                var actual = new DenseVector(new Scalar[] { 1, 2, 3, });
                actual.Clear();

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

                CheckThrow(typeof(InvalidCastException));
                ((IList)actual).Add(DateTime.Now);
            }
        }

        public class IListIndexProperty : TestFixture
        {
            public void ReadWorks()
            {
                DenseVector actual = new DenseVector(new Scalar[] { 1, 2, 3, });

                var expected = new DenseVector(new Scalar[] { 4, 0, 0 });

                CheckEqual(1, actual[0]);
                CheckEqual(2, actual[1]);
                CheckEqual(3, actual[2]);
            }

            public void WriteWorks()
            {
                DenseVector actual = new DenseVector(3);

                var expected = new DenseVector(new Scalar[] { 4, 0, 0 } );

                Scalar addme = 4;

                ((IList)actual)[0] = addme;

                CheckEqual(expected, actual);
            }

            public void WriteWorks_Cast()
            {
                DenseVector actual = new DenseVector(3);

                var expected = new DenseVector(new Scalar[] { 4, 0, 0 } );

                int addme = 4;

                ((IList)actual)[0] = addme;

                CheckEqual(expected, actual);
            }

            public void Read_OutOfRange()
            {
                DenseVector actual = new DenseVector(3);

                CheckThrow(typeof(IndexOutOfRangeException));
                CheckEqual(0, actual[3]); // dummy statement
            }

            public void Write_OutOfRange()
            {
                DenseVector actual = new DenseVector(3);

                CheckThrow(typeof(IndexOutOfRangeException));
                actual[3] = 10;
            }
        }

        public class ChangeCapacity : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(
                () => new DenseVector().ChangeCapacity((int)0));

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

                actual.ChangeCapacity(5);
                actual.SetLength(5);

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

                CheckEqual(expected, actual);
            }

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

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

                actual.SetLength(3);
                actual.ChangeCapacity(3);

                CheckEqual(expected, actual);
            }

            public void GrowFrom0()
            {
                var actual = new DenseVector(new Scalar[] { });

                actual.ChangeCapacity(2);
                actual.SetLength(2);

                var expected = new DenseVector(new Scalar[] { 0, 0, });

                CheckEqual(expected, actual);
            }

            public void GrowMoreThan2x()
            {
                var actual = new DenseVector(new Scalar[] { 1, });

                actual.ChangeCapacity(5);
                actual.SetLength(5);

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

                CheckEqual(expected, actual);
            }

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

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

                CheckThrow(typeof(Exception));
                actual.ChangeCapacity(3);
            }
        }

        public class RemoveAt : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(
                () => ((IList<Scalar>)new DenseVector()).RemoveAt((int)0));

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

                ((IList<Scalar>)actual).RemoveAt(2);

                CheckEqual(expected, actual);
            }

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

                CheckThrow(typeof(Exception));
                ((IList<Scalar>)actual).RemoveAt(5);
            }

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

                CheckThrow(typeof(Exception));
                ((IList<Scalar>)actual).RemoveAt(-1);
            }
        }

        public class ClearTests : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(
                () => new DenseVector().Clear());

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

                actual.Clear();

                CheckEqual(expectedClear, actual);
            }

            public void KeepsCapacity()
            {
                var expectedClear = new DenseVector(new Scalar[] { 3, 4, 5, 6, 7, });
                var actual = new DenseVector(new Scalar[] { 1, 2, 3, 4, 5, });

                actual.Clear();
                actual.AddRange(expectedClear);

                CheckEqual(expectedClear, actual);
            }
        }

        public class AddRange : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(
                () => new DenseVector().AddRange(default(DenseVector)));
        
            public void Works()
            {
                var actual = new DenseVector(5);
                actual.Clear();

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

                actual.AddRange(expected);

                CheckEqual(expected, actual);
            }

            public void WillGrowCapacity()
            {
                var actual = new DenseVector(5);

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

                actual.AddRange(adder);

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

                CheckEqual(expected, actual);
            }

            public void Concatenate()
            {
                var actual = new DenseVector(new Scalar[] { 9, 8, 7, 0, 0, 0, 0, 0, });
                actual.SetLength(3);

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

                actual.AddRange(toadd);

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

                CheckEqual(expected, actual);
            }
        }

        public class RemoveRange : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(
                () => new DenseVector().RemoveRange((int)0, (int)0));

            public void Works()
            {
                var actual = new DenseVector(new Scalar[] { 9, 8, 7, 6, 7, 4, 3, 2, 1, });

                var expected = new DenseVector(new Scalar[] { 9, 8, 7, 2, 1, });

                actual.RemoveRange(3, 4);

                CheckEqual(expected, actual);
            }

            public void PreservesCapacity()
            {
                var actual = new DenseVector(new Scalar[] { 9, 8, 7, 6, 7, 4, 3, 2, 1, });

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

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

                actual.RemoveRange(3, 4);
                actual.AddRange(toAdd);

                CheckEqual(expected, actual);
            }

            public void RemoveAll()
            {
                var actual = new DenseVector(new Scalar[] { 9, 8, 7, 6, 7, 4, 3, 2, 1, });

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

                actual.RemoveRange(0, actual.Length);

                CheckEqual(expected, actual);
            }
        }

        public class SumTests : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.Sum);

            public void Basic()
            {
                DenseVector values = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };

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

            public void ArrayIsUnmodified()
            {
                DenseVector values = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };

                values.Sum();

                DenseVector expected = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                CheckEqual(expected, values);
            }

            public void Offset()
            {
                DenseVector values = new Scalar[] { 100, 1, 2, 3, 4, 5, 6, 7, };

                CheckEqual(28, values.Sum(startingOffset: 1, subLength: 7));
            }

            public void Length()
            {
                DenseVector values = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 100, };

                CheckEqual(28, values.Sum(subLength: 7));
            }

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

                CheckEqual(18, values.Sum(2, 3, skip: 3));
            }
        }

        public class SumComplexInterleavedTests : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.SumComplexInterleaved);
            public override int OperationStride => 2;

            public void Basic()
            {
                var x = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                    9, 10, 11, 12, 13, 14, 15, 16,
                    17, 18, 19, 20, 21, 22
                });

                Complex sum = x.SumComplexInterleaved();

                CheckEqual((121, 132), sum);
            }

            public void ArrayUnmodified()
            {
                var x = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                    9, 10, 11, 12, 13, 14, 15, 16,
                    17, 18, 19, 20, 21, 22
                });

                var expected = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                    9, 10, 11, 12, 13, 14, 15, 16,
                    17, 18, 19, 20, 21, 22
                });

                Complex sum = x.SumComplexInterleaved();
                CheckEqual(expected, x);
            }

            public void StartingOffset()
            {
                var x = new DenseVector(new Scalar[] {
                    100, 1, 2, 3, 4, 5, 6, 7, 8,
                    9, 10, 11, 12, 13, 14, 15, 16,
                    17, 18, 19, 20, 21, 22
                });

                Complex sum = x.SumComplexInterleaved(startingOffset: 1);
                CheckEqual((121, 132), sum);
            }

            public void Sublength()
            {
                var x = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                    9, 10, 11, 12, 13, 14, 15, 16,
                    17, 18, 19, 20, 21, 22
                });

                Complex sum = x.SumComplexInterleaved(subLength: 10);
                CheckEqual((100, 110), sum);
            }
        }

        public class ArgMin : BlasBoundsFixture
        {
            private static class MethodInfoFinder
            {
                private static DenseVector x = null;
                public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                    () => x.ArgMin(default(int), default(int?)));
            }

            public override MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;
            public override bool AllowsZeroLength => false;

            public void Basic()
            {
                DenseVector array1 = new Scalar[] {
                    1, 2, 3, 4,
                    5, 6, 7, 0,
                    9, 10, 11,
                };

                CheckEqual(7, array1.ArgMin());
            }

            public void StartingOffset()
            {
                DenseVector array1 = new Scalar[] {
                    -100, 2, 3, 4,
                    5, 6, 7, 0,
                    9, 10, 11,
                };

                CheckEqual(7, array1.ArgMin(startingOffset: 1, subLength: 10));
            }

            public void Sublength()
            {
                DenseVector array1 = new Scalar[] {
                    1, 2, 3, 4,
                    5, 6, 7, 0,
                    9, 10, 11,
                };

                CheckEqual(0, array1.ArgMin(subLength: 7));
            }
        }

        public class ArgMax : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.DotProduct);

            private static class MethodInfoFinder
            {
                private static DenseVector x = null;
                public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                    () => x.ArgMax(default(int), default(int?)));
            }

            public override MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;
            public override bool AllowsZeroLength => false;

            public void Basic()
            {
                DenseVector array1 = new Scalar[] {
                    1, 2, 3, 4,
                    5, 6, 7, 0,
                    11, 9, 10,
                };

                CheckEqual(8, array1.ArgMax());
            }

            public void StartingOffset()
            {
                DenseVector array1 = new Scalar[] {
                    100, 2, 3, 4,
                    5, 6, 7, 0,
                    11, 10, 9,
                };

                CheckEqual(8, array1.ArgMax(startingOffset: 1, subLength: 10));
            }

            public void Sublength()
            {
                DenseVector array1 = new Scalar[] {
                    1, 2, 3, 4,
                    5, 6, 7, 0,
                    11, 10, 9,
                };

                CheckEqual(6, array1.ArgMax(subLength: 8));
            }
        }

        public class L1Norm : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.DotProduct);

            private static class MethodInfoFinder
            {
                private static DenseVector x = null;
                public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                    () => x.L1Norm(default(int), default(int?)));
            }

            public override MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;

            public void Basic()
            {
                DenseVector array1 = new Scalar[] {
                    1, -2, 3, -4,
                    5, -6, 7, 8,
                    -9, 10, 11,
                };

                CheckEqual(66, array1.L1Norm());
            }

            public void StartingOffset()
            {
                DenseVector array1 = new Scalar[] {
                    100, -2, 3, -4,
                    5, -6, 7, 8,
                    -9, 10, 11,
                };

                CheckEqual(65, array1.L1Norm(startingOffset: 1, subLength: 10));
            }

            public void Sublength()
            {
                DenseVector array1 = new Scalar[] {
                    1, -2, 3, -4,
                    5, -6, 7, 8,
                    -9, 10, 11,
                };

                CheckEqual(55, array1.L1Norm(subLength: 10));
            }
        }

        public class DotProduct : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.DotProduct);

            private static class MethodInfoFinder
            {
                private static DenseVector x = null;
                public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                    () => x.DotProduct(default(DenseVector), default(int), default(int), default(int?)));
            }

            public override MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;

            public void Basic()
            {
                DenseVector array1 = new Scalar[] {
                    1, 2, 3, 4,
                    5, 6, 7, 8,
                    9, 10, 11,
                };
                DenseVector array2 = new Scalar[] {
                    1, 2, 3, 4,
                    5, 6, 7, 8,
                    9, 10, 11,
                };

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

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

                CheckEqual(0, 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 class DotProductReverse : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.DotProductReverse);

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

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

                CheckEqual(184, x.DotProductReverse(y));
            }

            public override void ZeroLength()
            {
                DenseVector x = new Scalar[0];
                DenseVector y = new Scalar[0];
                CheckEqual(0, x.DotProductReverse(y));
            }

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

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

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

                x.DotProductReverse(y);

                CheckEqual(expectedX, x);
            }

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

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

                CheckEqual(184, x.DotProductReverse(y, startingOffsetThis: 1, subLength: 11));
            }

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

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

                CheckEqual(184, x.DotProductReverse(y, startingOffsetOther: 1, subLength: 11));
            }

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

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

                CheckEqual(184, x.DotProductReverse(y, subLength: 11));
            }
        }

        public class MACCComplexInterleaved : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.MACCComplexInterleaved);
            public override int OperationStride => 2;

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

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

                CheckEqual((454, 84), x.MACCComplexInterleaved(y));
            }

            public override void ZeroLength()
            {
                DenseVector x = new Scalar[0];
                DenseVector y = new Scalar[0];
                CheckEqual(0, x.MACCComplexInterleaved(y));
            }

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

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

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

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

                x.MACCComplexInterleaved(y);

                CheckEqual(expectedX, x);
                CheckEqual(expectedY, y);
            }

            public void StartingOffsetThis()
            {
                var x = new DenseVector(new Scalar[] {
                    100,
                    0, 1, 2, 3, 4, 5, 6, 7,
                    8, 9, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11,
                });

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

                CheckEqual((454, 84), x.MACCComplexInterleaved(y, startingOffsetThis: 1, subLength: 11));
            }

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

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

                CheckEqual((454, 84), x.MACCComplexInterleaved(y, startingOffsetOther: 1, subLength: 11));
            }

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

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

                CheckEqual((454, 84), x.MACCComplexInterleaved(y, subLength: 11));
            }
        }

        public class MACCComplexInterleavedWithReal : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.MACCComplexInterleavedWithReal);
            public override int OperationStride => 2;

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

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

                CheckEqual((224, 272), x.MACCComplexInterleavedWithReal(y));
            }

            public override void ZeroLength()
            {
                DenseVector x = new Scalar[0];
                DenseVector y = new Scalar[0];
                CheckEqual(0, x.MACCComplexInterleavedWithReal(y));
            }

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

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

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

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

                x.MACCComplexInterleavedWithReal(y);

                CheckEqual(expectedX, x);
                CheckEqual(expectedY, y);
            }

            public void StartingOffsetThis()
            {
                var x = new DenseVector(new Scalar[] {
                    100,
                    0, 1, 2, 3, 4, 5, 6, 7,
                    8, 9, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11,
                });

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

                CheckEqual((224, 272), x.MACCComplexInterleavedWithReal(y, startingOffsetThis: 1, subLength: 11));
            }

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

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

                CheckEqual((224, 272), x.MACCComplexInterleavedWithReal(y, startingOffsetOther: 1, subLength: 11));
            }

            public void Sublength()
            {
                var x = new DenseVector(new Scalar[] {
                    0, 1, 2, 3, 4, 5, 6, 7,
                    8, 9, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11, 101, 102, 103,
                });

                var y = new DenseVector(new Scalar[] {
                    9, 0, 8, 7,
                    2, 4, 1, 4,
                    0, 7, 6,
                    101, 102,
                });

                CheckEqual((224, 272), x.MACCComplexInterleavedWithReal(y, subLength: 11));
            }
        }

        public class TripleMACCComplexInterleaved : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.TripleMACCComplexInterleaved);
            public override int OperationStride => 2;

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

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

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

                CheckEqual((-236, 1605), DenseVector.TripleMACCComplexInterleaved(x, y, z));
            }

            public override void ZeroLength()
            {
                DenseVector x = new Scalar[0];
                DenseVector y = new Scalar[0];
                DenseVector z = new Scalar[0];
                CheckEqual(0, DenseVector.TripleMACCComplexInterleaved(x, y, z));
            }

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

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

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

                DenseVector.TripleMACCComplexInterleaved(x, y, z);

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

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

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

                CheckEqual(expectedX, x);
                CheckEqual(expectedY, y);
                CheckEqual(expectedZ, z);
            }

            public void StartingOffsetA()
            {
                var x = new DenseVector(new Scalar[] {
                    100, 0, 1, 2, 3, 4, 5, 6, 7,
                    8, 9, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11,
                });

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

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

                CheckEqual((-236, 1605), DenseVector.TripleMACCComplexInterleaved(x, y, z, startingOffsetA: 1, subLength: 11));
            }

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

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

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

                CheckEqual((-236, 1605), DenseVector.TripleMACCComplexInterleaved(x, y, z, startingOffsetB: 1, subLength: 11));
            }

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

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

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

                CheckEqual((-236, 1605), DenseVector.TripleMACCComplexInterleaved(x, y, z, startingOffsetC: 1, subLength: 11));
            }

            public void Sublength()
            {
                var x = new DenseVector(new Scalar[] {
                    0, 1, 2, 3, 4, 5, 6, 7,
                    8, 9, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11, 100
                });

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

                var z = new DenseVector(new Scalar[] {
                    6, 4, 4, 1, 5, 4, 4, 5,
                    8, 5, -5, -3, -7, 0, 9, 9,
                    8, 8, -6, 0, -2, 3, 103, 104, 105,
                });

                CheckEqual((-236, 1605), DenseVector.TripleMACCComplexInterleaved(x, y, z, subLength: 11));
            }
        }

        public class TripleMACCComplexConjugateFirstInterleaved : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.TripleMACCComplexConjugateFirstInterleaved);
            public override int OperationStride => 2;

            public void Basic()
            {
                var x = new DenseVector(new Scalar[] {
                    0, -1, 2, -3, 4, -5, 6, -7,
                    8, -9, 0, -1, 2, -3, 4, -5,
                    6, -7, 8, -9, 10, -11,
                });

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

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

                CheckEqual((-236, 1605), DenseVector.TripleMACCComplexConjugateFirstInterleaved(x, y, z));
            }

            public override void ZeroLength()
            {
                DenseVector x = new Scalar[0];
                DenseVector y = new Scalar[0];
                DenseVector z = new Scalar[0];
                CheckEqual(0, DenseVector.TripleMACCComplexConjugateFirstInterleaved(x, y, z));
            }

            public void OriginalArrayIsUnmodified()
            {
                var x = new DenseVector(new Scalar[] {
                    0, -1, 2, -3, 4, -5, 6, -7,
                    8, -9, 0, -1, 2, -3, 4, -5,
                    6, -7, 8, -9, 10, -11,
                });

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

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

                DenseVector.TripleMACCComplexConjugateFirstInterleaved(x, y, z);

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

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

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

                CheckEqual(expectedX, x);
                CheckEqual(expectedY, y);
                CheckEqual(expectedZ, z);
            }

            public void StartingOffsetA()
            {
                var x = new DenseVector(new Scalar[] {
                    100, 0, -1, 2, -3, 4, -5, 6, -7,
                    8, -9, 0, -1, 2, -3, 4, -5,
                    6, -7, 8, -9, 10, -11,
                });

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

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

                CheckEqual((-236, 1605), DenseVector.TripleMACCComplexConjugateFirstInterleaved(x, y, z,
                    startingOffsetA: 1, subLength: 11));
            }

            public void StartingOffsetB()
            {
                var x = new DenseVector(new Scalar[] {
                    0, -1, 2, -3, 4, -5, 6, -7,
                    8, -9, 0, -1, 2, -3, 4, -5,
                    6, -7, 8, -9, 10, -11,
                });

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

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

                CheckEqual((-236, 1605), DenseVector.TripleMACCComplexConjugateFirstInterleaved(x, y, z,
                    startingOffsetB: 1, subLength: 11));
            }

            public void StartingOffsetC()
            {
                var x = new DenseVector(new Scalar[] {
                    0, -1, 2, -3, 4, -5, 6, -7,
                    8, -9, 0, -1, 2, -3, 4, -5,
                    6, -7, 8, -9, 10, -11,
                });

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

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

                CheckEqual((-236, 1605), DenseVector.TripleMACCComplexConjugateFirstInterleaved(x, y, z,
                    startingOffsetC: 1, subLength: 11));
            }

            public void Sublength()
            {
                var x = new DenseVector(new Scalar[] {
                    0, -1, 2, -3, 4, -5, 6, -7,
                    8, -9, 0, -1, 2, -3, 4, -5,
                    6, -7, 8, -9, 10, -11, 100
                });

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

                var z = new DenseVector(new Scalar[] {
                    6, 4, 4, 1, 5, 4, 4, 5,
                    8, 5, -5, -3, -7, 0, 9, 9,
                    8, 8, -6, 0, -2, 3, 103, 104, 105,
                });

                CheckEqual((-236, 1605), DenseVector.TripleMACCComplexConjugateFirstInterleaved(x, y, z, subLength: 11));
            }
        }

        public class DotProductComplexInterleaved : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.DotProductComplexInterleaved);
            public override int OperationStride => 2;

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

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

                CheckEqual((410, -112), x.DotProductComplexInterleaved(y));
            }

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

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

                CheckEqual(x.DotProductComplexInterleaved(y), y.DotProductComplexInterleaved(x).Conjugate);
            }

            public override void ZeroLength()
            {
                DenseVector x = new Scalar[0];
                DenseVector y = new Scalar[0];
                CheckEqual(0, x.DotProductComplexInterleaved(y));
            }

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

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

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

                x.DotProductComplexInterleaved(y);

                CheckEqual(expectedX, x);
            }

            public void StartingOffsetThis()
            {
                var x = new DenseVector(new Scalar[] {
                    100, 0, 1, 2, 3, 4, 5, 6, 7,
                    8, 9, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11,
                });

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

                CheckEqual((410, -112), x.DotProductComplexInterleaved(y, startingOffsetThis: 1, subLength: 11));
            }

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

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

                CheckEqual((410, -112), x.DotProductComplexInterleaved(y, startingOffsetOther: 1, subLength: 11));
            }

            public void Sublength()
            {
                var x = new DenseVector(new Scalar[] {
                    0, 1, 2, 3, 4, 5, 6, 7,
                    8, 9, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11, 100, 100,
                });

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

                CheckEqual((410, -112), x.DotProductComplexInterleaved(y, subLength: 11));
            }
        }

        public class DotProductComplexInterleavedWithReal : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.DotProductComplexInterleavedWithReal);
            public override int InstanceOperationStride => 2;
            public override int VectorAOperationStride => 1;

            public override void TestSetup()
            {
                base.TestSetup();
            }

            public override void BaselinePasses()
            {
                base.BaselinePasses();
            }

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

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

                CheckEqual((170, -215), x.DotProductComplexInterleavedWithReal(y));
            }

            public void Offset()
            {
                var x = new DenseVector(new Scalar[] {
                    100, 0, 1, 2, 3, 4, 5, 6, 7,
                    8, 9, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11,
                });

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

                var result = x.DotProductComplexInterleavedWithReal(y, startingOffsetThis: 1, subLength: 11);
                CheckEqual((170, -215), result);
            }

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

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

                var result = x.DotProductComplexInterleavedWithReal(y, startingOffsetOther: 1, subLength: 11);
                CheckEqual((170, -215), result);
            }

            public void Length()
            {
                var x = new DenseVector(new Scalar[] {
                    0, 1, 2, 3, 4, 5, 6, 7,
                    8, 9, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11,
                    101,
                });

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

                var result = x.DotProductComplexInterleavedWithReal(y, subLength: 11);
                CheckEqual((170, -215), result);
            }
        }

        public class DotProductRealWithComplexInterleaved : BlasBoundsFixture
        {
            private static class MethodInfoFinder
            {
                private static DenseVector x = null;
                public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                    () => x.DotProduct(default(ComplexDenseVector), default(int), default(int), default(int?)));
            }

            public override MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;

            public override Dictionary<Type, Func<object>> TypeFactory => new Dictionary<Type, Func<object>>()
            {
                { typeof(ComplexDenseVector), () => new ComplexDenseVector(11) },
            };

            public override int InstanceOperationStride => 2;
            public override int VectorAOperationStride => 1;

            public override void TestSetup()
            {
                base.TestSetup();
            }

            public override void BaselinePasses()
            {
                base.BaselinePasses();
            }

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

                var y = new ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

                CheckEqual((170, 215), x.DotProduct(y));
            }

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

                var y = new ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

                var result = x.DotProduct(y, startingOffsetThis: 1, subLength: 11);
                CheckEqual((170, 215), result);
            }

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

                var y = new ComplexDenseVector(new Complex[] {
                    100, (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

                var result = x.DotProduct(y, startingOffsetOther: 1, subLength: 11);
                CheckEqual((170, 215), result);
            }

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

                var y = new ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                    103, 104,
                });

                var result = x.DotProduct(y, subLength: 11);
                CheckEqual((170, 215), result);
            }
        }

        public class Magnitude : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.Magnitude);

            public void Works()
            {
                DenseVector vec = new Scalar[] { 0, -1, 2, -3, 4, -5, };
                CheckEqual(Math.Sqrt(55), vec.Magnitude());
            }

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

            public override void ZeroLength()
            {
                DenseVector vec = new Scalar[] { };
                CheckEqual(0, vec.Magnitude());
            }

            public void StartingOffset()
            {
                DenseVector vec = new Scalar[] { 0, -1, 2, -3, 4, -5, };
                CheckEqual(Math.Sqrt(54), vec.Magnitude(startingIndex: 2, subLength: 4));
            }

            public void Sublength()
            {
                DenseVector vec = new Scalar[] { 0, -1, 2, -3, 4, -5, };
                CheckEqual(Math.Sqrt(30), vec.Magnitude(subLength: 5));
            }
        }

        public class MagnitudeSquared : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.MagnitudeSquared);

            public void Works()
            {
                DenseVector vec = new Scalar[] { 0, -1, 2, -3, 4, -5, };
                CheckEqual(55, vec.MagnitudeSquared());
            }

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

            public override void ZeroLength()
            {
                DenseVector vec = new Scalar[] { };
                CheckEqual(0, vec.MagnitudeSquared());
            }

            public void StartingOffset()
            {
                DenseVector vec = new Scalar[] { 0, -1, 2, -3, 4, -5, };
                CheckEqual(54, vec.MagnitudeSquared(startingOffset: 2, subLength: 4));
            }

            public void Sublength()
            {
                DenseVector vec = new Scalar[] { 0, -1, 2, -3, 4, -5, };
                CheckEqual(30, vec.MagnitudeSquared(subLength: 5));
            }
        }

        public class AssignmentMagnitudeSquared3D : BlasBoundsFixture
        {
            private static class MethodInfoFinder
            {
                private static DenseVector x = null;
                public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                    () => x.AssignmentMagnitudeSquared3D(x, x, x, (int)0, (int)0, (int)0, (int)0, (int?)null));
            }

            public override MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;

            public void Basic()
            {
                DenseVector a = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector b = new Scalar[] { 2, 3, 5, 1, 2, 3, 4, };
                DenseVector c = new Scalar[] { -1, -1, -1, -1, -1, -1, -1, };
                DenseVector actual = new DenseVector(7);

                actual.AssignmentMagnitudeSquared3D(c, a, b);

                DenseVector expected = new Scalar[] { 6, 14, 35, 18, 30, 46, 66 };

                CheckEqual(expected, actual);
            }

            public void Offset()
            {
                DenseVector a = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector b = new Scalar[] { 2, 3, 5, 1, 2, 3, 4, };
                DenseVector c = new Scalar[] { -1, -1, -1, -1, -1, -1, -1, };
                DenseVector actual = new DenseVector(8);
                actual[0] = 100;

                actual.AssignmentMagnitudeSquared3D(c, a, b, startingIndexThis: 1, subLength: 7);

                DenseVector expected = new Scalar[] { 100, 6, 14, 35, 18, 30, 46, 66 };

                CheckEqual(expected, actual);
            }

            public void OffsetA()
            {
                DenseVector a = new Scalar[] { 100, 1, 2, 3, 4, 5, 6, 7, };
                DenseVector b = new Scalar[] { 2, 3, 5, 1, 2, 3, 4, };
                DenseVector c = new Scalar[] { -1, -1, -1, -1, -1, -1, -1, };
                DenseVector actual = new DenseVector(7);

                actual.AssignmentMagnitudeSquared3D(a, b, c, startingIndexX: 1, subLength: 7);

                DenseVector expected = new Scalar[] { 6, 14, 35, 18, 30, 46, 66 };

                CheckEqual(expected, actual);
            }

            public void OffsetB()
            {
                DenseVector a = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector b = new Scalar[] { 100, 2, 3, 5, 1, 2, 3, 4, };
                DenseVector c = new Scalar[] { -1, -1, -1, -1, -1, -1, -1, };
                DenseVector actual = new DenseVector(7);

                actual.AssignmentMagnitudeSquared3D(a, b, c, startingIndexY: 1, subLength: 7);

                DenseVector expected = new Scalar[] { 6, 14, 35, 18, 30, 46, 66 };

                CheckEqual(expected, actual);
            }

            public void OffsetC()
            {
                DenseVector a = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector b = new Scalar[] { 2, 3, 5, 1, 2, 3, 4, };
                DenseVector c = new Scalar[] { 100, -1, -1, -1, -1, -1, -1, -1, };
                DenseVector actual = new DenseVector(7);

                actual.AssignmentMagnitudeSquared3D(a, b, c, startingIndexZ: 1, subLength: 7);

                DenseVector expected = new Scalar[] { 6, 14, 35, 18, 30, 46, 66 };

                CheckEqual(expected, actual);
            }

            public void Length()
            {
                DenseVector a = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 104, 105, 106, };
                DenseVector b = new Scalar[] { 2, 3, 5, 1, 2, 3, 4, 103, };
                DenseVector c = new Scalar[] { -1, -1, -1, -1, -1, -1, -1, 101, 102, };
                DenseVector actual = new DenseVector(8);
                actual[7] = 100;

                actual.AssignmentMagnitudeSquared3D(c, a, b, subLength: 7);

                DenseVector expected = new Scalar[] { 6, 14, 35, 18, 30, 46, 66, 100 };

                CheckEqual(expected, actual);
            }
        }

        public class AssignmentMagnitudeSquared2D : BlasBoundsFixture
        {
            private static class MethodInfoFinder
            {
                private static DenseVector x = null;
                public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                    () => x.AssignmentMagnitudeSquared2D(x, x, (int)0, (int)0, (int)0, (int?)null));
            }

            public override MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;

            public void Basic()
            {
                DenseVector a = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector b = new Scalar[] { 2, 3, 5, 1, 2, 3, 4, };
                DenseVector actual = new DenseVector(7);

                actual.AssignmentMagnitudeSquared2D(a, b);

                DenseVector expected = new Scalar[] { 5, 13, 34, 17, 29, 45, 65 };

                CheckEqual(expected, actual);
            }

            public void Offset()
            {
                DenseVector a = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector b = new Scalar[] { 2, 3, 5, 1, 2, 3, 4, };
                DenseVector actual = new DenseVector(8);
                actual[0] = 100;

                actual.AssignmentMagnitudeSquared2D(a, b, startingIndexThis: 1, subLength: 7);

                DenseVector expected = new Scalar[] { 100, 5, 13, 34, 17, 29, 45, 65 };

                CheckEqual(expected, actual);
            }

            public void OffsetA()
            {
                DenseVector a = new Scalar[] { 100, 1, 2, 3, 4, 5, 6, 7, };
                DenseVector b = new Scalar[] { 2, 3, 5, 1, 2, 3, 4, };
                DenseVector actual = new DenseVector(7);

                actual.AssignmentMagnitudeSquared2D(a, b, startingIndexX: 1, subLength: 7);

                DenseVector expected = new Scalar[] { 5, 13, 34, 17, 29, 45, 65 };

                CheckEqual(expected, actual);
            }

            public void OffsetB()
            {
                DenseVector a = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector b = new Scalar[] { 100, 2, 3, 5, 1, 2, 3, 4, };
                DenseVector actual = new DenseVector(7);

                actual.AssignmentMagnitudeSquared2D(a, b, startingIndexY: 1, subLength: 7);

                DenseVector expected = new Scalar[] { 5, 13, 34, 17, 29, 45, 65 };

                CheckEqual(expected, actual);
            }

            public void Length()
            {
                DenseVector a = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 104, 105, 106, };
                DenseVector b = new Scalar[] { 2, 3, 5, 1, 2, 3, 4, 103, };
                DenseVector actual = new DenseVector(8);
                actual[7] = 100;

                actual.AssignmentMagnitudeSquared2D(a, b, subLength: 7);

                DenseVector expected = new Scalar[] { 5, 13, 34, 17, 29, 45, 65, 100 };

                CheckEqual(expected, actual);
            }
        }

        public class Normalize : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.Normalize);

            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 StartingOffset()
            {
                DenseVector vec = new Scalar[] { 1, -3, 4, };
                DenseVector expected = new Scalar[] { 1, -3, 1, };

                vec.Normalize(startingIndex: 2, subLength: 1);
                CheckEqual(expected, vec);
            }

            public void Length()
            {
                DenseVector vec = new Scalar[] { 4, -3, 5, };
                DenseVector expected = new Scalar[] { 4.0/5.0, -3.0/5.0, 5, };

                vec.Normalize(subLength: 2);
                CheckEqual(expected, vec);
            }

            public void ZeroVector()
            {
                DenseVector vec = new Scalar[] { 0, 0, 0, };
                CheckThrow(typeof(Exception));
                vec.Normalize();
            }

            public override void ZeroLength()
            {
                CheckThrow(typeof(Exception));
                base.ZeroLength();
            }
        }

        public class ForwardPermute : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(
                () => new DenseVector().ForwardPermute((IList<int>)null, (int)0));

            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 ForwardPermuteRef : TestFixture, ITestFixture
        {
            private static DenseVector x;
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(
                () => x.ForwardPermute(ref x, (IList<int>)null, (int)0));

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

                x.ForwardPermute(ref actual, permutations);

                CheckEqual(expected, actual);
            }

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

                x.ForwardPermute(ref actual, permutations);

                CheckEqual(expected, actual);
            }

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

                CheckThrow(typeof(Exception));
                x.ForwardPermute(ref actual, permutations);
            }

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

                CheckThrow(typeof(Exception));
                x.ForwardPermute(ref actual, permutations);
            }

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

                CheckThrow(typeof(Exception));
                x.ForwardPermute(ref actual, permutations);
            }

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

                CheckThrow(typeof(Exception));
                x.ForwardPermute(ref actual, permutations);
            }

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

                x.ForwardPermute(ref actual, permutations);

                CheckEqual(expected, actual);
            }

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

                x.ForwardPermute(ref actual, permutations, subLength: 3);

                CheckEqual(expected, actual);
            }
        }

        public class BackPermute : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(
                () => new DenseVector().BackPermute((IList<int>)null, (int)0));

            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 BackPermuteRef : TestFixture, ITestFixture
        {
            private static DenseVector x;
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(
                () => x.BackPermute(ref x, (IList<int>)null, (int)0));

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

                DenseVector actual = new DenseVector(3);
                x.BackPermute(ref actual, permutations);

                CheckEqual(expected, actual);
            }

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

                DenseVector actual = new DenseVector(3);
                x.BackPermute(ref actual, permutations);

                CheckEqual(expected, actual);
            }

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

                CheckThrow(typeof(Exception));
                x.BackPermute(ref actual, permutations);
            }

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

                CheckThrow(typeof(Exception));
                x.BackPermute(ref actual, permutations);
            }

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

                CheckThrow(typeof(Exception));
                x.BackPermute(ref actual, permutations);
            }

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

                CheckThrow(typeof(Exception));
                x.BackPermute(ref actual, permutations);
            }

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

                x.BackPermute(ref actual, permutations);

                CheckEqual(expected, actual);
            }

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

                x.BackPermute(ref actual, permutations, 3);

                CheckEqual(expected, actual);

            }
        }

        public class ForwardPermuteFromCycles_Static : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(
                () => DenseVector.ForwardPermuteFromCycles(default(DenseVector), (IList<int>)null));

            public void Identity()
            {
                var cycles = new int[] { };

                DenseVector vector = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, };
                DenseVector expected = vector.Clone();

                DenseVector.ForwardPermuteFromCycles(vector, cycles);

                CheckEqual(expected, vector);
            }

            public void Identity_0s()
            {
                var cycles = new int[] { 0, 1, 2, 3, 4, 5, };

                DenseVector vector = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, };
                DenseVector expected = vector.Clone();

                DenseVector.ForwardPermuteFromCycles(vector, cycles);

                CheckEqual(expected, vector);
            }

            public void Reverse()
            {
                var cycles = new int[] { 2, 0, 6, 2, 1, 5, 2, 2, 4, };

                DenseVector vector = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, };
                DenseVector expected = new Scalar[] { 6, 5, 4, 3, 2, 1, 0, };

                DenseVector.ForwardPermuteFromCycles(vector, cycles);

                CheckEqual(expected, vector);
            }

            public void CycleShift()
            {
                var cycles = new int[] { 7, 6, 0, 1, 2, 3, 4, 5, };

                DenseVector vector = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, };
                DenseVector expected = new Scalar[] { 1, 2, 3, 4, 5, 6, 0, };

                DenseVector.ForwardPermuteFromCycles(vector, cycles);

                CheckEqual(expected, vector);
            }

            public void EmptyVector()
            {
                var cycles = new int[] { };

                DenseVector vector = new Scalar[] { };
                DenseVector expected = new Scalar[] { };

                DenseVector.ForwardPermuteFromCycles(vector, cycles);

                CheckEqual(expected, vector);
            }

            public void PermutationIndexTooFar()
            {
                var cycles = new int[] { 2, 0, 4, };

                DenseVector vector = new Scalar[] { 0, 1, 2, };

                CheckThrow(typeof(Exception));
                DenseVector.ForwardPermuteFromCycles(vector, cycles);
            }

            public void PermutationDuplicate()
            {
                var cycles = new int[] { 2, 0, 1, 2, 2, 0, };

                DenseVector vector = new Scalar[] { 0, 1, 2, };

                CheckThrow(typeof(Exception));
                DenseVector.ForwardPermuteFromCycles(vector, cycles);
            }

            public void PermutationNegative()
            {
                var cycles = new int[] { 2, 0, -1, };

                DenseVector vector = new Scalar[] { 0, 1, 2, };

                CheckThrow(typeof(Exception));
                DenseVector.ForwardPermuteFromCycles(vector, cycles);
            }

            public void PermutationNegativeLength()
            {
                var cycles = new int[] { 2, 0, 1, -1, 2, };

                DenseVector vector = new Scalar[] { 0, 1, 2, };

                CheckThrow(typeof(Exception));
                DenseVector.ForwardPermuteFromCycles(vector, cycles);
            }

            public void PermutationLongLength()
            {
                var cycles = new int[] { 20, 0, 1, 2, };

                DenseVector vector = new Scalar[] { 0, 1, 2, };

                CheckThrow(typeof(Exception));
                DenseVector.ForwardPermuteFromCycles(vector, cycles);
            }
        }

        public class ForwardPermuteFromCycles : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(
                () => (new DenseVector()).ForwardPermuteFromCycles((IList<int>)null));

            public void Identity()
            {
                var cycles = new int[] { };

                DenseVector vector = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, };
                DenseVector expected = vector.Clone();

                vector.ForwardPermuteFromCycles(cycles);

                CheckEqual(expected, vector);
            }

            public void Identity_0s()
            {
                var cycles = new int[] { 0, 1, 2, 3, 4, 5, };

                DenseVector vector = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, };
                DenseVector expected = vector.Clone();

                vector.ForwardPermuteFromCycles(cycles);

                CheckEqual(expected, vector);
            }

            public void Reverse()
            {
                var cycles = new int[] { 2, 0, 6, 2, 1, 5, 2, 2, 4, };

                DenseVector vector = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, };
                DenseVector expected = new Scalar[] { 6, 5, 4, 3, 2, 1, 0, };

                vector.ForwardPermuteFromCycles(cycles);

                CheckEqual(expected, vector);
            }

            public void CycleShift()
            {
                var cycles = new int[] { 7, 6, 0, 1, 2, 3, 4, 5, };

                DenseVector vector = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, };
                DenseVector expected = new Scalar[] { 1, 2, 3, 4, 5, 6, 0, };

                vector.ForwardPermuteFromCycles(cycles);

                CheckEqual(expected, vector);
            }

            public void EmptyVector()
            {
                var cycles = new int[] { };

                DenseVector vector = new Scalar[] { };
                DenseVector expected = new Scalar[] { };

                vector.ForwardPermuteFromCycles(cycles);

                CheckEqual(expected, vector);
            }

            public void PermutationIndexTooFar()
            {
                var cycles = new int[] { 2, 0, 4, };

                DenseVector vector = new Scalar[] { 0, 1, 2, };

                CheckThrow(typeof(Exception));
                vector.ForwardPermuteFromCycles(cycles);
            }

            public void PermutationDuplicate()
            {
                var cycles = new int[] { 2, 0, 1, 2, 2, 0, };

                DenseVector vector = new Scalar[] { 0, 1, 2, };

                CheckThrow(typeof(Exception));
                vector.ForwardPermuteFromCycles(cycles);
            }

            public void PermutationNegative()
            {
                var cycles = new int[] { 2, 0, -1, };

                DenseVector vector = new Scalar[] { 0, 1, 2, };

                CheckThrow(typeof(Exception));
                vector.ForwardPermuteFromCycles(cycles);
            }

            public void PermutationNegativeLength()
            {
                var cycles = new int[] { 2, 0, 1, -1, 2, };

                DenseVector vector = new Scalar[] { 0, 1, 2, };

                CheckThrow(typeof(Exception));
                vector.ForwardPermuteFromCycles(cycles);
            }

            public void PermutationLongLength()
            {
                var cycles = new int[] { 20, 0, 1, 2, };

                DenseVector vector = new Scalar[] { 0, 1, 2, };

                CheckThrow(typeof(Exception));
                vector.ForwardPermuteFromCycles(cycles);
            }
        }

        public class BackPermuteFromCycles_Static : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(
                () => DenseVector.BackPermuteFromCycles(default(DenseVector), (IList<int>)null));

            public void Identity()
            {
                var cycles = new int[] { };

                DenseVector vector = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, };
                DenseVector expected = vector.Clone();

                DenseVector.BackPermuteFromCycles(vector, cycles);

                CheckEqual(expected, vector);
            }

            public void Identity_0s()
            {
                var cycles = new int[] { 0, 1, 2, 3, 4, 5, };

                DenseVector vector = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, };
                DenseVector expected = vector.Clone();

                DenseVector.BackPermuteFromCycles(vector, cycles);

                CheckEqual(expected, vector);
            }

            public void Reverse()
            {
                var cycles = new int[] { 2, 0, 6, 2, 1, 5, 2, 2, 4, };

                DenseVector vector = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, };
                DenseVector expected = new Scalar[] { 6, 5, 4, 3, 2, 1, 0, };

                DenseVector.BackPermuteFromCycles(vector, cycles);

                CheckEqual(expected, vector);
            }

            public void CycleShift()
            {
                var cycles = new int[] { 7, 6, 0, 1, 2, 3, 4, 5, };

                DenseVector vector = new Scalar[] { 1, 2, 3, 4, 5, 6, 0, };
                DenseVector expected = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, };

                DenseVector.BackPermuteFromCycles(vector, cycles);

                CheckEqual(expected, vector);
            }

            public void EmptyVector()
            {
                var cycles = new int[] { };

                DenseVector vector = new Scalar[] { };
                DenseVector expected = new Scalar[] { };

                DenseVector.BackPermuteFromCycles(vector, cycles);

                CheckEqual(expected, vector);
            }

            public void PermutationIndexTooFar()
            {
                var cycles = new int[] { 2, 0, 4, };

                DenseVector vector = new Scalar[] { 0, 1, 2, };

                CheckThrow(typeof(Exception));
                DenseVector.BackPermuteFromCycles(vector, cycles);
            }

            public void PermutationDuplicate()
            {
                var cycles = new int[] { 2, 0, 1, 2, 2, 0, };

                DenseVector vector = new Scalar[] { 0, 1, 2, };

                CheckThrow(typeof(Exception));
                DenseVector.BackPermuteFromCycles(vector, cycles);
            }

            public void PermutationNegative()
            {
                var cycles = new int[] { 2, 0, -1, };

                DenseVector vector = new Scalar[] { 0, 1, 2, };

                CheckThrow(typeof(Exception));
                DenseVector.BackPermuteFromCycles(vector, cycles);
            }

            public void PermutationNegativeLength()
            {
                var cycles = new int[] { 2, 0, 1, -1, 2, };

                DenseVector vector = new Scalar[] { 0, 1, 2, };

                CheckThrow(typeof(Exception));
                DenseVector.BackPermuteFromCycles(vector, cycles);
            }

            public void PermutationLongLength()
            {
                var cycles = new int[] { 20, 0, 1, 2, };

                DenseVector vector = new Scalar[] { 0, 1, 2, };

                CheckThrow(typeof(Exception));
                DenseVector.BackPermuteFromCycles(vector, cycles);
            }
        }

        public class BackPermuteFromCycles : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(
                () => (new DenseVector()).BackPermuteFromCycles((IList<int>)null));

            public void Identity()
            {
                var cycles = new int[] { };

                DenseVector vector = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, };
                DenseVector expected = vector.Clone();

                vector.BackPermuteFromCycles(cycles);

                CheckEqual(expected, vector);
            }

            public void Identity_0s()
            {
                var cycles = new int[] { 0, 1, 2, 3, 4, 5, };

                DenseVector vector = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, };
                DenseVector expected = vector.Clone();

                vector.BackPermuteFromCycles(cycles);

                CheckEqual(expected, vector);
            }

            public void Reverse()
            {
                var cycles = new int[] { 2, 0, 6, 2, 1, 5, 2, 2, 4, };

                DenseVector vector = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, };
                DenseVector expected = new Scalar[] { 6, 5, 4, 3, 2, 1, 0, };

                vector.BackPermuteFromCycles(cycles);

                CheckEqual(expected, vector);
            }

            public void CycleShift()
            {
                var cycles = new int[] { 7, 6, 0, 1, 2, 3, 4, 5, };

                DenseVector vector = new Scalar[] { 1, 2, 3, 4, 5, 6, 0, };
                DenseVector expected = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, };

                vector.BackPermuteFromCycles(cycles);

                CheckEqual(expected, vector);
            }

            public void EmptyVector()
            {
                var cycles = new int[] { };

                DenseVector vector = new Scalar[] { };
                DenseVector expected = new Scalar[] { };

                vector.BackPermuteFromCycles(cycles);

                CheckEqual(expected, vector);
            }

            public void PermutationIndexTooFar()
            {
                var cycles = new int[] { 2, 0, 4, };

                DenseVector vector = new Scalar[] { 0, 1, 2, };

                CheckThrow(typeof(Exception));
                DenseVector.BackPermuteFromCycles(vector, cycles);
            }

            public void PermutationDuplicate()
            {
                var cycles = new int[] { 2, 0, 1, 2, 2, 0, };

                DenseVector vector = new Scalar[] { 0, 1, 2, };

                CheckThrow(typeof(Exception));
                vector.BackPermuteFromCycles(cycles);
            }

            public void PermutationNegative()
            {
                var cycles = new int[] { 2, 0, -1, };

                DenseVector vector = new Scalar[] { 0, 1, 2, };

                CheckThrow(typeof(Exception));
                vector.BackPermuteFromCycles(cycles);
            }

            public void PermutationNegativeLength()
            {
                var cycles = new int[] { 2, 0, 1, -1, 2, };

                DenseVector vector = new Scalar[] { 0, 1, 2, };

                CheckThrow(typeof(Exception));
                vector.BackPermuteFromCycles(cycles);
            }

            public void PermutationLongLength()
            {
                var cycles = new int[] { 20, 0, 1, 2, };

                DenseVector vector = new Scalar[] { 0, 1, 2, };

                CheckThrow(typeof(Exception));
                vector.BackPermuteFromCycles(cycles);
            }
        }

        public class Assignment : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.Assignment);

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

                DenseVector expected = new Scalar[] { 3, 4, 5, 6, 7, 8, 9, };

                array1.Assignment(array2);

                CheckEqual(expected, array1);
            }

            public void Offset()
            {
                DenseVector array1 = new Scalar[] { 100, 1, 2, 3, 4, 5, 6, 7, };
                DenseVector array2 = new Scalar[] { 3, 4, 5, 6, 7, 8, 9, };

                DenseVector expected = new Scalar[] { 100, 3, 4, 5, 6, 7, 8, 9, };

                array1.Assignment(array2, startingOffsetThis: 1, subLength: 7);

                CheckEqual(expected, array1);
            }

            public void OffsetA()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector array2 = new Scalar[] { 100, 3, 4, 5, 6, 7, 8, 9, };

                DenseVector expected = new Scalar[] { 3, 4, 5, 6, 7, 8, 9, };

                array1.Assignment(array2, startingOffsetOther: 1, subLength: 7);

                CheckEqual(expected, array1);
            }

            public void Length()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 101, 102, };
                DenseVector array2 = new Scalar[] { 3, 4, 5, 6, 7, 8, 9, 103, };

                DenseVector expected = new Scalar[] { 3, 4, 5, 6, 7, 8, 9, 101, 102, };

                array1.Assignment(array2, subLength: 7);

                CheckEqual(expected, array1);
            }
        }

        public class AssignmentInterleave : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.AssignmentInterleave);

            public void x22()
            {
                DenseVector even = new Scalar[] { 1, 3, };
                DenseVector odd = new Scalar[] { 2, 4 };

                DenseVector actual = new DenseVector(4);

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

                actual.AssignmentInterleave(even, odd);

                CheckEqual(expected, actual);
            }

            public void x32()
            {
                DenseVector even = new Scalar[] { 1, 3, 5, };
                DenseVector odd = new Scalar[] { 2, 4 };

                DenseVector actual = new DenseVector(5);

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

                actual.AssignmentInterleave(even, odd);

                CheckEqual(expected, actual);
            }

            public void x23()
            {
                DenseVector even = new Scalar[] { 1, 3, };
                DenseVector odd = new Scalar[] { 2, 4, 5, };

                DenseVector actual = new DenseVector(5);

                CheckThrow(typeof(Exception));
                actual.AssignmentInterleave(even, odd);
            }

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

                CheckThrow(typeof(Exception));
                vector.AssignmentInterleave(vector, vector);
            }

            public void InToEven_x4()
            {
                DenseVector vector = new Scalar[] { 1, 3, 0, 0 };

                DenseVector odd = new Scalar[] { 2, 4, };

                vector.AssignmentInterleave(vector, odd);

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

                CheckEqual(expected, vector);
            }

            public void InToEven_x5()
            {
                DenseVector vector = new Scalar[] { 1, 3, 5, 0, 0 };

                DenseVector odd = new Scalar[] { 2, 4, };

                vector.AssignmentInterleave(vector, odd);

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

                CheckEqual(expected, vector);
            }

            public void InToOdd_x4()
            {
                DenseVector vector = new Scalar[] { 2, 4, 0, 0 };

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

                vector.AssignmentInterleave(even, vector);

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

                CheckEqual(expected, vector);
            }

            public void Offset()
            {
                DenseVector even = new Scalar[] { 1, 3, };
                DenseVector odd = new Scalar[] { 2, 4 };

                DenseVector actual = new Scalar[] { 100, 101, 102, 103, 104, };

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

                actual.AssignmentInterleave(even, odd, startingOffsetThis: 1, subLength: 4);

                CheckEqual(expected, actual);
            }

            public void OffsetA()
            {
                DenseVector even = new Scalar[] { 100, 1, 3, };
                DenseVector odd = new Scalar[] { 2, 4 };

                DenseVector actual = new Scalar[] { 101, 102, 103, 104, };

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

                actual.AssignmentInterleave(even, odd, startingOffsetEven: 1, subLength: 4);

                CheckEqual(expected, actual);
            }

            public void OffsetB()
            {
                DenseVector even = new Scalar[] { 1, 3, };
                DenseVector odd = new Scalar[] { 100, 2, 4 };

                DenseVector actual = new Scalar[] { 101, 102, 103, 104, };

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

                actual.AssignmentInterleave(even, odd, startingOffsetOdd: 1, subLength: 4);

                CheckEqual(expected, actual);
            }

            public void Length()
            {
                DenseVector even = new Scalar[] { 1, 3, 110, 111, };
                DenseVector odd = new Scalar[] { 2, 4, 112, 113, };

                DenseVector actual = new Scalar[] { 101, 102, 103, 104, 105, 106, };

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

                actual.AssignmentInterleave(even, odd, subLength: 4);

                CheckEqual(expected, actual);
            }
        }

        public class DeinterleaveTests : TestFixture, ITestFixture
        {
            private static class MethodInfoFinder
            {
                private static DenseVector x = null;
                public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                    () => DenseVector.Deinterleave(x, ref x, ref x, (int)0, (int)0, (int)0, (int?)0));
            }

            public MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;

            public void VeryLong()
            {
                // The number of elements is chose so that it exercises every branch at least once.
                var x = new DenseVector(new Scalar[] {
                     0,  1,  2,  3,  4,  5,  6,  7,
                     8,  9, 10, 11, 12, 13, 14, 15,
                    16, 17, 18, 19, 20, 21, 22,
                });

                var even = new DenseVector(12);
                var odd = new DenseVector(11);

                var expectedX = new DenseVector(new Scalar[] {
                     0,  1,  2,  3,  4,  5,  6,  7,
                     8,  9, 10, 11, 12, 13, 14, 15,
                    16, 17, 18, 19, 20, 21, 22,
                });

                var expectedEven = new DenseVector(new Scalar[] {
                    0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22,
                });

                var expectedOdd = new DenseVector(new Scalar[] {
                    1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21,
                });

                DenseVector.Deinterleave(x, ref even, ref odd);

                CheckEqual(expectedX, x);
                CheckEqual(expectedEven, even);
                CheckEqual(expectedOdd, odd);
            }

            public void SourceIsEvenArray()
            {
                var x = new DenseVector(new Scalar[] {
                     0,  1,  2,  3,  4,  5,  6,  7,
                     8,  9, 10, 11, 12, 13, 14, 15,
                    16, 17, 18, 19, 20, 21, 22,
                });

                var odd = new DenseVector(11);

                var expectedX = new DenseVector(new Scalar[] {
                     0,   2,  4,  6,  8, 10, 12, 14,
                     16, 18, 20, 22, 12, 13, 14, 15,
                     16, 17, 18, 19, 20, 21, 22,
                });

                var expectedOdd = new DenseVector(new Scalar[] {
                    1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21,
                });

                DenseVector.Deinterleave(x, ref x, ref odd, subLength: 23);

                CheckEqual(expectedX, x);
                CheckEqual(expectedOdd, odd);
            }

            public void SourceIsOddArray()
            {
                var x = new DenseVector(new Scalar[] {
                     0,  1,  2,  3,  4,  5,  6,  7,
                     8,  9, 10, 11, 12, 13, 14, 15,
                    16, 17, 18, 19, 20, 21, 22,
                });

                var even = new DenseVector(12);

                var expectedX = new DenseVector(new Scalar[] {
                    1, 3, 5, 7,
                    9, 11, 13, 15,
                    17, 19, 21,

                    11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
                });

                var expectedEven = new DenseVector(new Scalar[] {
                    0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22,
                });

                DenseVector.Deinterleave(x, ref even, ref x, subLength: 23);

                CheckEqual(expectedX, x);
                CheckEqual(expectedEven, even);
            }

            public void SourceIsEvenArray_Offset1()
            {
                var x = new DenseVector(new Scalar[] {
                     0,  1,  2,  3,  4,  5,  6,  7,
                     8,  9, 10, 11, 12, 13, 14, 15,
                    16, 17, 18, 19, 20, 21, 22,
                });

                var odd = new DenseVector(11);

                var expectedX = new DenseVector(new Scalar[] {
                     0,

                     0,   2,  4,  6,  8, 10, 12, 14,
                     16, 18, 20, 22,

                     13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
                });

                var expectedOdd = new DenseVector(new Scalar[] {
                    1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21,
                });

                DenseVector.Deinterleave(x, ref x, ref odd, startingOffsetEven: 1, subLength: 23);

                CheckEqual(expectedX, x);
                CheckEqual(expectedOdd, odd);
            }

            public void SourceIsEvenArray_Offset2()
            {
                var x = new DenseVector(new Scalar[] {
                     0,  1,  2,  3,  4,  5,  6,  7,
                     8,  9, 10, 11, 12, 13, 14, 15,
                    16, 17, 18, 19, 20, 21, 22,
                });

                var odd = new DenseVector(11);

                CheckThrow(typeof(ArgumentException));
                DenseVector.Deinterleave(x, ref x, ref odd, startingOffsetEven: 2, subLength: 23);
            }

            public void SourceIsOddArray_Offset1()
            {
                var x = new DenseVector(new Scalar[] {
                     0,  1,  2,  3,  4,  5,  6,  7,
                     8,  9, 10, 11, 12, 13, 14, 15,
                    16, 17, 18, 19, 20, 21, 22,
                });

                var even = new DenseVector(12);

                var expectedX = new DenseVector(new Scalar[] {
                    0,
                    1, 3, 5, 7,
                    9, 11, 13, 15,
                    17, 19, 21,

                    12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
                });

                var expectedEven = new DenseVector(new Scalar[] {
                    0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22,
                });

                DenseVector.Deinterleave(x, ref even, ref x, startingOffsetOdd: 1, subLength: 23);

                CheckEqual(expectedX, x);
                CheckEqual(expectedEven, even);
            }

            public void SourceIsOddArray_Offset2()
            {
                var x = new DenseVector(new Scalar[] {
                     0,  1,  2,  3,  4,  5,  6,  7,
                     8,  9, 10, 11, 12, 13, 14, 15,
                    16, 17, 18, 19, 20, 21, 22,
                });

                var even = new DenseVector(12);

                CheckThrow(typeof(ArgumentException));
                DenseVector.Deinterleave(x, ref even, ref x, startingOffsetOdd: 2, subLength: 23);
            }

            public void EvenOddArraysAreTheSame_EvenThenOdd()
            {
                var x = new DenseVector(new Scalar[] {
                     0,  1,  2,  3,  4,  5,  6,  7,
                     8,  9, 10, 11, 12, 13, 14, 15,
                    16, 17, 18, 19, 20, 21, 22,
                });

                var evenOdd = new DenseVector(23);

                var expectedX = new DenseVector(new Scalar[] {
                     0,  1,  2,  3,  4,  5,  6,  7,
                     8,  9, 10, 11, 12, 13, 14, 15,
                    16, 17, 18, 19, 20, 21, 22,
                });

                var expectedEvenOdd = new DenseVector(new Scalar[] {
                    0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22,
                    1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21,
                });

                DenseVector.Deinterleave(x, ref evenOdd, ref evenOdd, startingOffsetOdd: 12, subLength: 23);

                CheckEqual(expectedX, x);
                CheckEqual(expectedEvenOdd, evenOdd);
            }

            public void EvenOddArraysAreTheSame_OddThenEven()
            {
                var x = new DenseVector(new Scalar[] {
                     0,  1,  2,  3,  4,  5,  6,  7,
                     8,  9, 10, 11, 12, 13, 14, 15,
                    16, 17, 18, 19, 20, 21, 22,
                });

                var evenOdd = new DenseVector(23);

                var expectedX = new DenseVector(new Scalar[] {
                     0,  1,  2,  3,  4,  5,  6,  7,
                     8,  9, 10, 11, 12, 13, 14, 15,
                    16, 17, 18, 19, 20, 21, 22,
                });

                var expectedEvenOdd = new DenseVector(new Scalar[] {
                    1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21,
                    0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22,
                });

                DenseVector.Deinterleave(x, ref evenOdd, ref evenOdd, startingOffsetEven: 11, subLength: 23);

                CheckEqual(expectedX, x);
                CheckEqual(expectedEvenOdd, evenOdd);
            }

            public void EvenOddArraysAreTheSame_WouldOverwriteOdd()
            {
                var x = new DenseVector(new Scalar[] {
                     0,  1,  2,  3,  4,  5,  6,  7,
                     8,  9, 10, 11, 12, 13, 14, 15,
                    16, 17, 18, 19, 20, 21, 22,
                });

                var evenOdd = new DenseVector(23);

                CheckThrow(typeof(ArgumentException));
                DenseVector.Deinterleave(x, ref evenOdd, ref evenOdd, startingOffsetOdd: 11, subLength: 23);
            }

            public void EvenOddArraysAreTheSame_WouldOverwriteEven()
            {
                var x = new DenseVector(new Scalar[] {
                     0,  1,  2,  3,  4,  5,  6,  7,
                     8,  9, 10, 11, 12, 13, 14, 15,
                    16, 17, 18, 19, 20, 21, 22,
                });

                var evenOdd = new DenseVector(23);

                CheckThrow(typeof(ArgumentException));
                DenseVector.Deinterleave(x, ref evenOdd, ref evenOdd, startingOffsetOdd: 10, subLength: 23);
            }

            public void StartingOffsetSourceNegative()
            {
                var x = new DenseVector(new Scalar[] {
                     0,  1,  2,  3,  4,  5,  6,  7,
                });

                var even = new DenseVector(4);
                var odd = new DenseVector(4);

                CheckThrow(typeof(Exception));
                DenseVector.Deinterleave(x, ref even, ref odd, startingOffsetInterleaved: -1);
            }

            public void StartingOffsetSourceTooLarge()
            {
                var x = new DenseVector(new Scalar[] {
                     0,  1,  2,  3,  4,  5,  6,  7,
                });

                var even = new DenseVector(4);
                var odd = new DenseVector(4);

                CheckThrow(typeof(Exception));
                DenseVector.Deinterleave(x, ref even, ref odd, startingOffsetInterleaved: 9, subLength: 0);
            }

            public void StartingOffsetEvenNegative()
            {
                var x = new DenseVector(new Scalar[] {
                     0,  1,  2,  3,  4,  5,  6,  7,
                });

                var even = new DenseVector(4);
                var odd = new DenseVector(4);

                CheckThrow(typeof(Exception));
                DenseVector.Deinterleave(x, ref even, ref odd, startingOffsetEven: -1);

            }

            public void StartingOffsetEvenTooLarge()
            {
                var x = new DenseVector(new Scalar[] {
                     0,  1,  2,  3,  4,  5,  6,  7,
                });

                var even = new DenseVector(4);
                var odd = new DenseVector(4);

                CheckThrow(typeof(Exception));
                DenseVector.Deinterleave(x, ref even, ref odd, startingOffsetEven: 5, subLength: 0);
            }

            public void StartingOffsetOddNegative()
            {
                var x = new DenseVector(new Scalar[] {
                     0,  1,  2,  3,  4,  5,  6,  7,
                });

                var even = new DenseVector(4);
                var odd = new DenseVector(4);

                CheckThrow(typeof(Exception));
                DenseVector.Deinterleave(x, ref even, ref odd, startingOffsetOdd: -1);
            }

            public void StartingOffsetOddTooLarge()
            {
                var x = new DenseVector(new Scalar[] {
                     0,  1,  2,  3,  4,  5,  6,  7,
                });

                var even = new DenseVector(4);
                var odd = new DenseVector(4);

                CheckThrow(typeof(Exception));
                DenseVector.Deinterleave(x, ref even, ref odd, startingOffsetOdd: 5, subLength: 0);
            }

            public void RunLengthNegative()
            {
                var x = new DenseVector(new Scalar[] {
                     0,  1,  2,  3,  4,  5,  6,  7,
                });

                var even = new DenseVector(4);
                var odd = new DenseVector(4);

                CheckThrow(typeof(Exception));
                DenseVector.Deinterleave(x, ref even, ref odd, subLength: -1);
            }

            public void RunLengthTooLarge()
            {
                var x = new DenseVector(new Scalar[] {
                     0,  1,  2,  3,  4,  5,  6,  7,
                });

                var even = new DenseVector(4);
                var odd = new DenseVector(4);

                CheckThrow(typeof(Exception));
                DenseVector.Deinterleave(x, ref even, ref odd, subLength: 9);
            }
        }

        public class FlushTests : BlasBoundsFixture
        {
            private static class MethodInfoFinder
            {
                private static DenseVector x = null;
                public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                    () => x.Flush((Scalar)0, (int)0, (int?)null));
            }

            public override MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;

            public void Basic()
            {
                DenseVector values = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector expected = new Scalar[] { -2, -2, -2, -2, -2, -2, -2, };

                values.Flush(-2);

                CheckEqual(expected, values);
            }

            public void Offset()
            {
                DenseVector values = new Scalar[] { 100, 1, 2, 3, 4, 5, 6, 7, };
                DenseVector expected = new Scalar[] { 100, -2, -2, -2, -2, -2, -2, -2, };

                values.Flush(-2, startingOffset: 1, subLength: 7);

                CheckEqual(expected, values);
            }

            public void Length()
            {
                DenseVector values = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 100, };
                DenseVector expected = new Scalar[] { -2, -2, -2, -2, -2, -2, -2, 100, };

                values.Flush(-2, subLength: 7);

                CheckEqual(expected, values);
            }
        }

        public class FlushComplexInterleaved : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.FlushComplexInterleaved);
            public override int OperationStride => 2;

            public void Basic()
            {
                var x = new DenseVector(22);
                x.FlushComplexInterleaved((3, 4));

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

                CheckEqual(expected, x);
            }

            public void Offset()
            {
                var x = new DenseVector(23);
                x[0] = 100;
                x.FlushComplexInterleaved((3, 4), startingOffset: 1);

                var expected = new DenseVector(new Scalar[] {
                    100, 3, 4, 3, 4, 3, 4, 3, 4,
                    3, 4, 3, 4, 3, 4, 3, 4,
                    3, 4, 3, 4, 3, 4,
                });

                CheckEqual(expected, x);
            }

            public void Length()
            {
                var x = new DenseVector(23);
                x.Flush(100);
                x.FlushComplexInterleaved((3, 4), subLength: 10);

                var expected = new DenseVector(new Scalar[] {
                    3, 4, 3, 4, 3, 4, 3, 4,
                    3, 4, 3, 4, 3, 4, 3, 4,
                    3, 4, 3, 4, 100, 100, 100,
                });

                CheckEqual(expected, x);
            }
        }

        public class Flush4 : BlasBoundsFixture
        {
            public override MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(
                () => (new DenseVector()).Flush(default(Vector4), (int)0, (int?)0));

            public void Basic()
            {
                var x = new DenseVector(new Scalar[]
                {
                    2, 3, 4, 5, 6, 7, 8, 9,
                });

                var pattern = new Vector4(5, 4, 3, 2);

                x.Flush(pattern);

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

                CheckEqual(expected, x);
            }

            public void Sub4Length()
            {
                var x = new DenseVector(new Scalar[]
                {
                    2, 3, 4, 5, 6, 7, 8,
                });

                var pattern = new Vector4(5, 4, 3, 2);

                x.Flush(pattern);

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

                CheckEqual(expected, x);
            }

            public void StartingOffset()
            {
                DenseVector x = new Scalar[] { 100, 1, 2, 3, 4, 5, 6, 7, };

                var pattern = new Vector4(5, 4, 3, 2);

                x.Flush(pattern, startingOffset: 1, subLength: 7);

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

                CheckEqual(expected, x);
            }

            public void Length()
            {
                DenseVector x = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 100, };

                var pattern = new Vector4(5, 4, 3, 2);

                x.Flush(pattern, subLength: 7);

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

                CheckEqual(expected, x);
            }
        }

        public class NegateTests : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.Negate);

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

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

            public void Offset()
            {
                DenseVector x = new DenseVector(new Scalar[] { 1, 2, -3, 4, 0, });
                DenseVector expected = new DenseVector(new Scalar[] { 1, 2, 3, -4, 0, });

                x.Negate(startingIndex: 2, subLength: 3);
                CheckEqual(expected, x);
            }

            public void Length()
            {
                DenseVector x = new DenseVector(new Scalar[] { 1, 2, -3, 4, 0, });
                DenseVector expected = new DenseVector(new Scalar[] { -1, -2, 3, 4, 0, });

                x.Negate(subLength: 3);
                CheckEqual(expected, x);
            }
        }

        public class Scale : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.Scale);

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

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

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

                x.Scale(-2.0, startingIndex: 2, subLength: 3);
                CheckEqual(expected, x);
            }

            public void Length()
            {
                DenseVector x = new Scalar[] { 1, 2, -3, 4, 0, };
                DenseVector expected = new Scalar[] { -2, -4, 6, 4, 0, };

                x.Scale(-2.0, subLength: 3);
                CheckEqual(expected, x);
            }
        }

        public class AssignmentScale : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.AssignmentScale);

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

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

            public void OffsetThis()
            {
                DenseVector x = new Scalar[] { 1, 2, -3, 4, 0, };
                DenseVector expected = new Scalar[] { 100, -2, -4, 6, -8, 0, };
                DenseVector actual = new DenseVector(6);
                actual[0] = 100;

                actual.AssignmentScale(x, -2.0, startingOffsetThis: 1, subLength: 5);
                CheckEqual(expected, actual);
            }

            public void OffsetA()
            {
                DenseVector x = new Scalar[] { 100, 1, 2, -3, 4, 0, };
                DenseVector expected = new Scalar[] { -2, -4, 6, -8, 0, };
                DenseVector actual = new DenseVector(5);

                actual.AssignmentScale(x, -2.0, startingOffsetA: 1, subLength: 5);
                CheckEqual(expected, actual);
            }

            public void Length()
            {
                DenseVector x = new Scalar[] { 1, 2, -3, 4, 0, };
                DenseVector expected = new Scalar[] { -2, -4, 6, -8, 0, 100, };
                DenseVector actual = new DenseVector(6);
                actual[5] = 100;

                actual.AssignmentScale(x, -2.0, subLength: 5);
                CheckEqual(expected, actual);
            }
        }

        public class ScaleComplexInterleaved : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.ScaleComplexInterleaved);
            public override int OperationStride => 2;

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

                Complex scalar = (3, 4);

                x.ScaleComplexInterleaved(scalar);

                var expected = new DenseVector(new Scalar[] {
                    -4, 3, -6, 17, -8, 31, -10, 45,
                    -12, 59, -4, 3, -6, 17, -8, 31,
                    -10, 45, -12, 59, -4, 3
                });

                CheckEqual(expected, x);
            }

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

                Complex scalar = (3, 4);

                x.ScaleComplexInterleaved(scalar, startingIndexThis: 1);

                var expected = new DenseVector(new Scalar[] {
                    100, -4, 3, -6, 17, -8, 31, -10, 45,
                    -12, 59, -4, 3, -6, 17, -8, 31,
                    -10, 45, -12, 59, -4, 3
                });

                CheckEqual(expected, x);
            }

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

                Complex scalar = (3, 4);

                x.ScaleComplexInterleaved(scalar, subLength: 10);

                var expected = new DenseVector(new Scalar[] {
                    -4, 3, -6, 17, -8, 31, -10, 45,
                    -12, 59, -4, 3, -6, 17, -8, 31,
                    -10, 45, -12, 59, 99, 100,
                });

                CheckEqual(expected, x);
            }
        }

        public class AssignmentScaleComplexInterleaved : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.AssignmentScaleComplexInterleaved);
            public override int OperationStride => 2;

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

                Complex scalar = (3, 4);

                var y = new DenseVector(22);

                y.AssignmentScaleComplexInterleaved(x, scalar);

                var expected = new DenseVector(new Scalar[] {
                    -4, 3, -6, 17, -8, 31, -10, 45,
                    -12, 59, -4, 3, -6, 17, -8, 31,
                    -10, 45, -12, 59, -4, 3
                });

                CheckEqual(expected, y);
            }

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

                Complex scalar = (3, 4);

                var y = new DenseVector(22);

                y.AssignmentScaleComplexInterleaved(x, scalar);

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

                CheckEqual(expected, x);
            }

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

                Complex scalar = (3, 4);

                var y = new DenseVector(23);
                y[0] = 100;

                y.AssignmentScaleComplexInterleaved(x, scalar, startingIndexThis: 1);

                var expected = new DenseVector(new Scalar[] {
                    100, -4, 3, -6, 17, -8, 31, -10, 45,
                    -12, 59, -4, 3, -6, 17, -8, 31,
                    -10, 45, -12, 59, -4, 3
                });

                CheckEqual(expected, y);
            }

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

                Complex scalar = (3, 4);

                var y = new DenseVector(22);

                y.AssignmentScaleComplexInterleaved(x, scalar, startingIndexOther: 1);

                var expected = new DenseVector(new Scalar[] {
                    -4, 3, -6, 17, -8, 31, -10, 45,
                    -12, 59, -4, 3, -6, 17, -8, 31,
                    -10, 45, -12, 59, -4, 3
                });

                CheckEqual(expected, y);
            }

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

                Complex scalar = (3, 4);

                var y = new DenseVector(22);
                y[20] = 99;
                y[21] = 100;

                y.AssignmentScaleComplexInterleaved(x, scalar, subLength: 10);

                var expected = new DenseVector(new Scalar[] {
                    -4, 3, -6, 17, -8, 31, -10, 45,
                    -12, 59, -4, 3, -6, 17, -8, 31,
                    -10, 45, -12, 59, 99, 100,
                });

                CheckEqual(expected, y);
            }
        }

        public class Subtract : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.Subtract);

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

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

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

                s1.Subtract(s2, startingIndexThis: 1, subLength: 7);
                CheckEqual(expected, s1);
            }

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

                s1.Subtract(s2, startingIndexOther: 1, subLength: 7);
                CheckEqual(expected, s1);
            }

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

                s1.Subtract(s2, subLength: 7);
                CheckEqual(expected, s1);
            }
        }

        public class AssignmentSubtract : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.AssignmentSub);

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

                z.AssignmentSub(s1, s2);
                CheckEqual(expected, z);
            }

            public void Offset()
            {
                DenseVector s1 = new Scalar[] { 1, 2, -3, 4, 0, 1, 2, };
                DenseVector s2 = new Scalar[] { 1, 1, 1, 1, -1, 2, 4,};
                DenseVector z = new DenseVector(8);
                z[0] = 100;
                DenseVector expected = new Scalar[] { 100, 0, 1, -4, 3, 1, -1, -2 };

                z.AssignmentSub(s1, s2, startingOffsetThis: 1, subLength: 7);
                CheckEqual(expected, z);
            }

            public void OffsetA()
            {
                DenseVector s1 = new Scalar[] { 100, 1, 2, -3, 4, 0, 1, 2, };
                DenseVector s2 = new Scalar[] { 1, 1, 1, 1, -1, 2, 4,};
                DenseVector z = new DenseVector(7);
                DenseVector expected = new Scalar[] { 0, 1, -4, 3, 1, -1, -2 };

                z.AssignmentSub(s1, s2, startingOffsetA: 1, subLength: 7);
                CheckEqual(expected, z);
            }

            public void OffsetB()
            {
                DenseVector s1 = new Scalar[] { 1, 2, -3, 4, 0, 1, 2, };
                DenseVector s2 = new Scalar[] { 100, 1, 1, 1, 1, -1, 2, 4,};
                DenseVector z = new DenseVector(7);
                DenseVector expected = new Scalar[] { 0, 1, -4, 3, 1, -1, -2 };

                z.AssignmentSub(s1, s2, startingOffsetB: 1, subLength: 7);
                CheckEqual(expected, z);
            }

            public void Length()
            {
                DenseVector s1 = new Scalar[] { 1, 2, -3, 4, 0, 1, 2, 103, 104, };
                DenseVector s2 = new Scalar[] { 1, 1, 1, 1, -1, 2, 4, 102, };
                DenseVector z = new DenseVector(8);
                z[7] = 100;
                DenseVector expected = new Scalar[] { 0, 1, -4, 3, 1, -1, -2, 100};

                z.AssignmentSub(s1, s2, subLength: 7);
                CheckEqual(expected, z);
            }
        }

        public class SubtractConjugateComplexInterleaved : BlasBoundsFixture
        {
            private static class MethodInfoFinder
            {
                private static DenseVector x = null;
                public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                    () => x.SubtractConjugateComplexInterleaved(x, (int)0, (int)0, (int?)null));
            }

            public override MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;
            public override int OperationStride => 2;

            public void Works()
            {
                var x = new DenseVector(new Scalar[] {
                    1, 2, -3, 4, 0, 1, 2, 3,
                    4, 5, 6, 7, 8, 9, 10, 11,
                    12, 13, 14, 15, 16, 17,
                });

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

                x.SubtractConjugateComplexInterleaved(y);

                DenseVector expected = new Scalar[] {
                    0, 1, -4, 3, 1, -1, -2, -3,
                    6, 9, 12, 15, 8, 8, 8, 8,
                    6, 8, 10, 12, 14, 16
                };

                CheckEqual(expected, x);
            }

            public void StartingOffset()
            {
                var x = new DenseVector(new Scalar[] {
                    100, 1, 2, -3, 4, 0, 1, 2, 3,
                    4, 5, 6, 7, 8, 9, 10, 11,
                    12, 13, 14, 15, 16, 17,
                });

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

                x.SubtractConjugateComplexInterleaved(y, startingIndexThis: 1, subLength: 11);

                DenseVector expected = new Scalar[] {
                    100, 0, 1, -4, 3, 1, -1, -2, -3,
                    6, 9, 12, 15, 8, 8, 8, 8,
                    6, 8, 10, 12, 14, 16
                };

                CheckEqual(expected, x);
            }

            public void StartingOffsetOther()
            {
                var x = new DenseVector(new Scalar[] {
                    1, 2, -3, 4, 0, 1, 2, 3,
                    4, 5, 6, 7, 8, 9, 10, 11,
                    12, 13, 14, 15, 16, 17,
                });

                var y = new DenseVector(new Scalar[] {
                    100, 1, -1, 1, -1, -1, -2, 4, -6,
                    -2, 4, -6, 8, 0, -1, 2, -3,
                    6, -5, 4, -3, 2, -1,
                });

                x.SubtractConjugateComplexInterleaved(y, startingIndexOther: 1, subLength: 11);

                DenseVector expected = new Scalar[] {
                    0, 1, -4, 3, 1, -1, -2, -3,
                    6, 9, 12, 15, 8, 8, 8, 8,
                    6, 8, 10, 12, 14, 16
                };

                CheckEqual(expected, x);
            }

            public void SubLength()
            {
                var x = new DenseVector(new Scalar[] {
                    1, 2, -3, 4, 0, 1, 2, 3,
                    4, 5, 6, 7, 8, 9, 10, 11,
                    12, 13, 14, 15, 16, 17, 101,
                });

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

                x.SubtractConjugateComplexInterleaved(y, subLength: 11);

                DenseVector expected = new Scalar[] {
                    0, 1, -4, 3, 1, -1, -2, -3,
                    6, 9, 12, 15, 8, 8, 8, 8,
                    6, 8, 10, 12, 14, 16, 101,
                };

                CheckEqual(expected, x);
            }
        }

        public class AssignmentSubtractConjugateComplexInterleaved : BlasBoundsFixture
        {
            private static class MethodInfoFinder
            {
                private static DenseVector x = null;
                public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                    () => x.AssignmentSubtractConjugateComplexInterleaved(x, x, (int)0, (int)0, (int)0, (int?)null));
            }

            public override MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;
            public override int OperationStride => 2;

            public void Works()
            {
                var x = new DenseVector(new Scalar[] {
                    1, 2, -3, 4, 0, 1, 2, 3,
                    4, 5, 6, 7, 8, 9, 10, 11,
                    12, 13, 14, 15, 16, 17,
                });

                var y = new DenseVector(new Scalar[] {
                    1, -1, 1, -1, -1, -2, 4, -6,
                    -2, 4, -6, 8, 0, -1, 2, -3,
                    6, -5, 4, -3, 2, -1,
                });
                var z = new DenseVector(22);

                z.AssignmentSubtractConjugateComplexInterleaved(x, y);

                DenseVector expected = new Scalar[] {
                    0, 1, -4, 3, 1, -1, -2, -3,
                    6, 9, 12, 15, 8, 8, 8, 8,
                    6, 8, 10, 12, 14, 16
                };

                CheckEqual(expected, z);
            }

            public void StartingOffset()
            {
                var x = new DenseVector(new Scalar[] {
                    1, 2, -3, 4, 0, 1, 2, 3,
                    4, 5, 6, 7, 8, 9, 10, 11,
                    12, 13, 14, 15, 16, 17,
                });

                var y = new DenseVector(new Scalar[] {
                    1, -1, 1, -1, -1, -2, 4, -6,
                    -2, 4, -6, 8, 0, -1, 2, -3,
                    6, -5, 4, -3, 2, -1,
                });
                var z = new DenseVector(23);
                z[0] = 100;
                z.AssignmentSubtractConjugateComplexInterleaved(x, y, startingOffsetThis: 1, subLength: 11);

                DenseVector expected = new Scalar[] {
                    100, 0, 1, -4, 3, 1, -1, -2, -3,
                    6, 9, 12, 15, 8, 8, 8, 8,
                    6, 8, 10, 12, 14, 16
                };

                CheckEqual(expected, z);
            }

            public void StartingOffsetA()
            {
                var x = new DenseVector(new Scalar[] {
                    100, 1, 2, -3, 4, 0, 1, 2, 3,
                    4, 5, 6, 7, 8, 9, 10, 11,
                    12, 13, 14, 15, 16, 17,
                });

                var y = new DenseVector(new Scalar[] {
                    1, -1, 1, -1, -1, -2, 4, -6,
                    -2, 4, -6, 8, 0, -1, 2, -3,
                    6, -5, 4, -3, 2, -1,
                });
                var z = new DenseVector(22);

                z.AssignmentSubtractConjugateComplexInterleaved(x, y, startingOffsetA: 1, subLength: 11);

                DenseVector expected = new Scalar[] {
                    0, 1, -4, 3, 1, -1, -2, -3,
                    6, 9, 12, 15, 8, 8, 8, 8,
                    6, 8, 10, 12, 14, 16
                };

                CheckEqual(expected, z);
            }

            public void StartingOffsetB()
            {
                var x = new DenseVector(new Scalar[] {
                    1, 2, -3, 4, 0, 1, 2, 3,
                    4, 5, 6, 7, 8, 9, 10, 11,
                    12, 13, 14, 15, 16, 17,
                });

                var y = new DenseVector(new Scalar[] {
                    100, 1, -1, 1, -1, -1, -2, 4, -6,
                    -2, 4, -6, 8, 0, -1, 2, -3,
                    6, -5, 4, -3, 2, -1,
                });
                var z = new DenseVector(22);

                z.AssignmentSubtractConjugateComplexInterleaved(x, y, startingOffsetB: 1, subLength: 11);

                DenseVector expected = new Scalar[] {
                    0, 1, -4, 3, 1, -1, -2, -3,
                    6, 9, 12, 15, 8, 8, 8, 8,
                    6, 8, 10, 12, 14, 16
                };

                CheckEqual(expected, z);
            }

            public void SubLength()
            {
                var x = new DenseVector(new Scalar[] {
                    1, 2, -3, 4, 0, 1, 2, 3,
                    4, 5, 6, 7, 8, 9, 10, 11,
                    12, 13, 14, 15, 16, 17, 101, 104, 105,
                });

                var y = new DenseVector(new Scalar[] {
                    1, -1, 1, -1, -1, -2, 4, -6,
                    -2, 4, -6, 8, 0, -1, 2, -3,
                    6, -5, 4, -3, 2, -1, 102, 103,
                });
                var z = new DenseVector(23);
                z[22] = 101;

                z.AssignmentSubtractConjugateComplexInterleaved(x, y, subLength: 11);

                DenseVector expected = new Scalar[] {
                    0, 1, -4, 3, 1, -1, -2, -3,
                    6, 9, 12, 15, 8, 8, 8, 8,
                    6, 8, 10, 12, 14, 16, 101,
                };

                CheckEqual(expected, z);
            }
        }

        public class SubtractComplexInterleavedWithReal : BlasBoundsFixture
        {
            private static class MethodInfoFinder
            {
                private static DenseVector x = null;
                public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                    () => x.SubtractComplexInterleavedWithReal(x, (int)0, (int)0, (int?)null));
            }

            public override MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;
            public override int OperationStride => 2;

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

                var y = new DenseVector(new Scalar[] {
                    -8, -9, -10, -11,
                    -1, -2, -3, -4,
                    -5, -6, -7,
                });

                x.SubtractComplexInterleavedWithReal(y);

                DenseVector expected = new Scalar[] {
                    9, 2, 12, 4, 15, 6, 18, 8,
                    10, 0, 2, 1, 5, 3, 8, 5,
                    11, 7, 14, 9, 17, 11,
                };

                CheckEqual(expected, x);
            }

            public void StartingOffset()
            {
                var x = new DenseVector(new Scalar[] {
                    100, 1, 2, 3, 4, 5, 6, 7, 8,
                    9, 0, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11,
                });

                var y = new DenseVector(new Scalar[] {
                    -8, -9, -10, -11,
                    -1, -2, -3, -4,
                    -5, -6, -7,
                });

                x.SubtractComplexInterleavedWithReal(y, startingIndexThis: 1, subLength: 11);

                DenseVector expected = new Scalar[] {
                    100, 9, 2, 12, 4, 15, 6, 18, 8,
                    10, 0, 2, 1, 5, 3, 8, 5,
                    11, 7, 14, 9, 17, 11,
                };

                CheckEqual(expected, x);
            }

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

                var y = new DenseVector(new Scalar[] {
                    100, -8, -9, -10, -11,
                    -1, -2, -3, -4,
                    -5, -6, -7,
                });

                x.SubtractComplexInterleavedWithReal(y, startingIndexA: 1, subLength: 11);

                DenseVector expected = new Scalar[] {
                    9, 2, 12, 4, 15, 6, 18, 8,
                    10, 0, 2, 1, 5, 3, 8, 5,
                    11, 7, 14, 9, 17, 11,
                };

                CheckEqual(expected, x);
            }

            public void SubLength()
            {
                var x = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                    9, 0, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11, 101
                });

                var y = new DenseVector(new Scalar[] {
                    -8, -9, -10, -11,
                    -1, -2, -3, -4,
                    -5, -6, -7,
                });

                x.SubtractComplexInterleavedWithReal(y, subLength: 11);

                DenseVector expected = new Scalar[] {
                    9, 2, 12, 4, 15, 6, 18, 8,
                    10, 0, 2, 1, 5, 3, 8, 5,
                    11, 7, 14, 9, 17, 11, 101
                };

                CheckEqual(expected, x);
            }
        }

        public class AssignmentSubtractComplexInterleavedWithReal : BlasBoundsFixture
        {
            private static class MethodInfoFinder
            {
                private static DenseVector x = null;
                public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                    () => x.AssignmentSubtractComplexInterleavedWithReal(x, x, (int)0, (int)0, (int)0, (int?)null));
            }

            public override MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;
            public override int OperationStride => 2;

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

                var y = new DenseVector(new Scalar[] {
                    -8, -9, -10, -11,
                    -1, -2, -3, -4,
                    -5, -6, -7,
                });
                var z = new DenseVector(22);

                z.AssignmentSubtractComplexInterleavedWithReal(x, y);

                DenseVector expected = new Scalar[] {
                    9, 2, 12, 4, 15, 6, 18, 8,
                    10, 0, 2, 1, 5, 3, 8, 5,
                    11, 7, 14, 9, 17, 11,
                };

                CheckEqual(expected, z);
            }

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

                var y = new DenseVector(new Scalar[] {
                    -8, -9, -10, -11,
                    -1, -2, -3, -4,
                    -5, -6, -7,
                });

                var z = new DenseVector(23);
                z[0] = 100;

                z.AssignmentSubtractComplexInterleavedWithReal(x, y, startingIndexThis: 1, subLength: 11);

                DenseVector expected = new Scalar[] {
                    100, 9, 2, 12, 4, 15, 6, 18, 8,
                    10, 0, 2, 1, 5, 3, 8, 5,
                    11, 7, 14, 9, 17, 11,
                };

                CheckEqual(expected, z);
            }

            public void StartingOffsetA()
            {
                var x = new DenseVector(new Scalar[] {
                    100, 1, 2, 3, 4, 5, 6, 7, 8,
                    9, 0, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11,
                });

                var y = new DenseVector(new Scalar[] {
                    -8, -9, -10, -11,
                    -1, -2, -3, -4,
                    -5, -6, -7,
                });
                var z = new DenseVector(22);

                z.AssignmentSubtractComplexInterleavedWithReal(x, y, startingIndexA: 1, subLength: 11);

                DenseVector expected = new Scalar[] {
                    9, 2, 12, 4, 15, 6, 18, 8,
                    10, 0, 2, 1, 5, 3, 8, 5,
                    11, 7, 14, 9, 17, 11,
                };

                CheckEqual(expected, z);
            }

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

                var y = new DenseVector(new Scalar[] {
                    100, -8, -9, -10, -11,
                    -1, -2, -3, -4,
                    -5, -6, -7,
                });
                var z = new DenseVector(22);

                z.AssignmentSubtractComplexInterleavedWithReal(x, y, startingIndexB: 1, subLength: 11);

                DenseVector expected = new Scalar[] {
                    9, 2, 12, 4, 15, 6, 18, 8,
                    10, 0, 2, 1, 5, 3, 8, 5,
                    11, 7, 14, 9, 17, 11,
                };

                CheckEqual(expected, z);
            }

            public void SubLength()
            {
                var x = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                    9, 0, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11, 102
                });

                var y = new DenseVector(new Scalar[] {
                    -8, -9, -10, -11,
                    -1, -2, -3, -4,
                    -5, -6, -7, 103, 104,
                });
                var z = new DenseVector(23);
                z[22] = 101;

                z.AssignmentSubtractComplexInterleavedWithReal(x, y, subLength: 11);

                DenseVector expected = new Scalar[] {
                    9, 2, 12, 4, 15, 6, 18, 8,
                    10, 0, 2, 1, 5, 3, 8, 5,
                    11, 7, 14, 9, 17, 11, 101
                };

                CheckEqual(expected, z);
            }
        }

        public class AssignmentSubtractRealWithComplexInterleaved : BlasBoundsFixture
        {
            private static class MethodInfoFinder
            {
                private static DenseVector x = null;
                public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                    () => x.AssignmentSubtractRealWithComplexInterleaved(x, x, (int)0, (int)0, (int)0, (int?)null));
            }

            public override MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;
            public override int OperationStride => 2;

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

                var y = new DenseVector(new Scalar[] {
                    -8, -9, -10, -11,
                    -1, -2, -3, -4,
                    -5, -6, -7,
                });
                var z = new DenseVector(22);

                z.AssignmentSubtractRealWithComplexInterleaved(y, x);

                DenseVector expected = new Scalar[] {
                    -9, 2, -12, 4, -15, 6, -18, 8,
                    -10, 0, -2, 1, -5, 3, -8, 5,
                    -11, 7, -14, 9, -17, 11,
                };

                CheckEqual(expected, z);
            }

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

                var y = new DenseVector(new Scalar[] {
                    -8, -9, -10, -11,
                    -1, -2, -3, -4,
                    -5, -6, -7,
                });

                var z = new DenseVector(23);
                z[0] = 100;

                z.AssignmentSubtractRealWithComplexInterleaved(y, x, startingIndexThis: 1, subLength: 11);

                DenseVector expected = new Scalar[] {
                    100, -9, 2, -12, 4, -15, 6, -18, 8,
                    -10, 0, -2, 1, -5, 3, -8, 5,
                    -11, 7, -14, 9, -17, 11,
                };

                CheckEqual(expected, z);
            }

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

                var y = new DenseVector(new Scalar[] {
                    100, -8, -9, -10, -11,
                    -1, -2, -3, -4,
                    -5, -6, -7,
                });
                var z = new DenseVector(22);

                z.AssignmentSubtractRealWithComplexInterleaved(y, x, startingIndexA: 1, subLength: 11);

                DenseVector expected = new Scalar[] {
                    -9, 2, -12, 4, -15, 6, -18, 8,
                    -10, 0, -2, 1, -5, 3, -8, 5,
                    -11, 7, -14, 9, -17, 11,
                };

                CheckEqual(expected, z);
            }

            public void StartingOffsetB()
            {
                var x = new DenseVector(new Scalar[] {
                    100, 1, 2, 3, 4, 5, 6, 7, 8,
                    9, 0, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11,
                });

                var y = new DenseVector(new Scalar[] {
                    -8, -9, -10, -11,
                    -1, -2, -3, -4,
                    -5, -6, -7,
                });
                var z = new DenseVector(22);

                z.AssignmentSubtractRealWithComplexInterleaved(y, x, startingIndexB: 1, subLength: 11);

                DenseVector expected = new Scalar[] {
                    -9, 2, -12, 4, -15, 6, -18, 8,
                    -10, 0, -2, 1, -5, 3, -8, 5,
                    -11, 7, -14, 9, -17, 11,
                };

                CheckEqual(expected, z);
            }

            public void SubLength()
            {
                var x = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                    9, 0, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11, 102
                });

                var y = new DenseVector(new Scalar[] {
                    -8, -9, -10, -11,
                    -1, -2, -3, -4,
                    -5, -6, -7, 103, 104,
                });
                var z = new DenseVector(23);
                z[22] = 101;

                z.AssignmentSubtractRealWithComplexInterleaved(y, x, subLength: 11);

                DenseVector expected = new Scalar[] {
                    -9, 2, -12, 4, -15, 6, -18, 8,
                    -10, 0, -2, 1, -5, 3, -8, 5,
                    -11, 7, -14, 9, -17, 11, 101
                };

                CheckEqual(expected, z);
            }
        }

        public class AddScalar : BlasBoundsFixture
        {
            private static class MethodInfoFinder
            {
                private static DenseVector x = null;
                public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                    () => x.Add((Scalar)0, (int)0, (int?)null));
            }

            public override MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;

            public void Basic()
            {
                DenseVector s1 = new Scalar[] { 1, 2, -3, 4, 0, 5, 6, };
                DenseVector expected = new Scalar[] { 8, 9, 4, 11, 7, 12, 13, };

                s1.Add(7);
                CheckEqual(expected, s1);
            }

            public void Offset()
            {
                DenseVector s1 = new Scalar[] { 100, 1, 2, -3, 4, 0, 5, 6, };
                DenseVector expected = new Scalar[] { 100, 8, 9, 4, 11, 7, 12, 13, };

                s1.Add(7, startingOffset: 1, subLength: 7);
                CheckEqual(expected, s1);
            }

            public void Length()
            {
                DenseVector s1 = new Scalar[] { 1, 2, -3, 4, 0, 5, 6, 100, };
                DenseVector expected = new Scalar[] { 8, 9, 4, 11, 7, 12, 13, 100, };

                s1.Add(7, subLength: 7);
                CheckEqual(expected, s1);
            }
        }

        public class AssignmentAddScalar : BlasBoundsFixture
        {
            private static class MethodInfoFinder
            {
                private static DenseVector x = null;
                public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                    () => x.AssignmentAdd(x, (Scalar)0, (int)0, (int)0, (int?)null));
            }

            public override MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;

            public void Basic()
            {
                DenseVector actual = new DenseVector(7);
                DenseVector s1 = new Scalar[] { 1, 2, -3, 4, 0, 5, 6, };
                DenseVector expected = new Scalar[] { 8, 9, 4, 11, 7, 12, 13, };

                actual.AssignmentAdd(s1, 7);
                CheckEqual(expected, actual);
            }

            public void OffsetThis()
            {
                DenseVector actual = new DenseVector(8);
                actual[0] = 100;
                DenseVector s1 = new Scalar[] { 1, 2, -3, 4, 0, 5, 6, };
                DenseVector expected = new Scalar[] { 100, 8, 9, 4, 11, 7, 12, 13, };

                actual.AssignmentAdd(s1, 7, startingOffsetThis: 1, subLength: 7);
                CheckEqual(expected, actual);
            }

            public void OffsetA()
            {
                DenseVector actual = new DenseVector(7);
                DenseVector s1 = new Scalar[] { 100, 1, 2, -3, 4, 0, 5, 6, };
                DenseVector expected = new Scalar[] { 8, 9, 4, 11, 7, 12, 13, };

                actual.AssignmentAdd(s1, 7, startingOffsetA: 1, subLength: 7);
                CheckEqual(expected, actual);
            }

            public void Length()
            {
                DenseVector actual = new DenseVector(8);
                DenseVector s1 = new Scalar[] { 1, 2, -3, 4, 0, 5, 6, 100, };
                DenseVector expected = new Scalar[] { 8, 9, 4, 11, 7, 12, 13, 100, };
                actual[7] = 100;

                actual.AssignmentAdd(s1, 7, subLength: 7);
                CheckEqual(expected, actual);
            }
        }

        public class AddVector4Tests : BlasBoundsFixture
        {
            private static class MethodInfoFinder
            {
                private static DenseVector x = null;
                public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                    () => x.Add(default(Vector4), (int)0, (int?)null));
            }

            public override MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;

            public void Works()
            {
                DenseVector x = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                x.Add(new Vector4(2, 3, 4, 5));

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

                CheckEqual(expected, x);
            }

            public void StartingOffset()
            {
                var x = new DenseVector(new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 8, });
                x.Add(new Vector4(2, 3, 4, 5), startingOffset: 3, subLength: 5);

                var expected = new DenseVector(new Scalar[]
                {
                    1, 2, 3, 6, 8, 10, 12, 10,
                });

                CheckEqual(expected, x);
            }

            public void SubLength()
            {
                var x = new DenseVector(new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 8, });
                x.Add(new Vector4(2, 3, 4, 5), subLength: 3);

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

                CheckEqual(expected, x);
            }
        }

        public class AssignmentAddVector4Tests : BlasBoundsFixture
        {
            private static class MethodInfoFinder
            {
                private static DenseVector x = null;
                public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                    () => x.AssignmentAdd(x, default(Vector4), (int)0, (int)0, (int?)null));
            }

            public override MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;

            public void Works()
            {
                DenseVector actual = new Scalar[7];
                DenseVector x = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                actual.AssignmentAdd(x, new Vector4(2, 3, 4, 5));

                DenseVector expected = new Scalar[] { 3, 5, 7, 9, 7, 9, 11 };

                CheckEqual(expected, actual);
            }

            public void StartingOffset()
            {
                DenseVector actual = new Scalar[8];
                actual[0] = 100;
                DenseVector x = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                actual.AssignmentAdd(x, new Vector4(2, 3, 4, 5), startingOffsetThis: 1, subLength: 7);

                DenseVector expected = new Scalar[] { 100, 3, 5, 7, 9, 7, 9, 11 };

                CheckEqual(expected, actual);
            }

            public void StartingOffsetA()
            {
                DenseVector actual = new Scalar[7];
                DenseVector x = new Scalar[] { 100, 1, 2, 3, 4, 5, 6, 7, };
                actual.AssignmentAdd(x, new Vector4(2, 3, 4, 5), startingOffsetA: 1, subLength: 7);

                DenseVector expected = new Scalar[] { 3, 5, 7, 9, 7, 9, 11 };

                CheckEqual(expected, actual);
            }

            public void Sublength()
            {
                DenseVector actual = new Scalar[8];
                actual[7] = 100;
                DenseVector x = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 101, 102, };
                actual.AssignmentAdd(x, new Vector4(2, 3, 4, 5), subLength: 7);

                DenseVector expected = new Scalar[] { 3, 5, 7, 9, 7, 9, 11, 100 };

                CheckEqual(expected, actual);
            }
        }

        public class AssignmentSubtractVector4Tests : BlasBoundsFixture
        {
            private static class MethodInfoFinder
            {
                private static DenseVector x = null;
                public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                    () => x.AssignmentSubtract(default(Vector4), x, (int)0, (int)0, (int?)null));
            }

            public override MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;

            public void Works()
            {
                DenseVector actual = new Scalar[7];
                DenseVector x = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                actual.AssignmentSubtract(new Vector4(2, 3, 4, 5), x);

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

                CheckEqual(expected, actual);
            }

            public void StartingOffset()
            {
                DenseVector actual = new Scalar[8];
                actual[0] = 100;
                DenseVector x = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                actual.AssignmentSubtract(new Vector4(2, 3, 4, 5), x, startingOffsetThis: 1, subLength: 7);

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

                CheckEqual(expected, actual);
            }

            public void StartingOffsetA()
            {
                DenseVector actual = new Scalar[7];
                DenseVector x = new Scalar[] { 100, 1, 2, 3, 4, 5, 6, 7, };
                actual.AssignmentSubtract(new Vector4(2, 3, 4, 5), x, startingOffsetA: 1, subLength: 7);

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

                CheckEqual(expected, actual);
            }

            public void Sublength()
            {
                DenseVector actual = new Scalar[8];
                actual[7] = 100;
                DenseVector x = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 101, 102, };
                actual.AssignmentSubtract(new Vector4(2, 3, 4, 5), x, subLength: 7);

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

                CheckEqual(expected, actual);
            }
        }

        public class AddVectorTests : BlasBoundsFixture
        {
            private static class MethodInfoFinder
            {
                private static DenseVector x = null;
                public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                    () => x.Add(default(DenseVector), (int)0, (int)0, (int?)null));
            }

            public override MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;

            public void Works()
            {
                DenseVector x = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector y = new Scalar[] { 2, 3, 4, 5, 2, 3, 4, };
                x.Add(y);

                DenseVector expected = new Scalar[] {
                    3, 5, 7, 9, 7, 9, 11,
                };

                CheckEqual(expected, x);
            }

            public void StartingOffset()
            {
                DenseVector x = new Scalar[] { 100, 1, 2, 3, 4, 5, 6, 7, };
                DenseVector y = new Scalar[] { 2, 3, 4, 5, 2, 3, 4, };
                DenseVector expected = new Scalar[] { 100, 3, 5, 7, 9, 7, 9, 11, };
                x.Add(y, startingIndexThis: 1, subLength: 7);

                CheckEqual(expected, x);
            }

            public void StartingOffsetA()
            {
                DenseVector x = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector y = new Scalar[] { 100, 2, 3, 4, 5, 2, 3, 4, };
                DenseVector expected = new Scalar[] { 3, 5, 7, 9, 7, 9, 11, };
                x.Add(y, startingIndexOther: 1, subLength: 7);

                CheckEqual(expected, x);
            }

            public void SubLength()
            {
                DenseVector x = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 101, 102, };
                DenseVector y = new Scalar[] { 2, 3, 4, 5, 2, 3, 4, 100, };
                DenseVector expected = new Scalar[] { 3, 5, 7, 9, 7, 9, 11, 101, 102, };
                x.Add(y, subLength: 7);

                CheckEqual(expected, x);
            }
        }

        public class AddConjugateComplexInterleaved : BlasBoundsFixture
        {
            private static class MethodInfoFinder
            {
                private static DenseVector x = null;
                public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                    () => x.AddConjugateComplexInterleaved(x, (int)0, (int)0, (int?)null));
            }

            public override MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;
            public override int OperationStride => 2;

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

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

                x.AddConjugateComplexInterleaved(y);

                DenseVector expected = new Scalar[] {
                    1,  3,  5,  7, 9, 11, 13, 15,
                    17, 9, 10, 12,  3, 5 , 7, 9,
                    11, 13, 15, 17,  19, 11 
                };

                CheckEqual(expected, x);
            }

            public void StartingOffset()
            {
                var x = new DenseVector(new Scalar[] {
                    100, 1, 2, 3, 4, 5, 6, 7, 8,
                    9, 0, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11,
                });

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

                x.AddConjugateComplexInterleaved(y, startingIndexThis: 1, subLength: 11);

                DenseVector expected = new Scalar[] {
                    100, 1,  3,  5,  7, 9, 11, 13, 15,
                    17, 9, 10, 12,  3, 5 , 7, 9,
                    11, 13, 15, 17,  19, 11 
                };

                CheckEqual(expected, x);
            }

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

                var y = new DenseVector(new Scalar[] {
                    100, 0, -1, 2, -3, 4, -5, 6, -7,
                    8, -9, 10, -11, 1, -2, 3, -4,
                    5, -6, 7, -8, 9, -0,
                });

                x.AddConjugateComplexInterleaved(y, startingIndexOther: 1, subLength: 11);

                DenseVector expected = new Scalar[] {
                    1,  3,  5,  7, 9, 11, 13, 15,
                    17, 9, 10, 12,  3, 5 , 7, 9,
                    11, 13, 15, 17,  19, 11 
                };

                CheckEqual(expected, x);
            }

            public void SubLength()
            {
                var x = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                    9, 0, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11, 101,
                });

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

                x.AddConjugateComplexInterleaved(y, subLength: 11);

                DenseVector expected = new Scalar[] {
                    1,  3,  5,  7, 9, 11, 13, 15,
                    17, 9, 10, 12,  3, 5 , 7, 9,
                    11, 13, 15, 17,  19, 11, 101,
                };

                CheckEqual(expected, x);
            }
        }

        public class AssignmentAddConjugateComplexInterleaved : BlasBoundsFixture
        {
            private static class MethodInfoFinder
            {
                private static DenseVector x = null;
                public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                    () => x.AssignmentAddConjugateComplexInterleaved(x, x, (int)0, (int)0, (int)0, (int?)null));
            }

            public override MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;
            public override int OperationStride => 2;

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

                var y = new DenseVector(new Scalar[] {
                    0, -1, 2, -3, 4, -5, 6, -7,
                    8, -9, 10, -11, 1, -2, 3, -4,
                    5, -6, 7, -8, 9, -0,
                });
                var z = new DenseVector(22);

                z.AssignmentAddConjugateComplexInterleaved(x, y);

                DenseVector expected = new Scalar[] {
                    1,  3,  5,  7, 9, 11, 13, 15,
                    17, 9, 10, 12,  3, 5 , 7, 9,
                    11, 13, 15, 17,  19, 11 
                };

                CheckEqual(expected, z);
            }

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

                var y = new DenseVector(new Scalar[] {
                    0, -1, 2, -3, 4, -5, 6, -7,
                    8, -9, 10, -11, 1, -2, 3, -4,
                    5, -6, 7, -8, 9, -0,
                });
                var z = new DenseVector(23);
                z[0] = 100;

                z.AssignmentAddConjugateComplexInterleaved(x, y, startingOffsetThis: 1, subLength: 11);

                DenseVector expected = new Scalar[] {
                    100, 1,  3,  5,  7, 9, 11, 13, 15,
                    17, 9, 10, 12,  3, 5 , 7, 9,
                    11, 13, 15, 17,  19, 11 
                };

                CheckEqual(expected, z);
            }

            public void StartingOffsetA()
            {
                var x = new DenseVector(new Scalar[] {
                    100, 1, 2, 3, 4, 5, 6, 7, 8,
                    9, 0, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11,
                });

                var y = new DenseVector(new Scalar[] {
                    0, -1, 2, -3, 4, -5, 6, -7,
                    8, -9, 10, -11, 1, -2, 3, -4,
                    5, -6, 7, -8, 9, -0,
                });
                var z = new DenseVector(22);

                z.AssignmentAddConjugateComplexInterleaved(x, y, startingOffsetA: 1, subLength: 11);

                DenseVector expected = new Scalar[] {
                    1,  3,  5,  7, 9, 11, 13, 15,
                    17, 9, 10, 12,  3, 5 , 7, 9,
                    11, 13, 15, 17,  19, 11 
                };

                CheckEqual(expected, z);
            }

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

                var y = new DenseVector(new Scalar[] {
                    100, 0, -1, 2, -3, 4, -5, 6, -7,
                    8, -9, 10, -11, 1, -2, 3, -4,
                    5, -6, 7, -8, 9, -0,
                });
                var z = new DenseVector(22);

                z.AssignmentAddConjugateComplexInterleaved(x, y, startingOffsetB: 1, subLength: 11);

                DenseVector expected = new Scalar[] {
                    1,  3,  5,  7, 9, 11, 13, 15,
                    17, 9, 10, 12,  3, 5 , 7, 9,
                    11, 13, 15, 17,  19, 11 
                };

                CheckEqual(expected, z);
            }

            public void SubLength()
            {
                var x = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                    9, 0, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11, 101,
                });

                var y = new DenseVector(new Scalar[] {
                    0, -1, 2, -3, 4, -5, 6, -7,
                    8, -9, 10, -11, 1, -2, 3, -4,
                    5, -6, 7, -8, 9, -0,
                });
                var z = new DenseVector(23);
                z[22] = 101;

                z.AssignmentAddConjugateComplexInterleaved(x, y, subLength: 11);

                DenseVector expected = new Scalar[] {
                    1,  3,  5,  7, 9, 11, 13, 15,
                    17, 9, 10, 12,  3, 5 , 7, 9,
                    11, 13, 15, 17,  19, 11, 101,
                };

                CheckEqual(expected, z);
            }
        }

        public class AssignmentAddTests : BlasBoundsFixture
        {
            private static class MethodInfoFinder
            {
                private static DenseVector x = null;
                public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                    () => x.AssignmentAdd(x, x, (int)0, (int)0, (int)0, (int?)null));
            }

            public override MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;

            public void Works()
            {
                DenseVector x = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector y = new Scalar[] { 2, 3, 4, 5, 2, 3, 4, };
                DenseVector z = new DenseVector(7);
                z.AssignmentAdd(x, y);

                DenseVector expected = new Scalar[] {
                    3, 5, 7, 9, 7, 9, 11,
                };

                CheckEqual(expected, z);
            }

            public void StartingOffset()
            {
                DenseVector x = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector y = new Scalar[] { 2, 3, 4, 5, 2, 3, 4, };
                DenseVector z = new DenseVector(8);
                z[0] = 100;
                DenseVector expected = new Scalar[] { 100, 3, 5, 7, 9, 7, 9, 11, };
                z.AssignmentAdd(x, y, startingOffsetThis: 1, subLength: 7);

                CheckEqual(expected, z);
            }

            public void StartingOffsetA()
            {
                DenseVector x = new Scalar[] { 100, 1, 2, 3, 4, 5, 6, 7, };
                DenseVector y = new Scalar[] { 2, 3, 4, 5, 2, 3, 4, };
                DenseVector z = new DenseVector(7);
                DenseVector expected = new Scalar[] { 3, 5, 7, 9, 7, 9, 11, };
                z.AssignmentAdd(x, y, startingOffsetA: 1, subLength: 7);

                CheckEqual(expected, z);
            }

            public void StartingOffsetB()
            {
                DenseVector x = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector y = new Scalar[] { 100, 2, 3, 4, 5, 2, 3, 4, };
                DenseVector z = new DenseVector(7);
                DenseVector expected = new Scalar[] { 3, 5, 7, 9, 7, 9, 11, };
                z.AssignmentAdd(x, y, startingOffsetB: 1, subLength: 7);

                CheckEqual(expected, z);
            }

            public void SubLength()
            {
                DenseVector x = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector y = new Scalar[] { 2, 3, 4, 5, 2, 3, 4, };
                DenseVector z = new DenseVector(8);
                z[7] = 100;
                DenseVector expected = new Scalar[] { 3, 5, 7, 9, 7, 9, 11, 100 };
                z.AssignmentAdd(x, y, subLength: 7);

                CheckEqual(expected, z);
            }
        }

        public class AddComplexInterleavedWithReal : BlasBoundsFixture
        {
            private static class MethodInfoFinder
            {
                private static DenseVector x = null;
                public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                    () => x.AddComplexInterleavedWithReal(x, (int)0, (int)0, (int?)null));
            }

            public override MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;
            public override int OperationStride => 2;

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

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

                x.AddComplexInterleavedWithReal(y);

                DenseVector expected = new Scalar[] {
                    9, 2, 12, 4, 15, 6, 18, 8,
                    10, 0, 2, 1, 5, 3, 8, 5,
                    11, 7, 14, 9, 17, 11,
                };

                CheckEqual(expected, x);
            }

            public void StartingOffset()
            {
                var x = new DenseVector(new Scalar[] {
                    100, 1, 2, 3, 4, 5, 6, 7, 8,
                    9, 0, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11,
                });

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

                x.AddComplexInterleavedWithReal(y, startingIndexThis: 1, subLength: 11);

                DenseVector expected = new Scalar[] {
                    100, 9, 2, 12, 4, 15, 6, 18, 8,
                    10, 0, 2, 1, 5, 3, 8, 5,
                    11, 7, 14, 9, 17, 11,
                };

                CheckEqual(expected, x);
            }

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

                var y = new DenseVector(new Scalar[] {
                    100, 8, 9, 10, 11,
                    1, 2, 3, 4,
                    5, 6, 7,
                });

                x.AddComplexInterleavedWithReal(y, startingIndexA: 1, subLength: 11);

                DenseVector expected = new Scalar[] {
                    9, 2, 12, 4, 15, 6, 18, 8,
                    10, 0, 2, 1, 5, 3, 8, 5,
                    11, 7, 14, 9, 17, 11,
                };

                CheckEqual(expected, x);
            }

            public void SubLength()
            {
                var x = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                    9, 0, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11, 101
                });

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

                x.AddComplexInterleavedWithReal(y, subLength: 11);

                DenseVector expected = new Scalar[] {
                    9, 2, 12, 4, 15, 6, 18, 8,
                    10, 0, 2, 1, 5, 3, 8, 5,
                    11, 7, 14, 9, 17, 11, 101
                };

                CheckEqual(expected, x);
            }
        }

        public class AssignmentAddComplexInterleavedWithReal : BlasBoundsFixture
        {
            private static class MethodInfoFinder
            {
                private static DenseVector x = null;
                public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                    () => x.AssignmentAddComplexInterleavedWithReal(x, x, (int)0, (int)0, (int)0, (int?)null));
            }

            public override MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;
            public override int OperationStride => 2;

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

                var y = new DenseVector(new Scalar[] {
                    8, 9, 10, 11,
                    1, 2, 3, 4,
                    5, 6, 7,
                });
                var z = new DenseVector(22);

                z.AssignmentAddComplexInterleavedWithReal(x, y);

                DenseVector expected = new Scalar[] {
                    9, 2, 12, 4, 15, 6, 18, 8,
                    10, 0, 2, 1, 5, 3, 8, 5,
                    11, 7, 14, 9, 17, 11,
                };

                CheckEqual(expected, z);
            }

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

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

                var z = new DenseVector(23);
                z[0] = 100;

                z.AssignmentAddComplexInterleavedWithReal(x, y, startingIndexThis: 1, subLength: 11);

                DenseVector expected = new Scalar[] {
                    100, 9, 2, 12, 4, 15, 6, 18, 8,
                    10, 0, 2, 1, 5, 3, 8, 5,
                    11, 7, 14, 9, 17, 11,
                };

                CheckEqual(expected, z);
            }

            public void StartingOffsetA()
            {
                var x = new DenseVector(new Scalar[] {
                    100, 1, 2, 3, 4, 5, 6, 7, 8,
                    9, 0, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11,
                });

                var y = new DenseVector(new Scalar[] {
                    8, 9, 10, 11,
                    1, 2, 3, 4,
                    5, 6, 7,
                });
                var z = new DenseVector(22);

                z.AssignmentAddComplexInterleavedWithReal(x, y, startingIndexA: 1, subLength: 11);

                DenseVector expected = new Scalar[] {
                    9, 2, 12, 4, 15, 6, 18, 8,
                    10, 0, 2, 1, 5, 3, 8, 5,
                    11, 7, 14, 9, 17, 11,
                };

                CheckEqual(expected, z);
            }

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

                var y = new DenseVector(new Scalar[] {
                    100, 8, 9, 10, 11,
                    1, 2, 3, 4,
                    5, 6, 7,
                });
                var z = new DenseVector(22);

                z.AssignmentAddComplexInterleavedWithReal(x, y, startingIndexB: 1, subLength: 11);

                DenseVector expected = new Scalar[] {
                    9, 2, 12, 4, 15, 6, 18, 8,
                    10, 0, 2, 1, 5, 3, 8, 5,
                    11, 7, 14, 9, 17, 11,
                };

                CheckEqual(expected, z);
            }

            public void SubLength()
            {
                var x = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                    9, 0, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11, 102
                });

                var y = new DenseVector(new Scalar[] {
                    8, 9, 10, 11,
                    1, 2, 3, 4,
                    5, 6, 7, 103, 104,
                });
                var z = new DenseVector(23);
                z[22] = 101;

                z.AssignmentAddComplexInterleavedWithReal(x, y, subLength: 11);

                DenseVector expected = new Scalar[] {
                    9, 2, 12, 4, 15, 6, 18, 8,
                    10, 0, 2, 1, 5, 3, 8, 5,
                    11, 7, 14, 9, 17, 11, 101
                };

                CheckEqual(expected, z);
            }
        }

        public class MaddVectorTests : BlasBoundsFixture
        {
            private static class MethodInfoFinder
            {
                private static DenseVector x = null;
                public static MethodInfo MethodInfo = LambdaHelper.GetMethodInfoForWrappedCall(
                    () => x.MADD(x, default(Scalar), (int)0, (int)0, (int?)null));
            }

            public override MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;

            public void Basic()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector array2 = new Scalar[] { 3, 4, 5, 6, 7, 8, 9, };
                DenseVector expected = new Scalar[] { 7, 10, 13, 16, 19, 22, 25, };

                array1.MADD(array2, 2.0);

                CheckEqual(expected, array1);
            }

            public void Offset()
            {
                DenseVector array1 = new Scalar[] { 100, 1, 2, 3, 4, 5, 6, 7, };
                DenseVector array2 = new Scalar[] { 3, 4, 5, 6, 7, 8, 9, };
                DenseVector expected = new Scalar[] { 100, 7, 10, 13, 16, 19, 22, 25, };

                array1.MADD(array2, 2.0, startingIndexThis: 1, subLength: 7 );

                CheckEqual(expected, array1);
            }

            public void OffsetA()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector array2 = new Scalar[] { 100, 3, 4, 5, 6, 7, 8, 9, };
                DenseVector expected = new Scalar[] { 7, 10, 13, 16, 19, 22, 25, };

                array1.MADD(array2, 2.0, startingIndexOther: 1, subLength: 7);

                CheckEqual(expected, array1);
            }

            public void Length()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 101, 102, };
                DenseVector array2 = new Scalar[] { 3, 4, 5, 6, 7, 8, 9, 103, };
                DenseVector expected = new Scalar[] { 7, 10, 13, 16, 19, 22, 25, 101, 102, };

                array1.MADD(array2, 2.0, subLength: 7);

                CheckEqual(expected, array1);
            }
        }

        public class AssignmentMadd : BlasBoundsFixture
        {
            private static class MethodInfoFinder
            {
                private static DenseVector x = null;
                public static MethodInfo MethodInfo = LambdaHelper.GetMethodInfoForWrappedCall(
                    () => x.AssignmentMADD(x, x, default(Scalar), (int)0, (int)0, (int)0, (int?)null));
            }

            public override MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;

            public void Basic()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector array2 = new Scalar[] { 3, 4, 5, 6, 7, 8, 9, };
                DenseVector expected = new Scalar[] { 7, 10, 13, 16, 19, 22, 25, };
                DenseVector actual = new DenseVector(7);

                actual.AssignmentMADD(array1, array2, 2.0);

                CheckEqual(expected, actual);
            }

            public void Offset()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector array2 = new Scalar[] { 3, 4, 5, 6, 7, 8, 9, };
                DenseVector expected = new Scalar[] { 100, 7, 10, 13, 16, 19, 22, 25, };
                DenseVector actual = new DenseVector(8);
                actual[0] = 100;

                actual.AssignmentMADD(array1, array2, 2.0, startingIndexThis: 1, subLength: 7);

                CheckEqual(expected, actual);
            }

            public void OffsetA()
            {
                DenseVector array1 = new Scalar[] { 100, 1, 2, 3, 4, 5, 6, 7, };
                DenseVector array2 = new Scalar[] { 3, 4, 5, 6, 7, 8, 9, };
                DenseVector expected = new Scalar[] { 7, 10, 13, 16, 19, 22, 25, };
                DenseVector actual = new DenseVector(7);

                actual.AssignmentMADD(array1, array2, 2.0, startingIndexSum: 1, subLength: 7);

                CheckEqual(expected, actual);
            }

            public void OffsetB()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector array2 = new Scalar[] { 100, 3, 4, 5, 6, 7, 8, 9, };
                DenseVector expected = new Scalar[] { 7, 10, 13, 16, 19, 22, 25, };
                DenseVector actual = new DenseVector(7);

                actual.AssignmentMADD(array1, array2, 2.0, startingIndexOther: 1, subLength: 7);

                CheckEqual(expected, actual);
            }

            public void Length()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 101, 102, };
                DenseVector array2 = new Scalar[] { 3, 4, 5, 6, 7, 8, 9, 103, 104, 105, };
                DenseVector expected = new Scalar[] { 7, 10, 13, 16, 19, 22, 25, 100, };
                DenseVector actual = new DenseVector(8);
                actual[7] = 100;

                actual.AssignmentMADD(array1, array2, 2.0, subLength: 7);

                CheckEqual(expected, actual);
            }
        }

        public class MaddReverse : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.MADDReverse);

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

                DenseVector expected = new Scalar[] { 19, 18, 17, 16, 15, 14, 13, };

                array1.MADDReverse(array2, 2.0);

                CheckEqual(expected, array1);
            }

            public void Offset()
            {
                DenseVector array1 = new Scalar[] { 100, 1, 2, 3, 4, 5, 6, 7, };
                DenseVector array2 = new Scalar[] { 3, 4, 5, 6, 7, 8, 9, };

                DenseVector expected = new Scalar[] { 100, 19, 18, 17, 16, 15, 14, 13, };

                array1.MADDReverse(array2, 2.0, startingIndexThis: 1, subLength: 7);

                CheckEqual(expected, array1);
            }

            public void OffsetA()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector array2 = new Scalar[] { 100, 3, 4, 5, 6, 7, 8, 9, };

                DenseVector expected = new Scalar[] { 19, 18, 17, 16, 15, 14, 13, };

                array1.MADDReverse(array2, 2.0, startingIndexOther: 1, subLength: 7);

                CheckEqual(expected, array1);
            }

            public void Length()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 101, 102, };
                DenseVector array2 = new Scalar[] { 3, 4, 5, 6, 7, 8, 9, 100, };

                DenseVector expected = new Scalar[] { 19, 18, 17, 16, 15, 14, 13, 101, 102, };

                array1.MADDReverse(array2, 2.0, subLength: 7);

                CheckEqual(expected, array1);
            }
        }

        public class MaddComplexInterleaved : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.MADDComplexInterleaved);
            public override int OperationStride => 2;

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

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

                var expected = new DenseVector(new Scalar[] {
                    -3, 5, -3, 21, -3, 37, -3, 53,
                    -3, 59, -14, 74, -3, 13, -3, 29,
                    -3, 45, -3, 61, 37, 47,
                });

                x.MADDComplexInterleaved(y, (3, 4));
                CheckEqual(expected, x);
            }

            public void StartingIndexThis()
            {
                var x = new DenseVector(new Scalar[] {
                    100, 1, 2, 3, 4, 5, 6, 7, 8,
                });

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

                var expected = new DenseVector(new Scalar[] {
                    100, -3, 5, -3, 21, -3, 37, -3, 53,
                });

                x.MADDComplexInterleaved(y, (3, 4), startingIndexThis: 1);
                CheckEqual(expected, x);
            }

            public void StartingIndexOther()
            {
                var x = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                });

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

                var expected = new DenseVector(new Scalar[] {
                    -3, 5, -3, 21, -3, 37, -3, 53,
                });

                x.MADDComplexInterleaved(y, (3, 4), startingIndexOther: 1);
                CheckEqual(expected, x);
            }

            public void Length()
            {
                var x = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                });

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

                var expected = new DenseVector(new Scalar[] {
                    -3, 5, -3, 21, -3, 37, 7, 8,
                });

                x.MADDComplexInterleaved(y, (3, 4), subLength: 3);
                CheckEqual(expected, x);
            }
        }

        public class AssignmentMADDComplexInterleaved : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.AssignmentMADDComplexInterleaved);
            public override int OperationStride => 2;

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

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

                var z = new DenseVector(22);

                var expected = new DenseVector(new Scalar[] {
                    -3, 5, -3, 21, -3, 37, -3, 53,
                    -3, 59, -14, 74, -3, 13, -3, 29,
                    -3, 45, -3, 61, 37, 47,
                });

                z.AssignmentMADDComplexInterleaved(x, y, (3, 4));
                CheckEqual(expected, z);
            }

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

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

                var z = new DenseVector(23);
                z[0] = 100;

                var expected = new DenseVector(new Scalar[] {
                    100, -3, 5, -3, 21, -3, 37, -3, 53,
                    -3, 59, -14, 74, -3, 13, -3, 29,
                    -3, 45, -3, 61, 37, 47,
                });

                z.AssignmentMADDComplexInterleaved(x, y, (3, 4), startingIndexThis: 1);
                CheckEqual(expected, z);
            }

            public void StartingIndexSum()
            {
                var x = new DenseVector(new Scalar[] {
                    100, 1, 2, 3, 4, 5, 6, 7, 8,
                    9, 0, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11,
                });

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

                var z = new DenseVector(22);

                var expected = new DenseVector(new Scalar[] {
                    -3, 5, -3, 21, -3, 37, -3, 53,
                    -3, 59, -14, 74, -3, 13, -3, 29,
                    -3, 45, -3, 61, 37, 47,
                });

                z.AssignmentMADDComplexInterleaved(x, y, (3, 4), startingIndexSum: 1);
                CheckEqual(expected, z);
            }

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

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

                var z = new DenseVector(22);

                var expected = new DenseVector(new Scalar[] {
                    -3, 5, -3, 21, -3, 37, -3, 53,
                    -3, 59, -14, 74, -3, 13, -3, 29,
                    -3, 45, -3, 61, 37, 47,
                });

                z.AssignmentMADDComplexInterleaved(x, y, (3, 4), startingIndexOther: 1);
                CheckEqual(expected, z);
            }

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

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

                var z = new DenseVector(22);
                z.Flush(100);

                var expected = new DenseVector(new Scalar[] {
                    -3, 5, -3, 21, -3, 37, -3, 53,
                    -3, 59, -14, 74, -3, 13, -3, 29,
                    -3, 45, -3, 61, 100, 100,
                });

                z.AssignmentMADDComplexInterleaved(x, y, (3, 4), subLength: 10);
                CheckEqual(expected, z);
            }
        }

        public class MADDConjugateComplexInterleaved : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.MADDConjugateComplexInterleaved);
            public override int OperationStride => 2;

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

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

                var expected = new DenseVector(new Scalar[] {
                    -3, 5, -3, 21, -3, 37, -3, 53,
                    -3, 59, -14, 74, -3, 13, -3, 29,
                    -3, 45, -3, 61, 37, 47,
                });

                x.MADDConjugateComplexInterleaved(y, (3, 4));
                CheckEqual(expected, x);
            }

            public void StartingIndexThis()
            {
                var x = new DenseVector(new Scalar[] {
                    100, 1, 2, 3, 4, 5, 6, 7, 8,
                    9, 0, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11,
                });

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

                var expected = new DenseVector(new Scalar[] {
                    100, -3, 5, -3, 21, -3, 37, -3, 53,
                    -3, 59, -14, 74, -3, 13, -3, 29,
                    -3, 45, -3, 61, 37, 47,
                });

                x.MADDConjugateComplexInterleaved(y, (3, 4), startingIndexThis: 1);
                CheckEqual(expected, x);
            }

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

                var y = new DenseVector(new Scalar[] {
                    100, 0, -1, 2, -3, 4, -5, 6, -7,
                    8, -9, 10, -11, 1, -2, 3, -4,
                    5, -6, 7, -8, 9, 0,
                });

                var expected = new DenseVector(new Scalar[] {
                    -3, 5, -3, 21, -3, 37, -3, 53,
                    -3, 59, -14, 74, -3, 13, -3, 29,
                    -3, 45, -3, 61, 37, 47,
                });

                x.MADDConjugateComplexInterleaved(y, (3, 4), startingIndexOther: 1);
                CheckEqual(expected, x);
            }

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

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

                var expected = new DenseVector(new Scalar[] {
                    -3, 5, -3, 21, -3, 37, -3, 53,
                    -3, 59, -14, 74, -3, 13, -3, 29,
                    -3, 45, -3, 61, 10, 11,
                });

                x.MADDConjugateComplexInterleaved(y, (3, 4), subLength: 10);
                CheckEqual(expected, x);
            }
        }

        public class AssignmentMADDConjugateComplexInterleaved : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.AssignmentMADDConjugateComplexInterleaved);
            public override int OperationStride => 2;

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

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

                var z = new DenseVector(22);

                var expected = new DenseVector(new Scalar[] {
                    -3, 5, -3, 21, -3, 37, -3, 53,
                    -3, 59, -14, 74, -3, 13, -3, 29,
                    -3, 45, -3, 61, 37, 47,
                });

                z.AssignmentMADDConjugateComplexInterleaved(x, y, (3, 4));
                CheckEqual(expected, z);
            }

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

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

                var z = new DenseVector(23);
                z[0] = 100;

                var expected = new DenseVector(new Scalar[] {
                    100, -3, 5, -3, 21, -3, 37, -3, 53,
                    -3, 59, -14, 74, -3, 13, -3, 29,
                    -3, 45, -3, 61, 37, 47,
                });

                z.AssignmentMADDConjugateComplexInterleaved(x, y, (3, 4), startingIndexThis: 1);
                CheckEqual(expected, z);
            }

            public void StartingIndexSum()
            {
                var x = new DenseVector(new Scalar[] {
                    100, 1, 2, 3, 4, 5, 6, 7, 8,
                    9, 0, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11,
                });

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

                var z = new DenseVector(22);

                var expected = new DenseVector(new Scalar[] {
                    -3, 5, -3, 21, -3, 37, -3, 53,
                    -3, 59, -14, 74, -3, 13, -3, 29,
                    -3, 45, -3, 61, 37, 47,
                });

                z.AssignmentMADDConjugateComplexInterleaved(x, y, (3, 4), startingIndexSum: 1);
                CheckEqual(expected, z);
            }

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

                var y = new DenseVector(new Scalar[] {
                    100, 0, -1, 2, -3, 4, -5, 6, -7,
                    8, -9, 10, -11, 1, -2, 3, -4,
                    5, -6, 7, -8, 9, 0,
                });

                var z = new DenseVector(22);

                var expected = new DenseVector(new Scalar[] {
                    -3, 5, -3, 21, -3, 37, -3, 53,
                    -3, 59, -14, 74, -3, 13, -3, 29,
                    -3, 45, -3, 61, 37, 47,
                });

                z.AssignmentMADDConjugateComplexInterleaved(x, y, (3, 4), startingIndexOther: 1);
                CheckEqual(expected, z);
            }

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

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

                var z = new DenseVector(22);
                z.Flush(100);

                var expected = new DenseVector(new Scalar[] {
                    -3, 5, -3, 21, -3, 37, -3, 53,
                    -3, 59, -14, 74, -3, 13, -3, 29,
                    -3, 45, -3, 61, 100, 100,
                });

                z.AssignmentMADDConjugateComplexInterleaved(x, y, (3, 4), subLength: 10);
                CheckEqual(expected, z);
            }
        }

        public class Multiply : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.Multiply);

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

                DenseVector expected = new Scalar[] { 3, 8, 15, 24, 35, 48, 63, };

                array1.Multiply(array2);

                CheckEqual(expected, array1);
            }

            public void StartingOffset()
            {
                DenseVector array1 = new Scalar[] { 100, 1, 2, 3, 4, 5, 6, 7, };
                DenseVector array2 = new Scalar[] { 3, 4, 5, 6, 7, 8, 9, };

                DenseVector expected = new Scalar[] { 100, 3, 8, 15, 24, 35, 48, 63, };

                array1.Multiply(array2, startingOffsetThis: 1, subLength: 7);

                CheckEqual(expected, array1);
            }

            public void StartingOffsetA()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector array2 = new Scalar[] { 100, 3, 4, 5, 6, 7, 8, 9, };

                DenseVector expected = new Scalar[] { 3, 8, 15, 24, 35, 48, 63, };

                array1.Multiply(array2, startingOffsetOther: 1, subLength: 7);

                CheckEqual(expected, array1);
            }

            public void Length()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 101, 102, };
                DenseVector array2 = new Scalar[] { 3, 4, 5, 6, 7, 8, 9, 100, };

                DenseVector expected = new Scalar[] { 3, 8, 15, 24, 35, 48, 63, 101, 102, };

                array1.Multiply(array2, subLength: 7);

                CheckEqual(expected, array1);
            }
        }

        public class AssignmentMultiply : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.AssignmentMul);

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

                DenseVector expected = new Scalar[] { 3, 8, 15, 24, 35, 48, 63, };
                var actual = new DenseVector(7);

                actual.AssignmentMul(array1, array2);

                CheckEqual(expected, actual);
            }

            public void StartingOffset()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector array2 = new Scalar[] { 3, 4, 5, 6, 7, 8, 9, };

                DenseVector expected = new Scalar[] { 100, 3, 8, 15, 24, 35, 48, 63, };

                var actual = new DenseVector(8);
                actual[0] = 100;

                actual.AssignmentMul(array1, array2, startingOffsetThis: 1, subLength: 7);

                CheckEqual(expected, actual);
            }

            public void StartingOffsetA()
            {
                DenseVector array1 = new Scalar[] { 100, 1, 2, 3, 4, 5, 6, 7, };
                DenseVector array2 = new Scalar[] { 3, 4, 5, 6, 7, 8, 9, };

                DenseVector expected = new Scalar[] { 3, 8, 15, 24, 35, 48, 63, };

                var actual = new DenseVector(7);

                actual.AssignmentMul(array1, array2, startingOffsetA: 1, subLength: 7);

                CheckEqual(expected, actual);
            }

            public void StartingOffsetB()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector array2 = new Scalar[] { 100, 3, 4, 5, 6, 7, 8, 9, };

                DenseVector expected = new Scalar[] { 3, 8, 15, 24, 35, 48, 63, };

                var actual = new DenseVector(7);

                actual.AssignmentMul(array1, array2, startingOffsetB: 1, subLength: 7);

                CheckEqual(expected, actual);
            }

            public void Length()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 101, 102, };
                DenseVector array2 = new Scalar[] { 3, 4, 5, 6, 7, 8, 9, 103, 104, 105, };

                DenseVector expected = new Scalar[] { 3, 8, 15, 24, 35, 48, 63, 100, };

                var actual = new DenseVector(8);
                actual[7] = 100;

                actual.AssignmentMul(array1, array2, subLength: 7);

                CheckEqual(expected, actual);
            }
        }

        public class MultiplyComplexInterleaved : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.MultiplyComplexInterleaved);
            public override int OperationStride => 2;

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

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

                x.MultiplyComplexInterleaved(y);

                var expected = new DenseVector(new Scalar[] {
                    -2, 1, -6, 17, -10, 49, -14, 97,
                    72, 81, -11, 10, -4, 7, -8, 31,
                    -12, 71, -16, 127, 90, 99
                });

                CheckEqual(expected, x);
            }

            public void StartingOffsetThis()
            {
                var x = new DenseVector(new Scalar[] {
                    100, 1, 2, 3, 4, 5, 6, 7, 8,
                });

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

                x.MultiplyComplexInterleaved(y, startingOffsetThis: 1, subLength: 4);

                var expected = new DenseVector(new Scalar[] {
                    100, -2, 1, -6, 17, -10, 49, -14, 97,
                });

                CheckEqual(expected, x);
            }

            public void StartingOffsetOther()
            {
                var x = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                });

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

                x.MultiplyComplexInterleaved(y, startingOffsetOther: 1, subLength: 4);

                var expected = new DenseVector(new Scalar[] {
                    -2, 1, -6, 17, -10, 49, -14, 97,
                });

                CheckEqual(expected, x);
            }

            public void Length()
            {
                var x = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                });

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

                x.MultiplyComplexInterleaved(y, subLength: 3);

                var expected = new DenseVector(new Scalar[] {
                    -2, 1, -6, 17, -10, 49, 7, 8,
                });

                CheckEqual(expected, x);
            }
        }

        public class AssignmentMultiplyComplexInterleaved : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.AssignmentMultiplyComplexInterleaved);
            public override int OperationStride => 2;

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

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

                var z = new DenseVector(22);

                z.AssignmentMultiplyComplexInterleaved(x, y);

                var expected = new DenseVector(new Scalar[] {
                    -2, 1, -6, 17, -10, 49, -14, 97,
                    72, 81, -11, 10, -4, 7, -8, 31,
                    -12, 71, -16, 127, 90, 99
                });

                CheckEqual(expected, z);
            }

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

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

                var z = new DenseVector(23);
                z[0] = 100;

                z.AssignmentMultiplyComplexInterleaved(x, y, startingOffsetThis: 1);

                var expected = new DenseVector(new Scalar[] {
                    100, -2, 1, -6, 17, -10, 49, -14, 97,
                    72, 81, -11, 10, -4, 7, -8, 31,
                    -12, 71, -16, 127, 90, 99
                });

                CheckEqual(expected, z);
            }

            public void StartingIndexA()
            {
                var x = new DenseVector(new Scalar[] {
                    100, 1, 2, 3, 4, 5, 6, 7, 8,
                    9, 0, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11,
                });

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

                var z = new DenseVector(22);

                z.AssignmentMultiplyComplexInterleaved(x, y, startingOffsetA: 1);

                var expected = new DenseVector(new Scalar[] {
                    -2, 1, -6, 17, -10, 49, -14, 97,
                    72, 81, -11, 10, -4, 7, -8, 31,
                    -12, 71, -16, 127, 90, 99
                });

                CheckEqual(expected, z);
            }

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

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

                var z = new DenseVector(22);

                z.AssignmentMultiplyComplexInterleaved(x, y, startingOffsetB: 1);

                var expected = new DenseVector(new Scalar[] {
                    -2, 1, -6, 17, -10, 49, -14, 97,
                    72, 81, -11, 10, -4, 7, -8, 31,
                    -12, 71, -16, 127, 90, 99
                });

                CheckEqual(expected, z);
            }

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

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

                var z = new DenseVector(22);

                z.AssignmentMultiplyComplexInterleaved(x, y, subLength: 10);

                var expected = new DenseVector(new Scalar[] {
                    -2, 1, -6, 17, -10, 49, -14, 97,
                    72, 81, -11, 10, -4, 7, -8, 31,
                    -12, 71, -16, 127, 0, 0,
                });

                CheckEqual(expected, z);
            }
        }

        public class MultiplyConjugateComplexInterleaved : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.MultiplyConjugateComplexInterleaved);
            public override int OperationStride => 2;

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

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

                x.MultiplyConjugateComplexInterleaved(y);

                var expected = new DenseVector(new Scalar[] {
                    -2, 1, -6, 17, -10, 49, -14, 97,
                    72, 81, -11, 10, -4, 7, -8, 31,
                    -12, 71, -16, 127, 90, 99
                });

                CheckEqual(expected, x);
            }

            public void StartingOffsetThis()
            {
                var x = new DenseVector(new Scalar[] {
                    100, 1, 2, 3, 4, 5, 6, 7, 8,
                });

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

                x.MultiplyConjugateComplexInterleaved(y, startingOffsetThis: 1, subLength: 4);

                var expected = new DenseVector(new Scalar[] {
                    100, -2, 1, -6, 17, -10, 49, -14, 97,
                });

                CheckEqual(expected, x);
            }

            public void StartingOffsetOther()
            {
                var x = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                });

                var y = new DenseVector(new Scalar[] {
                    100, 0, -1, 2, -3, 4, -5, 6, -7,
                });

                x.MultiplyConjugateComplexInterleaved(y, startingOffsetOther: 1, subLength: 4);

                var expected = new DenseVector(new Scalar[] {
                    -2, 1, -6, 17, -10, 49, -14, 97,
                });

                CheckEqual(expected, x);
            }

            public void Length()
            {
                var x = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                });

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

                x.MultiplyConjugateComplexInterleaved(y, subLength: 3);

                var expected = new DenseVector(new Scalar[] {
                    -2, 1, -6, 17, -10, 49, 7, 8,
                });

                CheckEqual(expected, x);
            }
        }

        public class AssignmentMultiplyConjugateComplexInterleaved : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.AssignmentMultiplyConjugateComplexInterleaved);
            public override int OperationStride => 2;

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

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

                var z = new DenseVector(22);

                z.AssignmentMultiplyConjugateComplexInterleaved(x, y);

                var expected = new DenseVector(new Scalar[] {
                    -2, 1, -6, 17, -10, 49, -14, 97,
                    72, 81, -11, 10, -4, 7, -8, 31,
                    -12, 71, -16, 127, 90, 99
                });

                CheckEqual(expected, z);
            }

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

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

                var z = new DenseVector(23);
                z[0] = 100;

                z.AssignmentMultiplyConjugateComplexInterleaved(x, y, startingOffsetThis: 1);

                var expected = new DenseVector(new Scalar[] {
                    100, -2, 1, -6, 17, -10, 49, -14, 97,
                    72, 81, -11, 10, -4, 7, -8, 31,
                    -12, 71, -16, 127, 90, 99
                });

                CheckEqual(expected, z);
            }

            public void StartingIndexA()
            {
                var x = new DenseVector(new Scalar[] {
                    100, 1, 2, 3, 4, 5, 6, 7, 8,
                    9, 0, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11,
                });

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

                var z = new DenseVector(22);

                z.AssignmentMultiplyConjugateComplexInterleaved(x, y, startingOffsetA: 1);

                var expected = new DenseVector(new Scalar[] {
                    -2, 1, -6, 17, -10, 49, -14, 97,
                    72, 81, -11, 10, -4, 7, -8, 31,
                    -12, 71, -16, 127, 90, 99
                });

                CheckEqual(expected, z);
            }

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

                var y = new DenseVector(new Scalar[] {
                    100, 0, -1, 2, -3, 4, -5, 6, -7,
                    8, -9, 10, -11, 1, -2, 3, -4,
                    5, -6, 7, -8, 9, -0,
                });

                var z = new DenseVector(22);

                z.AssignmentMultiplyConjugateComplexInterleaved(x, y, startingOffsetB: 1);

                var expected = new DenseVector(new Scalar[] {
                    -2, 1, -6, 17, -10, 49, -14, 97,
                    72, 81, -11, 10, -4, 7, -8, 31,
                    -12, 71, -16, 127, 90, 99
                });

                CheckEqual(expected, z);
            }

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

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

                var z = new DenseVector(22);

                z.AssignmentMultiplyConjugateComplexInterleaved(x, y, subLength: 10);

                var expected = new DenseVector(new Scalar[] {
                    -2, 1, -6, 17, -10, 49, -14, 97,
                    72, 81, -11, 10, -4, 7, -8, 31,
                    -12, 71, -16, 127, 0, 0,
                });

                CheckEqual(expected, z);
            }
        }

        public class MultiplyComplexInterleavedWithReal : BlasBoundsFixture
        {
            private static class MethodInfoFinder
            {
                private static DenseVector x = null;
                public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                    () => x.MultiplyComplexInterleavedWithReal(x, (int)0, (int)0, (int?)null));
            }

            public override MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;
            public override int OperationStride => 2;

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

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

                x.MultiplyComplexInterleavedWithReal(y);

                DenseVector expected = new Scalar[] {
                    8, 16, 27, 36, 50, 60, 77, 88,
                    9, 0, 0, 2, 6, 9, 16, 20,
                    30, 35, 48, 54, 70, 77
                };

                CheckEqual(expected, x);
            }

            public void StartingOffset()
            {
                var x = new DenseVector(new Scalar[] {
                    100, 1, 2, 3, 4, 5, 6, 7, 8,
                    9, 0, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11,
                });

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

                x.MultiplyComplexInterleavedWithReal(y, startingIndexThis: 1, subLength: 11);

                DenseVector expected = new Scalar[] {
                    100, 8, 16, 27, 36, 50, 60, 77, 88,
                    9, 0, 0, 2, 6, 9, 16, 20,
                    30, 35, 48, 54, 70, 77
                };

                CheckEqual(expected, x);
            }

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

                var y = new DenseVector(new Scalar[] {
                    100, 8, 9, 10, 11,
                    1, 2, 3, 4,
                    5, 6, 7,
                });

                x.MultiplyComplexInterleavedWithReal(y, startingIndexA: 1, subLength: 11);

                DenseVector expected = new Scalar[] {
                    8, 16, 27, 36, 50, 60, 77, 88,
                    9, 0, 0, 2, 6, 9, 16, 20,
                    30, 35, 48, 54, 70, 77
                };

                CheckEqual(expected, x);
            }

            public void SubLength()
            {
                var x = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                    9, 0, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11, 101
                });

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

                x.MultiplyComplexInterleavedWithReal(y, subLength: 11);

                DenseVector expected = new Scalar[] {
                    8, 16, 27, 36, 50, 60, 77, 88,
                    9, 0, 0, 2, 6, 9, 16, 20,
                    30, 35, 48, 54, 70, 77, 101
                };

                CheckEqual(expected, x);
            }
        }

        public class AssignmentMultiplyComplexInterleavedWithReal : BlasBoundsFixture
        {
            private static class MethodInfoFinder
            {
                private static DenseVector x = null;
                public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                    () => x.AssignmentMultiplyComplexInterleavedWithReal(x, x, (int)0, (int)0, (int)0, (int?)null));
            }

            public override MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;
            public override int OperationStride => 2;

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

                var y = new DenseVector(new Scalar[] {
                    8, 9, 10, 11,
                    1, 2, 3, 4,
                    5, 6, 7,
                });
                var z = new DenseVector(22);

                z.AssignmentMultiplyComplexInterleavedWithReal(x, y);

                DenseVector expected = new Scalar[] {
                    8, 16, 27, 36, 50, 60, 77, 88,
                    9, 0, 0, 2, 6, 9, 16, 20,
                    30, 35, 48, 54, 70, 77
                };

                CheckEqual(expected, z);
            }

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

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

                var z = new DenseVector(23);
                z[0] = 100;

                z.AssignmentMultiplyComplexInterleavedWithReal(x, y, startingIndexThis: 1, subLength: 11);

                DenseVector expected = new Scalar[] {
                    100, 8, 16, 27, 36, 50, 60, 77, 88,
                    9, 0, 0, 2, 6, 9, 16, 20,
                    30, 35, 48, 54, 70, 77
                };

                CheckEqual(expected, z);
            }

            public void StartingOffsetA()
            {
                var x = new DenseVector(new Scalar[] {
                    100, 1, 2, 3, 4, 5, 6, 7, 8,
                    9, 0, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11,
                });

                var y = new DenseVector(new Scalar[] {
                    8, 9, 10, 11,
                    1, 2, 3, 4,
                    5, 6, 7,
                });
                var z = new DenseVector(22);

                z.AssignmentMultiplyComplexInterleavedWithReal(x, y, startingIndexA: 1, subLength: 11);

                DenseVector expected = new Scalar[] {
                    8, 16, 27, 36, 50, 60, 77, 88,
                    9, 0, 0, 2, 6, 9, 16, 20,
                    30, 35, 48, 54, 70, 77
                };

                CheckEqual(expected, z);
            }

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

                var y = new DenseVector(new Scalar[] {
                    100, 8, 9, 10, 11,
                    1, 2, 3, 4,
                    5, 6, 7,
                });
                var z = new DenseVector(22);

                z.AssignmentMultiplyComplexInterleavedWithReal(x, y, startingIndexB: 1, subLength: 11);

                DenseVector expected = new Scalar[] {
                    8, 16, 27, 36, 50, 60, 77, 88,
                    9, 0, 0, 2, 6, 9, 16, 20,
                    30, 35, 48, 54, 70, 77
                };

                CheckEqual(expected, z);
            }

            public void SubLength()
            {
                var x = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                    9, 0, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11, 102
                });

                var y = new DenseVector(new Scalar[] {
                    8, 9, 10, 11,
                    1, 2, 3, 4,
                    5, 6, 7, 103, 104,
                });
                var z = new DenseVector(23);
                z[22] = 101;

                z.AssignmentMultiplyComplexInterleavedWithReal(x, y, subLength: 11);

                DenseVector expected = new Scalar[] {
                    8, 16, 27, 36, 50, 60, 77, 88,
                    9, 0, 0, 2, 6, 9, 16, 20,
                    30, 35, 48, 54, 70, 77, 101
                };

                CheckEqual(expected, z);
            }
        }

        public class MultiplyRepeating : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.MultiplyRepeating4);

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

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

                array1.MultiplyRepeating4(array2);

                CheckEqual(expected, array1);
            }

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

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

                array1.MultiplyRepeating4(array2);

                CheckEqual(expected, array1);
            }

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

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

                array2.MultiplyRepeating4(array1);

                CheckEqual(expected, array2);
            }

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

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

                array2.MultiplyRepeating4(array1);

                CheckEqual(expected, array2);
            }

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

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

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

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

                array1.MultiplyRepeating4(array2, startingIndexThis: 1, subLength: 7);

                CheckEqual(expected, array1);
            }

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

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

                array1.MultiplyRepeating4(array2, startingIndexRepeating: 1, subLength: 7);

                CheckEqual(expected, array1);
            }

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

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

                array1.MultiplyRepeating4(array2, subLength: 7);

                CheckEqual(expected, array1);
            }
        }

        public class LERPTests : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.LERP);

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

                DenseVector expected = new Scalar[] { 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, };

                array1.LERP(array2, 0.25);

                CheckEqual(expected, array1);
            }

            public void StartingOffset()
            {
                DenseVector array1 = new Scalar[] { 100, 1, 2, 3, 4, 5, 6, 7, };
                DenseVector array2 = new Scalar[] { 3, 4, 5, 6, 7, 8, 9, };

                DenseVector expected = new Scalar[] { 100, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, };

                array1.LERP(array2, 0.25, startingIndexThis: 1, subLength: 7);

                CheckEqual(expected, array1);
            }

            public void StartingOffsetA()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector array2 = new Scalar[] { 100, 3, 4, 5, 6, 7, 8, 9, };

                DenseVector expected = new Scalar[] { 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, };

                array1.LERP(array2, 0.25, startingIndexOther: 1, subLength: 7);

                CheckEqual(expected, array1);
            }

            public void Length()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 101, 102, };
                DenseVector array2 = new Scalar[] { 3, 4, 5, 6, 7, 8, 9, 100, };

                DenseVector expected = new Scalar[] { 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 101, 102, };

                array1.LERP(array2, 0.25, subLength: 7);

                CheckEqual(expected, array1);
            }
        }

        public class AssignmentLERPTests : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.AssignmentLERP);

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

                DenseVector expected = new Scalar[] { 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, };
                DenseVector actual = new DenseVector(expected.Count);

                actual.AssignmentLERP(array1, array2, 0.25);

                CheckEqual(expected, actual);
            }

            public void OriginalIsUnmodified()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector array2 = new Scalar[] { 3, 4, 5, 6, 7, 8, 9, };

                DenseVector expected = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector actual = new DenseVector(expected.Count);

                actual.AssignmentLERP(array1, array2, 0.25);

                CheckEqual(expected, array1);
            }

            public void StartingOffset()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector array2 = new Scalar[] { 3, 4, 5, 6, 7, 8, 9, };

                DenseVector expected = new Scalar[] { 100, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, };
                DenseVector actual = new DenseVector(expected.Count);
                actual.Flush(100);

                actual.AssignmentLERP(array1, array2, 0.25, startingIndexThis: 1, subLength: 7);

                CheckEqual(expected, actual);
            }

            public void StartingOffsetA()
            {
                DenseVector array1 = new Scalar[] { 100, 1, 2, 3, 4, 5, 6, 7, };
                DenseVector array2 = new Scalar[] { 3, 4, 5, 6, 7, 8, 9, };

                DenseVector expected = new Scalar[] { 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, };
                DenseVector actual = new DenseVector(expected.Count);
                actual.Flush(100);

                actual.AssignmentLERP(array1, array2, 0.25, startingIndexA: 1, subLength: 7);

                CheckEqual(expected, actual);
            }

            public void StartingOffsetB()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector array2 = new Scalar[] { 100, 3, 4, 5, 6, 7, 8, 9, };

                DenseVector expected = new Scalar[] { 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, };
                DenseVector actual = new DenseVector(expected.Count);
                actual.Flush(100);

                actual.AssignmentLERP(array1, array2, 0.25, startingIndexB: 1, subLength: 7);

                CheckEqual(expected, actual);
            }

            public void Length()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 101, 102, };
                DenseVector array2 = new Scalar[] { 3, 4, 5, 6, 7, 8, 9, 103, 104, 105, };

                DenseVector expected = new Scalar[] { 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 100 };
                DenseVector actual = new DenseVector(expected.Count);
                actual.Flush(100);

                actual.AssignmentLERP(array1, array2, 0.25, subLength: 7);

                CheckEqual(expected, actual);
            }
        }

        public class AssignmentReverse : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.AssignmentReverse);

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

                DenseVector expected = new Scalar[] { 9, 8, 7, 6, 5, 4, 3, };

                array1.AssignmentReverse(array2);

                CheckEqual(expected, array1);
            }

            public void Offset()
            {
                DenseVector array1 = new Scalar[] { 100, 1, 2, 3, 4, 5, 6, 7, };
                DenseVector array2 = new Scalar[] { 3, 4, 5, 6, 7, 8, 9, };

                DenseVector expected = new Scalar[] { 100, 9, 8, 7, 6, 5, 4, 3, };

                array1.AssignmentReverse(array2, startingOffsetThis: 1, subLength: 7);

                CheckEqual(expected, array1);
            }

            public void OffsetA()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector array2 = new Scalar[] { 100, 3, 4, 5, 6, 7, 8, 9, };

                DenseVector expected = new Scalar[] { 9, 8, 7, 6, 5, 4, 3, };

                array1.AssignmentReverse(array2, startingOffsetOther: 1, subLength: 7);

                CheckEqual(expected, array1);
            }

            public void Length()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 101, 102, };
                DenseVector array2 = new Scalar[] { 3, 4, 5, 6, 7, 8, 9, 103, };

                DenseVector expected = new Scalar[] { 9, 8, 7, 6, 5, 4, 3, 101, 102, };

                array1.AssignmentReverse(array2, subLength: 7);

                CheckEqual(expected, array1);
            }

            public void SameArray()
            {
                DenseVector actual = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };

                CheckThrow(typeof(Exception));
                actual.AssignmentReverse(actual);
            }
        }

        public class Reverse : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.Reverse);

            public void EvenLength()
            {
                DenseVector actual = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, };
                DenseVector expected = new Scalar[] { 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, };

                actual.Reverse();

                CheckEqual(expected, actual);
            }

            public void OddLength()
            {
                DenseVector actual = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector expected = new Scalar[] { 7, 6, 5, 4, 3, 2, 1, };

                actual.Reverse();

                CheckEqual(expected, actual);
            }

            public void Offset()
            {
                DenseVector actual = new Scalar[] { 100, 1, 2, 3, 4, 5, 6, 7, };
                DenseVector expected = new Scalar[] { 100, 7, 6, 5, 4, 3, 2, 1, };

                actual.Reverse(startingOffset: 1, subLength: 7);

                CheckEqual(expected, actual);
            }

            public void Length()
            {
                DenseVector actual = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 101, 102, };
                DenseVector expected = new Scalar[] { 7, 6, 5, 4, 3, 2, 1, 101, 102, };

                actual.Reverse(subLength: 7);

                CheckEqual(expected, actual);
            }
        }

        public class ReverseComplexInterleaved : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.ReverseComplexInterleaved);
            public override int OperationStride => 2;

            public void FullLoopsAndExtra()
            {
                DenseVector actual = new Scalar[]
                {
                    1,   2,   3,  4,    5,  6,    7,  8,
                    9,  10,  11, 12,   13, 14,   15, 16,
                    17, 18,  19, 20,   21, 22,
                };
                DenseVector expected = new Scalar[]
                {
                    21, 22, 19, 20, 17, 18, 15, 16,
                    13, 14, 11, 12,  9, 10,  7,  8,
                     5,  6,  3,  4,  1,  2,
                };

                actual.ReverseComplexInterleaved();

                CheckEqual(expected, actual);
            }

            public void EvenLength()
            {
                DenseVector actual = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, };
                DenseVector expected = new Scalar[] { 11, 12, 9, 10, 7, 8, 5, 6, 3, 4, 1, 2, };

                actual.ReverseComplexInterleaved();

                CheckEqual(expected, actual);
            }

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

                actual.ReverseComplexInterleaved();

                CheckEqual(expected, actual);
            }

            public void NonPairedValue()
            {
                DenseVector actual = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 100 };
                DenseVector expected = new Scalar[] { 11, 12, 9, 10, 7, 8, 5, 6, 3, 4, 1, 2, 100 };

                actual.ReverseComplexInterleaved();

                CheckEqual(expected, actual);
            }

            public void Offset()
            {
                DenseVector actual = new Scalar[] { 100, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, };
                DenseVector expected = new Scalar[] { 100, 9, 10, 7, 8, 5, 6, 3, 4, 1, 2, };

                actual.ReverseComplexInterleaved(startingOffset: 1, subLength: 5);

                CheckEqual(expected, actual);
            }

            public void Length()
            {
                DenseVector actual = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 101, 102, };
                DenseVector expected = new Scalar[] { 9, 10, 7, 8, 5, 6, 3, 4, 1, 2, 101, 102, };

                actual.ReverseComplexInterleaved(subLength: 5);

                CheckEqual(expected, actual);
            }
        }

        public class TripleDotProduct : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.TripleDotProduct);

            public override void FixtureSetup()
            {
                base.FixtureSetup();
            }

            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 OffsetA()
            {
                DenseVector A = new Scalar[] { 100, 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, startingOffset_A: 1, subLength: 7));
            }

            public void OffsetB()
            {
                DenseVector A = new Scalar[] { 1, 2, 3, 4, 5, 6, 7 };
                DenseVector B = new Scalar[] { 100, 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, startingOffset_B: 1, subLength: 7));
            }

            public void OffsetC()
            {
                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[] { 100, -1, -1, -1, -1, -1, -1, -1 };

                CheckEqual(-140, DenseVector.TripleDotProduct(A, B, C, startingOffset_C: 1, subLength: 7));
            }

            public void Length()
            {
                DenseVector A = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 101, 102, 103, };
                DenseVector B = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 104, 105,  };
                DenseVector C = new Scalar[] { -1, -1, -1, -1, -1, -1, -1, 106, };

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

        public class ComplexDivisionTests : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.ComplexDivision);
            public override bool VectorAChanged => true;
            public override bool VectorBChanged => true;

            public void Basic()
            {
                DenseVector real = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, };
                DenseVector imag = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, };

                DenseVector divisorReal = new Scalar[] { 0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, };
                DenseVector divisorImag = new Scalar[] { 1,  1,  2,  2,  3,  3,  4,  4,  5,  5,   6,   6,   7,   7, };

                DenseVector.ComplexDivision(ref real, ref imag, divisorReal, divisorImag);

                DenseVector expectedReal = new Scalar[] {
                    1,  0.5,  0.25,  -1.0/13,  -1.0/25,  -7.0/34.0,  -4.0/26, -17.0/65,  -19.0/89, -31.0/106, -1.0/4,
                    -49.0/157, -53.0/193, -71.0/218, };
                DenseVector expectedImag = new Scalar[] {
                    0, -1.5, -1.25, -18.0/13, -32.0/25, -45.0/34.0, -33.0/26, -84.0/65, -112.0/89, -135.0/106, -5.0/4,
                    -198.0/157, -240.0/193, -273.0/218 };

                CheckEqual(expectedReal, real);
                CheckEqual(expectedImag, imag);
            }

            public void StartingOffsetA()
            {
                DenseVector real = new Scalar[] { 100, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, };
                DenseVector imag = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, };

                DenseVector divisorReal = new Scalar[] { 0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, };
                DenseVector divisorImag = new Scalar[] { 1,  1,  2,  2,  3,  3,  4,  4,  5,  5,   6,   6,   7,   7, };

                DenseVector.ComplexDivision(
                    ref real, ref imag, divisorReal, divisorImag, startingOffsetDividendReal: 1, subLength: 14);

                DenseVector expectedReal = new Scalar[] {
                    100,
                    1,  0.5,  0.25,  -1.0/13,  -1.0/25,  -7.0/34.0,  -4.0/26, -17.0/65,  -19.0/89, -31.0/106, -1.0/4,
                    -49.0/157, -53.0/193, -71.0/218, };
                DenseVector expectedImag = new Scalar[] {
                    0, -1.5, -1.25, -18.0/13, -32.0/25, -45.0/34.0, -33.0/26, -84.0/65, -112.0/89, -135.0/106, -5.0/4,
                    -198.0/157, -240.0/193, -273.0/218 };

                CheckEqual(expectedReal, real);
                CheckEqual(expectedImag, imag);
            }

            public void StartingOffsetB()
            {
                DenseVector real = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, };
                DenseVector imag = new Scalar[] { 100, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, };

                DenseVector divisorReal = new Scalar[] { 0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, };
                DenseVector divisorImag = new Scalar[] { 1,  1,  2,  2,  3,  3,  4,  4,  5,  5,   6,   6,   7,   7, };

                DenseVector.ComplexDivision(
                    ref real, ref imag, divisorReal, divisorImag, startingOffsetDividendImag: 1, subLength: 14);

                DenseVector expectedReal = new Scalar[] {
                    1,  0.5,  0.25,  -1.0/13,  -1.0/25,  -7.0/34.0,  -4.0/26, -17.0/65,  -19.0/89, -31.0/106, -1.0/4,
                    -49.0/157, -53.0/193, -71.0/218, };
                DenseVector expectedImag = new Scalar[] {
                    100,
                    0, -1.5, -1.25, -18.0/13, -32.0/25, -45.0/34.0, -33.0/26, -84.0/65, -112.0/89, -135.0/106, -5.0/4,
                    -198.0/157, -240.0/193, -273.0/218 };

                CheckEqual(expectedReal, real);
                CheckEqual(expectedImag, imag);
            }

            public void StartingOffsetC()
            {
                DenseVector real = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, };
                DenseVector imag = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, };

                DenseVector divisorReal = new Scalar[] {
                    100, 0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, };
                DenseVector divisorImag = new Scalar[] { 1,  1,  2,  2,  3,  3,  4,  4,  5,  5,   6,   6,   7,   7, };

                DenseVector.ComplexDivision(
                    ref real, ref imag, divisorReal, divisorImag, startingOffsetDivisorReal: 1, subLength: 14);

                DenseVector expectedReal = new Scalar[] {
                    1,  0.5,  0.25,  -1.0/13,  -1.0/25,  -7.0/34.0,  -4.0/26, -17.0/65,  -19.0/89, -31.0/106, -1.0/4,
                    -49.0/157, -53.0/193, -71.0/218, };
                DenseVector expectedImag = new Scalar[] {
                    0, -1.5, -1.25, -18.0/13, -32.0/25, -45.0/34.0, -33.0/26, -84.0/65, -112.0/89, -135.0/106, -5.0/4,
                    -198.0/157, -240.0/193, -273.0/218 };

                CheckEqual(expectedReal, real);
                CheckEqual(expectedImag, imag);
            }

            public void StartingOffsetD()
            {
                DenseVector real = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, };
                DenseVector imag = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, };

                DenseVector divisorReal = new Scalar[] {
                    0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, };
                DenseVector divisorImag = new Scalar[] { 100,
                    1,  1,  2,  2,  3,  3,  4,  4,  5,  5,   6,   6,   7,   7, };

                DenseVector.ComplexDivision(
                    ref real, ref imag, divisorReal, divisorImag, startingOffsetDivisorImag: 1, subLength: 14);

                DenseVector expectedReal = new Scalar[] {
                    1,  0.5,  0.25,  -1.0/13,  -1.0/25,  -7.0/34.0,  -4.0/26, -17.0/65,  -19.0/89, -31.0/106, -1.0/4,
                    -49.0/157, -53.0/193, -71.0/218, };
                DenseVector expectedImag = new Scalar[] {
                    0, -1.5, -1.25, -18.0/13, -32.0/25, -45.0/34.0, -33.0/26, -84.0/65, -112.0/89, -135.0/106, -5.0/4,
                    -198.0/157, -240.0/193, -273.0/218 };

                CheckEqual(expectedReal, real);
                CheckEqual(expectedImag, imag);
            }

            public void Length()
            {
                DenseVector real = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 100, };
                DenseVector imag = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 101, 102, };

                DenseVector divisorReal = new Scalar[] {
                    0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, 103, 104, 105, };
                DenseVector divisorImag = new Scalar[] {
                    1,  1,  2,  2,  3,  3,  4,  4,  5,  5,   6,   6,   7,   7, 106, 107, 108, 109, };

                DenseVector.ComplexDivision(ref real, ref imag, divisorReal, divisorImag, subLength: 14);

                DenseVector expectedReal = new Scalar[] {
                    1,  0.5,  0.25,  -1.0/13,  -1.0/25,  -7.0/34.0,  -4.0/26, -17.0/65,  -19.0/89, -31.0/106, -1.0/4,
                    -49.0/157, -53.0/193, -71.0/218, 100,  };
                DenseVector expectedImag = new Scalar[] {
                    0, -1.5, -1.25, -18.0/13, -32.0/25, -45.0/34.0, -33.0/26, -84.0/65, -112.0/89, -135.0/106, -5.0/4,
                    -198.0/157, -240.0/193, -273.0/218, 101, 102, };

                CheckEqual(expectedReal, real);
                CheckEqual(expectedImag, imag);
            }
        }

        public class ComplexMultiplicationTests : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.ComplexMultiplication);
            public override bool VectorAChanged => true;
            public override bool VectorBChanged => true;

            public void Basic()
            {
                DenseVector real = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7, 8,  9, 10, 11, 12, 13, };
                DenseVector imag = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, };

                DenseVector divisorReal = new Scalar[] { 0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, };
                DenseVector divisorImag = new Scalar[] { 1,  1,  2,  2,  3,  3,  4,  4,  5,  5,   6,   6,   7,   7, };

                DenseVector.ComplexMultiplication(ref real, ref imag, divisorReal, divisorImag);

                DenseVector expectedReal = new Scalar[] {
                    -1, -3,  -10, -17, -31, -43, -64, -81, -109, -131, -166, -193, -235, -267 };
                DenseVector expectedImag = new Scalar[] {
                     0, -1,   -2,  -6,  -8, -15, -18, -28,  -32,  -45,  -50,  -66,  -72,  -91 };

                CheckEqual(expectedReal, real);
                CheckEqual(expectedImag, imag);
            }

            public void OffsetA()
            {
                DenseVector real = new Scalar[] { 100, 0, 1, 2, 3, 4, 5, 6, 7, 8,  9, 10, 11, 12, 13, };
                DenseVector imag = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, };

                DenseVector divisorReal = new Scalar[] { 0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, };
                DenseVector divisorImag = new Scalar[] { 1,  1,  2,  2,  3,  3,  4,  4,  5,  5,   6,   6,   7,   7, };

                DenseVector.ComplexMultiplication(
                    ref real, ref imag, divisorReal, divisorImag, startingOffsetMultiplicandReal: 1, subLength: 14);

                DenseVector expectedReal = new Scalar[] {
                    100,
                    -1, -3,  -10, -17, -31, -43, -64, -81, -109, -131, -166, -193, -235, -267 };
                DenseVector expectedImag = new Scalar[] {
                     0, -1,   -2,  -6,  -8, -15, -18, -28,  -32,  -45,  -50,  -66,  -72,  -91 };

                CheckEqual(expectedReal, real);
                CheckEqual(expectedImag, imag);
            }

            public void OffsetB()
            {
                DenseVector real = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7, 8,  9, 10, 11, 12, 13, };
                DenseVector imag = new Scalar[] { 100, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, };

                DenseVector divisorReal = new Scalar[] { 0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, };
                DenseVector divisorImag = new Scalar[] { 1,  1,  2,  2,  3,  3,  4,  4,  5,  5,   6,   6,   7,   7, };

                DenseVector.ComplexMultiplication(
                    ref real, ref imag, divisorReal, divisorImag, startingOffsetMultiplicandImag: 1, subLength: 14);

                DenseVector expectedReal = new Scalar[] {
                    -1, -3,  -10, -17, -31, -43, -64, -81, -109, -131, -166, -193, -235, -267 };
                DenseVector expectedImag = new Scalar[] {
                    100,
                     0, -1,   -2,  -6,  -8, -15, -18, -28,  -32,  -45,  -50,  -66,  -72,  -91 };

                CheckEqual(expectedReal, real);
                CheckEqual(expectedImag, imag);
            }

            public void OffsetC()
            {
                DenseVector real = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7, 8,  9, 10, 11, 12, 13, };
                DenseVector imag = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, };

                DenseVector divisorReal = new Scalar[] {
                    100,
                    0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, };
                DenseVector divisorImag = new Scalar[] {
                    1,  1,  2,  2,  3,  3,  4,  4,  5,  5,   6,   6,   7,   7, };

                DenseVector.ComplexMultiplication(
                    ref real, ref imag, divisorReal, divisorImag, startingOffsetMultiplierReal: 1, subLength: 14);

                DenseVector expectedReal = new Scalar[] {
                    -1, -3,  -10, -17, -31, -43, -64, -81, -109, -131, -166, -193, -235, -267 };
                DenseVector expectedImag = new Scalar[] {
                     0, -1,   -2,  -6,  -8, -15, -18, -28,  -32,  -45,  -50,  -66,  -72,  -91 };

                CheckEqual(expectedReal, real);
                CheckEqual(expectedImag, imag);
            }

            public void OffsetD()
            {
                DenseVector real = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7, 8,  9, 10, 11, 12, 13, };
                DenseVector imag = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, };

                DenseVector divisorReal = new Scalar[] {
                    0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, };
                DenseVector divisorImag = new Scalar[] {
                    100,
                    1,  1,  2,  2,  3,  3,  4,  4,  5,  5,   6,   6,   7,   7, };

                DenseVector.ComplexMultiplication(
                    ref real, ref imag, divisorReal, divisorImag, startingOffsetMultiplierImag: 1, subLength: 14);

                DenseVector expectedReal = new Scalar[] {
                    -1, -3,  -10, -17, -31, -43, -64, -81, -109, -131, -166, -193, -235, -267 };
                DenseVector expectedImag = new Scalar[] {
                     0, -1,   -2,  -6,  -8, -15, -18, -28,  -32,  -45,  -50,  -66,  -72,  -91 };

                CheckEqual(expectedReal, real);
                CheckEqual(expectedImag, imag);
            }

            public void Length()
            {
                DenseVector real = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7, 8,  9, 10, 11, 12, 13, 100, };
                DenseVector imag = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 101, 102, };

                DenseVector divisorReal = new Scalar[] {
                    0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, 103, 104, 105, };
                DenseVector divisorImag = new Scalar[] {
                    1,  1,  2,  2,  3,  3,  4,  4,  5,  5,   6,   6,   7,   7, 106, 107, 108, 109, };

                DenseVector.ComplexMultiplication(ref real, ref imag, divisorReal, divisorImag, subLength: 14);

                DenseVector expectedReal = new Scalar[] {
                    -1, -3,  -10, -17, -31, -43, -64, -81, -109, -131, -166, -193, -235, -267, 100, };
                DenseVector expectedImag = new Scalar[] {
                     0, -1,   -2,  -6,  -8, -15, -18, -28,  -32,  -45,  -50,  -66,  -72,  -91, 101, 102, };

                CheckEqual(expectedReal, real);
                CheckEqual(expectedImag, imag);
            }
        }

        public class EvaluatePolynomial : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.EvaluatePolynomial);

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

                CheckEqual(270, vec.EvaluatePolynomial(2));
            }

            public void Offset()
            {
                DenseVector vec = new Scalar[] { 100, 0, -1, 2, -3, 4, -5, 6, };

                CheckEqual(270, vec.EvaluatePolynomial(2, startingOffset: 1, subLength: 7));
            }

            public void Length()
            {
                DenseVector vec = new Scalar[] { 0, -1, 2, -3, 4, -5, 6, 100, };

                CheckEqual(270, vec.EvaluatePolynomial(2, subLength: 7));
            }
        }

        public class EvaluateComplexInterleavedPolynomial : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.EvaluateComplexInterleavedPolynomial);
            public override int OperationStride => 2;

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

                var value = x.EvaluateComplexInterleavedPolynomial(new Complex(3, 4));
                CheckEqual(new Complex(76339, 8986), value);
            }

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

                var value = x.EvaluateComplexInterleavedPolynomial(new Complex(3, 4), startingOffset: 1, subLength: 7);
                CheckEqual(new Complex(76339, 8986), value);
            }

            public void Length()
            {
                var x = new DenseVector(new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 100, 102, 103, 10, });

                var value = x.EvaluateComplexInterleavedPolynomial(new Complex(3, 4), subLength: 7);
                CheckEqual(new Complex(76339, 8986), value);
            }
        }

        public class Divide : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.Divide);

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

                DenseVector expected = new Scalar[] { 1.0/3, 2.0/4, 3.0/5, 4.0/6, 5.0/7, 6.0/8, 7.0/9 };

                array1.Divide(array2);

                CheckEqual(expected, array1);
            }

            public void Offset()
            {
                DenseVector array1 = new Scalar[] { 100, 1, 2, 3, 4, 5, 6, 7, };
                DenseVector array2 = new Scalar[] { 3, 4, 5, 6, 7, 8, 9, };

                DenseVector expected = new Scalar[] { 100, 1.0/3, 2.0/4, 3.0/5, 4.0/6, 5.0/7, 6.0/8, 7.0/9 };

                array1.Divide(array2, startingOffsetThis: 1, subLength: 7);

                CheckEqual(expected, array1);
            }

            public void OffsetA()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector array2 = new Scalar[] { 100, 3, 4, 5, 6, 7, 8, 9, };

                DenseVector expected = new Scalar[] { 1.0/3, 2.0/4, 3.0/5, 4.0/6, 5.0/7, 6.0/8, 7.0/9 };

                array1.Divide(array2, startingOffsetOther: 1, subLength: 7);

                CheckEqual(expected, array1);
            }

            public void Length()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 101, 102, };
                DenseVector array2 = new Scalar[] { 3, 4, 5, 6, 7, 8, 9, 103, };

                DenseVector expected = new Scalar[] { 1.0/3, 2.0/4, 3.0/5, 4.0/6, 5.0/7, 6.0/8, 7.0/9, 101, 102, };

                array1.Divide(array2, subLength: 7);

                CheckEqual(expected, array1);
            }
        }

        public class AssignmentDiv : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.AssignmentDiv);

            public void Basic()
            {
                DenseVector actual = new DenseVector(7);
                DenseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector array2 = new Scalar[] { 3, 4, 5, 6, 7, 8, 9, };

                DenseVector expected = new Scalar[] { 1.0/3, 2.0/4, 3.0/5, 4.0/6, 5.0/7, 6.0/8, 7.0/9 };

                actual.AssignmentDiv(array1, array2);

                CheckEqual(expected, actual);
            }

            public void Offset()
            {
                DenseVector actual = new DenseVector(8);
                actual[0] = 100;
                DenseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector array2 = new Scalar[] { 3, 4, 5, 6, 7, 8, 9, };

                DenseVector expected = new Scalar[] { 100, 1.0/3, 2.0/4, 3.0/5, 4.0/6, 5.0/7, 6.0/8, 7.0/9 };

                actual.AssignmentDiv(array1, array2, startingOffsetThis: 1, subLength: 7);

                CheckEqual(expected, actual);
            }

            public void OffsetA()
            {
                DenseVector actual = new DenseVector(7);
                DenseVector array1 = new Scalar[] { 100, 1, 2, 3, 4, 5, 6, 7, };
                DenseVector array2 = new Scalar[] { 3, 4, 5, 6, 7, 8, 9, };

                DenseVector expected = new Scalar[] { 1.0/3, 2.0/4, 3.0/5, 4.0/6, 5.0/7, 6.0/8, 7.0/9 };

                actual.AssignmentDiv(array1, array2, startingOffsetA: 1, subLength: 7);

                CheckEqual(expected, actual);
            }

            public void OffsetB()
            {
                DenseVector actual = new DenseVector(7);
                DenseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector array2 = new Scalar[] { 100, 3, 4, 5, 6, 7, 8, 9, };

                DenseVector expected = new Scalar[] { 1.0/3, 2.0/4, 3.0/5, 4.0/6, 5.0/7, 6.0/8, 7.0/9 };

                actual.AssignmentDiv(array1, array2, startingOffsetB: 1, subLength: 7);

                CheckEqual(expected, actual);
            }

            public void Length()
            {
                DenseVector actual = new DenseVector(8);
                actual[7] = 100;
                DenseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector array2 = new Scalar[] { 3, 4, 5, 6, 7, 8, 9, };

                DenseVector expected = new Scalar[] { 1.0/3, 2.0/4, 3.0/5, 4.0/6, 5.0/7, 6.0/8, 7.0/9, 100 };

                actual.AssignmentDiv(array1, array2, subLength: 7);

                CheckEqual(expected, actual);
            }
        }

        public class DivideComplexInterleaved : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.DivideComplexInterleaved);
            public override int OperationStride => 2;

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

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

                x.DivideComplexInterleaved(y);

                var expected = new DenseVector(new Scalar[] {
                    2.0, -1.0, 18.0/13, -1.0/13, 50.0/41, -1.0/41, 98.0/85, -1.0/85,
                    72.0/145, -81.0/145, 11.0/221, 10.0/221, 8.0/5, -1.0/5, 32.0/25, -1.0/25,
                    72.0/61, -1.0/61, 128.0/113, -1.0/113, 10.0/9, 11.0/9
                });

                CheckEqual(expected, x);
            }

            public void StartingOffsetThis()
            {
                var x = new DenseVector(new Scalar[] {
                    100, 1, 2, 3, 4, 5, 6, 7, 8,
                    9, 0, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11,
                });

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

                x.DivideComplexInterleaved(y, startingOffsetThis: 1, subLength: 11);

                var expected = new DenseVector(new Scalar[] {
                    100, 2.0, -1.0, 18.0/13, -1.0/13, 50.0/41, -1.0/41, 98.0/85, -1.0/85,
                    72.0/145, -81.0/145, 11.0/221, 10.0/221, 8.0/5, -1.0/5, 32.0/25, -1.0/25,
                    72.0/61, -1.0/61, 128.0/113, -1.0/113, 10.0/9, 11.0/9
                });

                CheckEqual(expected, x);
            }

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

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

                x.DivideComplexInterleaved(y, startingOffsetOther: 1, subLength: 11);

                var expected = new DenseVector(new Scalar[] {
                    2.0, -1.0, 18.0/13, -1.0/13, 50.0/41, -1.0/41, 98.0/85, -1.0/85,
                    72.0/145, -81.0/145, 11.0/221, 10.0/221, 8.0/5, -1.0/5, 32.0/25, -1.0/25,
                    72.0/61, -1.0/61, 128.0/113, -1.0/113, 10.0/9, 11.0/9
                });

                CheckEqual(expected, x);
            }

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

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

                x.DivideComplexInterleaved(y, subLength: 10);

                var expected = new DenseVector(new Scalar[] {
                    2.0, -1.0, 18.0/13, -1.0/13, 50.0/41, -1.0/41, 98.0/85, -1.0/85,
                    72.0/145, -81.0/145, 11.0/221, 10.0/221, 8.0/5, -1.0/5, 32.0/25, -1.0/25,
                    72.0/61, -1.0/61, 128.0/113, -1.0/113, 10, 11
                });

                CheckEqual(expected, x);
            }
        }

        public class AssignmentDivideComplexInterleaved : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.AssignmentDivideComplexInterleaved);
            public override int OperationStride => 2;

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

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

                var z = new DenseVector(22);

                z.AssignmentDivideComplexInterleaved(x, y);

                var expected = new DenseVector(new Scalar[] {
                    2.0, -1.0, 18.0/13, -1.0/13, 50.0/41, -1.0/41, 98.0/85, -1.0/85,
                    72.0/145, -81.0/145, 11.0/221, 10.0/221, 8.0/5, -1.0/5, 32.0/25, -1.0/25,
                    72.0/61, -1.0/61, 128.0/113, -1.0/113, 10.0/9, 11.0/9
                });

                CheckEqual(expected, z);
            }

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

                var y = new DenseVector(new Scalar[] {
                    0, 1, 2, 3, 4, 5, 6, 7,
                    8, 9, 10, 11, 1, 2, 3, 4,
                    5, 6, 7, 8, 9, 0,
                });
                var z = new DenseVector(23);
                z[0] = 100;

                z.AssignmentDivideComplexInterleaved(x, y, startingOffsetThis: 1, subLength: 11);

                var expected = new DenseVector(new Scalar[] {
                    100, 2.0, -1.0, 18.0/13, -1.0/13, 50.0/41, -1.0/41, 98.0/85, -1.0/85,
                    72.0/145, -81.0/145, 11.0/221, 10.0/221, 8.0/5, -1.0/5, 32.0/25, -1.0/25,
                    72.0/61, -1.0/61, 128.0/113, -1.0/113, 10.0/9, 11.0/9
                });

                CheckEqual(expected, z);
            }

            public void StartingOffsetA()
            {
                var x = new DenseVector(new Scalar[] {
                    100, 1, 2, 3, 4, 5, 6, 7, 8,
                    9, 0, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11,
                });

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

                var z = new DenseVector(22);

                z.AssignmentDivideComplexInterleaved(x, y, startingOffsetA: 1, subLength: 11);

                var expected = new DenseVector(new Scalar[] {
                    2.0, -1.0, 18.0/13, -1.0/13, 50.0/41, -1.0/41, 98.0/85, -1.0/85,
                    72.0/145, -81.0/145, 11.0/221, 10.0/221, 8.0/5, -1.0/5, 32.0/25, -1.0/25,
                    72.0/61, -1.0/61, 128.0/113, -1.0/113, 10.0/9, 11.0/9
                });

                CheckEqual(expected, z);
            }

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

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

                var z = new DenseVector(22);

                z.AssignmentDivideComplexInterleaved(x, y, startingOffsetB: 1, subLength: 11);

                var expected = new DenseVector(new Scalar[] {
                    2.0, -1.0, 18.0/13, -1.0/13, 50.0/41, -1.0/41, 98.0/85, -1.0/85,
                    72.0/145, -81.0/145, 11.0/221, 10.0/221, 8.0/5, -1.0/5, 32.0/25, -1.0/25,
                    72.0/61, -1.0/61, 128.0/113, -1.0/113, 10.0/9, 11.0/9
                });

                CheckEqual(expected, z);
            }

            public void Length()
            {
                var x = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                    9, 0, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11, 101,
                });

                var y = new DenseVector(new Scalar[] {
                    0, 1, 2, 3, 4, 5, 6, 7,
                    8, 9, 10, 11, 1, 2, 3, 4,
                    5, 6, 7, 8, 9, 0, 102, 103,
                });

                var z = new DenseVector(23);
                z[22] = 100;

                z.AssignmentDivideComplexInterleaved(x, y, subLength: 11);

                var expected = new DenseVector(new Scalar[] {
                    2.0, -1.0, 18.0/13, -1.0/13, 50.0/41, -1.0/41, 98.0/85, -1.0/85,
                    72.0/145, -81.0/145, 11.0/221, 10.0/221, 8.0/5, -1.0/5, 32.0/25, -1.0/25,
                    72.0/61, -1.0/61, 128.0/113, -1.0/113, 10.0/9, 11.0/9, 100
                });

                CheckEqual(expected, z);
            }
        }

        public class AssignmentDivideConjugateNumeratorComplexInterleaved : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.AssignmentDivideConjugateNumeratorComplexInterleaved);
            public override int OperationStride => 2;

            public void Basic()
            {
                var x = new DenseVector(new Scalar[] {
                    1, -2, 3, -4, 5, -6, 7, -8,
                    9, -0, 0, -1, 2, -3, 4, -5,
                    6, -7, 8, -9, 10, -11,
                });

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

                var z = new DenseVector(22);

                z.AssignmentDivideConjugateNumeratorComplexInterleaved(x, y);

                var expected = new DenseVector(new Scalar[] {
                    2.0, -1.0, 18.0/13, -1.0/13, 50.0/41, -1.0/41, 98.0/85, -1.0/85,
                    72.0/145, -81.0/145, 11.0/221, 10.0/221, 8.0/5, -1.0/5, 32.0/25, -1.0/25,
                    72.0/61, -1.0/61, 128.0/113, -1.0/113, 10.0/9, 11.0/9
                });

                CheckEqual(expected, z);
            }

            public void StartingOffsetThis()
            {
                var x = new DenseVector(new Scalar[] {
                    1, -2, 3, -4, 5, -6, 7, -8,
                    9, -0, 0, -1, 2, -3, 4, -5,
                    6, -7, 8, -9, 10, -11,
                });

                var y = new DenseVector(new Scalar[] {
                    0, 1, 2, 3, 4, 5, 6, 7,
                    8, 9, 10, 11, 1, 2, 3, 4,
                    5, 6, 7, 8, 9, 0,
                });
                var z = new DenseVector(23);
                z[0] = 100;

                z.AssignmentDivideConjugateNumeratorComplexInterleaved(x, y, startingOffsetThis: 1, subLength: 11);

                var expected = new DenseVector(new Scalar[] {
                    100, 2.0, -1.0, 18.0/13, -1.0/13, 50.0/41, -1.0/41, 98.0/85, -1.0/85,
                    72.0/145, -81.0/145, 11.0/221, 10.0/221, 8.0/5, -1.0/5, 32.0/25, -1.0/25,
                    72.0/61, -1.0/61, 128.0/113, -1.0/113, 10.0/9, 11.0/9
                });

                CheckEqual(expected, z);
            }

            public void StartingOffsetA()
            {
                var x = new DenseVector(new Scalar[] {
                    100, 1, -2, 3, -4, 5, -6, 7, -8,
                    9, -0, 0, -1, 2, -3, 4, -5,
                    6, -7, 8, -9, 10, -11,
                });

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

                var z = new DenseVector(22);

                z.AssignmentDivideConjugateNumeratorComplexInterleaved(x, y, startingOffsetA: 1, subLength: 11);

                var expected = new DenseVector(new Scalar[] {
                    2.0, -1.0, 18.0/13, -1.0/13, 50.0/41, -1.0/41, 98.0/85, -1.0/85,
                    72.0/145, -81.0/145, 11.0/221, 10.0/221, 8.0/5, -1.0/5, 32.0/25, -1.0/25,
                    72.0/61, -1.0/61, 128.0/113, -1.0/113, 10.0/9, 11.0/9
                });

                CheckEqual(expected, z);
            }

            public void StartingOffsetB()
            {
                var x = new DenseVector(new Scalar[] {
                    1, -2, 3, -4, 5, -6, 7, -8,
                    9, -0, 0, -1, 2, -3, 4, -5,
                    6, -7, 8, -9, 10, -11,
                });

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

                var z = new DenseVector(22);

                z.AssignmentDivideConjugateNumeratorComplexInterleaved(x, y, startingOffsetB: 1, subLength: 11);

                var expected = new DenseVector(new Scalar[] {
                    2.0, -1.0, 18.0/13, -1.0/13, 50.0/41, -1.0/41, 98.0/85, -1.0/85,
                    72.0/145, -81.0/145, 11.0/221, 10.0/221, 8.0/5, -1.0/5, 32.0/25, -1.0/25,
                    72.0/61, -1.0/61, 128.0/113, -1.0/113, 10.0/9, 11.0/9
                });

                CheckEqual(expected, z);
            }

            public void Length()
            {
                var x = new DenseVector(new Scalar[] {
                    1, -2, 3, -4, 5, -6, 7, -8,
                    9, -0, 0, -1, 2, -3, 4, -5,
                    6, -7, 8, -9, 10, -11, 101,
                });

                var y = new DenseVector(new Scalar[] {
                    0, 1, 2, 3, 4, 5, 6, 7,
                    8, 9, 10, 11, 1, 2, 3, 4,
                    5, 6, 7, 8, 9, 0, 102, 103,
                });

                var z = new DenseVector(23);
                z[22] = 100;

                z.AssignmentDivideConjugateNumeratorComplexInterleaved(x, y, subLength: 11);

                var expected = new DenseVector(new Scalar[] {
                    2.0, -1.0, 18.0/13, -1.0/13, 50.0/41, -1.0/41, 98.0/85, -1.0/85,
                    72.0/145, -81.0/145, 11.0/221, 10.0/221, 8.0/5, -1.0/5, 32.0/25, -1.0/25,
                    72.0/61, -1.0/61, 128.0/113, -1.0/113, 10.0/9, 11.0/9, 100
                });

                CheckEqual(expected, z);
            }
        }

        public class AssignmentDivideConjugateDenominatorComplexInterleaved : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.AssignmentDivideConjugateDenominatorComplexInterleaved);
            public override int OperationStride => 2;

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

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

                var z = new DenseVector(22);

                z.AssignmentDivideConjugateDenominatorComplexInterleaved(x, y);

                var expected = new DenseVector(new Scalar[] {
                    2.0, -1.0, 18.0/13, -1.0/13, 50.0/41, -1.0/41, 98.0/85, -1.0/85,
                    72.0/145, -81.0/145, 11.0/221, 10.0/221, 8.0/5, -1.0/5, 32.0/25, -1.0/25,
                    72.0/61, -1.0/61, 128.0/113, -1.0/113, 10.0/9, 11.0/9
                });

                CheckEqual(expected, z);
            }

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

                var y = new DenseVector(new Scalar[] {
                    0, -1, 2, -3, 4, -5, 6, -7,
                    8, -9, 10, -11, 1, -2, 3, -4,
                    5, -6, 7, -8, 9, -0,
                });
                var z = new DenseVector(23);
                z[0] = 100;

                z.AssignmentDivideConjugateDenominatorComplexInterleaved(x, y, startingOffsetThis: 1, subLength: 11);

                var expected = new DenseVector(new Scalar[] {
                    100, 2.0, -1.0, 18.0/13, -1.0/13, 50.0/41, -1.0/41, 98.0/85, -1.0/85,
                    72.0/145, -81.0/145, 11.0/221, 10.0/221, 8.0/5, -1.0/5, 32.0/25, -1.0/25,
                    72.0/61, -1.0/61, 128.0/113, -1.0/113, 10.0/9, 11.0/9
                });

                CheckEqual(expected, z);
            }

            public void StartingOffsetA()
            {
                var x = new DenseVector(new Scalar[] {
                    100, 1, 2, 3, 4, 5, 6, 7, 8,
                    9, 0, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11,
                });

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

                var z = new DenseVector(22);

                z.AssignmentDivideConjugateDenominatorComplexInterleaved(x, y, startingOffsetA: 1, subLength: 11);

                var expected = new DenseVector(new Scalar[] {
                    2.0, -1.0, 18.0/13, -1.0/13, 50.0/41, -1.0/41, 98.0/85, -1.0/85,
                    72.0/145, -81.0/145, 11.0/221, 10.0/221, 8.0/5, -1.0/5, 32.0/25, -1.0/25,
                    72.0/61, -1.0/61, 128.0/113, -1.0/113, 10.0/9, 11.0/9
                });

                CheckEqual(expected, z);
            }

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

                var y = new DenseVector(new Scalar[] {
                    100, 0, -1, 2, -3, 4, -5, 6, -7,
                    8, -9, 10, -11, 1, -2, 3, -4,
                    5, -6, 7, -8, 9, -0,
                });

                var z = new DenseVector(22);

                z.AssignmentDivideConjugateDenominatorComplexInterleaved(x, y, startingOffsetB: 1, subLength: 11);

                var expected = new DenseVector(new Scalar[] {
                    2.0, -1.0, 18.0/13, -1.0/13, 50.0/41, -1.0/41, 98.0/85, -1.0/85,
                    72.0/145, -81.0/145, 11.0/221, 10.0/221, 8.0/5, -1.0/5, 32.0/25, -1.0/25,
                    72.0/61, -1.0/61, 128.0/113, -1.0/113, 10.0/9, 11.0/9
                });

                CheckEqual(expected, z);
            }

            public void Length()
            {
                var x = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                    9, 0, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11, 101,
                });

                var y = new DenseVector(new Scalar[] {
                    0, -1, 2, -3, 4, -5, 6, -7,
                    8, -9, 10, -11, 1, -2, 3, -4,
                    5, -6, 7, -8, 9, -0, 102, 103,
                });

                var z = new DenseVector(23);
                z[22] = 100;

                z.AssignmentDivideConjugateDenominatorComplexInterleaved(x, y, subLength: 11);

                var expected = new DenseVector(new Scalar[] {
                    2.0, -1.0, 18.0/13, -1.0/13, 50.0/41, -1.0/41, 98.0/85, -1.0/85,
                    72.0/145, -81.0/145, 11.0/221, 10.0/221, 8.0/5, -1.0/5, 32.0/25, -1.0/25,
                    72.0/61, -1.0/61, 128.0/113, -1.0/113, 10.0/9, 11.0/9, 100
                });

                CheckEqual(expected, z);
            }
        }

        public class DivideConjugateComplexInterleaved : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.DivideConjugateComplexInterleaved);
            public override int OperationStride => 2;

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

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

                x.DivideConjugateComplexInterleaved(y);

                var expected = new DenseVector(new Scalar[] {
                    2.0, -1.0, 18.0/13, -1.0/13, 50.0/41, -1.0/41, 98.0/85, -1.0/85,
                    72.0/145, -81.0/145, 11.0/221, 10.0/221, 8.0/5, -1.0/5, 32.0/25, -1.0/25,
                    72.0/61, -1.0/61, 128.0/113, -1.0/113, 10.0/9, 11.0/9
                });

                CheckEqual(expected, x);
            }

            public void StartingOffsetThis()
            {
                var x = new DenseVector(new Scalar[] {
                    100, 1, 2, 3, 4, 5, 6, 7, 8,
                    9, 0, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11,
                });

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

                x.DivideConjugateComplexInterleaved(y, startingOffsetThis: 1, subLength: 11);

                var expected = new DenseVector(new Scalar[] {
                    100, 2.0, -1.0, 18.0/13, -1.0/13, 50.0/41, -1.0/41, 98.0/85, -1.0/85,
                    72.0/145, -81.0/145, 11.0/221, 10.0/221, 8.0/5, -1.0/5, 32.0/25, -1.0/25,
                    72.0/61, -1.0/61, 128.0/113, -1.0/113, 10.0/9, 11.0/9
                });

                CheckEqual(expected, x);
            }

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

                var y = new DenseVector(new Scalar[] {
                    100, 0, -1, 2, -3, 4, -5, 6, -7,
                    8, -9, 10, -11, 1, -2, 3, -4,
                    5, -6, 7, -8, 9, 0,
                });

                x.DivideConjugateComplexInterleaved(y, startingOffsetOther: 1, subLength: 11);

                var expected = new DenseVector(new Scalar[] {
                    2.0, -1.0, 18.0/13, -1.0/13, 50.0/41, -1.0/41, 98.0/85, -1.0/85,
                    72.0/145, -81.0/145, 11.0/221, 10.0/221, 8.0/5, -1.0/5, 32.0/25, -1.0/25,
                    72.0/61, -1.0/61, 128.0/113, -1.0/113, 10.0/9, 11.0/9
                });

                CheckEqual(expected, x);
            }

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

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

                x.DivideConjugateComplexInterleaved(y, subLength: 10);

                var expected = new DenseVector(new Scalar[] {
                    2.0, -1.0, 18.0/13, -1.0/13, 50.0/41, -1.0/41, 98.0/85, -1.0/85,
                    72.0/145, -81.0/145, 11.0/221, 10.0/221, 8.0/5, -1.0/5, 32.0/25, -1.0/25,
                    72.0/61, -1.0/61, 128.0/113, -1.0/113, 10, 11
                });

                CheckEqual(expected, x);
            }
        }

        public class DivideComplexInterleavedWithReal : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.DivideComplexInterleavedWithReal);
            public override int OperationStride => 2;

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

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

                x.DivideComplexInterleavedWithReal(y);

                var expected = new DenseVector(new Scalar[] {
                    1.0/8, 2.0/8, 3.0/9, 4.0/9, 5.0/10, 6.0/10, 7.0/11, 8.0/11,
                    9, 0, 0, 1.0/2, 2.0/3, 3.0/3, 4.0/4, 5.0/4,
                    6.0/5, 7.0/5, 8.0/6, 9.0/6, 10.0/7, 11.0/7
                });

                CheckEqual(expected, x);
            }

            public void StartingOffsetThis()
            {
                var x = new DenseVector(new Scalar[] {
                    100, 1, 2, 3, 4, 5, 6, 7, 8,
                    9, 0, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11,
                });

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

                x.DivideComplexInterleavedWithReal(y, startingIndexThis: 1, subLength: 11);

                var expected = new DenseVector(new Scalar[] {
                    100, 1.0/8, 2.0/8, 3.0/9, 4.0/9, 5.0/10, 6.0/10, 7.0/11, 8.0/11,
                    9, 0, 0, 1.0/2, 2.0/3, 3.0/3, 4.0/4, 5.0/4,
                    6.0/5, 7.0/5, 8.0/6, 9.0/6, 10.0/7, 11.0/7
                });

                CheckEqual(expected, x);
            }

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

                var y = new DenseVector(new Scalar[] {
                    100, 8, 9, 10, 11,
                    1, 2, 3, 4,
                    5, 6, 7,
                });

                x.DivideComplexInterleavedWithReal(y, startingIndexA: 1, subLength: 11);

                var expected = new DenseVector(new Scalar[] {
                    1.0/8, 2.0/8, 3.0/9, 4.0/9, 5.0/10, 6.0/10, 7.0/11, 8.0/11,
                    9, 0, 0, 1.0/2, 2.0/3, 3.0/3, 4.0/4, 5.0/4,
                    6.0/5, 7.0/5, 8.0/6, 9.0/6, 10.0/7, 11.0/7
                });

                CheckEqual(expected, x);
            }

            public void Length()
            {
                var x = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                    9, 0, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11, 101,
                });

                var y = new DenseVector(new Scalar[] {
                    8, 9, 10, 11,
                    1, 2, 3, 4,
                    5, 6, 7, 102, 103,
                });

                x.DivideComplexInterleavedWithReal(y, subLength: 11);

                var expected = new DenseVector(new Scalar[] {
                    1.0/8, 2.0/8, 3.0/9, 4.0/9, 5.0/10, 6.0/10, 7.0/11, 8.0/11,
                    9, 0, 0, 1.0/2, 2.0/3, 3.0/3, 4.0/4, 5.0/4,
                    6.0/5, 7.0/5, 8.0/6, 9.0/6, 10.0/7, 11.0/7, 101,
                });

                CheckEqual(expected, x);
            }
        }

        public class AssignmentDivideComplexInterleavedWithReal : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.AssignmentDivideComplexInterleavedWithReal);
            public override int OperationStride => 2;

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

                var y = new DenseVector(new Scalar[] {
                    8, 9, 10, 11,
                    1, 2, 3, 4,
                    5, 6, 7,
                });
                var z = new DenseVector(22);

                z.AssignmentDivideComplexInterleavedWithReal(x, y);

                var expected = new DenseVector(new Scalar[] {
                    1.0/8, 2.0/8, 3.0/9, 4.0/9, 5.0/10, 6.0/10, 7.0/11, 8.0/11,
                    9, 0, 0, 1.0/2, 2.0/3, 3.0/3, 4.0/4, 5.0/4,
                    6.0/5, 7.0/5, 8.0/6, 9.0/6, 10.0/7, 11.0/7
                });

                CheckEqual(expected, z);
            }

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

                var y = new DenseVector(new Scalar[] {
                    8, 9, 10, 11,
                    1, 2, 3, 4,
                    5, 6, 7,
                });
                var z = new DenseVector(23);
                z[0] = 100;

                z.AssignmentDivideComplexInterleavedWithReal(x, y, startingIndexThis: 1, subLength: 11);

                var expected = new DenseVector(new Scalar[] {
                    100, 1.0/8, 2.0/8, 3.0/9, 4.0/9, 5.0/10, 6.0/10, 7.0/11, 8.0/11,
                    9, 0, 0, 1.0/2, 2.0/3, 3.0/3, 4.0/4, 5.0/4,
                    6.0/5, 7.0/5, 8.0/6, 9.0/6, 10.0/7, 11.0/7
                });

                CheckEqual(expected, z);
            }

            public void StartingOffsetA()
            {
                var x = new DenseVector(new Scalar[] {
                    100, 1, 2, 3, 4, 5, 6, 7, 8,
                    9, 0, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11,
                });

                var y = new DenseVector(new Scalar[] {
                    8, 9, 10, 11,
                    1, 2, 3, 4,
                    5, 6, 7,
                });
                var z = new DenseVector(22);

                z.AssignmentDivideComplexInterleavedWithReal(x, y, startingIndexA: 1, subLength: 11);

                var expected = new DenseVector(new Scalar[] {
                    1.0/8, 2.0/8, 3.0/9, 4.0/9, 5.0/10, 6.0/10, 7.0/11, 8.0/11,
                    9, 0, 0, 1.0/2, 2.0/3, 3.0/3, 4.0/4, 5.0/4,
                    6.0/5, 7.0/5, 8.0/6, 9.0/6, 10.0/7, 11.0/7
                });

                CheckEqual(expected, z);
            }

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

                var y = new DenseVector(new Scalar[] {
                    100, 8, 9, 10, 11,
                    1, 2, 3, 4,
                    5, 6, 7,
                });
                var z = new DenseVector(22);

                z.AssignmentDivideComplexInterleavedWithReal(x, y, startingIndexB: 1, subLength: 11);

                var expected = new DenseVector(new Scalar[] {
                    1.0/8, 2.0/8, 3.0/9, 4.0/9, 5.0/10, 6.0/10, 7.0/11, 8.0/11,
                    9, 0, 0, 1.0/2, 2.0/3, 3.0/3, 4.0/4, 5.0/4,
                    6.0/5, 7.0/5, 8.0/6, 9.0/6, 10.0/7, 11.0/7
                });

                CheckEqual(expected, z);
            }

            public void Length()
            {
                var x = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                    9, 0, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11, 101,
                });

                var y = new DenseVector(new Scalar[] {
                    8, 9, 10, 11,
                    1, 2, 3, 4,
                    5, 6, 7, 102, 103,
                });
                var z = new DenseVector(23);
                z[22] = 101;

                z.AssignmentDivideComplexInterleavedWithReal(x, y, subLength: 11);

                var expected = new DenseVector(new Scalar[] {
                    1.0/8, 2.0/8, 3.0/9, 4.0/9, 5.0/10, 6.0/10, 7.0/11, 8.0/11,
                    9, 0, 0, 1.0/2, 2.0/3, 3.0/3, 4.0/4, 5.0/4,
                    6.0/5, 7.0/5, 8.0/6, 9.0/6, 10.0/7, 11.0/7, 101,
                });

                CheckEqual(expected, z);
            }
        }

        public class InverseDivideComplexInterleaved : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.InverseDivideComplexInterleaved);
            public override int OperationStride => 2;

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

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

                x.InverseDivideComplexInterleaved(y);

                var expected = new DenseVector(new Scalar[] {
                    2.0, -1.0, 18.0/13, -1.0/13, 50.0/41, -1.0/41, 98.0/85, -1.0/85,
                    72.0/145, -81.0/145, 11.0/221, 10.0/221, 8.0/5, -1.0/5, 32.0/25, -1.0/25,
                    72.0/61, -1.0/61, 128.0/113, -1.0/113, 10.0/9, 11.0/9
                });

                CheckEqual(expected, x);
            }

            public void StartingOffsetThis()
            {
                var x = new DenseVector(new Scalar[] {
                    100, 0, 1, 2, 3, 4, 5, 6, 7,
                    8, 9, 10, 11, 1, 2, 3, 4,
                    5, 6, 7, 8, 9, 0,
                });

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

                x.InverseDivideComplexInterleaved(y, startingOffsetThis: 1, subLength: 11);

                var expected = new DenseVector(new Scalar[] {
                    100, 2.0, -1.0, 18.0/13, -1.0/13, 50.0/41, -1.0/41, 98.0/85, -1.0/85,
                    72.0/145, -81.0/145, 11.0/221, 10.0/221, 8.0/5, -1.0/5, 32.0/25, -1.0/25,
                    72.0/61, -1.0/61, 128.0/113, -1.0/113, 10.0/9, 11.0/9
                });

                CheckEqual(expected, x);
            }

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

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

                x.InverseDivideComplexInterleaved(y, startingOffsetOther: 1, subLength: 11);

                var expected = new DenseVector(new Scalar[] {
                    2.0, -1.0, 18.0/13, -1.0/13, 50.0/41, -1.0/41, 98.0/85, -1.0/85,
                    72.0/145, -81.0/145, 11.0/221, 10.0/221, 8.0/5, -1.0/5, 32.0/25, -1.0/25,
                    72.0/61, -1.0/61, 128.0/113, -1.0/113, 10.0/9, 11.0/9
                });

                CheckEqual(expected, x);
            }

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

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

                x.InverseDivideComplexInterleaved(y, subLength: 10);

                var expected = new DenseVector(new Scalar[] {
                    2.0, -1.0, 18.0/13, -1.0/13, 50.0/41, -1.0/41, 98.0/85, -1.0/85,
                    72.0/145, -81.0/145, 11.0/221, 10.0/221, 8.0/5, -1.0/5, 32.0/25, -1.0/25,
                    72.0/61, -1.0/61, 128.0/113, -1.0/113, 9, 0
                });

                CheckEqual(expected, x);
            }
        }

        public class InverseDivideComplexInterleavedWithReal : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.InverseDivideComplexInterleavedWithReal);
            public override int OperationStride => 2;

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

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

                x.InverseDivideComplexInterleavedWithReal(y);

                var expected = new DenseVector(new Scalar[] {
                    8.0/5, -16.0/5, 27.0/25, -36.0/25, 50.0/61, -60.0/61, 77.0/113, -88.0/113,
                    1.0/9, 0, 0, -2, 6.0/13, -9.0/13, 16.0/41, -20.0/41,
                    6.0/17, -7.0/17, 48.0/145, -54.0/145, 70.0/221, -77.0/221
                });

                CheckEqual(expected, x);
            }

            public void StartingOffsetThis()
            {
                var x = new DenseVector(new Scalar[] {
                    100, 1, 2, 3, 4, 5, 6, 7, 8,
                    9, 0, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11,
                });

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

                x.InverseDivideComplexInterleavedWithReal(y, startingIndexThis: 1, subLength: 11);

                var expected = new DenseVector(new Scalar[] {
                    100, 8.0/5, -16.0/5, 27.0/25, -36.0/25, 50.0/61, -60.0/61, 77.0/113, -88.0/113,
                    1.0/9, 0, 0, -2, 6.0/13, -9.0/13, 16.0/41, -20.0/41,
                    6.0/17, -7.0/17, 48.0/145, -54.0/145, 70.0/221, -77.0/221
                });

                CheckEqual(expected, x);
            }

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

                var y = new DenseVector(new Scalar[] {
                    100, 8, 9, 10, 11,
                    1, 2, 3, 4,
                    5, 6, 7,
                });

                x.InverseDivideComplexInterleavedWithReal(y, startingIndexA: 1, subLength: 11);

                var expected = new DenseVector(new Scalar[] {
                    8.0/5, -16.0/5, 27.0/25, -36.0/25, 50.0/61, -60.0/61, 77.0/113, -88.0/113,
                    1.0/9, 0, 0, -2, 6.0/13, -9.0/13, 16.0/41, -20.0/41,
                    6.0/17, -7.0/17, 48.0/145, -54.0/145, 70.0/221, -77.0/221
                });

                CheckEqual(expected, x);
            }

            public void Length()
            {
                var x = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                    9, 0, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11, 101,
                });

                var y = new DenseVector(new Scalar[] {
                    8, 9, 10, 11,
                    1, 2, 3, 4,
                    5, 6, 7, 102, 103,
                });

                x.InverseDivideComplexInterleavedWithReal(y, subLength: 11);

                var expected = new DenseVector(new Scalar[] {
                    8.0/5, -16.0/5, 27.0/25, -36.0/25, 50.0/61, -60.0/61, 77.0/113, -88.0/113,
                    1.0/9, 0, 0, -2, 6.0/13, -9.0/13, 16.0/41, -20.0/41,
                    6.0/17, -7.0/17, 48.0/145, -54.0/145, 70.0/221, -77.0/221, 101,
                });

                CheckEqual(expected, x);
            }
        }

        public class AssignmentInverseDivideComplexInterleavedWithReal : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.AssignmentInverseDivideComplexInterleavedWithReal);
            public override int OperationStride => 2;

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

                var y = new DenseVector(new Scalar[] {
                    8, 9, 10, 11,
                    1, 2, 3, 4,
                    5, 6, 7,
                });
                var z = new DenseVector(22);

                z.AssignmentInverseDivideComplexInterleavedWithReal(y, x);

                var expected = new DenseVector(new Scalar[] {
                    8.0/5, -16.0/5, 27.0/25, -36.0/25, 50.0/61, -60.0/61, 77.0/113, -88.0/113,
                    1.0/9, 0, 0, -2, 6.0/13, -9.0/13, 16.0/41, -20.0/41,
                    6.0/17, -7.0/17, 48.0/145, -54.0/145, 70.0/221, -77.0/221,
                });

                CheckEqual(expected, z);
            }

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

                var y = new DenseVector(new Scalar[] {
                    8, 9, 10, 11,
                    1, 2, 3, 4,
                    5, 6, 7,
                });
                var z = new DenseVector(23);
                z[0] = 100;

                z.AssignmentInverseDivideComplexInterleavedWithReal(y, x, startingIndexThis: 1, subLength: 11);

                var expected = new DenseVector(new Scalar[] {
                    100, 8.0/5, -16.0/5, 27.0/25, -36.0/25, 50.0/61, -60.0/61, 77.0/113, -88.0/113,
                    1.0/9, 0, 0, -2, 6.0/13, -9.0/13, 16.0/41, -20.0/41,
                    6.0/17, -7.0/17, 48.0/145, -54.0/145, 70.0/221, -77.0/221,
                });

                CheckEqual(expected, z);
            }

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

                var y = new DenseVector(new Scalar[] {
                    100, 8, 9, 10, 11,
                    1, 2, 3, 4,
                    5, 6, 7,
                });
                var z = new DenseVector(22);

                z.AssignmentInverseDivideComplexInterleavedWithReal(y, x, startingIndexA: 1, subLength: 11);

                var expected = new DenseVector(new Scalar[] {
                    8.0/5, -16.0/5, 27.0/25, -36.0/25, 50.0/61, -60.0/61, 77.0/113, -88.0/113,
                    1.0/9, 0, 0, -2, 6.0/13, -9.0/13, 16.0/41, -20.0/41,
                    6.0/17, -7.0/17, 48.0/145, -54.0/145, 70.0/221, -77.0/221,
                });

                CheckEqual(expected, z);
            }

            public void StartingOffsetB()
            {
                var x = new DenseVector(new Scalar[] {
                    100, 1, 2, 3, 4, 5, 6, 7, 8,
                    9, 0, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11,
                });

                var y = new DenseVector(new Scalar[] {
                    8, 9, 10, 11,
                    1, 2, 3, 4,
                    5, 6, 7,
                });
                var z = new DenseVector(22);

                z.AssignmentInverseDivideComplexInterleavedWithReal(y, x, startingIndexB: 1, subLength: 11);

                var expected = new DenseVector(new Scalar[] {
                    8.0/5, -16.0/5, 27.0/25, -36.0/25, 50.0/61, -60.0/61, 77.0/113, -88.0/113,
                    1.0/9, 0, 0, -2, 6.0/13, -9.0/13, 16.0/41, -20.0/41,
                    6.0/17, -7.0/17, 48.0/145, -54.0/145, 70.0/221, -77.0/221,
                });

                CheckEqual(expected, z);
            }

            public void Length()
            {
                var x = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                    9, 0, 0, 1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10, 11, 101,
                });

                var y = new DenseVector(new Scalar[] {
                    8, 9, 10, 11,
                    1, 2, 3, 4,
                    5, 6, 7, 102, 103,
                });
                var z = new DenseVector(23);
                z[22] = 101;

                z.AssignmentInverseDivideComplexInterleavedWithReal(y, x, subLength: 11);

                var expected = new DenseVector(new Scalar[] {
                    8.0/5, -16.0/5, 27.0/25, -36.0/25, 50.0/61, -60.0/61, 77.0/113, -88.0/113,
                    1.0/9, 0, 0, -2, 6.0/13, -9.0/13, 16.0/41, -20.0/41,
                    6.0/17, -7.0/17, 48.0/145, -54.0/145, 70.0/221, -77.0/221, 101,
                });

                CheckEqual(expected, z);
            }
        }

        public class InverseDivideConjugateComplexInterleaved : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.InverseDivideConjugateComplexInterleaved);
            public override int OperationStride => 2;

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

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

                x.InverseDivideConjugateComplexInterleaved(y);

                var expected = new DenseVector(new Scalar[] {
                    2.0, -1.0, 18.0/13, -1.0/13, 50.0/41, -1.0/41, 98.0/85, -1.0/85,
                    72.0/145, -81.0/145, 11.0/221, 10.0/221, 8.0/5, -1.0/5, 32.0/25, -1.0/25,
                    72.0/61, -1.0/61, 128.0/113, -1.0/113, 10.0/9, 11.0/9
                });

                CheckEqual(expected, x);
            }

            public void StartingOffsetThis()
            {
                var x = new DenseVector(new Scalar[] {
                    100, 0, 1, 2, 3, 4, 5, 6, 7,
                    8, 9, 10, 11, 1, 2, 3, 4,
                    5, 6, 7, 8, 9, 0,
                });

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

                x.InverseDivideConjugateComplexInterleaved(y, startingOffsetThis: 1, subLength: 11);

                var expected = new DenseVector(new Scalar[] {
                    100, 2.0, -1.0, 18.0/13, -1.0/13, 50.0/41, -1.0/41, 98.0/85, -1.0/85,
                    72.0/145, -81.0/145, 11.0/221, 10.0/221, 8.0/5, -1.0/5, 32.0/25, -1.0/25,
                    72.0/61, -1.0/61, 128.0/113, -1.0/113, 10.0/9, 11.0/9
                });

                CheckEqual(expected, x);
            }

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

                var y = new DenseVector(new Scalar[] {
                    100, 1, -2, 3, -4, 5, -6, 7, -8,
                    9, -0, 0, -1, 2, -3, 4, -5,
                    6, -7, 8, -9, 10, -11,
                });

                x.InverseDivideConjugateComplexInterleaved(y, startingOffsetOther: 1, subLength: 11);

                var expected = new DenseVector(new Scalar[] {
                    2.0, -1.0, 18.0/13, -1.0/13, 50.0/41, -1.0/41, 98.0/85, -1.0/85,
                    72.0/145, -81.0/145, 11.0/221, 10.0/221, 8.0/5, -1.0/5, 32.0/25, -1.0/25,
                    72.0/61, -1.0/61, 128.0/113, -1.0/113, 10.0/9, 11.0/9
                });

                CheckEqual(expected, x);
            }

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

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

                x.InverseDivideConjugateComplexInterleaved(y, subLength: 10);

                var expected = new DenseVector(new Scalar[] {
                    2.0, -1.0, 18.0/13, -1.0/13, 50.0/41, -1.0/41, 98.0/85, -1.0/85,
                    72.0/145, -81.0/145, 11.0/221, 10.0/221, 8.0/5, -1.0/5, 32.0/25, -1.0/25,
                    72.0/61, -1.0/61, 128.0/113, -1.0/113, 9, 0
                });

                CheckEqual(expected, x);
            }
        }

        public class NaturalLogTests : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.NaturalLog);
            public override bool VectorBChanged => true;

            public void Basic()
            {
                DenseVector vector = 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),
                };

                DenseVector result = new DenseVector(size: 7);

                DenseVector expected = new Scalar[]
                {
                    0, 1, 2, 3, 4, 5, 6,
                };

                DenseVector.NaturalLog(vector, ref result);

                CheckEqual(expected, result);
            }

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

                DenseVector.NaturalLog(vector, ref vector);

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

            public void OffsetInput()
            {
                DenseVector vector = new Scalar[]
                {
                    100,
                    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),
                };

                DenseVector result = new DenseVector(size: 7);

                DenseVector expected = new Scalar[]
                {
                    0, 1, 2, 3, 4, 5, 6,
                };

                DenseVector.NaturalLog(vector, ref result, startingOffsetInput: 1, subLength: 7);

                CheckEqual(expected, result);
            }

            public void OffsetResult()
            {
                DenseVector vector = 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),
                };

                DenseVector result = new DenseVector(size: 8);
                result.Flush(100);

                DenseVector expected = new Scalar[]
                {
                    100, 0, 1, 2, 3, 4, 5, 6,
                };

                DenseVector.NaturalLog(vector, ref result, startingOffsetResults: 1, subLength: 7);

                CheckEqual(expected, result);
            }

            public void Length()
            {
                DenseVector vector = 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),
                };

                DenseVector result = new DenseVector(size: 8);
                result.Flush(100);

                DenseVector expected = new Scalar[]
                {
                    0, 1, 2, 3, 4, 5, 6, 100,
                };

                DenseVector.NaturalLog(vector, ref result, subLength: 7);

                CheckEqual(expected, result);
            }
        }

        public class Atan2 : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.AssignmentAtan2);

            public void Basic()
            {
                DenseVector num = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, };
                DenseVector denom = new Scalar[] { -3, -2, -1, 0, 1, 2, 3, };
                DenseVector actual = new DenseVector(size: 7);

                DenseVector expected = 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),
                    Math.Atan2(6, 3),
                };

                actual.AssignmentAtan2(num, denom);

                CheckEqual(expected, actual);
            }

            public void Offset()
            {
                DenseVector num = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, };
                DenseVector denom = new Scalar[] { -3, -2, -1, 0, 1, 2, 3, };
                DenseVector actual = new DenseVector(size: 8);
                actual.Flush(100);

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

                actual.AssignmentAtan2(num, denom, startingOffsetThis: 1, subLength: 7);

                CheckEqual(expected, actual);
            }

            public void OffsetA()
            {
                DenseVector num = new Scalar[] { 100, 0, 1, 2, 3, 4, 5, 6, };
                DenseVector denom = new Scalar[] { -3, -2, -1, 0, 1, 2, 3, };
                DenseVector actual = new DenseVector(size: 7);

                DenseVector expected = 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),
                    Math.Atan2(6, 3),
                };

                actual.AssignmentAtan2(num, denom, startingOffsetNum: 1, subLength: 7);

                CheckEqual(expected, actual);
            }

            public void OffsetB()
            {
                DenseVector num = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, };
                DenseVector denom = new Scalar[] { 100, -3, -2, -1, 0, 1, 2, 3, };
                DenseVector actual = new DenseVector(size: 7);

                DenseVector expected = 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),
                    Math.Atan2(6, 3),
                };

                actual.AssignmentAtan2(num, denom, startingOffsetDenom: 1, subLength: 7);

                CheckEqual(expected, actual);
            }

            public void Length()
            {
                DenseVector num = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, };
                DenseVector denom = new Scalar[] { -3, -2, -1, 0, 1, 2, 3, };
                DenseVector actual = new DenseVector(size: 8);
                actual.Flush(100);

                DenseVector expected = 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),
                    Math.Atan2(6, 3),
                    100,
                };

                actual.AssignmentAtan2(num, denom, subLength: 7);

                CheckEqual(expected, actual);
            }
        }

        public class SqrtTests : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.Sqrt);
            public override bool VectorBChanged => true;

            public void Basic()
            {
                DenseVector vector = new Scalar[] { 1, 4, 9, 16, 25, 36, 49, };
                DenseVector expected = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector actual = new DenseVector(size: 7);

                DenseVector.Sqrt(vector, ref actual);

                CheckEqual(expected, actual);
            }

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

                DenseVector.Sqrt(vector, ref vector);

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

            public void OffsetInput()
            {
                DenseVector vector = new Scalar[] { 100, 1, 4, 9, 16, 25, 36, 49, };
                DenseVector expected = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector actual = new DenseVector(size: 7);

                DenseVector.Sqrt(vector, ref actual, startingOffsetInput: 1, subLength: 7);

                CheckEqual(expected, actual);
            }

            public void OffsetOutput()
            {
                DenseVector vector = new Scalar[] { 1, 4, 9, 16, 25, 36, 49, };
                DenseVector expected = new Scalar[] { 100, 1, 2, 3, 4, 5, 6, 7, };
                DenseVector actual = new DenseVector(size: 8);
                actual.Flush(100);

                DenseVector.Sqrt(vector, ref actual, startingOffsetResults: 1, subLength: 7);

                CheckEqual(expected, actual);
            }

            public void Length()
            {
                DenseVector vector = new Scalar[] { 1, 4, 9, 16, 25, 36, 49, };
                DenseVector expected = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 100, };
                DenseVector actual = new DenseVector(size: 8);
                actual.Flush(100);

                DenseVector.Sqrt(vector, ref actual, subLength: 7);

                CheckEqual(expected, actual);
            }
        }

        public class ArgMinTests : BlasBoundsFixture
        {
            private static class MethodInfoFinder
            {
                private static DenseVector x = null;
                private static Scalar min;
                public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                    () => x.ArgMin(out min, (int)0, (int?)null));
            }

            public override MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;
            public override bool AllowsZeroLength => false;

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

                Scalar min;
                int index = array1.ArgMin(out min);

                CheckEqual(1, min);
                CheckEqual(6, index);
            }

            public void OutlessOverload()
            {
                DenseVector array1 = new Scalar[] { 7, 6, 5, 4, 3, 2, 1, };
                int index = array1.ArgMin();
                CheckEqual(6, index);
            }

            public void Offset()
            {
                DenseVector array1 = new Scalar[] { -5, 7, 6, 5, 4, 3, 2, 1, };

                Scalar min;
                int index = array1.ArgMin(out min, startingOffset: 1, subLength: 7);

                CheckEqual(1, min);
                CheckEqual(7, index);
            }

            public void Length()
            {
                DenseVector array1 = new Scalar[] { 7, 6, 5, 4, 3, 2, 1, -5, };

                Scalar min;
                int index = array1.ArgMin(out min, subLength: 7);

                CheckEqual(1, min);
                CheckEqual(6, index);
            }
        }

        public class ArgMaxTests : BlasBoundsFixture
        {
            private static class MethodInfoFinder
            {
                private static DenseVector x = null;
                private static Scalar max;
                public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                    () => x.ArgMax(out max, (int)0, (int?)null));
            }

            public override MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;
            public override bool AllowsZeroLength => false;

            public override string MethodName => nameof(DenseVector.ArgMax);

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

                Scalar max;
                int index = array1.ArgMax(out max);

                CheckEqual(7, max);
                CheckEqual(6, index);
            }

            public void OutlessOverload()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                int index = array1.ArgMax();
                CheckEqual(6, index);
            }

            public void Offset()
            {
                DenseVector array1 = new Scalar[] { 100, 1, 2, 3, 4, 5, 6, 7, };

                Scalar max;
                int index = array1.ArgMax(out max, startingOffset: 1, subLength: 7);

                CheckEqual(7, max);
                CheckEqual(7, index);
            }

            public void Length()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 100, };

                Scalar max;
                int index = array1.ArgMax(out max, subLength: 7);

                CheckEqual(7, max);
                CheckEqual(6, index);
            }

            public override void ZeroLength()
            {
                DenseVector array = new Scalar[] { };
                CheckThrow(typeof(Exception));
                array.ArgMax(out _);
            }
        }

        public class FMA : BlasBoundsFixture
        {
            private static class MethodInfoFinder
            {
                private static DenseVector x = null;
                public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                    () => x.FMA(x, x, (int)0, (int)0, (int)0, (int?)null));
            }

            public override MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;

            public void Basic()
            {
                DenseVector a = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector b = new Scalar[] { 2, 3, 5, 1, 2, 3, 4, };
                DenseVector c = new Scalar[] { -1, -1, -1, -1, -1, -1, -1, };

                c.FMA(a, b);

                DenseVector expected = new Scalar[] { 1, 5, 14, 3, 9, 17, 27, };

                CheckEqual(expected, c);
            }

            public void Offset()
            {
                DenseVector a = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector b = new Scalar[] { 2, 3, 5, 1, 2, 3, 4, };
                DenseVector c = new Scalar[] { 100, -1, -1, -1, -1, -1, -1, -1, };

                c.FMA(a, b, startingIndexThis: 1, subLength: 7);

                DenseVector expected = new Scalar[] { 100, 1, 5, 14, 3, 9, 17, 27, };

                CheckEqual(expected, c);
            }

            public void OffsetA()
            {
                DenseVector a = new Scalar[] { 100, 1, 2, 3, 4, 5, 6, 7, };
                DenseVector b = new Scalar[] { 2, 3, 5, 1, 2, 3, 4, };
                DenseVector c = new Scalar[] { -1, -1, -1, -1, -1, -1, -1, };

                c.FMA(a, b, startingIndexA: 1, subLength: 7);

                DenseVector expected = new Scalar[] { 1, 5, 14, 3, 9, 17, 27, };

                CheckEqual(expected, c);
            }

            public void OffsetB()
            {
                DenseVector a = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector b = new Scalar[] { 100, 2, 3, 5, 1, 2, 3, 4, };
                DenseVector c = new Scalar[] { -1, -1, -1, -1, -1, -1, -1, };

                c.FMA(a, b, startingIndexB: 1, subLength: 7);

                DenseVector expected = new Scalar[] { 1, 5, 14, 3, 9, 17, 27, };

                CheckEqual(expected, c);
            }

            public void Length()
            {
                DenseVector a = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector b = new Scalar[] { 2, 3, 5, 1, 2, 3, 4, };
                DenseVector c = new Scalar[] { -1, -1, -1, -1, -1, -1, -1, 100, 101, };

                c.FMA(a, b, subLength: 7);

                DenseVector expected = new Scalar[] { 1, 5, 14, 3, 9, 17, 27, 100, 101, };

                CheckEqual(expected, c);
            }
        }

        public class AssignmentFMA : BlasBoundsFixture
        {
            private static class MethodInfoFinder
            {
                private static DenseVector x = null;
                public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                    () => x.AssignmentFMA(x, x, x, (int)0, (int)0, (int)0, (int)0, (int?)null));
            }

            public override MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;

            public void Basic()
            {
                DenseVector a = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector b = new Scalar[] { 2, 3, 5, 1, 2, 3, 4, };
                DenseVector c = new Scalar[] { -1, -1, -1, -1, -1, -1, -1, };
                DenseVector actual = new DenseVector(7);

                actual.AssignmentFMA(c, a, b);

                DenseVector expected = new Scalar[] { 1, 5, 14, 3, 9, 17, 27, };

                CheckEqual(expected, actual);
            }

            public void Offset()
            {
                DenseVector a = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector b = new Scalar[] { 2, 3, 5, 1, 2, 3, 4, };
                DenseVector c = new Scalar[] { -1, -1, -1, -1, -1, -1, -1, };
                DenseVector actual = new DenseVector(8);
                actual[0] = 100;

                actual.AssignmentFMA(c, a, b, startingIndexThis: 1, subLength: 7);

                DenseVector expected = new Scalar[] { 100, 1, 5, 14, 3, 9, 17, 27, };

                CheckEqual(expected, actual);
            }

            public void OffsetSum()
            {
                DenseVector a = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector b = new Scalar[] { 2, 3, 5, 1, 2, 3, 4, };
                DenseVector c = new Scalar[] { 100, -1, -1, -1, -1, -1, -1, -1, };
                DenseVector actual = new DenseVector(7);

                actual.AssignmentFMA(c, a, b, startingIndexSum: 1, subLength: 7);

                DenseVector expected = new Scalar[] { 1, 5, 14, 3, 9, 17, 27, };

                CheckEqual(expected, actual);
            }

            public void OffsetA()
            {
                DenseVector a = new Scalar[] { 100, 1, 2, 3, 4, 5, 6, 7, };
                DenseVector b = new Scalar[] { 2, 3, 5, 1, 2, 3, 4, };
                DenseVector c = new Scalar[] { -1, -1, -1, -1, -1, -1, -1, };
                DenseVector actual = new DenseVector(7);

                actual.AssignmentFMA(c, a, b, startingIndexA: 1, subLength: 7);

                DenseVector expected = new Scalar[] { 1, 5, 14, 3, 9, 17, 27, };

                CheckEqual(expected, actual);
            }

            public void OffsetB()
            {
                DenseVector a = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector b = new Scalar[] { 100, 2, 3, 5, 1, 2, 3, 4, };
                DenseVector c = new Scalar[] { -1, -1, -1, -1, -1, -1, -1, };
                DenseVector actual = new DenseVector(7);

                actual.AssignmentFMA(c, a, b, startingIndexB: 1, subLength: 7);

                DenseVector expected = new Scalar[] { 1, 5, 14, 3, 9, 17, 27, };

                CheckEqual(expected, actual);
            }

            public void Length()
            {
                DenseVector a = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 104, 105, 106, };
                DenseVector b = new Scalar[] { 2, 3, 5, 1, 2, 3, 4, 103, };
                DenseVector c = new Scalar[] { -1, -1, -1, -1, -1, -1, -1, 101, 102, };
                DenseVector actual = new DenseVector(8);
                actual[7] = 100;

                actual.AssignmentFMA(c, a, b, subLength: 7);

                DenseVector expected = new Scalar[] { 1, 5, 14, 3, 9, 17, 27, 100, };

                CheckEqual(expected, actual);
            }
        }

        public class FMA4 : BlasBoundsFixture
        {
            private static class MethodInfoFinder
            {
                private static DenseVector x = null;
                public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                    () => x.FMA(default(Vector4), x, (int)0, (int)0, (int?)null));
            }

            public override MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;

            public void Basic()
            {
                DenseVector x = new Scalar[] { 2, 3, 4, 5, 6, 7, 8, };
                DenseVector a = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };

                var pattern = new Vector4(5, 4, 3, 2);

                x.FMA(pattern, a);

                DenseVector expected = new Scalar[] { 7, 11, 13, 13, 31, 31, 29, };

                CheckEqual(expected, x);
            }

            public void Offset()
            {
                DenseVector x = new Scalar[] { 100, 2, 3, 4, 5, 6, 7, 8, };
                DenseVector a = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };

                var pattern = new Vector4(5, 4, 3, 2);

                x.FMA(pattern, a, startingIndexThis: 1, subLength: 7);

                DenseVector expected = new Scalar[] { 100, 7, 11, 13, 13, 31, 31, 29, };

                CheckEqual(expected, x);
            }

            public void OffsetA()
            {
                DenseVector x = new Scalar[] { 2, 3, 4, 5, 6, 7, 8, };
                DenseVector a = new Scalar[] { 100, 1, 2, 3, 4, 5, 6, 7, };

                var pattern = new Vector4(5, 4, 3, 2);

                x.FMA(pattern, a, startingIndexA: 1, subLength: 7);

                DenseVector expected = new Scalar[] { 7, 11, 13, 13, 31, 31, 29, };

                CheckEqual(expected, x);
            }

            public void Length()
            {
                DenseVector x = new Scalar[] { 2, 3, 4, 5, 6, 7, 8, 101, 102, };
                DenseVector a = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };

                var pattern = new Vector4(5, 4, 3, 2);

                x.FMA(pattern, a, subLength: 7);

                DenseVector expected = new Scalar[] { 7, 11, 13, 13, 31, 31, 29, 101, 102, };

                CheckEqual(expected, x);
            }
        }

        public class FMAComplexInterleaved : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.FMAComplexInterleaved);
            public override int OperationStride => 2;

            public void Basic()
            {
                var z = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                    1, 2, 3, 4, 5, 6, 7, 8,
                    1, 2, 3, 4, 5, 6,
                });

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

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

                z.FMAComplexInterleaved(x, y);

                var expected = new DenseVector(new Scalar[] {
                    -1, 3, -3, 21, -5, 55, -7, 105,
                    73, 83, -8, 14, 1, 13, -1, 39,
                    -11, 73, -13, 131, 95, 105
                });

                CheckEqual(expected, z);
            }

            public void Offset()
            {
                var z = new DenseVector(new Scalar[] {
                    100, 1, 2, 3, 4, 5, 6, 7, 8,
                });

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

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

                z.FMAComplexInterleaved(x, y, startingIndexThis: 1, subLength: 4);

                var expected = new DenseVector(new Scalar[] {
                    100, -1, 3, -3, 21, -5, 55, -7, 105,
                });

                CheckEqual(expected, z);
            }

            public void OffsetA()
            {
                var z = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                });

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

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

                z.FMAComplexInterleaved(x, y, startingIndexA: 1, subLength: 4);

                var expected = new DenseVector(new Scalar[] {
                    -1, 3, -3, 21, -5, 55, -7, 105,
                });

                CheckEqual(expected, z);
            }

            public void OffsetB()
            {
                var z = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                });

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

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

                z.FMAComplexInterleaved(x, y, startingIndexB: 1, subLength: 4);

                var expected = new DenseVector(new Scalar[] {
                    -1, 3, -3, 21, -5, 55, -7, 105,
                });

                CheckEqual(expected, z);
            }

            public void Length()
            {
                var z = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                });

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

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

                z.FMAComplexInterleaved(x, y, subLength: 3);

                var expected = new DenseVector(new Scalar[] {
                    -1, 3, -3, 21, -5, 55, 7, 8,
                });

                CheckEqual(expected, z);
            }
        }

        public class AssignmentFMAComplexInterleaved : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.AssignmentFMAComplexInterleaved);
            public override int OperationStride => 2;

            public void Basic()
            {
                var z = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                    1, 2, 3, 4, 5, 6, 7, 8,
                    1, 2, 3, 4, 5, 6,
                });

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

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

                var w = new DenseVector(22);

                w.AssignmentFMAComplexInterleaved(z, x, y);

                var expected = new DenseVector(new Scalar[] {
                    -1, 3, -3, 21, -5, 55, -7, 105,
                    73, 83, -8, 14, 1, 13, -1, 39,
                    -11, 73, -13, 131, 95, 105
                });

                CheckEqual(expected, w);
            }

            public void OffsetThis()
            {
                var z = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                });

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

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

                var w = new DenseVector(9);
                w[0] = 100;

                w.AssignmentFMAComplexInterleaved(z, x, y, startingIndexThis: 1, subLength: 4);

                var expected = new DenseVector(new Scalar[] {
                    100, -1, 3, -3, 21, -5, 55, -7, 105,
                });

                CheckEqual(expected, w);
            }

            public void OffsetSum()
            {
                var z = new DenseVector(new Scalar[] {
                    100, 1, 2, 3, 4, 5, 6, 7, 8,
                });

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

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

                var w = new DenseVector(8);

                w.AssignmentFMAComplexInterleaved(z, x, y, startingIndexSum: 1, subLength: 4);

                var expected = new DenseVector(new Scalar[] {
                    -1, 3, -3, 21, -5, 55, -7, 105,
                });

                CheckEqual(expected, w);
            }

            public void OffsetA()
            {
                var z = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                });

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

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

                var w = new DenseVector(8);

                w.AssignmentFMAComplexInterleaved(z, x, y, startingIndexA: 1, subLength: 4);

                var expected = new DenseVector(new Scalar[] {
                    -1, 3, -3, 21, -5, 55, -7, 105,
                });

                CheckEqual(expected, w);
            }

            public void OffsetB()
            {
                var z = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                });

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

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

                var w = new DenseVector(8);

                w.AssignmentFMAComplexInterleaved(z, x, y, startingIndexB: 1, subLength: 4);

                var expected = new DenseVector(new Scalar[] {
                    -1, 3, -3, 21, -5, 55, -7, 105,
                });

                CheckEqual(expected, w);
            }

            public void Length()
            {
                var z = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                });

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

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

                var w = new DenseVector(8);
                w[6] = 3;
                w[7] = 4;

                w.AssignmentFMAComplexInterleaved(z, x, y, subLength: 3);

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

                CheckEqual(expected, w);
            }
        }

        public class FMAComplexInterleavedAndReal : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.FMAComplexInterleavedAndReal);
            public override int OperationStride => 2;

            public override void OffsetB_TooLarge()
            {
                Arguments.OffsetB = Arguments.B.Length + 1;
                Arguments.Length = 0;
                CheckThrow(typeof(Exception));
                CallMethodUnderTest();
            }

            public void Basic()
            {
                var z = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                    1, 2, 3, 4, 5, 6, 7, 8,
                    1, 2, 3, 4, 5, 6,
                });

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

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

                z.FMAComplexInterleavedAndReal(x, y);

                var expected = new DenseVector(new Scalar[] {
                    9, 18, 30, 40, 55, 66, 84, 96,
                    10, 2, 3, 6, 11, 15, 23, 28,
                    31, 37, 51, 58, 75, 83,
                });

                CheckEqual(expected, z);
            }

            public void Offset()
            {
                var z = new DenseVector(new Scalar[] {
                    100, 1, 2, 3, 4, 5, 6, 7, 8,
                    1, 2, 3, 4, 5, 6, 7, 8,
                    1, 2, 3, 4, 5, 6,
                });

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

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

                z.FMAComplexInterleavedAndReal(x, y, startingIndexThis: 1);

                var expected = new DenseVector(new Scalar[] {
                    100, 9, 18, 30, 40, 55, 66, 84, 96,
                    10, 2, 3, 6, 11, 15, 23, 28,
                    31, 37, 51, 58, 75, 83,
                });

                CheckEqual(expected, z);
            }

            public void OffsetA()
            {
                var z = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                    1, 2, 3, 4, 5, 6, 7, 8,
                    1, 2, 3, 4, 5, 6,
                });

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

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

                z.FMAComplexInterleavedAndReal(x, y, startingIndexA: 1);

                var expected = new DenseVector(new Scalar[] {
                    9, 18, 30, 40, 55, 66, 84, 96,
                    10, 2, 3, 6, 11, 15, 23, 28,
                    31, 37, 51, 58, 75, 83,
                });

                CheckEqual(expected, z);
            }

            public void OffsetB()
            {
                var z = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                    1, 2, 3, 4, 5, 6, 7, 8,
                    1, 2, 3, 4, 5, 6,
                });

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

                var y = new DenseVector(new Scalar[] {
                    100, 8, 9, 10, 11,
                    1, 2, 3, 4,
                    5, 6, 7,
                });

                z.FMAComplexInterleavedAndReal(x, y, startingIndexB: 1);

                var expected = new DenseVector(new Scalar[] {
                    9, 18, 30, 40, 55, 66, 84, 96,
                    10, 2, 3, 6, 11, 15, 23, 28,
                    31, 37, 51, 58, 75, 83,
                });

                CheckEqual(expected, z);
            }

            public void Length()
            {
                var z = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                    1, 2, 3, 4, 5, 6, 7, 8,
                    1, 2, 3, 4, 5, 6,
                });

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

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

                z.FMAComplexInterleavedAndReal(x, y, subLength: 10);

                var expected = new DenseVector(new Scalar[] {
                    9, 18, 30, 40, 55, 66, 84, 96,
                    10, 2, 3, 6, 11, 15, 23, 28,
                    31, 37, 51, 58, 5, 6,
                });

                CheckEqual(expected, z);
            }
        }

        public class AssignmentFMAComplexInterleavedAndReal : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.AssignmentFMAComplexInterleavedAndReal);
            public override int OperationStride => 2;

            /*
             * public override void OffsetB_TooLarge()
            {
                Arguments.OffsetB = Arguments.B.Length + 1;
                Arguments.Length = 0;
                CheckThrow(typeof(Exception));
                CallMethodUnderTest();
            }*/

            public void Basic()
            {
                var z = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                    1, 2, 3, 4, 5, 6, 7, 8,
                    1, 2, 3, 4, 5, 6,
                });

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

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

                var w = new DenseVector(22);

                w.AssignmentFMAComplexInterleavedAndReal(z, x, y);

                var expected = new DenseVector(new Scalar[] {
                    9, 18, 30, 40, 55, 66, 84, 96,
                    10, 2, 3, 6, 11, 15, 23, 28,
                    31, 37, 51, 58, 75, 83,
                });

                CheckEqual(expected, w);
            }

            public void OffsetThis()
            {
                var z = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                    1, 2, 3, 4, 5, 6, 7, 8,
                    1, 2, 3, 4, 5, 6,
                });

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

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

                var w = new DenseVector(23);
                w[0] = 100;

                w.AssignmentFMAComplexInterleavedAndReal(z, x, y, startingIndexThis: 1, subLength: 11);

                var expected = new DenseVector(new Scalar[] {
                    100, 9, 18, 30, 40, 55, 66, 84, 96,
                    10, 2, 3, 6, 11, 15, 23, 28,
                    31, 37, 51, 58, 75, 83,
                });

                CheckEqual(expected, w);
            }

            public void OffsetSum()
            {
                var z = new DenseVector(new Scalar[] {
                    100, 1, 2, 3, 4, 5, 6, 7, 8,
                    1, 2, 3, 4, 5, 6, 7, 8,
                    1, 2, 3, 4, 5, 6,
                });

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

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

                var w = new DenseVector(22);

                w.AssignmentFMAComplexInterleavedAndReal(z, x, y, startingIndexSum: 1, subLength: 11);

                var expected = new DenseVector(new Scalar[] {
                    9, 18, 30, 40, 55, 66, 84, 96,
                    10, 2, 3, 6, 11, 15, 23, 28,
                    31, 37, 51, 58, 75, 83,
                });

                CheckEqual(expected, w);
            }

            public void OffsetA()
            {
                var z = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                    1, 2, 3, 4, 5, 6, 7, 8,
                    1, 2, 3, 4, 5, 6,
                });

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

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

                var w = new DenseVector(22);

                w.AssignmentFMAComplexInterleavedAndReal(z, x, y, startingIndexA: 1, subLength: 11);

                var expected = new DenseVector(new Scalar[] {
                    9, 18, 30, 40, 55, 66, 84, 96,
                    10, 2, 3, 6, 11, 15, 23, 28,
                    31, 37, 51, 58, 75, 83,
                });

                CheckEqual(expected, w);
            }

            public void OffsetB()
            {
                var z = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                    1, 2, 3, 4, 5, 6, 7, 8,
                    1, 2, 3, 4, 5, 6,
                });

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

                var y = new DenseVector(new Scalar[] {
                    100, 8, 9, 10, 11,
                    1, 2, 3, 4,
                    5, 6, 7,
                });

                var w = new DenseVector(22);

                w.AssignmentFMAComplexInterleavedAndReal(z, x, y, startingIndexB: 1, subLength: 11);

                var expected = new DenseVector(new Scalar[] {
                    9, 18, 30, 40, 55, 66, 84, 96,
                    10, 2, 3, 6, 11, 15, 23, 28,
                    31, 37, 51, 58, 75, 83,
                });

                CheckEqual(expected, w);
            }

            public void Length()
            {
                var z = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                    1, 2, 3, 4, 5, 6, 7, 8,
                    1, 2, 3, 4, 5, 6,
                });

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

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

                var w = new DenseVector(22);
                w[20] = -3;
                w[21] = -4;

                w.AssignmentFMAComplexInterleavedAndReal(z, x, y, subLength: 10);

                var expected = new DenseVector(new Scalar[] {
                    9, 18, 30, 40, 55, 66, 84, 96,
                    10, 2, 3, 6, 11, 15, 23, 28,
                    31, 37, 51, 58, -3, -4,
                });

                CheckEqual(expected, w);
            }
        }

        public class FMAConjugateComplexInterleaved : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.FMAConjugateComplexInterleaved);
            public override int OperationStride => 2;

            public void Basic()
            {
                var z = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                    1, 2, 3, 4, 5, 6, 7, 8,
                    1, 2, 3, 4, 5, 6,
                });

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

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

                z.FMAConjugateComplexInterleaved(x, y);

                var expected = new DenseVector(new Scalar[] {
                    -1, 3, -3, 21, -5, 55, -7, 105,
                    73, 83, -8, 14, 1, 13, -1, 39,
                    -11, 73, -13, 131, 95, 105
                });

                CheckEqual(expected, z);
            }

            public void Offset()
            {
                var z = new DenseVector(new Scalar[] {
                    100, 1, 2, 3, 4, 5, 6, 7, 8,
                });

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

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

                z.FMAConjugateComplexInterleaved(x, y, startingIndexThis: 1, subLength: 4);

                var expected = new DenseVector(new Scalar[] {
                    100, -1, 3, -3, 21, -5, 55, -7, 105,
                });

                CheckEqual(expected, z);
            }

            public void OffsetA()
            {
                var z = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                });

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

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

                z.FMAConjugateComplexInterleaved(x, y, startingIndexA: 1, subLength: 4);

                var expected = new DenseVector(new Scalar[] {
                    -1, 3, -3, 21, -5, 55, -7, 105,
                });

                CheckEqual(expected, z);
            }

            public void OffsetB()
            {
                var z = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                });

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

                var y = new DenseVector(new Scalar[] {
                    100, 0, -1, 2, -3, 4, -5, 6, -7,
                });

                z.FMAConjugateComplexInterleaved(x, y, startingIndexB: 1, subLength: 4);

                var expected = new DenseVector(new Scalar[] {
                    -1, 3, -3, 21, -5, 55, -7, 105,
                });

                CheckEqual(expected, z);
            }

            public void Length()
            {
                var z = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                });

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

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

                z.FMAConjugateComplexInterleaved(x, y, subLength: 3);

                var expected = new DenseVector(new Scalar[] {
                    -1, 3, -3, 21, -5, 55, 7, 8,
                });

                CheckEqual(expected, z);
            }
        }

        public class AssignmentFMAConjugateComplexInterleaved : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.AssignmentFMAConjugateComplexInterleaved);
            public override int OperationStride => 2;

            public void Basic()
            {
                var z = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                    1, 2, 3, 4, 5, 6, 7, 8,
                    1, 2, 3, 4, 5, 6,
                });

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

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

                var w = new DenseVector(22);

                w.AssignmentFMAConjugateComplexInterleaved(z, x, y);

                var expected = new DenseVector(new Scalar[] {
                    -1, 3, -3, 21, -5, 55, -7, 105,
                    73, 83, -8, 14, 1, 13, -1, 39,
                    -11, 73, -13, 131, 95, 105
                });

                CheckEqual(expected, w);
            }

            public void OffsetThis()
            {
                var z = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                });

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

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

                var w = new DenseVector(9);
                w[0] = 100;

                w.AssignmentFMAConjugateComplexInterleaved(z, x, y, startingIndexThis: 1, subLength: 4);

                var expected = new DenseVector(new Scalar[] {
                    100, -1, 3, -3, 21, -5, 55, -7, 105,
                });

                CheckEqual(expected, w);
            }

            public void OffsetSum()
            {
                var z = new DenseVector(new Scalar[] {
                    100, 1, 2, 3, 4, 5, 6, 7, 8,
                });

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

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

                var w = new DenseVector(8);

                w.AssignmentFMAConjugateComplexInterleaved(z, x, y, startingIndexSum: 1, subLength: 4);

                var expected = new DenseVector(new Scalar[] {
                    -1, 3, -3, 21, -5, 55, -7, 105,
                });

                CheckEqual(expected, w);
            }

            public void OffsetA()
            {
                var z = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                });

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

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

                var w = new DenseVector(8);

                w.AssignmentFMAConjugateComplexInterleaved(z, x, y, startingIndexA: 1, subLength: 4);

                var expected = new DenseVector(new Scalar[] {
                    -1, 3, -3, 21, -5, 55, -7, 105,
                });

                CheckEqual(expected, w);
            }

            public void OffsetB()
            {
                var z = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                });

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

                var y = new DenseVector(new Scalar[] {
                    100, 0, -1, 2, -3, 4, -5, 6, -7,
                });

                var w = new DenseVector(8);

                w.AssignmentFMAConjugateComplexInterleaved(z, x, y, startingIndexB: 1, subLength: 4);

                var expected = new DenseVector(new Scalar[] {
                    -1, 3, -3, 21, -5, 55, -7, 105,
                });

                CheckEqual(expected, w);
            }

            public void Length()
            {
                var z = new DenseVector(new Scalar[] {
                    1, 2, 3, 4, 5, 6, 7, 8,
                });

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

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

                var w = new DenseVector(8);
                w[6] = 3;
                w[7] = 4;

                w.AssignmentFMAConjugateComplexInterleaved(z, x, y, subLength: 3);

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

                CheckEqual(expected, w);
            }
        }

        public class GivensRotation_RightTests : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.GivensRotation_Right);
            public override bool VectorAChanged => true;
            public override bool VectorBChanged => true;

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

                DenseVector expected1 = new Scalar[] { 11, 16, 21, 26, 31, 36, 41 };
                DenseVector expected2 = new Scalar[] {  3,  2,  1,  0, -1, -2, -3 };

                DenseVector.GivensRotation_Right(2.0, 3.0, array1, array2);

                CheckEqual(expected1, array1);
                CheckEqual(expected2, array2);
            }

            public void OffsetA()
            {
                DenseVector array1 = new Scalar[] { 100, 1, 2, 3, 4, 5, 6, 7, };
                DenseVector array2 = new Scalar[] { 3, 4, 5, 6, 7, 8, 9, };

                DenseVector expected1 = new Scalar[] { 100, 11, 16, 21, 26, 31, 36, 41 };
                DenseVector expected2 = new Scalar[] {       3,  2,  1,  0, -1, -2, -3 };

                DenseVector.GivensRotation_Right(2.0, 3.0, array1, array2, startingOffsetLeft: 1, subLength: 7);

                CheckEqual(expected1, array1);
                CheckEqual(expected2, array2);
            }

            public void OffsetB()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, };
                DenseVector array2 = new Scalar[] { 100, 3, 4, 5, 6, 7, 8, 9, };

                DenseVector expected1 = new Scalar[] {      11, 16, 21, 26, 31, 36, 41 };
                DenseVector expected2 = new Scalar[] { 100,  3,  2,  1,  0, -1, -2, -3 };

                DenseVector.GivensRotation_Right(2.0, 3.0, array1, array2, startingOffsetRight: 1, subLength: 7);

                CheckEqual(expected1, array1);
                CheckEqual(expected2, array2);
            }

            public void Length()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 100, };
                DenseVector array2 = new Scalar[] { 3, 4, 5, 6, 7, 8, 9, 101, 102, };

                DenseVector expected1 = new Scalar[] { 11, 16, 21, 26, 31, 36, 41, 100, };
                DenseVector expected2 = new Scalar[] {  3,  2,  1,  0, -1, -2, -3, 101, 102, };

                DenseVector.GivensRotation_Right(2.0, 3.0, array1, array2, subLength: 7);

                CheckEqual(expected1, array1);
                CheckEqual(expected2, array2);
            }
        }

        public class GivensRotation_LeftTests : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.GivensRotation_Left);
            public override bool VectorAChanged => true;
            public override bool VectorBChanged => true;

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

                DenseVector expected1 = new Scalar[] { -7, -8, -9, -10, -11, -12, -13, };
                DenseVector expected2 = new Scalar[] {  9, 14, 19,  24,  29,  34,  39, };

                DenseVector.GivensRotation_Left(2.0, 3.0, array1, array2);

                CheckEqual(expected1, array1);
                CheckEqual(expected2, array2);
            }

            public void OffsetA()
            {
                DenseVector array1 = new Scalar[] { 100, 1, 2, 3, 4, 5, 6, 7, };
                DenseVector array2 = new Scalar[] {      3, 4, 5, 6, 7, 8, 9, };

                DenseVector expected1 = new Scalar[] { 100, -7, -8, -9, -10, -11, -12, -13, };
                DenseVector expected2 = new Scalar[] {       9, 14, 19,  24,  29,  34,  39, };

                DenseVector.GivensRotation_Left(2.0, 3.0, array1, array2, startingOffsetLeft: 1, subLength: 7);

                CheckEqual(expected1, array1);
                CheckEqual(expected2, array2);
            }

            public void OffsetB()
            {
                DenseVector array1 = new Scalar[] {      1, 2, 3, 4, 5, 6, 7, };
                DenseVector array2 = new Scalar[] { 100, 3, 4, 5, 6, 7, 8, 9, };

                DenseVector expected1 = new Scalar[] {      -7, -8, -9, -10, -11, -12, -13, };
                DenseVector expected2 = new Scalar[] {  100, 9, 14, 19,  24,  29,  34,  39, };

                DenseVector.GivensRotation_Left(2.0, 3.0, array1, array2, startingOffsetRight: 1, subLength: 7);

                CheckEqual(expected1, array1);
                CheckEqual(expected2, array2);
            }

            public void Length()
            {
                DenseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 101, };
                DenseVector array2 = new Scalar[] { 3, 4, 5, 6, 7, 8, 9, 102, 103, };

                DenseVector expected1 = new Scalar[] { -7, -8, -9, -10, -11, -12, -13, 101, };
                DenseVector expected2 = new Scalar[] {  9, 14, 19,  24,  29,  34,  39, 102, 103, };

                DenseVector.GivensRotation_Left(2.0, 3.0, array1, array2, subLength: 7);

                CheckEqual(expected1, array1);
                CheckEqual(expected2, array2);
            }
        }

        public class PremultiplyByDescendingGivensSeries : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.PremultiplyByDescendingGivensRotations);
            public override bool VectorAChanged => true;

            public override void TestSetup()
            {
                base.TestSetup();

                Arguments.A.ChangeCapacity(Arguments.A.Length + 1);
                Arguments.A.SetLength(Arguments.A.Length + 1);
            }

            public void Works()
            {
                DenseVector col = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7, };
                DenseVector givensC = new Scalar[] { 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, };
                DenseVector givensS = new Scalar[]
                {
                    Math.Sqrt(1-0.1*0.1),
                    Math.Sqrt(1-0.2*0.2),
                    Math.Sqrt(1-0.3*0.3),
                    Math.Sqrt(1-0.4*0.4),
                    Math.Sqrt(1-0.5*0.5),
                    Math.Sqrt(1-0.6*0.6),
                    Math.Sqrt(1-0.7*0.7),
                };

                DenseVector expectedCol = new Scalar[]
                {
                    -0.994987437106620,
                    -1.939591794226542,
                    -2.712423727337440,
                    -3.116043655112210,
                    -2.900003498506830,
                    -1.81377204092480,
                    0.308146195156860,
                    10.314372,
                };

                DenseVector.PremultiplyByDescendingGivensRotations(ref col, givensC, givensS);
                CheckEqual(expectedCol, col);
            }

            public void Offset()
            {
                DenseVector col = new Scalar[] { 100, 0, 1, 2, 3, 4, 5, 6, 7, };
                DenseVector givensC = new Scalar[] { 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, };
                DenseVector givensS = new Scalar[]
                {
                    Math.Sqrt(1-0.1*0.1),
                    Math.Sqrt(1-0.2*0.2),
                    Math.Sqrt(1-0.3*0.3),
                    Math.Sqrt(1-0.4*0.4),
                    Math.Sqrt(1-0.5*0.5),
                    Math.Sqrt(1-0.6*0.6),
                    Math.Sqrt(1-0.7*0.7),
                };

                DenseVector expectedCol = new Scalar[]
                {
                    100,
                    -0.994987437106620,
                    -1.939591794226542,
                    -2.712423727337440,
                    -3.116043655112210,
                    -2.900003498506830,
                    -1.81377204092480,
                    0.308146195156860,
                    10.314372,
                };

                DenseVector.PremultiplyByDescendingGivensRotations(ref col, givensC, givensS, startingOffsetCol: 1, subLength: 7);
                CheckEqual(expectedCol, col);
            }

            public void OffsetA()
            {
                DenseVector col = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7, };
                DenseVector givensC = new Scalar[] { 100, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, };
                DenseVector givensS = new Scalar[]
                {
                    Math.Sqrt(1-0.1*0.1),
                    Math.Sqrt(1-0.2*0.2),
                    Math.Sqrt(1-0.3*0.3),
                    Math.Sqrt(1-0.4*0.4),
                    Math.Sqrt(1-0.5*0.5),
                    Math.Sqrt(1-0.6*0.6),
                    Math.Sqrt(1-0.7*0.7),
                };

                DenseVector expectedCol = new Scalar[]
                {
                    -0.994987437106620,
                    -1.939591794226542,
                    -2.712423727337440,
                    -3.116043655112210,
                    -2.900003498506830,
                    -1.81377204092480,
                    0.308146195156860,
                    10.314372,
                };

                DenseVector.PremultiplyByDescendingGivensRotations(ref col, givensC, givensS, startingOffsetGivensC: 1, subLength: 7);
                CheckEqual(expectedCol, col);
            }

            public void OffsetB()
            {
                DenseVector col = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7, };
                DenseVector givensC = new Scalar[] { 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, };
                DenseVector givensS = new Scalar[]
                {
                    100,
                    Math.Sqrt(1-0.1*0.1),
                    Math.Sqrt(1-0.2*0.2),
                    Math.Sqrt(1-0.3*0.3),
                    Math.Sqrt(1-0.4*0.4),
                    Math.Sqrt(1-0.5*0.5),
                    Math.Sqrt(1-0.6*0.6),
                    Math.Sqrt(1-0.7*0.7),
                };

                DenseVector expectedCol = new Scalar[]
                {
                    -0.994987437106620,
                    -1.939591794226542,
                    -2.712423727337440,
                    -3.116043655112210,
                    -2.900003498506830,
                    -1.81377204092480,
                    0.308146195156860,
                    10.314372,
                };

                DenseVector.PremultiplyByDescendingGivensRotations(ref col, givensC, givensS, startingOffsetGivensS: 1, subLength: 7);
                CheckEqual(expectedCol, col);
            }

            public void Length()
            {
                DenseVector col = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7, 100, };
                DenseVector givensC = new Scalar[] { 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 101, 102, };
                DenseVector givensS = new Scalar[]
                {
                    Math.Sqrt(1-0.1*0.1),
                    Math.Sqrt(1-0.2*0.2),
                    Math.Sqrt(1-0.3*0.3),
                    Math.Sqrt(1-0.4*0.4),
                    Math.Sqrt(1-0.5*0.5),
                    Math.Sqrt(1-0.6*0.6),
                    Math.Sqrt(1-0.7*0.7),
                    103, 104, 105,
                };

                DenseVector expectedCol = new Scalar[]
                {
                    -0.994987437106620,
                    -1.939591794226542,
                    -2.712423727337440,
                    -3.116043655112210,
                    -2.900003498506830,
                    -1.81377204092480,
                    0.308146195156860,
                    10.314372,
                    100,
                };

                DenseVector.PremultiplyByDescendingGivensRotations(ref col, givensC, givensS, subLength: 7);
                CheckEqual(expectedCol, col);
            }
        }

        public class PremultiplyByAscendingGivensSeries : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.PremultiplyByAscendingGivensRotations);
            public override bool VectorAChanged => true;

            public override void TestSetup()
            {
                base.TestSetup();

                Arguments.A.ChangeCapacity(Arguments.A.Length + 1);
                Arguments.A.SetLength(Arguments.A.Length + 1);
            }

            public void Works()
            {
                DenseVector col = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7, };
                DenseVector givensC = new Scalar[] { 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, };
                DenseVector givensS = new Scalar[]
                {
                    Math.Sqrt(1-0.1*0.1),
                    Math.Sqrt(1-0.2*0.2),
                    Math.Sqrt(1-0.3*0.3),
                    Math.Sqrt(1-0.4*0.4),
                    Math.Sqrt(1-0.5*0.5),
                    Math.Sqrt(1-0.6*0.6),
                    Math.Sqrt(1-0.7*0.7),
                };

                DenseVector expectedCol = new Scalar[]
                {
                    -1.7116335193,
                    0.1720256413,
                    0.6694748563,
                    2.5845269358,
                    2.2888895849,
                    5.2837015751,
                    3.52060006,
                    9.1848570571,
                };

                DenseVector.PremultiplyByAscendingGivensRotations(ref col, givensC, givensS);

                CheckEqual(expectedCol, col);
            }

            public void Offset()
            {
                DenseVector col = new Scalar[] { 100, 0, 1, 2, 3, 4, 5, 6, 7, };
                DenseVector givensC = new Scalar[] { 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, };
                DenseVector givensS = new Scalar[]
                {
                    Math.Sqrt(1-0.1*0.1),
                    Math.Sqrt(1-0.2*0.2),
                    Math.Sqrt(1-0.3*0.3),
                    Math.Sqrt(1-0.4*0.4),
                    Math.Sqrt(1-0.5*0.5),
                    Math.Sqrt(1-0.6*0.6),
                    Math.Sqrt(1-0.7*0.7),
                };

                DenseVector expectedCol = new Scalar[]
                {
                    100,
                    -1.7116335193,
                    0.1720256413,
                    0.6694748563,
                    2.5845269358,
                    2.2888895849,
                    5.2837015751,
                    3.52060006,
                    9.1848570571,
                };

                DenseVector.PremultiplyByAscendingGivensRotations(ref col, givensC, givensS, startingOffsetCol: 1, subLength: 7);

                CheckEqual(expectedCol, col);
            }

            public void OffsetA()
            {
                DenseVector col = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7, };
                DenseVector givensC = new Scalar[] { 100, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, };
                DenseVector givensS = new Scalar[]
                {
                    Math.Sqrt(1-0.1*0.1),
                    Math.Sqrt(1-0.2*0.2),
                    Math.Sqrt(1-0.3*0.3),
                    Math.Sqrt(1-0.4*0.4),
                    Math.Sqrt(1-0.5*0.5),
                    Math.Sqrt(1-0.6*0.6),
                    Math.Sqrt(1-0.7*0.7),
                };

                DenseVector expectedCol = new Scalar[]
                {
                    -1.7116335193,
                    0.1720256413,
                    0.6694748563,
                    2.5845269358,
                    2.2888895849,
                    5.2837015751,
                    3.52060006,
                    9.1848570571,
                };

                DenseVector.PremultiplyByAscendingGivensRotations(ref col, givensC, givensS, startingOffsetGivensC: 1, subLength: 7);

                CheckEqual(expectedCol, col);
            }

            public void OffsetB()
            {
                DenseVector col = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7, };
                DenseVector givensC = new Scalar[] { 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, };
                DenseVector givensS = new Scalar[]
                {
                    100,
                    Math.Sqrt(1-0.1*0.1),
                    Math.Sqrt(1-0.2*0.2),
                    Math.Sqrt(1-0.3*0.3),
                    Math.Sqrt(1-0.4*0.4),
                    Math.Sqrt(1-0.5*0.5),
                    Math.Sqrt(1-0.6*0.6),
                    Math.Sqrt(1-0.7*0.7),
                };

                DenseVector expectedCol = new Scalar[]
                {
                    -1.7116335193,
                    0.1720256413,
                    0.6694748563,
                    2.5845269358,
                    2.2888895849,
                    5.2837015751,
                    3.52060006,
                    9.1848570571,
                };

                DenseVector.PremultiplyByAscendingGivensRotations(ref col, givensC, givensS, startingOffsetGivensS: 1, subLength: 7);

                CheckEqual(expectedCol, col);
            }

            public void Length()
            {
                DenseVector col = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7, 100, };
                DenseVector givensC = new Scalar[] { 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 101, 102, };
                DenseVector givensS = new Scalar[]
                {
                    Math.Sqrt(1-0.1*0.1),
                    Math.Sqrt(1-0.2*0.2),
                    Math.Sqrt(1-0.3*0.3),
                    Math.Sqrt(1-0.4*0.4),
                    Math.Sqrt(1-0.5*0.5),
                    Math.Sqrt(1-0.6*0.6),
                    Math.Sqrt(1-0.7*0.7),
                    103, 104, 105,
                };

                DenseVector expectedCol = new Scalar[]
                {
                    -1.7116335193,
                    0.1720256413,
                    0.6694748563,
                    2.5845269358,
                    2.2888895849,
                    5.2837015751,
                    3.52060006,
                    9.1848570571,
                    100,
                };

                DenseVector.PremultiplyByAscendingGivensRotations(ref col, givensC, givensS, subLength: 7);

                CheckEqual(expectedCol, col);
            }
        }

        public class PremultiplyByDescendingGivensSeries_Permuting : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.PremultiplyByDescendingGivensRotations_Permuting);
            public override bool VectorAChanged => true;

            public override void TestSetup()
            {
                base.TestSetup();

                Arguments.A.ChangeCapacity(Arguments.A.Length + 1);
                Arguments.A.SetLength(Arguments.A.Length + 1);
            }

            public void Works()
            {
                DenseVector col = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7, };
                DenseVector givensC = new Scalar[] { 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, };
                DenseVector givensS = new Scalar[]
                {
                    Math.Sqrt(1-0.1*0.1),
                    Math.Sqrt(1-0.2*0.2),
                    Math.Sqrt(1-0.3*0.3),
                    Math.Sqrt(1-0.4*0.4),
                    Math.Sqrt(1-0.5*0.5),
                    Math.Sqrt(1-0.6*0.6),
                    Math.Sqrt(1-0.7*0.7),
                };

                DenseVector expectedCol = new Scalar[]
                {
                    0.100000000000000,
                    -0.574884608556315,
                    -1.159162935522344,
                    -1.616413085975629,
                    -1.890591450298270,
                    -1.892028939722855,
                    -1.4694555157,
                    -11.2423150933,
                };

                DenseVector.PremultiplyByDescendingGivensRotations_Permuting(ref col, givensC, givensS);

                CheckEqual(expectedCol, col);
            }

            public void Offset()
            {
                DenseVector col = new Scalar[] { 100, 0, 1, 2, 3, 4, 5, 6, 7, };
                DenseVector givensC = new Scalar[] { 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, };
                DenseVector givensS = new Scalar[]
                {
                    Math.Sqrt(1-0.1*0.1),
                    Math.Sqrt(1-0.2*0.2),
                    Math.Sqrt(1-0.3*0.3),
                    Math.Sqrt(1-0.4*0.4),
                    Math.Sqrt(1-0.5*0.5),
                    Math.Sqrt(1-0.6*0.6),
                    Math.Sqrt(1-0.7*0.7),
                };

                DenseVector expectedCol = new Scalar[]
                {
                    100,
                    0.100000000000000,
                    -0.574884608556315,
                    -1.159162935522344,
                    -1.616413085975629,
                    -1.890591450298270,
                    -1.892028939722855,
                    -1.4694555157,
                    -11.2423150933,
                };

                DenseVector.PremultiplyByDescendingGivensRotations_Permuting(ref col, givensC, givensS, startingOffsetCol: 1, subLength: 7);

                CheckEqual(expectedCol, col);
            }

            public void OffsetA()
            {
                DenseVector col = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7, };
                DenseVector givensC = new Scalar[] { 100, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, };
                DenseVector givensS = new Scalar[]
                {
                    Math.Sqrt(1-0.1*0.1),
                    Math.Sqrt(1-0.2*0.2),
                    Math.Sqrt(1-0.3*0.3),
                    Math.Sqrt(1-0.4*0.4),
                    Math.Sqrt(1-0.5*0.5),
                    Math.Sqrt(1-0.6*0.6),
                    Math.Sqrt(1-0.7*0.7),
                };

                DenseVector expectedCol = new Scalar[]
                {
                    0.100000000000000,
                    -0.574884608556315,
                    -1.159162935522344,
                    -1.616413085975629,
                    -1.890591450298270,
                    -1.892028939722855,
                    -1.4694555157,
                    -11.2423150933,
                };

                DenseVector.PremultiplyByDescendingGivensRotations_Permuting(ref col, givensC, givensS, startingOffsetGivensC: 1, subLength: 7);

                CheckEqual(expectedCol, col);
            }

            public void OffsetB()
            {
                DenseVector col = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7, };
                DenseVector givensC = new Scalar[] { 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, };
                DenseVector givensS = new Scalar[]
                {
                    100,
                    Math.Sqrt(1-0.1*0.1),
                    Math.Sqrt(1-0.2*0.2),
                    Math.Sqrt(1-0.3*0.3),
                    Math.Sqrt(1-0.4*0.4),
                    Math.Sqrt(1-0.5*0.5),
                    Math.Sqrt(1-0.6*0.6),
                    Math.Sqrt(1-0.7*0.7),
                };

                DenseVector expectedCol = new Scalar[]
                {
                    0.100000000000000,
                    -0.574884608556315,
                    -1.159162935522344,
                    -1.616413085975629,
                    -1.890591450298270,
                    -1.892028939722855,
                    -1.4694555157,
                    -11.2423150933,
                };

                DenseVector.PremultiplyByDescendingGivensRotations_Permuting(ref col, givensC, givensS, startingOffsetGivensS: 1, subLength: 7);

                CheckEqual(expectedCol, col);
            }

            public void Length()
            {
                DenseVector col = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7, 100, };
                DenseVector givensC = new Scalar[] { 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 101, 102, };
                DenseVector givensS = new Scalar[]
                {
                    Math.Sqrt(1-0.1*0.1),
                    Math.Sqrt(1-0.2*0.2),
                    Math.Sqrt(1-0.3*0.3),
                    Math.Sqrt(1-0.4*0.4),
                    Math.Sqrt(1-0.5*0.5),
                    Math.Sqrt(1-0.6*0.6),
                    Math.Sqrt(1-0.7*0.7),
                    103, 104, 105,
                };

                DenseVector expectedCol = new Scalar[]
                {
                    0.100000000000000,
                    -0.574884608556315,
                    -1.159162935522344,
                    -1.616413085975629,
                    -1.890591450298270,
                    -1.892028939722855,
                    -1.4694555157,
                    -11.2423150933,
                    100,
                };

                DenseVector.PremultiplyByDescendingGivensRotations_Permuting(ref col, givensC, givensS, subLength: 7);

                CheckEqual(expectedCol, col);
            }
        }

        public class PremultiplyByAscendingGivensSeries_Permuting : BlasBoundsFixture
        {
            public override string MethodName => nameof(DenseVector.PremultiplyByAscendingGivensRotations_Permuting);
            public override bool VectorAChanged => true;

            public override void TestSetup()
            {
                base.TestSetup();

                Arguments.A.ChangeCapacity(Arguments.A.Length + 1);
                Arguments.A.SetLength(Arguments.A.Length + 1);
            }

            public void Works()
            {
                DenseVector col = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7, };
                DenseVector givensC = new Scalar[] { 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, };
                DenseVector givensS = new Scalar[]
                {
                    Math.Sqrt(1-0.1*0.1),
                    Math.Sqrt(1-0.2*0.2),
                    Math.Sqrt(1-0.3*0.3),
                    Math.Sqrt(1-0.4*0.4),
                    Math.Sqrt(1-0.5*0.5),
                    Math.Sqrt(1-0.6*0.6),
                    Math.Sqrt(1-0.7*0.7),
                };

                DenseVector expectedCol = new Scalar[]
                {
                    0.1723613712,
                    -1.7149739901,
                    -3.4439482175,
                    -5.1592828766,
                    -6.333350014,
                    -6.2366933401,
                    -4.3478856457,
                    -0.7989999,
                };

                DenseVector.PremultiplyByAscendingGivensRotations_Permuting(ref col, givensC, givensS);

                CheckEqual(expectedCol, col);
            }

            public void Offset()
            {
                DenseVector col = new Scalar[] { 100, 0, 1, 2, 3, 4, 5, 6, 7, };
                DenseVector givensC = new Scalar[] { 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, };
                DenseVector givensS = new Scalar[]
                {
                    Math.Sqrt(1-0.1*0.1),
                    Math.Sqrt(1-0.2*0.2),
                    Math.Sqrt(1-0.3*0.3),
                    Math.Sqrt(1-0.4*0.4),
                    Math.Sqrt(1-0.5*0.5),
                    Math.Sqrt(1-0.6*0.6),
                    Math.Sqrt(1-0.7*0.7),
                };

                DenseVector expectedCol = new Scalar[]
                {
                    100,
                    0.1723613712,
                    -1.7149739901,
                    -3.4439482175,
                    -5.1592828766,
                    -6.333350014,
                    -6.2366933401,
                    -4.3478856457,
                    -0.7989999,
                };

                DenseVector.PremultiplyByAscendingGivensRotations_Permuting(ref col, givensC, givensS, startingOffsetCol: 1, subLength: 7);
                CheckEqual(expectedCol, col);
            }

            public void OffsetA()
            {
                DenseVector col = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7, };
                DenseVector givensC = new Scalar[] { 100, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, };
                DenseVector givensS = new Scalar[]
                {
                    Math.Sqrt(1-0.1*0.1),
                    Math.Sqrt(1-0.2*0.2),
                    Math.Sqrt(1-0.3*0.3),
                    Math.Sqrt(1-0.4*0.4),
                    Math.Sqrt(1-0.5*0.5),
                    Math.Sqrt(1-0.6*0.6),
                    Math.Sqrt(1-0.7*0.7),
                };

                DenseVector expectedCol = new Scalar[]
                {
                    0.1723613712,
                    -1.7149739901,
                    -3.4439482175,
                    -5.1592828766,
                    -6.333350014,
                    -6.2366933401,
                    -4.3478856457,
                    -0.7989999,
                };

                DenseVector.PremultiplyByAscendingGivensRotations_Permuting(ref col, givensC, givensS, startingOffsetGivensC: 1, subLength: 7);
                CheckEqual(expectedCol, col);
            }

            public void OffsetB()
            {
                DenseVector col = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7, };
                DenseVector givensC = new Scalar[] { 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, };
                DenseVector givensS = new Scalar[]
                {
                    100,
                    Math.Sqrt(1-0.1*0.1),
                    Math.Sqrt(1-0.2*0.2),
                    Math.Sqrt(1-0.3*0.3),
                    Math.Sqrt(1-0.4*0.4),
                    Math.Sqrt(1-0.5*0.5),
                    Math.Sqrt(1-0.6*0.6),
                    Math.Sqrt(1-0.7*0.7),
                };

                DenseVector expectedCol = new Scalar[]
                {
                    0.1723613712,
                    -1.7149739901,
                    -3.4439482175,
                    -5.1592828766,
                    -6.333350014,
                    -6.2366933401,
                    -4.3478856457,
                    -0.7989999,
                };

                DenseVector.PremultiplyByAscendingGivensRotations_Permuting(ref col, givensC, givensS, startingOffsetGivensS: 1, subLength: 7);
                CheckEqual(expectedCol, col);
            }

            public void Length()
            {
                DenseVector col = new Scalar[] { 0, 1, 2, 3, 4, 5, 6, 7, 100, };
                DenseVector givensC = new Scalar[] { 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 101, 102, };
                DenseVector givensS = new Scalar[]
                {
                    Math.Sqrt(1-0.1*0.1),
                    Math.Sqrt(1-0.2*0.2),
                    Math.Sqrt(1-0.3*0.3),
                    Math.Sqrt(1-0.4*0.4),
                    Math.Sqrt(1-0.5*0.5),
                    Math.Sqrt(1-0.6*0.6),
                    Math.Sqrt(1-0.7*0.7),
                    103, 104, 105,
                };

                DenseVector expectedCol = new Scalar[]
                {
                    0.1723613712,
                    -1.7149739901,
                    -3.4439482175,
                    -5.1592828766,
                    -6.333350014,
                    -6.2366933401,
                    -4.3478856457,
                    -0.7989999,
                    100,
                };

                DenseVector.PremultiplyByAscendingGivensRotations_Permuting(ref col, givensC, givensS, subLength: 7);
                CheckEqual(expectedCol, col);
            }
        }

        public class Pack_UnpackGivensRotations : UnitTestSharp.TestFixture
        {
            public void BasicRoundtrip()
            {
                // 9 elements so we're testing the x4 loop and the remainder loop
                DenseVector givensC = new Scalar[] { 0.8, 0.6, 0.8, 0.6, -0.8, -0.6, -0.8, -0.6, 0.5, };
                DenseVector givensS = new Scalar[] { -0.6, -0.8, 0.6, 0.8, -0.6, -0.8, 0.6, 0.8, 0.86602540378443864676372317075294, };
                var givensCClone = givensC.Clone();
                var givensSClone = givensS.Clone();

                DenseVector packed = new DenseVector(givensC.Length);

                DenseVector.PackGivensRotations(ref packed, givensC, givensS);

                // Check that the givens arrays aren't modified if we don't want them to be
                CheckEqual(givensCClone, givensC);
                CheckEqual(givensSClone, givensS);

                givensC.Flush(0);
                givensS.Flush(0);

                var packedClone = packed.Clone();

                DenseVector.UnpackGivensRotations(packed, ref givensC, ref givensS);

                // Check that unpacking doesn't modify the packed array if we don't want it to
                CheckEqual(packedClone, packed);

                // Check that we get the right numbers back
                CheckEqual(givensCClone, givensC);
                CheckEqual(givensSClone, givensS);
            }

            public void CanPackUnpackToCosineArray()
            {
                // 9 elements so we're testing the x4 loop and the remainder loop
                DenseVector givensC = new Scalar[] { 0.8, 0.6, 0.8, 0.6, -0.8, -0.6, -0.8, -0.6, 0.5, };
                DenseVector givensS = new Scalar[] { -0.6, -0.8, 0.6, 0.8, -0.6, -0.8, 0.6, 0.8, 0.86602540378443864676372317075294, };
                var givensCClone = givensC.Clone();
                var givensSClone = givensS.Clone();

                DenseVector.PackGivensRotations(ref givensC, givensC, givensS);

                // Check that the givens arrays aren't modified if we don't want them to be
                CheckEqual(givensSClone, givensS);

                givensS.Flush(0);

                DenseVector.UnpackGivensRotations(givensC, ref givensC, ref givensS);

                // Check that we get the right numbers back
                CheckEqual(givensCClone, givensC);
                CheckEqual(givensSClone, givensS);
            }

            public void CanPackUnpackToSineArray()
            {
                // 9 elements so we're testing the x4 loop and the remainder loop
                DenseVector givensC = new Scalar[] { 0.8, 0.6, 0.8, 0.6, -0.8, -0.6, -0.8, -0.6, 0.5, };
                DenseVector givensS = new Scalar[] { -0.6, -0.8, 0.6, 0.8, -0.6, -0.8, 0.6, 0.8, 0.86602540378443864676372317075294, };
                var givensCClone = givensC.Clone();
                var givensSClone = givensS.Clone();

                DenseVector.PackGivensRotations(ref givensS, givensC, givensS);

                // Check that the givens arrays aren't modified if we don't want them to be
                CheckEqual(givensCClone, givensC);

                givensC.Flush(0);

                DenseVector.UnpackGivensRotations(givensS, ref givensC, ref givensS);

                // Check that we get the right numbers back
                CheckEqual(givensCClone, givensC);
                CheckEqual(givensSClone, givensS);
            }

            public class PackGivensRotations : UnitTestSharp.TestFixture, ITestFixture
            {
                private static class MethodInfoFinder
                {
                    private static DenseVector x = null;
                    public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                        () => DenseVector.PackGivensRotations(ref x, x, x, (int)0, (int)0, (int?)null));
                }

                public MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;

                public void NegativeStartingIndex_Pack()
                {
                    DenseVector givensC = new Scalar[] { 0.8, 0.6, 0.8, 0.6, -0.8, -0.6, -0.8, -0.6, 0.5, };
                    DenseVector givensS = new Scalar[] { -0.6, -0.8, 0.6, 0.8, -0.6, -0.8, 0.6, 0.8, 0.86602540378443864676372317075294, };

                    DenseVector packed = new DenseVector(givensC.Length);

                    CheckThrow(typeof(Exception));
                    DenseVector.PackGivensRotations(ref packed, givensC, givensS, -1, 0, 1);
                }

                public void NegativeStartingIndex_Givens()
                {
                    DenseVector givensC = new Scalar[] { 0.8, 0.6, 0.8, 0.6, -0.8, -0.6, -0.8, -0.6, 0.5, };
                    DenseVector givensS = new Scalar[] { -0.6, -0.8, 0.6, 0.8, -0.6, -0.8, 0.6, 0.8, 0.86602540378443864676372317075294, };

                    DenseVector packed = new DenseVector(givensC.Length);

                    CheckThrow(typeof(Exception));
                    DenseVector.PackGivensRotations(ref packed, givensC, givensS, 0, -1, 1);
                }

                public void TooLargeStartingIndex_Pack()
                {
                    DenseVector givensC = new Scalar[] { 0.8, 0.6, 0.8, 0.6, -0.8, -0.6, -0.8, -0.6, 0.5, };
                    DenseVector givensS = new Scalar[] { -0.6, -0.8, 0.6, 0.8, -0.6, -0.8, 0.6, 0.8, 0.86602540378443864676372317075294, };

                    DenseVector packed = new DenseVector(givensC.Length);

                    CheckThrow(typeof(Exception));
                    DenseVector.PackGivensRotations(ref packed, givensC, givensS, 9, 0, 1);
                }

                public void TooLargeStartingIndex_Givens()
                {
                    DenseVector givensC = new Scalar[] { 0.8, 0.6, 0.8, 0.6, -0.8, -0.6, -0.8, -0.6, 0.5, };
                    DenseVector givensS = new Scalar[] { -0.6, -0.8, 0.6, 0.8, -0.6, -0.8, 0.6, 0.8, 0.86602540378443864676372317075294, };

                    DenseVector packed = new DenseVector(givensC.Length);

                    CheckThrow(typeof(Exception));
                    DenseVector.PackGivensRotations(ref packed, givensC, givensS, 0, 9, 1);
                }

                public void RunLengthTooLarge_Pack()
                {
                    DenseVector givensC = new Scalar[] { 0.8, 0.6, 0.8, 0.6, -0.8, -0.6, -0.8, -0.6, 0.5, };
                    DenseVector givensS = new Scalar[] { -0.6, -0.8, 0.6, 0.8, -0.6, -0.8, 0.6, 0.8, 0.86602540378443864676372317075294, };

                    DenseVector packed = new DenseVector(givensC.Length - 1);

                    CheckThrow(typeof(Exception));
                    DenseVector.PackGivensRotations(ref packed, givensC, givensS, 0, 0, 9);
                }

                public void RunLengthTooLarge_Givens()
                {
                    DenseVector givensC = new Scalar[] { 0.8, 0.6, 0.8, 0.6, -0.8, -0.6, -0.8, -0.6, 0.5, };
                    DenseVector givensS = new Scalar[] { -0.6, -0.8, 0.6, 0.8, -0.6, -0.8, 0.6, 0.8, 0.86602540378443864676372317075294, };

                    DenseVector packed = new DenseVector(givensC.Length + 1);

                    CheckThrow(typeof(Exception));
                    DenseVector.PackGivensRotations(ref packed, givensC, givensS, 0, 0, packed.Length);
                }

                public void RunLength0()
                {
                    DenseVector givensC = new Scalar[] { 0.8, 0.6, 0.8, 0.6, -0.8, -0.6, -0.8, -0.6, 0.5, };
                    DenseVector givensS = new Scalar[] { -0.6, -0.8, 0.6, 0.8, -0.6, -0.8, 0.6, 0.8, 0.86602540378443864676372317075294, };

                    DenseVector packed = new DenseVector(givensC.Length);
                    packed.Flush(-1);

                    var packedClone = packed.Clone();
                    var givensCClone = givensC.Clone();
                    var givensSClone = givensS.Clone();

                    DenseVector.PackGivensRotations(ref packed, givensC, givensS, 0, 0, 0);

                    CheckEqual(packedClone, packed);
                    CheckEqual(givensSClone, givensS);
                    CheckEqual(givensCClone, givensC);
                }

                public void RunLengthNegative()
                {
                    DenseVector givensC = new Scalar[] { 0.8, 0.6, 0.8, 0.6, -0.8, -0.6, -0.8, -0.6, 0.5, };
                    DenseVector givensS = new Scalar[] { -0.6, -0.8, 0.6, 0.8, -0.6, -0.8, 0.6, 0.8, 0.86602540378443864676372317075294, };

                    DenseVector packed = new DenseVector(givensC.Length);

                    CheckThrow(typeof(Exception));
                    DenseVector.PackGivensRotations(ref packed, givensC, givensS, 0, 0, -1);
                }
            }

            public class UnpackGivensRotations : UnitTestSharp.TestFixture, ITestFixture
            {
                private static class MethodInfoFinder
                {
                    private static DenseVector x = null;
                    public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                        () => DenseVector.UnpackGivensRotations(x, ref x, ref x, (int)0, (int)0, (int?)null));
                }

                public MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;

                public void NegativeStartingIndex_Pack()
                {
                    DenseVector packed = new Scalar[] { 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, };
                    DenseVector givensC = new DenseVector(packed.Length);
                    DenseVector givensS = new DenseVector(packed.Length);

                    CheckThrow(typeof(Exception));
                    DenseVector.UnpackGivensRotations(packed, ref givensC, ref givensS, -1, 0, 1);
                }

                public void NegativeStartingIndex_Givens()
                {
                    DenseVector packed = new Scalar[] { 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, };
                    DenseVector givensC = new DenseVector(packed.Length);
                    DenseVector givensS = new DenseVector(packed.Length);

                    CheckThrow(typeof(Exception));
                    DenseVector.UnpackGivensRotations(packed, ref givensC, ref givensS, 0, -1, 1);
                }

                public void TooLargeStartingIndex_Pack()
                {
                    DenseVector packed = new Scalar[] { 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, };
                    DenseVector givensC = new DenseVector(packed.Length);
                    DenseVector givensS = new DenseVector(packed.Length);

                    CheckThrow(typeof(Exception));
                    DenseVector.UnpackGivensRotations(packed, ref givensC, ref givensS, 7, 0, 1);
                }

                public void TooLargeStartingIndex_Givens()
                {
                    DenseVector packed = new Scalar[] { 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, };
                    DenseVector givensC = new DenseVector(packed.Length);
                    DenseVector givensS = new DenseVector(packed.Length);

                    CheckThrow(typeof(Exception));
                    DenseVector.UnpackGivensRotations(packed, ref givensC, ref givensS, 0, 7, 1);
                }

                public void RunLengthTooLarge_Pack()
                {
                    DenseVector packed = new Scalar[] { 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, };
                    DenseVector givensC = new DenseVector(packed.Length + 1);
                    DenseVector givensS = new DenseVector(packed.Length + 1);

                    CheckThrow(typeof(Exception));
                    DenseVector.UnpackGivensRotations(packed, ref givensC, ref givensS, 0, 0, 8);
                }

                public void RunLengthTooLarge_Givens()
                {
                    DenseVector packed = new Scalar[] { 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, };
                    DenseVector givensC = new DenseVector(packed.Length - 1);
                    DenseVector givensS = new DenseVector(packed.Length - 1);

                    CheckThrow(typeof(Exception));
                    DenseVector.UnpackGivensRotations(packed, ref givensC, ref givensS, 0, 0, packed.Length);
                }

                public void RunLength0()
                {
                    DenseVector packed = new Scalar[] { 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, };
                    DenseVector givensC = new DenseVector(packed.Length);
                    DenseVector givensS = new DenseVector(packed.Length);

                    givensC.Flush(-1);
                    givensS.Flush(-1);

                    var packedClone = packed.Clone();
                    var givensCClone = givensC.Clone();
                    var givensSClone = givensS.Clone();

                    DenseVector.UnpackGivensRotations(packed, ref givensC, ref givensS, 0, 0, 0);

                    CheckEqual(packedClone, packed);
                    CheckEqual(givensSClone, givensS);
                    CheckEqual(givensCClone, givensC);
                }

                public void RunLengthNegative()
                {
                    DenseVector packed = new Scalar[] { 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, };
                    DenseVector givensC = new DenseVector(packed.Length);
                    DenseVector givensS = new DenseVector(packed.Length);

                    CheckThrow(typeof(Exception));
                    DenseVector.UnpackGivensRotations(packed, ref givensC, ref givensS, 0, 0, -1);
                }
            }
        }

        public class PostMatrixMultiply : UnitTestSharp.TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(
                () => (new DenseVector())
                    .AssignmentPostMatrixMultiply(default(DenseVector), default(IRectangularMatrix)));

            public void NonSymmetricOrthogonal()
            {
                var matrix = new SquareMatrix(new Scalar[,] {
                    { 0, -1, },
                    { 1,  0, },
                });

                var expectedMatrix = matrix.Clone();

                var vector = new DenseVector(new Scalar[] { 3, 4 });
                var expected = new DenseVector(new Scalar[] { 4, -3 });
                var actual = new DenseVector(expected.Count);

                var expectedInput = vector.Clone();

                actual.AssignmentPostMatrixMultiply(vector, matrix);

                CheckEqual(expected, actual);
                CheckEqual(expectedMatrix, matrix);
                CheckEqual(expectedInput, vector);
            }

            public void NonSquare_Fat()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 0, -1, 1, },
                    { 1,  0, 1, },
                });

                var expectedMatrix = matrix.Clone();

                var vector = new DenseVector(new Scalar[] { 3, 4 });
                var expected = new DenseVector(new Scalar[] { 4, -3, 7 });
                var actual = new DenseVector(expected.Count);

                var expectedInput = vector.Clone();

                actual.AssignmentPostMatrixMultiply(vector, matrix);

                CheckEqual(expected, actual);
                CheckEqual(expectedMatrix, matrix);
                CheckEqual(expectedInput, vector);
            }

            public void NonSquare_Tall()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 0 },
                    { 1 },
                });

                var expectedMatrix = matrix.Clone();

                var vector = new DenseVector(new Scalar[] { 3, 4 });
                var expected = new DenseVector(new Scalar[] { 4 });
                var actual = new DenseVector(expected.Count);

                var expectedInput = vector.Clone();

                actual.AssignmentPostMatrixMultiply(vector, matrix);

                CheckEqual(expected, actual);
                CheckEqual(expectedMatrix, matrix);
                CheckEqual(expectedInput, vector);
            }

            public void DimsDontMatch()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 0, -1, 1, },
                    { 1,  0, 1, },
                });

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

                var actual = new DenseVector(3);

                CheckThrow(typeof(Exception));
                actual.AssignmentPostMatrixMultiply(vector, matrix);
            }

            public void Basic_x33()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 1, 2, 3, },
                    { 3, 2, 1, },
                    { 1, 0, 0, },
                });

                var expectedMatrix = matrix.Clone();

                var actual = new DenseVector[3];
                for (int i = 0; i < actual.Length; ++i)
                {
                    actual[i] = new DenseVector(actual.Length);

                    var temp = new DenseVector(actual.Length);
                    temp[i] = 1;
                    actual[i].AssignmentPostMatrixMultiply(temp, matrix);
                }

                var actualMat = new SquareMatrix(actual);

                CheckEqual(matrix.Transpose(), actualMat);
                CheckEqual(expectedMatrix, matrix);
            }

            public void SameInputOutput()
            {
                var matrix = new SquareMatrix(new Scalar[,] {
                    { 1, 0, },
                    { 0, 1, },
                });

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

                CheckThrow(typeof(Exception));
                vector.AssignmentPostMatrixMultiply(vector, matrix);
            }
        }

        public class PreMatrixMultiply : UnitTestSharp.TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(
                () => (new DenseVector())
                    .AssignmentPreMatrixMultiply(default(IRectangularMatrix), default(IVector)));

            public void NonSymmetricOrthogonal()
            {
                var matrix = new SquareMatrix(new Scalar[,] {
                    { 0, -1, },
                    { 1,  0, },
                });

                var expectedMatrix = matrix.Clone();

                var vector = new DenseVector(new Scalar[] { 3, 4 });
                var expected = new DenseVector(new Scalar[] { -4, 3 });
                var actual = new DenseVector(expected.Count);
                var expectedInput = vector.Clone();

                actual.AssignmentPreMatrixMultiply(matrix, vector);

                CheckEqual(expected, actual);
                CheckEqual(expectedMatrix, matrix);
                CheckEqual(expectedInput, vector);
            }

            public void NonSquare_Fat()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 0, -1, 1, },
                    { 1,  0, 1, },
                });

                var expectedMatrix = matrix.Clone();

                var vector = new DenseVector(new Scalar[] { 4, -3, 7 });
                var expected = new DenseVector(new Scalar[] { 10, 11 });
                var actual = new DenseVector(expected.Count);
                var expectedInput = vector.Clone();

                actual.AssignmentPreMatrixMultiply(matrix, vector);

                CheckEqual(expected, actual);
                CheckEqual(expectedMatrix, matrix);
                CheckEqual(expectedInput, vector);
            }

            public void NonSquare_Tall()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 0, 1 },
                });

                var expectedMatrix = matrix.Clone();

                var vector = new DenseVector(new Scalar[] { 3, 4 });
                var expected = new DenseVector(new Scalar[] { 4 });
                var actual = new DenseVector(expected.Count);
                var expectedInput = vector.Clone();

                actual.AssignmentPreMatrixMultiply(matrix, vector);

                CheckEqual(expected, actual);
                CheckEqual(expectedMatrix, matrix);
                CheckEqual(expectedInput, vector);
            }

            public void DimsDontMatch()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 0, -1, 1, },
                    { 1,  0, 1, },
                });

                var vector = new DenseVector(new Scalar[] { 3 });
                var actual = new DenseVector(3);

                CheckThrow(typeof(Exception));
                actual.AssignmentPreMatrixMultiply(matrix, vector);
            }

            public void AggressiveTesting()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 1, 2, },
                    { 3, 4, },
                });

                var expectedMatrix = matrix.Clone();

                var vector = new DenseVector(new Scalar[] { 5, 6, });
                var expected = new DenseVector(new Scalar[] { 17, 39 });
                var actual = new DenseVector(expected.Count);
                var expectedInput = vector.Clone();

                actual.AssignmentPreMatrixMultiply(matrix, vector);

                CheckEqual(expected, actual);
                CheckEqual(expectedMatrix, matrix);
                CheckEqual(expectedInput, vector);
            }

            public void SameInputOutput()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 1, 2, },
                    { 3, 4, },
                });

                var vector = new DenseVector(new Scalar[] { 5, 6, });

                CheckThrow(typeof(Exception));
                vector.AssignmentPreMatrixMultiply(matrix, vector);
            }
        }

        public class PreMatrixMADDTests : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(
                () => (new DenseVector())
                    .PreMatrixMADD(default(IRectangularMatrix), default(IVector), (int)0, (int)0));

            public void Basic_x22()
            {
                SquareMatrix matrix = new Scalar[,] {
                    { 1, 2, },
                    { 3, 4, },
                };

                DenseVector vector = new Scalar[] { 5, 6, };
                DenseVector target = new Scalar[] { 10, 11 };

                DenseVector expected = new Scalar[] { 27, 50, };

                target.PreMatrixMADD(matrix, vector);
                CheckEqual(expected, target);
            }

            public void Basic_x23()
            {
                RectangularMatrix matrix = new Scalar[,] {
                    { 1, 2, 3, },
                    { 4, 5, 6, },
                };

                DenseVector vector = new Scalar[] { 7, 8, 9, };
                DenseVector target = new Scalar[] { 10, 11 };

                DenseVector expected = new Scalar[] { 60, 133 };

                target.PreMatrixMADD(matrix, vector);
                CheckEqual(expected, target);
            }

            public void Basic_x32()
            {
                RectangularMatrix matrix = new Scalar[,] {
                    { 1, 2, },
                    { 3, 4, },
                    { 5, 6, },
                };

                DenseVector vector = new Scalar[] { 7, 8, };
                DenseVector target = new Scalar[] { 10, 11, 12, };

                DenseVector expected = new Scalar[] { 33, 64, 95 };

                target.PreMatrixMADD(matrix, vector);
                CheckEqual(expected, target);
            }

            public void Offset()
            {
                RectangularMatrix matrix = new Scalar[,] {
                    { 1, 2, },
                    { 3, 4, },
                    { 5, 6, },
                };

                DenseVector vector = new Scalar[] { 7, 8, };
                DenseVector target = new Scalar[] { 100, 10, 11, 12, };

                DenseVector expected = new Scalar[] { 100, 33, 64, 95 };

                target.PreMatrixMADD(matrix, vector, startingIndexThis: 1);
                CheckEqual(expected, target);
            }

            public void OffsetA()
            {
                RectangularMatrix matrix = new Scalar[,] {
                    { 1, 2, },
                    { 3, 4, },
                    { 5, 6, },
                };

                DenseVector vector = new Scalar[] { 100, 7, 8, };
                DenseVector target = new Scalar[] { 10, 11, 12, };

                DenseVector expected = new Scalar[] { 33, 64, 95 };

                target.PreMatrixMADD(matrix, vector, startingIndexX: 1);
                CheckEqual(expected, target);
            }

            public class BoundsTests : TestFixture
            {
                SquareMatrix matrix = new Scalar[,] {
                    { 1, 2, },
                    { 3, 4, },
                };

                DenseVector vector = new Scalar[] { 5, 6, };
                DenseVector target = new Scalar[] { 10, 11 };

                DenseVector expected = new Scalar[] { 27, 50, };

                public void NegativeOffset()
                {
                    CheckThrow();
                    target.PreMatrixMADD(matrix, vector, startingIndexThis: -1);
                }

                public void OffsetTooLarge()
                {
                    CheckThrow();
                    target.PreMatrixMADD(matrix, vector, startingIndexThis: 1);
                }

                public void NegativeOffsetA()
                {
                    CheckThrow();
                    target.PreMatrixMADD(matrix, vector, startingIndexX: -1);
                }

                public void OffsetATooLarge()
                {
                    CheckThrow();
                    target.PreMatrixMADD(matrix, vector, startingIndexX: 1);
                }
            }
        }

        public class Laplacian2DPointSourceGradient : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => GetMethodInfo(
                () => DenseVector.Laplacian2DPointSourceGradient(
                    default(DenseVector), default(DenseVector), default(DenseVector), Vector.Zero));

            public void Basic()
            {
                DenseVector x = new Scalar[] { 1, -4, 6, 0, -5, 2, 3 };
                DenseVector y = new Scalar[] { 2, 5, -3, 7, -6, -1, 3 };
                DenseVector p = new Scalar[] { 3, -2, 4, 1, -3, 2, 5 };

                var actual = DenseVector.Laplacian2DPointSourceGradient(x, y, p, new Vector(2, 4));

                var expected = new Vector(-2.4575716139, 4.1527117722);
                CheckEqual(expected, actual);
            }

            public void MisalignedLengths_X()
            {
                DenseVector x = new Scalar[] { 1, -4, 6, 0, -5, 2, 3, 1 };
                DenseVector y = new Scalar[] { 2, 5, -3, 7, -6, -1, 3 };
                DenseVector p = new Scalar[] { 3, -2, 4, 1, -3, 2, 5 };

                CheckThrow(typeof(Exception));
                DenseVector.Laplacian2DPointSourceGradient(x, y, p, new Vector(2, 4));
            }

            public void MisalignedLengths_Y()
            {
                DenseVector x = new Scalar[] { 1, -4, 6, 0, -5, 2, 3, };
                DenseVector y = new Scalar[] { 2, 5, -3, 7, -6, -1, 3, 1 };
                DenseVector p = new Scalar[] { 3, -2, 4, 1, -3, 2, 5 };

                var actual = DenseVector.Laplacian2DPointSourceGradient(x, y, p, new Vector(2, 4));
                var expected = new Vector(-2.4575716139, 4.1527117722);
                CheckEqual(expected, actual);
            }

            public void MisalignedLengths_Z()
            {
                DenseVector x = new Scalar[] { 1, -4, 6, 0, -5, 2, 3, };
                DenseVector y = new Scalar[] { 2, 5, -3, 7, -6, -1, 3 };
                DenseVector p = new Scalar[] { 3, -2, 4, 1, -3, 2, 5, 1 };

                var actual = DenseVector.Laplacian2DPointSourceGradient(x, y, p, new Vector(2, 4));
                var expected = new Vector(-2.4575716139, 4.1527117722);
                CheckEqual(expected, actual);
            }
        }

        public class Laplacian2DPanelSourceGradients : TestFixture, ITestFixture
        {
            private static class MethodInfoFinder
            {
                private static DenseVector x = null;
                public static MethodInfo MethodInfo =  LambdaHelper.GetMethodInfoForWrappedCall(
                    () => DenseVector.Laplacian2DPanelSourceGradients(ref x, ref x, new Scalar(2.0)));
            }

            public MethodInfo MethodInfo => MethodInfoFinder.MethodInfo;

            public void Basic()
            {
                DenseVector x = new Scalar[] { 1, -4, 6, 0, -5, 2, 3 };
                DenseVector y = new Scalar[] { 2, 5, -3, 7, -6, -1, 3 };
                Scalar panelLength = 2;

                DenseVector expectedX = new Scalar[] { 
                    0.3465735903, -0.1928312404, 0.2670412430, 0.0000000000, 
                    -0.1627112002, 0.8047189562, 0.3269632337 
                };
                DenseVector expectedY = new Scalar[] { 
                    0.7853981634, 0.2449786631, -0.1355277140, 0.2837941092, 
                    -0.1973955598, -0.4636476090, 0.3392926145 
                };

                DenseVector.Laplacian2DPanelSourceGradients(ref x, ref y, panelLength);

                CheckEqual(expectedX, x);
                CheckEqual(expectedY, y);
            }
        }

        private static MethodInfo GetMethodInfo<T>(Expression<Func<T>> func)
        {
            var baseMethod = LambdaHelper.GetMethodInfoForWrappedCall(func);

            var parameterTypes = baseMethod.GetParameters().Select(parameter => parameter.ParameterType).ToArray();

            // Find the corresponding method in the derived class
            return typeof(DenseVector).GetMethod(baseMethod.Name,
                BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static,
                binder: null, types: parameterTypes, modifiers: null);
        }

        public class TestAuditor : TestFixture
        {
            public void AllMethodsHaveTests()
            {
                var testedMethods = Assembly.GetExecutingAssembly()
                    .GetTypes()
                    .Where(type => typeof(ITestFixture).IsAssignableFrom(type) && !type.IsInterface && !type.IsAbstract)
                    .Select(fixtureType => (ITestFixture)Activator.CreateInstance(fixtureType))
                    .Select(fixture => fixture.MethodInfo)
                    .ToHashSet();

                var ignoredMethods = new HashSet<MethodInfo>() {
                    GetMethodInfo(() => (new DenseVector()).GetType()),
                    GetMethodInfo(() => (new DenseVector()).GetHashCode()),
                    
                    // These are thin wrappers around DenseVectorPool, which has its own tests.
                    GetMethodInfo(() => DenseVector.GrabFromScratchMemory(0)),
                    LambdaHelper.GetMethodInfoForWrappedCall(
                        () => DenseVector.ReturnToScratchMemory(default(DenseVector))),
                };

                var untestedMethods = typeof(DenseVector)
                    .GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly)
                    .Where(method => !testedMethods.Contains(method) && !ignoredMethods.Contains(method));

                foreach (var untestedMethod in untestedMethods)
                {
                    this.internals.RegisterFailedCheck($"No test fixture found for {untestedMethod}");
                }
            }
        }
    }
}