Python split_symbols_custom示例

示例#1

文件： test_implicit_multiplication_application.py 项目： vchekan/sympy

def test_symbol_splitting():
    # By default Greek letter names should not be split (lambda is a keyword
    # so skip it)
    transformations = standard_transformations + (split_symbols,)
    greek_letters = ('alpha', 'beta', 'gamma', 'delta', 'epsilon', 'zeta',
                     'eta', 'theta', 'iota', 'kappa', 'mu', 'nu', 'xi',
                     'omicron', 'pi', 'rho', 'sigma', 'tau', 'upsilon',
                     'phi', 'chi', 'psi', 'omega')

    for letter in greek_letters:
        assert(parse_expr(letter, transformations=transformations) ==
               parse_expr(letter))

    # Make sure custom splitting works
    def can_split(symbol):
        if symbol not in ('unsplittable', 'names'):
            return _token_splittable(symbol)
        return False
    transformations = standard_transformations
    transformations += (split_symbols_custom(can_split),
                        implicit_multiplication)

    assert(parse_expr('unsplittable', transformations=transformations) ==
           parse_expr('unsplittable'))
    assert(parse_expr('names', transformations=transformations) ==
           parse_expr('names'))
    assert(parse_expr('xy', transformations=transformations) ==
           parse_expr('x*y'))
    for letter in greek_letters:
        assert(parse_expr(letter, transformations=transformations) ==
               parse_expr(letter))

示例#2

文件： parser.py 项目： HuitingLiu/11747

def get_transformations(splittable_symbols):
    def splittable(symbol):
        return set(symbol).issubset(splittable_symbols)

    return (combinatorial_notation,
            unicode_operator) + standard_transformations + (
                convert_xor, split_symbols_custom(splittable),
                implicit_multiplication, implicit_application,
                function_exponentiation)

示例#3

文件： test_implicit_multiplication_application.py 项目： plaes/sympy

def test_symbol_splitting():
    # By default Greek letter names should not be split (lambda is a keyword
    # so skip it)
    transformations = standard_transformations + (split_symbols,)
    greek_letters = (
        "alpha",
        "beta",
        "gamma",
        "delta",
        "epsilon",
        "zeta",
        "eta",
        "theta",
        "iota",
        "kappa",
        "mu",
        "nu",
        "xi",
        "omicron",
        "pi",
        "rho",
        "sigma",
        "tau",
        "upsilon",
        "phi",
        "chi",
        "psi",
        "omega",
    )

    for letter in greek_letters:
        assert parse_expr(letter, transformations=transformations) == parse_expr(letter)

    # Make sure custom splitting works
    def can_split(symbol):
        if symbol not in ("unsplittable", "names"):
            return _token_splittable(symbol)
        return False

    transformations = standard_transformations
    transformations += (split_symbols_custom(can_split), implicit_multiplication)

    assert parse_expr("unsplittable", transformations=transformations) == parse_expr("unsplittable")
    assert parse_expr("names", transformations=transformations) == parse_expr("names")
    assert parse_expr("xy", transformations=transformations) == parse_expr("x*y")
    for letter in greek_letters:
        assert parse_expr(letter, transformations=transformations) == parse_expr(letter)

示例#4

def test_symbol_splitting():
    # By default Greek letter names should not be split (lambda is a keyword
    # so skip it)
    transformations = standard_transformations + (split_symbols, )
    greek_letters = ('alpha', 'beta', 'gamma', 'delta', 'epsilon', 'zeta',
                     'eta', 'theta', 'iota', 'kappa', 'mu', 'nu', 'xi',
                     'omicron', 'pi', 'rho', 'sigma', 'tau', 'upsilon', 'phi',
                     'chi', 'psi', 'omega')

    for letter in greek_letters:
        assert (parse_expr(
            letter, transformations=transformations) == parse_expr(letter))

    # Make sure symbol splitting resolves names
    transformations += (implicit_multiplication, )
    local_dict = {'e': sympy.E}
    cases = {
        'xe': 'E*x',
        'Iy': 'I*y',
        'ee': 'E*E',
    }
    for case, expected in cases.items():
        assert (parse_expr(
            case, local_dict=local_dict,
            transformations=transformations) == parse_expr(expected))

    # Make sure custom splitting works
    def can_split(symbol):
        if symbol not in ('unsplittable', 'names'):
            return _token_splittable(symbol)
        return False

    transformations = standard_transformations
    transformations += (split_symbols_custom(can_split),
                        implicit_multiplication)

    assert (parse_expr(
        'unsplittable',
        transformations=transformations) == parse_expr('unsplittable'))
    assert (parse_expr('names',
                       transformations=transformations) == parse_expr('names'))
    assert (parse_expr('xy',
                       transformations=transformations) == parse_expr('x*y'))
    for letter in greek_letters:
        assert (parse_expr(
            letter, transformations=transformations) == parse_expr(letter))

示例#5

文件： test_implicit_multiplication_application.py 项目： A-turing-machine/sympy

