+
    ‰°³jq>  ã                   ó  € ^ RI HtHt ^RIHt ^RIHt ^RIHt ^RI	H
t
 ^RIHt ^RIHt ^RIHt ^R	IHt ^R
IHt ^RIHt ^RIHt ^RIHt ^RIHt ^RIHt ^RIH t   ! R R]!4      t" ! R R]"]]]
]]]]]]]]]]4      t#R# )é    )ÚgtÚlt)Úxrange)ÚSpecialFunctions)ÚRSCache)ÚQuadratureMethods)Ú LaplaceTransformInversionMethods)ÚCalculusMethods)ÚOptimizationMethods)Ú
ODEMethods)ÚMatrixMethods)ÚMatrixCalculusMethods)ÚLinearAlgebraMethods)ÚEigen)ÚIdentificationMethods)ÚVisualizationMethods)Úlibmpc                   ó   € ] tR t^tRtR# )ÚContext© N)Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Ú__static_attributes__r   ó    ÚP/home/luca/screen-checking/.venv/lib/python3.14/site-packages/mpmath/ctx_base.pyr   r      s   † Ûr   r   c                   óf  a € ] tR t^t o ]P
                  t]P                  tR tR tRt	Rt
R tR tR tR tR tR	 tR
 tR tR tR tR!R ltR"R ltR tR#R ltR$R ltR%R ltR tR tR tR tR t] ! ]PB                  4      t"] ! ]PF                  4      t#] ! ]PH                  4      t$] ! ]PJ                  4      t%] ! ]PL                  4      t&] ! ]PN                  4      t(] ! ]PR                  4      t*] ! ]PV                  4      t,] ! ]PZ                  4      t.R&R lt/R&R lt0R t1R t2R t3R t4R t5V t6R# )'ÚStandardBaseContextc                ó  € / V n         \        P                  ! V 4       \        P                  ! V 4       \        P                  ! V 4       \
        P                  ! V 4       \        P                  ! V 4       \        P                  ! V 4       R # ©N)Ú_aliasesr   Ú__init__r   r   r	   r
   r   )Úctxs   &r   r#   ÚStandardBaseContext.__init__*   s]   € ØˆŒä×!Ò! #Ô&Ü×Ò˜ÔÜ×"Ò" 3Ô'Ü(×1Ò1°#Ô6Ü× Ò  Ô%Ü×Ò˜sÖ#r   c           	     óœ   € V P                   P                  4        F  w  r \        W\        W4      4       K  	  R #   \         d     K/  i ; ir!   )r"   ÚitemsÚsetattrÚgetattrÚAttributeError)r$   ÚaliasÚvalues   &  r   Ú_init_aliasesÚ!StandardBaseContext._init_aliases4   sC   € ØŸL™L×.Ñ.Ö0‰LˆEðÜ˜¤G¨CÓ$7Ö8ó 1øô "ô Úðús   ¡<¼AÁ
