Timeout for inverse-delp

Specification

\[ecc > 0 \land ecc < 1\]

Math

\[\begin{array}{l} t_0 := ecc \cdot \sin phip\\ \left(\left(con + \log \tan \left(\frac{\pi}{4} + 0.5 \cdot phip\right)\right) - hlf\_e \cdot \log \left(\frac{1 + t\_0}{1 - t\_0}\right)\right) \cdot \left(\left(1 - t\_0 \cdot t\_0\right) \cdot \left(\cos phip \cdot rone\_es\right)\right) \end{array} \]

FPCore

(FPCore (phip ecc hlf_e con rone_es)
  :precision binary64
  :pre (and (> ecc 0.0) (< ecc 1.0))
  (let* ((t_0 (* ecc (sin phip))))
  (*
   (-
    (+ con (log (tan (+ (/ PI 4.0) (* 0.5 phip)))))
    (* hlf_e (log (/ (+ 1.0 t_0) (- 1.0 t_0)))))
   (* (- 1.0 (* t_0 t_0)) (* (cos phip) rone_es)))))

C

double code(double phip, double ecc, double hlf_e, double con, double rone_es) {
	double t_0 = ecc * sin(phip);
	return ((con + log(tan(((((double) M_PI) / 4.0) + (0.5 * phip))))) - (hlf_e * log(((1.0 + t_0) / (1.0 - t_0))))) * ((1.0 - (t_0 * t_0)) * (cos(phip) * rone_es));
}

Java

public static double code(double phip, double ecc, double hlf_e, double con, double rone_es) {
	double t_0 = ecc * Math.sin(phip);
	return ((con + Math.log(Math.tan(((Math.PI / 4.0) + (0.5 * phip))))) - (hlf_e * Math.log(((1.0 + t_0) / (1.0 - t_0))))) * ((1.0 - (t_0 * t_0)) * (Math.cos(phip) * rone_es));
}

Python

def code(phip, ecc, hlf_e, con, rone_es):
	t_0 = ecc * math.sin(phip)
	return ((con + math.log(math.tan(((math.pi / 4.0) + (0.5 * phip))))) - (hlf_e * math.log(((1.0 + t_0) / (1.0 - t_0))))) * ((1.0 - (t_0 * t_0)) * (math.cos(phip) * rone_es))

Julia

function code(phip, ecc, hlf_e, con, rone_es)
	t_0 = Float64(ecc * sin(phip))
	return Float64(Float64(Float64(con + log(tan(Float64(Float64(pi / 4.0) + Float64(0.5 * phip))))) - Float64(hlf_e * log(Float64(Float64(1.0 + t_0) / Float64(1.0 - t_0))))) * Float64(Float64(1.0 - Float64(t_0 * t_0)) * Float64(cos(phip) * rone_es)))
end

MATLAB

function tmp = code(phip, ecc, hlf_e, con, rone_es)
	t_0 = ecc * sin(phip);
	tmp = ((con + log(tan(((pi / 4.0) + (0.5 * phip))))) - (hlf_e * log(((1.0 + t_0) / (1.0 - t_0))))) * ((1.0 - (t_0 * t_0)) * (cos(phip) * rone_es));
end

Wolfram

code[phip_, ecc_, hlf$95$e_, con_, rone$95$es_] := Block[{t$95$0 = N[(ecc * N[Sin[phip], $MachinePrecision]), $MachinePrecision]}, N[(N[(N[(con + N[Log[N[Tan[N[(N[(Pi / 4.0), $MachinePrecision] + N[(0.5 * phip), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - N[(hlf$95$e * N[Log[N[(N[(1.0 + t$95$0), $MachinePrecision] / N[(1.0 - t$95$0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(1.0 - N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision] * N[(N[Cos[phip], $MachinePrecision] * rone$95$es), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

ReFlow

f(phip, ecc, hlf_e, con, rone_es):
	phip in [-inf, +inf],
	ecc in [0, 1],
	hlf_e in [-inf, +inf],
	con in [-inf, +inf],
	rone_es in [-inf, +inf]
code: THEORY
BEGIN
f(phip, ecc, hlf_e, con, rone_es: real): real =
	LET t_0 = (ecc * (sin(phip))) IN
	((con + (ln((tan((((4 * atan(1)) / (4)) + ((5e-1) * phip))))))) - (hlf_e * (ln((((1) + t_0) / ((1) - t_0)))))) * (((1) - (t_0 * t_0)) * ((cos(phip)) * rone_es))
END code