def test_commutator():
    A = Operator('A')
    B = Operator('B')
    c = Commutator(A, B)
    c_tall = Commutator(A**2, B)
    assert str(c) == '[A,B]'
    assert pretty(c) == '[A,B]'
    assert upretty(c) == u('[A,B]')
    assert latex(c) == r'\left[A,B\right]'
    sT(c, "Commutator(Operator(Symbol('A')),Operator(Symbol('B')))")
    assert str(c_tall) == '[A**2,B]'
    ascii_str = \
"""\
[ 2  ]\n\
[A ,B]\
"""
    ucode_str = \
u("""\
⎡ 2  ⎤\n\
⎣A ,B⎦\
""")
    assert pretty(c_tall) == ascii_str
    assert upretty(c_tall) == ucode_str
    assert latex(c_tall) == r'\left[\left(A\right)^{2},B\right]'
    sT(c_tall, "Commutator(Pow(Operator(Symbol('A')), Integer(2)),Operator(Symbol('B')))")

def test_commutator():
    A = Operator("A")
    B = Operator("B")
    c = Commutator(A, B)
    c_tall = Commutator(A ** 2, B)
    assert str(c) == "[A,B]"
    assert pretty(c) == "[A,B]"
    assert upretty(c) == u"[A,B]"
    assert latex(c) == r"\left[A,B\right]"
    sT(c, "Commutator(Operator(Symbol('A')),Operator(Symbol('B')))")
    assert str(c_tall) == "[A**2,B]"
    ascii_str = """\
[ 2  ]\n\
[A ,B]\
"""
    ucode_str = u(
        """\
⎡ 2  ⎤\n\
⎣A ,B⎦\
"""
    )
    assert pretty(c_tall) == ascii_str
    assert upretty(c_tall) == ucode_str
    assert latex(c_tall) == r"\left[A^{2},B\right]"
    sT(c_tall, "Commutator(Pow(Operator(Symbol('A')), Integer(2)),Operator(Symbol('B')))")

def test_anticommutator():
    A = Operator("A")
    B = Operator("B")
    ac = AntiCommutator(A, B)
    ac_tall = AntiCommutator(A ** 2, B)
    assert str(ac) == "{A,B}"
    assert pretty(ac) == "{A,B}"
    assert upretty(ac) == u"{A,B}"
    assert latex(ac) == r"\left\{A,B\right\}"
    sT(ac, "AntiCommutator(Operator(Symbol('A')),Operator(Symbol('B')))")
    assert str(ac_tall) == "{A**2,B}"
    ascii_str = """\
/ 2  \\\n\
<A ,B>\n\
\\    /\
"""
    ucode_str = u(
        """\
⎧ 2  ⎫\n\
⎨A ,B⎬\n\
⎩    ⎭\
"""
    )
    assert pretty(ac_tall) == ascii_str
    assert upretty(ac_tall) == ucode_str
    assert latex(ac_tall) == r"\left\{A^{2},B\right\}"
    sT(ac_tall, "AntiCommutator(Pow(Operator(Symbol('A')), Integer(2)),Operator(Symbol('B')))")

def test_latex():
    assert latex((2*tau)**Rational(7,2)) == "8 \\sqrt{2} \\tau^{\\frac{7}{2}}"
    assert latex((2*mu)**Rational(7,2), mode='equation*') == \
            "\\begin{equation*}8 \\sqrt{2} \\mu^{\\frac{7}{2}}\\end{equation*}"
    assert latex((2*mu)**Rational(7,2), mode='equation', itex=True) == \
            "$$8 \\sqrt{2} \\mu^{\\frac{7}{2}}$$"
    assert latex([2/x, y]) =="\\begin{bmatrix}\\frac{2}{x}, & y\\end{bmatrix}"

def test_latex():
    assert latex((2 * tau) ** Rational(7, 2)) == "$8 \\sqrt{2} \\sqrt[7]{\\tau}$"
    assert (
        latex((2 * mu) ** Rational(7, 2), inline=False)
        == "\\begin{equation*}8 \\sqrt{2} \\sqrt[7]{\\mu}\\end{equation*}"
    )
    assert latex([2 / x, y]) == "$\\begin{bmatrix}\\frac{2}{x}, & y\\end{bmatrix}$"

def test_latex_Matrix():
    M = Matrix([[1 + x, y], [y, x - 1]])
    assert latex(M) == "$\\left(\\begin{smallmatrix}1 + x & y\\\\y & -1 + " "x\\end{smallmatrix}\\right)$"
    profile = {"mat_str": "bmatrix"}
    assert latex(M, profile) == "$\\left(\\begin{bmatrix}1 + x & y\\\\y & -1 + " + "x\\end{bmatrix}\\right)$"
    profile["mat_delim"] = None
    assert latex(M, profile) == "$\\begin{bmatrix}1 + x & y\\\\y & -1 + " "x\\end{bmatrix}$"

