Ë
    3^(hq>  ã                   ó  — d dl mZmZ ddlmZ ddlmZ ddlmZ ddl	m
Z
 ddlmZ ddlmZ dd	lmZ dd
lmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z   G d„ de!«      Z" G d„ de"eee
eeeeeeeeee«      Z#y)é    )ÚgtÚlté   )Úxrange)ÚSpecialFunctions)ÚRSCache)ÚQuadratureMethods)Ú LaplaceTransformInversionMethods)ÚCalculusMethods)ÚOptimizationMethods)Ú
ODEMethods)ÚMatrixMethods)ÚMatrixCalculusMethods)ÚLinearAlgebraMethods)ÚEigen)ÚIdentificationMethods)ÚVisualizationMethods)Úlibmpc                   ó   — e Zd Zy)ÚContextN)Ú__name__Ú
__module__Ú__qualname__© ó    úM/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/mpmath/ctx_base.pyr   r      s   „ Ør   r   c                   óD  — e Zd Zej                  Zej
                  Zd„ Zd„ ZdZdZ	d„ Z
d„ Zd„ Zd„ Zd„ Zd	„ Zd
„ Zd„ Zd„ Zd„ Zd d„Zd!d„Zd„ Zd"d„Zd#d„Zd$d„Zd„ Zd„ Zd„ Zd„ Zd„ Z eej@                  «      Z! eejD                  «      Z" eejF                  «      Z# eejH                  «      Z$ eejJ                  «      Z% eejL                  «      Z' eejP                  «      Z) eejT                  «      Z+ eejX                  «      Z-d%d„Z.d%d„Z/d„ Z0d„ Z1d„ Z2d„ Z3y)&ÚStandardBaseContextc                 ó  — i | _         t        j                  | «       t        j                  | «       t	        j                  | «       t        j                  | «       t        j                  | «       t        j                  | «       y ©N)Ú_aliasesr   Ú__init__r   r	   r
   r   r   )Úctxs    r   r"   zStandardBaseContext.__init__*   s]   € ØˆŒä×!Ñ! #Ô&Ü×Ñ˜ÔÜ×"Ñ" 3Ô'Ü(×1Ñ1°#Ô6Ü× Ñ  Ô%Ü×Ñ˜sÕ#r   c           	      ó–   — | j                   j                  «       D ]  \  }}	 t        | |t        | |«      «       Œ y # t        $ r Y Œ,w xY wr    )r!   ÚitemsÚsetattrÚgetattrÚAttributeError)r#   ÚaliasÚvalues      r   Ú_init_aliasesz!StandardBaseContext._init_aliases4   sN   € ØŸL™L×.Ñ.Ó0ò 	‰LˆE�5ðÜ˜˜U¤G¨C°Ó$7Õ8ñ	øô "ò Ùðús   ¢<¼	AÁAFc                 ó   — t        d|«       y )NzWarning:)Úprint©r#   Úmsgs     r   ÚwarnzStandardBaseContext.warn@   s   € Üˆj˜#Õr   c                 ó   — t        |«      ‚r    )Ú