AFc                ó   € \        R V4       R# )zWarning:N)Úprint©r$   Úmsgs   &&r   ÚwarnÚStandardBaseContext.warn@   s   € Üˆj˜#Ör   c                ó   € \        V4      hr!   )Ú
ValueErrorr1   s   &&r   Ú
bad_domainÚStandardBaseContext.bad_domainC   s   € Ü˜‹oÐr   c                óB   € \        VR 4      '       d   VP                  # V# )Úreal)Úhasattrr:   ©r$   Úxs   &&r   Ú_reÚStandardBaseContext._reF   s   € Ü�1�f×ÒØ—6‘6ˆMØˆr   c                óV   € \        VR 4      '       d   VP                  # V P                  # )Úimag)r;   rA   Úzeror<   s   &&r   Ú_imÚStandardBaseContext._imK   s!   € Ü�1�f×ÒØ—6‘6ˆMØ�x‰xˆr   c                ó   € V# r!   r   r<   s   &&r   Ú
_as_pointsÚStandardBaseContext._as_pointsP   s   € Øˆr   c                ó&   € V P                  V4      ) # r!   ©Úconvert)r$   r=   Úkwargss   &&,r   ÚfnegÚStandardBaseContext.fnegS   s   € Ø—‘˜A“ˆÐr   c                óP   € V P                  V4      V P                  V4      ,           # r!   rI   ©r$   r=   ÚyrK   s   &&&,r   ÚfaddÚStandardBaseContext.faddV   ó   € Ø�{‰{˜1‹~˜cŸk™k¨!›nÕ,Ð,r   c                óP   € V P                  V4      V P                  V4      ,
          # r!   rI   rO   s   &&&,r   ÚfsubÚStandardBaseContext.fsubY   rS   r   c                óP   € V P                  V4      V P                  V4      ,          # r!   rI   rO   s   &&&,r   ÚfmulÚStandardBaseContext.fmul\   rS   r   c                óP   € V P                  V4      V P                  V4      ,          # r!   rI   rO   s   &&&,r   ÚfdivÚStandardBaseContext.fdiv_   rS   r   c                ó
  € V'       dC   V'       d   \        R  V 4       V P                  4      # \        R V 4       V P                  4      # V'       d   \        R V 4       V P                  4      # \        WP                  4      # )c              3   óF   "  € T F  p\        V4      ^,          x € K  	  R# 5i©é   N©Úabs©Ú.0r=   s   & r   Ú	<genexpr>Ú+StandardBaseContext.fsum.<locals>.<genexpr>e   s   é € Ð4©t¨!œC ›F AŸIšI«tùs   ‚!c              3   ó8   "  € T F  p\        V4      x € K  	  R # 5ir!   ra   rc   s   & r   re   rf   f   s   é € Ð-© 1œ˜AŸ˜«ùs   ‚c              3   ó2   "  € T F  q^,          x € K  	  R# 5ir_   r   rc   s   & r   re   rf   h   s   é € Ð+¡d ˜1Ÿš£dùs   ‚)ÚsumrB   )r$   ÚargsÚabsoluteÚsquareds   &&&&r   ÚfsumÚStandardBaseContext.fsumb   s_   € ßßÜÑ4©tÓ4°c·h±hÓ?Ð?ÜÑ-©Ó-¨s¯x©xÓ8Ð8ßÜÑ+¡dÓ+¨S¯X©XÓ6Ð6Ü�4Ÿ™Ó"Ð"r   Nc                óÄ   a€ Ve   \        W4      pV'       d-   V P                  o\        V3R lV 4       V P                  4      # \        R V 4       V P                  4      # )Nc              3   óF   <"  € T F  w  rVS! V4      ,          x € K  	  R # 5ir!   r   )rd   r=   rP   Úcfs   &  €r   re   Ú+StandardBaseContext.fdot.<locals>.<genexpr>p   s   øé € Ð0©R¡E Q˜™"˜Q›%Ÿš«Rùs   ƒ!c              3   ó6   "  € T F  w  rW,          x € K  	  R # 5ir!   r   )rd   r=   rP   s   &  r   re   rr   r   s   é € Ð,©¡ ˜Ÿš«ùs   ‚)ÚzipÚconjri   rB   )r$   ÚxsÚysÚ	conjugaterq   s   &&&&@r   ÚfdotÚStandardBaseContext.fdotk   sK   ø€ ØŠ>Ü�R“ˆBßØ—‘ˆBÜÔ0©RÓ0°#·(±(Ó;Ð;äÑ,©Ó,¨c¯h©hÓ7Ð7r   c                ó@   € V P                   pV F  pW#,          pK  	  V# r!   )Úone)r$   rj   ÚprodÚargs   &&  r   ÚfprodÚStandardBaseContext.fprodt   s!   € Ø�w‰wˆÛˆCØ�KŠDñ àˆr   c                ó>   € \        V P                  ! W3/ VB 4       R# )z&
