Python Forward.suppress方法代码示例

# 需要导入模块: from pyparsing import Forward [as 别名]
# 或者: from pyparsing.Forward import suppress [as 别名]
    def bnf(self):
        '''
        The BNF grammar is defined bellow.
        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 ]*
        '''
        if not self._bnf:
            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 + "_$")
            minus = Literal("-")
            plus = Literal("+")
            div = Literal("/")
            mult = Literal("*")
            rpar = Literal(")").suppress()
            lpar = Literal("(").suppress()
            addop = plus | minus
            multop = mult | div
            expop = Literal("^")
            pi = CaselessLiteral("PI")

            expr = Forward()
            atom = (
                Optional("-") +
                (
                    pi |
                    e |
                    fnumber |
                    ident + lpar + delimitedList(expr) + rpar
                ).setParseAction(self.push_first) |
                (lpar + expr.suppress() + rpar)
            ).setParseAction(self.push_minus)

            # The right way to define exponentiation is -> 2^3^2 = 2^(3^2),
            # not (2^3)^2.
            factor = Forward()
            factor << atom + ZeroOrMore(
                (expop + factor).setParseAction(self.push_first)
            )

            term = factor + ZeroOrMore(
                (multop + factor).setParseAction(self.push_first)
            )
            expr << term + ZeroOrMore(
                (addop + term).setParseAction(self.push_first)
            )
            self._bnf = expr
        return self._bnf

# 需要导入模块: from pyparsing import Forward [as 别名]
# 或者: from pyparsing.Forward import suppress [as 别名]
def compute(input_string):
    # Debugging flag can be set to either "debug_flag=True" or "debug_flag=False"
    debug_flag = False

    explain_list = []
    variables = {}

    # define grammar
    point = Literal(".")
    e = CaselessLiteral("E")
    plusorminus = Literal("+") | Literal("-")
    number = Word(nums)
    integer = Combine(Optional(plusorminus) + number)
    floatnumber = Combine(integer + Optional(point + Optional(number)) + Optional(e + integer))

    ident = Word(alphas, alphanums + "_")

    plus = Literal("+")
    minus = Literal("-")
    mult = Literal("*")
    div = Literal("/")
    lpar = Literal("(").suppress()
    rpar = Literal(")").suppress()
    addop = plus | minus
    multop = mult | div
    expop = Literal("^")
    assign = Literal("=")

    expr = Forward()
    atom = (e | floatnumber | integer | ident).setParseAction(pushFirst) | (lpar + expr.suppress() + rpar)

    factor = Forward()
    factor << atom + ZeroOrMore((expop + factor).setParseAction(pushFirst))

    term = factor + ZeroOrMore((multop + factor).setParseAction(pushFirst))
    expr << term + ZeroOrMore((addop + term).setParseAction(pushFirst))
    bnf = Optional((ident + assign).setParseAction(assignVar)) + expr

    pattern = bnf + StringEnd()

    if input_string != "":
        try:
            L = pattern.parseString(input_string)
        except ParseException, err:
            raise ComputationException, "Error while parsing"
        print exprStack
        if len(exprStack) <= 1:
            return None
        result = evaluateStack(exprStack, explain_list)
        if len(str(result)) > 12:
            ret = "%e" % result
        else:
            ret = str(result)
        ret = ret.replace("e", " x 10^")
        ret = ret.replace("+", "")
        if len(explain_list):
            return "%s (%s)" % (ret, ", ".join(explain_list))
        else:
            return "%s" % ret

