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

namespace Azimuth.UnitTests.SparseLinearAlgebra
{
    public class SparseRectangularMatrixTests : UnitTestSharp.TestFixture
    {
        public class Ctors : UnitTestSharp.TestFixture
        {
            public void Basic()
            {
                var matrix = new SparseRectangularMatrix ( new Scalar[,] {
                    { 1, 2, },
                    { 3, 4, },
                });

                CheckEqual(1, matrix[0, 0]);
                CheckEqual(2, matrix[0, 1]);
                CheckEqual(3, matrix[1, 0]);
                CheckEqual(4, matrix[1, 1]);

                CheckEqual(2, matrix.ColumnCount);
                CheckEqual(2, matrix.RowCount);
            }

            public void Fat()
            {
                var matrix = new SparseRectangularMatrix ( new Scalar[,] {
                    { 1, 2, 7, },
                    { 3, 4, 8, },
                });

                CheckEqual(1, matrix[0, 0]);
                CheckEqual(2, matrix[0, 1]);
                CheckEqual(3, matrix[1, 0]);
                CheckEqual(4, matrix[1, 1]);

                CheckEqual(7, matrix[0, 2]);
                CheckEqual(8, matrix[1, 2]);

                CheckEqual(3, matrix.ColumnCount);
                CheckEqual(2, matrix.RowCount);
            }

            public void Long()
            {
                var matrix = new SparseRectangularMatrix ( new Scalar[,] {
                    { 1, 2, },
                    { 3, 4, },
                    { 7, 8, },
                });

                CheckEqual(1, matrix[0, 0]);
                CheckEqual(2, matrix[0, 1]);
                CheckEqual(3, matrix[1, 0]);
                CheckEqual(4, matrix[1, 1]);

                CheckEqual(7, matrix[2, 0]);
                CheckEqual(8, matrix[2, 1]);

                CheckEqual(2, matrix.ColumnCount);
                CheckEqual(3, matrix.RowCount);
            }

            public void JustSize()
            {
                var mat = new SparseRectangularMatrix(2, 3);

                CheckEqual(2, mat.RowCount);
                CheckEqual(3, mat.ColumnCount);
            }

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

                    CheckEqual(1, matrix[0, 0]);
                    CheckEqual(2, matrix[0, 1]);
                    CheckEqual(3, matrix[1, 0]);
                    CheckEqual(4, matrix[1, 1]);

                    CheckEqual(2, matrix.ColumnCount);
                    CheckEqual(2, matrix.RowCount);
                }

                public void Fat()
                {
                    var matrix = new SparseRectangularMatrix(new RectangularMatrix(new Scalar[,] {
                        { 1, 2, 7, },
                        { 3, 4, 8, },
                    }));

                    CheckEqual(1, matrix[0, 0]);
                    CheckEqual(2, matrix[0, 1]);
                    CheckEqual(3, matrix[1, 0]);
                    CheckEqual(4, matrix[1, 1]);

                    CheckEqual(7, matrix[0, 2]);
                    CheckEqual(8, matrix[1, 2]);

                    CheckEqual(3, matrix.ColumnCount);
                    CheckEqual(2, matrix.RowCount);
                }

