<s> r"""<STR_LIT>""" <EOL> from . functions import defun , defun_wrapped <EOL> def nome ( ctx , m ) : <EOL> m = ctx . convert ( m ) <EOL> if not m : <EOL> return m <EOL> if m == ctx . one : <EOL> return m <EOL> if ctx . isnan ( m ) : <EOL> return m <EOL> if ctx . isinf ( m ) : <EOL> if m == ctx . ninf : <EOL> return type ( m ) ( - <NUM_LIT:1> ) <EOL> else : <EOL> return ctx . mpc ( - <NUM_LIT:1> ) <EOL> a = ctx . ellipk ( ctx . one - m ) <EOL> b = ctx . ellipk ( m ) <EOL> v = ctx . exp ( - ctx . pi * a / b ) <EOL> if not ctx . _im ( m ) and ctx . _re ( m ) < <NUM_LIT:1> : <EOL> if ctx . _is_real_type ( m ) : <EOL> return v . real <EOL> else : <EOL> return v . real + <NUM_LIT> <EOL> elif m == <NUM_LIT:2> : <EOL> v = ctx . mpc ( <NUM_LIT:0> , v . imag ) <EOL> return v <EOL> @ defun_wrapped <EOL> def qfrom ( ctx , q = None , m = None , k = None , tau = None , qbar = None ) : <EOL> r"""<STR_LIT>""" <EOL> if q is not None : <EOL> return ctx . convert ( q ) <EOL> if m is not None : <EOL> return nome ( ctx , m ) <EOL> if k is not None : <EOL> return nome ( ctx , ctx . convert ( k ) ** <NUM_LIT:2> ) <EOL> if tau is not None : <EOL> return ctx . expjpi ( tau ) <EOL> if qbar is not None : <EOL> return ctx . sqrt ( qbar ) <EOL> @ defun_wrapped <EOL> def qbarfrom ( ctx , q = None , m = None , k = None , tau = None , qbar = None ) : <EOL> r"""<STR_LIT>""" <EOL> if qbar is not None : <EOL> return ctx . convert ( qbar ) <EOL> if q is not None : <EOL> return ctx . convert ( q ) ** <NUM_LIT:2> <EOL> if m is not None : <EOL> return nome ( ctx , m ) ** <NUM_LIT:2> <EOL> if k is not None : <EOL> return nome ( ctx , ctx . convert ( k ) ** <NUM_LIT:2> ) ** <NUM_LIT:2> <EOL> if tau is not None : <EOL> return ctx . expjpi ( <NUM_LIT:2> * tau ) <EOL> @ defun_wrapped <EOL> def taufrom ( ctx , q = None , m = None , k = None , tau = None , qbar = None ) : <EOL> r"""<STR_LIT>""" <EOL> if tau is not None : <EOL> return ctx . convert ( tau ) <EOL> if m is not None : <EOL> m = ctx . convert ( m ) <EOL> return ctx . j * ctx . ellipk ( <NUM_LIT:1> - m ) / ctx . ellipk ( m ) <EOL> if k is not None : <EOL> k = ctx . convert ( k ) <EOL> return ctx . j * ctx . ellipk ( <NUM_LIT:1> - k ** <NUM_LIT:2> ) / ctx . ellipk ( k ** <NUM_LIT:2> ) <EOL> if q is not None : <EOL> return ctx . log ( q ) / ( ctx . pi * ctx . j ) <EOL> if qbar is not None : <EOL> qbar = ctx . convert ( qbar ) <EOL> return ctx . log ( qbar ) / ( <NUM_LIT:2> * ctx . pi * ctx . j ) <EOL> @ defun_wrapped <EOL> def kfrom ( ctx , q = None , m = None , k = None , tau = None , qbar = None ) : <EOL> r"""<STR_LIT>""" <EOL> if k is not None : <EOL> return ctx . convert ( k ) <EOL> if m is not None : <EOL> return ctx . sqrt ( m ) <EOL> if tau is not None : <EOL> q = ctx . expjpi ( tau ) <EOL> if qbar is not None : <EOL> q = ctx . sqrt ( qbar ) <EOL> if q == <NUM_LIT:1> : <EOL> return q <EOL> if q == - <NUM_LIT:1> : <EOL> return ctx . mpc ( <NUM_LIT:0> , '<STR_LIT>' ) <EOL> return ( ctx . jtheta ( <NUM_LIT:2> , <NUM_LIT:0> , q ) / ctx . jtheta ( <NUM_LIT:3> , <NUM_LIT:0> , q ) ) ** <NUM_LIT:2> <EOL> @ defun_wrapped <EOL> def mfrom ( ctx , q = None , m = None , k = None , tau = None , qbar = None ) : <EOL> r"""<STR_LIT>""" <EOL> if m is not None : <EOL> return m <EOL> if k is not None : <EOL> return k ** <NUM_LIT:2> <EOL> if tau is not None : <EOL> q = ctx . expjpi ( tau ) <EOL> if qbar is not None : <EOL> q = ctx . sqrt ( qbar ) <EOL> if q == <NUM_LIT:1> : <EOL> return ctx . convert ( q ) <EOL> if q == - <NUM_LIT:1> : <EOL> return q * ctx . inf <EOL> v = ( ctx . jtheta ( <NUM_LIT:2> , <NUM_LIT:0> , q ) / ctx . jtheta ( <NUM_LIT:3> , <NUM_LIT:0> , q ) ) ** <NUM_LIT:4> <EOL> if ctx . _is_real_type ( q ) and q < <NUM_LIT:0> : <EOL> v = v . real <EOL> return v <EOL> jacobi_spec = { <EOL> '<STR_LIT>' : ( [ <NUM_LIT:3> ] , [ <NUM_LIT:2> ] , [ <NUM_LIT:1> ] , [ <NUM_LIT:4> ] , '<STR_LIT>' , '<STR_LIT>' ) , <EOL> '<STR_LIT>' : ( [ <NUM_LIT:4> ] , [ <NUM_LIT:2> ] , [ <NUM_LIT:2> ] , [ <NUM_LIT:4> ] , '<STR_LIT>' , '<STR_LIT>' ) , <EOL> '<STR_LIT>' : ( [ <NUM_LIT:4> ] , [ <NUM_LIT:3> ] , [ <NUM_LIT:3> ] , [ <NUM_LIT:4> ] , '<STR_LIT:1>' , '<STR_LIT>' ) , <EOL> '<STR_LIT>' : ( [ <NUM_LIT:2> ] , [ <NUM_LIT:3> ] , [ <NUM_LIT:4> ] , [ <NUM_LIT:1> ] , '<STR_LIT>' , '<STR_LIT>' ) , <EOL> '<STR_LIT>' : ( [ <NUM_LIT:2> ] , [ <NUM_LIT:4> ] , [ <NUM_LIT:4> ] , [ <NUM_LIT:2> ] , '<STR_LIT>' , '<STR_LIT>' ) , <EOL> '<STR_LIT>' : ( [ <NUM_LIT:3> ] , [ <NUM_LIT:4> ] , [ <NUM_LIT:4> ] , [ <NUM_LIT:3> ] , '<STR_LIT:1>' , '<STR_LIT>' ) , <EOL> '<STR_LIT>' : ( [ <NUM_LIT:3> ] , [ <NUM_LIT:4> ] , [ <NUM_LIT:1> ] , [ <NUM_LIT:2> ] , '<STR_LIT>' , '<STR_LIT>' ) , <EOL> '<STR_LIT>' : ( [ <NUM_LIT:3> , <NUM_LIT:3> ] , [ <NUM_LIT:2> , <NUM_LIT:4> ] , [ <NUM_LIT:1> ] , [ <NUM_LIT:3> ] , '<STR_LIT>' , '<STR_LIT>' ) , <EOL> '<STR_LIT>' : ( [ <NUM_LIT:3> ] , [ <NUM_LIT:2> ] , [ <NUM_LIT:2> ] , [ <NUM_LIT:3> ] , '<STR_LIT>' , '<STR_LIT:1>' ) , <EOL> '<STR_LIT>' : ( [ <NUM_LIT:4> ] , [ <NUM_LIT:3> ] , [ <NUM_LIT:2> ] , [ <NUM_LIT:1> ] , '<STR_LIT>' , '<STR_LIT>' ) , <EOL> '<STR_LIT>' : ( [ <NUM_LIT:2> ] , [ <NUM_LIT:3> ] , [ <NUM_LIT:3> ] , [ <NUM_LIT:2> ] , '<STR_LIT>' , '<STR_LIT:1>' ) , <EOL> '<STR_LIT>' : ( [ <NUM_LIT:2> , <NUM_LIT:4> ] , [ <NUM_LIT:3> , <NUM_LIT:3> ] , [ <NUM_LIT:3> ] , [ <NUM_LIT:1> ] , '<STR_LIT>' , '<STR_LIT>' ) , <EOL> '<STR_LIT>' : None , <EOL> '<STR_LIT>' : None , <EOL> '<STR_LIT>' : None , <EOL> '<STR_LIT>' : None <EOL> } <EOL> @ defun <EOL> def ellipfun ( ctx , kind , u = None , m = None , q = None , k = None , tau = None ) : <EOL> try : <EOL> S = jacobi_spec [ kind ] <EOL> except KeyError : <EOL> raise ValueError ( "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> if u is None : <EOL> def f ( * args , ** kwargs ) : <EOL> return ctx . ellipfun ( kind , * args , ** kwargs ) <EOL> f . __name__ = kind <EOL> return f <EOL> prec = ctx . prec <EOL> try : <EOL> ctx . prec += <NUM_LIT:10> <EOL> u = ctx . convert ( u ) <EOL> q = ctx . qfrom ( m = m , q = q , k = k , tau = tau ) <EOL> if S is None : <EOL> v = ctx . one + <NUM_LIT:0> * q * u <EOL> elif q == ctx . zero : <EOL> if S [ <NUM_LIT:4> ] == '<STR_LIT:1>' : v = ctx . one <EOL> else : v = getattr ( ctx , S [ <NUM_LIT:4> ] ) ( u ) <EOL> v += <NUM_LIT:0> * q * u <EOL> elif q == ctx . one : <EOL> if S [ <NUM_LIT:5> ] == '<STR_LIT:1>' : v = ctx . one <EOL> else : v = getattr ( ctx , S [ <NUM_LIT:5> ] ) ( u ) <EOL> v += <NUM_LIT:0> * q * u <EOL> else : <EOL> t = u / ctx . jtheta ( <NUM_LIT:3> , <NUM_LIT:0> , q ) ** <NUM_LIT:2> <EOL> v = ctx . one <EOL> for a in S [ <NUM_LIT:0> ] : v *= ctx . jtheta ( a , <NUM_LIT:0> , q ) <EOL> for b in S [ <NUM_LIT:1> ] : v /= ctx . jtheta ( b , <NUM_LIT:0> , q ) <EOL> for c in S [ <NUM_LIT:2> ] : v *= ctx . jtheta ( c , t , q ) <EOL> for d in S [ <NUM_LIT:3> ] : v /= ctx . jtheta ( d , t , q ) <EOL> finally : <EOL> ctx . prec = prec <EOL> return + v <EOL> @ defun_wrapped <EOL> def kleinj ( ctx , tau = None , ** kwargs ) : <EOL> r"""<STR_LIT>""" <EOL> q = ctx . qfrom ( tau = tau , ** kwargs ) <EOL> t2 = ctx . jtheta ( <NUM_LIT:2> , <NUM_LIT:0> , q ) <EOL> t3 = ctx . jtheta ( <NUM_LIT:3> , <NUM_LIT:0> , q ) <EOL> t4 = ctx . jtheta ( <NUM_LIT:4> , <NUM_LIT:0> , q ) <EOL> P = ( t2 ** <NUM_LIT:8> + t3 ** <NUM_LIT:8> + t4 ** <NUM_LIT:8> ) ** <NUM_LIT:3> <EOL> Q = <NUM_LIT> * ( t2 * t3 * t4 ) ** <NUM_LIT:8> <EOL> return P / Q <EOL> def RF_calc ( ctx , x , y , z , r ) : <EOL> if y == z : return RC_calc ( ctx , x , y , r ) <EOL> if x == z : return RC_calc ( ctx , y , x , r ) <EOL> if x == y : return RC_calc ( ctx , z , x , r ) <EOL> if not ( ctx . isnormal ( x ) and ctx . isnormal ( y ) and ctx . isnormal ( z ) ) : <EOL> if ctx . isnan ( x ) or ctx . isnan ( y ) or ctx . isnan ( z ) : <EOL> return x * y * z <EOL> if ctx . isinf ( x ) or ctx . isinf ( y ) or ctx . isinf ( z ) : <EOL> return ctx . zero <EOL> xm , ym , zm = x , y , z <EOL> A0 = Am = ( x + y + z ) / <NUM_LIT:3> <EOL> Q = ctx . root ( <NUM_LIT:3> * r , - <NUM_LIT:6> ) * max ( abs ( A0 - x ) , abs ( A0 - y ) , abs ( A0 - z ) ) <EOL> g = ctx . mpf ( <NUM_LIT> ) <EOL> pow4 = ctx . one <EOL> m = <NUM_LIT:0> <EOL> while <NUM_LIT:1> : <EOL> xs = ctx . sqrt ( xm ) <EOL> ys = ctx . sqrt ( ym ) <EOL> zs = ctx . sqrt ( zm ) <EOL> lm = xs * ys + xs * zs + ys * zs <EOL> Am1 = ( Am + lm ) * g <EOL> xm , ym , zm = ( xm + lm ) * g , ( ym + lm ) * g , ( zm + lm ) * g <EOL> if pow4 * Q < abs ( Am ) : <EOL> break <EOL> Am = Am1 <EOL> m += <NUM_LIT:1> <EOL> pow4 *= g <EOL> t = pow4 / Am <EOL> X = ( A0 - x ) * t <EOL> Y = ( A0 - y ) * t <EOL> Z = - X - Y <EOL> E2 = X * Y - Z ** <NUM_LIT:2> <EOL> E3 = X * Y * Z <EOL> return ctx . power ( Am , - <NUM_LIT:0.5> ) * ( <NUM_LIT> - <NUM_LIT> * E2 + <NUM_LIT> * E2 ** <NUM_LIT:2> + <NUM_LIT> * E3 - <NUM_LIT> * E2 * E3 ) / <NUM_LIT> <EOL> def RC_calc ( ctx , x , y , r , pv = True ) : <EOL> if not ( ctx . isnormal ( x ) and ctx . isnormal ( y ) ) : <EOL> if ctx . isinf ( x ) or ctx . isinf ( y ) : <EOL> return <NUM_LIT:1> / ( x * y ) <EOL> if y == <NUM_LIT:0> : <EOL> return ctx . inf <EOL> if x == <NUM_LIT:0> : <EOL> return ctx . pi / ctx . sqrt ( y ) / <NUM_LIT:2> <EOL> raise ValueError <EOL> if pv and ctx . _im ( y ) == <NUM_LIT:0> and ctx . _re ( y ) < <NUM_LIT:0> : <EOL> return ctx . sqrt ( x / ( x - y ) ) * RC_calc ( ctx , x - y , - y , r ) <EOL> if x == y : <EOL> return <NUM_LIT:1> / ctx . sqrt ( x ) <EOL> extraprec = <NUM_LIT:2> * max ( <NUM_LIT:0> , - ctx . mag ( x - y ) + ctx . mag ( x ) ) <EOL> ctx . prec += extraprec <EOL> if ctx . _is_real_type ( x ) and ctx . _is_real_type ( y ) : <EOL> x = ctx . _re ( x ) <EOL> y = ctx . _re ( y ) <EOL> a = ctx . sqrt ( x / y ) <EOL> if x < y : <EOL> b = ctx . sqrt ( y - x ) <EOL> v = ctx . acos ( a ) / b <EOL> else : <EOL> b = ctx . sqrt ( x - y ) <EOL> v = ctx . acosh ( a ) / b <EOL> else : <EOL> sx = ctx . sqrt ( x ) <EOL> sy = ctx . sqrt ( y ) <EOL> v = ctx . acos ( sx / sy ) / ( ctx . sqrt ( ( <NUM_LIT:1> - x / y ) ) * sy ) <EOL> ctx . prec -= extraprec <EOL> return v <EOL> def RJ_calc ( ctx , x , y , z , p , r ) : <EOL> if not ( ctx . isnormal ( x ) and ctx . isnormal ( y ) and ctx . isnormal ( z ) and ctx . isnormal ( p ) ) : <EOL> if ctx . isnan ( x ) or ctx . isnan ( y ) or ctx . isnan ( z ) or ctx . isnan ( p ) : <EOL> return x * y * z <EOL> if ctx . isinf ( x ) or ctx . isinf ( y ) or ctx . isinf ( z ) or ctx . isinf ( p ) : <EOL> return ctx . zero <EOL> if not p : <EOL> return ctx . inf <EOL> xm , ym , zm , pm = x , y , z , p <EOL> A0 = Am = ( x + y + z + <NUM_LIT:2> * p ) / <NUM_LIT:5> <EOL> delta = ( p - x ) * ( p - y ) * ( p - z ) <EOL> Q = ctx . root ( <NUM_LIT> * r , - <NUM_LIT:6> ) * max ( abs ( A0 - x ) , abs ( A0 - y ) , abs ( A0 - z ) , abs ( A0 - p ) ) <EOL> m = <NUM_LIT:0> <EOL> g = ctx . mpf ( <NUM_LIT> ) <EOL> pow4 = ctx . one <EOL> S = <NUM_LIT:0> <EOL> while <NUM_LIT:1> : <EOL> sx = ctx . sqrt ( xm ) <EOL> sy = ctx . sqrt ( ym ) <EOL> sz = ctx . sqrt ( zm ) <EOL> sp = ctx . sqrt ( pm ) <EOL> lm = sx * sy + sx * sz + sy * sz <EOL> Am1 = ( Am + lm ) * g <EOL> xm = ( xm + lm ) * g ; ym = ( ym + lm ) * g ; zm = ( zm + lm ) * g ; pm = ( pm + lm ) * g <EOL> dm = ( sp + sx ) * ( sp + sy ) * ( sp + sz ) <EOL> em = delta * ctx . power ( <NUM_LIT:4> , - <NUM_LIT:3> * m ) / dm ** <NUM_LIT:2> <EOL> if pow4 * Q < abs ( Am ) : <EOL> break <EOL> T = RC_calc ( ctx , ctx . one , ctx . one + em , r ) * pow4 / dm <EOL> S += T <EOL> pow4 *= g <EOL> m += <NUM_LIT:1> <EOL> Am = Am1 <EOL> t = ctx . ldexp ( <NUM_LIT:1> , - <NUM_LIT:2> * m ) / Am <EOL> X = ( A0 - x ) * t <EOL> Y = ( A0 - y ) * t <EOL> Z = ( A0 - z ) * t <EOL> P = ( - X - Y - Z ) / <NUM_LIT:2> <EOL> E2 = X * Y + X * Z + Y * Z - <NUM_LIT:3> * P ** <NUM_LIT:2> <EOL> E3 = X * Y * Z + <NUM_LIT:2> * E2 * P + <NUM_LIT:4> * P ** <NUM_LIT:3> <EOL> E4 = ( <NUM_LIT:2> * X * Y * Z + E2 * P + <NUM_LIT:3> * P ** <NUM_LIT:3> ) * P <EOL> E5 = X * Y * Z * P ** <NUM_LIT:2> <EOL> P = <NUM_LIT> - <NUM_LIT> * E2 + <NUM_LIT> * E2 ** <NUM_LIT:2> + <NUM_LIT> * E3 - <NUM_LIT> * E2 * E3 - <NUM_LIT> * E4 + <NUM_LIT> * E5 <EOL> Q = <NUM_LIT> <EOL> v1 = g ** m * ctx . power ( Am , - <NUM_LIT> ) * P / Q <EOL> v2 = <NUM_LIT:6> * S <EOL> return v1 + v2 <EOL> @ defun <EOL> def elliprf ( ctx , x , y , z ) : <EOL> r"""<STR_LIT>""" <EOL> x = ctx . convert ( x ) <EOL> y = ctx . convert ( y ) <EOL> z = ctx . convert ( z ) <EOL> prec = ctx . prec <EOL> try : <EOL> ctx . prec += <NUM_LIT:20> <EOL> tol = ctx . eps * <NUM_LIT:2> ** <NUM_LIT:10> <EOL> v = RF_calc ( ctx , x , y , z , tol ) <EOL> finally : <EOL> ctx . prec = prec <EOL> return + v <EOL> @ defun <EOL> def elliprc ( ctx , x , y , pv = True ) : <EOL> r"""<STR_LIT>""" <EOL> x = ctx . convert ( x ) <EOL> y = ctx . convert ( y ) <EOL> prec = ctx . prec <EOL> try : <EOL> ctx . prec += <NUM_LIT:20> <EOL> tol = ctx . eps * <NUM_LIT:2> ** <NUM_LIT:10> <EOL> v = RC_calc ( ctx , x , y , tol , pv ) <EOL> finally : <EOL> ctx . prec = prec <EOL> return + v <EOL> @ defun <EOL> def elliprj ( ctx , x , y , z , p ) : <EOL> r"""<STR_LIT>""" <EOL> x = ctx . convert ( x ) <EOL> y = ctx . convert ( y ) <EOL> z = ctx . convert ( z ) <EOL> p = ctx . convert ( p ) <EOL> prec = ctx . prec <EOL> try : <EOL> ctx . prec += <NUM_LIT:20> <EOL> tol = ctx . eps * <NUM_LIT:2> ** <NUM_LIT:10> <EOL> v = RJ_calc ( ctx , x , y , z , p , tol ) <EOL> finally : <EOL> ctx . prec = prec <EOL> return + v <EOL> @ defun <EOL> def elliprd ( ctx , x , y , z ) : <EOL> r"""<STR_LIT>""" <EOL> return ctx . elliprj ( x , y , z , z ) <EOL> @ defun <EOL> def elliprg ( ctx , x , y , z ) : <EOL> r"""<STR_LIT>""" <EOL> x = ctx . convert ( x ) <EOL> y = ctx . convert ( y ) <EOL> z = ctx . convert ( z ) <EOL> if not z : x , z = z , x <EOL> if not z : y , z = x , y <EOL> if not z : return ctx . inf <EOL> def terms ( ) : <EOL> T1 = <NUM_LIT:0.5> * z * ctx . elliprf ( x , y , z ) <EOL> T2 = - <NUM_LIT:0.5> * ( x - z ) * ( y - z ) * ctx . elliprd ( x , y , z ) / <NUM_LIT:3> <EOL> T3 = <NUM_LIT:0.5> * ctx . sqrt ( x * y / z ) <EOL> return T1 , T2 , T3 <EOL> return ctx . sum_accurately ( terms ) <EOL> @ defun_wrapped <EOL> def ellipf ( ctx , phi , m ) : <EOL> r"""<STR_LIT>""" <EOL> z = phi <EOL> if not ( ctx . isnormal ( z ) and ctx . isnormal ( m ) ) : <EOL> if m == <NUM_LIT:0> : <EOL> return z + m <EOL> if z == <NUM_LIT:0> : <EOL> return z * m <EOL> if m == ctx . inf or m == ctx . ninf : return z / m <EOL> raise ValueError <EOL> x = z . real <EOL> ctx . prec += max ( <NUM_LIT:0> , ctx . mag ( x ) ) <EOL> pi = + ctx . pi <EOL> away = abs ( x ) > pi / <NUM_LIT:2> <EOL> if m == <NUM_LIT:1> : <EOL> if away : <EOL> return ctx . inf <EOL> if away : <EOL> d = ctx . nint ( x / pi ) <EOL> z = z - pi * d <EOL> P = <NUM_LIT:2> * d * ctx . ellipk ( m ) <EOL> else : <EOL> P = <NUM_LIT:0> <EOL> c , s = ctx . cos_sin ( z ) <EOL> return s * ctx . elliprf ( c ** <NUM_LIT:2> , <NUM_LIT:1> - m * s ** <NUM_LIT:2> , <NUM_LIT:1> ) + P <EOL> @ defun_wrapped <EOL> def ellipe ( ctx , * args ) : <EOL> r"""<STR_LIT>""" <EOL> if len ( args ) == <NUM_LIT:1> : <EOL> return ctx . _ellipe ( args [ <NUM_LIT:0> ] ) <EOL> else : <EOL> phi , m = args <EOL> z = phi <EOL> if not ( ctx . isnormal ( z ) and ctx . isnormal ( m ) ) : <EOL> if m == <NUM_LIT:0> : <EOL> return z + m <EOL> if z == <NUM_LIT:0> : <EOL> return z * m <EOL> if m == ctx . inf or m == ctx . ninf : <EOL> return ctx . inf <EOL> raise ValueError <EOL> x = z . real <EOL> ctx . prec += max ( <NUM_LIT:0> , ctx . mag ( x ) ) <EOL> pi = + ctx . pi <EOL> away = abs ( x ) > pi / <NUM_LIT:2> <EOL> if away : <EOL> d = ctx . nint ( x / pi ) <EOL> z = z - pi * d <EOL> P = <NUM_LIT:2> * d * ctx . ellipe ( m ) <EOL> else : <EOL> P = <NUM_LIT:0> <EOL> def terms ( ) : <EOL> c , s = ctx . cos_sin ( z ) <EOL> x = c ** <NUM_LIT:2> <EOL> y = <NUM_LIT:1> - m * s ** <NUM_LIT:2> <EOL> RF = ctx . elliprf ( x , y , <NUM_LIT:1> ) <EOL> RD = ctx . elliprd ( x , y , <NUM_LIT:1> ) <EOL> return s * RF , - m * s ** <NUM_LIT:3> * RD / <NUM_LIT:3> <EOL> return ctx . sum_accurately ( terms ) + P <EOL> @ defun_wrapped <EOL> def ellippi ( ctx , * args ) : <EOL> r"""<STR_LIT>""" <EOL> if len ( args ) == <NUM_LIT:2> : <EOL> n , m = args <EOL> complete = True <EOL> z = phi = ctx . pi / <NUM_LIT:2> <EOL> else : <EOL> n , phi , m = args <EOL> complete = False <EOL> z = phi <EOL> if not ( ctx . isnormal ( n ) and ctx . isnormal ( z ) and ctx . isnormal ( m ) ) : <EOL> if ctx . isnan ( n ) or ctx . isnan ( z ) or ctx . isnan ( m ) : <EOL> raise ValueError <EOL> if complete : <EOL> if m == <NUM_LIT:0> : <EOL> if n == <NUM_LIT:1> : <EOL> return ctx . inf <EOL> return ctx . pi / ( <NUM_LIT:2> * ctx . sqrt ( <NUM_LIT:1> - n ) ) <EOL> if n == <NUM_LIT:0> : return ctx . ellipk ( m ) <EOL> if ctx . isinf ( n ) or ctx . isinf ( m ) : return ctx . zero <EOL> else : <EOL> if z == <NUM_LIT:0> : return z <EOL> if ctx . isinf ( n ) : return ctx . zero <EOL> if ctx . isinf ( m ) : return ctx . zero <EOL> if ctx . isinf ( n ) or ctx . isinf ( z ) or ctx . isinf ( m ) : <EOL> raise ValueError <EOL> if complete : <EOL> if m == <NUM_LIT:1> : <EOL> if n == <NUM_LIT:1> : <EOL> return ctx . inf <EOL> return - ctx . inf / ctx . sign ( n - <NUM_LIT:1> ) <EOL> away = False <EOL> else : <EOL> x = z . real <EOL> ctx . prec += max ( <NUM_LIT:0> , ctx . mag ( x ) ) <EOL> pi = + ctx . pi <EOL> away = abs ( x ) > pi / <NUM_LIT:2> <EOL> if away : <EOL> d = ctx . nint ( x / pi ) <EOL> z = z - pi * d <EOL> P = <NUM_LIT:2> * d * ctx . ellippi ( n , m ) <EOL> if ctx . isinf ( P ) : <EOL> return ctx . inf <EOL> else : <EOL> P = <NUM_LIT:0> <EOL> def terms ( ) : <EOL> if complete : <EOL> c , s = ctx . zero , ctx . one <EOL> else : <EOL> c , s = ctx . cos_sin ( z ) <EOL> x = c ** <NUM_LIT:2> <EOL> y = <NUM_LIT:1> - m * s ** <NUM_LIT:2> <EOL> RF = ctx . elliprf ( x , y , <NUM_LIT:1> ) <EOL> RJ = ctx . elliprj ( x , y , <NUM_LIT:1> , <NUM_LIT:1> - n * s ** <NUM_LIT:2> ) <EOL> return s * RF , n * s ** <NUM_LIT:3> * RJ / <NUM_LIT:3> <EOL> return ctx . sum_accurately ( terms ) + P </s>