ValueErrorr.   s     r   Ú
bad_domainzStandardBaseContext.bad_domainC   s   € Ü˜‹oÐr   c                 ó6   — t        |d«      r|j                  S |S )NÚreal)Úhasattrr5   ©r#   Úxs     r   Ú_rezStandardBaseContext._reF   s   € Ü�1�fÔØ—6‘6ˆMØˆr   c                 óJ   — t        |d«      r|j                  S | j                  S )NÚimag)r6   r;   Úzeror7   s     r   Ú_imzStandardBaseContext._imK   s   € Ü�1�fÔØ—6‘6ˆMØ�x‰xˆr   c                 ó   — |S r    r   r7   s     r   Ú
_as_pointszStandardBaseContext._as_pointsP   s   € Øˆr   c                 ó&   — | j                  |«       S r    ©Úconvert)r#   r8   Úkwargss      r   ÚfnegzStandardBaseContext.fnegS   s   € Ø—‘˜A“ˆÐr   c                 óH   — | j                  |«      | j                  |«      z   S r    rA   ©r#   r8   ÚyrC   s       r   ÚfaddzStandardBaseContext.faddV   ó   € Ø�{‰{˜1‹~˜cŸk™k¨!›nÑ,Ð,r   c                 óH   — | j                  |«      | j                  |«      z
  S r    rA   rF   s       r   ÚfsubzStandardBaseContext.fsubY   rI   r   c                 óH   — | j                  |«      | j                  |«      z  S r    rA   rF   s       r   ÚfmulzStandardBaseContext.fmul\   rI   r   c                 óH   — | j                  |«      | j                  |«      z  S r    rA   rF   s       r   ÚfdivzStandardBaseContext.fdiv_   rI   r   c                 óè   — |r<|rt        d„ |D «       | j                  «      S t        d„ |D «       | j                  «      S |rt        d„ |D «       | j                  «      S t        || j                  «      S )Nc              3   ó8   K  — | ]  }t        |«      d z  –— Œ y­w©é   N©Úabs©Ú.0r8   s     r   ú	<genexpr>z+StandardBaseContext.fsum.<locals>.<genexpr>e   s   è ø€ Ò4¨!œC ›F A�IÑ4ùs   ‚c              3   ó2   K  — | ]  }t        |«      –— Œ y ­wr    rT   rV   s     r   rX   z+StandardBaseContext.fsum.<locals>.<genexpr>f   s   è ø€ Ò- 1œ˜AŸÑ-ùs   ‚c              3   ó&   K  — | ]	  }|d z  –— Œ y­wrR   r   rV   s     r   rX   z+StandardBaseContext.fsum.<locals>.<genexpr>h   s   è ø€ Ò+ ˜˜1�Ñ+ùs   ‚)Úsumr<   )r#   ÚargsÚabsoluteÚsquareds       r   ÚfsumzStandardBaseContext.fsumb   sa   € ÙÙÜÑ4¨tÔ4°c·h±hÓ?Ð?ÜÑ-¨Ô-¨s¯x©xÓ8Ð8ÙÜÑ+ dÔ+¨S¯X©XÓ6Ð6Ü�4˜Ÿ™Ó"Ð"r   Nc                 ó´   ‡— |�t        ||«      }|r+| j                  Št        ˆfd„|D «       | j                  «      S t        d„ |D «       | j                  «      S )Nc              3   ó:   •K  — | ]  \  }}| ‰|«      z  –— Œ y ­wr    r   )rW   r8   rG   Úcfs      €r   rX   z+StandardBaseContext.fdot.<locals>.<genexpr>p   s   øè ø€ Ò0¡E Q q˜™"˜Q›%�Ñ0ùs   ƒc              3   ó,   K  — | ]  \  }}||z  –— Œ y ­wr    r   )rW   r8   rG   s      r   rX   z+StandardBaseContext.fdot.<locals>.<genexpr>r   s   è ø€ Ò,¡  1˜˜!�Ñ,ùs   ‚)ÚzipÚconjr[   r<   )r#   ÚxsÚysÚ	conjugaterb   s       @r   ÚfdotzStandardBaseContext.fdotk   sM   ø€ Øˆ>Ü�R˜“ˆBÙØ—‘ˆBÜÓ0¨RÔ0°#·(±(Ó;Ð;äÑ,¨Ô,¨c¯h©hÓ7Ð7r   c                 ó6   — | j                   }|D ]  }||z  }Œ	 |S r    )Úone)r#   r\   ÚprodÚargs       r   ÚfprodzStandardBaseContext.fprodt   s(   € Ø�w‰wˆØò 	ˆCØ�C‰K‰Dð	àˆr   c                 ó>   — t         | j                  ||fi |¤Ž«       y)z6
        Equivalent to ``print(nstr(x, n))``.
        N)r-   Únstr)r#   r8   ÚnrC   s       r   ÚnprintzStandardBaseContext.nprintz   s   € ô 	ˆhˆc�h‰h�q˜!Ñ&˜vÑ&Õ'r   c                 ól  ‡ ‡— ‰€d‰ j                   z  Š	 ‰ j                  |«      }t        |«      }t        |«      ‰k  r‰ j                  S ‰ j	                  |«      rgt        ‰|‰z  «      }t        |j                  «      |k  r|j                  S t        |j                  «      |k  r‰ j                  d|j                  «      S |S # t        $ re t        |‰ j                  «      r|j                  ˆ ˆfd„«      cY S t        |d«      r(|D �cg c]  }‰ j                  |‰«      ‘Œ nc c}w c}cY S Y |S w xY w)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``.
        éd   r   c                 ó(   •— ‰j                  | ‰«      S r    )Úchop)Úar#   Útols    €€r   ú<lambda>z*StandardBaseContext.chop.<locals>.<lambda>Ÿ   s   ø€ ¨¯©°!°SÓ)9€ r   Ú__iter__)ÚepsrB   rU   r<   Ú_is_complex_typeÚmaxr;   r5   ÚmpcÚ	TypeErrorÚ
