o oÇ h¬.ã@s¶dZddlZddlmZmZmZmZmZddlm Z ddl m Z ddl m Z mZmZmZmZmZmZmZmZmZddlmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#ddl$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*dd l+m,Z,m-Z-m.Z.m/Z/m0Z0dd l1m2Z2dd l3m4Z4dd l5m6Z6dd l7m8Z8ddl9m:Z:ddl;mm?Z?ddl@mAZAddlBmCZCddlDmEZEddlFmGZGe dƒZHddgiZIeHrûddlHmJZJmKZKmLZLmMZMddlNmOZOmPZPmQZQeJ ReC¡eJ Re:¡eM Re:¡eJ Re2¡eM Re2¡eK Re2¡eL Re2¡eJ Re8¡eM Re8¡eK Re8¡eL Re8¡eJ Re<¡eK Re<¡eJ Re=¡eK Re=¡eJ ReA¡eJ Re ¡eJ Re¡eJ Re¡eJ Re-¡eJ Re,¡eJ Re¡eJ Re0¡eJ Re.¡eJ Re/¡eJ Re¡eJ Re¡eJ Re¡eJ Re¡eJ Re¡eJ Re¡eJ Re¡eJ Re¡eJ Re ¡eJ Re!¡eJ Re#¡eJ Re"¡eJ Re'¡eJ Re)¡eJ Re%¡eJ Re(¡eJ Re&¡eJ Re*¡eJ Re¡eJ Re¡eJ Re¡eJ Re¡eJ Re¡eJ Re¡eO ReC¡dd„ƒZSeO Re4¡dd„ƒZSeQ ReC¡dd„ƒZSeQ Re4¡dd„ƒZSeP Re4¡d4dd „ƒZTeHrdd!lHmUZUnGd"d#„d#ƒZUeGd$d%Gd&d'„d'eUe?ƒƒZVeGd$d%Gd(d)„d)eVƒƒZWeGd$d%Gd*d+„d+eVƒƒZXeGd$d%Gd,d-„d-eVƒƒZYd.d/„ZZGd0d1„d1eƒZ[eGd$d%Gd2d3„d3ƒƒZ\dS)5zj The objects in this module allow the usage of the MatchPy pattern matching library on SymPy expressions. éN)ÚListÚCallableÚ NamedTupleÚAnyÚDict)Ú_sympify)Ú import_module) ÚlogÚsinÚcosÚtanÚcotÚcscÚsecÚerfÚgammaÚ uppergamma) ÚacoshÚasinhÚatanhÚacothÚacschÚasechÚcoshÚsinhÚtanhÚcothÚsechÚcsch)ÚatanÚacscÚasinÚacotÚacosÚasec)ÚfresnelcÚfresnelsÚerfcÚerfiÚEi)ÚAdd)ÚBasic)ÚExpr)ÚMul)ÚPow)ÚEqualityÚ Unequality)ÚSymbol)Úexp)ÚIntegral)Úsrepr)Údoctest_depends_onÚmatchpy)Ú*)Ú OperationÚCommutativeOperationÚAssociativeOperationÚOneIdentityOperation)Úop_iterÚcreate_operation_expressionÚop_lencCst|jdf|jdƒS)Nré©ÚiterÚ_args©Ú operation©rEúu/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/sympy/utilities/matchpy_connector.pyÚ_[srGcCó t|jƒS©Nr@rCrErErFrG_ó cCsdt|jdƒS)Nr?©ÚlenrBrCrErErFrGcscCrHrIrKrCrErErFrGgrJTcCs t|ƒ|ŽSrI)Útype)Ú old_operationÚ new_operandsÚ variable_namerErErFÚsympy_op_factoryks rQ)ÚWildcardc@seZdZdd„ZdS)rRcCs||_||_||_||_dSrI)Ú min_countÚ fixed_sizerPÚoptional)ÚselfÚ min_lengthrTrPrUrErErFÚ__init__ts zWildcard.__init__N)Ú__name__Ú __module__Ú __qualname__rXrErErErFrRss rR)r6)ÚmodulescszeZdZUeed<eed<ddd„Zdd„Zddd „Zd d „Z e dd d „ƒZ ‡fdd„Z ddd„Z dd„Zdd„Z‡ZS)Ú _WildAbstractrWrTNcKs6|j}|j}|durt|ƒ}t |||t|ƒ|¡dSrI)rWrTrrRrXÚstr)rVrPrUÚ assumptionsrWrTrErErFrX€s z_WildAbstract.__init__cCs|j|j|j|j|jdœS)N©rWrTrSrPrUr`©rVrErErFÚ __getstate__‡s ûz_WildAbstract.__getstate__cKs"| ||¡tj|||fi|¤ŽSrI)Ú _sanitizer]Ú__xnew__)ÚclsrPrUr_rErErFÚ__new__s z_WildAbstract.__new__cCs |j|jfSrI©rPrUrarErErFÚ__getnewargs__”ó z_WildAbstract.__getnewargs__cKstj||fi|¤Ž}|SrI)r1rd)rerPrUr_ÚobjrErErFrd—sz_WildAbstract.__xnew__cs>|jrtƒ ¡|j|j|j|jfStƒ ¡|j|j|jfSrI)rUÚsuperÚ_hashable_contentrSrTrPra©Ú __class__rErFrlœsz_WildAbstract._hashable_contentÚreturncCst|ƒ|j|jdS)Nrg)rMrPrUrarErErFÚ__copy__¢sz_WildAbstract.__copy__cCst|ƒSrI©r^rarErErFÚ__repr__¥sz_WildAbstract.__repr__cCs|jSrI©ÚnamerarErErFÚ__str__¨sz_WildAbstract.__str__)NN)ror])rYrZr[ÚintÚ__annotations__ÚboolrXrbrfrhÚ staticmethodrdrlrprrruÚ __classcell__rErErmrFr]{s      r]c@óeZdZdZdZdS)ÚWildDotr?TN©rYrZr[rWrTrErErErFr|¬ór|c@r{)ÚWildPlusr?FNr}rErErErFr²r~rc@r{)ÚWildStarrFNr}rErErErFr€¸r~r€cCs6t|ƒ}t dd|¡}t dd|¡}t dd|¡}|S)NzWildDot\('(\w+)'\)z\1zWildPlus\('(\w+)'\)z*\1zWildStar\('(\w+)'\))r4ÚreÚsub)ÚexprÚsrErErFÚ _get_srepr¾s r…c@seZdZUeed<eed<dS)ÚReplacementInfoÚ replacementÚinfoN)rYrZr[rrwrErErErFr†Æs  r†c @sØeZdZdZgddfdededefdd„Zded ed e ffd d „Z d e ded ed e ffdd„Z d e d ed e ffdd„Z d e d ed e ffdd„Z ggdfde dee dee ded df dd„Zddefdd„ZdS) ÚReplacera Replacer object to perform multiple pattern matching and subexpression replacements in SymPy expressions. Examples ======== Example to construct a simple first degree equation solver: >>> from sympy.utilities.matchpy_connector import WildDot, Replacer >>> from sympy import Equality, Symbol >>> x = Symbol("x") >>> a_ = WildDot("a_", optional=1) >>> b_ = WildDot("b_", optional=0) The lines above have defined two wildcards, ``a_`` and ``b_``, the coefficients of the equation `a x + b = 0`. The optional values specified indicate which expression to return in case no match is found, they are necessary in equations like `a x = 0` and `x + b = 0`. Create two constraints to make sure that ``a_`` and ``b_`` will not match any expression containing ``x``: >>> from matchpy import CustomConstraint >>> free_x_a = CustomConstraint(lambda a_: not a_.has(x)) >>> free_x_b = CustomConstraint(lambda b_: not b_.has(x)) Now create the rule replacer with the constraints: >>> replacer = Replacer(common_constraints=[free_x_a, free_x_b]) Add the matching rule: >>> replacer.add(Equality(a_*x + b_, 0), -b_/a_) Let's try it: >>> replacer.replace(Equality(3*x + 4, 0)) -4/3 Notice that it will not match equations expressed with other patterns: >>> eq = Equality(3*x, 4) >>> replacer.replace(eq) Eq(3*x, 4) In order to extend the matching patterns, define another one (we also need to clear the cache, because the previous result has already been memorized and the pattern matcher will not iterate again if given the same expression) >>> replacer.add(Equality(a_*x, b_), b_/a_) >>> replacer._matcher.clear() >>> replacer.replace(eq) 4/3 FÚcommon_constraintsÚlambdifyrˆcCs&t ¡|_||_||_||_i|_dSrI)r6ÚManyToOneMatcherÚ_matcherÚ_common_constraintÚ _lambdifyÚ_infoÚ _wildcards)rVrŠr‹rˆrErErFrXs  zReplacer.__init__Ú lambda_strro.cCstdƒt|tƒƒS)Nzfrom sympy import *)ÚexecÚevalÚlocals)rVr’rErErFÚ _get_lambda s zReplacer._get_lambdaÚconstraint_exprÚcondition_templatec CsNdd„| t¡Dƒ}d |¡}t|ƒ}| |¡}t | d|›d|›d¡¡S)NcSsg|]}|j‘qSrErs©Ú.0ÚxrErErFÚ sz3Replacer._get_custom_constraint..ú, úlambda z: (ú))Úatomsr]Újoinr…Úformatr6ÚCustomConstraintr–)rVr—r˜ÚwildsÚ lambdaargsÚfullexprÚ conditionrErErFÚ_get_custom_constraints  ÿzReplacer._get_custom_constraintcCó | |d¡S)Nz ({}) != False©r¨©rVr—rErErFÚ_get_custom_constraint_nonfalseriz(Replacer._get_custom_constraint_nonfalsecCr©)Nz ({}) == Truerªr«rErErFÚ_get_custom_constraint_trueriz$Replacer._get_custom_constraint_trueNrƒÚconditions_trueÚconditions_nonfalsec sæt|ƒ}t|ƒ}ˆjdd…}‡fdd„|Dƒ}‡fdd„|Dƒ}| |¡| |¡tj|g|¢RŽ} ˆjrTdd dd„| t¡Dƒ¡›dt |ƒ›} ˆ  | ¡} | }nˆj   d d „| t ¡Dƒ¡ˆjrjt||ƒ}ˆj | |¡dS) Ncóg|]}ˆ |¡‘qSrE)r­©ršÚcondrarErFrœ#ó ÿz Replacer.add..cr°rE)r¬r±rarErFrœ%r³ržrcss|]}|jVqdSrIrsr™rErErFÚ +s€zReplacer.add..z: cSsi|]}t|ƒ|“qSrErq)ršÚirErErFÚ /sz Replacer.add..)rrŽÚextendr6ÚPatternrr¡r r]r…r–r‘ÚupdaterRrr†rÚadd) rVrƒr‡r®r¯rˆÚ constraintsÚconstraint_conditions_trueÚconstraint_conditions_nonfalseÚpatternr’Ú lambda_exprrErarFrºs( ÿ ÿ  *  z Replacer.addéÿÿÿÿÚ max_countc súg}d}d}|rt|dks||krtd}t |¡D]N\}}zAttˆj |¡ƒƒ\}} ˆjr5|j} | |j ¡n|} ˆj rB| di| ¤Ž} n|   ‡fdd„|   ¡Dƒ¡} tj  ||| ¡}d}Wn tyeYqw|d7}|rt|dks||ksˆjr{||fS|S)NTrFcsi|] \}}ˆj||“qSrE)r‘)ršÚkÚvrarErFr¶Isz$Replacer.replace..r?rE)r6Úpreorder_iter_with_positionÚnextrArÚmatchrr‡ÚappendrˆrÚxreplaceÚitemsÚ functionsÚreplaceÚ StopIteration) rVÚ expressionrÁÚinfosÚreplacedÚ replace_countÚsubexprÚposÚreplacement_dataÚsubstr‡ÚresultrErarFrË4s4 ÿëzReplacer.replace)rÀ)rYrZr[Ú__doc__ÚlistrxrXr^rr,r–r¨r¬r­rrrºrvrËrErErErFr‰Ës"8ÿÿÿ ÿr‰)T)]rÖrÚtypingrrrrrÚsympy.core.sympifyrÚsympy.externalrÚsympy.functionsr r r r r rrrrrÚ%sympy.functions.elementary.hyperbolicrrrrrrrrrrrrÚ(sympy.functions.elementary.trigonometricrr r!r"r#r$Ú'sympy.functions.special.error_functionsr%r&r'r(r)Úsympy.core.addr*Úsympy.core.basicr+Úsympy.core.exprr,Úsympy.core.mulr-Úsympy.core.powerr.Úsympy.core.relationalr/r0Úsympy.core.symbolr1Ú&sympy.functions.elementary.exponentialr2Úsympy.integrals.integralsr3Úsympy.printing.reprr4Úsympy.utilities.decoratorr5r6Ú__doctest_requires__r8r9r:r;Úmatchpy.expressions.functionsr<r=r>ÚregisterrGrQrRr]r|rr€r…r†r‰rErErErFÚsÆ  08                                                                  0