コード例 #1
0
def _simplify(_expr_str):     
    print("đề =",_expr_str)
    
    if _expr_str.__len__() > 0:
        try:
            _expr = parse_expr(_expr_str)          
        except SyntaxError:
            return {'success': False, 'msg': "Cú pháp không hợp lệ"}        
        print("đề đã chuyển đổi = ",_expr)
        min_ex, rules, expr_list = logic_simplify.logic_simplify(_expr)
        print("min_ex :", min_ex)
        print("rules :", rules)
        print("list :", expr_list)
        steps = []
        for ex, r in zip(expr_list, rules):
            step_detail = {
                "expr": pretty(ex),
                "rule": r
            }
            steps.append(step_detail)
        print("step :",steps)
        answer = {
            "expr": pretty(_expr),
            "steps": steps,
            "min": pretty(min_ex)
        }
        return {'success': True, "type": "2", 'answer': answer}
    return {'success': False, 'msg': "Cú pháp không hợp lệ"}
コード例 #2
0
ファイル: test_pretty.py プロジェクト: certik/sympy-oldcore
def test_pretty_unicode_defaults():
    use_unicode = pprint_use_unicode(True)
    assert pretty(Symbol('alpha')) == u'\u03b1'
    pprint_use_unicode(False)
    assert pretty(Symbol('alpha')) == 'alpha'

    pprint_use_unicode(use_unicode)
コード例 #3
0
def _resolve_logic(question):
    def parse(text: str):
        tok = re.compile("{(.*)}( )*,( )*(.*)")
        results1 = tok.findall(text)
        if results1.__len__() > 0:
            _premises, _, _, con = results1[0]
            results2 = _premises.split(",")
            if results2.__len__() > 0:
                con = con.strip()
                pre = list(map(lambda x: x.strip(), results2))
                return pre, con

        return None

    if question.__len__() < 1:
        return {'success': False, 'msg': "Cú pháp không hợp lệ"}

    parse_result = parse(question)

    if parse_result is None:
        return {'success': False, 'msg': "Cú pháp không hợp lệ"}

    premises, conclusion = parse_result
    if premises.__len__() < 1:
        return {'success': False, 'msg': "Cần cung cấp giả thuyết!"}

    if conclusion.__len__() < 1:
        return {'success': False, 'msg': "Cần cung cấp kết luận!"}

    _premise_exprs = list()
    try:
        _premise_exprs = list(map(lambda x: parse_expr(x), premises))
    except SyntaxError:
        return {'success': False, 'msg': "Cú pháp của giả thuyết không hợp lệ"}

    try:
        _conclusion_expr = parse_expr(conclusion)
    except SyntaxError:
        return {'success': False, 'msg': "Cú pháp của kết luận không hợp lệ"}

    resolved, solution = LogicInference.resolve(
        _premise_exprs, _conclusion_expr)
    
    steps = []
    
    for rule_name, rules, fact in solution:        
        pretty_rules = list(map(lambda x: pretty(x), rules))
        step_detail = {
            "rules": pretty_rules,
            "rule": rule_name,
            "fact": pretty(fact)
        }
        steps.append(step_detail)
    answer = {
        "steps": steps,
        "result": resolved
    }
    return {'success': True, "type": "4", 'answer': answer}
コード例 #4
0
ファイル: test_pretty.py プロジェクト: certik/sympy-oldcore
def test_pretty_derivatives():
    # Simple
    f_1 = Derivative(log(x), x, evaluate=False)
    assert pretty(f_1) == 'd         \n--(log(x))\ndx        '

    f_2 = Derivative(log(x), x, evaluate=False) + x
    assert pretty(f_2) == '    d         \nx + --(log(x))\n    dx        '

    # Multiple symbols
    f_3 = Derivative(log(x) + x**2, x, y, evaluate=False)
    assert pretty(f_3) == '   2              \n  d  / 2         \\\n-----\\x  + log(x)/\ndy dx             '

    f_4 = Derivative(2*x*y, y, x, evaluate=False) + x**2
    assert pretty(f_4) == '        2        \n 2     d         \nx  + -----(2*x*y)\n     dx dy       '