Equivalent to ``print(nstr(x, n))``.
N)r0   Únstr)r$   r=   ÚnrK   s   &&&,r   ÚnprintÚStandardBaseContext.nprintz   s   € ô 	ˆc�hŠh�qÑ&˜vÑ&Ö'r   c                óº  a a€ Sf   ^dS P                   ,          o S P                  V4      p\        V4      p\        V4      S8  d   S P                  # S P	                  V4      '       dp   \        SVS,          4      p\        VP                  4      V8  d   VP                  # \        VP                  4      V8  d   S P                  ^ VP                  4      # V#   \         du    \        TS P                  4      '       d   TP                  T T3R l4      u # \        TR4      '       d+   T Uu. uF  pS P                  TS4      NK  	  Mu upi upu #  T# i ; i)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``.
c                 ó(   <€ SP                  V S4      # r!   )Úchop)Úar$   Útols   &€€r   Ú<lambda>Ú*StandardBaseContext.chop.<locals>.<lambda>Ÿ   s   ø€ ¨¯©°!°SÔ)9r   Ú__iter__)ÚepsrJ   rb   rB   Ú_is_complex_typeÚmaxrA   r:   ÚmpcÚ	TypeErrorÚ
isinstanceÚmatrixÚapplyr;   rˆ   )r$   r=   rŠ   ÚabsxÚpart_tolr‰   s   f&f   r   rˆ   ÚStandardBaseContext.chop€   s  ù€ ð Š;Ø�c—g‘g•+ˆCð	5Ø—‘˜A“ˆAÜ�q“6ˆDÜ�1‹v˜Œ|Ø—x‘x�Ø×#Ñ# A×&Ò&ä˜s D¨¥HÓ-�Ü�q—v‘v“; Ô)ØŸ6™6�MÜ�q—v‘v“; Ô)ØŸ7™7 1 a§f¡fÓ-Ð-ð ˆøô ô 	5Ü˜!˜SŸZ™Z×(Ò(Ø—w‘wÕ9Ó:Ò:Ü�q˜*×%Ò%Ù23Ó4±!¨Q˜Ÿ™  CÖ(²!ùÔ4Ò4ð &àˆð	5ús5   ›7C ÁC Á*8C Â#5C Ã=EÄEÄ0EÅ	EÅEc                ó2  € V P                  V4      pVf*   Vf&   V P                  ^V P                  ) ^,           4      ;r4Vf   TpMVf   Tp\        W,
          4      pWT8:  d   R# \        V4      p\        V4      pWg8  d   WW,          pWƒ8*  # WV,          pWƒ8*  # )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