isinstanceÚmatrixÚapplyr6   rv   )r#   r8   rx   ÚabsxÚpart_tolrw   s   ` `   r   rv   z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Ò4ð &àˆð	5ús0   •5C ÁAC Â3C Ã4D3Ã;D3ÄD%Ä$	D3Ä2D3c                 ó  — | j                  |«      }|€$|€"| j                  d| j                   dz   «      x}}|€|}n|€|}t        ||z
  «      }||k  ryt        |«      }t        |«      }||k  r
||z  }||k  S ||z  }||k  S )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

        r   é   T)rB   ÚldexpÚprecrU   )	r#   ÚsÚtÚrel_epsÚabs_epsÚdiffÚabssÚabstÚerrs	            r   ÚalmosteqzStandardBaseContext.almosteq¤   s¨   € ðB �K‰K˜‹NˆØˆ?˜w˜Ø #§	¡	¨!¨c¯h©h¨Y°q©[Ó 9Ð9ˆG�gØˆ?Ø‰GØˆ_ØˆGÜ�1�Q‘3‹xˆØ�7Š?ØÜ�1‹vˆÜ�1‹vˆØ�$Š;Ø�t‘)ˆCð �g‰~Ðð �t‘)ˆCØ�g‰~Ðr   c                 óF  — t        |«      dk  st        dt        |«      z  «      ‚t        |«      dk\  st        dt        |«      z  «      ‚d}d}t        |«      dk(  r|d   }nt        |«      dk\  r
|d   }|d   }t        |«      dk(  r|d   }| j                  |«      | j                  «      | j                  |«      }}}||z   |k7  sJ d«       ‚||kD  r|dkD  rg S t        }n|dk  rg S t        }g }d}|}	 |||z  z   }|dz  } |||«      r|j                  |«       n	 |S Œ,)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 %ir   z+arange expected at least 1 argument, got %ir   rS   z0dt is too small and would cause an infinite loop)Úlenr   Úmpfr   r   Úappend)	r#   r\   rw   ÚdtÚbÚopÚresultÚirŠ   s	            r   ÚarangezStandardBaseContext.arange×   sR  € ô@ �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ˆ1ˆØ�2‰v˜Š{ÐNÐNÓNˆ{àˆqŠ5Ø�AŠvØ�	Ü‰Bà�AŠvØ�	ÜˆBàˆØˆØˆØØ�B�q‘D‘ˆAØ�‰FˆAÙ�!�QŒxØ—‘˜aÕ àØˆð r   c                 ó²  — t        |«      dk(  r7| j                  |d   «      }| j                  |d   «      }t        |d   «      }nct        |«      dk(  r>t        |d   d«      sJ ‚|d   j                  }|d   j
                  }t        |d   «      }nt        dt        |«      z  «      ‚|dk  rt        d«      ‚d|vs|d   rV|dk(  r| j                  |«      gS ||z
  | j                  |dz
  «      z  }t        |«      D �cg c]
  }||z  |z   ‘Œ }}||d	<   |S ||z
  | j                  |«      z  }t        |«      D �cg c]
  }||z  |z   ‘Œ }}|S c c}w c c}w )
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')]

        r“   r   r   rS   Ú_mpi_z*linspace expected 2 or 3 arguments, got %izn must be greater than 0Úendpointéÿÿÿÿ)	r”   r•   Úintr6   rw   r˜   r   r2   r   )	r#   r\   rC   rw   r˜   rq   Ústepr›   rG   s	            r   ÚlinspacezStandardBaseContext.linspace   sj  € ô* ˆ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Ø�AŠvØŸ™ ›