コード例 #5
0
ファイル: test_pretty.py プロジェクト: certik/sympy-oldcore
def test_pretty_functions():
    # Simple
    assert pretty( (2*x + exp(x)) ) in [' x      \ne  + 2*x', '       x\n2*x + e ']
    assert pretty( sqrt(2) ) == '  ___\n\\/ 2 '
    assert pretty( sqrt(2+pi) ) == '  ________\n\\/ 2 + pi '
    assert pretty(abs(x)) == '|x|'
    assert pretty(abs(x/(x**2+1))) == '|  x   |\n|------|\n|     2|\n|1 + x |'

    # Univariate/Multivariate functions
    f = Function('f')
    assert pretty(f(x)) == 'f(x)'
    assert pretty(f(x, y)) == 'f(x, y)'
    assert pretty(f(x/(y+1), y)) == '    x      \nf(-----, y)\n  1 + y    '

    # Nesting of square roots
    assert pretty( sqrt((sqrt(x+1))+1) ) == '   _______________\n  /       _______ \n\\/  1 + \\/ 1 + x  '
    # Function powers
    assert pretty( sin(x)**2 ) == '   2   \nsin (x)'

    # Conjugates
    a,b = map(Symbol, 'ab')
コード例 #6
0
def _bool(question):  
    
    if question.__len__() > 0:        
        try:          
            if parse(question) == 0:                           
                return {'success': False, 'msg': "Cú pháp không hợp lệ"}
            else:
                question, Karf, te_bao_lon, cac_phu_tu_karf,da_thuc_toi_tieu, de_quy = parse(question)      
        except SyntaxError:
            print("ra try")
            return {'success': False, 'msg': "Cú pháp không hợp lệ"}        
        answer = {
            "ques": pretty(question),
            "karf":Karf,
            "te_bao_lon": te_bao_lon,
            "cac_phu_tu_karf":cac_phu_tu_karf,
            "da_thuc_toi_tieu":da_thuc_toi_tieu,
            "de_quy":de_quy,
        }
        return {'success': True, "type": "1", "answer": answer}
    return {'success': False, 'msg': "Cú pháp không hợp lệ"}
コード例 #7
0
ファイル: test_pretty.py プロジェクト: certik/sympy-oldcore
def test_pretty_integrals():
    # Simple
    f_1 = Integral(log(x), x)
    assert pretty(f_1) == '  /         \n |          \n | log(x) dx\n |          \n/           '

    f_2 = Integral(x**2, x)
    assert pretty(f_2) == '  /     \n |      \n |  2   \n | x  dx\n |      \n/       '
    # Double nesting of pow
    f_3 = Integral(x**(2**x), x)
    assert pretty(f_3) == '  /        \n |         \n |  / x\\   \n |  \\2 /   \n | x     dx\n |         \n/          '

    # Definite integrals
    f_4 = Integral(x**2, (x,1,2))
    assert pretty(f_4) == '  2      \n  /      \n |       \n |   2   \n |  x  dx\n |       \n/        \n1        '

    f_5 = Integral(x**2, (x,Rational(1,2),10))
    assert pretty(f_5) == ' 10      \n  /      \n |       \n |   2   \n |  x  dx\n |       \n/        \n1/2      '

    # Nested integrals
    f_6 = Integral(x**2*y**2, x,y)
    assert pretty(f_6) == '  /  /           \n |  |            \n |  |  2  2      \n |  | x *y  dx dy\n |  |            \n/  /             '
コード例 #8
0
ファイル: vmbot.py プロジェクト: ArcCodie/vmbot
 def do_math(args):
     return pretty(parse_expr(args), full_prec=False, use_unicode=False)
コード例 #9
0
def upretty(expr):
    return pretty(expr, True)
コード例 #10
0
def upretty(expr):
    return pretty(expr, True)
コード例 #11
0
ファイル: test_pretty.py プロジェクト: certik/sympy-oldcore
def test_pretty_relational():
    assert pretty(x == y) == 'x = y'
    assert pretty(x <= y) == 'x <= y'
    assert pretty(x > y) == 'y < x'
    assert pretty(x/(y+1) != y**2) == '  x       2\n----- != y \n1 + y      '
コード例 #12
0
def upretty(expr):
    return pretty(expr, use_unicode=True)