T)rJ   ÚldexpÚprecrb   )	r$   ÚsÚtÚrel_epsÚabs_epsÚdiffÚabssÚabstÚerrs	   &&&&&    r   ÚalmosteqÚStandardBaseContext.almosteq¤   s˜   € ðB �K‰K˜‹NˆØŠ?˜wšØ #§	¡	¨!¨c¯h©h¨Y°q­[Ó 9Ð9ˆGØŠ?Ø‰GØŠ_ØˆGÜ�1•3‹xˆØŒ?ÙÜ�1‹vˆÜ�1‹vˆØŒ;Ø•)ˆCð ‰~Ðð •)ˆCØ‰~Ðr   c                ó¼  € \        V4      ^8:  g   \        R\        V4      ,          4      h\        V4      ^8¼  g   \        R\        V4      ,          4      h^ p^p\        V4      ^8X  d   V^ ,          pM"\        V4      ^8¼  d   V^ ,          pV^,          p\        V4      ^8X  d
   V^,          pV P                  V4      V P                  X4      V P                  V4      r4pW#,           V8w  g   Q R4       hW$8”  d   V^ 8”  d   . # \        pMV^ 8  d   . # \        p. p^ pTp W#V,          ,           pV^,          pV! W„4      '       d   VP                  V4       K:   V# )a¡  
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 %iz+arange expected at least 1 argument, got %iz0dt is too small and would cause an infinite loop)Úlenr’   Úmpfr   r   Úappend)	r$   rj   r‰   ÚdtÚbÚopÚresultÚir�   s	   &*       r   ÚarangeÚStandardBaseContext.arange×   sE  € ô@ �4‹y˜AŒ~ÜÐIÜ! $›iõ(ó )ð )ä�4‹y˜AŒ~ÜÐIÜ! $›iõ(ó )ð )ð ˆØˆäˆt‹9˜Œ>Ø�Q•‰AÜ�‹Y˜!Œ^Ø�Q•ˆAØ�Q•ˆAÜˆt‹9˜Œ>Ø�a•ˆBØ—7‘7˜1“:˜sŸw™w q›z¨3¯7©7°2«;ˆbˆØ�v˜Œ{ÐNÐNÓNˆ{àŒ5Ø�AŒvØ�	Ü‰Bà�AŒvØ�	ÜˆBàˆØˆØˆØØ�q•D•ˆAØ��FˆAÙ�!�xŠxØ—‘˜aÖ àØˆr   c                ón  € \        V4      ^8X  dD   V P                  V^ ,          4      pV P                  V^,          4      p\        V^,          4      pM\        V4      ^8X  dU   \        V^ ,          R4      '       g   Q hV^ ,          P                  pV^ ,          P
                  p\        V^,          4      pM\        R\        V4      ,          4      hV^8  d   \        R4      hRV9   d   VR,          '       dl   V^8X  d   V P                  V4      .# WC,
          V P                  V^,
          4      ,          p\        V4       Uu. uF  qwV,          V,           NK  	  ppWHR&   V# WC,
          V P                  V4      ,          p\        V4       Uu. uF  qwV,          V,           NK  	  ppV# u upi u upi )aT  
``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')]

Ú_mpi_z*linspace expected 2 or 3 arguments, got %izn must be greater than 0Úendpointéÿÿÿÿ)	r§   r¨   Úintr;   r‰   r«   r’   r6   r   )	r$   rj   rK   r‰   r«   rƒ   Ústepr®   rP   s	   &*,      r   ÚlinspaceÚStandardBaseContext.linspace   sl  € ô* ˆt‹9˜Œ>Ø—‘˜˜Q�Ó ˆAØ—‘˜˜Q�Ó ˆAÜ�D˜•G“‰AÜ�‹Y˜!Œ^Ü˜4 �7 G×,Ò,Ð,Ð,Ø�Q•—	‘	ˆAØ�Q•—	‘	ˆAÜ�D˜•G“‰AäÐHÜ! $›iõ(ó )ð )àˆqŒ5ÜÐ7Ó8Ð8Ø˜VÔ# v¨j×'9Ô'9Ø�AŒvØŸ™ ›
�|Ð#Ø•E˜SŸW™W Q¨¥U›^Õ+ˆDÜ%+¨A¤YÓ/¡Y �4•˜!—�¡YˆAÐ/Øˆb‰Eð ˆð •E˜SŸW™W Q›ZÕ'ˆDÜ%+¨A¤YÓ/¡Y �4•˜!—�¡YˆAÐ/Øˆùò 0ùò 0s   ÅF-ÆF2c                óN   € V P                   ! V3/ VB V P                  ! V3/ VB 3# r!   )ÚcosÚsin©r$   ÚzrK   s   &&,r   Úcos_sinÚStandardBaseContext.cos_sinN  s)   € Ø�wŠw�qÑ#˜FÑ# S§W¢W¨QÑ%9°&Ñ%9Ð9Ð9r   c                óN   € V P                   ! V3/ VB V P                  ! V3/ VB 3# r!   )ÚcospiÚsinpir¼   s   &&,r   Úcospi_sinpiÚStandardBaseContext.cospi_sinpiQ  s)   € Ø�yŠy˜Ñ%˜fÑ% s§y¢y°Ñ'=°fÑ'=Ð=Ð=r   c                óP   € \        R VR,          ,          ^V,          ,           4      # )iè  g      Ð?)rµ   )r$   Úps   &&r   Ú_default_hyper_maxprecÚ*StandardBaseContext._default_hyper_maxprecT  s   € Ü�4˜!˜T�'•> A a¥CÕ'Ó(Ð(r   c                ó*  € V P                   p ^
p W4,           ^,           V n         V P                  pV P                  p^ pV! 4        Fp  pWh,          pWr,          '       gO   V'       dG   V P                  V4      p	\	        WY4      pV P                  V4      p
W©,
          V P                   8”  d    MV^,          pKr  	  VX