�|Ð#Ø˜‘E˜SŸW™W Q¨¡U›^Ñ+ˆDÜ%+¨A£YÖ/ ��4‘˜!“Ð/ˆAÐ/ØˆAˆb‰Eð ˆð ˜‘E˜SŸW™W Q›ZÑ'ˆDÜ%+¨A£YÖ/ ��4‘˜!“Ð/ˆAÐ/Øˆùò 0ùò 0s   Ä EÄ<Ec                 óN   —  | j                   |fi |¤Ž | j                  |fi |¤ŽfS r    )ÚcosÚsin©r#   ÚzrC   s      r   Úcos_sinzStandardBaseContext.cos_sinN  s-   € Øˆs�w‰w�qÑ#˜FÑ# W S§W¡W¨QÑ%9°&Ñ%9Ð9Ð9r   c                 óN   —  | j                   |fi |¤Ž | j                  |fi |¤ŽfS r    )ÚcospiÚsinpir§   s      r   Úcospi_sinpizStandardBaseContext.cospi_sinpiQ  s-   € Øˆs�y‰y˜Ñ%˜fÑ% y s§y¡y°Ñ'=°fÑ'=Ð=Ð=r   c                 ó0   — t        d|dz  z  d|z  z   «      S )Niè  g      Ð?r†   )r¡   )r#   Úps     r   Ú_default_hyper_maxprecz*StandardBaseContext._default_hyper_maxprecT  s   € Ü�4˜!˜T™'‘> A a¡CÑ'Ó(Ð(r   c                 óÆ  — | j                   }	 d}	 ||z   dz   | _         | j                  }| j                  }d} |«       D ]U  }||z  }||z  sD|rB| j                  |«      }	t	        ||	«      }| j                  |«      }
|
|	z
  | j                   kD  r n|dz  }ŒW |
z
  }||k7  rn,||k  s| j
                  rn|t        | j                   |«      z  }Œ½||| _         S # || _         w xY w©Né
   r   é   r   )rˆ   Úninfr<   Úmagr}   Ú_fixed_precisionÚmin)r#   ÚtermsÚ
check_steprˆ   Ú	extraprecÚmax_magr‰   ÚkÚtermÚterm_magÚsum_magÚcancellations               r   Úsum_accuratelyz"StandardBaseContext.sum_accuratelya  sþ   € Ø�x‰xˆð	ØˆIØØ )Ñ+¨aÑ/�”ØŸ(™(�Ø—H‘H�Ø�Ù!›Gò �DØ˜‘I�AØ 
šN±Ø#&§7¡7¨4£=˜Ü"% g¨xÓ"8˜Ø"%§'¡'¨!£*˜Ø" XÑ-°·±Ò8Ù!Ø˜‘F‘Aðð  '¨Ñ0�Ø <Ò/ØØ )Ò+¨s×/CÒ/CØØœS §¡¨<Ó8Ñ8�	ð' ð( àˆC�Hø�tˆC�Hús   ŽCC Ã	C c                 óÒ  — | j                   }	 d}	 ||z   dz   | _         | j                  }| j                  }|}d} |«       D ]Y  }	||	z  }|	|z
  }