def test_latex():
    assert latex((2*tau)**Rational(7,2)) == "$8 \\sqrt{2} \\tau^{\\frac{7}{2}}$"
    assert latex((2*mu)**Rational(7,2), inline=False) == \
            "\\begin{equation*}8 \\sqrt{2} \\mu^{\\frac{7}{2}}\\end{equation*}"
    assert latex((2*mu)**Rational(7,2), inline=False, itex=True) == \
            "$$8 \\sqrt{2} \\mu^{\\frac{7}{2}}$$"
    assert latex([2/x, y]) =="$\\begin{bmatrix}\\frac{2}{x}, & y\\end{bmatrix}$"

def clean_up_zeros(matrix_spec, label="", colors={}, 
                    environment="equation", cancel_zeros=True, diagonal_col_offset=None):

    matrix, indexed_sym = matrix_spec
    if diagonal_col_offset is None: diagonal_col_offset = 1

    tex_code = r"\begin{" + environment + r"}" + "\n" if environment else ""
    tex_code += r"\left[\begin{array}{" + ('c' * matrix.cols) + r'}' + "\n"

    for r in range(matrix.rows):
        for c in range(matrix.cols):
            
            space = "" if c == 0 else " "

            if r*diagonal_col_offset < c: coeff_str = ""
            elif cancel_zeros: coeff_str = latex(matrix[r,c]) if matrix[r,c] != 0 else ""
            else: coeff_str = latex(matrix[r,c])

            if (r,c) in colors: coeff_str = r'\textcolor{' + colors[(r,c)] + r'}{' + coeff_str + "}"
            tex_code += "{}{} {}".format(space, coeff_str, r'\\' if c == matrix.cols-1 else r'&') 

        tex_code += "" if r == matrix.rows - 1 else "\n"

    label = "\n{}".format(r'\label{eq:' + label + r'}' + "\n" if label else "")
    tex_code += "\n" + r'\end{array}\right]' 
    tex_code += label + r'\end{' + environment + '}' if environment else ""

    return tex_code

def test_anticommutator():
    A = Operator('A')
    B = Operator('B')
    ac = AntiCommutator(A, B)
    ac_tall = AntiCommutator(A**2, B)
    assert str(ac) == '{A,B}'
    assert pretty(ac) == '{A,B}'
    assert upretty(ac) == u('{A,B}')
    assert latex(ac) == r'\left\{A,B\right\}'
    sT(ac, "AntiCommutator(Operator(Symbol('A')),Operator(Symbol('B')))")
    assert str(ac_tall) == '{A**2,B}'
    ascii_str = \
"""\
/ 2  \\\n\
<A ,B>\n\
\\    /\
"""
    ucode_str = \
u("""\
⎧ 2  ⎫\n\
⎨A ,B⎬\n\
⎩    ⎭\
""")
    assert pretty(ac_tall) == ascii_str
    assert upretty(ac_tall) == ucode_str
    assert latex(ac_tall) == r'\left\{\left(A\right)^{2},B\right\}'
    sT(ac_tall, "AntiCommutator(Pow(Operator(Symbol('A')), Integer(2)),Operator(Symbol('B')))")

def test_latex_fresnel():
    from sympy.functions.special.error_functions import (fresnels, fresnelc)
    from sympy.abc import z
    assert latex(fresnels(z)) == r'S\left(z\right)'
    assert latex(fresnelc(z)) == r'C\left(z\right)'
    assert latex(fresnels(z)**2) == r'S^{2}\left(z\right)'
    assert latex(fresnelc(z)**2) == r'C^{2}\left(z\right)'

def test_latex_product():
    assert (
        latex(Product(x * y ** 2, (x, -2, 2), (y, -5, 5)))
        == r"\prod_{\substack{-2 \leq x \leq 2\\-5 \leq y \leq 5}} x y^{2}"
    )
    assert latex(Product(x ** 2, (x, -2, 2))) == r"\prod_{x=-2}^{2} x^{2}"
    assert latex(Product(x ** 2 + y, (x, -2, 2))) == r"\prod_{x=-2}^{2} \left(x^{2} + y\right)"

def test_latex_sum():
    assert latex(Sum(x*y**2, (x, -2, 2), (y, -5, 5))) == \
        r"\sum_{\substack{-2 \leq x \leq 2\\-5 \leq y \leq 5}} x y^{2}"
    assert latex(Sum(x**2, (x, -2, 2))) == \
        r"\sum_{x=-2}^{2} x^{2}"
    assert latex(Sum(x**2 + y, (x, -2, 2))) == \
        r"\sum_{x=-2}^{2} \left(x^{2} + y\right)"