# 需要导入模块: from pyparsing import Forward [as 别名]
# 或者: from pyparsing.Forward import suppress [as 别名]
    def _BNF(self):
        base16 = Literal("$")
        hex = Combine(base16 + Word(hexnums + "_"))

        base4 = Literal("%%")
        quaternary = Combine(base4 + Word("0123_"))

        base2 = Literal("%")
        binary = Combine(base2 + Word("01_"))

        plusminus = Literal("+") | Literal("-")
        integer = Combine(Optional(plusminus) + Word(nums+"_"))

        name_token = Combine(Optional(Literal(":") | Literal("@")) + Word("_" + alphas, "_" + alphanums))
        name_token.setParseAction(self._mark_name_token)

        lparens = Literal("(").suppress()
        rparens = Literal(")").suppress()

        # op0 = Literal("@")
        op1 = (Literal("^^") | Literal("||") | Literal("|<") | Literal(">|") | Literal("!")).setParseAction(self._mark_unary)
        op2 = Literal("->") | Literal("<-") | Literal(">>") | Literal("<<") | Literal("~>") | Literal("><")
        op3 = Literal("&")
        op4 = Literal("|") | Literal("^")
        op5 = Literal("**") | Literal("*") | Literal("//") | Literal("/")
        op6 = Literal("+") | Literal("-")
        op7 = Literal("#>") | Literal("<#")
        op8 = Literal("<") | Literal(">") | Literal("<>") | Literal("==") | Literal("=<") | Literal("=>")
        op9 = Literal("NOT").setParseAction(self._mark_unary)
        op10 = Literal("AND")
        op11 = Literal("OR")
        op12 = Literal(",")

        expr = Forward()

        atom = name_token | hex | quaternary | binary | integer | quotedString
        atom.setParseAction(self._push)
        atom = atom | (lparens + expr.suppress() + rparens)
 
        # term0  = atom   + ZeroOrMore((op0 + atom)   .setParseAction(self._push))
        # term1  = term0  + ZeroOrMore((op1 + term0)  .setParseAction(self._push))
        term1  = atom   + ZeroOrMore((op1 + atom)   .setParseAction(self._push))
        term2  = term1  + ZeroOrMore((op2 + term1)  .setParseAction(self._push))
        term3  = term2  + ZeroOrMore((op3 + term2)  .setParseAction(self._push))
        term4  = term3  + ZeroOrMore((op4 + term3)  .setParseAction(self._push))
        term5  = term4  + ZeroOrMore((op5 + term4)  .setParseAction(self._push))
        term6  = term5  + ZeroOrMore((op6 + term5)  .setParseAction(self._push))
        term7  = term6  + ZeroOrMore((op7 + term6)  .setParseAction(self._push))
        term8  = term7  + ZeroOrMore((op8 + term7)  .setParseAction(self._push))
        term9  = term8  + ZeroOrMore((op9 + term8)  .setParseAction(self._push))
        term10 = term9  + ZeroOrMore((op10 + term9) .setParseAction(self._push))
        term11 = term10 + ZeroOrMore((op11 + term10).setParseAction(self._push))
        expr  << term11 + ZeroOrMore((op12 + term11).setParseAction(self._push))

        return expr

