o l hq>@sddlmZmZddlmZddlmZddlmZddl m Z ddl m Z ddl mZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlm Z Gddde!Z"Gddde"eee e eeeeeeeeeZ#dS))gtlt)xrange)SpecialFunctions)RSCache)QuadratureMethods) LaplaceTransformInversionMethods)CalculusMethods)OptimizationMethods) ODEMethods) MatrixMethods)MatrixCalculusMethods)LinearAlgebraMethods)Eigen)IdentificationMethods)VisualizationMethods)libmpc@s eZdZdS)ContextN)__name__ __module__ __qualname__rrc/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/mpmath/ctx_base.pyrsrc@speZdZejZejZddZddZdZdZ ddZ dd Z d d Z d d Z ddZddZddZddZddZddZd?ddZd@ddZdd ZdAd"d#ZdBd$d%ZdCd&d'Zd(d)Zd*d+Zd,d-Zd.d/Zd0d1Zeej Z!eej"Z"eej#Z#eej$Z$eej%Z%eej&Z'eej(Z)eej*Z+eej,Z-dDd3d4Z.dDd5d6Z/d7d8Z0d9d:Z1d;d<Z2d=d>Z3dS)EStandardBaseContextcCsFi|_t|t|t|t|t|t|dSN)_aliasesr__init__rrr r r )ctxrrrr*s     zStandardBaseContext.__init__c Cs@|jD]\}}z t||t||WqtyYqwdSr)ritemssetattrgetattrAttributeError)raliasvaluerrr _init_aliases4s z!StandardBaseContext._init_aliasesFcCstd|dS)NzWarning:)printrmsgrrrwarn@szStandardBaseContext.warncCst|r) ValueErrorr'rrr bad_domainCszStandardBaseContext.bad_domaincCst|dr|jS|S)Nreal)hasattrr,rxrrr_reFs zStandardBaseContext._recCst|dr|jS|jS)Nimag)r-r1zeror.rrr_imKs zStandardBaseContext._imcCs|Srrr.rrr _as_pointsPszStandardBaseContext._as_pointscKs || Srconvert)rr/kwargsrrrfnegSs zStandardBaseContext.fnegcKs||||Srr5rr/yr7rrrfaddVzStandardBaseContext.faddcKs||||Srr5r9rrrfsubYr<zStandardBaseContext.fsubcKs||||Srr5r9rrrfmul\r<zStandardBaseContext.fmulcKs||||Srr5r9rrrfdiv_r<zStandardBaseContext.fdivcCsZ|r|rtdd|D|jStdd|D|jS|r'tdd|D|jSt||jS)Ncss|] }t|dVqdSNabs.0r/rrr ez+StandardBaseContext.fsum..css|]}t|VqdSrrBrDrrrrFfcss|]}|dVqdSr@rrDrrrrFhrH)sumr2)rargsabsolutesquaredrrrfsumbs zStandardBaseContext.fsumNcsL|dur t||}|r|jtfdd|D|jStdd|D|jS)Nc3s |] \}}||VqdSrrrEr/r:cfrrrFpsz+StandardBaseContext.fdot..css|] \}}||VqdSrrrNrrrrFrrG)zipconjrIr2)rxsys conjugaterrOrfdotks  zStandardBaseContext.fdotcCs|j}|D]}||9}q|Sr)one)rrJprodargrrrfprodts zStandardBaseContext.fprodcKst|j||fi|dS)z6 Equivalent to ``print(nstr(x, n))``. N)r&nstr)rr/nr7rrrnprintzszStandardBaseContext.nprintcsdur djz?|}t|}t|krjWS|rCt|}t|j|kr4|jWSt|j|krFd|jWSW|SW|St yut |j ra| fddYSt |drrfdd|DYSY|Sw) a Chops off small real or imaginary parts, or converts numbers close to zero to exact zeros. The input can be a single number or an iterable:: >>> from mpmath import * >>> mp.dps = 15; mp.pretty = False >>> chop(5+1e-10j, tol=1e-9) mpf('5.0') >>> nprint(chop([1.0, 1e-20, 3+1e-18j, -4, 2])) [1.0, 0.0, 3.0, -4.0, 2.0] The tolerance defaults to ``100*eps``. Ndrcs |Srchop)artolrrs z*StandardBaseContext.chop..__iter__csg|]}|qSrr`)rErbrcrr z,StandardBaseContext.chop..)epsr6rCr2_is_complex_typemaxr1r,mpc TypeError isinstancematrixapplyr-)rr/rdabsxpart_tolrrcrras2       zStandardBaseContext.chopc Cs||}|dur|dur|d|j d}}|dur |}n|dur&|}t||}||kr2dSt|}t|}||krF||}||kS||}||kS)a Determine whether the difference between `s` and `t` is smaller than a given epsilon, either relatively or absolutely. Both a maximum relative difference and a maximum difference ('epsilons') may be specified. The absolute difference is defined as `|s-t|` and the relative difference is defined as `|s-t|/\max(|s|, |t|)`. If only one epsilon is given, both are set to the same value. If none is given, both epsilons are set to `2^{-p+m}` where `p` is the current working precision and `m` is a small integer. The default setting typically allows :func:`~mpmath.almosteq` to be used to check for mathematical equality in the presence of small rounding errors. **Examples** >>> from mpmath import * >>> mp.dps = 15 >>> almosteq(3.141592653589793, 3.141592653589790) True >>> almosteq(3.141592653589793, 3.141592653589700) False >>> almosteq(3.141592653589793, 3.141592653589700, 1e-10) True >>> almosteq(1e-20, 2e-20) True >>> almosteq(1e-20, 2e-20, rel_eps=0, abs_eps=0) False NrT)r6ldexpprecrC) rstrel_epsabs_epsdiffabssabsterrrrralmosteqs" ! zStandardBaseContext.almosteqc Gs&t|dkstdt|t|dkstdt|d}d}t|dkr+|d}nt|dkr9|d}|d}t|dkrC|d}||||||}}}|||ks^Jd||krk|dkrhgSt}n|dkrqgSt}g}d}|} |||}|d7}|||r||n |Sqz)aa This is a generalized version of Python's :func:`~mpmath.range` function that accepts fractional endpoints and step sizes and returns a list of ``mpf`` instances. Like :func:`~mpmath.range`, :func:`~mpmath.arange` can be called with 1, 2 or 3 arguments: ``arange(b)`` `[0, 1, 2, \ldots, x]` ``arange(a, b)`` `[a, a+1, a+2, \ldots, x]` ``arange(a, b, h)`` `[a, a+h, a+h, \ldots, x]` where `b-1 \le x < b` (in the third case, `b-h \le x < b`). Like Python's :func:`~mpmath.range`, the endpoint is not included. To produce ranges where the endpoint is included, :func:`~mpmath.linspace` is more convenient. **Examples** >>> from mpmath import * >>> mp.dps = 15; mp.pretty = False >>> arange(4) [mpf('0.0'), mpf('1.0'), mpf('2.0'), mpf('3.0')] >>> arange(1, 2, 0.25) [mpf('1.0'), mpf('1.25'), mpf('1.5'), mpf('1.75')] >>> arange(1, -1, -0.75) [mpf('1.0'), mpf('0.25'), mpf('-0.5')] z+arange expected at most 3 arguments, got %irz+arange expected at least 1 argument, got %irrAz0dt is too small and would cause an infinite loop)lenrmmpfrrappend) rrJrbdtbopresultirwrrrarangesJ      "   zStandardBaseContext.arangecs"t|dkr||d||d}t|d}n(t|dkr;t|dds*J|dj|dj}t|d}ntdt||dkrKtdd|vsS|drz|dkr]|gS|||dfd d t|D}||d <|S|||fd d t|D}|S) a ``linspace(a, b, n)`` returns a list of `n` evenly spaced samples from `a` to `b`. The syntax ``linspace(mpi(a,b), n)`` is also valid. This function is often more convenient than :func:`~mpmath.arange` for partitioning an interval into subintervals, since the endpoint is included:: >>> from mpmath import * >>> mp.dps = 15; mp.pretty = False >>> linspace(1, 4, 4) [mpf('1.0'), mpf('2.0'), mpf('3.0'), mpf('4.0')] You may also provide the keyword argument ``endpoint=False``:: >>> linspace(1, 4, 4, endpoint=False) [mpf('1.0'), mpf('1.75'), mpf('2.5'), mpf('3.25')] rrrrA_mpi_z*linspace expected 2 or 3 arguments, got %izn must be greater than 0endpointcg|]}|qSrrrErrbsteprrrgGrhz0StandardBaseContext.linspace..crrrrrrrrgKrh) rrintr-rbrrmr*r)rrJr7rr]r:rrrlinspace s0     zStandardBaseContext.linspacecK$|j|fi||j|fi|fSr)cossinrzr7rrrcos_sinN$zStandardBaseContext.cos_sincKrr)cospisinpirrrr cospi_sinpiQrzStandardBaseContext.cospi_sinpicCstd|dd|S)Nig?rs)r)rprrr_default_hyper_maxprecTsz*StandardBaseContext._default_hyper_maxprecrc Cs|j}z^d} ||d|_|j}|j}d}|D](}||7}||s=|r=||} t|| }||} | | |jkr=n|d7}q|| } | | krKn| |ksR|jrSn |t|j| 7}q|W||_S||_wN rr)runinfr2magrk_fixed_precisionmin) rterms check_stepru extraprecmax_magrvktermterm_magsum_mag cancellationrrrsum_accuratelyas4      z"StandardBaseContext.sum_accuratelycCs|j}zcd} ||d|_|j}|j}|}d}|D]+} || 9}| |} ||sB|| } t|| }|||} | |jkrBn|d7}q|| } | | krPn| |ksW|jrXn |t|j| 7}q|W||_S||_wr)rurrWrrkrr)rfactorsrrurrrWrvrfactorrrrrrrrmul_accurately}s8     z"StandardBaseContext.mul_accuratelycCs||||S)aConverts `x` and `y` to mpmath numbers and evaluates `x^y = \exp(y \log(x))`:: >>> from mpmath import * >>> mp.dps = 30; mp.pretty = True >>> power(2, 0.5) 1.41421356237309504880168872421 This shows the leading few digits of a large Mersenne prime (performing the exact calculation ``2**43112609-1`` and displaying the result in Python would be very slow):: >>> power(2, 43112609)-1 3.16470269330255923143453723949e+12978188 r5)rr/r:rrrpowerszStandardBaseContext.powercCs ||Sr)zeta)rr]rrr _zeta_ints zStandardBaseContext._zeta_intcsdgfdd}|S)a Return a wrapped copy of *f* that raises ``NoConvergence`` when *f* has been called more than *N* times:: >>> from mpmath import * >>> mp.dps = 15 >>> f = maxcalls(sin, 10) >>> print(sum(f(n) for n in range(10))) 1.95520948210738 >>> f(10) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... NoConvergence: maxcalls: function evaluated 10 times rcs8dd7<dkrd|i|S)Nrrz%maxcalls: function evaluated %i times) NoConvergence)rJr7Ncounterrfrrf_maxcalls_wrappeds z8StandardBaseContext.maxcalls..f_maxcalls_wrappedr)rrrrrrrmaxcallsszStandardBaseContext.maxcallscs(ifdd}j|_j|_|S)a Return a wrapped copy of *f* that caches computed values, i.e. a memoized copy of *f*. Values are only reused if the cached precision is equal to or higher than the working precision:: >>> from mpmath import * >>> mp.dps = 15; mp.pretty = True >>> f = memoize(maxcalls(sin, 1)) >>> f(2) 0.909297426825682 >>> f(2) 0.909297426825682 >>> mp.dps = 25 >>> f(2) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... NoConvergence: maxcalls: function evaluated 1 times cs`|r |t|f}n|}j}|vr!|\}}||kr!| S|i|}||f|<|Sr)tuplerru)rJr7keyrucpreccvaluer$rrf_cacherrf_cacheds  z-StandardBaseContext.memoize..f_cached)r__doc__)rrrrrrmemoizes  zStandardBaseContext.memoize)FF)NF)r[r)NN)r)4rrrrr ComplexResultrr%rverboser)r+r0r3r4r8r;r=r>r?rMrVrZr^rar~rrrrr staticmethodgcd_gcd list_primesisprimebernfracmoebiusifac_ifaceulernum _eulernum stirling1 _stirling1 stirling2 _stirling2rrrrrrrrrrrsV      $3I.             rN)$operatorrr libmp.backendrfunctions.functionsrfunctions.rszetarcalculus.quadraturercalculus.inverselaplacer calculus.calculusr calculus.optimizationr calculus.odesr matrices.matricesr matrices.calculusrmatrices.linalgrmatrices.eigenridentificationr visualizationrrobjectrrrrrrs@