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

namespace Azimuth.UnitTests.DenseLinearAlgebra
{
    public class LinearLeastSquaresTests_Solve : UnitTestSharp.TestFixture
    {
        public class FullRankSquare : UnitTestSharp.TestFixture
        {
            public void x11()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 7 },
                });

                var input = new DenseVector(new Scalar[] {
                    28,
                });

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

                DenseVector output;

                LinearLeastSquares lls = new LinearLeastSquares(matrix);
                lls.SolveSystem(out output, input);

                CheckEqual(expected, output);
            }

            public void x22_Triangular()
            {

                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 2, 1, },
                    { 0, 1, },
                });

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

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

                DenseVector output;

                LinearLeastSquares lls = new LinearLeastSquares(matrix);
                lls.SolveSystem(out output, input);

                CheckEqual(expected, output);
            }
            
            public void x22()
            {                
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 3, 4, },
                    { 7, 10, },
                });

                var input = new DenseVector(new Scalar[] {
                    7,
                    17,
                });

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

                DenseVector output;

                LinearLeastSquares lls = new LinearLeastSquares(matrix);
                lls.SolveSystem(out output, input);

                CheckEqual(expected, output);
            }

            public void x33_Triangular()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 4, 2, 1, },                    
                    { 0, 2, 1, },
                    { 0, 0, 1, },
                });

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

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

                DenseVector output;

                LinearLeastSquares lls = new LinearLeastSquares(matrix);
                lls.SolveSystem(out output, input);

                CheckEqual(expected, output);
            }

            public void x33_A()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 2,  1,  3, },
                    {-1,  0,  7, },
                    { 0, -1, -1, },
                });

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

                var expected = new DenseVector(new Scalar[] {
                       .75,
                     -1.25,
                       .25,
                });

                DenseVector output;

                LinearLeastSquares lls = new LinearLeastSquares(matrix);
                lls.SolveSystem(out output, input);

                CheckEqual(expected, output);
            }

            public void x33()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 1, 2, 3, },                    
                    { 1, 2, 1, },
                    { 3, 2, 1, },
                });

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

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

                DenseVector output;

                LinearLeastSquares lls = new LinearLeastSquares(matrix);
                lls.SolveSystem(out output, input);

                CheckEqual(expected, output);
            }
        }

        public class RankDeficientSquare : UnitTestSharp.TestFixture
        {
            public void x22()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 1, 2, },
                    { 2, 4, },
                });

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

                var expected = new DenseVector(new Scalar[] {
                    .12,
                    .24,
                });

                DenseVector output;

                LinearLeastSquares lls = new LinearLeastSquares(matrix);
                lls.SolveSystem(out output, input);

                CheckEqual(expected, output);
            }

            public void x33()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 1, 2, 3, },
                    { 3, 2, 1, },
                    { 1, 1, 1, },
                });

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

                var expected = new DenseVector(new Scalar[] {
                    1.0/5.4,
                    1.0/5.4,
                    1.0/5.4,
                });

                DenseVector output;

                LinearLeastSquares lls = new LinearLeastSquares(matrix);
                lls.SolveSystem(out output, input);

                CheckEqual(expected, output);
            }
        }

        public class FullRankFat : UnitTestSharp.TestFixture
        {
            public void x24()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 1, 2, 3, 4, },
                    { 4, 3, 2, 1, },
                });

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

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

                DenseVector output;

                LinearLeastSquares lls = new LinearLeastSquares(matrix);
                lls.SolveSystem(out output, input);

                CheckEqual(expected, output);
            }

            public void x36()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 1, 2, 3, 4, 5, 6, },
                    { 6, 5, 4, 3, 2, 1, },
                    { 1, 2, 2, 2, 2, 1, },
                });

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

                var expected = new DenseVector(new Scalar[] {
                    -6.0/28.0,
                     5.0/28.0,
                     5.0/28.0,
                     5.0/28.0,
                     5.0/28.0,
                    -6.0/28.0,
                });

                DenseVector output;

                LinearLeastSquares lls = new LinearLeastSquares(matrix);
                lls.SolveSystem(out output, input);

                CheckEqual(expected, output);
            }
        }

        public class FullRankTall : UnitTestSharp.TestFixture
        {
            public void x42()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 1, 4, },
                    { 2, 3, },
                    { 3, 2, },
                    { 4, 1, },
                });

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

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

                DenseVector output;

                LinearLeastSquares lls = new LinearLeastSquares(matrix);
                lls.SolveSystem(out output, input);

                CheckEqual(expected, output);
            }

            public void x63()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 1, 6, 1, },
                    { 2, 5, 2, },
                    { 3, 4, 2, },
                    { 4, 3, 2, },
                    { 5, 2, 2, },
                    { 6, 1, 1, },
                });

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

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

                DenseVector output;

                LinearLeastSquares lls = new LinearLeastSquares(matrix);
                lls.SolveSystem(out output, input);

                CheckEqual(expected, output);
            }
        }

        public class RankDeficientFat : UnitTestSharp.TestFixture
        {
            public void x24()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 1, 2, 3, 4, },
                    { 2, 4, 6, 8, },
                });

                var input = new DenseVector(new Scalar[] {
                    100,
                    100,
                });

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

                DenseVector output;

                LinearLeastSquares lls = new LinearLeastSquares(matrix);
                lls.SolveSystem(out output, input);

                CheckEqual(expected, output);
            }

            public void x36()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 1, 2, 3,  4,  5,  6, },
                    { 2, 4, 6,  8, 10, 12, },
                    { 3, 6, 9, 12, 15, 18, },
                });

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

                var expected = new DenseVector(new Scalar[] {
                    1 * 3.0/637.0,
                    2 * 3.0/637.0,
                    3 * 3.0/637.0,
                    4 * 3.0/637.0,
                    5 * 3.0/637.0,
                    6 * 3.0/637.0,
                });

                DenseVector output;

                LinearLeastSquares lls = new LinearLeastSquares(matrix);
                lls.SolveSystem(out output, input);

                CheckEqual(expected, output);
            }
        }

        public class RankDeficientTall : UnitTestSharp.TestFixture
        {
            public void x42()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 1, 2 },
                    { 2, 4 },
                    { 3, 6 },
                    { 4, 8 },
                });

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

                var expected = new DenseVector(new Scalar[] {
                    1.0/7.5,
                    1.0/3.75,
                });

                DenseVector output;

                LinearLeastSquares lls = new LinearLeastSquares(matrix);
                lls.SolveSystem(out output, input);
                
               CheckEqual(expected, output);
            }

            public void x63()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 1,  2,  3, },
                    { 2,  4,  6, },
                    { 3,  6,  9, },
                    { 4,  8, 12, },
                    { 5, 10, 15, },
                    { 6, 12, 18, },
                });

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

                var expected = new DenseVector(new Scalar[] {
                    1 * 3.0/182,
                    2 * 3.0/182,
                    3 * 3.0/182,
                });

                DenseVector output;

                LinearLeastSquares lls = new LinearLeastSquares(matrix);
                lls.SolveSystem(out output, input);

                CheckEqual(expected, output);
            }
        }
    }

    
    public class LinearLeastSquaresTests_SolveWithConstraints : UnitTestSharp.TestFixture
    {
        
        public class NoConstraintsActually : UnitTestSharp.TestFixture
        {
            public void x63()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 1,  2,  3, },
                    { 2,  4,  6, },
                    { 3,  6,  9, },
                    { 4,  8, 12, },
                    { 5, 10, 15, },
                    { 6, 12, 18, },
                });

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

                var expected = new DenseVector(new Scalar[] {
                    1 * 3.0/182,
                    2 * 3.0/182,
                    3 * 3.0/182,
                });

                DenseVector output;

                LinearLeastSquares lls = new LinearLeastSquares(matrix);
                Check(lls.SolveSystemWithConstraints(out output, input, 
                    new RectangularMatrix(0,matrix.ColumnCount), new DenseVector(0)));

                CheckEqual(expected, output);
            }

            public void x36()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 1, 2, 3,  4,  5,  6, },
                    { 2, 4, 6,  8, 10, 12, },
                    { 3, 6, 9, 12, 15, 18, },
                });

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

                var expected = new DenseVector(new Scalar[] {
                    1 * 3.0/637.0,
                    2 * 3.0/637.0,
                    3 * 3.0/637.0,
                    4 * 3.0/637.0,
                    5 * 3.0/637.0,
                    6 * 3.0/637.0,
                });

                DenseVector output;

                LinearLeastSquares lls = new LinearLeastSquares(matrix);
                Check(lls.SolveSystemWithConstraints(out output, input, new RectangularMatrix(0, matrix.ColumnCount), new DenseVector(0)));

                CheckEqual(expected, output);
            }
        }

        
        public class RedundantConstraints : UnitTestSharp.TestFixture
        {
            public void x11()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 1, },
                });

                var constraints = new RectangularMatrix(new Scalar[,] {
                    { -1, }, 
                    {  1, },
                });

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

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

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

                DenseVector output;

                LinearLeastSquares lls = new LinearLeastSquares(matrix);
                Check(lls.SolveSystemWithConstraints(out output, input, constraints, h));

                CheckEqual(expected, output);
            }

            public void x36()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 1, 2, 3,  4,  5,  6, },
                    { 2, 4, 6,  8, 10, 12, },
                    { 3, 6, 9, 12, 15, 18, },
                });

                var constraints = new RectangularMatrix(new Scalar[,] {
                    { -1,  0, 0, 0, 0, 0, }, 
                    {  0, -1, 0, 0, 0, 0, },
                });

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

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

                var expected = new DenseVector(new Scalar[] {
                    1 * 3.0/637.0,
                    2 * 3.0/637.0,
                    3 * 3.0/637.0,
                    4 * 3.0/637.0,
                    5 * 3.0/637.0,
                    6 * 3.0/637.0,
                });

                DenseVector output;

                LinearLeastSquares lls = new LinearLeastSquares(matrix);
                Check(lls.SolveSystemWithConstraints(out output, input, constraints, h));

                CheckEqual(expected, output);
            }
        }

        
        public class NonredundantConstraints : UnitTestSharp.TestFixture
        {
            public void x11()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 1, },
                });

                var constraints = new RectangularMatrix(new Scalar[,] {
                    { -1, }, 
                    {  1, },
                });

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

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

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

                DenseVector output;

                LinearLeastSquares lls = new LinearLeastSquares(matrix);
                Check(lls.SolveSystemWithConstraints(out output, input, constraints, h));

                CheckEqual(expected, output);
            }

            public void x22()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 1, 0, },
                    { 0, 1, },
                });

                var constraints = new RectangularMatrix(new Scalar[,] {
                    { -1,  0, }, 
                    {  1,  0, },
                    {  0, -1, }, 
                    {  0,  1, },
                });

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

                var input = new DenseVector(new Scalar[] {
                    3,
                    -3,
                });

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

                DenseVector output;

                LinearLeastSquares lls = new LinearLeastSquares(matrix);
                Check(lls.SolveSystemWithConstraints(out output, input, constraints, h));

                CheckEqual(expected, output);
            }

            public void x33()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 0, 0, 1, },
                    { 0, 1, 0, },
                    { 1, 0, 0, },
                });

                var constraints = new RectangularMatrix(new Scalar[,] {
                    { -1,  0, 0, }, 
                    {  1,  0, 0, },
                    {  0, -1, 0, }, 
                    {  0,  1, 0, },
                });

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

                var input = new DenseVector(new Scalar[] {
                    3,
                    -3,
                    3,
                });

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

                DenseVector output;

                LinearLeastSquares lls = new LinearLeastSquares(matrix);
                Check(lls.SolveSystemWithConstraints(out output, input, constraints, h));

                CheckEqual(expected, output);
            }
        }

        
        public class BadSizes : UnitTestSharp.TestFixture
        {
            public void BadSizeForG()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 0, 0, 1, },
                    { 0, 1, 0, },
                    { 1, 0, 0, },
                });

                var constraints = new RectangularMatrix(new Scalar[,] {
                    { -1,  }, 
                    {  1,  },
                });

                var h = new DenseVector(new Scalar[] {
                    -2,
                    -2,
                });

                var input = new DenseVector(new Scalar[] {
                    3,
                    -3,
                    3,
                });

                DenseVector output;

                LinearLeastSquares lls = new LinearLeastSquares(matrix);

                CheckThrow(typeof(Exception));
                lls.SolveSystemWithConstraints(out output, input, constraints, h);
            }

            public void BadSizeForH()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 0, 0, 1, },
                    { 0, 1, 0, },
                    { 1, 0, 0, },
                });

                var constraints = new RectangularMatrix(new Scalar[,] {
                    { -1, 0, 0, }, 
                    {  1, 0, 0, },
                });

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

                var input = new DenseVector(new Scalar[] {
                    3,
                    -3,
                    3,
                });

                DenseVector output;

                LinearLeastSquares lls = new LinearLeastSquares(matrix);

                CheckThrow(typeof(Exception));
                lls.SolveSystemWithConstraints(out output, input, constraints, h);
            }

            public void BadSizeForInput()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 0, 0, 1, },
                    { 0, 1, 0, },
                    { 1, 0, 0, },
                });

                var constraints = new RectangularMatrix(new Scalar[,] {
                    { -1, 0, 0, }, 
                    {  1, 0, 0, },
                });

                var h = new DenseVector(new Scalar[] {
                    -2,
                    -2,
                });

                var input = new DenseVector(new Scalar[] {
                    3,
                    -3,
                });

                DenseVector output;

                LinearLeastSquares lls = new LinearLeastSquares(matrix);

                CheckThrow(typeof(Exception));
                lls.SolveSystemWithConstraints(out output, input, constraints, h);
            }
        }

        
        public class InconsistentConstraints : UnitTestSharp.TestFixture
        {
            public void x11()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 1, },
                });

                var constraints = new RectangularMatrix(new Scalar[,] {
                    {  1,  }, 
                    { -1,  },
                });

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

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

                DenseVector expected = null;

                DenseVector output;

                LinearLeastSquares lls = new LinearLeastSquares(matrix);
                CheckFalse(lls.SolveSystemWithConstraints(out output, input, constraints, h));

                CheckEqual(expected, output);
            }

            public void x22()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 1, 0, },
                    { 0, 1, },
                });

                var constraints = new RectangularMatrix(new Scalar[,] {
                    {  1, 0, }, 
                    { -1, 0, },
                });

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

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

                DenseVector expected = null;

                DenseVector output;

                LinearLeastSquares lls = new LinearLeastSquares(matrix);
                CheckFalse(lls.SolveSystemWithConstraints(out output, input, constraints, h));

                CheckEqual(expected, output);
            }

            public void x33()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 1, 0, 0, },
                    { 0, 1, 0, },
                    { 0, 0, 1, },
                });

                var constraints = new RectangularMatrix(new Scalar[,] {
                    {  1, 0, 0, }, 
                    { -1, 0, 0, },
                });

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

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

                DenseVector expected = null;

                DenseVector output;

                LinearLeastSquares lls = new LinearLeastSquares(matrix);
                CheckFalse(lls.SolveSystemWithConstraints(out output, input, constraints, h));

                CheckEqual(expected, output);
            }
        }

        public class NonSimpleConstraints : UnitTestSharp.TestFixture
        {
            public void x22()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 1, 1, },
                    { -1, 1, },
                });

                var constraints = new RectangularMatrix(new Scalar[,] {
                    {  1, 1, }, 
                    {  -1, 1, },
                });

                var h = new DenseVector(new Scalar[] {
                    10,
                    10,
                });

                var input = new DenseVector(new Scalar[] {
                    -100,
                    -100,
                });

                DenseVector expected = new Scalar[] {
                    0,
                    10,
                };

                DenseVector output;

                LinearLeastSquares lls = new LinearLeastSquares(matrix);
                Check(lls.SolveSystemWithConstraints(out output, input, constraints, h));

                CheckEqual(expected, output);
            }
        }

        public class LazyColumnGrabber : UnitTestSharp.TestFixture
        {
            public void Identity()
            {
                var A = new SquareMatrix(new Scalar[,] 
                {
                    { 1, 0, 0, },
                    { 0, 1, 0, },
                    { 0, 0, 1, },
                });

                var G = new SquareMatrix(new Scalar[,]
                {
                    { 1, 0, 0, },
                    { 0, 1, 0, },
                    { 0, 0, 1, },
                });

                var qr_left = new QRDecomposition(A);
                var qr_right = new QRDecomposition(qr_left.R.Transpose());

                var grabber = LinearLeastSquares.LazyColumnGrabber(qr_right, qr_left, G);

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

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

                CheckEqual(expected, actual);
            }

            public void Basic_x33()
            {
                var A = new SquareMatrix(new Scalar[,] 
                {
                    { 1, 2, 3, },
                    { 3, 2, 1, },
                    { 1, 0, 0, },
                });

                var G = new SquareMatrix(new Scalar[,]
                {
                    { 0, 0, 1, },
                    { 1, 1, 0, },
                    { 1, 0, 1, },
                });

                var qr_left = new QRDecomposition(A);
                var qr_right = new QRDecomposition(qr_left.R.Transpose());

                var grabber = LinearLeastSquares.LazyColumnGrabber(qr_right, qr_left, G);

                var expected = new SquareMatrix(new Scalar[,]
                {
                    { 1.5, -1.5, 2.5, },
                    { -1.5, 1.625, -2.5, },
                    { 2.5, -2.5, 4.5 },
                });

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

                CheckEqual(expected, actual);
            }
        }
    }
}