Timeout for init-lam0-twopoint

Specification

Math

\[\begin{array}{l} t_0 := \begin{array}{l} \mathbf{if}\;lam1 - lam2 < -\pi:\\ \;\;\;\;lam2 + 2 \cdot \pi\\ \mathbf{elif}\;lam1 - lam2 > \pi:\\ \;\;\;\;lam2 - 2 \cdot \pi\\ \mathbf{else}:\\ \;\;\;\;lam2\\ \end{array}\\ 0.5 \cdot \left(lam1 + t\_0\right) - \frac{\tan^{-1} \left(\frac{J \cdot \tan \left(0.5 \cdot \left(B \cdot \left(lam1 - t\_0\right)\right)\right)}{p}\right)}{B} \end{array} \]

FPCore

(FPCore (lam1 lam2 B J p)
  :precision binary64
  :pre TRUE
  (let* ((t_0
        (if (< (- lam1 lam2) (- PI))
          (+ lam2 (* 2.0 PI))
          (if (> (- lam1 lam2) PI) (- lam2 (* 2.0 PI)) lam2))))
  (-
   (* 0.5 (+ lam1 t_0))
   (/ (atan (/ (* J (tan (* 0.5 (* B (- lam1 t_0))))) p)) B))))

C

double code(double lam1, double lam2, double B, double J, double p) {
	double tmp;
	if ((lam1 - lam2) < -((double) M_PI)) {
		tmp = lam2 + (2.0 * ((double) M_PI));
	} else if ((lam1 - lam2) > ((double) M_PI)) {
		tmp = lam2 - (2.0 * ((double) M_PI));
	} else {
		tmp = lam2;
	}
	double t_0 = tmp;
	return (0.5 * (lam1 + t_0)) - (atan(((J * tan((0.5 * (B * (lam1 - t_0))))) / p)) / B);
}

Java

public static double code(double lam1, double lam2, double B, double J, double p) {
	double tmp;
	if ((lam1 - lam2) < -Math.PI) {
		tmp = lam2 + (2.0 * Math.PI);
	} else if ((lam1 - lam2) > Math.PI) {
		tmp = lam2 - (2.0 * Math.PI);
	} else {
		tmp = lam2;
	}
	double t_0 = tmp;
	return (0.5 * (lam1 + t_0)) - (Math.atan(((J * Math.tan((0.5 * (B * (lam1 - t_0))))) / p)) / B);
}

Python

def code(lam1, lam2, B, J, p):
	tmp = 0
	if (lam1 - lam2) < -math.pi:
		tmp = lam2 + (2.0 * math.pi)
	elif (lam1 - lam2) > math.pi:
		tmp = lam2 - (2.0 * math.pi)
	else:
		tmp = lam2
	t_0 = tmp
	return (0.5 * (lam1 + t_0)) - (math.atan(((J * math.tan((0.5 * (B * (lam1 - t_0))))) / p)) / B)

Julia

function code(lam1, lam2, B, J, p)
	tmp = 0.0
	if (Float64(lam1 - lam2) < Float64(-pi))
		tmp = Float64(lam2 + Float64(2.0 * pi));
	elseif (Float64(lam1 - lam2) > pi)
		tmp = Float64(lam2 - Float64(2.0 * pi));
	else
		tmp = lam2;
	end
	t_0 = tmp
	return Float64(Float64(0.5 * Float64(lam1 + t_0)) - Float64(atan(Float64(Float64(J * tan(Float64(0.5 * Float64(B * Float64(lam1 - t_0))))) / p)) / B))
end

MATLAB

function tmp_2 = code(lam1, lam2, B, J, p)
	tmp = 0.0;
	if ((lam1 - lam2) < -pi)
		tmp = lam2 + (2.0 * pi);
	elseif ((lam1 - lam2) > pi)
		tmp = lam2 - (2.0 * pi);
	else
		tmp = lam2;
	end
	t_0 = tmp;
	tmp_2 = (0.5 * (lam1 + t_0)) - (atan(((J * tan((0.5 * (B * (lam1 - t_0))))) / p)) / B);
end

Wolfram

code[lam1_, lam2_, B_, J_, p_] := Block[{t$95$0 = If[Less[N[(lam1 - lam2), $MachinePrecision], (-Pi)], N[(lam2 + N[(2.0 * Pi), $MachinePrecision]), $MachinePrecision], If[Greater[N[(lam1 - lam2), $MachinePrecision], Pi], N[(lam2 - N[(2.0 * Pi), $MachinePrecision]), $MachinePrecision], lam2]]}, N[(N[(0.5 * N[(lam1 + t$95$0), $MachinePrecision]), $MachinePrecision] - N[(N[ArcTan[N[(N[(J * N[Tan[N[(0.5 * N[(B * N[(lam1 - t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / p), $MachinePrecision]], $MachinePrecision] / B), $MachinePrecision]), $MachinePrecision]]

ReFlow

f(lam1, lam2, B, J, p):
	lam1 in [-inf, +inf],
	lam2 in [-inf, +inf],
	B in [-inf, +inf],
	J in [-inf, +inf],
	p in [-inf, +inf]
code: THEORY
BEGIN
f(lam1, lam2, B, J, p: real): real =
	LET tmp_1 = IF ((lam1 - lam2) > (4 * atan(1))) THEN (lam2 - ((2) * (4 * atan(1)))) ELSE lam2 ENDIF IN
	LET tmp = IF ((lam1 - lam2) < (- (4 * atan(1)))) THEN (lam2 + ((2) * (4 * atan(1)))) ELSE tmp_1 ENDIF IN
	LET t_0 = tmp IN
	((5e-1) * (lam1 + t_0)) - ((atan(((J * (tan(((5e-1) * (B * (lam1 - t_0)))))) / p))) / B)
END code