,
          pW»8w  d   M8W´8  g   V P
                  '       d   MV\        V P                   V4      ,          pKò  VW0n         #   Y0n         i ; i©é
   )r›   ÚninfrB   Úmagr�   Ú_fixed_precisionÚmin)r$   ÚtermsÚ
check_stepr›   Ú	extraprecÚmax_magrœ   ÚkÚtermÚterm_magÚsum_magÚcancellations   &&&         r   Úsum_accuratelyÚ"StandardBaseContext.sum_accuratelya  så   € Ø�x‰xˆð	ØˆIØØÕ+¨aÕ/�”ØŸ(™(�Ø—H‘H�Ø�Ù!žG�DØ•I�AØŸNœN·Ø#&§7¡7¨4£=˜Ü"% gÓ"8˜Ø"%§'¡'¨!£*˜Ø"Õ-°·±Ô8Ù!Ø˜•F’Añ $ð  '¨Õ0�ØÔ/ØØÔ+¨s×/C×/CÐ/CØØœS §¡¨<Ó8Õ8’	Øà�Hø�t�Hús   ŽAD
 Á'A:D
 Ã"!D
 Ä
Dc                ó0  € V P                   p ^
p W4,           ^,           V n         V P                  pV P                  pTp^ pV! 4        Fq  p	Wy,          pW–,
          p
W‚,          '       gH   V P                  V
4      p\	        W[4      pV P                  Wv,
          4      pV) V P                   8”  d    MV^,          pKs  	  VX,
          pWÝ8w  d   M8WÔ8  g   V P
                  '       d   MV\        V P                   V4      ,          pKõ  VW0n         #   Y0n         i ; irÊ   )r›   rÌ   r|   rÍ   r�   rÎ   rÏ   )r$   ÚfactorsrÑ   r›   rÒ   rÓ   r|   rœ   rÔ   ÚfactorrÕ   rÖ   r×   rØ   s   &&&           r   Úmul_accuratelyÚ"StandardBaseContext.mul_accurately}  sò   € Ø�x‰xˆð	ØˆIØØÕ+¨aÕ/�”ØŸ(™(�Ø—g‘g�Ø�Ø�Ù%ži�FØ•K�AØ!�<�DØŸNœNØ#&§7¡7¨4£=˜Ü"% gÓ"8˜Ø"%§'¡'¨!­%£.˜ð %˜9 s§x¡xÔ/Ù!Ø˜•F’Añ (ð  '¨Õ0�ØÔ/ØØÔ+¨s×/C×/CÐ/CØØœS §¡¨<Ó8Õ8’	Øà�Hø�t�Hús   ŽCD Ã%!D ÄDc                óP   € V P                  V4      V P                  V4      ,          # )aÄ  Converts `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
