Timeout for inverse-lamt

Specification

Math

\[\tan^{-1} \left(\frac{\left(1 - \left(spp \cdot spp\right) \cdot rone\_es\right) \cdot \left(\tan lamdp \cdot ca\right) - \frac{spp \cdot \left(sa \cdot \sqrt{\left(1 + q \cdot \left(\sin lamdp \cdot \sin lamdp\right)\right) \cdot \left(1 - spp \cdot spp\right) - \left(spp \cdot spp\right) \cdot u}\right)}{\cos lamdp}}{1 - \left(spp \cdot spp\right) \cdot \left(1 + u\right)}\right) \]

FPCore

(FPCore (lamdp spp q u rone_es ca sa)
  :precision binary64
  :pre TRUE
  (atan
 (/
  (-
   (* (- 1.0 (* (* spp spp) rone_es)) (* (tan lamdp) ca))
   (/
    (*
     spp
     (*
      sa
      (sqrt
       (-
        (*
         (+ 1.0 (* q (* (sin lamdp) (sin lamdp))))
         (- 1.0 (* spp spp)))
        (* (* spp spp) u)))))
    (cos lamdp)))
  (- 1.0 (* (* spp spp) (+ 1.0 u))))))

C

double code(double lamdp, double spp, double q, double u, double rone_es, double ca, double sa) {
	return atan(((((1.0 - ((spp * spp) * rone_es)) * (tan(lamdp) * ca)) - ((spp * (sa * sqrt((((1.0 + (q * (sin(lamdp) * sin(lamdp)))) * (1.0 - (spp * spp))) - ((spp * spp) * u))))) / cos(lamdp))) / (1.0 - ((spp * spp) * (1.0 + u)))));
}

Fortran

real(8) function code(lamdp, spp, q, u, rone_es, ca, sa)
use fmin_fmax_functions
    real(8), intent (in) :: lamdp
    real(8), intent (in) :: spp
    real(8), intent (in) :: q
    real(8), intent (in) :: u
    real(8), intent (in) :: rone_es
    real(8), intent (in) :: ca
    real(8), intent (in) :: sa
    code = atan(((((1.0d0 - ((spp * spp) * rone_es)) * (tan(lamdp) * ca)) - ((spp * (sa * sqrt((((1.0d0 + (q * (sin(lamdp) * sin(lamdp)))) * (1.0d0 - (spp * spp))) - ((spp * spp) * u))))) / cos(lamdp))) / (1.0d0 - ((spp * spp) * (1.0d0 + u)))))
end function

Java

public static double code(double lamdp, double spp, double q, double u, double rone_es, double ca, double sa) {
	return Math.atan(((((1.0 - ((spp * spp) * rone_es)) * (Math.tan(lamdp) * ca)) - ((spp * (sa * Math.sqrt((((1.0 + (q * (Math.sin(lamdp) * Math.sin(lamdp)))) * (1.0 - (spp * spp))) - ((spp * spp) * u))))) / Math.cos(lamdp))) / (1.0 - ((spp * spp) * (1.0 + u)))));
}

Python

def code(lamdp, spp, q, u, rone_es, ca, sa):
	return math.atan(((((1.0 - ((spp * spp) * rone_es)) * (math.tan(lamdp) * ca)) - ((spp * (sa * math.sqrt((((1.0 + (q * (math.sin(lamdp) * math.sin(lamdp)))) * (1.0 - (spp * spp))) - ((spp * spp) * u))))) / math.cos(lamdp))) / (1.0 - ((spp * spp) * (1.0 + u)))))

Julia

function code(lamdp, spp, q, u, rone_es, ca, sa)
	return atan(Float64(Float64(Float64(Float64(1.0 - Float64(Float64(spp * spp) * rone_es)) * Float64(tan(lamdp) * ca)) - Float64(Float64(spp * Float64(sa * sqrt(Float64(Float64(Float64(1.0 + Float64(q * Float64(sin(lamdp) * sin(lamdp)))) * Float64(1.0 - Float64(spp * spp))) - Float64(Float64(spp * spp) * u))))) / cos(lamdp))) / Float64(1.0 - Float64(Float64(spp * spp) * Float64(1.0 + u)))))
end

MATLAB

function tmp = code(lamdp, spp, q, u, rone_es, ca, sa)
	tmp = atan(((((1.0 - ((spp * spp) * rone_es)) * (tan(lamdp) * ca)) - ((spp * (sa * sqrt((((1.0 + (q * (sin(lamdp) * sin(lamdp)))) * (1.0 - (spp * spp))) - ((spp * spp) * u))))) / cos(lamdp))) / (1.0 - ((spp * spp) * (1.0 + u)))));
end

Wolfram

code[lamdp_, spp_, q_, u_, rone$95$es_, ca_, sa_] := N[ArcTan[N[(N[(N[(N[(1.0 - N[(N[(spp * spp), $MachinePrecision] * rone$95$es), $MachinePrecision]), $MachinePrecision] * N[(N[Tan[lamdp], $MachinePrecision] * ca), $MachinePrecision]), $MachinePrecision] - N[(N[(spp * N[(sa * N[Sqrt[N[(N[(N[(1.0 + N[(q * N[(N[Sin[lamdp], $MachinePrecision] * N[Sin[lamdp], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(1.0 - N[(spp * spp), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(spp * spp), $MachinePrecision] * u), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Cos[lamdp], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(1.0 - N[(N[(spp * spp), $MachinePrecision] * N[(1.0 + u), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]

ReFlow

f(lamdp, spp, q, u, rone_es, ca, sa):
	lamdp in [-inf, +inf],
	spp in [-inf, +inf],
	q in [-inf, +inf],
	u in [-inf, +inf],
	rone_es in [-inf, +inf],
	ca in [-inf, +inf],
	sa in [-inf, +inf]
code: THEORY
BEGIN
f(lamdp, spp, q, u, rone_es, ca, sa: real): real =
	atan((((((1) - ((spp * spp) * rone_es)) * ((tan(lamdp)) * ca)) - ((spp * (sa * (sqrt(((((1) + (q * ((sin(lamdp)) * (sin(lamdp))))) * ((1) - (spp * spp))) - ((spp * spp) * u)))))) / (cos(lamdp)))) / ((1) - ((spp * spp) * ((1) + u)))))
END code