Ticket #5711: trac_5711-enhanced-symbolic-typesetting-rebased_to_4.0.2.patch

File trac_5711-enhanced-symbolic-typesetting-rebased_to_4.0.2.patch, 10.0 KB (added by gmhossain, 11 years ago)
  • sage/calculus/calculus.py

    # HG changeset patch
    # User Golam Mortuza Hossain <gmhossain@gmail.com>
    # Date 1245756426 10800
    # Node ID 75e9c68c3e93ab7b6593c00519cbabd3f281e6be
    # Parent  2e793d2a0e123293b73eed40715e43185fd9ccfe
    Enhances typsetting of Symbolic functions within Sage (rebased to Sage-4.0.2)
    
    diff -r 2e793d2a0e12 -r 75e9c68c3e93 sage/calculus/calculus.py
    a b  
    13801380        if not isinstance(f, PrimitiveFunction):
    13811381            del functions[name]
    13821382       
    1383 _limit = SFunction('limit')
    1384 
    13851383def dummy_limit(*args):
    13861384    """
    13871385    This function is called to create formal wrappers of limits that
     
    14201418        args[i] = Integer(args[i])
    14211419    return f.diff(*args)
    14221420 
     1421def dummy_integrate(*args):
     1422    """
     1423    This function is called to create formal wrappers of integrals that
     1424    Maxima can't compute:
     1425   
     1426    EXAMPLES::
     1427   
     1428        sage: from sage.calculus.calculus import dummy_integrate
     1429        sage: f(x) = function('f',x)
     1430        sage: dummy_integrate(f(x), x)
     1431        integrate(f(x), x)
     1432        sage: a,b = var('a,b')
     1433        sage: dummy_integrate(f(x), x, a, b)
     1434        integrate(f(x), x, a, b)
     1435
     1436    """
     1437    if len(args) == 4:
     1438        return _integrate(args[0], var(repr(args[1])), SR(args[2]), SR(args[3]))
     1439    else:
     1440        return _integrate(args[0], var(repr(args[1])))
     1441
     1442def dummy_laplace(*args):
     1443    """
     1444    This function is called to create formal wrappers of laplace transforms
     1445    that Maxima can't compute:
     1446   
     1447    EXAMPLES::
     1448   
     1449        sage: from sage.calculus.calculus import dummy_laplace
     1450        sage: s,t = var('s,t')
     1451        sage: f(t) = function('f',t)
     1452        sage: dummy_laplace(f(t),t,s)
     1453        laplace(f(t), t, s)
     1454    """
     1455    return _laplace(args[0], var(repr(args[1])), var(repr(args[2])))
     1456
     1457def dummy_inverse_laplace(*args):
     1458    """
     1459    This function is called to create formal wrappers of inverse laplace
     1460    transforms that Maxima can't compute:
     1461   
     1462    EXAMPLES::
     1463   
     1464        sage: from sage.calculus.calculus import dummy_inverse_laplace
     1465        sage: s,t = var('s,t')
     1466        sage: F(s) = function('F',s)
     1467        sage: dummy_inverse_laplace(F(s),s,t)
     1468        ilt(F(s), s, t)
     1469    """
     1470    return _inverse_laplace(args[0], var(repr(args[1])), var(repr(args[2])))
     1471
     1472#######################################################
     1473#
     1474# Helper functions for printing latex expression
     1475#
     1476#######################################################
     1477
     1478def _limit_latex_(*args):
     1479    r"""
     1480    Return latex expression for limit of a symbolic function.
     1481   
     1482    EXAMPLES::
     1483   
     1484        sage: from sage.calculus.calculus import _limit_latex_
     1485        sage: var('x,a')
     1486        (x, a)
     1487        sage: f(x) = function('f',x)
     1488        sage: _limit_latex_(f(x), x, a)
     1489        '\\lim_{x \\to a}\\, f\\left(x\\right)'
     1490   
     1491    AUTHORS:
     1492
     1493    - Golam Mortuza Hossain (2009-06-15)
     1494    """
     1495    # Read f,x,a from arguments
     1496    f = args[0]
     1497    x = args[1]
     1498    a = args[2]
     1499    return "\\lim_{%s \\to %s}\\, %s"%(latex(x), latex(a), latex(f))
     1500
     1501def _integrate_latex_(*args):
     1502    r"""
     1503    Return LaTeX expression for integration of a symbolic function.
     1504   
     1505    EXAMPLES::
     1506   
     1507        sage: from sage.calculus.calculus import _integrate_latex_
     1508        sage: var('x,a,b')
     1509        (x, a, b)
     1510        sage: f(x) = function('f',x)
     1511        sage: _integrate_latex_(f(x),x)
     1512        '\\int f\\left(x\\right)\\,{d x}'
     1513        sage: _integrate_latex_(f(x),x,a,b)
     1514        '\\int_{a}^{b} f\\left(x\\right)\\,{d x}'
     1515   
     1516    AUTHORS:
     1517
     1518    - Golam Mortuza Hossain (2009-06-22)
     1519    """
     1520    f = args[0]
     1521    x = args[1]
     1522    # Check whether its a definite integral
     1523    if len(args) == 4:
     1524        a = args[2]
     1525        b = args[3]
     1526        return "\\int_{%s}^{%s} %s\\,{d %s}"%(latex(a), latex(b), latex(f), latex(x))
     1527    # Typeset as indefinite integral
     1528    return "\\int %s\\,{d %s}"%(latex(f), latex(x))
     1529
     1530def _laplace_latex_(*args):
     1531    r"""
     1532    Return LaTeX expression for Laplace transform of a symbolic function.
     1533   
     1534    EXAMPLES::
     1535   
     1536        sage: from sage.calculus.calculus import _laplace_latex_
     1537        sage: var('s,t')
     1538        (s, t)
     1539        sage: f(t) = function('f',t)
     1540        sage: _laplace_latex_(f(t),t,s)
     1541        '\\mathcal{L}\\left(f\\left(t\\right), t, s\\right)'
     1542   
     1543    AUTHORS:
     1544
     1545    - Golam Mortuza Hossain (2009-06-22)
     1546    """
     1547    return "\\mathcal{L}\\left(%s\\right)"%(', '.join([latex(x) for x in args]))
     1548
     1549def _inverse_laplace_latex_(*args):
     1550    r"""
     1551    Return LaTeX expression for inverse Laplace transform of a symbolic function.
     1552   
     1553    EXAMPLES::
     1554   
     1555        sage: from sage.calculus.calculus import _inverse_laplace_latex_
     1556        sage: var('s,t')
     1557        (s, t)
     1558        sage: F(s) = function('F',s)
     1559        sage: _inverse_laplace_latex_(F(s),s,t)
     1560        '\\mathcal{L}^{-1}\\left(F\\left(s\\right), s, t\\right)'
     1561   
     1562    AUTHORS:
     1563
     1564    - Golam Mortuza Hossain (2009-06-22)
     1565    """
     1566    return "\\mathcal{L}^{-1}\\left(%s\\right)"%(', '.join([latex(x) for x in args]))
     1567
     1568# Return un-evaluated expression as instances of SFunction class
     1569_limit = SFunction('limit', print_latex_func=_limit_latex_)
     1570_integrate = SFunction('integrate', print_latex_func=_integrate_latex_)
     1571_laplace = SFunction('laplace', print_latex_func=_laplace_latex_)
     1572_inverse_laplace = SFunction('ilt', print_latex_func=_inverse_laplace_latex_)
     1573
    14231574######################################i################
    14241575
    14251576
     
    15141665    # have to do this here, otherwise maxima_tick catches it
    15151666    syms['limit'] = dummy_limit
    15161667    syms['diff'] = dummy_diff
     1668    syms['integrate'] = dummy_integrate
     1669    syms['laplace'] = dummy_laplace
     1670    syms['ilt'] = dummy_inverse_laplace
    15171671
    15181672    global is_simplified
    15191673    try:
  • sage/misc/latex.py

    diff -r 2e793d2a0e12 -r 75e9c68c3e93 sage/misc/latex.py
    a b  
    18121812                   'omega',
    18131813                   'Omega']
    18141814
    1815 def latex_varify(a):
     1815def latex_varify(a, is_fname=False):
    18161816    r"""
    18171817    Convert a string ``a`` to a LaTeX string: if it's an element of
    18181818    ``common_varnames``, then prepend a backslash.  If ``a`` consists
    18191819    of a single letter, then return it.  Otherwise, return
    1820     "\\mbox{a}".
     1820    either "{\\rm a}" or "\\mbox{a}" if "is_fname" flag is True or False.
    18211821
    18221822    INPUT:
    18231823
     
    18321832        'w'
    18331833        sage: latex_varify('aleph')
    18341834        '\\mbox{aleph}'
     1835        sage: latex_varify('aleph', is_fname=True)
     1836        '{\\rm aleph}'
    18351837        sage: latex_varify('alpha')
    18361838        '\\alpha'
    18371839    """
     
    18391841        return "\\" + a
    18401842    elif len(a) == 1:
    18411843        return a
     1844    elif is_fname is True:
     1845        return '{\\rm %s}'%a
    18421846    else:
    18431847        return '\\mbox{%s}'%a
    18441848
    1845 def latex_variable_name(x):
     1849def latex_variable_name(x, is_fname=False):
    18461850    r"""
    18471851    Return latex version of a variable name.
    18481852   
     
    18851889        '\\sigma_{\\alpha}'
    18861890        sage: latex_variable_name('nothing1')
    18871891        '\\mbox{nothing}_{1}'
     1892        sage: latex_variable_name('nothing1', is_fname=True)
     1893        '{\\rm nothing}_{1}'
    18881894        sage: latex_variable_name('nothing_abc')
    18891895        '\\mbox{nothing}_{\\mbox{abc}}'
     1896        sage: latex_variable_name('nothing_abc', is_fname=True)
     1897        '{\\rm nothing}_{{\\rm abc}}'
    18901898        sage: latex_variable_name('alpha_beta_gamma12')
    18911899        '\\alpha_{\\beta_{\\gamma_{12}}}'
    18921900   
     
    19141922        # handle the suffix specially because it very well might be numeric
    19151923        # I use strip to avoid using regex's -- It makes it a bit faster (and the code is more comprehensible to non-regex'ed people)
    19161924        if suffix.strip("1234567890")!="":
    1917             suffix = latex_variable_name(suffix) # recurse to deal with recursive subscripts
    1918         return '%s_{%s}'%(latex_varify(prefix), suffix)
     1925            suffix = latex_variable_name(suffix, is_fname) # recurse to deal with recursive subscripts
     1926        return '%s_{%s}'%(latex_varify(prefix, is_fname), suffix)
    19191927    else:
    1920         return latex_varify(prefix)
     1928        return latex_varify(prefix, is_fname)
    19211929
    19221930class LatexExamples():
    19231931    r"""
  • sage/symbolic/function.pyx

    diff -r 2e793d2a0e12 -r 75e9c68c3e93 sage/symbolic/function.pyx
    a b  
    119119            my args are: x, y^z
    120120
    121121            sage: latex(foo(x,y^z))
    122             \mbox{t}\left(x, y^{z}\right)
     122            t\left(x, y^{z}\right)
    123123            sage: foo = nfunction('t', 2, print_latex_func=my_print)
    124124            sage: foo(x,y^z)
    125125            t(x, y^z)
  • sage/symbolic/pynac.pyx

    diff -r 2e793d2a0e12 -r 75e9c68c3e93 sage/symbolic/pynac.pyx
    a b  
    361361        sage: get_sfunction_from_serial(i) == foo
    362362        True
    363363        sage: py_latex_function_pystring(i, (x,y^z))
    364         '\\mbox{foo}\\left(x, y^{z}\\right)'
     364        '{\\rm foo}\\left(x, y^{z}\\right)'
    365365        sage: py_latex_function_pystring(i, (x,y^z), True)
    366          '\\left(\\mbox{foo}\\right)\\left(x, y^{z}\\right)'
     366         '\\left({\\rm foo}\\right)\\left(x, y^{z}\\right)'
    367367
    368368    Test latex_name::
    369369
     
    412412    if func._latex_name:
    413413        name = func._latex_name
    414414    else:
    415         # if latex_name is not defined, use default name
    416         name = ''.join([r'\mbox{', func._name, '}'])
     415        # if latex_name is not defined, then call
     416        # latex_variable_name with "is_fname=True" flag
     417        from sage.misc.latex import latex_variable_name
     418        name = latex_variable_name(func._name, is_fname=True)
    417419    if fname_paren:
    418420        olist = [r'\left(', name, r'\right)']
    419421    else:
     
    513515        sage: get_sfunction_from_serial(i) == foo
    514516        True
    515517        sage: py_latex_fderivative(i, (0, 1, 0, 1), (x, y^z))
    516         D[0, 1, 0, 1]\left(\mbox{foo}\right)\left(x, y^{z}\right)
     518        D[0, 1, 0, 1]\left({\rm foo}\right)\left(x, y^{z}\right)
    517519
    518520    Test latex_name::
    519521