rI   )r$   r=   rP   s   &&&r   ÚpowerÚStandardBaseContext.power�  s   € ð  �{‰{˜1‹~ §¡¨Q£Õ/Ð/r   c                ó$   € V P                  V4      # r!   )Úzeta)r$   rƒ   s   &&r   Ú	_zeta_intÚStandardBaseContext._zeta_int¯  s   € Ø�x‰x˜‹{Ðr   c                ó&   a aaa€ ^ .oVVV V3R lpV# )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

c                  óŠ   <€ S^ ;;,          ^,          uu&   S^ ,          S8”  d   SP                  RS,          4      hS! V / VB # )r   z%maxcalls: function evaluated %i times)ÚNoConvergence)rj   rK   ÚNÚcounterr$   Úfs   *,€€€€r   Úf_maxcalls_wrappedÚ8StandardBaseContext.maxcalls.<locals>.f_maxcalls_wrappedÃ  sC   ø€ Ø�A�J˜!�O‹JØ�q�z˜AŒ~Ø×'Ñ'Ð(OÐRSÕ(SÓTÐTÙ�dÐ%˜fÑ%Ð%r   r   )r$   rì   rê   rí   rë   s   fff @r   ÚmaxcallsÚStandardBaseContext.maxcalls²  s   û€ ð  �#ˆ÷	&ð 	&ð
 "Ð!r   c                ód   a aa€ / oV VV3R lpSP                   Vn         SP                  Vn        V# )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

c                  ó¾   <€ V'       d   V \        VP                  4       4      3pMT pSP                  pVS	9   d   S	V,          w  rEWC8¼  d   V5# S! V / VB pW63S	V&   V# r!   )Útupler'   r›   )
rj   rK   Úkeyr›   ÚcprecÚcvaluer,   r$   rì   Úf_caches
   *,     €€€r   Úf_cachedÚ-StandardBaseContext.memoize.<locals>.f_cachedß  sf   ø€ ßØœE &§,¡,£.Ó1Ð1‘à�Ø—8‘8ˆDØ�gŒ~Ø '¨¥‘�Ø”=Ø"˜7�NÙ�tÐ&˜vÑ&ˆEØ ˜=ˆG�C‰LØˆLr   )r   Ú__doc__)r$   rì   rø   r÷   s   ff @r   ÚmemoizeÚStandardBaseContext.memoizeÊ  s.   ú€ ð( ˆ÷	ð ŸJ™JˆÔØŸ9™9ˆÔØˆr   r   )FF)NF)é   r!   )NN)é   )7r   r   r   r   r   ré   ÚComplexResultr#   r-   rÎ   Úverboser3   r7   r>   rC   rF   rL   rQ   rU   rX   r[   rm   ry   r   r„   rˆ   r¤   r¯   r·   r¾   rÃ   rÇ   ÚstaticmethodÚgcdÚ_gcdÚlist_primesÚisprimeÚbernfracÚmoebiusÚifacÚ_ifacÚeulernumÚ	_eulernumÚ	stirling1Ú
_stirling1Ú	stirling2Ú
_stirling2rÙ   rÞ   rá   rå   rï   rû   r   Ú__classdictcell__)Ú__classdict__s   @r   r   r      sJ  ø‡ € ð ×'Ñ'€MØ×'Ñ'€Mò$òð Ðð €Gòòòò
ò
òò-ò-ò-ò-ô#ô8òô(ô"ôH1òfGòR,ò\:ò>ò)ñ ˜Ÿ	™	Ó"€DÙ˜u×0Ñ0Ó1€KÙ˜5Ÿ=™=Ó)€GÙ˜EŸN™NÓ+€HÙ˜5Ÿ=™=Ó)€GÙ˜Ÿ™Ó$€EÙ˜UŸ^™^Ó,€IÙ˜eŸo™oÓ.€JÙ˜eŸo™oÓ.€Jôô8ò@0ò$ò"÷0$ð $r   r   N)$Úoperatorr   r   Úlibmp.backendr   Úfunctions.functionsr   Úfunctions.rszetar   Úcalculus.quadraturer   Úcalculus.inverselaplacer	   Úcalculus.calculusr
   Úcalculus.optimizationr   Úcalculus.odesr   Úmatrices.matricesr   Úmatrices.calculusr   Úmatrices.linalgr   Úmatrices.eigenr   Úidentificationr   Úvisualizationr   Ú r   Úobjectr   r   r   r   r   Ú<module>r#     sv   ðß å !å 1Ý %Ý 2Ý EÝ .Ý 6Ý %Ý ,Ý 4Ý 1Ý !Ý 1Ý /å ô	ˆfô 	ôV˜'ØØØØ$ØØØØØ	ØØØØöVr   