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

namespace Azimuth.UnitTests.DenseLinearAlgebra
{
    public class DantzigsAlgorithmTests : UnitTestSharp.TestFixture
    {
        public class PivotTests : UnitTestSharp.TestFixture
        {
            public void Basic()
            {
                var M = new SquareMatrix(new Scalar[,] {
                    { 1, 0, },
                    { 0, 1, },
                });

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

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

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

                DantzigsAlgorithm.Pivot(ref M, ref q, 0, 0);

                CheckEqual(expectedM, M);
                CheckEqual(expectedQ, q);
            }

            public void x22_00()
            {
                var M = new SquareMatrix(new Scalar[,] {
                    { 1, 2, },
                    { 2, 1, },
                });

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

                var expectedM = new SquareMatrix(new Scalar[,] {
                    { 1, -2, },
                    { 2, -3, },
                });

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

                DantzigsAlgorithm.Pivot(ref M, ref q, 0, 0);

                CheckEqual(expectedM, M);
                CheckEqual(expectedQ, q);
            }
        }

        public class LCPTests : UnitTestSharp.TestFixture
        {
            public void Basic()
            {
                var M = new SquareMatrix(new Scalar[,] {
                    { 1, 0, },
                    { 0, 1, },
                });

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

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

                DenseVector z = null;
                bool success = DantzigsAlgorithm.SolveLCP(out z, M, q);

                CheckTrue(success);

                CheckEqual(expectedZ, z);
            }
            public void IdentityMatrix_x11_Neg()
            {
                var M = new SquareMatrix(new Scalar[,] {
                    {  1, },
                });

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

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

                DenseVector z;
                bool success = DantzigsAlgorithm.SolveLCP(out z, M, q);
                Check(success);

                CheckEqual(correctAnswer, z);
            }

            public void IdentityMatrix_x11_Pos()
            {
                var M = new SquareMatrix(new Scalar[,] {
                    {  1, },
                });

                var q = new DenseVector(new Scalar[] {
                    5,
                });

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

                DenseVector z;
                bool success = DantzigsAlgorithm.SolveLCP(out z, M, q);
                Check(success);

                CheckEqual(correctAnswer, z);
            }

            public void IdentityMatrix_x22_SimpleDegeneracy()
            {
                var M = new SquareMatrix(new Scalar[,] {
                    {  1, 0, },
                    {  0, 1, },
                });

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

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

                DenseVector z;
                bool success = DantzigsAlgorithm.SolveLCP(out z, M, q);
                Check(success);

                CheckEqual(correctAnswer, z);
            }

            public void IdentityMatrix_x22_Pos()
            {
                var M = new SquareMatrix(new Scalar[,] {
                    {  1, 0, },
                    {  0, 1, },
                });

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

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

                DenseVector z;
                bool success = DantzigsAlgorithm.SolveLCP(out z, M, q);
                Check(success);

                CheckEqual(correctAnswer, z);
            }

            public void IdentityMatrix_x22_Mixed()
            {
                var M = new SquareMatrix(new Scalar[,] {
                    {  1, 0, },
                    {  0, 1, },
                });

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

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

                DenseVector z;
                bool success = DantzigsAlgorithm.SolveLCP(out z, M, q);
                Check(success);

                CheckEqual(correctAnswer, z);
            }

            public void IdentityMatrix_x33()
            {
                var M = new SquareMatrix(new Scalar[,] {
                    {  1, 0, 0, },
                    {  0, 1, 0, }, 
                    {  0, 0, 1, },
                });

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

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

                DenseVector z;
                bool success = DantzigsAlgorithm.SolveLCP(out z, M, q);
                Check(success);

                CheckEqual(correctAnswer, z);
            }

            public void IdentityMatrix_x55()
            {
                var M = new SquareMatrix(new Scalar[,] {
                    {  1, 0, 0, 0, 0, },
                    {  0, 1, 0, 0, 0, },
                    {  0, 0, 1, 0, 0, },
                    {  0, 0, 0, 1, 0, },
                    {  0, 0, 0, 0, 1, },
                });

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

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

                DenseVector z;
                bool success = DantzigsAlgorithm.SolveLCP(out z, M, q);
                Check(success);

                CheckEqual(correctAnswer, z);
            }

            public void Identity_x11_NoSolution()
            {
                var M = new SquareMatrix(new Scalar[,] {
                    { -1, },
                });

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

                DenseVector correctAnswer = null;

                DenseVector z;
                bool success = DantzigsAlgorithm.SolveLCP(out z, M, q);
                CheckFalse(success);

                CheckEqual(correctAnswer, z);
            }

            public void Identity_x11_Solution()
            {
                var M = new SquareMatrix(new Scalar[,] {
                    { 1, },
                });

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

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

                DenseVector z;
                bool success = DantzigsAlgorithm.SolveLCP(out z, M, q);
                Check(success);

                CheckEqual(correctAnswer, z);
            }

            public void Identity_x22_Degenerate()
            {
                var M = new SquareMatrix(new Scalar[,] {
                    { 1, 0, },
                    { 0, 1, },
                });

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

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

                DenseVector z;
                bool success = DantzigsAlgorithm.SolveLCP(out z, M, q);
                Check(success);

                CheckEqual(correctAnswer, z);
            }
        }
    }
}