def test_symbol_splitting():
    # By default Greek letter names should not be split (lambda is a keyword
    # so skip it)
    transformations = standard_transformations + (split_symbols,)
    greek_letters = ('alpha', 'beta', 'gamma', 'delta', 'epsilon', 'zeta',
                     'eta', 'theta', 'iota', 'kappa', 'mu', 'nu', 'xi',
                     'omicron', 'pi', 'rho', 'sigma', 'tau', 'upsilon',
                     'phi', 'chi', 'psi', 'omega')

    for letter in greek_letters:
        assert(parse_expr(letter, transformations=transformations) ==
               parse_expr(letter))

    # Make sure symbol splitting resolves names
    transformations += (implicit_multiplication,)
    local_dict = { 'e': sympy.E }
    cases = {
        'xe': 'E*x',
        'Iy': 'I*y',
        'ee': 'E*E',
    }
    for case, expected in cases.items():
        assert(parse_expr(case, local_dict=local_dict,
                          transformations=transformations) ==
               parse_expr(expected))

    # Make sure custom splitting works
    def can_split(symbol):
        if symbol not in ('unsplittable', 'names'):
            return _token_splittable(symbol)
        return False
    transformations = standard_transformations
    transformations += (split_symbols_custom(can_split),
                        implicit_multiplication)

    assert(parse_expr('unsplittable', transformations=transformations) ==
           parse_expr('unsplittable'))
    assert(parse_expr('names', transformations=transformations) ==
           parse_expr('names'))
    assert(parse_expr('xy', transformations=transformations) ==
           parse_expr('x*y'))
    for letter in greek_letters:
        assert(parse_expr(letter, transformations=transformations) ==
               parse_expr(letter))

示例#6

文件： funStrUtils.py 项目： krasux/Powell_Powell_Optimization_Program

    parse_expr,
    standard_transformations,
    convert_xor,
    implicit_multiplication,
    implicit_application,
    function_exponentiation,
    split_symbols_custom,
    _token_splittable
)


def can_split(symbol):
    if symbol not in ('x1', 'x2', 'x3', 'x4', 'x5'):
        return _token_splittable(symbol)
    return False
split_xn = split_symbols_custom(can_split)
trans = standard_transformations + (split_xn, implicit_multiplication,
                                    implicit_application, function_exponentiation, convert_xor)

var('x:6')


def str2fun(str):
    function = lambdify((x1,x2,x3,x4,x5), parse_expr(str, transformations=trans))
    def funcVec(x):
        x1 = 0
        x2 = 0
        x3 = 0
        x4 = 0
        x5 = 0
        if isinstance(x, Number):

示例#7

from sympy import var
from sympy.parsing.sympy_parser import (parse_expr, standard_transformations,
                                        convert_xor, implicit_multiplication,
                                        implicit_application,
                                        function_exponentiation,
                                        split_symbols_custom,
                                        _token_splittable)


def can_split(symbol):
    if symbol not in ('x1', 'x2', 'x3', 'x4', 'x5'):
        return _token_splittable(symbol)
    return False


split_xn = split_symbols_custom(can_split)
trans = standard_transformations + (split_xn, implicit_multiplication,
                                    implicit_application,
                                    function_exponentiation, convert_xor)

var('x:6')


def str2fun(str):
    function = lambdify((x1, x2, x3, x4, x5),
                        parse_expr(str, transformations=trans))

    def funcVec(x):
        x1 = 0
        x2 = 0
        x3 = 0

示例#8

文件： test_implicit_multiplication_application.py 项目： msgoff/sympy

def test_symbol_splitting():
    # By default Greek letter names should not be split (lambda is a keyword
    # so skip it)
    transformations = standard_transformations + (split_symbols,)
    greek_letters = (
        "alpha",
        "beta",
        "gamma",
        "delta",
        "epsilon",
        "zeta",
        "eta",
        "theta",
        "iota",
        "kappa",
        "mu",
        "nu",
        "xi",
        "omicron",
        "pi",
        "rho",
        "sigma",
        "tau",
        "upsilon",
        "phi",
        "chi",
        "psi",
        "omega",
    )

    for letter in greek_letters:
        assert parse_expr(letter, transformations=transformations) == parse_expr(letter)

    # Make sure symbol splitting resolves names
    transformations += (implicit_multiplication,)
    local_dict = {"e": sympy.E}
    cases = {
        "xe": "E*x",
        "Iy": "I*y",
        "ee": "E*E",
    }
    for case, expected in cases.items():
        assert parse_expr(
            case, local_dict=local_dict, transformations=transformations
        ) == parse_expr(expected)

    # Make sure custom splitting works
    def can_split(symbol):
        if symbol not in ("unsplittable", "names"):
            return _token_splittable(symbol)
        return False

    transformations = standard_transformations
    transformations += (split_symbols_custom(can_split), implicit_multiplication)

    assert parse_expr("unsplittable", transformations=transformations) == parse_expr(
        "unsplittable"
    )
    assert parse_expr("names", transformations=transformations) == parse_expr("names")
    assert parse_expr("xy", transformations=transformations) == parse_expr("x*y")
    for letter in greek_letters:
        assert parse_expr(letter, transformations=transformations) == parse_expr(letter)