def test_QuotientRing():
    from sympy.polys.domains import QQ

    R = QQ[x] / [x ** 2 + 1]

    assert latex(R) == r"\frac{\mathbb{Q}\left[x\right]}{\left< {x^{2} + 1} \right>}"
    assert latex(R.one) == r"{1} + {\left< {x^{2} + 1} \right>}"

def test_latex_intervals():
    a = Symbol('a', real=True)
    assert latex(Interval(0, a)) == r"\left[0, a\right]"
    assert latex(Interval(0, a, False, False)) == r"\left[0, a\right]"
    assert latex(Interval(0, a, True, False)) == r"\left(0, a\right]"
    assert latex(Interval(0, a, False, True)) == r"\left[0, a\right)"
    assert latex(Interval(0, a, True, True)) == r"\left(0, a\right)"

def test_Hadamard():
    from sympy.matrices import MatrixSymbol, HadamardProduct

    X = MatrixSymbol("X", 2, 2)
    Y = MatrixSymbol("Y", 2, 2)
    assert latex(HadamardProduct(X, Y * Y)) == r"X \circ \left(Y Y\right)"
    assert latex(HadamardProduct(X, Y) * Y) == r"\left(X \circ Y\right) Y"

def test_mode():
    expr = x + y
    assert latex(expr) == "x + y"
    assert latex(expr, mode="plain") == "x + y"
    assert latex(expr, mode="inline") == "$x + y$"
    assert latex(expr, mode="equation*") == "\\begin{equation*}x + y\\end{equation*}"
    assert latex(expr, mode="equation") == "\\begin{equation}x + y\\end{equation}"

def test_mode():
    expr = x+y
    assert latex(expr) == 'x + y'
    assert latex(expr, mode='plain') == 'x + y'
    assert latex(expr, mode='inline') == '$x + y$'
    assert latex(expr, mode='equation*')== '\\begin{equation*}x + y\\end{equation*}'
    assert latex(expr, mode='equation')== '\\begin{equation}x + y\\end{equation}'

    def _repr_html_(self, include_terms_cache=True, doit=True):
        '''
        Jupyter notebook integration for pretty printing

        Taken from: http://ipython.readthedocs.io/en/stable/config/integrating.html
        '''

        def subscripts_of(key):
            with bind_Mul_indexed(key, self.indexed) as (_, subscripts):
                return tuple(subscripts)


        substitutions = dict(zip(self.index, itertools.repeat(0)))
        keys_with_integral_subscripts = {k.subs(substitutions):k for k in self.terms_cache}
        integral_subscrips = {subscripts_of(k):k for k in keys_with_integral_subscripts}
        sorted_subscripts = sorted(integral_subscrips.keys())
        ordered_terms_cache = [Eq(symbolic_key, self.terms_cache[symbolic_key]) 
                                for k in sorted_subscripts
                                for symbolic_key in [keys_with_integral_subscripts[integral_subscrips[k]]]]


        src = r'$\left(\Theta, \Gamma\right)_{{{index}}}^{{{sym}}}$ where: <br><ul>{Theta}{Gamma}</ul>'.format(
            sym=latex(self.indexed),
            index=','.join(map(latex, self.index)),
            #index=latex(self.index),
            Theta=r'<li>$\Theta = \left\{{ {rec_eqs} \right\}}$</li>'.format(
                rec_eqs=latex(self.recurrence_eq.doit() if doit else self.recurrence_eq)),
            Gamma=r'<li>$\Gamma = \left\{{\begin{{array}}{{c}}{terms_cache}\end{{array}}\right\}}$</li>'.format(
                terms_cache=r'\\'.join(map(latex, ordered_terms_cache))))

        return src

def test_PrettyPoly():
    from sympy.polys.domains import QQ
    F = QQ.frac_field(x, y)
    R = QQ[x, y]

    assert latex(F.convert(x/(x + y))) == latex(x/(x + y))
    assert latex(R.convert(x + y)) == latex(x + y)

def test_latex_Poly():
    assert latex(Poly(x**2 + 2 * x, x)) == \
        r"\operatorname{Poly}{\left( x^{2} + 2 x, x, domain=\mathbb{Z} \right)}"
    assert latex(Poly(x/y, x)) == \
        r"\operatorname{Poly}{\left( \frac{x}{y}, x, domain=\mathbb{Z}\left(y\right) \right)}"
    assert latex(Poly(2.0*x + y)) == \
        r"\operatorname{Poly}{\left( 2.0 x + 1.0 y, x, y, domain=\mathbb{R} \right)}"