mirror of
https://github.com/RPCS3/discord-bot.git
synced 2026-01-31 01:25:22 +01:00
130 lines
4.6 KiB
Python
130 lines
4.6 KiB
Python
from pyparsing import (Literal, CaselessLiteral, Word, Combine, Group, Optional,
|
|
ZeroOrMore, Forward, nums, alphas, oneOf)
|
|
import math
|
|
import operator
|
|
|
|
__author__ = 'Paul McGuire & Roberto Anic Banic'
|
|
__version__ = '$Revision: 0.1 $'
|
|
__date__ = '$Date: 2018-02-04 $'
|
|
__source__ = '''http://pyparsing.wikispaces.com/file/view/fourFn.py
|
|
http://pyparsing.wikispaces.com/message/view/home/15549426
|
|
'''
|
|
__note__ = '''
|
|
All I've done is rewrap Paul McGuire's fourFn.py as a class, so I can use it
|
|
more easily in other places.
|
|
Added cmp
|
|
'''
|
|
|
|
|
|
class NumericStringParser(object):
|
|
'''
|
|
Most of this code comes from the fourFn.py pyparsing example
|
|
|
|
'''
|
|
|
|
def pushFirst(self, strg, loc, toks):
|
|
self.exprStack.append(toks[0])
|
|
|
|
def pushUMinus(self, strg, loc, toks):
|
|
if toks and toks[0] == '-':
|
|
self.exprStack.append('unary -')
|
|
|
|
def __init__(self):
|
|
"""
|
|
expop :: '^'
|
|
multop :: '*' | '/'
|
|
addop :: '+' | '-'
|
|
integer :: ['+' | '-'] '0'..'9'+
|
|
atom :: PI | E | real | fn '(' expr ')' | '(' expr ')'
|
|
factor :: atom [ expop factor ]*
|
|
term :: factor [ multop factor ]*
|
|
expr :: term [ addop term ]*
|
|
"""
|
|
point = Literal(".")
|
|
e = CaselessLiteral("E")
|
|
fnumber = Combine(Word("+-" + nums, nums) +
|
|
Optional(point + Optional(Word(nums))) +
|
|
Optional(e + Word("+-" + nums, nums)))
|
|
ident = Word(alphas, alphas + nums + "_$")
|
|
plus = Literal("+")
|
|
minus = Literal("-")
|
|
mult = Literal("*")
|
|
div = Literal("/")
|
|
lpar = Literal("(").suppress()
|
|
rpar = Literal(")").suppress()
|
|
addop = plus | minus
|
|
multop = mult | div
|
|
expop = Literal("^")
|
|
pi = CaselessLiteral("PI")
|
|
expr = Forward()
|
|
atom = ((Optional(oneOf("- +")) +
|
|
(ident + lpar + expr + rpar | pi | e | fnumber).setParseAction(self.pushFirst))
|
|
| Optional(oneOf("- +")) + Group(lpar + expr + rpar)
|
|
).setParseAction(self.pushUMinus)
|
|
# by defining exponentiation as "atom [ ^ factor ]..." instead of
|
|
# "atom [ ^ atom ]...", we get right-to-left exponents, instead of left-to-right
|
|
# that is, 2^3^2 = 2^(3^2), not (2^3)^2.
|
|
factor = Forward()
|
|
factor << atom + \
|
|
ZeroOrMore((expop + factor).setParseAction(self.pushFirst))
|
|
term = factor + \
|
|
ZeroOrMore((multop + factor).setParseAction(self.pushFirst))
|
|
expr << term + \
|
|
ZeroOrMore((addop + term).setParseAction(self.pushFirst))
|
|
# addop_term = ( addop + term ).setParseAction( self.pushFirst )
|
|
# general_term = term + ZeroOrMore( addop_term ) | OneOrMore( addop_term)
|
|
# expr << general_term
|
|
self.bnf = expr
|
|
# map operator symbols to corresponding arithmetic operations
|
|
epsilon = 1e-12
|
|
self.opn = {"+": operator.add,
|
|
"-": operator.sub,
|
|
"*": operator.mul,
|
|
"/": operator.truediv,
|
|
"^": operator.pow}
|
|
self.fn = {"sin": math.sin,
|
|
"cos": math.cos,
|
|
"tan": math.tan,
|
|
"exp": math.exp,
|
|
"abs": abs,
|
|
"sqrt": lambda a: math.sqrt(a),
|
|
"trunc": lambda a: int(a),
|
|
"round": round,
|
|
"sgn": lambda a: abs(a) > epsilon and self.cmp(a, 0) or 0}
|
|
|
|
def evaluateStack(self, s):
|
|
op = s.pop()
|
|
if op == 'unary -':
|
|
return -self.evaluateStack(s)
|
|
if op in "+-*/^":
|
|
op2 = self.evaluateStack(s)
|
|
op1 = self.evaluateStack(s)
|
|
return self.opn[op](op1, op2)
|
|
elif op == "PI":
|
|
return math.pi # 3.1415926535
|
|
elif op == "E":
|
|
return math.e # 2.718281828
|
|
elif op in self.fn:
|
|
return self.fn[op](self.evaluateStack(s))
|
|
elif op[0].isalpha():
|
|
return 0
|
|
else:
|
|
return float(op)
|
|
|
|
def eval(self, num_string, parseAll=True):
|
|
self.exprStack = []
|
|
results = self.bnf.parseString(num_string, parseAll)
|
|
val = self.evaluateStack(self.exprStack[:])
|
|
return val
|
|
|
|
def cmp(self, x, y):
|
|
"""
|
|
Replacement for built-in function cmp that was removed in Python 3
|
|
|
|
Compare the two objects x and y and return an integer according to
|
|
the outcome. The return value is negative if x < y, zero if x == y
|
|
and strictly positive if x > y.
|
|
"""
|
|
|
|
return (x > y) - (x < y)
|