# 需要导入模块: from pyparsing import Forward [as 别名]
# 或者: from pyparsing.Forward import suppress [as 别名]
    def _BNF(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 ]*
        """
        if not self.bnf:
            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()
#             comma = Literal( "," ).suppress()
            comma = Literal( "," )
            addop  = plus | minus
            multop = mult | div
            expop = Literal( "^" )
            pi    = CaselessLiteral( "PI" )
            var_list = [Literal(i) for i in self.var_names]
            
            expr = Forward()
            arg_func = Forward()
            or_vars = MatchFirst(var_list)
#             atom = (Optional("-") + ( pi | e | fnumber | ident + lpar + delimitedList(Group(expr)) + rpar | or_vars ).setParseAction( self._pushFirst ) | ( lpar + delimitedList(Group(expr)).suppress() + rpar ) ).setParseAction(self._pushUMinus) 
            atom = ((Optional("-") + ( pi | e | fnumber | ident + lpar + arg_func + rpar | or_vars ).setParseAction( self._pushFirst )) | \
                     (Optional("-") + ( lpar + arg_func.suppress() + rpar )) ).setParseAction(self._pushUMinus) 
            
#             expr + ZeroOrMore( "," + expr )
            # by defining exponentiation as "atom [ ^ factor ]..." instead of "atom [ ^ atom ]...", we get right-to-left exponents, instead of left-to-righ
            # 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 ) )
            arg_func << expr + ZeroOrMore( (comma + expr).setParseAction( self._pushFirst))
            self.bnf = expr
        return self.bnf

# 需要导入模块: from pyparsing import Forward [as 别名]
# 或者: from pyparsing.Forward import suppress [as 别名]
def _dice_grammar(exprStack, varStack):

    def pushFirst(str, loc, toks):
        exprStack.append(toks[0])

    def assignVar(str, loc, toks):
        varStack.append(toks[0])

    point = Literal('.')
    e = CaselessLiteral('E')
    plusorminus = Literal('+') | Literal('-')
    singledie = Literal('d')
    number = Word(nums)
    integer = Combine(Optional(plusorminus) + number)
    singleroll = Combine(singledie + number)
    floatnumber = Combine(
        integer + Optional(point + Optional(number)) + Optional(e + integer))

    ident = Word(alphas, alphanums + '_')

    plus = Literal("+")
    minus = Literal("-")
    mult = Literal("*")
    div = Literal("/")

    lpar = Literal("(").suppress()
    rpar = Literal(")").suppress()
    addop = plus | minus
    multop = mult | div
    expop = Literal("^")
    dieop = Literal("d")
    assign = Literal("=")

    expr = Forward()
    atom = (
        (e | floatnumber | integer | ident | singleroll).setParseAction(
            pushFirst) | (lpar + expr.suppress() + rpar))
    roll = Forward()
    roll << atom + ZeroOrMore((dieop + roll).setParseAction(pushFirst))

    factor = Forward()
    factor << roll + ZeroOrMore((expop + factor).setParseAction(pushFirst))

    term = factor + ZeroOrMore((multop + factor).setParseAction(pushFirst))

    expr << term + ZeroOrMore((addop + term).setParseAction(pushFirst))
    bnf = Optional((ident + assign).setParseAction(assignVar)) + expr

    return bnf + StringEnd()

# 需要导入模块: from pyparsing import Forward [as 别名]
# 或者: from pyparsing.Forward import suppress [as 别名]
def BNF():
    """
    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 ]*
    """
    global bnf
    if not bnf:
        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("-") + (pi | e | fnumber | ident +
                                  lpar + expr + rpar).setParseAction(pushFirst)
                | (lpar + expr.suppress() + rpar)).setParseAction(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(pushFirst))

        term = factor + ZeroOrMore((multop +
                                    factor).setParseAction(pushFirst))
        expr << term + ZeroOrMore((addop + term).setParseAction(pushFirst))
        bnf = expr
    return bnf

# 需要导入模块: from pyparsing import Forward [as 别名]
# 或者: from pyparsing.Forward import suppress [as 别名]
    def grammar(self):
        def push_first(s, loc, toks):
            self.stack.append(toks[0])

        def push_atom(s, loc, toks):
            atom = toks[0]
            number = _parse_number(atom)
            if number is not None:
                self.stack.append(number)
            else:
                self.stack.append(toks[0].lower())

        # constant expressions
        lpar   = Literal('(').suppress()
        rpar   = Literal(')').suppress()
        addop  = Literal('+') | Literal('-')
        multop = Literal('*') | Literal('/')
        bitop  = Literal('<<') | Literal('>>') | \
                 Literal('&')  | Literal('|') | Literal('^') | \
                 Literal('<-') | Literal('->')
        number = (Combine(Literal('$') + Word(nums+'_abcdefABCDEF'))) | \
                 (Combine(Literal('%') + Word('_01'))) | \
                 Word('_' + nums)
        id = Combine(Optional('@') + Optional(':') + Regex(r'[a-zA-Z_]\w*'))

        expr = Forward()
        term = Forward()
        bwterm = Forward()

        atom  = Optional('-') + (number | id)
        rexpr = (lpar + expr.suppress() + rpar).suppress()

        # bitwise operators have highest precedence, followed by mul/div and
        # finally add/sub
        bwterm << ( atom.setParseAction(push_atom) | rexpr ) + ZeroOrMore( (bitop + bwterm).setParseAction(push_first) )
        term << bwterm + ZeroOrMore( (multop + bwterm).setParseAction(push_first) )
        expr << term + ZeroOrMore( (addop + term).setParseAction(push_first) )

        return expr

# 需要导入模块: from pyparsing import Forward [as 别名]
# 或者: from pyparsing.Forward import suppress [as 别名]
not_equal_op     = Literal( "!=" )
greater_op       = Combine( Literal( ">" ) + ~Literal( "=" ) )
greater_equal_op = Combine( Literal( ">" ) + Literal( "=" ) )
less_op          = Combine( Literal( "<" ) + ~Literal( "=" ) )
less_equal_op    = Combine( Literal( "<" ) + Literal( "=" ) )

addop  = plus | minus
multop = mult | div
compop = less_op | greater_op | less_equal_op | greater_equal_op | not_equal_op | equal_op
expop = Literal( "^" )
#assign = Literal( "=" )
band = Literal( "@" )

expr = Forward()
atom = ( ( e | floatnumber | integer | ident.setParseAction( assignVar ) | fn + lpar + expr + rpar | fn + lpar + expr + colon + expr + rpar | fn + lpar + expr + colon + expr + colon + expr + rpar ).setParseAction(pushFirst) |
         ( lpar + expr.suppress() + rpar )
       )

factor = Forward()
factor << atom + ( ( band + factor ).setParseAction( pushFirst ) | ZeroOrMore( ( expop + factor ).setParseAction( pushFirst ) ) )

term = factor + ZeroOrMore( ( multop + factor ).setParseAction( pushFirst ) )
addterm = term + ZeroOrMore( ( addop + term ).setParseAction( pushFirst ) )
expr << addterm + ZeroOrMore( ( compop + addterm ).setParseAction( pushFirst ) )
bnf = expr

pattern =  bnf + StringEnd()

# map operator symbols to corresponding arithmetic operations
opn = { "+" : ( lambda a,b: numpy.add( a, b ) ),
        "-" : ( lambda a,b: numpy.subtract( a, b ) ),

# 需要导入模块: from pyparsing import Forward [as 别名]
# 或者: from pyparsing.Forward import suppress [as 别名]
def create_bnf(stack):
    point = Literal(".")
    comma = Literal(",")
    e = CaselessLiteral("E")
    inumber = Word(nums)
    fnumber = Combine(Word("+-"+nums, nums) +
                       Optional(point + Optional(Word(nums))) +
                       Optional(e + Word("+-"+nums, nums)))
    _of = Literal('of')
    _in = Literal('in')
    _by = Literal('by')
    _copy = Literal('copy')

    _mv = Literal('-v').setParseAction(replace('OA_SubV'))
    _me = Literal('-e').setParseAction(replace('OA_SubE'))
    _mf = Literal('-f').setParseAction(replace('OA_SubF'))
    _mc = Literal('-c').setParseAction(replace('OA_SubC'))
    _ms = Literal('-s').setParseAction(replace('OA_SubS'))
    _pv = Literal('+v').setParseAction(replace('OA_AddV'))
    _pe = Literal('+e').setParseAction(replace('OA_AddE'))
    _pf = Literal('+f').setParseAction(replace('OA_AddF'))
    _pc = Literal('+c').setParseAction(replace('OA_AddC'))
    _ps = Literal('+s').setParseAction(replace('OA_AddS'))
    _inv = Literal('*v').setParseAction(replace('OA_IntersectV'))
    _ine = Literal('*e').setParseAction(replace('OA_IntersectE'))
    _inf = Literal('*f').setParseAction(replace('OA_IntersectF'))
    _inc = Literal('*c').setParseAction(replace('OA_IntersectC'))
    _ins = Literal('*s').setParseAction(replace('OA_IntersectS'))
    regop = (_mv | _me | _mf | _mc | _ms |
             _pv | _pe | _pf | _pc | _ps |
             _inv | _ine | _inf | _inc | _ins)

    lpar  = Literal("(").suppress()
    rpar  = Literal(")").suppress()

    _all = Literal('all').setParseAction(replace('KW_All'))
    vertex = Literal('vertex')
    vertices = Literal('vertices')
    cell = Literal('cell')
    cells = Literal('cells')
    group = Literal('group')
    _set = Literal('set')
    surface = Literal('surface')

    ident = Word(alphas + '_.', alphanums + '_.')
    set_name = Word(nums) | ident

    function = Word(alphas + '_', alphanums + '_')
    function = Group(function).setParseAction(join_tokens)

    region = Combine(Literal('r.') + Word(alphas + '_',
                                          '_' + alphas + nums + '.'))
    region = Group(Optional(_copy, default='nocopy') + region)
    region.setParseAction(replace('KW_Region', keep=True))

    coor = oneOf('x y z')
    boolop = oneOf('& |')
    relop = oneOf('< > <= >= != ==')
    bool_term = (ZeroOrMore('(') + (coor | fnumber) + relop + (coor | fnumber)
                 + ZeroOrMore(')'))
    relation = Forward()
    relation << (ZeroOrMore('(')
                 + bool_term + ZeroOrMore(boolop + relation)
                 + ZeroOrMore(')'))
    relation = Group(relation).setParseAction(join_tokens)

    nos = Group(vertices + _of + surface).setParseAction(replace('E_VOS'))
    nir = Group(vertices + _in + relation).setParseAction(
        replace('E_VIR', keep=True))
    nbf = Group(vertices + _by + function).setParseAction(
        replace('E_VBF', keep=True))
    ebf = Group(cells + _by + function).setParseAction(
        replace('E_CBF', keep=True))
    eog = Group(cells + _of + group + Word(nums)).setParseAction(
        replace('E_COG', keep=True))
    nog = Group(vertices + _of + group + Word(nums)).setParseAction(
        replace('E_VOG', keep=True))
    onir = Group(vertex + _in + region).setParseAction(
        replace_with_region('E_OVIR', 2))
    ni = Group(vertex + delimitedList(inumber)).setParseAction(
        replace('E_VI', keep=True))
    ei1 = Group(cell + delimitedList(inumber)).setParseAction(
        replace('E_CI1', keep=True))
    etuple = (lpar.suppress() + inumber + comma.suppress()
              + inumber + rpar.suppress())
    ei2 = Group(cell + delimitedList(etuple)).setParseAction(
        replace('E_CI2', keep=True))
    noset = Group(vertices + _of + _set + set_name).setParseAction(
        replace('E_VOSET', keep=True))
    eoset = Group(cells + _of + _set + set_name).setParseAction(
        replace('E_COSET', keep=True))

    region_expression = Forward()

    atom1 = (_all | region | ni | onir | nos | nir | nbf
             | ei1 | ei2 | ebf | eog | nog | noset | eoset)
    atom1.setParseAction(to_stack(stack))
    atom2 = (lpar + region_expression.suppress() + rpar)
    atom = (atom1 | atom2)

#.........这里部分代码省略.........

# 需要导入模块: from pyparsing import Forward [as 别名]
# 或者: from pyparsing.Forward import suppress [as 别名]
class EquationGrammar(object):
   def __init__(self):
      self._expr_stack=[]

      # every optional, matchfirst, or ZeroOrMore needs to have a probability defined in this dict
      self._generators={}

      # operators
      plus=Literal("+")
      minus=Literal("-")
      mult=Literal("*")
      div=Literal("/")
      addsub=plus|minus
      self._generators[addsub]=flip_gen([plus,minus])
      multdiv=mult|div
      self._generators[multdiv]=flip_gen([mult,div])

      # constants
      pi=CaselessLiteral("PI")
      e=CaselessLiteral("E")

      # numbers and identifiers
      point=Literal(".")
      integer=Combine(Word("+-"+nums,nums))
      self._generators[integer.expr]=num_gen(nums)

      #ident=Word(alphas,alphas+nums)
      fnsin=Literal("sin")
      fncos=Literal("cos")
      fntan=Literal("tan")
      fnabs=Literal("abs")
      fnident=fnsin|fncos|fntan|fnabs
      self._generators[fnident]=choose_gen([fnsin,fncos,fntan,fnabs],[0.4,0.4,0.1,0.1])
      variable=Literal("x")

      # grouping
      lparen=Literal("(").suppress()
      rparen=Literal(")").suppress()

      # expressions
      self._expr=Forward()
      optneg=Optional("-")
      self._generators[optneg]=flip_gen(["-",None])
      functioncall=fnident+lparen+self._expr+rparen
      atom_base=pi|e|integer|functioncall|variable
      atom_base_choices=[pi,e,integer,functioncall,variable]
      self._generators[atom_base]=(choose_gen(atom_base_choices,[0.1,0.1,0.2,0.3,0.3]),\
         choose_gen(atom_base_choices,[0.1,0.1,0.4,0.0,0.4]))
      parenthetical=lparen+self._expr.suppress()+rparen
      atom=(optneg+atom_base.setParseAction(self.push_first)|parenthetical).setParseAction(\
         self.push_uminus)
      atom_choices=[atom_base,parenthetical]
      self._generators[atom]=(choose_gen(atom_choices,[0.5,0.5]),choose_gen(atom_choices,[1.0,0.0]))

      # 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()
      # parse either curly braces or parenthesis, but only generate curly braces
      expon=Literal("^")
      exponlparen=Literal("{").suppress()
      exponrparen=Literal("}").suppress()
      mf_lparen=exponlparen|lparen
      lparen_choices=[exponlparen,lparen]
      self._generators[mf_lparen]=choose_gen(lparen_choices,[1.0,0.0])
      mf_rparen=exponrparen|rparen
      rparen_choices=[exponrparen,rparen]
      self._generators[mf_rparen]=choose_gen(rparen_choices,[1.0,0.0])

      exponfactor=(expon+mf_lparen.suppress()+factor+mf_rparen.suppress()).setParseAction(\
         self.push_first)
      zom_exponfactor=ZeroOrMore(exponfactor)
      self._generators[zom_exponfactor]=poisson_gen(exponfactor,0.2)
      factor << atom + zom_exponfactor

      multdivfactor=(multdiv+factor).setParseAction(self.push_first)
      zom_multdivfactor=ZeroOrMore(multdivfactor)
      self._generators[zom_multdivfactor]=poisson_gen(multdivfactor,0.5)
      term=factor+zom_multdivfactor

      addsubterm=(addsub+term).setParseAction(self.push_first)
      zom_addsubterm=ZeroOrMore(addsubterm)
      self._generators[zom_addsubterm]=poisson_gen(addsubterm,0.5)
      self._expr << term+zom_addsubterm

      self._id_expr=id(self._expr)

   def set_expr_stack(self,expr_stack):
      self._expr_stack=expr_stack

   def push_first(self,strg,loc,toks):
      self._expr_stack.append(toks[0])

   def push_uminus(self,strg,loc,toks):
      if toks and toks[0]=='-':
         self._expr_stack.append('unary -')

   def parse_string(self,s):
      return self._expr.parseString(s)

#.........这里部分代码省略.........

# 需要导入模块: from pyparsing import Forward [as 别名]
# 或者: from pyparsing.Forward import suppress [as 别名]

#.........这里部分代码省略.........
                     "median": xr.DataArray.median,
                     "min": xr.DataArray.min,
                     "prod": xr.DataArray.prod,
                     "sum": xr.DataArray.sum,
                     "std": xr.DataArray.std,
                     "var": xr.DataArray.var}

        # Define non-xarray DataArray operators with 2 input parameter
        self.xcond = {"<": np.percentile}

        # Define Grammar
        point = Literal(".")
        e = CaselessLiteral("E")
        fnumber = Combine(Word("+-"+nums, nums) +
                          Optional(point + Optional(Word(nums))) +
                          Optional(e + Word("+-"+nums, nums)))
        variable = Word(alphas, alphas+nums+"_$")

        seq = Literal("=")
        b_not = Literal("~")
        plus = Literal("+")
        minus = Literal("-")
        mult = Literal("*")
        div = Literal("/")
        gt = Literal(">")
        gte = Literal(">=")
        lt = Literal("<")
        lte = Literal("<=")
        eq = Literal("==")
        neq = Literal("!=")
        b_or = Literal("|")
        b_and = Literal("&")
        l_not = Literal("!")
        lpar = Literal("(").suppress()
        rpar = Literal(")").suppress()
        comma = Literal(",")
        colon = Literal(":")
        lbrac = Literal("[")
        rbrac = Literal("]")
        lcurl = Literal("{")
        rcurl = Literal("}")
        qmark = Literal("?")
        scolon = Literal(";")
        addop = plus | minus
        multop = mult | div
        sliceop = colon
        compop = gte | lte | gt | lt
        eqop = eq | neq
        bitcompop = b_or | b_and
        bitnotop = b_not
        logicalnotop = l_not
        assignop = seq
        expop = Literal("^")

        expr = Forward()
        indexexpr = Forward()

        atom = (Optional("-") +
                (variable + seq + expr).setParseAction(self.push_assign) |
                indexexpr.setParseAction(self.push_index) |
                (lpar + expr + qmark.setParseAction(self.push_ternary1) + expr +
                 scolon.setParseAction(self.push_ternary2) + expr +
                 rpar).setParseAction(self.push_ternary) |
                (lpar + expr + qmark + expr + scolon + expr +
                 rpar).setParseAction(self.push_ternary) |
                (logicalnotop + expr).setParseAction(self.push_ulnot) |

# 需要导入模块: from pyparsing import Forward [as 别名]
# 或者: from pyparsing.Forward import suppress [as 别名]
	def __init__(self):
		# define grammar
		point = Literal('.')
		e = CaselessLiteral('E')
		plusorminus = Literal('+') | Literal('-')
		number = Word(nums) 
		integer = Combine( Optional(plusorminus) + number )
		floatnumber = Combine( integer +
							Optional( point + Optional(number) ) +
							Optional( e + integer )
							)

		ident = Word('$',alphanums + '_') 

		plus  = Literal( "+" )
		minus = Literal( "-" )
		mult  = Literal( "*" )
		div   = Literal( "/" )
		lpar  = Literal( "(" ).suppress()
		rpar  = Literal( ")" ).suppress()
		addop  = plus | minus
		multop = mult | div
		expop = Literal( "^" )	

		expr = Forward()
		def defineFunction(name, parameterCount=None):
			keyword = CaselessKeyword(name).setParseAction(self.pushEnd)
			funcPattern = keyword + lpar
			if parameterCount == None:
				funcPattern += Optional(expr+ZeroOrMore(Literal(',')+expr))
			elif parameterCount > 0:
				funcPattern += expr
				for i in range(parameterCount-1):
					funcPattern += Literal(',') + expr
			funcPattern += rpar
			return funcPattern.setParseAction(self.pushFirst)
		maxFunc = defineFunction('max')
		minFunc = defineFunction('min')
		casesFunc = defineFunction('cases')
		cases1Func = defineFunction('cases1', parameterCount = 5)
		cases2Func = defineFunction('cases2', parameterCount = 8)
		cases3Func = defineFunction('cases3', parameterCount = 11)
		cases333Func = defineFunction('cases333', parameterCount = 11)
		round3downFunc = defineFunction('round3down', parameterCount = 1)
		
		#func = (funcident.setParseAction(self.pushEnd)+lpar +Optional(expr+ZeroOrMore(Literal(',')+expr))+rpar).setParseAction(self.pushFirst)
		atom = ( maxFunc | minFunc | casesFunc | cases1Func | cases2Func | cases3Func | cases333Func| round3downFunc |
				( e | floatnumber | integer | ident ).setParseAction(self.pushFirst) |
				( lpar + expr.suppress() + rpar )
			)
				
		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 ) )

		self.pattern =  expr + StringEnd()
		# map operator symbols to corresponding arithmetic operations
		self.opn = { "+" : self.handleNone( lambda a,b: a + b ),
				"-" : self.handleNone( lambda a,b: a - b ),
				"*" : self.handleNone( lambda a,b: a * b, none_survives=True ),
				"/" : self.handleNone( lambda a,b: a / b, none_survives=True ),
				"^" : self.handleNone( lambda a,b: a ** b, none_survives=True ) }
		self.functions = { 'max': max,
			'min': self.min,
			'cases': self.cases,
			'cases1': self.cases1,
			'cases2': self.cases2,
			'cases3': self.cases3,
			'cases333': self.cases333,
			'round3down': self.round3down
			}

# 需要导入模块: from pyparsing import Forward [as 别名]
# 或者: from pyparsing.Forward import suppress [as 别名]
def BNF():
    """
    expop   :: '^'
    multop  :: '*' | '/' | '>>' | '<<' | '|' | '&'
    addop   :: '+' | '-'
    hex     :: '0x' + integer
    integer :: ['+' | '-'] '0'..'9'+
    atom    :: PI | E | real | fn '(' expr ')' | '(' expr ')'
    factor  :: atom [ expop factor ]*
    term    :: factor [ multop factor ]*
    expr    :: term [ addop term ]*
    """
    global bnf

    if not bnf:
        point = Literal( "." )
        e     = CaselessLiteral( "E" )
        hexnum = CaselessLiteral("0x") + OneOrMore(oneOf(nums + 'a b c d e f A B C D E F'))
        hexnum.setParseAction(lambda s,l,t:str(int(''.join(t),16)))
        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( "/" )
        lshift  = Literal( "<<" )
        rshift  = Literal( ">>" )
        or_  = Literal( "|" )
        and_  = Literal( "&" )
        lpar  = Literal( "(" ).suppress()
        rpar  = Literal( ")" ).suppress()
        addop  = plus | minus
        multop = mult | div | lshift | rshift | or_ | and_
        expop = Literal( "^" )
        pi    = CaselessLiteral( "PI" )

        expr = Forward()
        atom = (Optional("-") + ( pi | e | hexnum | fnumber | ident + lpar + expr + rpar ).setParseAction( pushFirst ) | ( lpar + expr.suppress() + rpar )).setParseAction(pushUMinus)

        # by defining exponentiation as "atom [ ^ factor ]..." instead of "atom [ ^ atom ]...", we get right-to-left exponents, instead of left-to-righ
        # that is, 2^3^2 = 2^(3^2), not (2^3)^2.
        factor = Forward()
        factor << atom + ZeroOrMore( ( expop + factor ).setParseAction( pushFirst ) )

        term = factor + ZeroOrMore( ( multop + factor ).setParseAction( pushFirst ) )
        expr << term + ZeroOrMore( ( addop + term ).setParseAction( pushFirst ) )
        bnf = expr
    return bnf

# 需要导入模块: from pyparsing import Forward [as 别名]
# 或者: from pyparsing.Forward import suppress [as 别名]
    def init_grammar(self):
        LPAR, RPAR, LBRACK, RBRACK, LBRACE, RBRACE, SEMI, COMMA, EQUAL, COLON = map(Suppress, "()[]{};,=:")

        USE = Keyword("use")
        MODULE = Keyword("module")
        IF = Keyword("if")
        FOR = Keyword("for")
        ELSE = Keyword("else")
        TRUE = Keyword("true")
        FALSE = Keyword("false")
        UNDEF = Keyword("undef")
        mul_operator = oneOf("* /")
        add_operator = oneOf("+ -")
        exp_operator = Literal( "^" )

        boolOperand = ( TRUE | FALSE )
        boolOperand.setParseAction(BoolOperand)

        boolExpr = infixNotation( boolOperand, [
            ("not", 1, opAssoc.RIGHT, BoolNot),
            ("and", 2, opAssoc.LEFT,  BoolAnd),
            ("or",  2, opAssoc.LEFT,  BoolOr),
        ])

        identifier = Word("$" + alphas + "_", alphanums + "_")
        plusorminus = Literal('+') | Literal('-')
        numberal = Word(nums)
        e = CaselessLiteral('E')
        integer = Combine( Optional(plusorminus) + numberal )
        floatnumber = Combine( integer +
                       Optional( Literal('.') + Optional(numberal) ) +
                       Optional( e + integer )
                     )
        number = ( integer | floatnumber )

        calculation = Forward()
        atom = ( ( e | floatnumber | integer | identifier ).setParseAction( self.pushFirst ) |
                 ( LPAR + calculation.suppress() + RPAR )
               )

        factor = Forward()
        factor << atom + ZeroOrMore( ( exp_operator + factor ).setParseAction( self.pushFirst ) )

        term = factor + ZeroOrMore( ( mul_operator + factor ).setParseAction( self.pushFirst ) )
        calculation << term + ZeroOrMore( ( add_operator + term ).setParseAction( self.pushFirst ) )
        calculation.setParseAction(self.calculate)


        constant = number.setParseAction(self.constant_action)
        modifier_name = ( Keyword("translate") | Keyword("rotate") | Keyword("scale") | Keyword("simplify") )

        use = (USE + identifier("name") + SEMI).setParseAction(self.use_action)

        expression = Forward()

        arguments = delimitedList(expression("exp").setParseAction(self.argument_action))
        module_call = ((identifier("name") + FollowedBy("(")).setParseAction(self.module_call_prepare_action) +
                       LPAR + Optional(arguments)("args") + RPAR)
        module_call_statement = (module_call + SEMI).setParseAction(self.module_call_action)

        primitive_argument_assignment_value = (calculation | boolExpr)

        primitive_argument_assignment = (identifier("variable") + EQUAL + primitive_argument_assignment_value).setParseAction(self.primitive_argument_assignment_action)
        primitive_argument = (primitive_argument_assignment | expression("exp"))
        primitive_argument_list = delimitedList(primitive_argument.setParseAction(self.argument_action))

        modifier = ( (modifier_name + FollowedBy("(")).setParseAction(self.primitive_modifier_prepare_action) +
                              LPAR + Optional(primitive_argument_list)("args") + RPAR).setParseAction(self.primitive_modifier_action)

        primitive_call_statement = ( ZeroOrMore(modifier)("modifiers") + (identifier("name") + FollowedBy("(")).setParseAction(self.primitive_call_prepare_action) +
                                    LPAR + Optional(primitive_argument_list)("args") + RPAR + SEMI).setParseAction(self.primitive_call_action)

        expression << (boolExpr | calculation).setParseAction(self.debug_action)#.setParseAction(lambda x: x[0])

        statement = Forward()

        assign_statement = (identifier("variable") + EQUAL + expression("expression") + SEMI).setParseAction(self.assign_action)

        modifier_scope = ( (ZeroOrMore(modifier)("modifiers") + identifier("name") + LPAR + Optional(primitive_argument_list)("args") + RPAR + FollowedBy("{")).setParseAction(self.modifier_scope_prepare_action) +
                            LBRACE + ZeroOrMore(statement) + RBRACE ).setParseAction(self.modifier_scope_action)

        vector = (LBRACK + calculation + COLON + calculation + RBRACK).setParseAction(self.vector_action)

        for_loop_scope = ( ZeroOrMore(modifier)("modifiers") + ( FOR + LPAR + identifier("index") + EQUAL + vector("loop_range") + RPAR + FollowedBy("{") ).setParseAction(self.begin_for_loop_scope) +
                         LBRACE + ZeroOrMore(statement)("body") + RBRACE ).setParseAction(self.for_loop_scope_action)

        statement << ( for_loop_scope | primitive_call_statement | module_call_statement | Suppress(assign_statement) | modifier_scope )

        body = OneOrMore(statement)

        self.program = (ZeroOrMore(use) + body).setParseAction(self.program_end_action)

# 需要导入模块: from pyparsing import Forward [as 别名]
# 或者: from pyparsing.Forward import suppress [as 别名]
 def grammar(self):
     if not self.bnf:
         point = Literal( "." )
         fnumber = Combine( Word( nums ) + 
                            Optional( point + Optional( Word( nums ) ) ) 
                            )
         ident = Word(alphas.lower()+"_", alphanums+"_")
         plus  = Literal( "+" )
         minus = Literal( "-" )
         mult  = Literal( "*" )
         # passiverate = Word('infty') | Word('T')
         div   = Literal( "/" )
         lpar  = Literal( "(" ).suppress()
         rpar  = Literal( ")" ).suppress()
         addop  = plus | minus
         multop = mult | div
         assign = Literal('=')
         expop = Literal( "^" )
         expr = Forward()
         atom = Optional("-") + ( fnumber | ident + lpar + expr + rpar | ident).setParseAction(self._pushFirst ) | lpar + expr.suppress() + rpar 
         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 ) )
         bnf = (ident + assign).setParseAction(self._assignVar) + expr 
         self.bnf = bnf
     return self.bnf