passagemath-categories 10.6.32__cp314-cp314t-musllinux_1_2_aarch64.whl

sage/typeset/symbols.py

@@ -0,0 +1,334 @@
+# sage_setup: distribution = sagemath-categories
+"""
+Symbols for Character Art
+
+This module defines single- and multi-line symbols.
+
+EXAMPLES::
+
+    sage: from sage.typeset.symbols import *
+
+    sage: symbols = ascii_art('')
+    sage: for i in range(1, 5):
+    ....:     symbols += ascii_left_parenthesis.character_art(i)
+    ....:     symbols += ascii_art(' ')
+    ....:     symbols += ascii_right_parenthesis.character_art(i)
+    ....:     symbols += ascii_art(' ')
+    sage: for i in range(1, 5):
+    ....:     symbols += ascii_left_square_bracket.character_art(i)
+    ....:     symbols += ascii_art(' ')
+    ....:     symbols += ascii_right_square_bracket.character_art(i)
+    ....:     symbols += ascii_art(' ')
+    sage: for i in range(1, 5):
+    ....:     symbols += ascii_left_curly_brace.character_art(i)
+    ....:     symbols += ascii_art(' ')
+    ....:     symbols += ascii_right_curly_brace.character_art(i)
+    ....:     symbols += ascii_art(' ')
+    sage: symbols
+                ( )             [ ]             { }
+            ( ) ( )         [ ] [ ]         { } { }
+        ( ) ( ) ( )     [ ] [ ] [ ]     { } { } { }
+    ( ) ( ) ( ) ( ) [ ] [ ] [ ] [ ] { } { } { } { }
+
+    sage: symbols = unicode_art('')
+    sage: for i in range(1, 5):
+    ....:     symbols += unicode_left_parenthesis.character_art(i)
+    ....:     symbols += unicode_art(' ')
+    ....:     symbols += unicode_right_parenthesis.character_art(i)
+    ....:     symbols += unicode_art(' ')
+    sage: for i in range(1, 5):
+    ....:     symbols += unicode_left_square_bracket.character_art(i)
+    ....:     symbols += unicode_art(' ')
+    ....:     symbols += unicode_right_square_bracket.character_art(i)
+    ....:     symbols += unicode_art(' ')
+    sage: for i in range(1, 5):
+    ....:     symbols += unicode_left_curly_brace.character_art(i)
+    ....:     symbols += unicode_art(' ')
+    ....:     symbols += unicode_right_curly_brace.character_art(i)
+    ....:     symbols += unicode_art(' ')
+    sage: symbols
+                ⎛ ⎞             ⎡ ⎤             ⎧ ⎫
+            ⎛ ⎞ ⎜ ⎟         ⎡ ⎤ ⎢ ⎥         ⎧ ⎫ ⎭ ⎩
+        ⎛ ⎞ ⎜ ⎟ ⎜ ⎟     ⎡ ⎤ ⎢ ⎥ ⎢ ⎥     ⎰ ⎱ ⎨ ⎬ ⎫ ⎧
+    ( ) ⎝ ⎠ ⎝ ⎠ ⎝ ⎠ [ ] ⎣ ⎦ ⎣ ⎦ ⎣ ⎦ { } ⎱ ⎰ ⎩ ⎭ ⎩ ⎭
+"""
+import unicodedata
+from sage.structure.sage_object import SageObject
+
+
+class CompoundSymbol(SageObject):
+
+    def __init__(self, character, top, extension, bottom,
+                 middle=None,
+                 middle_top=None, middle_bottom=None,
+                 top_2=None, bottom_2=None):
+        """
+        A multi-character (ascii/unicode art) symbol.
+
+        INPUT:
+
+        Instead of a string, each of these can be unicode in Python 2:
+
+        - ``character`` -- string; the single-line version of the symbol
+
+        - ``top`` -- string; the top line of a multi-line symbol
+
+        - ``extension`` -- string; the extension line of a multi-line symbol (will
+          be repeated)
+
+        - ``bottom`` -- string; the bottom line of a multi-line symbol
+
+        - ``middle`` -- (optional) string; the middle part, for example
+          in curly braces. Will be used only once for the symbol, and
+          only if its height is odd.
+
+        - ``middle_top`` -- (optional) string; the upper half of the
+          2-line middle part if the height of the symbol is even.
+          Will be used only once for the symbol.
+
+        - ``middle_bottom`` -- (optional) string; the lower half of the
+          2-line middle part if the height of the symbol is even.
+          Will be used only once for the symbol.
+
+        - ``top_2`` -- (optional) string; the upper half of a 2-line symbol
+
+        - ``bottom_2`` -- (optional) string; the lower half of a 2-line symbol
+
+        EXAMPLES::
+
+            sage: from sage.typeset.symbols import CompoundSymbol
+            sage: i = CompoundSymbol('I', '+', '|', '+', '|')
+            sage: i.print_to_stdout(1)
+            I
+            sage: i.print_to_stdout(3)
+            +
+            |
+            +
+        """
+        self.character = character
+        self.top = top
+        self.extension = extension
+        self.bottom = bottom
+        self.middle = middle or extension
+        self.middle_top = middle_top or extension
+        self.middle_bottom = middle_bottom or extension
+        self.top_2 = top_2 or top
+        self.bottom_2 = bottom_2 or bottom
+
+    def _repr_(self):
+        """
+        Return string representation.
+
+        EXAMPLES::
+
+            sage: from sage.typeset.symbols import unicode_left_parenthesis
+            sage: unicode_left_parenthesis
+            multi_line version of "("
+        """
+        return 'multi_line version of "{0}"'.format(self.character)
+
+    def __call__(self, num_lines):
+        r"""
+        Return the lines for a multi-line symbol.
+
+        INPUT:
+
+        - ``num_lines`` -- integer; the total number of lines
+
+        OUTPUT: list of strings / unicode strings
+
+        EXAMPLES::
+
+            sage: from sage.typeset.symbols import unicode_left_parenthesis
+            sage: unicode_left_parenthesis(4)
+            ['\u239b', '\u239c', '\u239c', '\u239d']
+        """
+        if num_lines <= 0:
+            raise ValueError('number of lines must be positive')
+        elif num_lines == 1:
+            return [self.character]
+        elif num_lines == 2:
+            return [self.top_2, self.bottom_2]
+        elif num_lines == 3:
+            return [self.top, self.middle, self.bottom]
+        elif num_lines % 2 == 0:
+            ext = [self.extension] * ((num_lines - 4) // 2)
+            return [self.top] + ext + [self.middle_top, self.middle_bottom] + ext + [self.bottom]
+        else:  # num_lines %2 == 1
+            ext = [self.extension] * ((num_lines - 3) // 2)
+            return [self.top] + ext + [self.middle] + ext + [self.bottom]
+
+    def print_to_stdout(self, num_lines):
+        """
+        Print the multi-line symbol.
+
+        This method is for testing purposes.
+
+        INPUT:
+
+        - ``num_lines`` -- integer; the total number of lines
+
+        EXAMPLES::
+
+            sage: from sage.typeset.symbols import *
+            sage: unicode_integral.print_to_stdout(1)
+            ∫
+            sage: unicode_integral.print_to_stdout(2)
+            ⌠
+            ⌡
+            sage: unicode_integral.print_to_stdout(3)
+            ⌠
+            ⎮
+            ⌡
+            sage: unicode_integral.print_to_stdout(4)
+            ⌠
+            ⎮
+            ⎮
+            ⌡
+        """
+        print('\n'.join(self(num_lines)))
+
+
+class CompoundAsciiSymbol(CompoundSymbol):
+
+    def character_art(self, num_lines):
+        """
+        Return the ASCII art of the symbol.
+
+        EXAMPLES::
+
+            sage: from sage.typeset.symbols import *
+            sage: ascii_left_curly_brace.character_art(3)
+            {
+            {
+            {
+        """
+        from sage.typeset.ascii_art import AsciiArt
+        return AsciiArt(self(num_lines))
+
+
+class CompoundUnicodeSymbol(CompoundSymbol):
+
+    def character_art(self, num_lines):
+        """
+        Return the unicode art of the symbol.
+
+        EXAMPLES::
+
+            sage: from sage.typeset.symbols import *
+            sage: unicode_left_curly_brace.character_art(3)
+            ⎧
+            ⎨
+            ⎩
+        """
+        from sage.typeset.unicode_art import UnicodeArt
+        return UnicodeArt(self(num_lines))
+
+
+ascii_integral = CompoundAsciiSymbol(
+    'int',
+    r' /\\',
+    r' | ',
+    r'\\/ ',
+)
+
+unicode_integral = CompoundUnicodeSymbol(
+    unicodedata.lookup('INTEGRAL'),
+    unicodedata.lookup('TOP HALF INTEGRAL'),
+    unicodedata.lookup('INTEGRAL EXTENSION'),
+    unicodedata.lookup('BOTTOM HALF INTEGRAL'),
+)
+
+ascii_left_parenthesis = CompoundAsciiSymbol(
+    '(',
+    '(',
+    '(',
+    '(',
+)
+
+ascii_right_parenthesis = CompoundAsciiSymbol(
+    ')',
+    ')',
+    ')',
+    ')',
+)
+
+unicode_left_parenthesis = CompoundUnicodeSymbol(
+    unicodedata.lookup('LEFT PARENTHESIS'),
+    unicodedata.lookup('LEFT PARENTHESIS UPPER HOOK'),
+    unicodedata.lookup('LEFT PARENTHESIS EXTENSION'),
+    unicodedata.lookup('LEFT PARENTHESIS LOWER HOOK'),
+)
+
+unicode_right_parenthesis = CompoundUnicodeSymbol(
+    unicodedata.lookup('RIGHT PARENTHESIS'),
+    unicodedata.lookup('RIGHT PARENTHESIS UPPER HOOK'),
+    unicodedata.lookup('RIGHT PARENTHESIS EXTENSION'),
+    unicodedata.lookup('RIGHT PARENTHESIS LOWER HOOK'),
+)
+
+ascii_left_square_bracket = CompoundAsciiSymbol(
+    '[',
+    '[',
+    '[',
+    '[',
+)
+
+ascii_right_square_bracket = CompoundAsciiSymbol(
+    ']',
+    ']',
+    ']',
+    ']',
+)
+
+unicode_left_square_bracket = CompoundUnicodeSymbol(
+    unicodedata.lookup('LEFT SQUARE BRACKET'),
+    unicodedata.lookup('LEFT SQUARE BRACKET UPPER CORNER'),
+    unicodedata.lookup('LEFT SQUARE BRACKET EXTENSION'),
+    unicodedata.lookup('LEFT SQUARE BRACKET LOWER CORNER'),
+)
+
+unicode_right_square_bracket = CompoundUnicodeSymbol(
+    unicodedata.lookup('RIGHT SQUARE BRACKET'),
+    unicodedata.lookup('RIGHT SQUARE BRACKET UPPER CORNER'),
+    unicodedata.lookup('RIGHT SQUARE BRACKET EXTENSION'),
+    unicodedata.lookup('RIGHT SQUARE BRACKET LOWER CORNER'),
+)
+
+ascii_left_curly_brace = CompoundAsciiSymbol(
+    '{',
+    '{',
+    '{',
+    '{',
+)
+
+ascii_right_curly_brace = CompoundAsciiSymbol(
+    '}',
+    '}',
+    '}',
+    '}',
+)
+
+unicode_left_curly_brace = CompoundUnicodeSymbol(
+    unicodedata.lookup('LEFT CURLY BRACKET'),
+    unicodedata.lookup('LEFT CURLY BRACKET UPPER HOOK'),
+    unicodedata.lookup('CURLY BRACKET EXTENSION'),
+    unicodedata.lookup('LEFT CURLY BRACKET LOWER HOOK'),
+    unicodedata.lookup('LEFT CURLY BRACKET MIDDLE PIECE'),
+    unicodedata.lookup('RIGHT CURLY BRACKET LOWER HOOK'),
+    unicodedata.lookup('RIGHT CURLY BRACKET UPPER HOOK'),
+    unicodedata.lookup('UPPER LEFT OR LOWER RIGHT CURLY BRACKET SECTION'),
+    unicodedata.lookup('UPPER RIGHT OR LOWER LEFT CURLY BRACKET SECTION'),
+)
+
+unicode_right_curly_brace = CompoundUnicodeSymbol(
+    unicodedata.lookup('RIGHT CURLY BRACKET'),
+    unicodedata.lookup('RIGHT CURLY BRACKET UPPER HOOK'),
+    unicodedata.lookup('CURLY BRACKET EXTENSION'),
+    unicodedata.lookup('RIGHT CURLY BRACKET LOWER HOOK'),
+    unicodedata.lookup('RIGHT CURLY BRACKET MIDDLE PIECE'),
+    unicodedata.lookup('LEFT CURLY BRACKET LOWER HOOK'),
+    unicodedata.lookup('LEFT CURLY BRACKET UPPER HOOK'),
+    unicodedata.lookup('UPPER RIGHT OR LOWER LEFT CURLY BRACKET SECTION'),
+    unicodedata.lookup('UPPER LEFT OR LOWER RIGHT CURLY BRACKET SECTION'),
+)

sage/typeset/unicode_art.py

@@ -0,0 +1,183 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Unicode Art
+
+This module implements ascii art using unicode characters. It is a
+strict superset of :mod:`~sage.typeset.ascii_art`.
+"""
+
+# ******************************************************************************
+#       Copyright (C) 2013 Jean-Baptiste Priez <jbp@kerios.fr>,
+#                     2015 Volker Braun <vbraun.name@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#    This code is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#    General Public License for more details.
+#
+#  The full text of the GPL is available at:
+#
+#                  https://www.gnu.org/licenses/
+# ******************************************************************************
+
+from sage.typeset.character_art import CharacterArt
+from sage.typeset.character_art_factory import CharacterArtFactory
+import sage.typeset.symbols as symbol
+
+
+class UnicodeArt(CharacterArt):
+    r"""
+    An Ascii art object is an object with some specific representation for
+    *printing*.
+
+    INPUT:
+
+    - ``lines`` -- the list of lines of the representation of the ascii art
+      object
+
+    - ``breakpoints`` -- the list of points where the representation can be
+      split
+
+    - ``baseline`` -- the reference line (from the bottom)
+
+    EXAMPLES::
+
+        sage: i = var('i')                                                              # needs sage.symbolic
+        sage: unicode_art(sum(pi^i/factorial(i)*x^i, i, 0, oo))                         # needs sage.symbolic
+         π⋅x
+        ℯ
+    """
+    _string_type = str
+
+
+_unicode_art_factory = CharacterArtFactory(
+    UnicodeArt, str, '_unicode_art_',
+    (symbol.unicode_left_parenthesis, symbol.unicode_right_parenthesis),
+    (symbol.unicode_left_square_bracket, symbol.unicode_right_square_bracket),
+    (symbol.unicode_left_curly_brace, symbol.unicode_right_curly_brace),
+)
+
+
+empty_unicode_art = _unicode_art_factory.build_empty()
+
+
+def unicode_art(*obj, **kwds):
+    r"""
+    Return an unicode art representation.
+
+    INPUT:
+
+    - ``*obj`` -- any number of positional arguments, of arbitrary
+      type. The objects whose ascii art representation we want.
+
+    - ``sep`` -- (optional) ``'sep=...'`` keyword argument (or ``'separator'``).
+      Anything that can be converted to unicode art (default: empty unicode
+      art). The separator in-between a list of objects. Only used if
+      more than one object given.
+
+    - ``baseline`` -- (default: 0) the baseline for the object
+
+    - ``sep_baseline`` -- (default: 0) the baseline for the separator
+
+    OUTPUT: :class:`UnicodeArt` instance
+
+    EXAMPLES::
+
+        sage: result = unicode_art(integral(exp(sqrt(x))/(x+pi), x))                    # needs sage.symbolic
+        ...
+        sage: result                                                                    # needs sage.symbolic
+            ⌠
+            ⎮   √x
+            ⎮  ℯ
+            ⎮ ───── dx
+            ⎮ x + π
+            ⌡
+        sage: ident = lambda n: identity_matrix(ZZ, n)
+        sage: unicode_art(ident(1), ident(2), ident(3), sep=' : ')                      # needs sage.modules
+                      ⎛1 0 0⎞
+              ⎛1 0⎞   ⎜0 1 0⎟
+        (1) : ⎝0 1⎠ : ⎝0 0 1⎠
+
+    If specified, the ``sep_baseline`` overrides the baseline of
+    an unicode art separator::
+
+        sage: sep_line = unicode_art('\n'.join(' ⎟ ' for _ in range(5)), baseline=5)
+        sage: unicode_art(*AlternatingSignMatrices(3),                                  # needs sage.combinat sage.modules
+        ....:             separator=sep_line, sep_baseline=1)
+                ⎟         ⎟         ⎟            ⎟         ⎟         ⎟
+        ⎛1 0 0⎞ ⎟ ⎛0 1 0⎞ ⎟ ⎛1 0 0⎞ ⎟ ⎛ 0  1  0⎞ ⎟ ⎛0 0 1⎞ ⎟ ⎛0 1 0⎞ ⎟ ⎛0 0 1⎞
+        ⎜0 1 0⎟ ⎟ ⎜1 0 0⎟ ⎟ ⎜0 0 1⎟ ⎟ ⎜ 1 -1  1⎟ ⎟ ⎜1 0 0⎟ ⎟ ⎜0 0 1⎟ ⎟ ⎜0 1 0⎟
+        ⎝0 0 1⎠ ⎟ ⎝0 0 1⎠ ⎟ ⎝0 1 0⎠ ⎟ ⎝ 0  1  0⎠ ⎟ ⎝0 1 0⎠ ⎟ ⎝1 0 0⎠ ⎟ ⎝1 0 0⎠
+                ⎟         ⎟         ⎟            ⎟         ⎟         ⎟
+
+    TESTS::
+
+        sage: n = var('n')                                                              # needs sage.symbolic
+        sage: unicode_art(sum(binomial(2 * n, n + 1) * x^n, n, 0, oo))                  # needs sage.symbolic
+         ⎛        _________    ⎞
+        -⎝2⋅x + ╲╱ 1 - 4⋅x  - 1⎠
+        ─────────────────────────
+                   _________
+             2⋅x⋅╲╱ 1 - 4⋅x
+        sage: unicode_art(list(DyckWords(3)))                                           # needs sage.combinat
+        ⎡                                   ╱╲   ⎤
+        ⎢            ╱╲    ╱╲      ╱╲╱╲    ╱  ╲  ⎥
+        ⎣ ╱╲╱╲╱╲, ╱╲╱  ╲, ╱  ╲╱╲, ╱    ╲, ╱    ╲ ⎦
+        sage: unicode_art(1)
+        1
+    """
+    separator, baseline, sep_baseline = _unicode_art_factory.parse_keywords(kwds)
+    if kwds:
+        raise ValueError('unknown keyword arguments: {0}'.format(list(kwds)))
+    if len(obj) == 1:
+        return _unicode_art_factory.build(obj[0], baseline=baseline)
+    if not isinstance(separator, UnicodeArt):
+        separator = _unicode_art_factory.build(separator, baseline=sep_baseline)
+    elif sep_baseline is not None:
+        from copy import copy
+        separator = copy(separator)
+        separator._baseline = sep_baseline
+    return _unicode_art_factory.concatenate(obj, separator, empty_unicode_art,
+                                            baseline=baseline)
+
+
+_subscript_dict = {'0': '₀', '1': '₁', '2': '₂', '3': '₃', '4': '₄',
+                   '5': '₅', '6': '₆', '7': '₇', '8': '₈', '9': '₉',
+                   '-': '₋', '+': '₊'}
+
+
+_superscript_dict = {'0': '⁰', '1': '¹', '2': '²', '3': '³', '4': '⁴',
+                     '5': '⁵', '6': '⁶', '7': '⁷', '8': '⁸', '9': '⁹',
+                     '-': '⁻', '+': '⁺', '/': 'ᐟ'}
+
+
+def unicode_superscript(x):
+    r"""
+    Return the rational number ``x`` as a superscript.
+
+    EXAMPLES::
+
+        sage: from sage.typeset.unicode_art import unicode_superscript
+        sage: unicode_superscript(15123902)
+        '¹⁵¹²³⁹⁰²'
+        sage: unicode_superscript(-712/5)
+        '⁻⁷¹²ᐟ⁵'
+    """
+    return ''.join(_superscript_dict[i] for i in str(x))
+
+
+def unicode_subscript(x):
+    r"""
+    Return the integer ``x`` as a superscript.
+
+    EXAMPLES::
+
+        sage: from sage.typeset.unicode_art import unicode_subscript
+        sage: unicode_subscript(15123902)
+        '₁₅₁₂₃₉₀₂'
+        sage: unicode_subscript(-712)
+        '₋₇₁₂'
+    """
+    return ''.join(_subscript_dict[i] for i in str(x))

sage/typeset/unicode_characters.py

@@ -0,0 +1,101 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Unicode Characters
+
+This module provides Python identifiers for Unicode characters corresponding
+to various mathematical symbols.
+
+The syntax is ``unicode_XXX``, where ``XXX`` is the LaTeX name of the symbol,
+stripped of any backslash or any curly brace (e.g. ``unicode_mathbbR`` for
+``ℝ``).
+
+EXAMPLES:
+
+Operators::
+
+    sage: from sage.typeset.unicode_characters import unicode_otimes
+    sage: unicode_otimes
+    '⊗'
+    sage: hex(ord(_))
+    '0x2297'
+    sage: from sage.typeset.unicode_characters import unicode_bigotimes
+    sage: unicode_bigotimes
+    '⨂'
+    sage: hex(ord(_))
+    '0x2a02'
+    sage: from sage.typeset.unicode_characters import unicode_wedge
+    sage: unicode_wedge
+    '∧'
+    sage: hex(ord(_))
+    '0x2227'
+    sage: from sage.typeset.unicode_characters import unicode_bigwedge
+    sage: unicode_bigwedge
+    '⋀'
+    sage: hex(ord(_))
+    '0x22c0'
+    sage: from sage.typeset.unicode_characters import unicode_partial
+    sage: unicode_partial
+    '∂'
+    sage: hex(ord(_))
+    '0x2202'
+
+Arrows::
+
+    sage: from sage.typeset.unicode_characters import unicode_to
+    sage: unicode_to
+    '→'
+    sage: hex(ord(_))
+    '0x2192'
+    sage: from sage.typeset.unicode_characters import unicode_mapsto
+    sage: unicode_mapsto
+    '↦'
+    sage: hex(ord(_))
+    '0x21a6'
+
+Letters::
+
+    sage: from sage.typeset.unicode_characters import unicode_mathbbR
+    sage: unicode_mathbbR
+    'ℝ'
+    sage: hex(ord(_))
+    '0x211d'
+    sage: from sage.typeset.unicode_characters import unicode_mathbbC
+    sage: unicode_mathbbC
+    'ℂ'
+    sage: hex(ord(_))
+    '0x2102'
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2021 Eric Gourgoulhon <eric.gourgoulhon@obspm.fr>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+# Operators:
+
+unicode_otimes = '\u2297'          # '⊗'
+
+unicode_bigotimes = '\u2A02'       # '⨂'
+
+unicode_wedge = '\u2227'           # '∧'
+
+unicode_bigwedge = '\u22C0'        # '⋀'
+
+unicode_partial = '\u2202'         # '∂'
+
+# Arrows:
+
+unicode_to = '\u2192'              # '→'
+
+unicode_mapsto = '\u21A6'          # '↦'
+
+# Letters:
+
+unicode_mathbbR = '\u211D'         # 'ℝ'
+
+unicode_mathbbC = '\u2102'         # 'ℂ'