||z  sC| j                  |
«      }t	        ||«      }| j                  ||z
  «      }| | j                   kD  r n|dz  }Œ[ |z
  }||k7  rn,||k  s| j
                  rn|t        | j                   |«      z  }ŒÃ||| _         S # || _         w xY wr²   )rˆ   rµ   rk   r¶   r}   r·   r¸   )r#   Úfactorsrº   rˆ   r»   r¼   rk   r‰   r½   Úfactorr¾   r¿   rÀ   rÁ   s                 r   Úmul_accuratelyz"StandardBaseContext.mul_accurately}  s  € Ø�x‰xˆð	ØˆIØØ )Ñ+¨aÑ/�”ØŸ(™(�Ø—g‘g�Ø�Ø�Ù%›iò �FØ˜‘K�AØ! C™<�DØ 
šNØ#&§7¡7¨4£=˜Ü"% g¨xÓ"8˜Ø"%§'¡'¨!¨C©%£.˜ð %˜9 s§x¡xÒ/Ù!Ø˜‘F‘Aðð  '¨Ñ0�Ø <Ò/ØØ )Ò+¨s×/CÒ/CØØœS §¡¨<Ó8Ñ8�	ð/ ð0 àˆC�Hø�tˆC�Hús   ŽCC Ã	C&c                 óH   — | j                  |«      | j                  |«      z  S )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
        rA   )r#   r8   rG   s      r   ÚpowerzStandardBaseContext.power�  s   € ð  �{‰{˜1‹~ §¡¨Q£Ñ/Ð/r   c                 ó$   — | j                  |«      S r    )Úzeta)r#   rq   s     r   Ú	_zeta_intzStandardBaseContext._zeta_int¯  s   € Ø�x‰x˜‹{Ðr   c                 ó$   ‡ ‡‡‡— dgŠˆˆˆ ˆfd„}|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

        r   c                  óf   •— ‰dxx   dz  cc<   ‰d   ‰kD  r‰j                  d‰z  «      ‚ ‰| i |¤ŽS )Nr   r   z%maxcalls: function evaluated %i times)ÚNoConvergence)r\   rC   ÚNÚcounterr#   Úfs     €€€€r   Úf_maxcalls_wrappedz8StandardBaseContext.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   ``` @r   ÚmaxcallszStandardBaseContext.maxcalls²  s   û€ ð  �#ˆ÷	&ð
 "Ð!r   c                 ób   ‡ ‡‡— i Šˆ ˆˆfd„}‰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

        c                  ó¦   •— |r| t        |j                  «       «      f}n| }‰j                  }|‰	v r‰	|   \  }}||k\  r|­S  ‰| i |¤Ž}||f‰	|<   |S r    )Útupler%   rˆ   )
r\   rC   Úkeyrˆ   ÚcprecÚcvaluer*   r#   rÑ   Úf_caches
          €€€r   Úf_cachedz-StandardBaseContext.memoize.<locals>.f_cachedß  sl   ø€ ÙØœE &§,¡,£.Ó1Ð1‘à�Ø—8‘8ˆDØ�g‰~Ø '¨¡‘��vØ˜D’=Ø"˜7�NÙ�tÐ&˜vÑ&ˆEØ  %˜=ˆG�C‰LØˆLr   )r   Ú__doc__)r#   rÑ   rÛ   rÚ   s   `` @r   ÚmemoizezStandardBaseContext.memoizeÊ  s.   ú€ ð( ˆö	ð ŸJ™JˆÔØŸ9™9ˆÔØˆr   )FF)NF)é   r    )NN)r   )4r   r   r   r   rÎ   ÚComplexResultr"   r+   r·   Úverboser0   r3   r9   r=   r?   rD   rH   rK   rM   rO   r_   ri   rn   rr   rv   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   r   r   r   r      sB  „ ð ×'Ñ'€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   