                public void Long()
                {
                    var matrix = new SparseRectangularMatrix(new RectangularMatrix(new Scalar[,] {
                        { 1, 2, },
                        { 3, 4, },
                        { 7, 8, },
                    }));

                    CheckEqual(1, matrix[0, 0]);
                    CheckEqual(2, matrix[0, 1]);
                    CheckEqual(3, matrix[1, 0]);
                    CheckEqual(4, matrix[1, 1]);

                    CheckEqual(7, matrix[2, 0]);
                    CheckEqual(8, matrix[2, 1]);

                    CheckEqual(2, matrix.ColumnCount);
                    CheckEqual(3, matrix.RowCount);
                }
            }
        }

        public class Indexer : UnitTestSharp.TestFixture
        {
            public void Basic()
            {
                var mat = new SparseRectangularMatrix(2, 2);

                mat[0, 1] = 5;

                CheckEqual(5, mat[0, 1]);
            }

            public void Set_Negative()
            {
                var mat = new SparseRectangularMatrix(2, 2);

                CheckThrow(typeof(Exception));
                mat[0, -1] = 5;
            }

            public void Get_Negative()
            {
                var mat = new SparseRectangularMatrix(2, 2);

                CheckThrow(typeof(Exception));
                Scalar x = mat[0, -1];
            }

            public void Set_TooBig()
            {
                var mat = new SparseRectangularMatrix(2, 2);

                CheckThrow(typeof(Exception));
                Scalar x = mat[0, 2];
            }

            public void Get_TooBig()
            {
                var mat = new SparseRectangularMatrix(2, 2);

                CheckThrow(typeof(Exception));
                Scalar x = mat[0, 2];
            }
        }

        public class Transpose : UnitTestSharp.TestFixture
        {
            public void Basic()
            {
                var mat = new SparseRectangularMatrix(new Scalar[,] {
                    { 1, 2, },
                    { 3, 4, },
                });

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

                CheckEqual(expected, mat.Transpose());
            }

            public void Empty()
            {
                var mat = new SparseRectangularMatrix(new Scalar[,] {
                    { },
                });

                CheckEqual(mat, mat.Transpose());
            }

            public void Single()
            {
                var mat = new SparseRectangularMatrix(new Scalar[,] {
                    { 7, },
                });

                CheckEqual(mat, mat.Transpose());
            }

            public void Fat()
            {
                var mat = new SparseRectangularMatrix(new Scalar[,] {
                    { 1, 2, 5, },
                    { 3, 4, 6, },
                });

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

                CheckEqual(expected, mat.Transpose());
            }

            public void Tall()
            {
                var mat = new SparseRectangularMatrix(new Scalar[,] {
                    { 1, 3, },
                    { 2, 4, },
                    { 5, 6, },
                });

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

                CheckEqual(expected, mat.Transpose());
            }
        }

        public class Equality_Sparse : UnitTestSharp.TestFixture
        {
            public void Equal_Square()
            {
                var matrix1 = new SparseRectangularMatrix(new Scalar[,] {
                    { 1, 2, 3 },
                    { 6, 5, 4 },
                    { 0, 0, 8 }
                });

                var matrix2 = new SparseRectangularMatrix(new Scalar[,] {
                    { 1, 2, 3 },
                    { 6, 5, 4 },
                    { 0, 0, 8 }
                });

                CheckEqual(matrix1, matrix2);
                CheckEqual(matrix2, matrix1);
            }

            public void Equal_Tall()
            {
                var matrix1 = new SparseRectangularMatrix(new Scalar[,] {
                    { 1, 2, },
                    { 6, 0, },
                    { 7, 0, }
                });

                var matrix2 = new SparseRectangularMatrix(new Scalar[,] {
                    { 1, 2, },
                    { 6, 0, },
                    { 7, 0, }
                });

                CheckEqual(matrix1, matrix2);
                CheckEqual(matrix2, matrix1);
            }

            public void Equal_Fat()
            {
                var matrix1 = new SparseRectangularMatrix(new Scalar[,] {
                    { 1, 0, 3 },
                    { 6, 5, 4 },
                });

                var matrix2 = new SparseRectangularMatrix(new Scalar[,] {
                    { 1, 0, 3 },
                    { 6, 5, 4 },
                });

                CheckEqual(matrix1, matrix2);
                CheckEqual(matrix2, matrix1);
            }

            public void NotEqual_SameSize_Square()
            {
                var matrix1 = new SparseRectangularMatrix(new Scalar[,] {
                    { 1, 2, 3 },
                    { 0, 0, 4 },
                    { 7, 0, 8 }
                });

                var matrix2 = new SparseRectangularMatrix(new Scalar[,] {
                    { 1, 2, 3 },
                    { 0, 0, 4 },
                    { 7, 0, 10 }
                });

                CheckNotEqual(matrix1, matrix2);
                CheckNotEqual(matrix2, matrix1);
            }

            public void NotEqual_SameSize_Tall()
            {
                var matrix1 = new SparseRectangularMatrix(new Scalar[,] {
                    { 1, 2, },
                    { 0, 5, },
                    { 7, 9, }
                });

                var matrix2 = new SparseRectangularMatrix(new Scalar[,] {
                    { 1, 2, },
                    { 0, 10, },
                    { 7, 9, }
                });

                CheckNotEqual(matrix1, matrix2);
                CheckNotEqual(matrix2, matrix1);
            }

            public void NotEqual_SameSize_Fat()
            {
                var matrix1 = new SparseRectangularMatrix(new Scalar[,] {
                    { 1, 0, 3, },
                    { 0, 5, 10, },
                });

                var matrix2 = new SparseRectangularMatrix(new Scalar[,] {
                    { 1, 0, 3, },
                    { 0, 5, 4, },
                });

                CheckNotEqual(matrix1, matrix2);
                CheckNotEqual(matrix2, matrix1);
            }

            public void NotEqual_DifferentSize()
            {
                var matrix1 = new SparseRectangularMatrix(new Scalar[,] {
                    { 1, 0, 3 },
                    { 6, 5, 4 },
                });

                var matrix2 = new SparseRectangularMatrix(new Scalar[,] {
                    { 1, 0, },
                    { 6, 5, },
                    { 7, 9, }
                });

                CheckNotEqual(matrix1, matrix2);
                CheckNotEqual(matrix2, matrix1);
            }

            public void Equal_ISparseRectangularMatrix()
            {
                var matrix1 = new SparseRectangularMatrix(new Scalar[,] {
                    { 1, 2, },
                    { 0, 5, },
                });

                var matrix2 = new SparseRectangularMatrix(new Scalar[,] {
                    { 1, 2, },
                    { 0, 5, },
                });

                CheckEqual(matrix1, matrix2);
                CheckEqual(matrix2, matrix1);
            }
        }

        public class Equality_IRectangular: UnitTestSharp.TestFixture
        {
            public void Equal_Square()
            {
                var matrix1 = new SparseRectangularMatrix(new Scalar[,] {
                    { 1, 2, 3 },
                    { 6, 5, 4 },
                    { 0, 0, 8 }
                });

                var matrix2 = new SparseRectangularMatrix(new Scalar[,] {
                    { 1, 2, 3 },
                    { 6, 5, 4 },
                    { 0, 0, 8 }
                });

                CheckEqual(matrix1, (IRectangularMatrix)matrix2);
                CheckEqual(matrix2, (IRectangularMatrix)matrix1);
            }

            public void Equal_Tall()
            {
                var matrix1 = new SparseRectangularMatrix(new Scalar[,] {
                    { 1, 2, },
                    { 6, 0, },
                    { 7, 0, }
                });

                var matrix2 = new SparseRectangularMatrix(new Scalar[,] {
                    { 1, 2, },
                    { 6, 0, },
                    { 7, 0, }
                });

                CheckEqual(matrix1, (IRectangularMatrix)matrix2);
                CheckEqual(matrix2, (IRectangularMatrix)matrix1);
            }

            public void Equal_Fat()
            {
                var matrix1 = new SparseRectangularMatrix(new Scalar[,] {
                    { 1, 0, 3 },
                    { 6, 5, 4 },
                });

                var matrix2 = new SparseRectangularMatrix(new Scalar[,] {
                    { 1, 0, 3 },
                    { 6, 5, 4 },
                });

                CheckEqual(matrix1, (IRectangularMatrix)matrix2);
                CheckEqual(matrix2, (IRectangularMatrix)matrix1);
            }

            public void NotEqual_SameSize_Square()
            {
                var matrix1 = new SparseRectangularMatrix(new Scalar[,] {
                    { 1, 2, 3 },
                    { 0, 0, 4 },
                    { 7, 0, 8 }
                });

                var matrix2 = new SparseRectangularMatrix(new Scalar[,] {
                    { 1, 2, 3 },
                    { 0, 0, 4 },
                    { 7, 0, 10 }
                });

                CheckNotEqual(matrix1, (IRectangularMatrix)matrix2);
                CheckNotEqual(matrix2, (IRectangularMatrix)matrix1);
            }

            public void NotEqual_SameSize_Tall()
            {
                var matrix1 = new SparseRectangularMatrix(new Scalar[,] {
                    { 1, 2, },
                    { 0, 5, },
                    { 7, 9, }
                });

                var matrix2 = new SparseRectangularMatrix(new Scalar[,] {
                    { 1, 2, },
                    { 0, 10, },
                    { 7, 9, }
                });

                CheckNotEqual(matrix1, (IRectangularMatrix)matrix2);
                CheckNotEqual(matrix2, (IRectangularMatrix)matrix1);
            }

            public void NotEqual_SameSize_Fat()
            {
                var matrix1 = new SparseRectangularMatrix(new Scalar[,] {
                    { 1, 0, 3, },
                    { 0, 5, 10, },
                });

                var matrix2 = new SparseRectangularMatrix(new Scalar[,] {
                    { 1, 0, 3, },
                    { 0, 5, 4, },
                });

                CheckNotEqual(matrix1, (IRectangularMatrix)matrix2);
                CheckNotEqual(matrix2, (IRectangularMatrix)matrix1);
            }

            public void NotEqual_DifferentSize()
            {
                var matrix1 = new SparseRectangularMatrix(new Scalar[,] {
                    { 1, 0, 3 },
                    { 6, 5, 4 },
                });

                var matrix2 = new SparseRectangularMatrix(new Scalar[,] {
                    { 1, 0, },
                    { 6, 5, },
                    { 7, 9, }
                });

                CheckNotEqual(matrix1, (IRectangularMatrix)matrix2);
                CheckNotEqual(matrix2, (IRectangularMatrix)matrix1);
            }

            public void Equal_ISparseRectangularMatrix()
            {
                var matrix1 = new SparseRectangularMatrix(new Scalar[,] {
                    { 1, 2, },
                    { 0, 5, },
                });

                var matrix2 = new SparseRectangularMatrix(new Scalar[,] {
                    { 1, 2, },
                    { 0, 5, },
                });

                CheckEqual(matrix1, (IRectangularMatrix)matrix2);
                CheckEqual(matrix2, (IRectangularMatrix)matrix1);
            }
        }

        public class SparseMatrixMultiply_IntoDense : UnitTestSharp.TestFixture
        {
            public void x11()
            {
                var a = new SparseRectangularMatrix(new Scalar[,] { { 2 } });
                var b = new SparseRectangularMatrix( new Scalar[,] { { 3 } });

                var c = new SparseRectangularMatrix(new Scalar[,] { { 6 } });

                CheckEqual(c, a.MatrixMultiplyIntoDense(b));
                CheckEqual(c, b.MatrixMultiplyIntoDense(a));
            }

            public void x22()
            {
                var a = new SparseRectangularMatrix( new Scalar[,] { { 2, 3 }, { 4, -2 } });
                var b = new SparseRectangularMatrix( new Scalar[,] { { 7, 3 }, { 1, 2 } });

                var c = new SparseRectangularMatrix( new Scalar[,] { { 17, 12 }, { 26, 8 } });
                var d = new SparseRectangularMatrix(new Scalar[,] { { 26, 15 }, { 10, -1 } });

                CheckEqual(c, a.MatrixMultiplyIntoDense(b));
                CheckEqual(d, b.MatrixMultiplyIntoDense(a));
            }

            public void WrongSize()
            {
                var a = new SparseRectangularMatrix( new Scalar[,] { { 2, 3 }, { 4, -2 } });
                var b = new SparseRectangularMatrix(new Scalar[,] { { 1, 2 } });

                CheckThrow(typeof(Exception));

                a.MatrixMultiplyIntoDense(b);
            }

            public void DifferentSizes()
            {
                var a = new SparseRectangularMatrix( new Scalar[,] { { 2, 3 }, { 4, -2 } });
                var b = new SparseRectangularMatrix( new Scalar[,] { { 1, 2 } });

                var c = new SparseRectangularMatrix(new Scalar[,] { { 10, -1 } });

                CheckEqual(c, b.MatrixMultiplyIntoDense(a));
            }
        }

        public class SparseMatrixMultiply_IntoSparse : UnitTestSharp.TestFixture
        {
            public void x11()
            {
                var a = new SparseRectangularMatrix(new Scalar[,] { { 2 } });
                var b = new SparseRectangularMatrix(new Scalar[,] { { 3 } });

                var c = new SparseRectangularMatrix(new Scalar[,] { { 6 } });

                CheckEqual(c, a.MatrixMultiplyIntoSparse(b));
                CheckEqual(c, b.MatrixMultiplyIntoSparse(a));
            }

            public void x22()
            {
                var a = new SparseRectangularMatrix(new Scalar[,] { { 2, 3 }, { 4, -2 } });
                var b = new SparseRectangularMatrix(new Scalar[,] { { 7, 3 }, { 1, 2 } });

                var c = new SparseRectangularMatrix(new Scalar[,] { { 17, 12 }, { 26, 8 } });
                var d = new SparseRectangularMatrix(new Scalar[,] { { 26, 15 }, { 10, -1 } });

                CheckEqual(c, a.MatrixMultiplyIntoSparse(b));
                CheckEqual(d, b.MatrixMultiplyIntoSparse(a));
            }

            public void WrongSize()
            {
                var a = new SparseRectangularMatrix(new Scalar[,] { { 2, 3 }, { 4, -2 } });
                var b = new SparseRectangularMatrix(new Scalar[,] { { 1, 2 } });

                CheckThrow(typeof(Exception));

                a.MatrixMultiplyIntoSparse(b);
            }

            public void DifferentSizes()
            {
                var a = new SparseRectangularMatrix(new Scalar[,] { { 2, 3 }, { 4, -2 } });
                var b = new SparseRectangularMatrix(new Scalar[,] { { 1, 2 } });

                var c = new SparseRectangularMatrix(new Scalar[,] { { 10, -1 } });

                CheckEqual(c, b.MatrixMultiplyIntoSparse(a));
            }
        }

        public class DenseMatrixMultiply : UnitTestSharp.TestFixture
        {
            public void x11()
            {
                var a = new RectangularMatrix(new Scalar[,] { { 2 } });
                var b = new SparseRectangularMatrix(new Scalar[,] { { 3 } });

                var c = new RectangularMatrix(new Scalar[,] { { 6 } });

                CheckEqual(c, a.MatrixMultiply(b));
                CheckEqual(c, b.MatrixMultiplyIntoDense(a));
            }

            public void x22()
            {
                var a = new RectangularMatrix(new Scalar[,] { { 2, 3 }, { 4, -2 } });
                var b = new SparseRectangularMatrix(new Scalar[,] { { 7, 3 }, { 1, 2 } });

                var c = new RectangularMatrix(new Scalar[,] { { 17, 12 }, { 26, 8 } });
                var d = new RectangularMatrix(new Scalar[,] { { 26, 15 }, { 10, -1 } });

                CheckEqual(c, a.MatrixMultiply(b));
                CheckEqual(d, b.MatrixMultiplyIntoDense(a));
            }

            public void WrongSize()
            {
                var a = new SparseRectangularMatrix(new Scalar[,] { { 2, 3 }, { 4, -2 } });
                var b = new RectangularMatrix(new Scalar[,] { { 1, 2 } });

                CheckThrow(typeof(Exception));

                a.MatrixMultiplyIntoDense(b);
            }

            public void DifferentSizes()
            {
                var a = new RectangularMatrix(new Scalar[,] { { 2, 3 }, { 4, -2 } });
                var b = new SparseRectangularMatrix(new Scalar[,] { { 1, 2 } });

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

                CheckEqual(c, b.MatrixMultiplyIntoDense(a));
            }
        }
    }
}