using Azimuth.SparseLinearAlgebra;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Security.Permissions;
using System.Text;
using System.Threading.Tasks;
using System.Xml.XPath;
using UnitTestSharp;

namespace Azimuth.UnitTests
{
    public class ComplexDenseVectorTests : UnitTestSharp.TestFixture
    {
        public class CtorTests : UnitTestSharp.TestFixture
        {
            public void Empty()
            {
                var x = new ComplexDenseVector();
                CheckEqual(0, x.Length);
            }

            public void FromArrayOfTuples()
            {
                var x = new ComplexDenseVector(new Complex[] { (1, 2), (3, 4), (5, 6), (7, 8), (9, 0) });
                var expected = new DenseVector(new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 });
                CheckEqual(expected, x.InterleavedCoefficients);
            }

            public void FromSize()
            {
                var x = new ComplexDenseVector(3);
                var expected = new DenseVector(new Scalar[] { 0, 0, 0, 0, 0, 0 });
                CheckEqual(expected, x.InterleavedCoefficients);
            }
        }

        public class InterleavedCoefficients : UnitTestSharp.TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => typeof(ComplexDenseVector).GetMethod("get_InterleavedCoefficients");

            public void ProducesDenseVector()
            {
                var x = new ComplexDenseVector(new Complex[] { (1, 2), (3, 4), (5, 6), (7, 8), (9, 0) });
                var expected = new DenseVector(new Scalar[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 });
                CheckEqual(expected, x.InterleavedCoefficients);
            }
        }

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

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] { (1, 2), (3, 4), (5, 6), (7, 8), (9, 0) });
                CheckEqual(5, x.Length);
            }
        }

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

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] { (1, 2), (3, 4), (5, 6), (7, 8), (9, 0) });
                CheckEqual(5, x.Count);
            }
        }

        public class ObjectEqualityTests : UnitTestSharp.TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => GetMethodInfo(() =>
                (new ComplexDenseVector()).Equals(new object())
            );

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

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

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

        public class EqualityTests : UnitTestSharp.TestFixture, ITestFixture
        {
            private static ComplexDenseVector _x = null;
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                _x.Equals(_x)
            );

            public void Equal()
            {
                var x = new ComplexDenseVector(new Complex[] { (1, 2), (3, 4), (5, 6), (7, 8), (9, 0) });
                var y = new ComplexDenseVector(new Complex[] { (1, 2), (3, 4), (5, 6), (7, 8), (9, 0) });
                Check(x.Equals(y));
                Check(y.Equals(x));
            }

            public void NotEqual_DifferentLengths()
            {
                var x = new ComplexDenseVector(new Complex[] { (1, 2), (3, 4), (5, 6), (7, 8), (9, 0) });
                var y = new ComplexDenseVector(new Complex[] { (1, 2), (3, 4), (5, 6), (7, 8), });
                CheckFalse(x.Equals(y));
                CheckFalse(y.Equals(x));
            }

            public void NotEqual_DifferentValues()
            {
                var x = new ComplexDenseVector(new Complex[] { (1, 2), (3, 4), (5, 6), (7, 8), (9, 0) });
                var y = new ComplexDenseVector(new Complex[] { (3, 2), (3, 4), (5, 6), (7, 8), (9, 0) });
                CheckFalse(x.Equals(y));
                CheckFalse(y.Equals(x));
            }
        }

        public class GetItem : UnitTestSharp.TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => typeof(ComplexDenseVector).GetMethod("get_Item");

            public void Basic()
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] { (0, 1), (2, 3), 6 });
                CheckEqual((0, 1), x[0]);
                CheckEqual((2, 3), x[1]);
                CheckEqual(6, x[2]);
            }

            public void NegativeIndex()
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] { (0, 1), (2, 3), 6 });
                CheckThrow(typeof(Exception));
                var a = x[-1];
            }

            public void IndexTooLarge()
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] { (0, 1), (2, 3), 6 });
                CheckThrow(typeof(Exception));
                var a = x[3];
            }
        }

        public class SetItem : UnitTestSharp.TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => typeof(ComplexDenseVector).GetMethod("set_Item");

            public void Basic()
            {
                ComplexDenseVector x = new ComplexDenseVector(3);
                x[0] = (0, 1);
                x[1] = (2, 3);
                x[2] = 6;
                CheckEqual((0, 1), x[0]);
                CheckEqual((2, 3), x[1]);
                CheckEqual(6, x[2]);
            }

            public void NegativeIndex()
            {
                ComplexDenseVector x = new ComplexDenseVector(3);
                CheckThrow(typeof(Exception));
                x[-1] = 7;
            }

            public void IndexTooLarge()
            {
                ComplexDenseVector x = new ComplexDenseVector(3);
                CheckThrow(typeof(Exception));
                x[3] = 7;
            }
        }

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

            public void Empty()
            {
                var x = new ComplexDenseVector(0);
                CheckEqual("<{empty}>", x.ToString());
            }

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] { (1, 2), (3, 4), 5 });
                CheckEqual("<(1 + 2i) : (3 + 4i) : 5>", x.ToString());
            }
        }

        public class IndexingOperator : UnitTestSharp.TestFixture
        {
            public void Get_Basic()
            {
                var x = new ComplexDenseVector(new Complex[] { (1, 2), (3, 4), (5, 6), (7, 8), (9, 0) });
                CheckEqual(x[0], (1, 2));
                CheckEqual(x[1], (3, 4));
                CheckEqual(x[2], (5, 6));
                CheckEqual(x[3], (7, 8));
                CheckEqual(x[4], (9, 0));
            }

            public void Get_NegativeIndex()
            {
                var x = new ComplexDenseVector(new Complex[] { (1, 2), (3, 4), (5, 6), (7, 8), (9, 0) });
                CheckThrow(typeof(IndexOutOfRangeException));
                var _ = x[-1];
            }

            public void Get_IndexTooLarge()
            {
                var x = new ComplexDenseVector(new Complex[] { (1, 2), (3, 4), (5, 6), (7, 8), (9, 0) });
                CheckThrow(typeof(IndexOutOfRangeException));
                var _ = x[5];
            }

            public void Set_Basic()
            {
                var x = new ComplexDenseVector(5);
                x[0] = (1, 2);
                x[1] = (3, 4);
                x[2] = (5, 6);
                x[3] = (7, 8);
                x[4] = (9, 0);

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

                CheckEqual(expected, x);
            }

            public void Set_NegativeIndex()
            {
                var x = new ComplexDenseVector(new Complex[] { (1, 2), (3, 4), (5, 6), (7, 8), (9, 0) });
                CheckThrow(typeof(IndexOutOfRangeException));
                x[-1] = (3, 4);
            }

            public void Set_IndexTooLarge()
            {
                var x = new ComplexDenseVector(new Complex[] { (1, 2), (3, 4), (5, 6), (7, 8), (9, 0) });
                CheckThrow(typeof(IndexOutOfRangeException));
                x[5] = (3, 4);
            }
        }

        public class ViewTests : UnitTestSharp.TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => GetMethodInfo(() => (new ComplexDenseVector()).GetView(0, 0));

            public class ManagedArray : UnitTestSharp.TestFixture
            {
                public void ViewEquality()
                {
                    var x = new ComplexDenseVector(new Complex[] { 0, 1, 2, 3, 4, 5, 6, 7 });
                    var actual = x.GetView(startingOffset: 2, length: 4);
                    var expected = new ComplexDenseVector(new Complex[] { 2, 3, 4, 5 });
                    CheckEqual(expected, actual);
                }

                public void ArrayAccessorGet()
                {
                    var x = new ComplexDenseVector(new Complex[] { 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 ComplexDenseVector(new Complex[] { 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 ComplexDenseVector(new Complex[] { 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 ComplexDenseVector(new Complex[] { 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 ComplexDenseVector(new Complex[] { 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 ComplexDenseVector(new Complex[] { 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 ComplexDenseVector(new Complex[] { 0, 1, 2, 3, 4, 5, 6, 7 });
                    CheckThrow(typeof(Exception));
                    var actual = x.GetView(startingOffset: 2, length: -1);
                }

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

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

        public class AssignmentTests : UnitTestSharp.TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().Assignment((ComplexDenseVector)null, (int)0, (int)0, (int?)null)
            );

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

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

                x.Assignment(y);
                CheckEqual(expected, x);
                CheckEqual(expected, y);
            }

            public void DoesNotModifySourceArray()
            {
                var x = new ComplexDenseVector(5);
                var y = new ComplexDenseVector(new Complex[] { (3, 2), (3, 4), (5, 6), (7, 8), (9, 0) });

                var expected = new ComplexDenseVector(new Complex[] { (3, 2), (11, 12), (5, 6), (7, 8), (9, 0) });

                x.Assignment(y);
                y[1] = (11, 12);
                CheckEqual(expected, y);
            }

            public void StartingIndexThis()
            {
                var x = new ComplexDenseVector(5);
                var y = new ComplexDenseVector(new Complex[] { (3, 2), (3, 4), (5, 6), (7, 8), (9, 0) });

                var expected = new ComplexDenseVector(new Complex[] { 0, 0, (3, 2), (3, 4), (5, 6) });

                x.Assignment(y, startingIndexThis: 2, subLength: 3);
                CheckEqual(expected, x);
            }

            public void StartingIndexThis_Negative()
            {
                var x = new ComplexDenseVector(5);
                var y = new ComplexDenseVector(new Complex[] { (3, 2), (3, 4), (5, 6), (7, 8), (9, 0) });

                CheckThrow(typeof(Exception));
                x.Assignment(y, startingIndexThis: -1, subLength: 0);
            }

            public void StartingIndexThis_TooLarge()
            {
                var x = new ComplexDenseVector(5);
                var y = new ComplexDenseVector(new Complex[] { (3, 2), (3, 4), (5, 6), (7, 8), (9, 0) });

                CheckThrow(typeof(Exception));
                x.Assignment(y, startingIndexThis: 6, subLength: 0);
            }

            public void StartingIndexOther()
            {
                var x = new ComplexDenseVector(5);
                var y = new ComplexDenseVector(new Complex[] { (3, 2), (3, 4), (5, 6), (7, 8), (9, 0) });

                var expected = new ComplexDenseVector(new Complex[] { (5, 6), (7, 8), (9, 0), 0, 0, });

                x.Assignment(y, startingIndexOther: 2, subLength: 3);
                CheckEqual(expected, x);
            }

            public void StartingIndexOther_Negative()
            {
                var x = new ComplexDenseVector(5);
                var y = new ComplexDenseVector(new Complex[] { (3, 2), (3, 4), (5, 6), (7, 8), (9, 0) });

                CheckThrow(typeof(Exception));
                x.Assignment(y, startingIndexOther: -1, subLength: 0);
            }

            public void StartingIndexOther_TooLarge()
            {
                var x = new ComplexDenseVector(5);
                var y = new ComplexDenseVector(new Complex[] { (3, 2), (3, 4), (5, 6), (7, 8), (9, 0) });

                CheckThrow(typeof(Exception));
                x.Assignment(y, startingIndexOther: 6, subLength: 0);
            }

            public void SubLength()
            {
                var x = new ComplexDenseVector(5);
                var y = new ComplexDenseVector(new Complex[] { (3, 2), (3, 4), (5, 6), (7, 8), (9, 0) });

                var expected = new ComplexDenseVector(new Complex[] { (3, 2), (3, 4), (5, 6), 0, 0, });

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

            public void SubLength_Negative()
            {
                var x = new ComplexDenseVector(5);
                var y = new ComplexDenseVector(new Complex[] { (3, 2), (3, 4), (5, 6), (7, 8), (9, 0) });

                CheckThrow(typeof(Exception));
                x.Assignment(y, subLength: -1);
            }

            public void SubLength_TooLarge()
            {
                var x = new ComplexDenseVector(5);
                var y = new ComplexDenseVector(new Complex[] { (3, 2), (3, 4), (5, 6), (7, 8), (9, 0) });

                CheckThrow(typeof(Exception));
                x.Assignment(y, subLength: 6);
            }
        }

        public class CountTests : TestFixture
        {
            public void Count()
            {
                var x = new ComplexDenseVector(new Complex[] { (1, 2), (3, 4), (5, 6) });
                CheckEqual(3, x.Count);
            }

            public void Length()
            {
                var x = new ComplexDenseVector(new Complex[] { (1, 2), (3, 4), (5, 6) });
                CheckEqual(3, x.Length);
            }
        }

        public class AddTests : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().Add((ComplexDenseVector)null, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (10, 11), (1, 2), (3, 4),
                    (5, 6), (7, 8), (9, 0),
                });

                x.Add(y);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( 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 DoesNotModifyOther()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (10, 11), (1, 2), (3, 4),
                    (5, 6), (7, 8), (9, 0),
                });

                x.Add(y);

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

                CheckEqual(expected, y);
            }

            public void StartingIndexThis()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (10, 11), (1, 2), (3, 4),
                    (5, 6), (7, 8), (9, 0),
                });

                x.Add(y, startingIndexThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    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 StartingIndexOther()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    100, (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (10, 11), (1, 2), (3, 4),
                    (5, 6), (7, 8), (9, 0),
                });

                x.Add(y, startingIndexOther: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( 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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (10, 11), (1, 2), (3, 4),
                    (5, 6), (7, 8), (9, 0),
                });

                x.Add(y, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( 1,  3), ( 5,  7), (9, 11), (13, 15),
                    ( 17, 9), (10, 12), ( 3, 5 ), (7, 9),
                    ( 11, 13), (15, 17), ( 10, 11 )
                });

                CheckEqual(expected, x);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

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

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Add(y, startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Add(y, startingIndexThis: 12, subLength: 0);
                }

                public void StartingIndexOther_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Add(y, startingIndexOther: -1, subLength: 0);
                }

                public void StartingIndexOther_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Add(y, startingIndexOther: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Add(y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Add(y, subLength: 12);
                }
            }
        }

        public class AddConjugateTests : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().AddConjugate((ComplexDenseVector)null, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, -1), (2, -3), (4, -5), (6, -7),
                    (8, -9), (10, -11), (1, -2), (3, -4),
                    (5, -6), (7, -8), (9, -0),
                });

                x.AddConjugate(y);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( 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 DoesNotModifyOther()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, -1), (2, -3), (4, -5), (6, -7),
                    (8, -9), (10, -11), (1, -2), (3, -4),
                    (5, -6), (7, -8), (9, -0),
                });

                x.AddConjugate(y);

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

                CheckEqual(expected, y);
            }

            public void StartingIndexThis()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    (0, -1), (2, -3), (4, -5), (6, -7),
                    (8, -9), (10, -11), (1, -2), (3, -4),
                    (5, -6), (7, -8), (9, -0),
                });

                x.AddConjugate(y, startingIndexThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    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 StartingIndexOther()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    100, (0, -1), (2, -3), (4, -5), (6, -7),
                    (8, -9), (10, -11), (1, -2), (3, -4),
                    (5, -6), (7, -8), (9, -0),
                });

                x.AddConjugate(y, startingIndexOther: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( 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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, -1), (2, -3), (4, -5), (6, -7),
                    (8, -9), (10, -11), (1, -2), (3, -4),
                    (5, -6), (7, -8), (9, -0),
                });

                x.AddConjugate(y, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( 1,  3), ( 5,  7), (9, 11), (13, 15),
                    ( 17, 9), (10, 12), ( 3, 5 ), (7, 9),
                    ( 11, 13), (15, 17), ( 10, 11 )
                });

                CheckEqual(expected, x);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

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

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.AddConjugate(y, startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.AddConjugate(y, startingIndexThis: 12, subLength: 0);
                }

                public void StartingIndexOther_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.AddConjugate(y, startingIndexOther: -1, subLength: 0);
                }

                public void StartingIndexOther_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.AddConjugate(y, startingIndexOther: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.AddConjugate(y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.AddConjugate(y, subLength: 12);
                }
            }
        }

        public class AssignmentAdd : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().AssignmentAdd((ComplexDenseVector)null, (ComplexDenseVector)null,
                    (int)0, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);

                z.AssignmentAdd(x, y);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( 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 OtherArraysAreUnmodified()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);

                z.AssignmentAdd(x, y);

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

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

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

            public void StartingIndexThis()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(12);
                z[0] = 100;

                z.AssignmentAdd(x, y, startingOffsetThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    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 StartingIndexA()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);

                z.AssignmentAdd(x, y, startingOffsetA: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( 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 StartingIndexB()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(11);

                z.AssignmentAdd(x, y, startingOffsetB: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( 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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);
                z.Flush((3, 4));

                z.AssignmentAdd(x, y, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( 1,  3), ( 5,  7), (9, 11), (13, 15),
                    ( 17, 9), (10, 12), ( 3, 5 ), (7, 9),
                    ( 11, 13), (15, 17), ( 3, 4 )
                });

                CheckEqual(expected, z);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

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

                ComplexDenseVector z = new ComplexDenseVector(11);

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentAdd(x, y, startingOffsetThis: -1);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentAdd(x, y, startingOffsetThis: 12, subLength: 0);
                }

                public void StartingIndexA_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentAdd(x, y, startingOffsetA: -1);
                }

                public void StartingIndexA_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentAdd(x, y, startingOffsetA: 12, subLength: 0);
                }

                public void StartingIndexB_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentAdd(x, y, startingOffsetB: -1);
                }

                public void StartingIndexB_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentAdd(x, y, startingOffsetB: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentAdd(x, y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentAdd(x, y, subLength: 12);
                }
            }
        }

        public class AssignmentAddConjugate : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().AssignmentAddConjugate((ComplexDenseVector)null, (ComplexDenseVector)null,
                    (int)0, (int)0, (int)0, (int?)null)
            );
            
            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);

                z.AssignmentAddConjugate(x, y);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( 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 OtherArraysAreUnmodified()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);

                z.AssignmentAddConjugate(x, y);

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

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

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

            public void StartingIndexThis()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(12);
                z[0] = 100;

                z.AssignmentAddConjugate(x, y, startingOffsetThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    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 StartingIndexA()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);

                z.AssignmentAddConjugate(x, y, startingOffsetA: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( 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 StartingIndexB()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(11);

                z.AssignmentAddConjugate(x, y, startingOffsetB: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( 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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);
                z.Flush((3, 4));

                z.AssignmentAddConjugate(x, y, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( 1,  3), ( 5,  7), (9, 11), (13, 15),
                    ( 17, 9), (10, 12), ( 3, 5 ), (7, 9),
                    ( 11, 13), (15, 17), ( 3, 4 )
                });

                CheckEqual(expected, z);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

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

                ComplexDenseVector z = new ComplexDenseVector(11);

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentAddConjugate(x, y, startingOffsetThis: -1);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentAddConjugate(x, y, startingOffsetThis: 12, subLength: 0);
                }

                public void StartingIndexA_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentAddConjugate(x, y, startingOffsetA: -1);
                }

                public void StartingIndexA_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentAddConjugate(x, y, startingOffsetA: 12, subLength: 0);
                }

                public void StartingIndexB_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentAddConjugate(x, y, startingOffsetB: -1);
                }

                public void StartingIndexB_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentAddConjugate(x, y, startingOffsetB: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentAddConjugate(x, y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentAddConjugate(x, y, subLength: 12);
                }
            }
        }

        public class Add_RealTests : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().Add((DenseVector)null, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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.Add(y);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 OtherArraysAreUnmodified()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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.Add(y);

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

                CheckEqual(expectedY, y);
            }

            public void StartingIndexThis()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    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.Add(y, startingIndexThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    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 StartingIndexOther()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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.Add(y, startingIndexOther: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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.Add(y, subLength: 10);

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

                CheckEqual(expected, x);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

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

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Add(y, startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Add(y, startingIndexThis: 12, subLength: 0);
                }

                public void StartingIndexA_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Add(y, startingIndexOther: -1, subLength: 0);
                }

                public void StartingIndexA_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Add(y, startingIndexOther: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Add(y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Add(y, subLength: 12);
                }
            }
        }

        public class AssignmentAdd_RealTests : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().AssignmentAdd((ComplexDenseVector)null, (DenseVector)null,
                    (int)0, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 actual = new ComplexDenseVector(11);
                actual.Flush((3, 4));
                actual.AssignmentAdd(x, y);

                var expected = new ComplexDenseVector(new Complex[] {
                    (9, 2), (12, 4), (15, 6), (18, 8),
                    (10, 0), (2, 1), (5, 3), (8, 5),
                    (11, 7), (14, 9), (17, 11),
                });

                CheckEqual(expected, actual);
            }

            public void OtherArrayIsUnmodified()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 actual = new ComplexDenseVector(11);
                actual.AssignmentAdd(x, y);

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

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

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

            public void StartingOffsetThis()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 actual = new ComplexDenseVector(12);
                actual.Flush((3, 4));

                actual.AssignmentAdd(x, y, startingIndexThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (3, 4),
                    (9, 2), (12, 4), (15, 6), (18, 8),
                    (10, 0), (2, 1), (5, 3), (8, 5),
                    (11, 7), (14, 9), (17, 11),
                });

                CheckEqual(expected, actual);
            }

            public void StartingOffsetA()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    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 actual = new ComplexDenseVector(11);

                actual.AssignmentAdd(x, y, startingIndexA: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (9, 2), (12, 4), (15, 6), (18, 8),
                    (10, 0), (2, 1), (5, 3), (8, 5),
                    (11, 7), (14, 9), (17, 11),
                });

                CheckEqual(expected, actual);
            }

            public void StartingOffsetB()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 actual = new ComplexDenseVector(11);

                actual.AssignmentAdd(x, y, startingIndexB: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (9, 2), (12, 4), (15, 6), (18, 8),
                    (10, 0), (2, 1), (5, 3), (8, 5),
                    (11, 7), (14, 9), (17, 11),
                });

                CheckEqual(expected, actual);
            }

            public void Sublength()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 actual = new ComplexDenseVector(11);
                actual.Flush((3, 4));

                actual.AssignmentAdd(x, y, subLength: 10);

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

                CheckEqual(expected, actual);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

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

                ComplexDenseVector actual = new ComplexDenseVector(11);

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentAdd(x, y, startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentAdd(x, y, startingIndexThis: 12, subLength: 0);
                }

                public void StartingIndexA_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentAdd(x, y, startingIndexA: -1, subLength: 0);
                }

                public void StartingIndexA_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentAdd(x, y, startingIndexA: 12, subLength: 0);
                }

                public void StartingIndexB_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentAdd(x, y, startingIndexB: -1, subLength: 0);
                }

                public void StartingIndexB_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentAdd(x, y, startingIndexB: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentAdd(x, y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentAdd(x, y, subLength: 12);
                }
            }
        }

        public class SubtractTests : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().Subtract((ComplexDenseVector)null, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (1, 1), (1, 1), (-1, 2), (4, 6),
                    (-2, -4), (-6, -8), (0, 1), (2, 3),
                    (6, 5), (4, 3), (2, 1),
                });

                x.Subtract(y);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( 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 DoesNotModifyOther()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (1, 1), (1, 1), (-1, 2), (4, 6),
                    (-2, -4), (-6, -8), (0, 1), (2, 3),
                    (6, 5), (4, 3), (2, 1),
                });

                x.Subtract(y);

                var expected = new ComplexDenseVector(new Complex[] {
                    (1, 1), (1, 1), (-1, 2), (4, 6),
                    (-2, -4), (-6, -8), (0, 1), (2, 3),
                    (6, 5), (4, 3), (2, 1),
                });

                CheckEqual(expected, y);
            }

            public void StartingIndexThis()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    (1, 1), (1, 1), (-1, 2), (4, 6),
                    (-2, -4), (-6, -8), (0, 1), (2, 3),
                    (6, 5), (4, 3), (2, 1),
                });

                x.Subtract(y, startingIndexThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    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 StartingIndexOther()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    100, (1, 1), (1, 1), (-1, 2), (4, 6),
                    (-2, -4), (-6, -8), (0, 1), (2, 3),
                    (6, 5), (4, 3), (2, 1),
                });

                x.Subtract(y, startingIndexOther: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( 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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (1, 1), (1, 1), (-1, 2), (4, 6),
                    (-2, -4), (-6, -8), (0, 1), (2, 3),
                    (6, 5), (4, 3), (2, 1),
                });

                x.Subtract(y, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( 0,  1), ( -4,  3), (1, -1), (-2, -3),
                    ( 6, 9), (12, 15), ( 8, 8 ), (8, 8),
                    ( 6, 8), (10, 12), ( 16, 17 )
                });

                CheckEqual(expected, x);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

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

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Subtract(y, startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Subtract(y, startingIndexThis: 12, subLength: 0);
                }

                public void StartingIndexOther_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Subtract(y, startingIndexOther: -1, subLength: 0);
                }

                public void StartingIndexOther_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Subtract(y, startingIndexOther: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Subtract(y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Subtract(y, subLength: 12);
                }
            }
        }

        public class AssignmentSubtract : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().AssignmentSubtract((ComplexDenseVector)null, (ComplexDenseVector)null,
                    (int)0, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);

                z.AssignmentSubtract(x, y);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( 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 OtherArraysAreUnmodified()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);

                z.AssignmentSubtract(x, y);

                var expectedX = new ComplexDenseVector(new Complex[] {
                    (1, 2), (-3, 4), (0, 1), (2, 3),
                    (4, 5), (6, 7), (8, 9), (10, 11),
                    (12, 13), (14, 15), (16, 17),
                });

                var expectedY = new ComplexDenseVector(new Complex[] {
                    (1, 1), (1, 1), (-1, 2), (4, 6),
                    (-2, -4), (-6, -8), (0, 1), (2, 3),
                    (6, 5), (4, 3), (2, 1),
                });

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

            public void StartingIndexThis()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(12);
                z[0] = 100;

                z.AssignmentSubtract(x, y, startingOffsetThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    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 StartingIndexA()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);

                z.AssignmentSubtract(x, y, startingOffsetA: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( 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 StartingIndexB()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(11);

                z.AssignmentSubtract(x, y, startingOffsetB: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( 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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);
                z.Flush((3, 4));

                z.AssignmentSubtract(x, y, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( 0,  1), ( -4,  3), (1, -1), (-2, -3),
                    ( 6, 9), (12, 15), ( 8, 8 ), (8, 8),
                    ( 6, 8), (10, 12), ( 3, 4 )
                });

                CheckEqual(expected, z);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

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

                ComplexDenseVector z = new ComplexDenseVector(11);

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentSubtract(x, y, startingOffsetThis: -1);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentSubtract(x, y, startingOffsetThis: 12, subLength: 0);
                }

                public void StartingIndexA_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentSubtract(x, y, startingOffsetA: -1);
                }

                public void StartingIndexA_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentSubtract(x, y, startingOffsetA: 12, subLength: 0);
                }

                public void StartingIndexB_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentSubtract(x, y, startingOffsetB: -1);
                }

                public void StartingIndexB_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentSubtract(x, y, startingOffsetB: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentSubtract(x, y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentSubtract(x, y, subLength: 12);
                }
            }
        }

        public class SubtractConjugateTests : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().SubtractConjugate((ComplexDenseVector)null, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (1, -1), (1, -1), (-1, -2), (4, -6),
                    (-2, 4), (-6, 8), (0, -1), (2, -3),
                    (6, -5), (4, -3), (2, -1),
                });

                x.SubtractConjugate(y);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( 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 DoesNotModifyOther()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (1, -1), (1, -1), (-1, -2), (4, -6),
                    (-2, 4), (-6, 8), (0, -1), (2, -3),
                    (6, -5), (4, -3), (2, -1),
                });

                x.SubtractConjugate(y);

                var expected = new ComplexDenseVector(new Complex[] {
                    (1, -1), (1, -1), (-1, -2), (4, -6),
                    (-2, 4), (-6, 8), (0, -1), (2, -3),
                    (6, -5), (4, -3), (2, -1),
                });

                CheckEqual(expected, y);
            }

            public void StartingIndexThis()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    (1, -1), (1, -1), (-1, -2), (4, -6),
                    (-2, 4), (-6, 8), (0, -1), (2, -3),
                    (6, -5), (4, -3), (2, -1),
                });

                x.SubtractConjugate(y, startingIndexThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    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 StartingIndexOther()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    100, (1, -1), (1, -1), (-1, -2), (4, -6),
                    (-2, 4), (-6, 8), (0, -1), (2, -3),
                    (6, -5), (4, -3), (2, -1),
                });

                x.SubtractConjugate(y, startingIndexOther: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( 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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (1, -1), (1, -1), (-1, -2), (4, -6),
                    (-2, 4), (-6, 8), (0, -1), (2, -3),
                    (6, -5), (4, -3), (2, -1),
                });

                x.SubtractConjugate(y, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( 0,  1), ( -4,  3), (1, -1), (-2, -3),
                    ( 6, 9), (12, 15), ( 8, 8 ), (8, 8),
                    ( 6, 8), (10, 12), ( 16, 17 )
                });

                CheckEqual(expected, x);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

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

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.SubtractConjugate(y, startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.SubtractConjugate(y, startingIndexThis: 12, subLength: 0);
                }

                public void StartingIndexOther_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.SubtractConjugate(y, startingIndexOther: -1, subLength: 0);
                }

                public void StartingIndexOther_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.SubtractConjugate(y, startingIndexOther: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.SubtractConjugate(y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.SubtractConjugate(y, subLength: 12);
                }
            }
        }

        public class AssignmentSubtractConjugate : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().AssignmentSubtractConjugate((ComplexDenseVector)null,
                    (ComplexDenseVector)null, (int)0, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);

                z.AssignmentSubtractConjugate(x, y);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( 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 OtherArraysAreUnmodified()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);

                z.AssignmentSubtractConjugate(x, y);

                var expectedX = new ComplexDenseVector(new Complex[] {
                    (1, 2), (-3, 4), (0, 1), (2, 3),
                    (4, 5), (6, 7), (8, 9), (10, 11),
                    (12, 13), (14, 15), (16, 17),
                });

                var expectedY = new ComplexDenseVector(new Complex[] {
                    (1, -1), (1, -1), (-1, -2), (4, -6),
                    (-2, 4), (-6, 8), (0, -1), (2, -3),
                    (6, -5), (4, -3), (2, -1),
                });

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

            public void StartingIndexThis()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(12);
                z[0] = 100;

                z.AssignmentSubtractConjugate(x, y, startingOffsetThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    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 StartingIndexA()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);

                z.AssignmentSubtractConjugate(x, y, startingOffsetA: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( 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 StartingIndexB()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(11);

                z.AssignmentSubtractConjugate(x, y, startingOffsetB: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( 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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);
                z.Flush((3, 4));

                z.AssignmentSubtractConjugate(x, y, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( 0,  1), ( -4,  3), (1, -1), (-2, -3),
                    ( 6, 9), (12, 15), ( 8, 8 ), (8, 8),
                    ( 6, 8), (10, 12), ( 3, 4 )
                });

                CheckEqual(expected, z);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

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

                ComplexDenseVector z = new ComplexDenseVector(11);

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentSubtractConjugate(x, y, startingOffsetThis: -1);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentSubtractConjugate(x, y, startingOffsetThis: 12, subLength: 0);
                }

                public void StartingIndexA_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentSubtractConjugate(x, y, startingOffsetA: -1);
                }

                public void StartingIndexA_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentSubtractConjugate(x, y, startingOffsetA: 12, subLength: 0);
                }

                public void StartingIndexB_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentSubtractConjugate(x, y, startingOffsetB: -1);
                }

                public void StartingIndexB_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentSubtractConjugate(x, y, startingOffsetB: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentSubtractConjugate(x, y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentSubtractConjugate(x, y, subLength: 12);
                }
            }
        }

        public class Subtract_RealTests : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().Subtract((DenseVector)null, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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.Subtract(y);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 OtherArraysAreUnmodified()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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.Subtract(y);

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

                CheckEqual(expectedY, y);
            }

            public void StartingIndexThis()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    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.Subtract(y, startingIndexThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    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 StartingIndexOther()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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.Subtract(y, startingIndexOther: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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.Subtract(y, subLength: 10);

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

                CheckEqual(expected, x);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

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

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Subtract(y, startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Subtract(y, startingIndexThis: 12, subLength: 0);
                }

                public void StartingIndexA_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Subtract(y, startingIndexOther: -1, subLength: 0);
                }

                public void StartingIndexA_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Subtract(y, startingIndexOther: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Subtract(y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Subtract(y, subLength: 12);
                }
            }
        }

        public class AssignmentSubtract_RealTests : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().AssignmentSubtract((ComplexDenseVector)null, (DenseVector)null,
                    (int)0, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 actual = new ComplexDenseVector(11);
                actual.Flush((3, 4));
                actual.AssignmentSubtract(x, y);

                var expected = new ComplexDenseVector(new Complex[] {
                    (9, 2), (12, 4), (15, 6), (18, 8),
                    (10, 0), (2, 1), (5, 3), (8, 5),
                    (11, 7), (14, 9), (17, 11),
                });

                CheckEqual(expected, actual);
            }

            public void OtherArrayIsUnmodified()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 actual = new ComplexDenseVector(11);
                actual.AssignmentSubtract(x, y);

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

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

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

            public void StartingOffsetThis()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 actual = new ComplexDenseVector(12);
                actual.Flush((3, 4));

                actual.AssignmentSubtract(x, y, startingIndexThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (3, 4),
                    (9, 2), (12, 4), (15, 6), (18, 8),
                    (10, 0), (2, 1), (5, 3), (8, 5),
                    (11, 7), (14, 9), (17, 11),
                });

                CheckEqual(expected, actual);
            }

            public void StartingOffsetA()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    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 actual = new ComplexDenseVector(11);

                actual.AssignmentSubtract(x, y, startingIndexA: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (9, 2), (12, 4), (15, 6), (18, 8),
                    (10, 0), (2, 1), (5, 3), (8, 5),
                    (11, 7), (14, 9), (17, 11),
                });

                CheckEqual(expected, actual);
            }

            public void StartingOffsetB()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 actual = new ComplexDenseVector(11);

                actual.AssignmentSubtract(x, y, startingIndexB: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (9, 2), (12, 4), (15, 6), (18, 8),
                    (10, 0), (2, 1), (5, 3), (8, 5),
                    (11, 7), (14, 9), (17, 11),
                });

                CheckEqual(expected, actual);
            }

            public void Sublength()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 actual = new ComplexDenseVector(11);
                actual.Flush((3, 4));

                actual.AssignmentSubtract(x, y, subLength: 10);

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

                CheckEqual(expected, actual);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

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

                ComplexDenseVector actual = new ComplexDenseVector(11);

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentSubtract(x, y, startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentSubtract(x, y, startingIndexThis: 12, subLength: 0);
                }

                public void StartingIndexA_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentSubtract(x, y, startingIndexA: -1, subLength: 0);
                }

                public void StartingIndexA_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentSubtract(x, y, startingIndexA: 12, subLength: 0);
                }

                public void StartingIndexB_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentSubtract(x, y, startingIndexB: -1, subLength: 0);
                }

                public void StartingIndexB_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentSubtract(x, y, startingIndexB: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentSubtract(x, y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentSubtract(x, y, subLength: 12);
                }
            }
        }

        public class AssignmentSubtract_RealSubComplexTests : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().AssignmentSubtract((DenseVector)null, (ComplexDenseVector)null,
                    (int)0, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 actual = new ComplexDenseVector(11);
                actual.Flush((3, 4));
                actual.AssignmentSubtract(y, x);

                var expected = new ComplexDenseVector(new Complex[] {
                    (-9, 2), (-12, 4), (-15, 6), (-18, 8),
                    (-10, 0), (-2, 1), (-5, 3), (-8, 5),
                    (-11, 7), (-14, 9), (-17, 11),
                });

                CheckEqual(expected, actual);
            }

            public void OtherArrayIsUnmodified()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 actual = new ComplexDenseVector(11);
                actual.AssignmentSubtract(y, x);

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

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

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

            public void StartingOffsetThis()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 actual = new ComplexDenseVector(12);
                actual.Flush((3, 4));

                actual.AssignmentSubtract(y, x, startingIndexThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (3, 4),
                    (-9, 2), (-12, 4), (-15, 6), (-18, 8),
                    (-10, 0), (-2, 1), (-5, 3), (-8, 5),
                    (-11, 7), (-14, 9), (-17, 11),
                });

                CheckEqual(expected, actual);
            }

            public void StartingOffsetA()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 actual = new ComplexDenseVector(11);

                actual.AssignmentSubtract(y, x, startingIndexA: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (-9, 2), (-12, 4), (-15, 6), (-18, 8),
                    (-10, 0), (-2, 1), (-5, 3), (-8, 5),
                    (-11, 7), (-14, 9), (-17, 11),
                });

                CheckEqual(expected, actual);
            }

            public void StartingOffsetB()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    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 actual = new ComplexDenseVector(11);

                actual.AssignmentSubtract(y, x, startingIndexB: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (-9, 2), (-12, 4), (-15, 6), (-18, 8),
                    (-10, 0), (-2, 1), (-5, 3), (-8, 5),
                    (-11, 7), (-14, 9), (-17, 11),
                });

                CheckEqual(expected, actual);
            }

            public void Sublength()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 actual = new ComplexDenseVector(11);
                actual.Flush((3, 4));

                actual.AssignmentSubtract(y, x, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    (-9, 2), (-12, 4), (-15, 6), (-18, 8),
                    (-10, 0), (-2, 1), (-5, 3), (-8, 5),
                    (-11, 7), (-14, 9), (3, 4),
                });

                CheckEqual(expected, actual);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

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

                ComplexDenseVector actual = new ComplexDenseVector(11);

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentSubtract(y, x, startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentSubtract(y, x, startingIndexThis: 12, subLength: 0);
                }

                public void StartingIndexA_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentSubtract(y, x, startingIndexA: -1, subLength: 0);
                }

                public void StartingIndexA_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentSubtract(y, x, startingIndexA: 12, subLength: 0);
                }

                public void StartingIndexB_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentSubtract(y, x, startingIndexB: -1, subLength: 0);
                }

                public void StartingIndexB_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentSubtract(y, x, startingIndexB: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentSubtract(y, x, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentSubtract(y, x, subLength: 12);
                }
            }
        }

        public class MultiplyTests : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().Multiply((ComplexDenseVector)null, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (10, 11), (1, 2), (3, 4),
                    (5, 6), (7, 8), (9, 0),
                });

                x.Multiply(y);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( -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 DoesNotModifyOther()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (10, 11), (1, 2), (3, 4),
                    (5, 6), (7, 8), (9, 0),
                });

                x.Multiply(y);

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

                CheckEqual(expected, y);
            }

            public void StartingIndexThis()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (10, 11), (1, 2), (3, 4),
                    (5, 6), (7, 8), (9, 0),
                });

                x.Multiply(y, startingIndexThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    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, x);
            }

            public void StartingIndexOther()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    100, (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (10, 11), (1, 2), (3, 4),
                    (5, 6), (7, 8), (9, 0),
                });

                x.Multiply(y, startingIndexOther: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( -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 Sublength()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (10, 11), (1, 2), (3, 4),
                    (5, 6), (7, 8), (9, 0),
                });

                x.Multiply(y, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( -2,  1), ( -6,  17), (-10, 49), (-14, 97),
                    ( 72, 81), (-11,  10), ( -4,  7), (-8, 31),
                    (-12, 71), (-16, 127), ( 10, 11)
                });

                CheckEqual(expected, x);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

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

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Multiply(y, startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Multiply(y, startingIndexThis: 12, subLength: 0);
                }

                public void StartingIndexOther_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Multiply(y, startingIndexOther: -1, subLength: 0);
                }

                public void StartingIndexOther_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Multiply(y, startingIndexOther: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Multiply(y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Multiply(y, subLength: 12);
                }
            }
        }

        public class AssignmentMultiply : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().AssignmentMultiply((ComplexDenseVector)null, (ComplexDenseVector)null, 
                    (int)0, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);

                z.AssignmentMultiply(x, y);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( -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 OtherArraysAreUnmodified()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);

                z.AssignmentMultiply(x, y);

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

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

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

            public void StartingIndexThis()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(12);
                z[0] = 100;

                z.AssignmentMultiply(x, y, startingOffsetThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);

                z.AssignmentMultiply(x, y, startingOffsetA: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( -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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(11);

                z.AssignmentMultiply(x, y, startingOffsetB: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( -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 Sublength()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);
                z.Flush((3, 4));

                z.AssignmentMultiply(x, y, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( -2,  1), ( -6,  17), (-10, 49), (-14, 97),
                    ( 72, 81), (-11,  10), ( -4,  7), (-8, 31),
                    (-12, 71), (-16, 127), ( 3, 4)
                });

                CheckEqual(expected, z);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

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

                ComplexDenseVector z = new ComplexDenseVector(11);

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentMultiply(x, y, startingOffsetThis: -1);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentMultiply(x, y, startingOffsetThis: 12, subLength: 0);
                }

                public void StartingIndexA_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentMultiply(x, y, startingOffsetA: -1);
                }

                public void StartingIndexA_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentMultiply(x, y, startingOffsetA: 12, subLength: 0);
                }

                public void StartingIndexB_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentMultiply(x, y, startingOffsetB: -1);
                }

                public void StartingIndexB_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentMultiply(x, y, startingOffsetB: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentMultiply(x, y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentMultiply(x, y, subLength: 12);
                }
            }
        }

        public class MultiplyConjugateTests : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().MultiplyConjugate((ComplexDenseVector)null, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, -1), (2, -3), (4, -5), (6, -7),
                    (8, -9), (10, -11), (1, -2), (3, -4),
                    (5, -6), (7, -8), (9, -0),
                });

                x.MultiplyConjugate(y);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( -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 DoesNotModifyOther()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, -1), (2, -3), (4, -5), (6, -7),
                    (8, -9), (10, -11), (1, -2), (3, -4),
                    (5, -6), (7, -8), (9, -0),
                });

                x.MultiplyConjugate(y);

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

                CheckEqual(expected, y);
            }

            public void StartingIndexThis()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    (0, -1), (2, -3), (4, -5), (6, -7),
                    (8, -9), (10, -11), (1, -2), (3, -4),
                    (5, -6), (7, -8), (9, -0),
                });

                x.MultiplyConjugate(y, startingIndexThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    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, x);
            }

            public void StartingIndexOther()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    100, (0, -1), (2, -3), (4, -5), (6, -7),
                    (8, -9), (10, -11), (1, -2), (3, -4),
                    (5, -6), (7, -8), (9, -0),
                });

                x.MultiplyConjugate(y, startingIndexOther: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( -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 Sublength()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, -1), (2, -3), (4, -5), (6, -7),
                    (8, -9), (10, -11), (1, -2), (3, -4),
                    (5, -6), (7, -8), (9, -0),
                });

                x.MultiplyConjugate(y, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( -2,  1), ( -6,  17), (-10, 49), (-14, 97),
                    ( 72, 81), (-11,  10), ( -4,  7), (-8, 31),
                    (-12, 71), (-16, 127), ( 10, 11)
                });

                CheckEqual(expected, x);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

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

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.MultiplyConjugate(y, startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.MultiplyConjugate(y, startingIndexThis: 12, subLength: 0);
                }

                public void StartingIndexOther_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.MultiplyConjugate(y, startingIndexOther: -1, subLength: 0);
                }

                public void StartingIndexOther_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.MultiplyConjugate(y, startingIndexOther: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.MultiplyConjugate(y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.MultiplyConjugate(y, subLength: 12);
                }
            }
        }

        public class AssignmentMultiplyConjugate : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().AssignmentMultiplyConjugate((ComplexDenseVector)null,
                    (ComplexDenseVector)null, (int)0, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);

                z.AssignmentMultiplyConjugate(x, y);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( -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 OtherArraysAreUnmodified()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);

                z.AssignmentMultiplyConjugate(x, y);

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

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

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

            public void StartingIndexThis()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(12);
                z[0] = 100;

                z.AssignmentMultiplyConjugate(x, y, startingOffsetThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);

                z.AssignmentMultiplyConjugate(x, y, startingOffsetA: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( -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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(11);

                z.AssignmentMultiplyConjugate(x, y, startingOffsetB: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( -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 Sublength()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);
                z.Flush((3, 4));

                z.AssignmentMultiplyConjugate(x, y, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    ( -2,  1), ( -6,  17), (-10, 49), (-14, 97),
                    ( 72, 81), (-11,  10), ( -4,  7), (-8, 31),
                    (-12, 71), (-16, 127), ( 3, 4)
                });

                CheckEqual(expected, z);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

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

                ComplexDenseVector z = new ComplexDenseVector(11);

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentMultiplyConjugate(x, y, startingOffsetThis: -1);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentMultiplyConjugate(x, y, startingOffsetThis: 12, subLength: 0);
                }

                public void StartingIndexA_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentMultiplyConjugate(x, y, startingOffsetA: -1);
                }

                public void StartingIndexA_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentMultiplyConjugate(x, y, startingOffsetA: 12, subLength: 0);
                }

                public void StartingIndexB_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentMultiplyConjugate(x, y, startingOffsetB: -1);
                }

                public void StartingIndexB_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentMultiplyConjugate(x, y, startingOffsetB: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentMultiplyConjugate(x, y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentMultiplyConjugate(x, y, subLength: 12);
                }
            }
        }

        public class Multiply_RealTests : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().Multiply((DenseVector)null, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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.Multiply(y);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 OtherArraysAreUnmodified()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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.Multiply(y);

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

                CheckEqual(expectedY, y);
            }

            public void StartingIndexThis()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    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.Multiply(y, startingIndexThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    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 StartingIndexOther()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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.Multiply(y, startingIndexOther: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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.Multiply(y, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    (8, 16), (27, 36), (50, 60), (77, 88),
                    (9, 0), (0, 2), (6, 9), (16, 20),
                    (30, 35), (48, 54), (10, 11)
                });

                CheckEqual(expected, x);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

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

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Multiply(y, startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Multiply(y, startingIndexThis: 12, subLength: 0);
                }

                public void StartingIndexA_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Multiply(y, startingIndexOther: -1, subLength: 0);
                }

                public void StartingIndexA_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Multiply(y, startingIndexOther: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Multiply(y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Multiply(y, subLength: 12);
                }
            }
        }

        public class AssignmentMultiply_RealTests : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().AssignmentMultiply((ComplexDenseVector)null, (DenseVector)null,
                    (int)0, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 actual = new ComplexDenseVector(11);
                actual.Flush((3, 4));
                actual.AssignmentMultiply(x, y);

                var expected = new ComplexDenseVector(new Complex[] {
                    (8, 16), (27, 36), (50, 60), (77, 88),
                    (9, 0), (0, 2), (6, 9), (16, 20),
                    (30, 35), (48, 54), (70, 77)
                });

                CheckEqual(expected, actual);
            }

            public void OtherArrayIsUnmodified()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 actual = new ComplexDenseVector(11);
                actual.AssignmentMultiply(x, y);

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

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

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

            public void StartingOffsetThis()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 actual = new ComplexDenseVector(12);
                actual.Flush((3, 4));

                actual.AssignmentMultiply(x, y, startingIndexThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (3, 4),
                    (8, 16), (27, 36), (50, 60), (77, 88),
                    (9, 0), (0, 2), (6, 9), (16, 20),
                    (30, 35), (48, 54), (70, 77)
                });

                CheckEqual(expected, actual);
            }

            public void StartingOffsetA()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    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 actual = new ComplexDenseVector(11);

                actual.AssignmentMultiply(x, y, startingIndexA: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (8, 16), (27, 36), (50, 60), (77, 88),
                    (9, 0), (0, 2), (6, 9), (16, 20),
                    (30, 35), (48, 54), (70, 77)
                });

                CheckEqual(expected, actual);
            }

            public void StartingOffsetB()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 actual = new ComplexDenseVector(11);

                actual.AssignmentMultiply(x, y, startingIndexB: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (8, 16), (27, 36), (50, 60), (77, 88),
                    (9, 0), (0, 2), (6, 9), (16, 20),
                    (30, 35), (48, 54), (70, 77)
                });

                CheckEqual(expected, actual);
            }

            public void Sublength()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 actual = new ComplexDenseVector(11);
                actual.Flush((3, 4));

                actual.AssignmentMultiply(x, y, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    (8, 16), (27, 36), (50, 60), (77, 88),
                    (9, 0), (0, 2), (6, 9), (16, 20),
                    (30, 35), (48, 54), (3, 4)
                });

                CheckEqual(expected, actual);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

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

                ComplexDenseVector actual = new ComplexDenseVector(11);

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentMultiply(x, y, startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentMultiply(x, y, startingIndexThis: 12, subLength: 0);
                }

                public void StartingIndexA_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentMultiply(x, y, startingIndexA: -1, subLength: 0);
                }

                public void StartingIndexA_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentMultiply(x, y, startingIndexA: 12, subLength: 0);
                }

                public void StartingIndexB_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentMultiply(x, y, startingIndexB: -1, subLength: 0);
                }

                public void StartingIndexB_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentMultiply(x, y, startingIndexB: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentMultiply(x, y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentMultiply(x, y, subLength: 12);
                }
            }
        }

        public class DivideTests : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().Divide((ComplexDenseVector)null, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (10, 11), (1, 2), (3, 4),
                    (5, 6), (7, 8), (9, 0),
                });

                x.Divide(y);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 DividyByZero()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    1
                });

                var y = new ComplexDenseVector(new Complex[] {
                    0
                });

                x.Divide(y);

                Check(Complex.IsNaN(x[0]));
            }

            public void DoesNotModifyOther()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (10, 11), (1, 2), (3, 4),
                    (5, 6), (7, 8), (9, 0),
                });

                x.Divide(y);

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

                CheckEqual(expectedY, y);
            }

            public void StartingIndexThis()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (10, 11), (1, 2), (3, 4),
                    (5, 6), (7, 8), (9, 0),
                });

                x.Divide(y, startingIndexThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    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 StartingIndexOther()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    100, (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (10, 11), (1, 2), (3, 4),
                    (5, 6), (7, 8), (9, 0),
                });

                x.Divide(y, startingIndexOther: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 Sublength()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (10, 11), (1, 2), (3, 4),
                    (5, 6), (7, 8), (9, 0),
                });

                x.Divide(y, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

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

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Divide(y, startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Divide(y, startingIndexThis: 12, subLength: 0);
                }

                public void StartingIndexOther_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Divide(y, startingIndexOther: -1, subLength: 0);
                }

                public void StartingIndexOther_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Divide(y, startingIndexOther: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Divide(y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Divide(y, subLength: 12);
                }
            }
        }

        public class AssignmentDivide : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().AssignmentDivide((ComplexDenseVector)null, (ComplexDenseVector)null,
                    (int)0, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);

                z.AssignmentDivide(x, y);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 OtherArraysAreUnmodified()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);

                z.AssignmentDivide(x, y);

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

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

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

            public void StartingIndexThis()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(12);
                z[0] = 100;

                z.AssignmentDivide(x, y, startingOffsetThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    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 StartingIndexA()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);

                z.AssignmentDivide(x, y, startingOffsetA: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 StartingIndexB()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(11);

                z.AssignmentDivide(x, y, startingOffsetB: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 Sublength()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);
                z.Flush((3, 4));

                z.AssignmentDivide(x, y, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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), (3, 4)
                });

                CheckEqual(expected, z);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

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

                ComplexDenseVector z = new ComplexDenseVector(11);

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentDivide(x, y, startingOffsetThis: -1);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentDivide(x, y, startingOffsetThis: 12, subLength: 0);
                }

                public void StartingIndexA_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentDivide(x, y, startingOffsetA: -1);
                }

                public void StartingIndexA_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentDivide(x, y, startingOffsetA: 12, subLength: 0);
                }

                public void StartingIndexB_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentDivide(x, y, startingOffsetB: -1);
                }

                public void StartingIndexB_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentDivide(x, y, startingOffsetB: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentDivide(x, y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentDivide(x, y, subLength: 12);
                }
            }
        }

        public class DivideConjugateTests : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().DivideConjugate((ComplexDenseVector)null, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, -1), (2, -3), (4, -5), (6, -7),
                    (8, -9), (10, -11), (1, -2), (3, -4),
                    (5, -6), (7, -8), (9, 0),
                });

                x.DivideConjugate(y);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 DividyByZero()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    1
                });

                var y = new ComplexDenseVector(new Complex[] {
                    0
                });

                x.DivideConjugate(y);

                Check(Complex.IsNaN(x[0]));
            }

            public void DoesNotModifyOther()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, -1), (2, -3), (4, -5), (6, -7),
                    (8, -9), (10, -11), (1, -2), (3, -4),
                    (5, -6), (7, -8), (9, 0),
                });

                x.DivideConjugate(y);

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

                CheckEqual(expectedY, y);
            }

            public void StartingIndexThis()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    (0, -1), (2, -3), (4, -5), (6, -7),
                    (8, -9), (10, -11), (1, -2), (3, -4),
                    (5, -6), (7, -8), (9, 0),
                });

                x.DivideConjugate(y, startingIndexThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    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 StartingIndexOther()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    100, (0, -1), (2, -3), (4, -5), (6, -7),
                    (8, -9), (10, -11), (1, -2), (3, -4),
                    (5, -6), (7, -8), (9, 0),
                });

                x.DivideConjugate(y, startingIndexOther: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 Sublength()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, -1), (2, -3), (4, -5), (6, -7),
                    (8, -9), (10, -11), (1, -2), (3, -4),
                    (5, -6), (7, -8), (9, 0),
                });

                x.DivideConjugate(y, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

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

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.DivideConjugate(y, startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.DivideConjugate(y, startingIndexThis: 12, subLength: 0);
                }

                public void StartingIndexOther_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.DivideConjugate(y, startingIndexOther: -1, subLength: 0);
                }

                public void StartingIndexOther_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.DivideConjugate(y, startingIndexOther: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.DivideConjugate(y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.DivideConjugate(y, subLength: 12);
                }
            }
        }

        public class InverseDivideTests : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().InverseDivide((ComplexDenseVector)null, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

                x.InverseDivide(y);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 DividyByZero()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    0
                });

                var y = new ComplexDenseVector(new Complex[] {
                    1
                });

                x.InverseDivide(y);

                Check(Complex.IsNaN(x[0]));
            }

            public void DoesNotModifyOther()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

                x.InverseDivide(y);

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

                CheckEqual(expectedY, y);
            }

            public void StartingIndexThis()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

                x.InverseDivide(y, startingIndexThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    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 StartingIndexOther()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    100, (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

                x.InverseDivide(y, startingIndexOther: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 Sublength()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

                x.InverseDivide(y, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

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

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.InverseDivide(y, startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.InverseDivide(y, startingIndexThis: 12, subLength: 0);
                }

                public void StartingIndexOther_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.InverseDivide(y, startingIndexOther: -1, subLength: 0);
                }

                public void StartingIndexOther_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.InverseDivide(y, startingIndexOther: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.InverseDivide(y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.InverseDivide(y, subLength: 12);
                }
            }
        }

        public class InverseDivideConjugateTests : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().InverseDivideConjugate((ComplexDenseVector)null, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (1, -2), (3, -4), (5, -6), (7, -8),
                    (9, -0), (0, -1), (2, -3), (4, -5),
                    (6, -7), (8, -9), (10, -11),
                });

                x.InverseDivideConjugate(y);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 DividyByZero()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    0
                });

                var y = new ComplexDenseVector(new Complex[] {
                    1
                });

                x.InverseDivideConjugate(y);

                Check(Complex.IsNaN(x[0]));
            }

            public void DoesNotModifyOther()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

                x.InverseDivideConjugate(y);

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

                CheckEqual(expectedY, y);
            }

            public void StartingIndexThis()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    (1, -2), (3, -4), (5, -6), (7, -8),
                    (9, -0), (0, -1), (2, -3), (4, -5),
                    (6, -7), (8, -9), (10, -11),
                });

                x.InverseDivideConjugate(y, startingIndexThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    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 StartingIndexOther()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    100, (1, -2), (3, -4), (5, -6), (7, -8),
                    (9, -0), (0, -1), (2, -3), (4, -5),
                    (6, -7), (8, -9), (10, -11),
                });

                x.InverseDivideConjugate(y, startingIndexOther: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 Sublength()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (1, -2), (3, -4), (5, -6), (7, -8),
                    (9, -0), (0, -1), (2, -3), (4, -5),
                    (6, -7), (8, -9), (10, -11),
                });

                x.InverseDivideConjugate(y, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

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

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.InverseDivideConjugate(y, startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.InverseDivideConjugate(y, startingIndexThis: 12, subLength: 0);
                }

                public void StartingIndexOther_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.InverseDivideConjugate(y, startingIndexOther: -1, subLength: 0);
                }

                public void StartingIndexOther_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.InverseDivideConjugate(y, startingIndexOther: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.InverseDivideConjugate(y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.InverseDivideConjugate(y, subLength: 12);
                }
            }
        }

        public class AssignmentDivideConjugateDenominator : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().AssignmentDivideConjugateDenominator(
                    (ComplexDenseVector)null, (ComplexDenseVector)null, (int)0, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);

                z.AssignmentDivideConjugateDenominator(x, y);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 OtherArraysAreUnmodified()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);

                z.AssignmentDivideConjugateDenominator(x, y);

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

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

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

            public void StartingIndexThis()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(12);
                z[0] = 100;

                z.AssignmentDivideConjugateDenominator(x, y, startingOffsetThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    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 StartingIndexA()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);

                z.AssignmentDivideConjugateDenominator(x, y, startingOffsetA: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 StartingIndexB()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(11);

                z.AssignmentDivideConjugateDenominator(x, y, startingOffsetB: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 Sublength()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);
                z.Flush((3, 4));

                z.AssignmentDivideConjugateDenominator(x, y, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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), (3, 4)
                });

                CheckEqual(expected, z);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

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

                ComplexDenseVector z = new ComplexDenseVector(11);

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentDivideConjugateDenominator(x, y, startingOffsetThis: -1);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentDivideConjugateDenominator(x, y, startingOffsetThis: 12, subLength: 0);
                }

                public void StartingIndexA_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentDivideConjugateDenominator(x, y, startingOffsetA: -1);
                }

                public void StartingIndexA_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentDivideConjugateDenominator(x, y, startingOffsetA: 12, subLength: 0);
                }

                public void StartingIndexB_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentDivideConjugateDenominator(x, y, startingOffsetB: -1);
                }

                public void StartingIndexB_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentDivideConjugateDenominator(x, y, startingOffsetB: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentDivideConjugateDenominator(x, y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentDivideConjugateDenominator(x, y, subLength: 12);
                }
            }
        }

        public class AssignmentDivideConjugateNumerator : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().AssignmentDivideConjugateNumerator(
                    (ComplexDenseVector)null, (ComplexDenseVector)null, (int)0, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);

                z.AssignmentDivideConjugateNumerator(x, y);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 OtherArraysAreUnmodified()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);

                z.AssignmentDivideConjugateNumerator(x, y);

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

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

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

            public void StartingIndexThis()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(12);
                z[0] = 100;

                z.AssignmentDivideConjugateNumerator(x, y, startingOffsetThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    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 StartingIndexA()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);

                z.AssignmentDivideConjugateNumerator(x, y, startingOffsetA: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 StartingIndexB()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(11);

                z.AssignmentDivideConjugateNumerator(x, y, startingOffsetB: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 Sublength()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);
                z.Flush((3, 4));

                z.AssignmentDivideConjugateNumerator(x, y, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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), (3, 4)
                });

                CheckEqual(expected, z);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

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

                ComplexDenseVector z = new ComplexDenseVector(11);

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentDivideConjugateNumerator(x, y, startingOffsetThis: -1);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentDivideConjugateNumerator(x, y, startingOffsetThis: 12, subLength: 0);
                }

                public void StartingIndexA_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentDivideConjugateNumerator(x, y, startingOffsetA: -1);
                }

                public void StartingIndexA_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentDivideConjugateNumerator(x, y, startingOffsetA: 12, subLength: 0);
                }

                public void StartingIndexB_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentDivideConjugateNumerator(x, y, startingOffsetB: -1);
                }

                public void StartingIndexB_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentDivideConjugateNumerator(x, y, startingOffsetB: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentDivideConjugateNumerator(x, y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentDivideConjugateNumerator(x, y, subLength: 12);
                }
            }
        }

        public class Divide_RealTests : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().Divide((DenseVector)null, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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.Divide(y);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 OtherArraysAreUnmodified()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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.Divide(y);

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

                CheckEqual(expectedY, y);
            }

            public void StartingIndexThis()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    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.Divide(y, startingIndexThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    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 StartingIndexOther()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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.Divide(y, startingIndexOther: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 Sublength()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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.Divide(y, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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, 11),
                });

                CheckEqual(expected, x);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

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

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Divide(y, startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Divide(y, startingIndexThis: 12, subLength: 0);
                }

                public void StartingIndexA_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Divide(y, startingIndexOther: -1, subLength: 0);
                }

                public void StartingIndexA_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Divide(y, startingIndexOther: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Divide(y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Divide(y, subLength: 12);
                }
            }
        }

        public class AssignmentDivide_RealTests : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().AssignmentDivide((ComplexDenseVector)null, (DenseVector)null,
                    (int)0, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 actual = new ComplexDenseVector(11);
                actual.Flush((3, 4));
                actual.AssignmentDivide(x, y);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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, actual);
            }

            public void OtherArrayIsUnmodified()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 actual = new ComplexDenseVector(11);
                actual.AssignmentDivide(x, y);

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

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

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

            public void StartingOffsetThis()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 actual = new ComplexDenseVector(12);
                actual.Flush((3, 4));

                actual.AssignmentDivide(x, y, startingIndexThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (3, 4),
                    (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, actual);
            }

            public void StartingOffsetA()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    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 actual = new ComplexDenseVector(11);

                actual.AssignmentDivide(x, y, startingIndexA: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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, actual);
            }

            public void StartingOffsetB()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 actual = new ComplexDenseVector(11);

                actual.AssignmentDivide(x, y, startingIndexB: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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, actual);
            }

            public void Sublength()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 actual = new ComplexDenseVector(11);
                actual.Flush((3, 4));

                actual.AssignmentDivide(x, y, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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), (3, 4)
                });

                CheckEqual(expected, actual);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

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

                ComplexDenseVector actual = new ComplexDenseVector(11);

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentDivide(x, y, startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentDivide(x, y, startingIndexThis: 12, subLength: 0);
                }

                public void StartingIndexA_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentDivide(x, y, startingIndexA: -1, subLength: 0);
                }

                public void StartingIndexA_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentDivide(x, y, startingIndexA: 12, subLength: 0);
                }

                public void StartingIndexB_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentDivide(x, y, startingIndexB: -1, subLength: 0);
                }

                public void StartingIndexB_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentDivide(x, y, startingIndexB: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentDivide(x, y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentDivide(x, y, subLength: 12);
                }
            }
        }

        public class InverseDivide_RealTests : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().InverseDivide((DenseVector)null, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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.InverseDivide(y);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 OtherArraysAreUnmodified()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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.InverseDivide(y);

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

                CheckEqual(expectedY, y);
            }

            public void StartingIndexThis()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    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.InverseDivide(y, startingIndexThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    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 StartingIndexOther()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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.InverseDivide(y, startingIndexOther: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 Sublength()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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.InverseDivide(y, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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), (10, 11)
                });

                CheckEqual(expected, x);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

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

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.InverseDivide(y, startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.InverseDivide(y, startingIndexThis: 12, subLength: 0);
                }

                public void StartingIndexA_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.InverseDivide(y, startingIndexOther: -1, subLength: 0);
                }

                public void StartingIndexA_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.InverseDivide(y, startingIndexOther: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.InverseDivide(y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.InverseDivide(y, subLength: 12);
                }
            }
        }

        public class AssignmentInverseDivide_RealTests : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().AssignmentDivide((DenseVector)null, (ComplexDenseVector)null,
                    (int)0, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 actual = new ComplexDenseVector(11);
                actual.Flush((3, 4));
                actual.AssignmentDivide(y, x);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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, actual);
            }

            public void OtherArrayIsUnmodified()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 actual = new ComplexDenseVector(11);
                actual.AssignmentDivide(y, x);

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

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

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

            public void StartingOffsetThis()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 actual = new ComplexDenseVector(12);
                actual.Flush((3, 4));

                actual.AssignmentDivide(y, x, startingIndexThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (3, 4),
                    (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, actual);
            }

            public void StartingOffsetA()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 actual = new ComplexDenseVector(11);

                actual.AssignmentDivide(y, x, startingIndexA: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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, actual);
            }

            public void StartingOffsetB()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    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 actual = new ComplexDenseVector(11);

                actual.AssignmentDivide(y, x, startingIndexB: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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, actual);
            }

            public void Sublength()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 actual = new ComplexDenseVector(11);
                actual.Flush((3, 4));

                actual.AssignmentDivide(y, x, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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), (3, 4),
                });

                CheckEqual(expected, actual);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

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

                ComplexDenseVector actual = new ComplexDenseVector(11);

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentDivide(y, x, startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentDivide(y, x, startingIndexThis: 12, subLength: 0);
                }

                public void StartingIndexA_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentDivide(y, x, startingIndexA: -1, subLength: 0);
                }

                public void StartingIndexA_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentDivide(y, x, startingIndexA: 12, subLength: 0);
                }

                public void StartingIndexB_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentDivide(y, x, startingIndexB: -1, subLength: 0);
                }

                public void StartingIndexB_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentDivide(y, x, startingIndexB: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentDivide(y, x, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentDivide(y, x, subLength: 12);
                }
            }
        }

        public class MADDTests : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().MADD((ComplexDenseVector)null, Complex.NaN, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (-3, 5), (-3, 21), (-3, 37), (-3, 53),
                    (-3, 59), (-14, 74), (-3, 13), (-3, 29),
                    (-3, 45), (-3, 61), (37, 47),
                });

                x.MADD(y, (3, 4));
                CheckEqual(expected, x);
            }

            public void OtherArrayIsUnmodified()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (10, 11), (1, 2), (3, 4),
                    (5, 6), (7, 8), (9, 0),
                });

                x.MADD(y, (3, 4));
                CheckEqual(expected, y);
            }

            public void StartingIndexThis()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    100, (-3, 5), (-3, 21), (-3, 37), (-3, 53),
                    (-3, 59), (-14, 74), (-3, 13), (-3, 29),
                    (-3, 45), (-3, 61), (37, 47),
                });

                x.MADD(y, (3, 4), startingIndexThis: 1, subLength: 11);
                CheckEqual(expected, x);
            }

            public void StartingIndexOther()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    (-3, 5), (-3, 21), (-3, 37), (-3, 53),
                    (-3, 59), (-14, 74), (-3, 13), (-3, 29),
                    (-3, 45), (-3, 61), (37, 47),
                });

                x.MADD(y, (3, 4), startingIndexOther: 1, subLength: 11);
                CheckEqual(expected, x);
            }

            public void Sublength()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (-3, 5), (-3, 21), (-3, 37), (-3, 53),
                    (-3, 59), (-14, 74), (-3, 13), (-3, 29),
                    (-3, 45), (-3, 61), (10, 11),
                });

                x.MADD(y, (3, 4), subLength: 10);
                CheckEqual(expected, x);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

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

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.MADD(y, (3, 4), startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.MADD(y, (3, 4), startingIndexThis: 12, subLength: 0);
                }

                public void StartingIndexOther_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.MADD(y, (3, 4), startingIndexOther: -1, subLength: 0);
                }

                public void StartingIndexOther_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.MADD(y, (3, 4), startingIndexOther: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.MADD(y, (3, 4), subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.MADD(y, (3, 4), subLength: 12);
                }
            }
        }

        public class AssignmentMADD : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().AssignmentMADD((ComplexDenseVector)null, (ComplexDenseVector)null,
                    Complex.NaN, (int)0, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (-3, 5), (-3, 21), (-3, 37), (-3, 53),
                    (-3, 59), (-14, 74), (-3, 13), (-3, 29),
                    (-3, 45), (-3, 61), (37, 47),
                });

                z.AssignmentMADD(x, y, (3, 4));
                CheckEqual(expected, z);
            }

            public void OtherArraysAreUnmodified()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);

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

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

                z.AssignmentMADD(x, y, (3, 4));
                CheckEqual(expectedX, x);
                CheckEqual(expectedY, y);
            }

            public void StartingIndexThis()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(12);
                z[0] = 100;

                var expected = new ComplexDenseVector(new Complex[] {
                    100, (-3, 5), (-3, 21), (-3, 37), (-3, 53),
                    (-3, 59), (-14, 74), (-3, 13), (-3, 29),
                    (-3, 45), (-3, 61), (37, 47),
                });

                z.AssignmentMADD(x, y, (3, 4), startingIndexThis: 1, subLength: 11);
                CheckEqual(expected, z);
            }

            public void StartingIndexSum()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (-3, 5), (-3, 21), (-3, 37), (-3, 53),
                    (-3, 59), (-14, 74), (-3, 13), (-3, 29),
                    (-3, 45), (-3, 61), (37, 47),
                });

                z.AssignmentMADD(x, y, (3, 4), startingIndexSum: 1, subLength: 11);
                CheckEqual(expected, z);
            }

            public void StartingIndexOther()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (-3, 5), (-3, 21), (-3, 37), (-3, 53),
                    (-3, 59), (-14, 74), (-3, 13), (-3, 29),
                    (-3, 45), (-3, 61), (37, 47),
                });

                z.AssignmentMADD(x, y, (3, 4), startingIndexOther: 1, subLength: 11);
                CheckEqual(expected, z);
            }

            public void Sublength()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(11);
                z[10] = 100;

                var expected = new ComplexDenseVector(new Complex[] {
                    (-3, 5), (-3, 21), (-3, 37), (-3, 53),
                    (-3, 59), (-14, 74), (-3, 13), (-3, 29),
                    (-3, 45), (-3, 61), 100,
                });

                z.AssignmentMADD(x, y, (3, 4), startingIndexOther: 1, subLength: 10);
                CheckEqual(expected, z);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

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

                ComplexDenseVector z = new ComplexDenseVector(11);

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentMADD(x, y, (3, 4), startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentMADD(x, y, (3, 4), startingIndexThis: 12, subLength: 0);
                }

                public void StartingIndexSum_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentMADD(x, y, (3, 4), startingIndexSum: -1, subLength: 0);
                }

                public void StartingIndexSum_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentMADD(x, y, (3, 4), startingIndexSum: 12, subLength: 0);
                }

                public void StartingIndexOther_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentMADD(x, y, (3, 4), startingIndexSum: -1, subLength: 0);
                }

                public void StartingIndexOther_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentMADD(x, y, (3, 4), startingIndexSum: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentMADD(x, y, (3, 4), subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentMADD(x, y, (3, 4), subLength: 12);
                }
            }
        }

        public class MADDConjugateTests : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().MADDConjugate((ComplexDenseVector)null, Complex.NaN, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (-3, 5), (-3, 21), (-3, 37), (-3, 53),
                    (-3, 59), (-14, 74), (-3, 13), (-3, 29),
                    (-3, 45), (-3, 61), (37, 47),
                });

                x.MADDConjugate(y, (3, 4));
                CheckEqual(expected, x);
            }

            public void OtherArrayIsUnmodified()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, -1), (2, -3), (4, -5), (6, -7),
                    (8, -9), (10, -11), (1, -2), (3, -4),
                    (5, -6), (7, -8), (9, -0),
                });

                x.MADDConjugate(y, (3, 4));
                CheckEqual(expected, y);
            }

            public void StartingIndexThis()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    100, (-3, 5), (-3, 21), (-3, 37), (-3, 53),
                    (-3, 59), (-14, 74), (-3, 13), (-3, 29),
                    (-3, 45), (-3, 61), (37, 47),
                });

                x.MADDConjugate(y, (3, 4), startingIndexThis: 1, subLength: 11);
                CheckEqual(expected, x);
            }

            public void StartingIndexOther()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    (-3, 5), (-3, 21), (-3, 37), (-3, 53),
                    (-3, 59), (-14, 74), (-3, 13), (-3, 29),
                    (-3, 45), (-3, 61), (37, 47),
                });

                x.MADDConjugate(y, (3, 4), startingIndexOther: 1, subLength: 11);
                CheckEqual(expected, x);
            }

            public void Sublength()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (-3, 5), (-3, 21), (-3, 37), (-3, 53),
                    (-3, 59), (-14, 74), (-3, 13), (-3, 29),
                    (-3, 45), (-3, 61), (10, 11),
                });

                x.MADDConjugate(y, (3, 4), subLength: 10);
                CheckEqual(expected, x);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

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

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.MADDConjugate(y, (3, 4), startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.MADDConjugate(y, (3, 4), startingIndexThis: 12, subLength: 0);
                }

                public void StartingIndexOther_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.MADDConjugate(y, (3, 4), startingIndexOther: -1, subLength: 0);
                }

                public void StartingIndexOther_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.MADDConjugate(y, (3, 4), startingIndexOther: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.MADDConjugate(y, (3, 4), subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.MADDConjugate(y, (3, 4), subLength: 12);
                }
            }
        }

        public class AssignmentMADDConjugate : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().AssignmentMADDConjugate((ComplexDenseVector)null, (ComplexDenseVector)null,
                    Complex.NaN, (int)0, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (-3, 5), (-3, 21), (-3, 37), (-3, 53),
                    (-3, 59), (-14, 74), (-3, 13), (-3, 29),
                    (-3, 45), (-3, 61), (37, 47),
                });

                z.AssignmentMADDConjugate(x, y, (3, 4));
                CheckEqual(expected, z);
            }

            public void OtherArraysAreUnmodified()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);

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

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

                z.AssignmentMADDConjugate(x, y, (3, 4));
                CheckEqual(expectedX, x);
                CheckEqual(expectedY, y);
            }

            public void StartingIndexThis()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(12);
                z[0] = 100;

                var expected = new ComplexDenseVector(new Complex[] {
                    100, (-3, 5), (-3, 21), (-3, 37), (-3, 53),
                    (-3, 59), (-14, 74), (-3, 13), (-3, 29),
                    (-3, 45), (-3, 61), (37, 47),
                });

                z.AssignmentMADDConjugate(x, y, (3, 4), startingIndexThis: 1, subLength: 11);
                CheckEqual(expected, z);
            }

            public void StartingIndexSum()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (-3, 5), (-3, 21), (-3, 37), (-3, 53),
                    (-3, 59), (-14, 74), (-3, 13), (-3, 29),
                    (-3, 45), (-3, 61), (37, 47),
                });

                z.AssignmentMADDConjugate(x, y, (3, 4), startingIndexSum: 1, subLength: 11);
                CheckEqual(expected, z);
            }

            public void StartingIndexOther()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (-3, 5), (-3, 21), (-3, 37), (-3, 53),
                    (-3, 59), (-14, 74), (-3, 13), (-3, 29),
                    (-3, 45), (-3, 61), (37, 47),
                });

                z.AssignmentMADDConjugate(x, y, (3, 4), startingIndexOther: 1, subLength: 11);
                CheckEqual(expected, z);
            }

            public void Sublength()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(11);
                z[10] = 100;

                var expected = new ComplexDenseVector(new Complex[] {
                    (-3, 5), (-3, 21), (-3, 37), (-3, 53),
                    (-3, 59), (-14, 74), (-3, 13), (-3, 29),
                    (-3, 45), (-3, 61), 100,
                });

                z.AssignmentMADDConjugate(x, y, (3, 4), startingIndexOther: 1, subLength: 10);
                CheckEqual(expected, z);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

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

                ComplexDenseVector z = new ComplexDenseVector(11);

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentMADDConjugate(x, y, (3, 4), startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentMADDConjugate(x, y, (3, 4), startingIndexThis: 12, subLength: 0);
                }

                public void StartingIndexSum_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentMADDConjugate(x, y, (3, 4), startingIndexSum: -1, subLength: 0);
                }

                public void StartingIndexSum_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentMADDConjugate(x, y, (3, 4), startingIndexSum: 12, subLength: 0);
                }

                public void StartingIndexOther_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentMADDConjugate(x, y, (3, 4), startingIndexSum: -1, subLength: 0);
                }

                public void StartingIndexOther_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentMADDConjugate(x, y, (3, 4), startingIndexSum: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentMADDConjugate(x, y, (3, 4), subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentMADDConjugate(x, y, (3, 4), subLength: 12);
                }
            }
        }

        public class FMA_ComplexComplex : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().FMA((ComplexDenseVector)null, (ComplexDenseVector)null,
                    (int)0, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (10, 11), (1, 2), (3, 4),
                    (5, 6), (7, 8), (9, 0),
                });

                z.FMA(x, y);

                var expected = new ComplexDenseVector(new Complex[] {
                    (-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 OtherArraysAreUnmodified()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (10, 11), (1, 2), (3, 4),
                    (5, 6), (7, 8), (9, 0),
                });

                z.FMA(x, y);

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

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

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

            public void StartingIndexThis()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (10, 11), (1, 2), (3, 4),
                    (5, 6), (7, 8), (9, 0),
                });

                z.FMA(x, y, startingIndexThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    100, (-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 StartingIndexA()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (10, 11), (1, 2), (3, 4),
                    (5, 6), (7, 8), (9, 0),
                });

                z.FMA(x, y, startingIndexA: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (-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 StartingIndexB()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    100, (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (10, 11), (1, 2), (3, 4),
                    (5, 6), (7, 8), (9, 0),
                });

                z.FMA(x, y, startingIndexB: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (-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 Sublength()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (10, 11), (1, 2), (3, 4),
                    (5, 6), (7, 8), (9, 0),
                });

                z.FMA(x, y, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    (-1, 3), (-3, 21), (-5, 55), (-7, 105),
                    (73, 83), (-8, 14), (1, 13), (-1, 39),
                    (-11, 73), (-13, 131), (5, 6)
                });

                CheckEqual(expected, z);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector z = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (1, 2), (3, 4), (5, 6),
                });

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

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

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.FMA(x, y, startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.FMA(x, y, startingIndexThis: 12, subLength: 0);
                }

                public void StartingIndexA_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.FMA(x, y, startingIndexA: -1, subLength: 0);
                }

                public void StartingIndexA_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.FMA(x, y, startingIndexA: 12, subLength: 0);
                }

                public void StartingIndexB_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.FMA(x, y, startingIndexB: -1, subLength: 0);
                }

                public void StartingIndexB_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.FMA(x, y, startingIndexB: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.FMA(x, y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.FMA(x, y, subLength: 12);
                }
            }
        }

        public class AssignmentFMA_Complex : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().AssignmentFMA((ComplexDenseVector)null, (ComplexDenseVector)null,
                    (ComplexDenseVector)null, (int)0, (int)0, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (10, 11), (1, 2), (3, 4),
                    (5, 6), (7, 8), (9, 0),
                });

                var actual = new ComplexDenseVector(11);
                actual.Flush((3, 4));
                actual.AssignmentFMA(z, x, y);

                var expected = new ComplexDenseVector(new Complex[] {
                    (-1, 3), (-3, 21), (-5, 55), (-7, 105),
                    (73, 83), (-8, 14), (1, 13), (-1, 39),
                    (-11, 73), (-13, 131), (95, 105)
                });

                CheckEqual(expected, actual);
            }

            public void OtherArrayIsUnmodified()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (10, 11), (1, 2), (3, 4),
                    (5, 6), (7, 8), (9, 0),
                });

                var actual = new ComplexDenseVector(11);
                actual.AssignmentFMA(z, x, y);

                var expectedZ = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (1, 2), (3, 4), (5, 6),
                });

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

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

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

            public void StartingOffsetThis()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (10, 11), (1, 2), (3, 4),
                    (5, 6), (7, 8), (9, 0),
                });

                var actual = new ComplexDenseVector(12);
                actual.Flush((3, 4));

                actual.AssignmentFMA(z, x, y, startingIndexThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (3, 4),
                    (-1, 3), (-3, 21), (-5, 55), (-7, 105),
                    (73, 83), (-8, 14), (1, 13), (-1, 39),
                    (-11, 73), (-13, 131), (95, 105)
                });

                CheckEqual(expected, actual);
            }

            public void StartingOffsetSum()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (10, 11), (1, 2), (3, 4),
                    (5, 6), (7, 8), (9, 0),
                });

                var actual = new ComplexDenseVector(11);

                actual.AssignmentFMA(z, x, y, startingIndexSum: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (-1, 3), (-3, 21), (-5, 55), (-7, 105),
                    (73, 83), (-8, 14), (1, 13), (-1, 39),
                    (-11, 73), (-13, 131), (95, 105)
                });

                CheckEqual(expected, actual);
            }

            public void StartingOffsetA()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (10, 11), (1, 2), (3, 4),
                    (5, 6), (7, 8), (9, 0),
                });

                var actual = new ComplexDenseVector(11);

                actual.AssignmentFMA(z, x, y, startingIndexA: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (-1, 3), (-3, 21), (-5, 55), (-7, 105),
                    (73, 83), (-8, 14), (1, 13), (-1, 39),
                    (-11, 73), (-13, 131), (95, 105)
                });

                CheckEqual(expected, actual);
            }

            public void StartingOffsetB()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    100, (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (10, 11), (1, 2), (3, 4),
                    (5, 6), (7, 8), (9, 0),
                });

                var actual = new ComplexDenseVector(11);

                actual.AssignmentFMA(z, x, y, startingIndexB: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (-1, 3), (-3, 21), (-5, 55), (-7, 105),
                    (73, 83), (-8, 14), (1, 13), (-1, 39),
                    (-11, 73), (-13, 131), (95, 105)
                });

                CheckEqual(expected, actual);
            }

            public void Sublength()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (10, 11), (1, 2), (3, 4),
                    (5, 6), (7, 8), (9, 0),
                });

                var actual = new ComplexDenseVector(11);
                actual.Flush((3, 4));

                actual.AssignmentFMA(z, x, y, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    (-1, 3), (-3, 21), (-5, 55), (-7, 105),
                    (73, 83), (-8, 14), (1, 13), (-1, 39),
                    (-11, 73), (-13, 131), (3, 4),
                });

                CheckEqual(expected, actual);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector z = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (1, 2), (3, 4), (5, 6),
                });

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

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

                ComplexDenseVector actual = new ComplexDenseVector(11);

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentFMA(z, x, y, startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentFMA(z, x, y, startingIndexThis: 12, subLength: 0);
                }

                public void StartingIndexSum_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentFMA(z, x, y, startingIndexSum: -1, subLength: 0);
                }

                public void StartingIndexSum_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentFMA(z, x, y, startingIndexSum: 12, subLength: 0);
                }

                public void StartingIndexA_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentFMA(z, x, y, startingIndexA: -1, subLength: 0);
                }

                public void StartingIndexA_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentFMA(z, x, y, startingIndexA: 12, subLength: 0);
                }

                public void StartingIndexB_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentFMA(z, x, y, startingIndexB: -1, subLength: 0);
                }

                public void StartingIndexB_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentFMA(z, x, y, startingIndexB: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentFMA(z, x, y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentFMA(z, x, y, subLength: 12);
                }
            }
        }

        public class FMA_ComplexReal : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().FMA((ComplexDenseVector)null, (DenseVector)null,
                    (int)0, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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.FMA(x, y);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 OtherArraysAreUnmodified()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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.FMA(x, y);

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

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

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

            public void StartingIndexThis()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    (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.FMA(x, y, startingIndexThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    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 StartingIndexA()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    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.FMA(x, y, startingIndexA: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 StartingIndexB()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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.FMA(x, y, startingIndexB: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 Sublength()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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.FMA(x, y, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 BoundsTests : TestFixture
            {
                ComplexDenseVector z = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (1, 2), (3, 4), (5, 6),
                });

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

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

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.FMA(x, y, startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.FMA(x, y, startingIndexThis: 12, subLength: 0);
                }

                public void StartingIndexA_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.FMA(x, y, startingIndexA: -1, subLength: 0);
                }

                public void StartingIndexA_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.FMA(x, y, startingIndexA: 12, subLength: 0);
                }

                public void StartingIndexB_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.FMA(x, y, startingIndexB: -1, subLength: 0);
                }

                public void StartingIndexB_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.FMA(x, y, startingIndexB: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.FMA(x, y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.FMA(x, y, subLength: 12);
                }
            }
        }

        public class AssignmentFMA_Real : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().AssignmentFMA((ComplexDenseVector)null, (ComplexDenseVector)null,
                    (DenseVector)null, (int)0, (int)0, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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[] {
                    1, 2, 3, 4,
                    5, 6, 7, 8,
                    9, 10, 11,
                });

                var actual = new ComplexDenseVector(11);
                actual.Flush((3, 4));
                actual.AssignmentFMA(z, x, y);

                var expected = new ComplexDenseVector(new Complex[] {
                    (2, 4), (9, 12), (20, 24), (35, 40),
                    (46, 2), (3, 10), (19, 27), (39, 48),
                    (55, 65), (83, 94), (115, 127),
                });

                CheckEqual(expected, actual);
            }

            public void OtherArrayIsUnmodified()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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[] {
                    1, 2, 3, 4,
                    5, 6, 7, 8,
                    9, 10, 11,
                });

                var actual = new ComplexDenseVector(11);
                actual.AssignmentFMA(z, x, y);

                var expectedZ = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (1, 2), (3, 4), (5, 6),
                });

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

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

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

            public void StartingOffsetThis()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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[] {
                    1, 2, 3, 4,
                    5, 6, 7, 8,
                    9, 10, 11,
                });

                var actual = new ComplexDenseVector(12);
                actual.Flush((3, 4));

                actual.AssignmentFMA(z, x, y, startingIndexThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (3, 4),
                    (2, 4), (9, 12), (20, 24), (35, 40),
                    (46, 2), (3, 10), (19, 27), (39, 48),
                    (55, 65), (83, 94), (115, 127),
                });

                CheckEqual(expected, actual);
            }

            public void StartingOffsetSum()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    (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[] {
                    1, 2, 3, 4,
                    5, 6, 7, 8,
                    9, 10, 11,
                });

                var actual = new ComplexDenseVector(11);

                actual.AssignmentFMA(z, x, y, startingIndexSum: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (2, 4), (9, 12), (20, 24), (35, 40),
                    (46, 2), (3, 10), (19, 27), (39, 48),
                    (55, 65), (83, 94), (115, 127),
                });

                CheckEqual(expected, actual);
            }

            public void StartingOffsetA()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    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[] {
                    1, 2, 3, 4,
                    5, 6, 7, 8,
                    9, 10, 11,
                });

                var actual = new ComplexDenseVector(11);

                actual.AssignmentFMA(z, x, y, startingIndexA: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (2, 4), (9, 12), (20, 24), (35, 40),
                    (46, 2), (3, 10), (19, 27), (39, 48),
                    (55, 65), (83, 94), (115, 127),
                });

                CheckEqual(expected, actual);
            }

            public void StartingOffsetB()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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,
                    1, 2, 3, 4,
                    5, 6, 7, 8,
                    9, 10, 11,
                });

                var actual = new ComplexDenseVector(11);

                actual.AssignmentFMA(z, x, y, startingIndexB: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (2, 4), (9, 12), (20, 24), (35, 40),
                    (46, 2), (3, 10), (19, 27), (39, 48),
                    (55, 65), (83, 94), (115, 127),
                });

                CheckEqual(expected, actual);
            }

            public void Sublength()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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[] {
                    1, 2, 3, 4,
                    5, 6, 7, 8,
                    9, 10, 11,
                });

                var actual = new ComplexDenseVector(11);
                actual.Flush((3, 4));

                actual.AssignmentFMA(z, x, y, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    (2, 4), (9, 12), (20, 24), (35, 40),
                    (46, 2), (3, 10), (19, 27), (39, 48),
                    (55, 65), (83, 94), (3, 4),
                });

                CheckEqual(expected, actual);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector z = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (1, 2), (3, 4), (5, 6),
                });

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

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

                ComplexDenseVector actual = new ComplexDenseVector(11);

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentFMA(z, x, y, startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentFMA(z, x, y, startingIndexThis: 12, subLength: 0);
                }

                public void StartingIndexSum_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentFMA(z, x, y, startingIndexSum: -1, subLength: 0);
                }

                public void StartingIndexSum_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentFMA(z, x, y, startingIndexSum: 12, subLength: 0);
                }

                public void StartingIndexA_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentFMA(z, x, y, startingIndexA: -1, subLength: 0);
                }

                public void StartingIndexA_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentFMA(z, x, y, startingIndexA: 12, subLength: 0);
                }

                public void StartingIndexB_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentFMA(z, x, y, startingIndexB: -1, subLength: 0);
                }

                public void StartingIndexB_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentFMA(z, x, y, startingIndexB: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentFMA(z, x, y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentFMA(z, x, y, subLength: 12);
                }
            }
        }

        public class FMAConjugate : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().FMAConjugate((ComplexDenseVector)null, (ComplexDenseVector)null,
                    (int)0, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, -1), (2, -3), (4, -5), (6, -7),
                    (8, -9), (10, -11), (1, -2), (3, -4),
                    (5, -6), (7, -8), (9, 0),
                });

                z.FMAConjugate(x, y);

                var expected = new ComplexDenseVector(new Complex[] {
                    (-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 OtherArraysAreUnmodified()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, -1), (2, -3), (4, -5), (6, -7),
                    (8, -9), (10, -11), (1, -2), (3, -4),
                    (5, -6), (7, -8), (9, 0),
                });

                z.FMAConjugate(x, y);

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

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

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

            public void StartingIndexThis()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, -1), (2, -3), (4, -5), (6, -7),
                    (8, -9), (10, -11), (1, -2), (3, -4),
                    (5, -6), (7, -8), (9, 0),
                });

                z.FMAConjugate(x, y, startingIndexThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    100, (-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 StartingIndexA()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    (0, -1), (2, -3), (4, -5), (6, -7),
                    (8, -9), (10, -11), (1, -2), (3, -4),
                    (5, -6), (7, -8), (9, 0),
                });

                z.FMAConjugate(x, y, startingIndexA: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (-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 StartingIndexB()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    100, (0, -1), (2, -3), (4, -5), (6, -7),
                    (8, -9), (10, -11), (1, -2), (3, -4),
                    (5, -6), (7, -8), (9, 0),
                });

                z.FMAConjugate(x, y, startingIndexB: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (-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 Sublength()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, -1), (2, -3), (4, -5), (6, -7),
                    (8, -9), (10, -11), (1, -2), (3, -4),
                    (5, -6), (7, -8), (9, 0),
                });

                z.FMAConjugate(x, y, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    (-1, 3), (-3, 21), (-5, 55), (-7, 105),
                    (73, 83), (-8, 14), (1, 13), (-1, 39),
                    (-11, 73), (-13, 131), (5, 6)
                });

                CheckEqual(expected, z);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector z = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (1, 2), (3, 4), (5, 6),
                });

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

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

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.FMAConjugate(x, y, startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.FMAConjugate(x, y, startingIndexThis: 12, subLength: 0);
                }

                public void StartingIndexA_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.FMAConjugate(x, y, startingIndexA: -1, subLength: 0);
                }

                public void StartingIndexA_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.FMAConjugate(x, y, startingIndexA: 12, subLength: 0);
                }

                public void StartingIndexB_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.FMAConjugate(x, y, startingIndexB: -1, subLength: 0);
                }

                public void StartingIndexB_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.FMAConjugate(x, y, startingIndexB: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.FMAConjugate(x, y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.FMAConjugate(x, y, subLength: 12);
                }
            }
        }

        public class AssignmentFMAConjugate : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().AssignmentFMAConjugate((ComplexDenseVector)null, (ComplexDenseVector)null,
                    (ComplexDenseVector)null, (int)0, (int)0, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, -1), (2, -3), (4, -5), (6, -7),
                    (8, -9), (10, -11), (1, -2), (3, -4),
                    (5, -6), (7, -8), (9, 0),
                });

                var actual = new ComplexDenseVector(11);
                actual.Flush((3, 4));
                actual.AssignmentFMAConjugate(z, x, y);

                var expected = new ComplexDenseVector(new Complex[] {
                    (-1, 3), (-3, 21), (-5, 55), (-7, 105),
                    (73, 83), (-8, 14), (1, 13), (-1, 39),
                    (-11, 73), (-13, 131), (95, 105)
                });

                CheckEqual(expected, actual);
            }

            public void OtherArrayIsUnmodified()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, -1), (2, -3), (4, -5), (6, -7),
                    (8, -9), (10, -11), (1, -2), (3, -4),
                    (5, -6), (7, -8), (9, 0),
                });

                var actual = new ComplexDenseVector(11);
                actual.AssignmentFMAConjugate(z, x, y);

                var expectedZ = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (1, 2), (3, 4), (5, 6),
                });

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

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

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

            public void StartingOffsetThis()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, -1), (2, -3), (4, -5), (6, -7),
                    (8, -9), (10, -11), (1, -2), (3, -4),
                    (5, -6), (7, -8), (9, 0),
                });

                var actual = new ComplexDenseVector(12);
                actual.Flush((3, 4));

                actual.AssignmentFMAConjugate(z, x, y, startingIndexThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (3, 4),
                    (-1, 3), (-3, 21), (-5, 55), (-7, 105),
                    (73, 83), (-8, 14), (1, 13), (-1, 39),
                    (-11, 73), (-13, 131), (95, 105)
                });

                CheckEqual(expected, actual);
            }

            public void StartingOffsetSum()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, -1), (2, -3), (4, -5), (6, -7),
                    (8, -9), (10, -11), (1, -2), (3, -4),
                    (5, -6), (7, -8), (9, 0),
                });

                var actual = new ComplexDenseVector(11);

                actual.AssignmentFMAConjugate(z, x, y, startingIndexSum: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (-1, 3), (-3, 21), (-5, 55), (-7, 105),
                    (73, 83), (-8, 14), (1, 13), (-1, 39),
                    (-11, 73), (-13, 131), (95, 105)
                });

                CheckEqual(expected, actual);
            }

            public void StartingOffsetA()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    (0, -1), (2, -3), (4, -5), (6, -7),
                    (8, -9), (10, -11), (1, -2), (3, -4),
                    (5, -6), (7, -8), (9, 0),
                });

                var actual = new ComplexDenseVector(11);

                actual.AssignmentFMAConjugate(z, x, y, startingIndexA: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (-1, 3), (-3, 21), (-5, 55), (-7, 105),
                    (73, 83), (-8, 14), (1, 13), (-1, 39),
                    (-11, 73), (-13, 131), (95, 105)
                });

                CheckEqual(expected, actual);
            }

            public void StartingOffsetB()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    100, (0, -1), (2, -3), (4, -5), (6, -7),
                    (8, -9), (10, -11), (1, -2), (3, -4),
                    (5, -6), (7, -8), (9, 0),
                });

                var actual = new ComplexDenseVector(11);

                actual.AssignmentFMAConjugate(z, x, y, startingIndexB: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (-1, 3), (-3, 21), (-5, 55), (-7, 105),
                    (73, 83), (-8, 14), (1, 13), (-1, 39),
                    (-11, 73), (-13, 131), (95, 105)
                });

                CheckEqual(expected, actual);
            }

            public void Sublength()
            {
                var z = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, -1), (2, -3), (4, -5), (6, -7),
                    (8, -9), (10, -11), (1, -2), (3, -4),
                    (5, -6), (7, -8), (9, 0),
                });

                var actual = new ComplexDenseVector(11);
                actual.Flush((3, 4));

                actual.AssignmentFMAConjugate(z, x, y, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    (-1, 3), (-3, 21), (-5, 55), (-7, 105),
                    (73, 83), (-8, 14), (1, 13), (-1, 39),
                    (-11, 73), (-13, 131), (3, 4),
                });

                CheckEqual(expected, actual);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector z = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (1, 2), (3, 4), (5, 6),
                });

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

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

                ComplexDenseVector actual = new ComplexDenseVector(11);

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentFMAConjugate(z, x, y, startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentFMAConjugate(z, x, y, startingIndexThis: 12, subLength: 0);
                }

                public void StartingIndexSum_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentFMAConjugate(z, x, y, startingIndexSum: -1, subLength: 0);
                }

                public void StartingIndexSum_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentFMAConjugate(z, x, y, startingIndexSum: 12, subLength: 0);
                }

                public void StartingIndexA_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentFMAConjugate(z, x, y, startingIndexA: -1, subLength: 0);
                }

                public void StartingIndexA_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentFMAConjugate(z, x, y, startingIndexA: 12, subLength: 0);
                }

                public void StartingIndexB_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentFMAConjugate(z, x, y, startingIndexB: -1, subLength: 0);
                }

                public void StartingIndexB_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentFMAConjugate(z, x, y, startingIndexB: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentFMAConjugate(z, x, y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    actual.AssignmentFMAConjugate(z, x, y, subLength: 12);
                }
            }
        }

        public class AddScalarTests : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().Add(Complex.NaN, (int)0, (int?)null)
            );

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

                x.Add(new Complex(3, -4));

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

                CheckEqual(expected, x);
            }

            public void DoesNotModifyOther()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 Complex(3, 4);

                x.Add(y);

                var expected = new Complex(3, 4);
                CheckEqual(expected, y);
            }

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

                x.Add(new Complex(3, -4), startingIndexThis: 1, subLength: 11);

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

                CheckEqual(expected, x);
            }

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

                x.Add(new Complex(3, -4), subLength: 10);

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

                CheckEqual(expected, x);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

                Complex y = new Complex(3, -4);

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Add(y, startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Add(y, startingIndexThis: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Add(y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Add(y, subLength: 12);
                }
            }
        }

        public class AssignmentAddScalar : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().AssignmentAdd((ComplexDenseVector)null, Complex.NaN,
                    (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 Complex(3, 4);
                var z = new ComplexDenseVector(11);

                z.AssignmentAdd(x, y);

                var expected = new ComplexDenseVector(new Complex[] {
                    (4, 6), (6, 8), (8, 10), (10, 12),
                    (12, 4), (3, 5), (5, 7), (7, 9),
                    (9, 11), (11, 13), (13, 15),
                });

                CheckEqual(expected, z);
            }

            public void OtherArraysAreUnmodified()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 Complex(3, 4);
                var z = new ComplexDenseVector(11);

                z.AssignmentAdd(x, y);

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

                var expectedY = new Complex(3, 4);

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

            public void StartingIndexThis()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 Complex(3, 4);
                var z = new ComplexDenseVector(12);
                z[0] = 100;

                z.AssignmentAdd(x, y, startingIndexThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    100, (4, 6), (6, 8), (8, 10), (10, 12),
                    (12, 4), (3, 5), (5, 7), (7, 9),
                    (9, 11), (11, 13), (13, 15),
                });

                CheckEqual(expected, z);
            }

            public void StartingIndexA()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    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 Complex(3, 4);
                var z = new ComplexDenseVector(11);
                z.AssignmentAdd(x, y, startingIndexA: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (4, 6), (6, 8), (8, 10), (10, 12),
                    (12, 4), (3, 5), (5, 7), (7, 9),
                    (9, 11), (11, 13), (13, 15),
                });

                CheckEqual(expected, z);
            }

            public void Sublength()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 Complex(3, 4);
                var z = new ComplexDenseVector(11);
                z.Flush((7, 12));

                z.AssignmentAdd(x, y, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    (4, 6), (6, 8), (8, 10), (10, 12),
                    (12, 4), (3, 5), (5, 7), (7, 9),
                    (9, 11), (11, 13), (7, 12),
                });

                CheckEqual(expected, z);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

                Complex y = new Complex(3, 4);
                ComplexDenseVector z = new ComplexDenseVector(11);

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentAdd(x, y, startingIndexThis: -1);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentAdd(x, y, startingIndexThis: 12, subLength: 0);
                }

                public void StartingIndexA_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentAdd(x, y, startingIndexA: -1);
                }

                public void StartingIndexA_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentAdd(x, y, startingIndexA: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentAdd(x, y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentAdd(x, y, subLength: 12);
                }
            }
        }

        public class SubtractScalarTests : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().Subtract(Complex.NaN, (int)0, (int?)null)
            );

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

                x.Subtract(new Complex(-3, 4));

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

                CheckEqual(expected, x);
            }

            public void DoesNotModifyOther()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 Complex(-3, 4);

                x.Subtract(y);

                var expected = new Complex(-3, 4);
                CheckEqual(expected, y);
            }

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

                x.Subtract(new Complex(-3, 4), startingIndexThis: 1, subLength: 11);

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

                CheckEqual(expected, x);
            }

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

                x.Subtract(new Complex(-3, 4), subLength: 10);

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

                CheckEqual(expected, x);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

                Complex y = new Complex(3, -4);

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Subtract(y, startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Subtract(y, startingIndexThis: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Subtract(y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Subtract(y, subLength: 12);
                }
            }
        }

        public class AssignmentPostSubtractScalar : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().AssignmentSubtract((ComplexDenseVector)null, Complex.NaN,
                    (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 Complex(-3, -4);
                var z = new ComplexDenseVector(11);

                z.AssignmentSubtract(x, y);

                var expected = new ComplexDenseVector(new Complex[] {
                    (4, 6), (6, 8), (8, 10), (10, 12),
                    (12, 4), (3, 5), (5, 7), (7, 9),
                    (9, 11), (11, 13), (13, 15),
                });

                CheckEqual(expected, z);
            }

            public void OtherArraysAreUnmodified()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 Complex(-3, -4);
                var z = new ComplexDenseVector(11);

                z.AssignmentSubtract(x, y);

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

                var expectedY = new Complex(-3, -4);

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

            public void StartingIndexThis()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 Complex(-3, -4);
                var z = new ComplexDenseVector(12);
                z[0] = 100;

                z.AssignmentSubtract(x, y, startingIndexThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    100, (4, 6), (6, 8), (8, 10), (10, 12),
                    (12, 4), (3, 5), (5, 7), (7, 9),
                    (9, 11), (11, 13), (13, 15),
                });

                CheckEqual(expected, z);
            }

            public void StartingIndexA()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    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 Complex(-3, -4);
                var z = new ComplexDenseVector(11);
                z.AssignmentSubtract(x, y, startingIndexA: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (4, 6), (6, 8), (8, 10), (10, 12),
                    (12, 4), (3, 5), (5, 7), (7, 9),
                    (9, 11), (11, 13), (13, 15),
                });

                CheckEqual(expected, z);
            }

            public void Sublength()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 Complex(-3, -4);
                var z = new ComplexDenseVector(11);
                z.Flush((7, 12));

                z.AssignmentSubtract(x, y, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    (4, 6), (6, 8), (8, 10), (10, 12),
                    (12, 4), (3, 5), (5, 7), (7, 9),
                    (9, 11), (11, 13), (7, 12),
                });

                CheckEqual(expected, z);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

                Complex y = new Complex(-3, -4);
                ComplexDenseVector z = new ComplexDenseVector(11);

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentSubtract(x, y, startingIndexThis: -1);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentSubtract(x, y, startingIndexThis: 12, subLength: 0);
                }

                public void StartingIndexA_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentSubtract(x, y, startingIndexA: -1);
                }

                public void StartingIndexA_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentSubtract(x, y, startingIndexA: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentSubtract(x, y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentSubtract(x, y, subLength: 12);
                }
            }
        }

        public class AssignmentPreSubtractScalar : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().AssignmentSubtract(Complex.NaN, (ComplexDenseVector)null,
                    (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 Complex(-3, -4);
                var z = new ComplexDenseVector(11);

                z.AssignmentSubtract(y, x);

                var expected = new ComplexDenseVector(new Complex[] {
                    (-4, -6), (-6, -8), (-8, -10), (-10, -12),
                    (-12, -4), (-3, -5), (-5, -7), (-7, -9),
                    (-9, -11), (-11, -13), (-13, -15),
                });

                CheckEqual(expected, z);
            }

            public void OtherArraysAreUnmodified()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 Complex(-3, -4);
                var z = new ComplexDenseVector(11);

                z.AssignmentSubtract(y, x);

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

                var expectedY = new Complex(-3, -4);

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

            public void StartingIndexThis()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 Complex(-3, -4);
                var z = new ComplexDenseVector(12);
                z[0] = 100;

                z.AssignmentSubtract(y, x, startingIndexThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    100, (-4, -6), (-6, -8), (-8, -10), (-10, -12),
                    (-12, -4), (-3, -5), (-5, -7), (-7, -9),
                    (-9, -11), (-11, -13), (-13, -15),
                });

                CheckEqual(expected, z);
            }

            public void StartingIndexA()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    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 Complex(-3, -4);
                var z = new ComplexDenseVector(11);
                z.AssignmentSubtract(y, x, startingIndexA: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (-4, -6), (-6, -8), (-8, -10), (-10, -12),
                    (-12, -4), (-3, -5), (-5, -7), (-7, -9),
                    (-9, -11), (-11, -13), (-13, -15),
                });

                CheckEqual(expected, z);
            }

            public void Sublength()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 Complex(-3, -4);
                var z = new ComplexDenseVector(11);
                z.Flush((7, 12));

                z.AssignmentSubtract(y, x, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    (-4, -6), (-6, -8), (-8, -10), (-10, -12),
                    (-12, -4), (-3, -5), (-5, -7), (-7, -9),
                    (-9, -11), (-11, -13), (7, 12),
                });

                CheckEqual(expected, z);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (9, 0), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (10, 11),
                });

                Complex y = new Complex(-3, -4);
                ComplexDenseVector z = new ComplexDenseVector(11);

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentSubtract(y, x, startingIndexThis: -1);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentSubtract(y, x, startingIndexThis: 12, subLength: 0);
                }

                public void StartingIndexA_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentSubtract(y, x, startingIndexA: -1);
                }

                public void StartingIndexA_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentSubtract(y, x, startingIndexA: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentSubtract(y, x, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    z.AssignmentSubtract(y, x, subLength: 12);
                }
            }
        }

        public class DivideComplexScalarTests : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().Divide(Complex.NaN, (int)0, (int?)null)
            );

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

                x.Divide((0.12, -0.16));

                var expected = new ComplexDenseVector(new Complex[] {
                    (-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 ComplexDenseVector(new Complex[] {
                    (3, 4),
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (0, 1),
                });

                x.Divide((0.12, -0.16), startingIndexThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (3, 4),
                    (-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 ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (3, 4),
                });

                x.Divide((0.12, -0.16), subLength: 10);

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

                CheckEqual(expected, x);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (0, 1),
                });

                Complex scalar = (0.12, -0.16);

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Divide(scalar, startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Divide(scalar, startingIndexThis: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Divide(scalar, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Divide(scalar, subLength: 12);
                }
            }
        }

        public class AssignmentDivideComplex : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().AssignmentDivide((ComplexDenseVector)null, Complex.NaN,
                    (int)0, (int)0, (int?)null)
            );

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

                Complex scalar = (0.12, -0.16);

                var y = new ComplexDenseVector(11);

                y.AssignmentDivide(x, scalar);

                var expected = new ComplexDenseVector(new Complex[] {
                    (-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 ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (0, 1),
                });

                Complex scalar = (0.12, -0.16);

                var y = new ComplexDenseVector(11);

                y.AssignmentDivide(x, scalar);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (0, 1),
                });

                Complex scalar = (0.12, -0.16);

                var y = new ComplexDenseVector(12);
                y.Flush((3, 4));

                y.AssignmentDivide(x, scalar, startingIndexThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (3, 4),
                    (-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 StartingOffsetA()
            {
                var x = 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), (0, 1),
                });

                Complex scalar = (0.12, -0.16);

                var y = new ComplexDenseVector(11);
                y.Flush((3, 4));

                y.AssignmentDivide(x, scalar, startingIndexA: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (-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 ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (0, 1),
                });

                Complex scalar = (0.12, -0.16);

                var y = new ComplexDenseVector(11);
                y.Flush((3, 4));

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

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

                CheckEqual(expected, y);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (0, 1),
                });

                ComplexDenseVector y = new ComplexDenseVector(11);

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    y.AssignmentDivide(x, (3, 4), startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    y.AssignmentDivide(x, (3, 4), startingIndexThis: 12, subLength: 0);
                }

                public void StartingIndexA_Negative()
                {
                    CheckThrow(typeof(Exception));
                    y.AssignmentDivide(x, (3, 4), startingIndexA: -1, subLength: 0);
                }

                public void StartingIndexA_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    y.AssignmentDivide(x, (3, 4), startingIndexA: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    y.AssignmentDivide(x, (3, 4), subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    y.AssignmentDivide(x, (3, 4), subLength: 12);
                }
            }
        }

        public class DivideRealScalarTests : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().Divide(Scalar.NaN, (int)0, (int?)null)
            );

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

                x.Divide(1.0/3);

                var expected = new ComplexDenseVector(new Complex[] {
                    (0, 3), (6, 9), (12, 15), (18, 21),
                    (24, 27), (0, 3), (6, 9), (12, 15),
                    (18, 21), (24, 27), (0, 3),
                });

                CheckEqual(expected, x);
            }

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

                x.Divide(1.0/3, startingIndexThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (3, 4),
                    (0, 3), (6, 9), (12, 15), (18, 21),
                    (24, 27), (0, 3), (6, 9), (12, 15),
                    (18, 21), (24, 27), (0, 3),
                });

                CheckEqual(expected, x);
            }

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

                x.Divide(1.0 / 3, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    (0, 3), (6, 9), (12, 15), (18, 21),
                    (24, 27), (0, 3), (6, 9), (12, 15),
                    (18, 21), (24, 27), (3, 4),
                });

                CheckEqual(expected, x);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (0, 1),
                });

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Divide(1.0 / 3, startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Divide(1.0 / 3, startingIndexThis: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Divide(1.0 / 3, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Divide(1.0 / 3, subLength: 12);
                }
            }
        }

        public class AssignmentDivideReal : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().AssignmentDivide((ComplexDenseVector)null, Scalar.NaN,
                    (int)0, (int)0, (int?)null)
            );

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

                var y = new ComplexDenseVector(11);

                y.AssignmentDivide(x, value: 1.0/3);

                var expected = new ComplexDenseVector(new Complex[] {
                    (0, 3), (6, 9), (12, 15), (18, 21),
                    (24, 27), (0, 3), (6, 9), (12, 15),
                    (18, 21), (24, 27), (0, 3),
                });

                CheckEqual(expected, y);
            }

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

                var y = new ComplexDenseVector(11);

                y.AssignmentDivide(x, value: 1.0/3);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (0, 1),
                });

                var y = new ComplexDenseVector(12);
                y.Flush((3, 4));

                y.AssignmentDivide(x, value: 1.0/3, startingIndexThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (3, 4),
                    (0, 3), (6, 9), (12, 15), (18, 21),
                    (24, 27), (0, 3), (6, 9), (12, 15),
                    (18, 21), (24, 27), (0, 3),
                });

                CheckEqual(expected, y);
            }

            public void StartingOffsetA()
            {
                var x = 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), (0, 1),
                });

                var y = new ComplexDenseVector(11);
                y.Flush((3, 4));

                y.AssignmentDivide(x, value: 1.0/3, startingIndexA: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (0, 3), (6, 9), (12, 15), (18, 21),
                    (24, 27), (0, 3), (6, 9), (12, 15),
                    (18, 21), (24, 27), (0, 3),
                });

                CheckEqual(expected, y);
            }

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

                var y = new ComplexDenseVector(11);
                y.Flush((3, 4));

                y.AssignmentDivide(x, value: 1.0/3, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    (0, 3), (6, 9), (12, 15), (18, 21),
                    (24, 27), (0, 3), (6, 9), (12, 15),
                    (18, 21), (24, 27), (3, 4),
                });

                CheckEqual(expected, y);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (0, 1),
                });

                ComplexDenseVector y = new ComplexDenseVector(11);

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    y.AssignmentDivide(x, value: 3, startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    y.AssignmentDivide(x, value: 3, startingIndexThis: 12, subLength: 0);
                }

                public void StartingIndexA_Negative()
                {
                    CheckThrow(typeof(Exception));
                    y.AssignmentDivide(x, value: 3, startingIndexA: -1, subLength: 0);
                }

                public void StartingIndexA_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    y.AssignmentDivide(x, value: 3, startingIndexA: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    y.AssignmentDivide(x, value: 3, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    y.AssignmentDivide(x, value: 3, subLength: 12);
                }
            }
        }

        public class Negate : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().Negate((int)0, (int?)null)
            );

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

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

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

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

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

                x.Negate(startingOffsetThis: 1, subLength: 11);
                CheckEqual(expected, x);
            }

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

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

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

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (1, 2), (3, 4), (5, 6), (7, 8),
                    (-9, 0), (0, 1), (2, 3), (4, 5),
                    (-6, -7), (8, 9), (10, 11),
                });

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Negate(startingOffsetThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Negate(startingOffsetThis: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Negate(subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Negate(subLength: 12);
                }
            }
        }

        public class SumTests : UnitTestSharp.TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().Sum((int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] { (1, 2), (3, 4), (5, 6), (7, 8), (9, 0) });
                CheckEqual((25, 20), x.Sum());
            }

            public void ZeroLength()
            {
                var x = new ComplexDenseVector(new Complex[] { (1, 2), (3, 4), (5, 6), (7, 8), (9, 0) });
                CheckEqual(0, x.Sum(subLength: 0));
            }

            public void NegativeLength()
            {
                var x = new ComplexDenseVector(new Complex[] { (1, 2), (3, 4), (5, 6), (7, 8), (9, 0) });
                CheckThrow(typeof(Exception));
                x.Sum(subLength: -1);
            }

            public void LengthTooLarge()
            {
                var x = new ComplexDenseVector(new Complex[] { (1, 2), (3, 4), (5, 6), (7, 8), (9, 0) });
                CheckThrow(typeof(Exception));
                x.Sum(subLength: 6);
            }

            public void StartingIndex()
            {
                var x = new ComplexDenseVector(new Complex[] { (1, 2), (3, 4), (5, 6), (7, 8), (9, 0) });
                CheckEqual((24, 18), x.Sum(startingOffset: 1, subLength: 4));
            }

            public void StartingIndexNegative()
            {
                var x = new ComplexDenseVector(new Complex[] { (1, 2), (3, 4), (5, 6), (7, 8), (9, 0) });
                CheckThrow(typeof(Exception));
                x.Sum(startingOffset: -1, subLength: 0);
            }

            public void StartingIndexTooLarge()
            {
                var x = new ComplexDenseVector(new Complex[] { (1, 2), (3, 4), (5, 6), (7, 8), (9, 0) });
                CheckThrow(typeof(Exception));
                x.Sum(startingOffset: 6, subLength: 0);
            }
        }

        public class Scale : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().Scale(Complex.NaN, (int)0, (int?)null)
            );

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

                x.Scale(scalar: (3, 4));

                var expected = new ComplexDenseVector(new Complex[] {
                    (-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 ComplexDenseVector(new Complex[] {
                    (3, 4),
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (0, 1),
                });

                x.Scale(scalar: (3, 4), startingIndexThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (3, 4),
                    (-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 ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (3, 4),
                });

                x.Scale(scalar: (3, 4), subLength: 10);

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

                CheckEqual(expected, x);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (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);

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Scale(scalar, startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Scale(scalar, startingIndexThis: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Scale(scalar, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Scale(scalar, subLength: 12);
                }
            }
        }

        public class MultiplyScalar : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().Multiply(Complex.NaN, (int)0, (int?)null)
            );

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

                x.Multiply((3, 4));

                var expected = new ComplexDenseVector(new Complex[] {
                    (-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 ComplexDenseVector(new Complex[] {
                    (3, 4),
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (0, 1),
                });

                x.Multiply((3, 4), startingIndexThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (3, 4),
                    (-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 ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (3, 4),
                });

                x.Multiply((3, 4), subLength: 10);

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

                CheckEqual(expected, x);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (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);

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Multiply(scalar, startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Multiply(scalar, startingIndexThis: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Multiply(scalar, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Multiply(scalar, subLength: 12);
                }
            }
        }

        public class ScaleReal : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().Scale(Scalar.NaN, (int)0, (int?)null)
            );

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

                x.Scale(scalar: 3);

                var expected = new ComplexDenseVector(new Complex[] {
                    (0, 3), (6, 9), (12, 15), (18, 21),
                    (24, 27), (0, 3), (6, 9), (12, 15),
                    (18, 21), (24, 27), (0, 3),
                });

                CheckEqual(expected, x);
            }

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

                x.Scale(scalar: 3, startingIndexThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (3, 4),
                    (0, 3), (6, 9), (12, 15), (18, 21),
                    (24, 27), (0, 3), (6, 9), (12, 15),
                    (18, 21), (24, 27), (0, 3),
                });

                CheckEqual(expected, x);
            }

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

                x.Scale(scalar: 3, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    (0, 3), (6, 9), (12, 15), (18, 21),
                    (24, 27), (0, 3), (6, 9), (12, 15),
                    (18, 21), (24, 27), (3, 4),
                });

                CheckEqual(expected, x);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (0, 1),
                });

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Scale(scalar: 3, startingIndexThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Scale(scalar: 3, startingIndexThis: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Scale(scalar: 3, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Scale(scalar: 3, subLength: 12);
                }
            }
        }

        public class AssignmentScale : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().AssignmentScale((ComplexDenseVector)null, Complex.NaN,
                    (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);

                y.AssignmentScale(x, scalar);

                var expected = new ComplexDenseVector(new Complex[] {
                    (-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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);

                y.AssignmentScale(x, scalar);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(12);
                y.Flush((3, 4));

                y.AssignmentScale(x, scalar, startingOffsetThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (3, 4),
                    (-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 StartingOffsetA()
            {
                var x = 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), (0, 1),
                });

                Complex scalar = (3, 4);

                var y = new ComplexDenseVector(11);
                y.Flush((3, 4));

                y.AssignmentScale(x, scalar, startingOffsetA: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (-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 ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(11);
                y.Flush((3, 4));

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

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

                CheckEqual(expected, y);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (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);

                ComplexDenseVector y = new ComplexDenseVector(11);

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    y.AssignmentScale(x, (3, 4), startingOffsetThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    y.AssignmentScale(x, (3, 4), startingOffsetThis: 12, subLength: 0);
                }

                public void StartingIndexA_Negative()
                {
                    CheckThrow(typeof(Exception));
                    y.AssignmentScale(x, (3, 4), startingOffsetA: -1, subLength: 0);
                }

                public void StartingIndexA_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    y.AssignmentScale(x, (3, 4), startingOffsetA: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    y.AssignmentScale(x, (3, 4), subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    y.AssignmentScale(x, (3, 4), subLength: 12);
                }
            }
        }

        public class AssignmentScaleReal : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().AssignmentScale((ComplexDenseVector)null, Scalar.NaN,
                    (int)0, (int)0, (int?)null)
            );

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

                var y = new ComplexDenseVector(11);

                y.AssignmentScale(x, scalar: 3);

                var expected = new ComplexDenseVector(new Complex[] {
                    (0, 3), (6, 9), (12, 15), (18, 21),
                    (24, 27), (0, 3), (6, 9), (12, 15),
                    (18, 21), (24, 27), (0, 3),
                });

                CheckEqual(expected, y);
            }

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

                var y = new ComplexDenseVector(11);

                y.AssignmentScale(x, scalar: 3);

                var expected = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (0, 1),
                });

                var y = new ComplexDenseVector(12);
                y.Flush((3, 4));

                y.AssignmentScale(x, scalar: 3, startingOffsetThis: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (3, 4),
                    (0, 3), (6, 9), (12, 15), (18, 21),
                    (24, 27), (0, 3), (6, 9), (12, 15),
                    (18, 21), (24, 27), (0, 3),
                });

                CheckEqual(expected, y);
            }

            public void StartingOffsetA()
            {
                var x = 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), (0, 1),
                });

                var y = new ComplexDenseVector(11);
                y.Flush((3, 4));

                y.AssignmentScale(x, scalar: 3, startingOffsetA: 1, subLength: 11);

                var expected = new ComplexDenseVector(new Complex[] {
                    (0, 3), (6, 9), (12, 15), (18, 21),
                    (24, 27), (0, 3), (6, 9), (12, 15),
                    (18, 21), (24, 27), (0, 3),
                });

                CheckEqual(expected, y);
            }

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

                var y = new ComplexDenseVector(11);
                y.Flush((3, 4));

                y.AssignmentScale(x, scalar: 3, subLength: 10);

                var expected = new ComplexDenseVector(new Complex[] {
                    (0, 3), (6, 9), (12, 15), (18, 21),
                    (24, 27), (0, 3), (6, 9), (12, 15),
                    (18, 21), (24, 27), (3, 4),
                });

                CheckEqual(expected, y);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(new Complex[] {
                    (0, 1), (2, 3), (4, 5), (6, 7),
                    (8, 9), (0, 1), (2, 3), (4, 5),
                    (6, 7), (8, 9), (0, 1),
                });

                ComplexDenseVector y = new ComplexDenseVector(11);

                public void StartingIndexThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    y.AssignmentScale(x, scalar: 3, startingOffsetThis: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    y.AssignmentScale(x, scalar: 3, startingOffsetThis: 12, subLength: 0);
                }

                public void StartingIndexA_Negative()
                {
                    CheckThrow(typeof(Exception));
                    y.AssignmentScale(x, scalar: 3, startingOffsetA: -1, subLength: 0);
                }

                public void StartingIndexA_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    y.AssignmentScale(x, scalar: 3, startingOffsetA: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    y.AssignmentScale(x, scalar: 3, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    y.AssignmentScale(x, scalar: 3, subLength: 12);
                }
            }
        }

        public class Flush : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().Flush(Complex.NaN, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = new ComplexDenseVector(11);
                x.Flush((3, 4));

                ComplexDenseVector expected = new ComplexDenseVector(new Complex[] {
                    (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 StartingOffset()
            {
                var x = new ComplexDenseVector(11);
                x[0] = 100;
                x.Flush((3, 4), startingOffset: 1, subLength: 10);

                ComplexDenseVector expected = new ComplexDenseVector(new Complex[] {
                    100, (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 Sublength()
            {
                var x = new ComplexDenseVector(11);
                x[10] = 100;
                x.Flush((3, 4), subLength: 10);

                ComplexDenseVector expected = new ComplexDenseVector(new Complex[] {
                    (3, 4), (3, 4), (3, 4), (3, 4),
                    (3, 4), (3, 4), (3, 4), (3, 4),
                    (3, 4), (3, 4), 100,
                });

                CheckEqual(expected, x);
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = new ComplexDenseVector(11);

                public void StartingOffset_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Flush((3, 4), startingOffset: -1, subLength: 0);
                }

                public void StartingIndexThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Flush((3, 4), startingOffset: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Flush((3, 4), subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Flush((3, 4), subLength: 12);
                }

            }
        }

        public class DotProduct : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().DotProduct((ComplexDenseVector)null, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = 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 y = new ComplexDenseVector(new Complex[] {
                    (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.DotProduct(y));
            }

            public void ArraysAreUnmodified()
            {
                var x = 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 y = new ComplexDenseVector(new Complex[] {
                    (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 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 expectedY = new ComplexDenseVector(new Complex[] {
                    (9, 1), (0, 3), (8, 6), (7, 5),
                    (2, 0), (4, 8), (1, 3), (4, 0),
                    (0, 5), (7, 9), (6, 2)
                });

                x.DotProduct(y);

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

            public void StartingOffsetThis()
            {
                var x = 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 y = new ComplexDenseVector(new Complex[] {
                    (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.DotProduct(y, startingOffsetThis: 1, subLength: 11));
            }

            public void StartingOffsetOther()
            {
                var x = 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 y = new ComplexDenseVector(new Complex[] {
                    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.DotProduct(y, startingOffsetA: 1, subLength: 11));
            }

            public void Sublength()
            {
                var x = 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), 100, 100
                });

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

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

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = 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),
                });

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

                public void StartingOffsetThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.DotProduct(y, startingOffsetThis: -1, subLength: 0);
                }

                public void StartingOffsetThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.DotProduct(y, startingOffsetThis: 12, subLength: 0);
                }

                public void StartingOffsetOther_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.DotProduct(y, startingOffsetA: -1, subLength: 0);
                }

                public void StartingOffsetOther_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.DotProduct(y, startingOffsetA: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.DotProduct(y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.DotProduct(y, subLength: 12);
                }
            }
        }

        public class DotProductWithReal : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().DotProduct((DenseVector)null, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = 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),
                });

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

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

            public void ArraysAreUnmodified()
            {
                var x = 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),
                });

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

                var expectedX = 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),
                });

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

                x.DotProduct(y);

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

            public void StartingOffsetThis()
            {
                var x = 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),
                });

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

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

            public void StartingOffsetOther()
            {
                var x = 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),
                });

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

                CheckEqual((170, -215), x.DotProduct(y, startingOffsetA: 1, subLength: 11));
            }

            public void Sublength()
            {
                var x = 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), 101,
                });

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

                CheckEqual((170, -215), x.DotProduct(y, subLength: 11));
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = 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),
                });

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

                public void StartingOffsetThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.DotProduct(y, startingOffsetThis: -1, subLength: 0);
                }

                public void StartingOffsetThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.DotProduct(y, startingOffsetThis: 12, subLength: 0);
                }

                public void StartingOffsetOther_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.DotProduct(y, startingOffsetA: -1, subLength: 0);
                }

                public void StartingOffsetOther_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.DotProduct(y, startingOffsetA: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.DotProduct(y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.DotProduct(y, subLength: 12);
                }
            }

            public class ReverseTests : TestFixture, ITestFixture
            {
                public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                    new ComplexDenseVector().Reverse((int)0, (int?)null)
                );

                public void FullLoopsAndExtra()
                {
                    ComplexDenseVector actual = new ComplexDenseVector(new Complex[]
                    {
                        (1,   2),   (3,  4),   (5,  6),    (7,  8),
                        (9,  10),  (11, 12),   (13, 14),   (15, 16),
                        (17, 18),  (19, 20),   (21, 22),
                    });
                    ComplexDenseVector expected = new ComplexDenseVector(new Complex[]
                    {
                        (21, 22), (19, 20), (17, 18), (15, 16),
                        (13, 14), (11, 12),  (9, 10),  (7,  8),
                         (5,  6),  (3,  4),  (1,  2),
                    });

                    actual.Reverse();

                    CheckEqual(expected, actual);
                }

                public void EvenLength()
                {
                    ComplexDenseVector actual = new ComplexDenseVector(new Complex[]
                    {
                        (1, 2), (3, 4), (5, 6), (7, 8), (9, 10), (11, 12),
                    });
                    ComplexDenseVector expected = new ComplexDenseVector(new Complex[]
                    {
                        (11, 12), (9, 10), (7, 8), (5, 6), (3, 4), (1, 2),
                    });

                    actual.Reverse();

                    CheckEqual(expected, actual);
                }

                public void OddLength()
                {
                    ComplexDenseVector actual = new ComplexDenseVector(new Complex[]
                    {
                        (1, 2), (3, 4), (5, 6), (7, 8), (9, 10),
                    });

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

                    actual.Reverse();

                    CheckEqual(expected, actual);
                }

                public void Offset()
                {
                    ComplexDenseVector actual = new ComplexDenseVector(new Complex[]
                    {
                        (100, 101), (1, 2), (3, 4), (5, 6), (7, 8), (9, 10),
                    });

                    ComplexDenseVector expected = new ComplexDenseVector(new Complex[]
                    {
                        (100, 101), (9, 10), (7, 8), (5, 6), (3, 4), (1, 2),
                    });

                    actual.Reverse(startingOffset: 1, subLength: 5);

                    CheckEqual(expected, actual);
                }

                public void Length()
                {
                    ComplexDenseVector actual = new ComplexDenseVector(new Complex[]
                    {
                        (1, 2), (3, 4), (5, 6), (7, 8), (9, 10), (102, 103), (104, 105),
                    });

                    ComplexDenseVector expected = new ComplexDenseVector(new Complex[]
                    {
                        (9, 10), (7, 8), (5, 6), (3, 4), (1, 2), (102, 103), (104, 105),
                    });

                    actual.Reverse(subLength: 5);

                    CheckEqual(expected, actual);
                }

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

                public void StartingOffsetThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Reverse(startingOffset: -1, subLength: 0);
                }

                public void StartingOffsetThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Reverse(startingOffset: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.Reverse(startingOffset: 0, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.Reverse(startingOffset: 0, subLength: 12);
                }
            }
        }

        public class MACCTests : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().MACC((ComplexDenseVector)null, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = 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 y = new ComplexDenseVector(new Complex[] {
                    (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.MACC(y));
            }

            public void ArraysAreUnmodified()
            {
                var x = 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 y = new ComplexDenseVector(new Complex[] {
                    (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 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 expectedY = new ComplexDenseVector(new Complex[] {
                    (9, -1), (0, -3), (8, -6), (7, -5),
                    (2, 0), (4, -8), (1, -3), (4, 0),
                    (0, -5), (7, -9), (6, -2)
                });

                x.MACC(y);

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

            public void StartingOffsetThis()
            {
                var x = 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 y = new ComplexDenseVector(new Complex[] {
                    (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.MACC(y, startingOffsetThis: 1, subLength: 11));
            }

            public void StartingOffsetOther()
            {
                var x = 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 y = new ComplexDenseVector(new Complex[] {
                    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.MACC(y, startingOffsetA: 1, subLength: 11));
            }

            public void Sublength()
            {
                var x = 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), 100, 100
                });

                var y = new ComplexDenseVector(new Complex[] {
                    (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.MACC(y, subLength: 11));
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = 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),
                });

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

                public void StartingOffsetThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.MACC(y, startingOffsetThis: -1, subLength: 0);
                }

                public void StartingOffsetThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.MACC(y, startingOffsetThis: 12, subLength: 0);
                }

                public void StartingOffsetOther_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.MACC(y, startingOffsetA: -1, subLength: 0);
                }

                public void StartingOffsetOther_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.MACC(y, startingOffsetA: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.MACC(y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.MACC(y, subLength: 12);
                }
            }
        }

        public class MACCConjugate : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().MACCConjugate((ComplexDenseVector)null, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = 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 y = new ComplexDenseVector(new Complex[] {
                    (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.MACCConjugate(y));
            }

            public void ArraysAreUnmodified()
            {
                var x = 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 y = new ComplexDenseVector(new Complex[] {
                    (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 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 expectedY = new ComplexDenseVector(new Complex[] {
                    (9, 1), (0, 3), (8, 6), (7, 5),
                    (2, 0), (4, 8), (1, 3), (4, 0),
                    (0, 5), (7, 9), (6, 2)
                });

                x.MACCConjugate(y);

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

            public void StartingOffsetThis()
            {
                var x = 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 y = new ComplexDenseVector(new Complex[] {
                    (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.MACCConjugate(y, startingOffsetThis: 1, subLength: 11));
            }

            public void StartingOffsetOther()
            {
                var x = 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 y = new ComplexDenseVector(new Complex[] {
                    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.MACCConjugate(y, startingOffsetA: 1, subLength: 11));
            }

            public void Sublength()
            {
                var x = 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), 100, 100
                });

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

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

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = 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),
                });

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

                public void StartingOffsetThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.MACCConjugate(y, startingOffsetThis: -1, subLength: 0);
                }

                public void StartingOffsetThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.MACCConjugate(y, startingOffsetThis: 12, subLength: 0);
                }

                public void StartingOffsetOther_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.MACCConjugate(y, startingOffsetA: -1, subLength: 0);
                }

                public void StartingOffsetOther_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.MACCConjugate(y, startingOffsetA: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.MACCConjugate(y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.MACCConjugate(y, subLength: 12);
                }
            }
        }

        public class MACCWithRealTests : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().MACC((DenseVector)null, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = 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 y = new DenseVector(new Scalar[] {
                    9, 0, 8, 7,
                    2, 4, 1, 4,
                    0, 7, 6
                });

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

            public void ArraysAreUnmodified()
            {
                var x = 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 y = new DenseVector(new Scalar[] {
                    9, 0, 8, 7,
                    2, 4, 1, 4,
                    0, 7, 6
                });

                var expectedX = 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 expectedY = new DenseVector(new Scalar[] {
                    9, 0, 8, 7,
                    2, 4, 1, 4,
                    0, 7, 6
                });

                x.MACC(y);

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

            public void StartingOffsetThis()
            {
                var x = 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 y = new DenseVector(new Scalar[] {
                    9, 0, 8, 7,
                    2, 4, 1, 4,
                    0, 7, 6
                });

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

            public void StartingOffsetOther()
            {
                var x = 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 y = new DenseVector(new Scalar[] {
                    100,
                    9, 0, 8, 7,
                    2, 4, 1, 4,
                    0, 7, 6
                });

                CheckEqual((224, 272), x.MACC(y, startingOffsetA: 1, subLength: 11));
            }

            public void Sublength()
            {
                var x = 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), 100, 100
                });

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

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

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = 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),
                });

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

                public void StartingOffsetThis_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.MACC(y, startingOffsetThis: -1, subLength: 0);
                }

                public void StartingOffsetThis_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.MACC(y, startingOffsetThis: 12, subLength: 0);
                }

                public void StartingOffsetOther_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.MACC(y, startingOffsetA: -1, subLength: 0);
                }

                public void StartingOffsetOther_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.MACC(y, startingOffsetA: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    x.MACC(y, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    x.MACC(y, subLength: 12);
                }
            }
        }

        public class TripleMACCTests : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                ComplexDenseVector.TripleMACC((ComplexDenseVector)null, (ComplexDenseVector)null,
                    (ComplexDenseVector)null, (int)0, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = 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 y = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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), ComplexDenseVector.TripleMACC(x, y, z));
            }

            public void ZeroLength()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    
                });

                var y = new ComplexDenseVector(new Complex[] {
                    
                });

                var z = new ComplexDenseVector(new Complex[] {
                    
                });

                CheckEqual((0, 0), ComplexDenseVector.TripleMACC(x, y, z));
            }

            public void ArraysAreUnmodified()
            {
                var x = 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 y = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (6, 4), (4, 1), (5, 4), (4, 5),
                    (8, 5), (-5, -3), (-7, 0), (9, 9),
                    (8, 8), (-6, 0), (-2, 3)
                });

                var expectedX = 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 expectedY = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (6, 4), (4, 1), (5, 4), (4, 5),
                    (8, 5), (-5, -3), (-7, 0), (9, 9),
                    (8, 8), (-6, 0), (-2, 3)
                });

                ComplexDenseVector.TripleMACC(x, y, z);

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

            public void StartingOffsetA()
            {
                var x = 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 y = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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), ComplexDenseVector.TripleMACC(x, y, z, startingOffsetA: 1, subLength: 11));
            }

            public void StartingOffsetB()
            {
                var x = 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 y = new ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    (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), ComplexDenseVector.TripleMACC(x, y, z, startingOffsetB: 1, subLength: 11));
            }

            public void StartingOffsetC()
            {
                var x = 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 y = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    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), ComplexDenseVector.TripleMACC(x, y, z, startingOffsetC: 1, subLength: 11));
            }

            public void Sublength()
            {
                var x = 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), 100, 100
                });

                var y = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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), ComplexDenseVector.TripleMACC(x, y, z, subLength: 11));
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = 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),
                });

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

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

                public void StartingOffsetA_Negative()
                {
                    CheckThrow(typeof(Exception));
                    ComplexDenseVector.TripleMACC(x, y, z, startingOffsetA: -1, subLength: 0);
                }

                public void StartingOffsetA_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    ComplexDenseVector.TripleMACC(x, y, z, startingOffsetA: 12, subLength: 0);
                }

                public void StartingOffsetB_Negative()
                {
                    CheckThrow(typeof(Exception));
                    ComplexDenseVector.TripleMACC(x, y, z, startingOffsetB: -1, subLength: 0);
                }

                public void StartingOffsetB_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    ComplexDenseVector.TripleMACC(x, y, z, startingOffsetB: 12, subLength: 0);
                }

                public void StartingOffsetC_Negative()
                {
                    CheckThrow(typeof(Exception));
                    ComplexDenseVector.TripleMACC(x, y, z, startingOffsetC: -1, subLength: 0);
                }

                public void StartingOffsetC_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    ComplexDenseVector.TripleMACC(x, y, z, startingOffsetC: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    ComplexDenseVector.TripleMACC(x, y, z, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    ComplexDenseVector.TripleMACC(x, y, z, subLength: 12);
                }
            }
        }

        public class TripleMACCConjugateFirstTests : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                ComplexDenseVector.TripleMACCConjugateFirst((ComplexDenseVector)null, (ComplexDenseVector)null,
                    (ComplexDenseVector)null, (int)0, (int)0, (int)0, (int?)null)
            );

            public void Basic()
            {
                var x = 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 y = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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), ComplexDenseVector.TripleMACCConjugateFirst(x, y, z));
            }

            public void ZeroLength()
            {
                var x = new ComplexDenseVector(new Complex[] {
                    
                });

                var y = new ComplexDenseVector(new Complex[] {
                    
                });

                var z = new ComplexDenseVector(new Complex[] {
                    
                });

                CheckEqual((0, 0), ComplexDenseVector.TripleMACCConjugateFirst(x, y, z));
            }

            public void ArraysAreUnmodified()
            {
                var x = 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 y = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (6, 4), (4, 1), (5, 4), (4, 5),
                    (8, 5), (-5, -3), (-7, 0), (9, 9),
                    (8, 8), (-6, 0), (-2, 3)
                });

                var expectedX = 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 expectedY = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (6, 4), (4, 1), (5, 4), (4, 5),
                    (8, 5), (-5, -3), (-7, 0), (9, 9),
                    (8, 8), (-6, 0), (-2, 3)
                });

                ComplexDenseVector.TripleMACCConjugateFirst(x, y, z);

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

            public void StartingOffsetA()
            {
                var x = 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 y = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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), ComplexDenseVector.TripleMACCConjugateFirst(x, y, z, startingOffsetA: 1, subLength: 11));
            }

            public void StartingOffsetB()
            {
                var x = 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 y = new ComplexDenseVector(new Complex[] {
                    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 ComplexDenseVector(new Complex[] {
                    (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), ComplexDenseVector.TripleMACCConjugateFirst(x, y, z, startingOffsetB: 1, subLength: 11));
            }

            public void StartingOffsetC()
            {
                var x = 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 y = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    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), ComplexDenseVector.TripleMACCConjugateFirst(x, y, z, startingOffsetC: 1, subLength: 11));
            }

            public void Sublength()
            {
                var x = 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), 100, 100
                });

                var y = new ComplexDenseVector(new Complex[] {
                    (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 ComplexDenseVector(new Complex[] {
                    (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), ComplexDenseVector.TripleMACCConjugateFirst(x, y, z, subLength: 11));
            }

            public class BoundsTests : TestFixture
            {
                ComplexDenseVector x = 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),
                });

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

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

                public void StartingOffsetA_Negative()
                {
                    CheckThrow(typeof(Exception));
                    ComplexDenseVector.TripleMACCConjugateFirst(x, y, z, startingOffsetA: -1, subLength: 0);
                }

                public void StartingOffsetA_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    ComplexDenseVector.TripleMACCConjugateFirst(x, y, z, startingOffsetA: 12, subLength: 0);
                }

                public void StartingOffsetB_Negative()
                {
                    CheckThrow(typeof(Exception));
                    ComplexDenseVector.TripleMACCConjugateFirst(x, y, z, startingOffsetB: -1, subLength: 0);
                }

                public void StartingOffsetB_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    ComplexDenseVector.TripleMACCConjugateFirst(x, y, z, startingOffsetB: 12, subLength: 0);
                }

                public void StartingOffsetC_Negative()
                {
                    CheckThrow(typeof(Exception));
                    ComplexDenseVector.TripleMACCConjugateFirst(x, y, z, startingOffsetC: -1, subLength: 0);
                }

                public void StartingOffsetC_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    ComplexDenseVector.TripleMACCConjugateFirst(x, y, z, startingOffsetC: 12, subLength: 0);
                }

                public void Sublength_Negative()
                {
                    CheckThrow(typeof(Exception));
                    ComplexDenseVector.TripleMACCConjugateFirst(x, y, z, subLength: -1);
                }

                public void Sublength_TooLarge()
                {
                    CheckThrow(typeof(Exception));
                    ComplexDenseVector.TripleMACCConjugateFirst(x, y, z, subLength: 12);
                }
            }
        }

        public class EvaluatePolynomial : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().EvaluatePolynomial(Complex.NaN, (int)0, (int?)null)
            );

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

                var value = x.EvaluatePolynomial(new Complex(3, 4));
                CheckEqual(new Complex(76339, 8986), value);
            }

            public void StartingOffset()
            {
                var x = new ComplexDenseVector(new Complex[]
                {
                    (101, 102), (1, 2), (3, 4), (5, 6), (7, 8), (9, 0), (1, 2), (3, 4),
                });

                var value = x.EvaluatePolynomial(new Complex(3, 4), startingOffset: 1, subLength: 7);
                CheckEqual(new Complex(76339, 8986), value);
            }

            public void Length()
            {
                var x = new ComplexDenseVector(new Complex[]
                {
                    (1, 2), (3, 4), (5, 6), (7, 8), (9, 0), (1, 2), (3, 4), (101, 102), (103, 104),
                });

                var value = x.EvaluatePolynomial(new Complex(3, 4), subLength: 7);
                CheckEqual(new Complex(76339, 8986), value);
            }

            ComplexDenseVector x = new ComplexDenseVector(new Complex[]
            {
                (1, 2), (3, 4), (5, 6), (7, 8), (9, 0), (1, 2), (3, 4),
            });
            public void StartingOffset_Negative()
            {
                CheckThrow(typeof(Exception));
                x.EvaluatePolynomial(new Complex(3, 4), startingOffset: -1, subLength: 0);
            }

            public void StartingOffset_TooLarge()
            {
                CheckThrow(typeof(Exception));
                x.EvaluatePolynomial(new Complex(3, 4), startingOffset: 8, subLength: 0);
            }

            public void Sublength_Negative()
            {
                CheckThrow(typeof(Exception));
                x.EvaluatePolynomial(new Complex(3, 4), startingOffset: 2, subLength: -1);
            }

            public void Sublength_TooLarge()
            {
                CheckThrow(typeof(Exception));
                x.EvaluatePolynomial(new Complex(3, 4), startingOffset: 0, subLength: 8);
            }
        }

        public class Magnitude : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().Magnitude((int)0, (int?)null)
            );

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

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

            public void ZeroLength()
            {
                ComplexDenseVector vec = new ComplexDenseVector (new Complex[] { });
                CheckEqual(0, vec.Magnitude());
            }

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

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

            ComplexDenseVector x = new ComplexDenseVector(new Complex[] { 0, -1, 2, -3, 4, -5, });
            public void StartingOffset_Negative()
            {
                CheckThrow(typeof(Exception));
                x.Magnitude(startingOffset: -1, subLength: 0);
            }

            public void StartingOffset_TooLarge()
            {
                CheckThrow(typeof(Exception));
                x.Magnitude(startingOffset: 7, subLength: 0);
            }

            public void Sublength_Negative()
            {
                CheckThrow(typeof(Exception));
                x.Magnitude(subLength: -1);
            }

            public void Sublength_TooLarge()
            {
                CheckThrow(typeof(Exception));
                x.Magnitude(subLength: 7);
            }
        }

        public class MagnitudeSquared : TestFixture, ITestFixture
        {
            public MethodInfo MethodInfo => LambdaHelper.GetMethodInfoForWrappedCall(() =>
                new ComplexDenseVector().MagnitudeSquared((int)0, (int?)null)
            );

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

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

            public void ZeroLength()
            {
                ComplexDenseVector vec = new ComplexDenseVector(new Complex[] { } );
                CheckEqual(0, vec.MagnitudeSquared());
            }

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

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

            ComplexDenseVector x = new ComplexDenseVector(new Complex[] { 0, -1, 2, -3, 4, -5, });
            public void StartingOffset_Negative()
            {
                CheckThrow(typeof(Exception));
                x.MagnitudeSquared(startingOffset: -1, subLength: 0);
            }

            public void StartingOffset_TooLarge()
            {
                CheckThrow(typeof(Exception));
                x.MagnitudeSquared(startingOffset: 7, subLength: 0);
            }

            public void Sublength_Negative()
            {
                CheckThrow(typeof(Exception));
                x.MagnitudeSquared(subLength: -1);
            }

            public void Sublength_TooLarge()
            {
                CheckThrow(typeof(Exception));
                x.MagnitudeSquared(subLength: 7);
            }
        }

        private static MethodInfo GetMethodInfo<T>(Expression<Func<T>> func)
        {
            var baseMethod = LambdaHelper.GetMethodInfoForWrappedCall(func);

            var parameterTypes = baseMethod.GetParameters().Select(parameter => parameter.ParameterType).ToArray();

            return typeof(ComplexDenseVector).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 ComplexDenseVector()).GetType()),
                    GetMethodInfo(() => (new ComplexDenseVector()).GetHashCode()),
                };

                var untestedMethods = typeof(ComplexDenseVector)
                    .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}");
                }
            }
        }
    }
}