コード例 #13
0
ファイル: test_pretty.py プロジェクト: certik/sympy-oldcore
def test_pretty_basic():
    # Simple numbers/symbols
    assert pretty( -Rational(1)/2 ) == '-1/2'
    assert pretty( -Rational(13)/22 ) == '  13\n- --\n  22'
    assert pretty( oo ) == 'oo'

    # Powers
    assert pretty( (x**2) ) == ' 2\nx '
    assert pretty( 1/x ) == '1\n-\nx'

    # Sums of terms
    assert pretty( (x**2 + x + 1))  == '         2\n1 + x + x '
    assert pretty( 1-x ) == '1 - x'
    assert pretty( 1-2*x ) == '1 - 2*x'
    assert pretty( 1-Rational(3,2)*y/x ) == '    3*y\n1 - ---\n    2*x'

    # Multiplication
    assert pretty( x/y ) == 'x\n-\ny'
    assert pretty( -x/y ) == '-x\n--\ny '
    assert pretty( (x+2)/y ) == '2 + x\n-----\n  y  '
    assert pretty( (1+x)*y ) in ['(1 + x)*y', 'y*(1 + x)']

    # Check for proper placement of negative sign
    assert pretty( -5*x/(x+10) ) == ' -5*x \n------\n10 + x'
    assert pretty( 1 - Rational(3,2)*(x+1) ) == '       3*x\n-1/2 - ---\n        2 '
コード例 #14
0
ファイル: test_pretty.py プロジェクト: certik/sympy-oldcore
def test_pretty_unicode():
    assert pretty( oo, True ) == u'\u221e'
    assert pretty( pi, True ) == u'\u03c0'
    assert pretty( pi+2*x, True ) == u'\u03c0 + 2*x'
    assert pretty( pi**2+exp(x), True ) == u' 2    x\n\u03c0  + \u212f '
    assert pretty( x != y, True ) == u'x \u2260 y'
コード例 #15
0
def _equivalent(question):
    def parse(text: str):
        tok = re.compile("{(.*),(.*)}")
        results = tok.findall(text)

        if results.__len__() > 0:
            ex_1, ex_2 = results[0]
            ex_1 = ex_1.strip()
            ex_2 = ex_2.strip()
            return ex_1, ex_2

        return None

    if question.__len__() < 1:
        return {'success': False, 'msg': "Cú pháp không hợp lệ"}

    parse_result = parse(question)

    if parse_result is None:
        return {'success': False, 'msg': "Cú pháp không hợp lệ"}

    _expr_str_1, _expr_str_2 = parse_result
    if _expr_str_1.__len__() < 1 or _expr_str_2.__len__() < 1:
        return {'success': False, 'msg': "Cú pháp không hợp lệ"}

    try:
        _expr_1 = parse_expr(_expr_str_1)
    except SyntaxError:
        return {'success': False, 'msg': "Cú pháp không hợp lệ"}

    try:
        _expr_2 = parse_expr(_expr_str_2)
    except SyntaxError:
        return {'success': False, 'msg': "Cú pháp không hợp lệ"}

    result, step_1, step_2 = logic_simplify.equivalent(_expr_1, _expr_2)

    _ex1 = _expr_1
    _ex2 = _expr_2

    steps_1 = []
    if step_1 is not None:
        _ex1, rules_1, expr_list_1 = step_1
        for ex, r in zip(expr_list_1, rules_1):
            step_detail = {
                "expr": pretty(ex),
                "rule": r
            }
            steps_1.append(step_detail)

    steps_2 = []
    if step_2 is not None:
        _ex2, rules_2, expr_list_2 = step_2
        for ex, r in zip(expr_list_2, rules_2):
            step_detail = {
                "expr": pretty(ex),
                "rule": r
            }
            steps_2.append(step_detail)

    answer = {
        "expr_1": pretty(_ex1),
        "expr_2": pretty(_ex2),
        "steps_1": steps_1,
        "steps_2": steps_2,
        "result": result
    }
    return {'success': True, "type": "3", 'answer': answer}
コード例 #16
0
 def do_math(args):
     return pretty(parse_expr(args), full_prec=False, use_unicode=False)
コード例 #17
0
def upretty(expr):
    return pretty(expr, use_unicode=True)
コード例 #18
0
ファイル: test_pretty.py プロジェクト: certik/sympy-oldcore
def test_pretty_limits():
    assert pretty( limit(x, x, oo, evaluate=False) ) == ' lim x\nx->oo '
    assert pretty( limit(x**2, x, 0, evaluate=False) ) == '     2\nlim x \nx->0  '