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

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

                var vector = new DenseVector(array);

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

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

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

                var vector = new DenseVector(array);

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

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

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

                var vector = new DenseVector(array);

                array[0] = 10;

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

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

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

                array[0] = 10;

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

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

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

                CheckEqual(10, vector.Length);
            }

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

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

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

                var copy = new DenseVector(vec);

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

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

                var copy = new DenseVector(vec);

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

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

                var vector = new DenseVector(array);

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

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

                var vector = new DenseVector(array);

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

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

                var vector = new DenseVector(array);

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

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

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

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

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

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

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

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

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

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

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

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

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

                vec.SwapElements(3, 4);

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

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

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

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

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

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

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

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

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

                vec.Normalize();

                CheckEqual(expected, vec);
            }

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

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

                vec.Normalize(5);

                CheckEqual(expected, vec);
            }

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

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

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

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

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

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

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

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

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

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

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

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

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

                actual = actual.ForwardPermute(permutations);

                CheckEqual(expected, actual);
            }

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

                actual = actual.ForwardPermute(permutations);

                CheckEqual(expected, actual);
            }

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

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

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

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

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

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

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

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

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

                actual = actual.ForwardPermute(permutations);

                CheckEqual(expected, actual);
            }
        }

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

                actual = actual.BackPermute(permutations);

                CheckEqual(expected, actual);
            }

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

                actual = actual.BackPermute(permutations);

                CheckEqual(expected, actual);
            }

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

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

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

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

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

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

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

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

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

                actual = actual.BackPermute(permutations);

                CheckEqual(expected, actual);
            }
        }

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

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

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

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

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

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

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

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

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

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

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

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