
(FPCore (lambda1 lambda2 phi1 phi2) :precision binary64 (atan2 (* (sin (- lambda1 lambda2)) (cos phi2)) (- (* (cos phi1) (sin phi2)) (* (* (sin phi1) (cos phi2)) (cos (- lambda1 lambda2))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
return atan2((sin((lambda1 - lambda2)) * cos(phi2)), ((cos(phi1) * sin(phi2)) - ((sin(phi1) * cos(phi2)) * cos((lambda1 - lambda2)))));
}
real(8) function code(lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
code = atan2((sin((lambda1 - lambda2)) * cos(phi2)), ((cos(phi1) * sin(phi2)) - ((sin(phi1) * cos(phi2)) * cos((lambda1 - lambda2)))))
end function
public static double code(double lambda1, double lambda2, double phi1, double phi2) {
return Math.atan2((Math.sin((lambda1 - lambda2)) * Math.cos(phi2)), ((Math.cos(phi1) * Math.sin(phi2)) - ((Math.sin(phi1) * Math.cos(phi2)) * Math.cos((lambda1 - lambda2)))));
}
def code(lambda1, lambda2, phi1, phi2): return math.atan2((math.sin((lambda1 - lambda2)) * math.cos(phi2)), ((math.cos(phi1) * math.sin(phi2)) - ((math.sin(phi1) * math.cos(phi2)) * math.cos((lambda1 - lambda2)))))
function code(lambda1, lambda2, phi1, phi2) return atan(Float64(sin(Float64(lambda1 - lambda2)) * cos(phi2)), Float64(Float64(cos(phi1) * sin(phi2)) - Float64(Float64(sin(phi1) * cos(phi2)) * cos(Float64(lambda1 - lambda2))))) end
function tmp = code(lambda1, lambda2, phi1, phi2) tmp = atan2((sin((lambda1 - lambda2)) * cos(phi2)), ((cos(phi1) * sin(phi2)) - ((sin(phi1) * cos(phi2)) * cos((lambda1 - lambda2))))); end
code[lambda1_, lambda2_, phi1_, phi2_] := N[ArcTan[N[(N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] / N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] - N[(N[(N[Sin[phi1], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\tan^{-1}_* \frac{\sin \left(\lambda_1 - \lambda_2\right) \cdot \cos \phi_2}{\cos \phi_1 \cdot \sin \phi_2 - \left(\sin \phi_1 \cdot \cos \phi_2\right) \cdot \cos \left(\lambda_1 - \lambda_2\right)}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 33 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (lambda1 lambda2 phi1 phi2) :precision binary64 (atan2 (* (sin (- lambda1 lambda2)) (cos phi2)) (- (* (cos phi1) (sin phi2)) (* (* (sin phi1) (cos phi2)) (cos (- lambda1 lambda2))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
return atan2((sin((lambda1 - lambda2)) * cos(phi2)), ((cos(phi1) * sin(phi2)) - ((sin(phi1) * cos(phi2)) * cos((lambda1 - lambda2)))));
}
real(8) function code(lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
code = atan2((sin((lambda1 - lambda2)) * cos(phi2)), ((cos(phi1) * sin(phi2)) - ((sin(phi1) * cos(phi2)) * cos((lambda1 - lambda2)))))
end function
public static double code(double lambda1, double lambda2, double phi1, double phi2) {
return Math.atan2((Math.sin((lambda1 - lambda2)) * Math.cos(phi2)), ((Math.cos(phi1) * Math.sin(phi2)) - ((Math.sin(phi1) * Math.cos(phi2)) * Math.cos((lambda1 - lambda2)))));
}
def code(lambda1, lambda2, phi1, phi2): return math.atan2((math.sin((lambda1 - lambda2)) * math.cos(phi2)), ((math.cos(phi1) * math.sin(phi2)) - ((math.sin(phi1) * math.cos(phi2)) * math.cos((lambda1 - lambda2)))))
function code(lambda1, lambda2, phi1, phi2) return atan(Float64(sin(Float64(lambda1 - lambda2)) * cos(phi2)), Float64(Float64(cos(phi1) * sin(phi2)) - Float64(Float64(sin(phi1) * cos(phi2)) * cos(Float64(lambda1 - lambda2))))) end
function tmp = code(lambda1, lambda2, phi1, phi2) tmp = atan2((sin((lambda1 - lambda2)) * cos(phi2)), ((cos(phi1) * sin(phi2)) - ((sin(phi1) * cos(phi2)) * cos((lambda1 - lambda2))))); end
code[lambda1_, lambda2_, phi1_, phi2_] := N[ArcTan[N[(N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] / N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] - N[(N[(N[Sin[phi1], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\tan^{-1}_* \frac{\sin \left(\lambda_1 - \lambda_2\right) \cdot \cos \phi_2}{\cos \phi_1 \cdot \sin \phi_2 - \left(\sin \phi_1 \cdot \cos \phi_2\right) \cdot \cos \left(\lambda_1 - \lambda_2\right)}
\end{array}
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(atan2
(*
(fma (sin lambda1) (cos lambda2) (* (sin lambda2) (- (cos lambda1))))
(cos phi2))
(-
(* (cos phi1) (sin phi2))
(*
(sin phi1)
(*
(cbrt (pow (cos phi2) 2.0))
(*
(fma (cos lambda1) (cos lambda2) (* (sin lambda1) (sin lambda2)))
(cbrt (cos phi2))))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
return atan2((fma(sin(lambda1), cos(lambda2), (sin(lambda2) * -cos(lambda1))) * cos(phi2)), ((cos(phi1) * sin(phi2)) - (sin(phi1) * (cbrt(pow(cos(phi2), 2.0)) * (fma(cos(lambda1), cos(lambda2), (sin(lambda1) * sin(lambda2))) * cbrt(cos(phi2)))))));
}
function code(lambda1, lambda2, phi1, phi2) return atan(Float64(fma(sin(lambda1), cos(lambda2), Float64(sin(lambda2) * Float64(-cos(lambda1)))) * cos(phi2)), Float64(Float64(cos(phi1) * sin(phi2)) - Float64(sin(phi1) * Float64(cbrt((cos(phi2) ^ 2.0)) * Float64(fma(cos(lambda1), cos(lambda2), Float64(sin(lambda1) * sin(lambda2))) * cbrt(cos(phi2))))))) end
code[lambda1_, lambda2_, phi1_, phi2_] := N[ArcTan[N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision] + N[(N[Sin[lambda2], $MachinePrecision] * (-N[Cos[lambda1], $MachinePrecision])), $MachinePrecision]), $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] / N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] - N[(N[Sin[phi1], $MachinePrecision] * N[(N[Power[N[Power[N[Cos[phi2], $MachinePrecision], 2.0], $MachinePrecision], 1/3], $MachinePrecision] * N[(N[(N[Cos[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision] + N[(N[Sin[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Power[N[Cos[phi2], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\tan^{-1}_* \frac{\mathsf{fma}\left(\sin \lambda_1, \cos \lambda_2, \sin \lambda_2 \cdot \left(-\cos \lambda_1\right)\right) \cdot \cos \phi_2}{\cos \phi_1 \cdot \sin \phi_2 - \sin \phi_1 \cdot \left(\sqrt[3]{{\cos \phi_2}^{2}} \cdot \left(\mathsf{fma}\left(\cos \lambda_1, \cos \lambda_2, \sin \lambda_1 \cdot \sin \lambda_2\right) \cdot \sqrt[3]{\cos \phi_2}\right)\right)}
\end{array}
Initial program 78.8%
associate-*l*78.8%
Simplified78.8%
sin-diff86.8%
fma-neg86.8%
Applied egg-rr86.8%
cos-diff99.7%
flip-+99.7%
associate-*r/99.7%
*-commutative99.7%
*-commutative99.7%
*-commutative99.7%
Applied egg-rr99.7%
associate-/l*99.7%
*-commutative99.7%
difference-of-squares99.7%
*-commutative99.7%
fma-udef99.7%
*-commutative99.7%
Simplified99.7%
div-inv99.7%
add-cube-cbrt99.6%
associate-*l*99.6%
cbrt-unprod99.7%
pow199.7%
pow199.7%
pow-sqr99.7%
metadata-eval99.7%
Applied egg-rr99.7%
*-commutative99.7%
Simplified99.7%
Final simplification99.7%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(atan2
(*
(fma (sin lambda1) (cos lambda2) (* (sin lambda2) (- (cos lambda1))))
(cos phi2))
(-
(* (cos phi1) (sin phi2))
(*
(sin phi1)
(*
(cos phi2)
(fma (cos lambda1) (cos lambda2) (* (sin lambda1) (sin lambda2))))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
return atan2((fma(sin(lambda1), cos(lambda2), (sin(lambda2) * -cos(lambda1))) * cos(phi2)), ((cos(phi1) * sin(phi2)) - (sin(phi1) * (cos(phi2) * fma(cos(lambda1), cos(lambda2), (sin(lambda1) * sin(lambda2)))))));
}
function code(lambda1, lambda2, phi1, phi2) return atan(Float64(fma(sin(lambda1), cos(lambda2), Float64(sin(lambda2) * Float64(-cos(lambda1)))) * cos(phi2)), Float64(Float64(cos(phi1) * sin(phi2)) - Float64(sin(phi1) * Float64(cos(phi2) * fma(cos(lambda1), cos(lambda2), Float64(sin(lambda1) * sin(lambda2))))))) end
code[lambda1_, lambda2_, phi1_, phi2_] := N[ArcTan[N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision] + N[(N[Sin[lambda2], $MachinePrecision] * (-N[Cos[lambda1], $MachinePrecision])), $MachinePrecision]), $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] / N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] - N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision] + N[(N[Sin[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\tan^{-1}_* \frac{\mathsf{fma}\left(\sin \lambda_1, \cos \lambda_2, \sin \lambda_2 \cdot \left(-\cos \lambda_1\right)\right) \cdot \cos \phi_2}{\cos \phi_1 \cdot \sin \phi_2 - \sin \phi_1 \cdot \left(\cos \phi_2 \cdot \mathsf{fma}\left(\cos \lambda_1, \cos \lambda_2, \sin \lambda_1 \cdot \sin \lambda_2\right)\right)}
\end{array}
Initial program 78.8%
associate-*l*78.8%
Simplified78.8%
sin-diff86.8%
fma-neg86.8%
Applied egg-rr86.8%
cos-diff99.7%
*-commutative99.7%
Applied egg-rr99.7%
*-commutative99.7%
fma-udef99.7%
Simplified99.7%
Final simplification99.7%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0
(*
(fma (sin lambda1) (cos lambda2) (* (sin lambda2) (- (cos lambda1))))
(cos phi2)))
(t_1 (* (cos phi1) (sin phi2)))
(t_2 (- t_1 (* (sin phi1) (* (cos phi2) (cos (- lambda1 lambda2)))))))
(if (<= phi2 -380.0)
(atan2
(*
(cos phi2)
(- (* (sin lambda1) (cos lambda2)) (* (cos lambda1) (sin lambda2))))
t_2)
(if (<= phi2 850.0)
(atan2
t_0
(-
t_1
(*
(sin phi1)
(fma (cos lambda1) (cos lambda2) (* (sin lambda1) (sin lambda2))))))
(atan2 t_0 t_2)))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = fma(sin(lambda1), cos(lambda2), (sin(lambda2) * -cos(lambda1))) * cos(phi2);
double t_1 = cos(phi1) * sin(phi2);
double t_2 = t_1 - (sin(phi1) * (cos(phi2) * cos((lambda1 - lambda2))));
double tmp;
if (phi2 <= -380.0) {
tmp = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), t_2);
} else if (phi2 <= 850.0) {
tmp = atan2(t_0, (t_1 - (sin(phi1) * fma(cos(lambda1), cos(lambda2), (sin(lambda1) * sin(lambda2))))));
} else {
tmp = atan2(t_0, t_2);
}
return tmp;
}
function code(lambda1, lambda2, phi1, phi2) t_0 = Float64(fma(sin(lambda1), cos(lambda2), Float64(sin(lambda2) * Float64(-cos(lambda1)))) * cos(phi2)) t_1 = Float64(cos(phi1) * sin(phi2)) t_2 = Float64(t_1 - Float64(sin(phi1) * Float64(cos(phi2) * cos(Float64(lambda1 - lambda2))))) tmp = 0.0 if (phi2 <= -380.0) tmp = atan(Float64(cos(phi2) * Float64(Float64(sin(lambda1) * cos(lambda2)) - Float64(cos(lambda1) * sin(lambda2)))), t_2); elseif (phi2 <= 850.0) tmp = atan(t_0, Float64(t_1 - Float64(sin(phi1) * fma(cos(lambda1), cos(lambda2), Float64(sin(lambda1) * sin(lambda2)))))); else tmp = atan(t_0, t_2); end return tmp end
code[lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision] + N[(N[Sin[lambda2], $MachinePrecision] * (-N[Cos[lambda1], $MachinePrecision])), $MachinePrecision]), $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 - N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[phi2, -380.0], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision] - N[(N[Cos[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$2], $MachinePrecision], If[LessEqual[phi2, 850.0], N[ArcTan[t$95$0 / N[(t$95$1 - N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision] + N[(N[Sin[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[t$95$0 / t$95$2], $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(\sin \lambda_1, \cos \lambda_2, \sin \lambda_2 \cdot \left(-\cos \lambda_1\right)\right) \cdot \cos \phi_2\\
t_1 := \cos \phi_1 \cdot \sin \phi_2\\
t_2 := t_1 - \sin \phi_1 \cdot \left(\cos \phi_2 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)\\
\mathbf{if}\;\phi_2 \leq -380:\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \left(\sin \lambda_1 \cdot \cos \lambda_2 - \cos \lambda_1 \cdot \sin \lambda_2\right)}{t_2}\\
\mathbf{elif}\;\phi_2 \leq 850:\\
\;\;\;\;\tan^{-1}_* \frac{t_0}{t_1 - \sin \phi_1 \cdot \mathsf{fma}\left(\cos \lambda_1, \cos \lambda_2, \sin \lambda_1 \cdot \sin \lambda_2\right)}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{t_0}{t_2}\\
\end{array}
\end{array}
if phi2 < -380Initial program 79.9%
associate-*l*79.9%
Simplified79.9%
sin-diff63.6%
cancel-sign-sub-inv63.6%
Applied egg-rr90.0%
cancel-sign-sub-inv63.6%
Simplified90.0%
if -380 < phi2 < 850Initial program 81.0%
associate-*l*81.0%
Simplified81.0%
sin-diff87.3%
fma-neg87.3%
Applied egg-rr87.3%
cos-diff99.8%
flip-+99.8%
associate-*r/99.8%
*-commutative99.8%
*-commutative99.8%
*-commutative99.8%
Applied egg-rr99.8%
associate-/l*99.8%
*-commutative99.8%
difference-of-squares99.8%
*-commutative99.8%
fma-udef99.8%
*-commutative99.8%
Simplified99.8%
Taylor expanded in phi2 around 0 98.5%
fma-def98.6%
Simplified98.6%
if 850 < phi2 Initial program 74.1%
associate-*l*74.2%
Simplified74.2%
sin-diff82.9%
fma-neg82.9%
Applied egg-rr82.9%
Final simplification91.9%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(atan2
(*
(fma (sin lambda1) (cos lambda2) (* (sin lambda2) (- (cos lambda1))))
(cos phi2))
(-
(* (cos phi1) (sin phi2))
(*
(sin phi1)
(*
(cos phi2)
(+ (* (sin lambda1) (sin lambda2)) (* (cos lambda2) (cos lambda1))))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
return atan2((fma(sin(lambda1), cos(lambda2), (sin(lambda2) * -cos(lambda1))) * cos(phi2)), ((cos(phi1) * sin(phi2)) - (sin(phi1) * (cos(phi2) * ((sin(lambda1) * sin(lambda2)) + (cos(lambda2) * cos(lambda1)))))));
}
function code(lambda1, lambda2, phi1, phi2) return atan(Float64(fma(sin(lambda1), cos(lambda2), Float64(sin(lambda2) * Float64(-cos(lambda1)))) * cos(phi2)), Float64(Float64(cos(phi1) * sin(phi2)) - Float64(sin(phi1) * Float64(cos(phi2) * Float64(Float64(sin(lambda1) * sin(lambda2)) + Float64(cos(lambda2) * cos(lambda1))))))) end
code[lambda1_, lambda2_, phi1_, phi2_] := N[ArcTan[N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision] + N[(N[Sin[lambda2], $MachinePrecision] * (-N[Cos[lambda1], $MachinePrecision])), $MachinePrecision]), $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] / N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] - N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision] + N[(N[Cos[lambda2], $MachinePrecision] * N[Cos[lambda1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\tan^{-1}_* \frac{\mathsf{fma}\left(\sin \lambda_1, \cos \lambda_2, \sin \lambda_2 \cdot \left(-\cos \lambda_1\right)\right) \cdot \cos \phi_2}{\cos \phi_1 \cdot \sin \phi_2 - \sin \phi_1 \cdot \left(\cos \phi_2 \cdot \left(\sin \lambda_1 \cdot \sin \lambda_2 + \cos \lambda_2 \cdot \cos \lambda_1\right)\right)}
\end{array}
Initial program 78.8%
associate-*l*78.8%
Simplified78.8%
sin-diff86.8%
fma-neg86.8%
Applied egg-rr86.8%
cos-diff99.7%
+-commutative99.7%
*-commutative99.7%
Applied egg-rr99.7%
Final simplification99.7%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0
(*
(fma (sin lambda1) (cos lambda2) (* (sin lambda2) (- (cos lambda1))))
(cos phi2)))
(t_1 (* (cos phi1) (sin phi2)))
(t_2 (- t_1 (* (sin phi1) (* (cos phi2) (cos (- lambda1 lambda2)))))))
(if (<= phi2 -380.0)
(atan2
(*
(cos phi2)
(- (* (sin lambda1) (cos lambda2)) (* (cos lambda1) (sin lambda2))))
t_2)
(if (<= phi2 850.0)
(atan2
t_0
(-
t_1
(*
(sin phi1)
(+
(* (sin lambda1) (sin lambda2))
(* (cos lambda2) (cos lambda1))))))
(atan2 t_0 t_2)))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = fma(sin(lambda1), cos(lambda2), (sin(lambda2) * -cos(lambda1))) * cos(phi2);
double t_1 = cos(phi1) * sin(phi2);
double t_2 = t_1 - (sin(phi1) * (cos(phi2) * cos((lambda1 - lambda2))));
double tmp;
if (phi2 <= -380.0) {
tmp = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), t_2);
} else if (phi2 <= 850.0) {
tmp = atan2(t_0, (t_1 - (sin(phi1) * ((sin(lambda1) * sin(lambda2)) + (cos(lambda2) * cos(lambda1))))));
} else {
tmp = atan2(t_0, t_2);
}
return tmp;
}
function code(lambda1, lambda2, phi1, phi2) t_0 = Float64(fma(sin(lambda1), cos(lambda2), Float64(sin(lambda2) * Float64(-cos(lambda1)))) * cos(phi2)) t_1 = Float64(cos(phi1) * sin(phi2)) t_2 = Float64(t_1 - Float64(sin(phi1) * Float64(cos(phi2) * cos(Float64(lambda1 - lambda2))))) tmp = 0.0 if (phi2 <= -380.0) tmp = atan(Float64(cos(phi2) * Float64(Float64(sin(lambda1) * cos(lambda2)) - Float64(cos(lambda1) * sin(lambda2)))), t_2); elseif (phi2 <= 850.0) tmp = atan(t_0, Float64(t_1 - Float64(sin(phi1) * Float64(Float64(sin(lambda1) * sin(lambda2)) + Float64(cos(lambda2) * cos(lambda1)))))); else tmp = atan(t_0, t_2); end return tmp end
code[lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision] + N[(N[Sin[lambda2], $MachinePrecision] * (-N[Cos[lambda1], $MachinePrecision])), $MachinePrecision]), $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 - N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[phi2, -380.0], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision] - N[(N[Cos[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$2], $MachinePrecision], If[LessEqual[phi2, 850.0], N[ArcTan[t$95$0 / N[(t$95$1 - N[(N[Sin[phi1], $MachinePrecision] * N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision] + N[(N[Cos[lambda2], $MachinePrecision] * N[Cos[lambda1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[t$95$0 / t$95$2], $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(\sin \lambda_1, \cos \lambda_2, \sin \lambda_2 \cdot \left(-\cos \lambda_1\right)\right) \cdot \cos \phi_2\\
t_1 := \cos \phi_1 \cdot \sin \phi_2\\
t_2 := t_1 - \sin \phi_1 \cdot \left(\cos \phi_2 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)\\
\mathbf{if}\;\phi_2 \leq -380:\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \left(\sin \lambda_1 \cdot \cos \lambda_2 - \cos \lambda_1 \cdot \sin \lambda_2\right)}{t_2}\\
\mathbf{elif}\;\phi_2 \leq 850:\\
\;\;\;\;\tan^{-1}_* \frac{t_0}{t_1 - \sin \phi_1 \cdot \left(\sin \lambda_1 \cdot \sin \lambda_2 + \cos \lambda_2 \cdot \cos \lambda_1\right)}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{t_0}{t_2}\\
\end{array}
\end{array}
if phi2 < -380Initial program 79.9%
associate-*l*79.9%
Simplified79.9%
sin-diff63.6%
cancel-sign-sub-inv63.6%
Applied egg-rr90.0%
cancel-sign-sub-inv63.6%
Simplified90.0%
if -380 < phi2 < 850Initial program 81.0%
associate-*l*81.0%
Simplified81.0%
sin-diff87.3%
fma-neg87.3%
Applied egg-rr87.3%
cos-diff99.8%
flip-+99.8%
associate-*r/99.8%
*-commutative99.8%
*-commutative99.8%
*-commutative99.8%
Applied egg-rr99.8%
associate-/l*99.8%
*-commutative99.8%
difference-of-squares99.8%
*-commutative99.8%
fma-udef99.8%
*-commutative99.8%
Simplified99.8%
Taylor expanded in phi2 around 0 98.5%
if 850 < phi2 Initial program 74.1%
associate-*l*74.2%
Simplified74.2%
sin-diff82.9%
fma-neg82.9%
Applied egg-rr82.9%
Final simplification91.9%
(FPCore (lambda1 lambda2 phi1 phi2) :precision binary64 (atan2 (* (fma (sin lambda1) (cos lambda2) (* (sin lambda2) (- (cos lambda1)))) (cos phi2)) (- (* (cos phi1) (sin phi2)) (* (sin phi1) (* (cos phi2) (cos (- lambda1 lambda2)))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
return atan2((fma(sin(lambda1), cos(lambda2), (sin(lambda2) * -cos(lambda1))) * cos(phi2)), ((cos(phi1) * sin(phi2)) - (sin(phi1) * (cos(phi2) * cos((lambda1 - lambda2))))));
}
function code(lambda1, lambda2, phi1, phi2) return atan(Float64(fma(sin(lambda1), cos(lambda2), Float64(sin(lambda2) * Float64(-cos(lambda1)))) * cos(phi2)), Float64(Float64(cos(phi1) * sin(phi2)) - Float64(sin(phi1) * Float64(cos(phi2) * cos(Float64(lambda1 - lambda2)))))) end
code[lambda1_, lambda2_, phi1_, phi2_] := N[ArcTan[N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision] + N[(N[Sin[lambda2], $MachinePrecision] * (-N[Cos[lambda1], $MachinePrecision])), $MachinePrecision]), $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] / N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] - N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\tan^{-1}_* \frac{\mathsf{fma}\left(\sin \lambda_1, \cos \lambda_2, \sin \lambda_2 \cdot \left(-\cos \lambda_1\right)\right) \cdot \cos \phi_2}{\cos \phi_1 \cdot \sin \phi_2 - \sin \phi_1 \cdot \left(\cos \phi_2 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)}
\end{array}
Initial program 78.8%
associate-*l*78.8%
Simplified78.8%
sin-diff86.8%
fma-neg86.8%
Applied egg-rr86.8%
Final simplification86.8%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (cos phi1) (sin phi2))))
(if (or (<= lambda1 -6e-5) (not (<= lambda1 2.7e-6)))
(atan2
(*
(cos phi2)
(- (* (sin lambda1) (cos lambda2)) (* (cos lambda1) (sin lambda2))))
(- t_0 (* (cos phi2) (* (cos lambda1) (sin phi1)))))
(atan2
(* (cos phi2) (sin (- lambda1 lambda2)))
(+
t_0
(*
(sin phi1)
(* (cos phi2) (- (* lambda1 (sin (- lambda2))) (cos lambda2)))))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos(phi1) * sin(phi2);
double tmp;
if ((lambda1 <= -6e-5) || !(lambda1 <= 2.7e-6)) {
tmp = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), (t_0 - (cos(phi2) * (cos(lambda1) * sin(phi1)))));
} else {
tmp = atan2((cos(phi2) * sin((lambda1 - lambda2))), (t_0 + (sin(phi1) * (cos(phi2) * ((lambda1 * sin(-lambda2)) - cos(lambda2))))));
}
return tmp;
}
real(8) function code(lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: t_0
real(8) :: tmp
t_0 = cos(phi1) * sin(phi2)
if ((lambda1 <= (-6d-5)) .or. (.not. (lambda1 <= 2.7d-6))) then
tmp = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), (t_0 - (cos(phi2) * (cos(lambda1) * sin(phi1)))))
else
tmp = atan2((cos(phi2) * sin((lambda1 - lambda2))), (t_0 + (sin(phi1) * (cos(phi2) * ((lambda1 * sin(-lambda2)) - cos(lambda2))))))
end if
code = tmp
end function
public static double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = Math.cos(phi1) * Math.sin(phi2);
double tmp;
if ((lambda1 <= -6e-5) || !(lambda1 <= 2.7e-6)) {
tmp = Math.atan2((Math.cos(phi2) * ((Math.sin(lambda1) * Math.cos(lambda2)) - (Math.cos(lambda1) * Math.sin(lambda2)))), (t_0 - (Math.cos(phi2) * (Math.cos(lambda1) * Math.sin(phi1)))));
} else {
tmp = Math.atan2((Math.cos(phi2) * Math.sin((lambda1 - lambda2))), (t_0 + (Math.sin(phi1) * (Math.cos(phi2) * ((lambda1 * Math.sin(-lambda2)) - Math.cos(lambda2))))));
}
return tmp;
}
def code(lambda1, lambda2, phi1, phi2): t_0 = math.cos(phi1) * math.sin(phi2) tmp = 0 if (lambda1 <= -6e-5) or not (lambda1 <= 2.7e-6): tmp = math.atan2((math.cos(phi2) * ((math.sin(lambda1) * math.cos(lambda2)) - (math.cos(lambda1) * math.sin(lambda2)))), (t_0 - (math.cos(phi2) * (math.cos(lambda1) * math.sin(phi1))))) else: tmp = math.atan2((math.cos(phi2) * math.sin((lambda1 - lambda2))), (t_0 + (math.sin(phi1) * (math.cos(phi2) * ((lambda1 * math.sin(-lambda2)) - math.cos(lambda2)))))) return tmp
function code(lambda1, lambda2, phi1, phi2) t_0 = Float64(cos(phi1) * sin(phi2)) tmp = 0.0 if ((lambda1 <= -6e-5) || !(lambda1 <= 2.7e-6)) tmp = atan(Float64(cos(phi2) * Float64(Float64(sin(lambda1) * cos(lambda2)) - Float64(cos(lambda1) * sin(lambda2)))), Float64(t_0 - Float64(cos(phi2) * Float64(cos(lambda1) * sin(phi1))))); else tmp = atan(Float64(cos(phi2) * sin(Float64(lambda1 - lambda2))), Float64(t_0 + Float64(sin(phi1) * Float64(cos(phi2) * Float64(Float64(lambda1 * sin(Float64(-lambda2))) - cos(lambda2)))))); end return tmp end
function tmp_2 = code(lambda1, lambda2, phi1, phi2) t_0 = cos(phi1) * sin(phi2); tmp = 0.0; if ((lambda1 <= -6e-5) || ~((lambda1 <= 2.7e-6))) tmp = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), (t_0 - (cos(phi2) * (cos(lambda1) * sin(phi1))))); else tmp = atan2((cos(phi2) * sin((lambda1 - lambda2))), (t_0 + (sin(phi1) * (cos(phi2) * ((lambda1 * sin(-lambda2)) - cos(lambda2)))))); end tmp_2 = tmp; end
code[lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[lambda1, -6e-5], N[Not[LessEqual[lambda1, 2.7e-6]], $MachinePrecision]], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision] - N[(N[Cos[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(t$95$0 - N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[lambda1], $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(t$95$0 + N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * N[(N[(lambda1 * N[Sin[(-lambda2)], $MachinePrecision]), $MachinePrecision] - N[Cos[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \cos \phi_1 \cdot \sin \phi_2\\
\mathbf{if}\;\lambda_1 \leq -6 \cdot 10^{-5} \lor \neg \left(\lambda_1 \leq 2.7 \cdot 10^{-6}\right):\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \left(\sin \lambda_1 \cdot \cos \lambda_2 - \cos \lambda_1 \cdot \sin \lambda_2\right)}{t_0 - \cos \phi_2 \cdot \left(\cos \lambda_1 \cdot \sin \phi_1\right)}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{t_0 + \sin \phi_1 \cdot \left(\cos \phi_2 \cdot \left(\lambda_1 \cdot \sin \left(-\lambda_2\right) - \cos \lambda_2\right)\right)}\\
\end{array}
\end{array}
if lambda1 < -6.00000000000000015e-5 or 2.69999999999999998e-6 < lambda1 Initial program 62.5%
associate-*l*62.5%
Simplified62.5%
cos-mult52.3%
sum-cos51.6%
associate-/l*51.6%
+-commutative51.6%
associate-+l+51.6%
associate--r-51.6%
+-commutative51.6%
Applied egg-rr51.6%
associate-/r/51.6%
metadata-eval51.6%
*-lft-identity51.6%
associate-+r+51.6%
+-commutative51.6%
associate-+l+51.4%
+-commutative51.4%
associate-+l-51.4%
Simplified51.4%
sin-diff55.9%
cancel-sign-sub-inv55.9%
Applied egg-rr65.8%
cancel-sign-sub-inv55.9%
Simplified65.8%
Taylor expanded in lambda2 around 0 76.8%
*-commutative76.8%
associate-*l*76.8%
Simplified76.8%
if -6.00000000000000015e-5 < lambda1 < 2.69999999999999998e-6Initial program 99.2%
associate-*l*99.2%
Simplified99.2%
Taylor expanded in lambda1 around 0 99.4%
cos-neg99.4%
mul-1-neg99.4%
unsub-neg99.4%
Simplified99.4%
Final simplification86.9%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (cos phi1) (sin phi2))))
(if (or (<= lambda2 -0.45) (not (<= lambda2 126.0)))
(atan2
(*
(cos phi2)
(- (* (sin lambda1) (cos lambda2)) (* (cos lambda1) (sin lambda2))))
(- t_0 (* (sin phi1) (* (cos lambda2) (cos phi2)))))
(atan2
(* (cos phi2) (fma (sin lambda1) (cos lambda2) (- (sin lambda2))))
(- t_0 (* (sin phi1) (* (cos phi2) (cos (- lambda1 lambda2)))))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos(phi1) * sin(phi2);
double tmp;
if ((lambda2 <= -0.45) || !(lambda2 <= 126.0)) {
tmp = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), (t_0 - (sin(phi1) * (cos(lambda2) * cos(phi2)))));
} else {
tmp = atan2((cos(phi2) * fma(sin(lambda1), cos(lambda2), -sin(lambda2))), (t_0 - (sin(phi1) * (cos(phi2) * cos((lambda1 - lambda2))))));
}
return tmp;
}
function code(lambda1, lambda2, phi1, phi2) t_0 = Float64(cos(phi1) * sin(phi2)) tmp = 0.0 if ((lambda2 <= -0.45) || !(lambda2 <= 126.0)) tmp = atan(Float64(cos(phi2) * Float64(Float64(sin(lambda1) * cos(lambda2)) - Float64(cos(lambda1) * sin(lambda2)))), Float64(t_0 - Float64(sin(phi1) * Float64(cos(lambda2) * cos(phi2))))); else tmp = atan(Float64(cos(phi2) * fma(sin(lambda1), cos(lambda2), Float64(-sin(lambda2)))), Float64(t_0 - Float64(sin(phi1) * Float64(cos(phi2) * cos(Float64(lambda1 - lambda2)))))); end return tmp end
code[lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[lambda2, -0.45], N[Not[LessEqual[lambda2, 126.0]], $MachinePrecision]], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision] - N[(N[Cos[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(t$95$0 - N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[lambda2], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision] + (-N[Sin[lambda2], $MachinePrecision])), $MachinePrecision]), $MachinePrecision] / N[(t$95$0 - N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \cos \phi_1 \cdot \sin \phi_2\\
\mathbf{if}\;\lambda_2 \leq -0.45 \lor \neg \left(\lambda_2 \leq 126\right):\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \left(\sin \lambda_1 \cdot \cos \lambda_2 - \cos \lambda_1 \cdot \sin \lambda_2\right)}{t_0 - \sin \phi_1 \cdot \left(\cos \lambda_2 \cdot \cos \phi_2\right)}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \mathsf{fma}\left(\sin \lambda_1, \cos \lambda_2, -\sin \lambda_2\right)}{t_0 - \sin \phi_1 \cdot \left(\cos \phi_2 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)}\\
\end{array}
\end{array}
if lambda2 < -0.450000000000000011 or 126 < lambda2 Initial program 56.9%
associate-*l*57.0%
Simplified57.0%
add-log-exp56.9%
Applied egg-rr56.9%
Taylor expanded in lambda1 around 0 56.9%
cos-neg56.9%
Simplified56.9%
add-log-exp56.9%
sin-diff74.0%
cancel-sign-sub-inv74.0%
Applied egg-rr74.0%
cancel-sign-sub-inv74.0%
*-commutative74.0%
Simplified74.0%
if -0.450000000000000011 < lambda2 < 126Initial program 98.1%
associate-*l*98.1%
Simplified98.1%
sin-diff98.3%
fma-neg98.3%
Applied egg-rr98.3%
Taylor expanded in lambda1 around 0 98.3%
Final simplification86.9%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (cos phi1) (sin phi2))) (t_1 (cos (- lambda1 lambda2))))
(if (or (<= phi1 -2.6e+26) (not (<= phi1 0.07)))
(atan2
(* (cos phi2) (fma (sin lambda1) (cos lambda2) (- (sin lambda2))))
(- t_0 (* (sin phi1) (* (cos phi2) t_1))))
(atan2
(*
(cos phi2)
(- (* (sin lambda1) (cos lambda2)) (* (cos lambda1) (sin lambda2))))
(- t_0 (* (sin phi1) t_1))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos(phi1) * sin(phi2);
double t_1 = cos((lambda1 - lambda2));
double tmp;
if ((phi1 <= -2.6e+26) || !(phi1 <= 0.07)) {
tmp = atan2((cos(phi2) * fma(sin(lambda1), cos(lambda2), -sin(lambda2))), (t_0 - (sin(phi1) * (cos(phi2) * t_1))));
} else {
tmp = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), (t_0 - (sin(phi1) * t_1)));
}
return tmp;
}
function code(lambda1, lambda2, phi1, phi2) t_0 = Float64(cos(phi1) * sin(phi2)) t_1 = cos(Float64(lambda1 - lambda2)) tmp = 0.0 if ((phi1 <= -2.6e+26) || !(phi1 <= 0.07)) tmp = atan(Float64(cos(phi2) * fma(sin(lambda1), cos(lambda2), Float64(-sin(lambda2)))), Float64(t_0 - Float64(sin(phi1) * Float64(cos(phi2) * t_1)))); else tmp = atan(Float64(cos(phi2) * Float64(Float64(sin(lambda1) * cos(lambda2)) - Float64(cos(lambda1) * sin(lambda2)))), Float64(t_0 - Float64(sin(phi1) * t_1))); end return tmp end
code[lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]}, If[Or[LessEqual[phi1, -2.6e+26], N[Not[LessEqual[phi1, 0.07]], $MachinePrecision]], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision] + (-N[Sin[lambda2], $MachinePrecision])), $MachinePrecision]), $MachinePrecision] / N[(t$95$0 - N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision] - N[(N[Cos[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(t$95$0 - N[(N[Sin[phi1], $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \cos \phi_1 \cdot \sin \phi_2\\
t_1 := \cos \left(\lambda_1 - \lambda_2\right)\\
\mathbf{if}\;\phi_1 \leq -2.6 \cdot 10^{+26} \lor \neg \left(\phi_1 \leq 0.07\right):\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \mathsf{fma}\left(\sin \lambda_1, \cos \lambda_2, -\sin \lambda_2\right)}{t_0 - \sin \phi_1 \cdot \left(\cos \phi_2 \cdot t_1\right)}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \left(\sin \lambda_1 \cdot \cos \lambda_2 - \cos \lambda_1 \cdot \sin \lambda_2\right)}{t_0 - \sin \phi_1 \cdot t_1}\\
\end{array}
\end{array}
if phi1 < -2.60000000000000002e26 or 0.070000000000000007 < phi1 Initial program 74.1%
associate-*l*74.1%
Simplified74.1%
sin-diff77.5%
fma-neg77.5%
Applied egg-rr77.5%
Taylor expanded in lambda1 around 0 75.5%
if -2.60000000000000002e26 < phi1 < 0.070000000000000007Initial program 83.5%
associate-*l*83.5%
Simplified83.5%
Taylor expanded in phi2 around 0 83.4%
sin-diff90.2%
cancel-sign-sub-inv90.2%
Applied egg-rr96.0%
cancel-sign-sub-inv90.2%
Simplified96.0%
Final simplification85.8%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (cos phi1) (sin phi2))) (t_1 (cos (- lambda1 lambda2))))
(if (or (<= phi1 -2.6e+26) (not (<= phi1 0.07)))
(atan2
(* (cos phi2) (fma (sin lambda1) (cos lambda2) (- (sin lambda2))))
(- t_0 (* (sin phi1) (* (cos phi2) t_1))))
(atan2
(*
(fma (sin lambda1) (cos lambda2) (* (sin lambda2) (- (cos lambda1))))
(cos phi2))
(- t_0 (* (sin phi1) t_1))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos(phi1) * sin(phi2);
double t_1 = cos((lambda1 - lambda2));
double tmp;
if ((phi1 <= -2.6e+26) || !(phi1 <= 0.07)) {
tmp = atan2((cos(phi2) * fma(sin(lambda1), cos(lambda2), -sin(lambda2))), (t_0 - (sin(phi1) * (cos(phi2) * t_1))));
} else {
tmp = atan2((fma(sin(lambda1), cos(lambda2), (sin(lambda2) * -cos(lambda1))) * cos(phi2)), (t_0 - (sin(phi1) * t_1)));
}
return tmp;
}
function code(lambda1, lambda2, phi1, phi2) t_0 = Float64(cos(phi1) * sin(phi2)) t_1 = cos(Float64(lambda1 - lambda2)) tmp = 0.0 if ((phi1 <= -2.6e+26) || !(phi1 <= 0.07)) tmp = atan(Float64(cos(phi2) * fma(sin(lambda1), cos(lambda2), Float64(-sin(lambda2)))), Float64(t_0 - Float64(sin(phi1) * Float64(cos(phi2) * t_1)))); else tmp = atan(Float64(fma(sin(lambda1), cos(lambda2), Float64(sin(lambda2) * Float64(-cos(lambda1)))) * cos(phi2)), Float64(t_0 - Float64(sin(phi1) * t_1))); end return tmp end
code[lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]}, If[Or[LessEqual[phi1, -2.6e+26], N[Not[LessEqual[phi1, 0.07]], $MachinePrecision]], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision] + (-N[Sin[lambda2], $MachinePrecision])), $MachinePrecision]), $MachinePrecision] / N[(t$95$0 - N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision] + N[(N[Sin[lambda2], $MachinePrecision] * (-N[Cos[lambda1], $MachinePrecision])), $MachinePrecision]), $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] / N[(t$95$0 - N[(N[Sin[phi1], $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \cos \phi_1 \cdot \sin \phi_2\\
t_1 := \cos \left(\lambda_1 - \lambda_2\right)\\
\mathbf{if}\;\phi_1 \leq -2.6 \cdot 10^{+26} \lor \neg \left(\phi_1 \leq 0.07\right):\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \mathsf{fma}\left(\sin \lambda_1, \cos \lambda_2, -\sin \lambda_2\right)}{t_0 - \sin \phi_1 \cdot \left(\cos \phi_2 \cdot t_1\right)}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{\mathsf{fma}\left(\sin \lambda_1, \cos \lambda_2, \sin \lambda_2 \cdot \left(-\cos \lambda_1\right)\right) \cdot \cos \phi_2}{t_0 - \sin \phi_1 \cdot t_1}\\
\end{array}
\end{array}
if phi1 < -2.60000000000000002e26 or 0.070000000000000007 < phi1 Initial program 74.1%
associate-*l*74.1%
Simplified74.1%
sin-diff77.5%
fma-neg77.5%
Applied egg-rr77.5%
Taylor expanded in lambda1 around 0 75.5%
if -2.60000000000000002e26 < phi1 < 0.070000000000000007Initial program 83.5%
associate-*l*83.5%
Simplified83.5%
sin-diff96.0%
fma-neg96.1%
Applied egg-rr96.1%
Taylor expanded in phi2 around 0 96.0%
Final simplification85.8%
(FPCore (lambda1 lambda2 phi1 phi2) :precision binary64 (atan2 (* (cos phi2) (- (* (sin lambda1) (cos lambda2)) (* (cos lambda1) (sin lambda2)))) (- (* (cos phi1) (sin phi2)) (* (sin phi1) (* (cos phi2) (cos (- lambda1 lambda2)))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
return atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), ((cos(phi1) * sin(phi2)) - (sin(phi1) * (cos(phi2) * cos((lambda1 - lambda2))))));
}
real(8) function code(lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
code = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), ((cos(phi1) * sin(phi2)) - (sin(phi1) * (cos(phi2) * cos((lambda1 - lambda2))))))
end function
public static double code(double lambda1, double lambda2, double phi1, double phi2) {
return Math.atan2((Math.cos(phi2) * ((Math.sin(lambda1) * Math.cos(lambda2)) - (Math.cos(lambda1) * Math.sin(lambda2)))), ((Math.cos(phi1) * Math.sin(phi2)) - (Math.sin(phi1) * (Math.cos(phi2) * Math.cos((lambda1 - lambda2))))));
}
def code(lambda1, lambda2, phi1, phi2): return math.atan2((math.cos(phi2) * ((math.sin(lambda1) * math.cos(lambda2)) - (math.cos(lambda1) * math.sin(lambda2)))), ((math.cos(phi1) * math.sin(phi2)) - (math.sin(phi1) * (math.cos(phi2) * math.cos((lambda1 - lambda2))))))
function code(lambda1, lambda2, phi1, phi2) return atan(Float64(cos(phi2) * Float64(Float64(sin(lambda1) * cos(lambda2)) - Float64(cos(lambda1) * sin(lambda2)))), Float64(Float64(cos(phi1) * sin(phi2)) - Float64(sin(phi1) * Float64(cos(phi2) * cos(Float64(lambda1 - lambda2)))))) end
function tmp = code(lambda1, lambda2, phi1, phi2) tmp = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), ((cos(phi1) * sin(phi2)) - (sin(phi1) * (cos(phi2) * cos((lambda1 - lambda2)))))); end
code[lambda1_, lambda2_, phi1_, phi2_] := N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision] - N[(N[Cos[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] - N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\tan^{-1}_* \frac{\cos \phi_2 \cdot \left(\sin \lambda_1 \cdot \cos \lambda_2 - \cos \lambda_1 \cdot \sin \lambda_2\right)}{\cos \phi_1 \cdot \sin \phi_2 - \sin \phi_1 \cdot \left(\cos \phi_2 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)}
\end{array}
Initial program 78.8%
associate-*l*78.8%
Simplified78.8%
sin-diff56.1%
cancel-sign-sub-inv56.1%
Applied egg-rr86.8%
cancel-sign-sub-inv56.1%
Simplified86.8%
Final simplification86.8%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (cos phi1) (sin phi2)))
(t_1 (cos (- lambda1 lambda2)))
(t_2 (sin (- lambda1 lambda2))))
(if (<= phi1 -4.3e+30)
(atan2
(* (cos phi2) (expm1 (log1p t_2)))
(- t_0 (* (sin phi1) (* (cos phi2) t_1))))
(if (<= phi1 0.07)
(atan2
(*
(cos phi2)
(- (* (sin lambda1) (cos lambda2)) (* (cos lambda1) (sin lambda2))))
(- t_0 (* (sin phi1) t_1)))
(atan2
(* (cos phi2) t_2)
(- t_0 (* (sin phi1) (* (cos phi2) (log1p (expm1 t_1))))))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos(phi1) * sin(phi2);
double t_1 = cos((lambda1 - lambda2));
double t_2 = sin((lambda1 - lambda2));
double tmp;
if (phi1 <= -4.3e+30) {
tmp = atan2((cos(phi2) * expm1(log1p(t_2))), (t_0 - (sin(phi1) * (cos(phi2) * t_1))));
} else if (phi1 <= 0.07) {
tmp = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), (t_0 - (sin(phi1) * t_1)));
} else {
tmp = atan2((cos(phi2) * t_2), (t_0 - (sin(phi1) * (cos(phi2) * log1p(expm1(t_1))))));
}
return tmp;
}
public static double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = Math.cos(phi1) * Math.sin(phi2);
double t_1 = Math.cos((lambda1 - lambda2));
double t_2 = Math.sin((lambda1 - lambda2));
double tmp;
if (phi1 <= -4.3e+30) {
tmp = Math.atan2((Math.cos(phi2) * Math.expm1(Math.log1p(t_2))), (t_0 - (Math.sin(phi1) * (Math.cos(phi2) * t_1))));
} else if (phi1 <= 0.07) {
tmp = Math.atan2((Math.cos(phi2) * ((Math.sin(lambda1) * Math.cos(lambda2)) - (Math.cos(lambda1) * Math.sin(lambda2)))), (t_0 - (Math.sin(phi1) * t_1)));
} else {
tmp = Math.atan2((Math.cos(phi2) * t_2), (t_0 - (Math.sin(phi1) * (Math.cos(phi2) * Math.log1p(Math.expm1(t_1))))));
}
return tmp;
}
def code(lambda1, lambda2, phi1, phi2): t_0 = math.cos(phi1) * math.sin(phi2) t_1 = math.cos((lambda1 - lambda2)) t_2 = math.sin((lambda1 - lambda2)) tmp = 0 if phi1 <= -4.3e+30: tmp = math.atan2((math.cos(phi2) * math.expm1(math.log1p(t_2))), (t_0 - (math.sin(phi1) * (math.cos(phi2) * t_1)))) elif phi1 <= 0.07: tmp = math.atan2((math.cos(phi2) * ((math.sin(lambda1) * math.cos(lambda2)) - (math.cos(lambda1) * math.sin(lambda2)))), (t_0 - (math.sin(phi1) * t_1))) else: tmp = math.atan2((math.cos(phi2) * t_2), (t_0 - (math.sin(phi1) * (math.cos(phi2) * math.log1p(math.expm1(t_1)))))) return tmp
function code(lambda1, lambda2, phi1, phi2) t_0 = Float64(cos(phi1) * sin(phi2)) t_1 = cos(Float64(lambda1 - lambda2)) t_2 = sin(Float64(lambda1 - lambda2)) tmp = 0.0 if (phi1 <= -4.3e+30) tmp = atan(Float64(cos(phi2) * expm1(log1p(t_2))), Float64(t_0 - Float64(sin(phi1) * Float64(cos(phi2) * t_1)))); elseif (phi1 <= 0.07) tmp = atan(Float64(cos(phi2) * Float64(Float64(sin(lambda1) * cos(lambda2)) - Float64(cos(lambda1) * sin(lambda2)))), Float64(t_0 - Float64(sin(phi1) * t_1))); else tmp = atan(Float64(cos(phi2) * t_2), Float64(t_0 - Float64(sin(phi1) * Float64(cos(phi2) * log1p(expm1(t_1)))))); end return tmp end
code[lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[phi1, -4.3e+30], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[(Exp[N[Log[1 + t$95$2], $MachinePrecision]] - 1), $MachinePrecision]), $MachinePrecision] / N[(t$95$0 - N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[phi1, 0.07], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision] - N[(N[Cos[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(t$95$0 - N[(N[Sin[phi1], $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * t$95$2), $MachinePrecision] / N[(t$95$0 - N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * N[Log[1 + N[(Exp[t$95$1] - 1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \cos \phi_1 \cdot \sin \phi_2\\
t_1 := \cos \left(\lambda_1 - \lambda_2\right)\\
t_2 := \sin \left(\lambda_1 - \lambda_2\right)\\
\mathbf{if}\;\phi_1 \leq -4.3 \cdot 10^{+30}:\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \mathsf{expm1}\left(\mathsf{log1p}\left(t_2\right)\right)}{t_0 - \sin \phi_1 \cdot \left(\cos \phi_2 \cdot t_1\right)}\\
\mathbf{elif}\;\phi_1 \leq 0.07:\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \left(\sin \lambda_1 \cdot \cos \lambda_2 - \cos \lambda_1 \cdot \sin \lambda_2\right)}{t_0 - \sin \phi_1 \cdot t_1}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot t_2}{t_0 - \sin \phi_1 \cdot \left(\cos \phi_2 \cdot \mathsf{log1p}\left(\mathsf{expm1}\left(t_1\right)\right)\right)}\\
\end{array}
\end{array}
if phi1 < -4.3e30Initial program 81.1%
associate-*l*81.1%
Simplified81.1%
expm1-log1p-u81.2%
Applied egg-rr81.2%
if -4.3e30 < phi1 < 0.070000000000000007Initial program 82.8%
associate-*l*82.8%
Simplified82.8%
Taylor expanded in phi2 around 0 82.8%
sin-diff89.7%
cancel-sign-sub-inv89.7%
Applied egg-rr95.4%
cancel-sign-sub-inv89.7%
Simplified95.4%
if 0.070000000000000007 < phi1 Initial program 68.4%
associate-*l*68.4%
Simplified68.4%
log1p-expm1-u68.5%
Applied egg-rr68.5%
Final simplification85.2%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (cos phi1) (sin phi2)))
(t_1 (cos (- lambda1 lambda2)))
(t_2 (sin (- lambda1 lambda2))))
(if (<= phi1 -5.4e-16)
(atan2
(* (cos phi2) (expm1 (log1p t_2)))
(- t_0 (* (sin phi1) (* (cos phi2) t_1))))
(if (<= phi1 1.05e-64)
(atan2
(*
(fma (sin lambda1) (cos lambda2) (* (sin lambda2) (- (cos lambda1))))
(cos phi2))
(sin phi2))
(atan2
(* (cos phi2) t_2)
(- t_0 (* (sin phi1) (* (cos phi2) (log1p (expm1 t_1))))))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos(phi1) * sin(phi2);
double t_1 = cos((lambda1 - lambda2));
double t_2 = sin((lambda1 - lambda2));
double tmp;
if (phi1 <= -5.4e-16) {
tmp = atan2((cos(phi2) * expm1(log1p(t_2))), (t_0 - (sin(phi1) * (cos(phi2) * t_1))));
} else if (phi1 <= 1.05e-64) {
tmp = atan2((fma(sin(lambda1), cos(lambda2), (sin(lambda2) * -cos(lambda1))) * cos(phi2)), sin(phi2));
} else {
tmp = atan2((cos(phi2) * t_2), (t_0 - (sin(phi1) * (cos(phi2) * log1p(expm1(t_1))))));
}
return tmp;
}
function code(lambda1, lambda2, phi1, phi2) t_0 = Float64(cos(phi1) * sin(phi2)) t_1 = cos(Float64(lambda1 - lambda2)) t_2 = sin(Float64(lambda1 - lambda2)) tmp = 0.0 if (phi1 <= -5.4e-16) tmp = atan(Float64(cos(phi2) * expm1(log1p(t_2))), Float64(t_0 - Float64(sin(phi1) * Float64(cos(phi2) * t_1)))); elseif (phi1 <= 1.05e-64) tmp = atan(Float64(fma(sin(lambda1), cos(lambda2), Float64(sin(lambda2) * Float64(-cos(lambda1)))) * cos(phi2)), sin(phi2)); else tmp = atan(Float64(cos(phi2) * t_2), Float64(t_0 - Float64(sin(phi1) * Float64(cos(phi2) * log1p(expm1(t_1)))))); end return tmp end
code[lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[phi1, -5.4e-16], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[(Exp[N[Log[1 + t$95$2], $MachinePrecision]] - 1), $MachinePrecision]), $MachinePrecision] / N[(t$95$0 - N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[phi1, 1.05e-64], N[ArcTan[N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision] + N[(N[Sin[lambda2], $MachinePrecision] * (-N[Cos[lambda1], $MachinePrecision])), $MachinePrecision]), $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] / N[Sin[phi2], $MachinePrecision]], $MachinePrecision], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * t$95$2), $MachinePrecision] / N[(t$95$0 - N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * N[Log[1 + N[(Exp[t$95$1] - 1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \cos \phi_1 \cdot \sin \phi_2\\
t_1 := \cos \left(\lambda_1 - \lambda_2\right)\\
t_2 := \sin \left(\lambda_1 - \lambda_2\right)\\
\mathbf{if}\;\phi_1 \leq -5.4 \cdot 10^{-16}:\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \mathsf{expm1}\left(\mathsf{log1p}\left(t_2\right)\right)}{t_0 - \sin \phi_1 \cdot \left(\cos \phi_2 \cdot t_1\right)}\\
\mathbf{elif}\;\phi_1 \leq 1.05 \cdot 10^{-64}:\\
\;\;\;\;\tan^{-1}_* \frac{\mathsf{fma}\left(\sin \lambda_1, \cos \lambda_2, \sin \lambda_2 \cdot \left(-\cos \lambda_1\right)\right) \cdot \cos \phi_2}{\sin \phi_2}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot t_2}{t_0 - \sin \phi_1 \cdot \left(\cos \phi_2 \cdot \mathsf{log1p}\left(\mathsf{expm1}\left(t_1\right)\right)\right)}\\
\end{array}
\end{array}
if phi1 < -5.39999999999999999e-16Initial program 76.5%
associate-*l*76.5%
Simplified76.5%
expm1-log1p-u76.5%
Applied egg-rr76.5%
if -5.39999999999999999e-16 < phi1 < 1.05000000000000006e-64Initial program 85.8%
associate-*l*85.8%
Simplified85.8%
Taylor expanded in phi2 around 0 85.8%
Taylor expanded in phi1 around 0 84.0%
sin-diff99.8%
fma-neg99.9%
Applied egg-rr98.1%
if 1.05000000000000006e-64 < phi1 Initial program 71.5%
associate-*l*71.5%
Simplified71.5%
log1p-expm1-u71.5%
Applied egg-rr71.5%
Final simplification83.9%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0
(-
(* (cos phi1) (sin phi2))
(* (sin phi1) (* (cos phi2) (cos (- lambda1 lambda2))))))
(t_1 (sin (- lambda1 lambda2))))
(if (<= phi1 -8e-17)
(atan2 (* (cos phi2) (expm1 (log1p t_1))) t_0)
(if (<= phi1 3.4e-64)
(atan2
(*
(fma (sin lambda1) (cos lambda2) (* (sin lambda2) (- (cos lambda1))))
(cos phi2))
(sin phi2))
(atan2 (* (cos phi2) t_1) t_0)))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = (cos(phi1) * sin(phi2)) - (sin(phi1) * (cos(phi2) * cos((lambda1 - lambda2))));
double t_1 = sin((lambda1 - lambda2));
double tmp;
if (phi1 <= -8e-17) {
tmp = atan2((cos(phi2) * expm1(log1p(t_1))), t_0);
} else if (phi1 <= 3.4e-64) {
tmp = atan2((fma(sin(lambda1), cos(lambda2), (sin(lambda2) * -cos(lambda1))) * cos(phi2)), sin(phi2));
} else {
tmp = atan2((cos(phi2) * t_1), t_0);
}
return tmp;
}
function code(lambda1, lambda2, phi1, phi2) t_0 = Float64(Float64(cos(phi1) * sin(phi2)) - Float64(sin(phi1) * Float64(cos(phi2) * cos(Float64(lambda1 - lambda2))))) t_1 = sin(Float64(lambda1 - lambda2)) tmp = 0.0 if (phi1 <= -8e-17) tmp = atan(Float64(cos(phi2) * expm1(log1p(t_1))), t_0); elseif (phi1 <= 3.4e-64) tmp = atan(Float64(fma(sin(lambda1), cos(lambda2), Float64(sin(lambda2) * Float64(-cos(lambda1)))) * cos(phi2)), sin(phi2)); else tmp = atan(Float64(cos(phi2) * t_1), t_0); end return tmp end
code[lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] - N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[phi1, -8e-17], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[(Exp[N[Log[1 + t$95$1], $MachinePrecision]] - 1), $MachinePrecision]), $MachinePrecision] / t$95$0], $MachinePrecision], If[LessEqual[phi1, 3.4e-64], N[ArcTan[N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision] + N[(N[Sin[lambda2], $MachinePrecision] * (-N[Cos[lambda1], $MachinePrecision])), $MachinePrecision]), $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] / N[Sin[phi2], $MachinePrecision]], $MachinePrecision], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * t$95$1), $MachinePrecision] / t$95$0], $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \cos \phi_1 \cdot \sin \phi_2 - \sin \phi_1 \cdot \left(\cos \phi_2 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)\\
t_1 := \sin \left(\lambda_1 - \lambda_2\right)\\
\mathbf{if}\;\phi_1 \leq -8 \cdot 10^{-17}:\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \mathsf{expm1}\left(\mathsf{log1p}\left(t_1\right)\right)}{t_0}\\
\mathbf{elif}\;\phi_1 \leq 3.4 \cdot 10^{-64}:\\
\;\;\;\;\tan^{-1}_* \frac{\mathsf{fma}\left(\sin \lambda_1, \cos \lambda_2, \sin \lambda_2 \cdot \left(-\cos \lambda_1\right)\right) \cdot \cos \phi_2}{\sin \phi_2}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot t_1}{t_0}\\
\end{array}
\end{array}
if phi1 < -8.00000000000000057e-17Initial program 76.5%
associate-*l*76.5%
Simplified76.5%
expm1-log1p-u76.5%
Applied egg-rr76.5%
if -8.00000000000000057e-17 < phi1 < 3.40000000000000012e-64Initial program 85.8%
associate-*l*85.8%
Simplified85.8%
Taylor expanded in phi2 around 0 85.8%
Taylor expanded in phi1 around 0 84.0%
sin-diff99.8%
fma-neg99.9%
Applied egg-rr98.1%
if 3.40000000000000012e-64 < phi1 Initial program 71.5%
associate-*l*71.5%
Simplified71.5%
Final simplification83.9%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(if (or (<= phi1 -5.2e-17) (not (<= phi1 2.9e-64)))
(atan2
(* (cos phi2) (sin (- lambda1 lambda2)))
(-
(* (cos phi1) (sin phi2))
(* (sin phi1) (* (cos phi2) (cos (- lambda1 lambda2))))))
(atan2
(*
(fma (sin lambda1) (cos lambda2) (* (sin lambda2) (- (cos lambda1))))
(cos phi2))
(sin phi2))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if ((phi1 <= -5.2e-17) || !(phi1 <= 2.9e-64)) {
tmp = atan2((cos(phi2) * sin((lambda1 - lambda2))), ((cos(phi1) * sin(phi2)) - (sin(phi1) * (cos(phi2) * cos((lambda1 - lambda2))))));
} else {
tmp = atan2((fma(sin(lambda1), cos(lambda2), (sin(lambda2) * -cos(lambda1))) * cos(phi2)), sin(phi2));
}
return tmp;
}
function code(lambda1, lambda2, phi1, phi2) tmp = 0.0 if ((phi1 <= -5.2e-17) || !(phi1 <= 2.9e-64)) tmp = atan(Float64(cos(phi2) * sin(Float64(lambda1 - lambda2))), Float64(Float64(cos(phi1) * sin(phi2)) - Float64(sin(phi1) * Float64(cos(phi2) * cos(Float64(lambda1 - lambda2)))))); else tmp = atan(Float64(fma(sin(lambda1), cos(lambda2), Float64(sin(lambda2) * Float64(-cos(lambda1)))) * cos(phi2)), sin(phi2)); end return tmp end
code[lambda1_, lambda2_, phi1_, phi2_] := If[Or[LessEqual[phi1, -5.2e-17], N[Not[LessEqual[phi1, 2.9e-64]], $MachinePrecision]], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] - N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision] + N[(N[Sin[lambda2], $MachinePrecision] * (-N[Cos[lambda1], $MachinePrecision])), $MachinePrecision]), $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] / N[Sin[phi2], $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_1 \leq -5.2 \cdot 10^{-17} \lor \neg \left(\phi_1 \leq 2.9 \cdot 10^{-64}\right):\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\cos \phi_1 \cdot \sin \phi_2 - \sin \phi_1 \cdot \left(\cos \phi_2 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{\mathsf{fma}\left(\sin \lambda_1, \cos \lambda_2, \sin \lambda_2 \cdot \left(-\cos \lambda_1\right)\right) \cdot \cos \phi_2}{\sin \phi_2}\\
\end{array}
\end{array}
if phi1 < -5.20000000000000006e-17 or 2.8999999999999999e-64 < phi1 Initial program 73.9%
associate-*l*73.9%
Simplified73.9%
if -5.20000000000000006e-17 < phi1 < 2.8999999999999999e-64Initial program 85.8%
associate-*l*85.8%
Simplified85.8%
Taylor expanded in phi2 around 0 85.8%
Taylor expanded in phi1 around 0 84.0%
sin-diff99.8%
fma-neg99.9%
Applied egg-rr98.1%
Final simplification83.9%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (cos phi1) (sin phi2))))
(if (<= lambda2 -2.4e-20)
(atan2
(* (cos phi2) (sin (- lambda2)))
(- t_0 (* (sin phi1) (* (cos lambda2) (cos phi2)))))
(if (<= lambda2 126.0)
(atan2
(* (sin lambda1) (cos phi2))
(- t_0 (* (sin phi1) (* (cos phi2) (cos (- lambda1 lambda2))))))
(atan2
(*
(fma (sin lambda1) (cos lambda2) (* (sin lambda2) (- (cos lambda1))))
(cos phi2))
(sin phi2))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos(phi1) * sin(phi2);
double tmp;
if (lambda2 <= -2.4e-20) {
tmp = atan2((cos(phi2) * sin(-lambda2)), (t_0 - (sin(phi1) * (cos(lambda2) * cos(phi2)))));
} else if (lambda2 <= 126.0) {
tmp = atan2((sin(lambda1) * cos(phi2)), (t_0 - (sin(phi1) * (cos(phi2) * cos((lambda1 - lambda2))))));
} else {
tmp = atan2((fma(sin(lambda1), cos(lambda2), (sin(lambda2) * -cos(lambda1))) * cos(phi2)), sin(phi2));
}
return tmp;
}
function code(lambda1, lambda2, phi1, phi2) t_0 = Float64(cos(phi1) * sin(phi2)) tmp = 0.0 if (lambda2 <= -2.4e-20) tmp = atan(Float64(cos(phi2) * sin(Float64(-lambda2))), Float64(t_0 - Float64(sin(phi1) * Float64(cos(lambda2) * cos(phi2))))); elseif (lambda2 <= 126.0) tmp = atan(Float64(sin(lambda1) * cos(phi2)), Float64(t_0 - Float64(sin(phi1) * Float64(cos(phi2) * cos(Float64(lambda1 - lambda2)))))); else tmp = atan(Float64(fma(sin(lambda1), cos(lambda2), Float64(sin(lambda2) * Float64(-cos(lambda1)))) * cos(phi2)), sin(phi2)); end return tmp end
code[lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[lambda2, -2.4e-20], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[Sin[(-lambda2)], $MachinePrecision]), $MachinePrecision] / N[(t$95$0 - N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[lambda2], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[lambda2, 126.0], N[ArcTan[N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] / N[(t$95$0 - N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision] + N[(N[Sin[lambda2], $MachinePrecision] * (-N[Cos[lambda1], $MachinePrecision])), $MachinePrecision]), $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] / N[Sin[phi2], $MachinePrecision]], $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \cos \phi_1 \cdot \sin \phi_2\\
\mathbf{if}\;\lambda_2 \leq -2.4 \cdot 10^{-20}:\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(-\lambda_2\right)}{t_0 - \sin \phi_1 \cdot \left(\cos \lambda_2 \cdot \cos \phi_2\right)}\\
\mathbf{elif}\;\lambda_2 \leq 126:\\
\;\;\;\;\tan^{-1}_* \frac{\sin \lambda_1 \cdot \cos \phi_2}{t_0 - \sin \phi_1 \cdot \left(\cos \phi_2 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{\mathsf{fma}\left(\sin \lambda_1, \cos \lambda_2, \sin \lambda_2 \cdot \left(-\cos \lambda_1\right)\right) \cdot \cos \phi_2}{\sin \phi_2}\\
\end{array}
\end{array}
if lambda2 < -2.39999999999999993e-20Initial program 65.3%
associate-*l*65.3%
Simplified65.3%
add-log-exp65.3%
Applied egg-rr65.3%
Taylor expanded in lambda1 around 0 65.2%
cos-neg65.2%
Simplified65.2%
Taylor expanded in lambda1 around 0 63.6%
if -2.39999999999999993e-20 < lambda2 < 126Initial program 98.7%
associate-*l*98.7%
Simplified98.7%
Taylor expanded in lambda2 around 0 88.5%
if 126 < lambda2 Initial program 48.5%
associate-*l*48.5%
Simplified48.5%
Taylor expanded in phi2 around 0 42.5%
Taylor expanded in phi1 around 0 32.1%
sin-diff70.0%
fma-neg70.0%
Applied egg-rr53.1%
Final simplification74.1%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (cos phi1) (sin phi2))))
(if (<= lambda2 -2100.0)
(atan2
(* (cos phi2) (sin (- lambda2)))
(- t_0 (* (sin phi1) (* (cos lambda2) (cos phi2)))))
(if (<= lambda2 750.0)
(atan2
(* (cos phi2) (sin (- lambda1 lambda2)))
(- t_0 (* (sin phi1) (* (cos lambda1) (cos phi2)))))
(atan2
(*
(fma (sin lambda1) (cos lambda2) (* (sin lambda2) (- (cos lambda1))))
(cos phi2))
(sin phi2))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos(phi1) * sin(phi2);
double tmp;
if (lambda2 <= -2100.0) {
tmp = atan2((cos(phi2) * sin(-lambda2)), (t_0 - (sin(phi1) * (cos(lambda2) * cos(phi2)))));
} else if (lambda2 <= 750.0) {
tmp = atan2((cos(phi2) * sin((lambda1 - lambda2))), (t_0 - (sin(phi1) * (cos(lambda1) * cos(phi2)))));
} else {
tmp = atan2((fma(sin(lambda1), cos(lambda2), (sin(lambda2) * -cos(lambda1))) * cos(phi2)), sin(phi2));
}
return tmp;
}
function code(lambda1, lambda2, phi1, phi2) t_0 = Float64(cos(phi1) * sin(phi2)) tmp = 0.0 if (lambda2 <= -2100.0) tmp = atan(Float64(cos(phi2) * sin(Float64(-lambda2))), Float64(t_0 - Float64(sin(phi1) * Float64(cos(lambda2) * cos(phi2))))); elseif (lambda2 <= 750.0) tmp = atan(Float64(cos(phi2) * sin(Float64(lambda1 - lambda2))), Float64(t_0 - Float64(sin(phi1) * Float64(cos(lambda1) * cos(phi2))))); else tmp = atan(Float64(fma(sin(lambda1), cos(lambda2), Float64(sin(lambda2) * Float64(-cos(lambda1)))) * cos(phi2)), sin(phi2)); end return tmp end
code[lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[lambda2, -2100.0], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[Sin[(-lambda2)], $MachinePrecision]), $MachinePrecision] / N[(t$95$0 - N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[lambda2], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[lambda2, 750.0], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(t$95$0 - N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[lambda1], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision] + N[(N[Sin[lambda2], $MachinePrecision] * (-N[Cos[lambda1], $MachinePrecision])), $MachinePrecision]), $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] / N[Sin[phi2], $MachinePrecision]], $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \cos \phi_1 \cdot \sin \phi_2\\
\mathbf{if}\;\lambda_2 \leq -2100:\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(-\lambda_2\right)}{t_0 - \sin \phi_1 \cdot \left(\cos \lambda_2 \cdot \cos \phi_2\right)}\\
\mathbf{elif}\;\lambda_2 \leq 750:\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{t_0 - \sin \phi_1 \cdot \left(\cos \lambda_1 \cdot \cos \phi_2\right)}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{\mathsf{fma}\left(\sin \lambda_1, \cos \lambda_2, \sin \lambda_2 \cdot \left(-\cos \lambda_1\right)\right) \cdot \cos \phi_2}{\sin \phi_2}\\
\end{array}
\end{array}
if lambda2 < -2100Initial program 65.6%
associate-*l*65.6%
Simplified65.6%
add-log-exp65.6%
Applied egg-rr65.6%
Taylor expanded in lambda1 around 0 65.6%
cos-neg65.6%
Simplified65.6%
Taylor expanded in lambda1 around 0 63.9%
if -2100 < lambda2 < 750Initial program 97.6%
associate-*l*97.6%
Simplified97.6%
Taylor expanded in lambda2 around 0 97.0%
if 750 < lambda2 Initial program 47.6%
associate-*l*47.6%
Simplified47.6%
Taylor expanded in phi2 around 0 42.7%
Taylor expanded in phi1 around 0 32.3%
sin-diff69.5%
fma-neg69.5%
Applied egg-rr53.7%
Final simplification79.4%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (cos phi2) (sin (- lambda1 lambda2))))
(t_1 (* (cos phi1) (sin phi2))))
(if (<= lambda1 -0.52)
(atan2
(*
(fma (sin lambda1) (cos lambda2) (* (sin lambda2) (- (cos lambda1))))
(cos phi2))
(sin phi2))
(if (<= lambda1 2.25e-6)
(atan2 t_0 (- t_1 (* (sin phi1) (* (cos lambda2) (cos phi2)))))
(atan2 t_0 (- t_1 (* (sin phi1) (* (cos lambda1) (cos phi2)))))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos(phi2) * sin((lambda1 - lambda2));
double t_1 = cos(phi1) * sin(phi2);
double tmp;
if (lambda1 <= -0.52) {
tmp = atan2((fma(sin(lambda1), cos(lambda2), (sin(lambda2) * -cos(lambda1))) * cos(phi2)), sin(phi2));
} else if (lambda1 <= 2.25e-6) {
tmp = atan2(t_0, (t_1 - (sin(phi1) * (cos(lambda2) * cos(phi2)))));
} else {
tmp = atan2(t_0, (t_1 - (sin(phi1) * (cos(lambda1) * cos(phi2)))));
}
return tmp;
}
function code(lambda1, lambda2, phi1, phi2) t_0 = Float64(cos(phi2) * sin(Float64(lambda1 - lambda2))) t_1 = Float64(cos(phi1) * sin(phi2)) tmp = 0.0 if (lambda1 <= -0.52) tmp = atan(Float64(fma(sin(lambda1), cos(lambda2), Float64(sin(lambda2) * Float64(-cos(lambda1)))) * cos(phi2)), sin(phi2)); elseif (lambda1 <= 2.25e-6) tmp = atan(t_0, Float64(t_1 - Float64(sin(phi1) * Float64(cos(lambda2) * cos(phi2))))); else tmp = atan(t_0, Float64(t_1 - Float64(sin(phi1) * Float64(cos(lambda1) * cos(phi2))))); end return tmp end
code[lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[Cos[phi2], $MachinePrecision] * N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[lambda1, -0.52], N[ArcTan[N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision] + N[(N[Sin[lambda2], $MachinePrecision] * (-N[Cos[lambda1], $MachinePrecision])), $MachinePrecision]), $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] / N[Sin[phi2], $MachinePrecision]], $MachinePrecision], If[LessEqual[lambda1, 2.25e-6], N[ArcTan[t$95$0 / N[(t$95$1 - N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[lambda2], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[t$95$0 / N[(t$95$1 - N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[lambda1], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)\\
t_1 := \cos \phi_1 \cdot \sin \phi_2\\
\mathbf{if}\;\lambda_1 \leq -0.52:\\
\;\;\;\;\tan^{-1}_* \frac{\mathsf{fma}\left(\sin \lambda_1, \cos \lambda_2, \sin \lambda_2 \cdot \left(-\cos \lambda_1\right)\right) \cdot \cos \phi_2}{\sin \phi_2}\\
\mathbf{elif}\;\lambda_1 \leq 2.25 \cdot 10^{-6}:\\
\;\;\;\;\tan^{-1}_* \frac{t_0}{t_1 - \sin \phi_1 \cdot \left(\cos \lambda_2 \cdot \cos \phi_2\right)}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{t_0}{t_1 - \sin \phi_1 \cdot \left(\cos \lambda_1 \cdot \cos \phi_2\right)}\\
\end{array}
\end{array}
if lambda1 < -0.52000000000000002Initial program 52.9%
associate-*l*52.9%
Simplified52.9%
Taylor expanded in phi2 around 0 43.8%
Taylor expanded in phi1 around 0 37.9%
sin-diff73.1%
fma-neg73.2%
Applied egg-rr57.5%
if -0.52000000000000002 < lambda1 < 2.25000000000000006e-6Initial program 99.2%
associate-*l*99.2%
Simplified99.2%
Taylor expanded in lambda1 around 0 99.2%
cos-neg56.8%
Simplified99.2%
if 2.25000000000000006e-6 < lambda1 Initial program 73.2%
associate-*l*73.2%
Simplified73.2%
Taylor expanded in lambda2 around 0 73.2%
Final simplification80.2%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (cos phi1) (sin phi2))))
(if (<= lambda2 -5800000000000.0)
(atan2
(* (cos phi2) (sin (- lambda2)))
(- t_0 (* (sin phi1) (* (cos lambda2) (cos phi2)))))
(if (<= lambda2 2.6e+138)
(atan2
(* (cos phi2) (sin (- lambda1 lambda2)))
(- t_0 (* (sin phi1) (cos (+ lambda1 lambda2)))))
(atan2
(*
(fma (sin lambda1) (cos lambda2) (* (sin lambda2) (- (cos lambda1))))
(cos phi2))
(sin phi2))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos(phi1) * sin(phi2);
double tmp;
if (lambda2 <= -5800000000000.0) {
tmp = atan2((cos(phi2) * sin(-lambda2)), (t_0 - (sin(phi1) * (cos(lambda2) * cos(phi2)))));
} else if (lambda2 <= 2.6e+138) {
tmp = atan2((cos(phi2) * sin((lambda1 - lambda2))), (t_0 - (sin(phi1) * cos((lambda1 + lambda2)))));
} else {
tmp = atan2((fma(sin(lambda1), cos(lambda2), (sin(lambda2) * -cos(lambda1))) * cos(phi2)), sin(phi2));
}
return tmp;
}
function code(lambda1, lambda2, phi1, phi2) t_0 = Float64(cos(phi1) * sin(phi2)) tmp = 0.0 if (lambda2 <= -5800000000000.0) tmp = atan(Float64(cos(phi2) * sin(Float64(-lambda2))), Float64(t_0 - Float64(sin(phi1) * Float64(cos(lambda2) * cos(phi2))))); elseif (lambda2 <= 2.6e+138) tmp = atan(Float64(cos(phi2) * sin(Float64(lambda1 - lambda2))), Float64(t_0 - Float64(sin(phi1) * cos(Float64(lambda1 + lambda2))))); else tmp = atan(Float64(fma(sin(lambda1), cos(lambda2), Float64(sin(lambda2) * Float64(-cos(lambda1)))) * cos(phi2)), sin(phi2)); end return tmp end
code[lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[lambda2, -5800000000000.0], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[Sin[(-lambda2)], $MachinePrecision]), $MachinePrecision] / N[(t$95$0 - N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[lambda2], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[lambda2, 2.6e+138], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(t$95$0 - N[(N[Sin[phi1], $MachinePrecision] * N[Cos[N[(lambda1 + lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision] + N[(N[Sin[lambda2], $MachinePrecision] * (-N[Cos[lambda1], $MachinePrecision])), $MachinePrecision]), $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] / N[Sin[phi2], $MachinePrecision]], $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \cos \phi_1 \cdot \sin \phi_2\\
\mathbf{if}\;\lambda_2 \leq -5800000000000:\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(-\lambda_2\right)}{t_0 - \sin \phi_1 \cdot \left(\cos \lambda_2 \cdot \cos \phi_2\right)}\\
\mathbf{elif}\;\lambda_2 \leq 2.6 \cdot 10^{+138}:\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{t_0 - \sin \phi_1 \cdot \cos \left(\lambda_1 + \lambda_2\right)}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{\mathsf{fma}\left(\sin \lambda_1, \cos \lambda_2, \sin \lambda_2 \cdot \left(-\cos \lambda_1\right)\right) \cdot \cos \phi_2}{\sin \phi_2}\\
\end{array}
\end{array}
if lambda2 < -5.8e12Initial program 64.4%
associate-*l*64.4%
Simplified64.4%
add-log-exp64.4%
Applied egg-rr64.4%
Taylor expanded in lambda1 around 0 64.4%
cos-neg64.4%
Simplified64.4%
Taylor expanded in lambda1 around 0 62.7%
if -5.8e12 < lambda2 < 2.6000000000000001e138Initial program 91.5%
associate-*l*91.5%
Simplified91.5%
Taylor expanded in phi2 around 0 75.1%
pow175.1%
sub-neg75.1%
add-sqr-sqrt35.5%
sqrt-unprod75.1%
sqr-neg75.1%
sqrt-unprod38.9%
add-sqr-sqrt75.1%
Applied egg-rr75.1%
unpow175.1%
+-commutative75.1%
Simplified75.1%
if 2.6000000000000001e138 < lambda2 Initial program 40.1%
associate-*l*40.1%
Simplified40.1%
Taylor expanded in phi2 around 0 35.5%
Taylor expanded in phi1 around 0 27.7%
sin-diff70.5%
fma-neg70.6%
Applied egg-rr57.5%
Final simplification70.0%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(if (<= lambda1 -8.5e+15)
(atan2
(*
(fma (sin lambda1) (cos lambda2) (* (sin lambda2) (- (cos lambda1))))
(cos phi2))
(sin phi2))
(atan2
(* (cos phi2) (sin (- lambda1 lambda2)))
(- (* (cos phi1) (sin phi2)) (* (sin phi1) (cos (+ lambda1 lambda2)))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (lambda1 <= -8.5e+15) {
tmp = atan2((fma(sin(lambda1), cos(lambda2), (sin(lambda2) * -cos(lambda1))) * cos(phi2)), sin(phi2));
} else {
tmp = atan2((cos(phi2) * sin((lambda1 - lambda2))), ((cos(phi1) * sin(phi2)) - (sin(phi1) * cos((lambda1 + lambda2)))));
}
return tmp;
}
function code(lambda1, lambda2, phi1, phi2) tmp = 0.0 if (lambda1 <= -8.5e+15) tmp = atan(Float64(fma(sin(lambda1), cos(lambda2), Float64(sin(lambda2) * Float64(-cos(lambda1)))) * cos(phi2)), sin(phi2)); else tmp = atan(Float64(cos(phi2) * sin(Float64(lambda1 - lambda2))), Float64(Float64(cos(phi1) * sin(phi2)) - Float64(sin(phi1) * cos(Float64(lambda1 + lambda2))))); end return tmp end
code[lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[lambda1, -8.5e+15], N[ArcTan[N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision] + N[(N[Sin[lambda2], $MachinePrecision] * (-N[Cos[lambda1], $MachinePrecision])), $MachinePrecision]), $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] / N[Sin[phi2], $MachinePrecision]], $MachinePrecision], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] - N[(N[Sin[phi1], $MachinePrecision] * N[Cos[N[(lambda1 + lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\lambda_1 \leq -8.5 \cdot 10^{+15}:\\
\;\;\;\;\tan^{-1}_* \frac{\mathsf{fma}\left(\sin \lambda_1, \cos \lambda_2, \sin \lambda_2 \cdot \left(-\cos \lambda_1\right)\right) \cdot \cos \phi_2}{\sin \phi_2}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\cos \phi_1 \cdot \sin \phi_2 - \sin \phi_1 \cdot \cos \left(\lambda_1 + \lambda_2\right)}\\
\end{array}
\end{array}
if lambda1 < -8.5e15Initial program 50.3%
associate-*l*50.3%
Simplified50.3%
Taylor expanded in phi2 around 0 42.4%
Taylor expanded in phi1 around 0 36.9%
sin-diff72.9%
fma-neg72.9%
Applied egg-rr58.8%
if -8.5e15 < lambda1 Initial program 88.7%
associate-*l*88.7%
Simplified88.7%
Taylor expanded in phi2 around 0 71.8%
pow171.8%
sub-neg71.8%
add-sqr-sqrt40.9%
sqrt-unprod57.8%
sqr-neg57.8%
sqrt-unprod28.4%
add-sqr-sqrt71.8%
Applied egg-rr71.8%
unpow171.8%
+-commutative71.8%
Simplified71.8%
Final simplification68.4%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(if (or (<= lambda2 -0.45) (not (<= lambda2 126.0)))
(atan2
(*
(cos phi2)
(- (* (sin lambda1) (cos lambda2)) (* (cos lambda1) (sin lambda2))))
(sin phi2))
(atan2
(* (cos phi2) (sin (- lambda1 lambda2)))
(- (* (cos phi1) (sin phi2)) (* (cos lambda1) (sin phi1))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if ((lambda2 <= -0.45) || !(lambda2 <= 126.0)) {
tmp = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), sin(phi2));
} else {
tmp = atan2((cos(phi2) * sin((lambda1 - lambda2))), ((cos(phi1) * sin(phi2)) - (cos(lambda1) * sin(phi1))));
}
return tmp;
}
real(8) function code(lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: tmp
if ((lambda2 <= (-0.45d0)) .or. (.not. (lambda2 <= 126.0d0))) then
tmp = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), sin(phi2))
else
tmp = atan2((cos(phi2) * sin((lambda1 - lambda2))), ((cos(phi1) * sin(phi2)) - (cos(lambda1) * sin(phi1))))
end if
code = tmp
end function
public static double code(double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if ((lambda2 <= -0.45) || !(lambda2 <= 126.0)) {
tmp = Math.atan2((Math.cos(phi2) * ((Math.sin(lambda1) * Math.cos(lambda2)) - (Math.cos(lambda1) * Math.sin(lambda2)))), Math.sin(phi2));
} else {
tmp = Math.atan2((Math.cos(phi2) * Math.sin((lambda1 - lambda2))), ((Math.cos(phi1) * Math.sin(phi2)) - (Math.cos(lambda1) * Math.sin(phi1))));
}
return tmp;
}
def code(lambda1, lambda2, phi1, phi2): tmp = 0 if (lambda2 <= -0.45) or not (lambda2 <= 126.0): tmp = math.atan2((math.cos(phi2) * ((math.sin(lambda1) * math.cos(lambda2)) - (math.cos(lambda1) * math.sin(lambda2)))), math.sin(phi2)) else: tmp = math.atan2((math.cos(phi2) * math.sin((lambda1 - lambda2))), ((math.cos(phi1) * math.sin(phi2)) - (math.cos(lambda1) * math.sin(phi1)))) return tmp
function code(lambda1, lambda2, phi1, phi2) tmp = 0.0 if ((lambda2 <= -0.45) || !(lambda2 <= 126.0)) tmp = atan(Float64(cos(phi2) * Float64(Float64(sin(lambda1) * cos(lambda2)) - Float64(cos(lambda1) * sin(lambda2)))), sin(phi2)); else tmp = atan(Float64(cos(phi2) * sin(Float64(lambda1 - lambda2))), Float64(Float64(cos(phi1) * sin(phi2)) - Float64(cos(lambda1) * sin(phi1)))); end return tmp end
function tmp_2 = code(lambda1, lambda2, phi1, phi2) tmp = 0.0; if ((lambda2 <= -0.45) || ~((lambda2 <= 126.0))) tmp = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), sin(phi2)); else tmp = atan2((cos(phi2) * sin((lambda1 - lambda2))), ((cos(phi1) * sin(phi2)) - (cos(lambda1) * sin(phi1)))); end tmp_2 = tmp; end
code[lambda1_, lambda2_, phi1_, phi2_] := If[Or[LessEqual[lambda2, -0.45], N[Not[LessEqual[lambda2, 126.0]], $MachinePrecision]], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision] - N[(N[Cos[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Sin[phi2], $MachinePrecision]], $MachinePrecision], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] - N[(N[Cos[lambda1], $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\lambda_2 \leq -0.45 \lor \neg \left(\lambda_2 \leq 126\right):\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \left(\sin \lambda_1 \cdot \cos \lambda_2 - \cos \lambda_1 \cdot \sin \lambda_2\right)}{\sin \phi_2}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\cos \phi_1 \cdot \sin \phi_2 - \cos \lambda_1 \cdot \sin \phi_1}\\
\end{array}
\end{array}
if lambda2 < -0.450000000000000011 or 126 < lambda2 Initial program 56.9%
associate-*l*57.0%
Simplified57.0%
Taylor expanded in phi2 around 0 46.6%
Taylor expanded in phi1 around 0 37.1%
sin-diff53.8%
cancel-sign-sub-inv53.8%
Applied egg-rr53.8%
cancel-sign-sub-inv53.8%
Simplified53.8%
if -0.450000000000000011 < lambda2 < 126Initial program 98.1%
associate-*l*98.1%
Simplified98.1%
Taylor expanded in phi2 around 0 79.7%
Taylor expanded in lambda2 around 0 79.7%
*-commutative79.7%
Simplified79.7%
Final simplification67.5%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (cos phi2) (sin (- lambda1 lambda2))))
(t_1 (* (cos phi1) (sin phi2))))
(if (<= lambda1 -0.122)
(atan2
(*
(cos phi2)
(- (* (sin lambda1) (cos lambda2)) (* (cos lambda1) (sin lambda2))))
(sin phi2))
(if (<= lambda1 1.8)
(atan2 t_0 (- t_1 (* (cos lambda2) (sin phi1))))
(atan2 t_0 (- t_1 (* (cos lambda1) (sin phi1))))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos(phi2) * sin((lambda1 - lambda2));
double t_1 = cos(phi1) * sin(phi2);
double tmp;
if (lambda1 <= -0.122) {
tmp = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), sin(phi2));
} else if (lambda1 <= 1.8) {
tmp = atan2(t_0, (t_1 - (cos(lambda2) * sin(phi1))));
} else {
tmp = atan2(t_0, (t_1 - (cos(lambda1) * sin(phi1))));
}
return tmp;
}
real(8) function code(lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = cos(phi2) * sin((lambda1 - lambda2))
t_1 = cos(phi1) * sin(phi2)
if (lambda1 <= (-0.122d0)) then
tmp = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), sin(phi2))
else if (lambda1 <= 1.8d0) then
tmp = atan2(t_0, (t_1 - (cos(lambda2) * sin(phi1))))
else
tmp = atan2(t_0, (t_1 - (cos(lambda1) * sin(phi1))))
end if
code = tmp
end function
public static double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = Math.cos(phi2) * Math.sin((lambda1 - lambda2));
double t_1 = Math.cos(phi1) * Math.sin(phi2);
double tmp;
if (lambda1 <= -0.122) {
tmp = Math.atan2((Math.cos(phi2) * ((Math.sin(lambda1) * Math.cos(lambda2)) - (Math.cos(lambda1) * Math.sin(lambda2)))), Math.sin(phi2));
} else if (lambda1 <= 1.8) {
tmp = Math.atan2(t_0, (t_1 - (Math.cos(lambda2) * Math.sin(phi1))));
} else {
tmp = Math.atan2(t_0, (t_1 - (Math.cos(lambda1) * Math.sin(phi1))));
}
return tmp;
}
def code(lambda1, lambda2, phi1, phi2): t_0 = math.cos(phi2) * math.sin((lambda1 - lambda2)) t_1 = math.cos(phi1) * math.sin(phi2) tmp = 0 if lambda1 <= -0.122: tmp = math.atan2((math.cos(phi2) * ((math.sin(lambda1) * math.cos(lambda2)) - (math.cos(lambda1) * math.sin(lambda2)))), math.sin(phi2)) elif lambda1 <= 1.8: tmp = math.atan2(t_0, (t_1 - (math.cos(lambda2) * math.sin(phi1)))) else: tmp = math.atan2(t_0, (t_1 - (math.cos(lambda1) * math.sin(phi1)))) return tmp
function code(lambda1, lambda2, phi1, phi2) t_0 = Float64(cos(phi2) * sin(Float64(lambda1 - lambda2))) t_1 = Float64(cos(phi1) * sin(phi2)) tmp = 0.0 if (lambda1 <= -0.122) tmp = atan(Float64(cos(phi2) * Float64(Float64(sin(lambda1) * cos(lambda2)) - Float64(cos(lambda1) * sin(lambda2)))), sin(phi2)); elseif (lambda1 <= 1.8) tmp = atan(t_0, Float64(t_1 - Float64(cos(lambda2) * sin(phi1)))); else tmp = atan(t_0, Float64(t_1 - Float64(cos(lambda1) * sin(phi1)))); end return tmp end
function tmp_2 = code(lambda1, lambda2, phi1, phi2) t_0 = cos(phi2) * sin((lambda1 - lambda2)); t_1 = cos(phi1) * sin(phi2); tmp = 0.0; if (lambda1 <= -0.122) tmp = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), sin(phi2)); elseif (lambda1 <= 1.8) tmp = atan2(t_0, (t_1 - (cos(lambda2) * sin(phi1)))); else tmp = atan2(t_0, (t_1 - (cos(lambda1) * sin(phi1)))); end tmp_2 = tmp; end
code[lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[Cos[phi2], $MachinePrecision] * N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[lambda1, -0.122], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision] - N[(N[Cos[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Sin[phi2], $MachinePrecision]], $MachinePrecision], If[LessEqual[lambda1, 1.8], N[ArcTan[t$95$0 / N[(t$95$1 - N[(N[Cos[lambda2], $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[t$95$0 / N[(t$95$1 - N[(N[Cos[lambda1], $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)\\
t_1 := \cos \phi_1 \cdot \sin \phi_2\\
\mathbf{if}\;\lambda_1 \leq -0.122:\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \left(\sin \lambda_1 \cdot \cos \lambda_2 - \cos \lambda_1 \cdot \sin \lambda_2\right)}{\sin \phi_2}\\
\mathbf{elif}\;\lambda_1 \leq 1.8:\\
\;\;\;\;\tan^{-1}_* \frac{t_0}{t_1 - \cos \lambda_2 \cdot \sin \phi_1}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{t_0}{t_1 - \cos \lambda_1 \cdot \sin \phi_1}\\
\end{array}
\end{array}
if lambda1 < -0.122Initial program 52.9%
associate-*l*52.9%
Simplified52.9%
Taylor expanded in phi2 around 0 43.8%
Taylor expanded in phi1 around 0 37.9%
sin-diff57.5%
cancel-sign-sub-inv57.5%
Applied egg-rr57.5%
cancel-sign-sub-inv57.5%
Simplified57.5%
if -0.122 < lambda1 < 1.80000000000000004Initial program 98.3%
associate-*l*98.3%
Simplified98.3%
Taylor expanded in phi2 around 0 78.6%
Taylor expanded in lambda1 around 0 78.6%
*-commutative78.6%
*-commutative78.6%
cos-neg78.6%
Simplified78.6%
if 1.80000000000000004 < lambda1 Initial program 73.5%
associate-*l*73.5%
Simplified73.5%
Taylor expanded in phi2 around 0 61.8%
Taylor expanded in lambda2 around 0 61.8%
*-commutative61.8%
Simplified61.8%
Final simplification68.2%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(if (<= lambda1 -5e+16)
(atan2
(*
(cos phi2)
(- (* (sin lambda1) (cos lambda2)) (* (cos lambda1) (sin lambda2))))
(sin phi2))
(atan2
(* (cos phi2) (sin (- lambda1 lambda2)))
(- (* (cos phi1) (sin phi2)) (* (sin phi1) (cos (+ lambda1 lambda2)))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (lambda1 <= -5e+16) {
tmp = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), sin(phi2));
} else {
tmp = atan2((cos(phi2) * sin((lambda1 - lambda2))), ((cos(phi1) * sin(phi2)) - (sin(phi1) * cos((lambda1 + lambda2)))));
}
return tmp;
}
real(8) function code(lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: tmp
if (lambda1 <= (-5d+16)) then
tmp = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), sin(phi2))
else
tmp = atan2((cos(phi2) * sin((lambda1 - lambda2))), ((cos(phi1) * sin(phi2)) - (sin(phi1) * cos((lambda1 + lambda2)))))
end if
code = tmp
end function
public static double code(double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (lambda1 <= -5e+16) {
tmp = Math.atan2((Math.cos(phi2) * ((Math.sin(lambda1) * Math.cos(lambda2)) - (Math.cos(lambda1) * Math.sin(lambda2)))), Math.sin(phi2));
} else {
tmp = Math.atan2((Math.cos(phi2) * Math.sin((lambda1 - lambda2))), ((Math.cos(phi1) * Math.sin(phi2)) - (Math.sin(phi1) * Math.cos((lambda1 + lambda2)))));
}
return tmp;
}
def code(lambda1, lambda2, phi1, phi2): tmp = 0 if lambda1 <= -5e+16: tmp = math.atan2((math.cos(phi2) * ((math.sin(lambda1) * math.cos(lambda2)) - (math.cos(lambda1) * math.sin(lambda2)))), math.sin(phi2)) else: tmp = math.atan2((math.cos(phi2) * math.sin((lambda1 - lambda2))), ((math.cos(phi1) * math.sin(phi2)) - (math.sin(phi1) * math.cos((lambda1 + lambda2))))) return tmp
function code(lambda1, lambda2, phi1, phi2) tmp = 0.0 if (lambda1 <= -5e+16) tmp = atan(Float64(cos(phi2) * Float64(Float64(sin(lambda1) * cos(lambda2)) - Float64(cos(lambda1) * sin(lambda2)))), sin(phi2)); else tmp = atan(Float64(cos(phi2) * sin(Float64(lambda1 - lambda2))), Float64(Float64(cos(phi1) * sin(phi2)) - Float64(sin(phi1) * cos(Float64(lambda1 + lambda2))))); end return tmp end
function tmp_2 = code(lambda1, lambda2, phi1, phi2) tmp = 0.0; if (lambda1 <= -5e+16) tmp = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), sin(phi2)); else tmp = atan2((cos(phi2) * sin((lambda1 - lambda2))), ((cos(phi1) * sin(phi2)) - (sin(phi1) * cos((lambda1 + lambda2))))); end tmp_2 = tmp; end
code[lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[lambda1, -5e+16], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision] - N[(N[Cos[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Sin[phi2], $MachinePrecision]], $MachinePrecision], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] - N[(N[Sin[phi1], $MachinePrecision] * N[Cos[N[(lambda1 + lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\lambda_1 \leq -5 \cdot 10^{+16}:\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \left(\sin \lambda_1 \cdot \cos \lambda_2 - \cos \lambda_1 \cdot \sin \lambda_2\right)}{\sin \phi_2}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\cos \phi_1 \cdot \sin \phi_2 - \sin \phi_1 \cdot \cos \left(\lambda_1 + \lambda_2\right)}\\
\end{array}
\end{array}
if lambda1 < -5e16Initial program 50.3%
associate-*l*50.3%
Simplified50.3%
Taylor expanded in phi2 around 0 42.4%
Taylor expanded in phi1 around 0 36.9%
sin-diff58.8%
cancel-sign-sub-inv58.8%
Applied egg-rr58.8%
cancel-sign-sub-inv58.8%
Simplified58.8%
if -5e16 < lambda1 Initial program 88.7%
associate-*l*88.7%
Simplified88.7%
Taylor expanded in phi2 around 0 71.8%
pow171.8%
sub-neg71.8%
add-sqr-sqrt40.9%
sqrt-unprod57.8%
sqr-neg57.8%
sqrt-unprod28.4%
add-sqr-sqrt71.8%
Applied egg-rr71.8%
unpow171.8%
+-commutative71.8%
Simplified71.8%
Final simplification68.4%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(if (or (<= phi2 -1.5e-71) (not (<= phi2 0.14)))
(atan2
(*
(cos phi2)
(- (* (sin lambda1) (cos lambda2)) (* (cos lambda1) (sin lambda2))))
(sin phi2))
(atan2
(* (cos phi2) (sin (- lambda1 lambda2)))
(- (* phi2 (cos phi1)) (* (sin phi1) (cos (- lambda1 lambda2)))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if ((phi2 <= -1.5e-71) || !(phi2 <= 0.14)) {
tmp = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), sin(phi2));
} else {
tmp = atan2((cos(phi2) * sin((lambda1 - lambda2))), ((phi2 * cos(phi1)) - (sin(phi1) * cos((lambda1 - lambda2)))));
}
return tmp;
}
real(8) function code(lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: tmp
if ((phi2 <= (-1.5d-71)) .or. (.not. (phi2 <= 0.14d0))) then
tmp = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), sin(phi2))
else
tmp = atan2((cos(phi2) * sin((lambda1 - lambda2))), ((phi2 * cos(phi1)) - (sin(phi1) * cos((lambda1 - lambda2)))))
end if
code = tmp
end function
public static double code(double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if ((phi2 <= -1.5e-71) || !(phi2 <= 0.14)) {
tmp = Math.atan2((Math.cos(phi2) * ((Math.sin(lambda1) * Math.cos(lambda2)) - (Math.cos(lambda1) * Math.sin(lambda2)))), Math.sin(phi2));
} else {
tmp = Math.atan2((Math.cos(phi2) * Math.sin((lambda1 - lambda2))), ((phi2 * Math.cos(phi1)) - (Math.sin(phi1) * Math.cos((lambda1 - lambda2)))));
}
return tmp;
}
def code(lambda1, lambda2, phi1, phi2): tmp = 0 if (phi2 <= -1.5e-71) or not (phi2 <= 0.14): tmp = math.atan2((math.cos(phi2) * ((math.sin(lambda1) * math.cos(lambda2)) - (math.cos(lambda1) * math.sin(lambda2)))), math.sin(phi2)) else: tmp = math.atan2((math.cos(phi2) * math.sin((lambda1 - lambda2))), ((phi2 * math.cos(phi1)) - (math.sin(phi1) * math.cos((lambda1 - lambda2))))) return tmp
function code(lambda1, lambda2, phi1, phi2) tmp = 0.0 if ((phi2 <= -1.5e-71) || !(phi2 <= 0.14)) tmp = atan(Float64(cos(phi2) * Float64(Float64(sin(lambda1) * cos(lambda2)) - Float64(cos(lambda1) * sin(lambda2)))), sin(phi2)); else tmp = atan(Float64(cos(phi2) * sin(Float64(lambda1 - lambda2))), Float64(Float64(phi2 * cos(phi1)) - Float64(sin(phi1) * cos(Float64(lambda1 - lambda2))))); end return tmp end
function tmp_2 = code(lambda1, lambda2, phi1, phi2) tmp = 0.0; if ((phi2 <= -1.5e-71) || ~((phi2 <= 0.14))) tmp = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), sin(phi2)); else tmp = atan2((cos(phi2) * sin((lambda1 - lambda2))), ((phi2 * cos(phi1)) - (sin(phi1) * cos((lambda1 - lambda2))))); end tmp_2 = tmp; end
code[lambda1_, lambda2_, phi1_, phi2_] := If[Or[LessEqual[phi2, -1.5e-71], N[Not[LessEqual[phi2, 0.14]], $MachinePrecision]], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision] - N[(N[Cos[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Sin[phi2], $MachinePrecision]], $MachinePrecision], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(N[(phi2 * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] - N[(N[Sin[phi1], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_2 \leq -1.5 \cdot 10^{-71} \lor \neg \left(\phi_2 \leq 0.14\right):\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \left(\sin \lambda_1 \cdot \cos \lambda_2 - \cos \lambda_1 \cdot \sin \lambda_2\right)}{\sin \phi_2}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\phi_2 \cdot \cos \phi_1 - \sin \phi_1 \cdot \cos \left(\lambda_1 - \lambda_2\right)}\\
\end{array}
\end{array}
if phi2 < -1.5000000000000001e-71 or 0.14000000000000001 < phi2 Initial program 76.4%
associate-*l*76.4%
Simplified76.4%
Taylor expanded in phi2 around 0 52.4%
Taylor expanded in phi1 around 0 47.9%
sin-diff57.2%
cancel-sign-sub-inv57.2%
Applied egg-rr57.2%
cancel-sign-sub-inv57.2%
Simplified57.2%
if -1.5000000000000001e-71 < phi2 < 0.14000000000000001Initial program 82.6%
associate-*l*82.6%
Simplified82.6%
Taylor expanded in phi2 around 0 82.6%
Taylor expanded in phi2 around 0 82.6%
Final simplification67.1%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (cos phi2) (sin (- lambda1 lambda2)))))
(if (or (<= phi2 -2.8e+15) (not (<= phi2 2900000000.0)))
(atan2 t_0 (sin phi2))
(atan2
t_0
(- (* phi2 (cos phi1)) (* (sin phi1) (cos (- lambda1 lambda2))))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos(phi2) * sin((lambda1 - lambda2));
double tmp;
if ((phi2 <= -2.8e+15) || !(phi2 <= 2900000000.0)) {
tmp = atan2(t_0, sin(phi2));
} else {
tmp = atan2(t_0, ((phi2 * cos(phi1)) - (sin(phi1) * cos((lambda1 - lambda2)))));
}
return tmp;
}
real(8) function code(lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: t_0
real(8) :: tmp
t_0 = cos(phi2) * sin((lambda1 - lambda2))
if ((phi2 <= (-2.8d+15)) .or. (.not. (phi2 <= 2900000000.0d0))) then
tmp = atan2(t_0, sin(phi2))
else
tmp = atan2(t_0, ((phi2 * cos(phi1)) - (sin(phi1) * cos((lambda1 - lambda2)))))
end if
code = tmp
end function
public static double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = Math.cos(phi2) * Math.sin((lambda1 - lambda2));
double tmp;
if ((phi2 <= -2.8e+15) || !(phi2 <= 2900000000.0)) {
tmp = Math.atan2(t_0, Math.sin(phi2));
} else {
tmp = Math.atan2(t_0, ((phi2 * Math.cos(phi1)) - (Math.sin(phi1) * Math.cos((lambda1 - lambda2)))));
}
return tmp;
}
def code(lambda1, lambda2, phi1, phi2): t_0 = math.cos(phi2) * math.sin((lambda1 - lambda2)) tmp = 0 if (phi2 <= -2.8e+15) or not (phi2 <= 2900000000.0): tmp = math.atan2(t_0, math.sin(phi2)) else: tmp = math.atan2(t_0, ((phi2 * math.cos(phi1)) - (math.sin(phi1) * math.cos((lambda1 - lambda2))))) return tmp
function code(lambda1, lambda2, phi1, phi2) t_0 = Float64(cos(phi2) * sin(Float64(lambda1 - lambda2))) tmp = 0.0 if ((phi2 <= -2.8e+15) || !(phi2 <= 2900000000.0)) tmp = atan(t_0, sin(phi2)); else tmp = atan(t_0, Float64(Float64(phi2 * cos(phi1)) - Float64(sin(phi1) * cos(Float64(lambda1 - lambda2))))); end return tmp end
function tmp_2 = code(lambda1, lambda2, phi1, phi2) t_0 = cos(phi2) * sin((lambda1 - lambda2)); tmp = 0.0; if ((phi2 <= -2.8e+15) || ~((phi2 <= 2900000000.0))) tmp = atan2(t_0, sin(phi2)); else tmp = atan2(t_0, ((phi2 * cos(phi1)) - (sin(phi1) * cos((lambda1 - lambda2))))); end tmp_2 = tmp; end
code[lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[Cos[phi2], $MachinePrecision] * N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[phi2, -2.8e+15], N[Not[LessEqual[phi2, 2900000000.0]], $MachinePrecision]], N[ArcTan[t$95$0 / N[Sin[phi2], $MachinePrecision]], $MachinePrecision], N[ArcTan[t$95$0 / N[(N[(phi2 * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] - N[(N[Sin[phi1], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)\\
\mathbf{if}\;\phi_2 \leq -2.8 \cdot 10^{+15} \lor \neg \left(\phi_2 \leq 2900000000\right):\\
\;\;\;\;\tan^{-1}_* \frac{t_0}{\sin \phi_2}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{t_0}{\phi_2 \cdot \cos \phi_1 - \sin \phi_1 \cdot \cos \left(\lambda_1 - \lambda_2\right)}\\
\end{array}
\end{array}
if phi2 < -2.8e15 or 2.9e9 < phi2 Initial program 76.7%
associate-*l*76.7%
Simplified76.7%
Taylor expanded in phi2 around 0 51.3%
Taylor expanded in phi1 around 0 47.0%
if -2.8e15 < phi2 < 2.9e9Initial program 81.2%
associate-*l*81.2%
Simplified81.2%
Taylor expanded in phi2 around 0 78.6%
Taylor expanded in phi2 around 0 78.4%
Final simplification61.8%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (cos (- lambda1 lambda2)))
(t_1 (* (cos phi2) (sin (- lambda1 lambda2)))))
(if (or (<= phi1 -0.0075) (not (<= phi1 6.6e-5)))
(atan2 t_1 (* (sin phi1) (- t_0)))
(atan2 t_1 (- (sin phi2) (* phi1 t_0))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos((lambda1 - lambda2));
double t_1 = cos(phi2) * sin((lambda1 - lambda2));
double tmp;
if ((phi1 <= -0.0075) || !(phi1 <= 6.6e-5)) {
tmp = atan2(t_1, (sin(phi1) * -t_0));
} else {
tmp = atan2(t_1, (sin(phi2) - (phi1 * t_0)));
}
return tmp;
}
real(8) function code(lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = cos((lambda1 - lambda2))
t_1 = cos(phi2) * sin((lambda1 - lambda2))
if ((phi1 <= (-0.0075d0)) .or. (.not. (phi1 <= 6.6d-5))) then
tmp = atan2(t_1, (sin(phi1) * -t_0))
else
tmp = atan2(t_1, (sin(phi2) - (phi1 * t_0)))
end if
code = tmp
end function
public static double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = Math.cos((lambda1 - lambda2));
double t_1 = Math.cos(phi2) * Math.sin((lambda1 - lambda2));
double tmp;
if ((phi1 <= -0.0075) || !(phi1 <= 6.6e-5)) {
tmp = Math.atan2(t_1, (Math.sin(phi1) * -t_0));
} else {
tmp = Math.atan2(t_1, (Math.sin(phi2) - (phi1 * t_0)));
}
return tmp;
}
def code(lambda1, lambda2, phi1, phi2): t_0 = math.cos((lambda1 - lambda2)) t_1 = math.cos(phi2) * math.sin((lambda1 - lambda2)) tmp = 0 if (phi1 <= -0.0075) or not (phi1 <= 6.6e-5): tmp = math.atan2(t_1, (math.sin(phi1) * -t_0)) else: tmp = math.atan2(t_1, (math.sin(phi2) - (phi1 * t_0))) return tmp
function code(lambda1, lambda2, phi1, phi2) t_0 = cos(Float64(lambda1 - lambda2)) t_1 = Float64(cos(phi2) * sin(Float64(lambda1 - lambda2))) tmp = 0.0 if ((phi1 <= -0.0075) || !(phi1 <= 6.6e-5)) tmp = atan(t_1, Float64(sin(phi1) * Float64(-t_0))); else tmp = atan(t_1, Float64(sin(phi2) - Float64(phi1 * t_0))); end return tmp end
function tmp_2 = code(lambda1, lambda2, phi1, phi2) t_0 = cos((lambda1 - lambda2)); t_1 = cos(phi2) * sin((lambda1 - lambda2)); tmp = 0.0; if ((phi1 <= -0.0075) || ~((phi1 <= 6.6e-5))) tmp = atan2(t_1, (sin(phi1) * -t_0)); else tmp = atan2(t_1, (sin(phi2) - (phi1 * t_0))); end tmp_2 = tmp; end
code[lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$1 = N[(N[Cos[phi2], $MachinePrecision] * N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[phi1, -0.0075], N[Not[LessEqual[phi1, 6.6e-5]], $MachinePrecision]], N[ArcTan[t$95$1 / N[(N[Sin[phi1], $MachinePrecision] * (-t$95$0)), $MachinePrecision]], $MachinePrecision], N[ArcTan[t$95$1 / N[(N[Sin[phi2], $MachinePrecision] - N[(phi1 * t$95$0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \cos \left(\lambda_1 - \lambda_2\right)\\
t_1 := \cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)\\
\mathbf{if}\;\phi_1 \leq -0.0075 \lor \neg \left(\phi_1 \leq 6.6 \cdot 10^{-5}\right):\\
\;\;\;\;\tan^{-1}_* \frac{t_1}{\sin \phi_1 \cdot \left(-t_0\right)}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{t_1}{\sin \phi_2 - \phi_1 \cdot t_0}\\
\end{array}
\end{array}
if phi1 < -0.0074999999999999997 or 6.6000000000000005e-5 < phi1 Initial program 72.2%
associate-*l*72.2%
Simplified72.2%
Taylor expanded in phi2 around 0 45.1%
Taylor expanded in phi2 around 0 40.4%
*-commutative40.4%
associate-*l*40.4%
*-commutative40.4%
neg-mul-140.4%
Simplified40.4%
if -0.0074999999999999997 < phi1 < 6.6000000000000005e-5Initial program 86.5%
associate-*l*86.5%
Simplified86.5%
Taylor expanded in phi2 around 0 86.5%
Taylor expanded in phi1 around 0 86.5%
mul-1-neg86.5%
Simplified86.5%
Final simplification61.6%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (cos phi2) (sin (- lambda1 lambda2)))))
(if (or (<= phi2 -1.5e-71) (not (<= phi2 2900000000.0)))
(atan2 t_0 (sin phi2))
(atan2 t_0 (* (sin phi1) (- (cos (- lambda1 lambda2))))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos(phi2) * sin((lambda1 - lambda2));
double tmp;
if ((phi2 <= -1.5e-71) || !(phi2 <= 2900000000.0)) {
tmp = atan2(t_0, sin(phi2));
} else {
tmp = atan2(t_0, (sin(phi1) * -cos((lambda1 - lambda2))));
}
return tmp;
}
real(8) function code(lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: t_0
real(8) :: tmp
t_0 = cos(phi2) * sin((lambda1 - lambda2))
if ((phi2 <= (-1.5d-71)) .or. (.not. (phi2 <= 2900000000.0d0))) then
tmp = atan2(t_0, sin(phi2))
else
tmp = atan2(t_0, (sin(phi1) * -cos((lambda1 - lambda2))))
end if
code = tmp
end function
public static double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = Math.cos(phi2) * Math.sin((lambda1 - lambda2));
double tmp;
if ((phi2 <= -1.5e-71) || !(phi2 <= 2900000000.0)) {
tmp = Math.atan2(t_0, Math.sin(phi2));
} else {
tmp = Math.atan2(t_0, (Math.sin(phi1) * -Math.cos((lambda1 - lambda2))));
}
return tmp;
}
def code(lambda1, lambda2, phi1, phi2): t_0 = math.cos(phi2) * math.sin((lambda1 - lambda2)) tmp = 0 if (phi2 <= -1.5e-71) or not (phi2 <= 2900000000.0): tmp = math.atan2(t_0, math.sin(phi2)) else: tmp = math.atan2(t_0, (math.sin(phi1) * -math.cos((lambda1 - lambda2)))) return tmp
function code(lambda1, lambda2, phi1, phi2) t_0 = Float64(cos(phi2) * sin(Float64(lambda1 - lambda2))) tmp = 0.0 if ((phi2 <= -1.5e-71) || !(phi2 <= 2900000000.0)) tmp = atan(t_0, sin(phi2)); else tmp = atan(t_0, Float64(sin(phi1) * Float64(-cos(Float64(lambda1 - lambda2))))); end return tmp end
function tmp_2 = code(lambda1, lambda2, phi1, phi2) t_0 = cos(phi2) * sin((lambda1 - lambda2)); tmp = 0.0; if ((phi2 <= -1.5e-71) || ~((phi2 <= 2900000000.0))) tmp = atan2(t_0, sin(phi2)); else tmp = atan2(t_0, (sin(phi1) * -cos((lambda1 - lambda2)))); end tmp_2 = tmp; end
code[lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[Cos[phi2], $MachinePrecision] * N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[phi2, -1.5e-71], N[Not[LessEqual[phi2, 2900000000.0]], $MachinePrecision]], N[ArcTan[t$95$0 / N[Sin[phi2], $MachinePrecision]], $MachinePrecision], N[ArcTan[t$95$0 / N[(N[Sin[phi1], $MachinePrecision] * (-N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision])), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)\\
\mathbf{if}\;\phi_2 \leq -1.5 \cdot 10^{-71} \lor \neg \left(\phi_2 \leq 2900000000\right):\\
\;\;\;\;\tan^{-1}_* \frac{t_0}{\sin \phi_2}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{t_0}{\sin \phi_1 \cdot \left(-\cos \left(\lambda_1 - \lambda_2\right)\right)}\\
\end{array}
\end{array}
if phi2 < -1.5000000000000001e-71 or 2.9e9 < phi2 Initial program 77.0%
associate-*l*77.0%
Simplified77.0%
Taylor expanded in phi2 around 0 53.4%
Taylor expanded in phi1 around 0 48.9%
if -1.5000000000000001e-71 < phi2 < 2.9e9Initial program 81.5%
associate-*l*81.5%
Simplified81.5%
Taylor expanded in phi2 around 0 80.0%
Taylor expanded in phi2 around 0 77.9%
*-commutative77.9%
associate-*l*77.9%
*-commutative77.9%
neg-mul-177.9%
Simplified77.9%
Final simplification60.7%
(FPCore (lambda1 lambda2 phi1 phi2) :precision binary64 (if (or (<= lambda2 -3e-19) (not (<= lambda2 1.2e+102))) (atan2 (* (cos phi2) (sin (- lambda2))) (sin phi2)) (atan2 (* (sin lambda1) (cos phi2)) (sin phi2))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if ((lambda2 <= -3e-19) || !(lambda2 <= 1.2e+102)) {
tmp = atan2((cos(phi2) * sin(-lambda2)), sin(phi2));
} else {
tmp = atan2((sin(lambda1) * cos(phi2)), sin(phi2));
}
return tmp;
}
real(8) function code(lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: tmp
if ((lambda2 <= (-3d-19)) .or. (.not. (lambda2 <= 1.2d+102))) then
tmp = atan2((cos(phi2) * sin(-lambda2)), sin(phi2))
else
tmp = atan2((sin(lambda1) * cos(phi2)), sin(phi2))
end if
code = tmp
end function
public static double code(double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if ((lambda2 <= -3e-19) || !(lambda2 <= 1.2e+102)) {
tmp = Math.atan2((Math.cos(phi2) * Math.sin(-lambda2)), Math.sin(phi2));
} else {
tmp = Math.atan2((Math.sin(lambda1) * Math.cos(phi2)), Math.sin(phi2));
}
return tmp;
}
def code(lambda1, lambda2, phi1, phi2): tmp = 0 if (lambda2 <= -3e-19) or not (lambda2 <= 1.2e+102): tmp = math.atan2((math.cos(phi2) * math.sin(-lambda2)), math.sin(phi2)) else: tmp = math.atan2((math.sin(lambda1) * math.cos(phi2)), math.sin(phi2)) return tmp
function code(lambda1, lambda2, phi1, phi2) tmp = 0.0 if ((lambda2 <= -3e-19) || !(lambda2 <= 1.2e+102)) tmp = atan(Float64(cos(phi2) * sin(Float64(-lambda2))), sin(phi2)); else tmp = atan(Float64(sin(lambda1) * cos(phi2)), sin(phi2)); end return tmp end
function tmp_2 = code(lambda1, lambda2, phi1, phi2) tmp = 0.0; if ((lambda2 <= -3e-19) || ~((lambda2 <= 1.2e+102))) tmp = atan2((cos(phi2) * sin(-lambda2)), sin(phi2)); else tmp = atan2((sin(lambda1) * cos(phi2)), sin(phi2)); end tmp_2 = tmp; end
code[lambda1_, lambda2_, phi1_, phi2_] := If[Or[LessEqual[lambda2, -3e-19], N[Not[LessEqual[lambda2, 1.2e+102]], $MachinePrecision]], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[Sin[(-lambda2)], $MachinePrecision]), $MachinePrecision] / N[Sin[phi2], $MachinePrecision]], $MachinePrecision], N[ArcTan[N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] / N[Sin[phi2], $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\lambda_2 \leq -3 \cdot 10^{-19} \lor \neg \left(\lambda_2 \leq 1.2 \cdot 10^{+102}\right):\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(-\lambda_2\right)}{\sin \phi_2}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{\sin \lambda_1 \cdot \cos \phi_2}{\sin \phi_2}\\
\end{array}
\end{array}
if lambda2 < -2.99999999999999993e-19 or 1.19999999999999997e102 < lambda2 Initial program 58.7%
associate-*l*58.8%
Simplified58.8%
Taylor expanded in phi2 around 0 48.4%
Taylor expanded in phi1 around 0 39.2%
Taylor expanded in lambda1 around 0 38.8%
if -2.99999999999999993e-19 < lambda2 < 1.19999999999999997e102Initial program 93.0%
associate-*l*93.0%
Simplified93.0%
Taylor expanded in phi2 around 0 75.4%
Taylor expanded in phi1 around 0 54.7%
Taylor expanded in lambda2 around 0 48.8%
*-commutative48.8%
Simplified48.8%
Final simplification44.7%
(FPCore (lambda1 lambda2 phi1 phi2) :precision binary64 (if (or (<= phi2 -2.05e+46) (not (<= phi2 2.6e-18))) (atan2 (* (sin lambda1) (cos phi2)) (sin phi2)) (atan2 (sin (- lambda1 lambda2)) (sin phi2))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if ((phi2 <= -2.05e+46) || !(phi2 <= 2.6e-18)) {
tmp = atan2((sin(lambda1) * cos(phi2)), sin(phi2));
} else {
tmp = atan2(sin((lambda1 - lambda2)), sin(phi2));
}
return tmp;
}
real(8) function code(lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: tmp
if ((phi2 <= (-2.05d+46)) .or. (.not. (phi2 <= 2.6d-18))) then
tmp = atan2((sin(lambda1) * cos(phi2)), sin(phi2))
else
tmp = atan2(sin((lambda1 - lambda2)), sin(phi2))
end if
code = tmp
end function
public static double code(double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if ((phi2 <= -2.05e+46) || !(phi2 <= 2.6e-18)) {
tmp = Math.atan2((Math.sin(lambda1) * Math.cos(phi2)), Math.sin(phi2));
} else {
tmp = Math.atan2(Math.sin((lambda1 - lambda2)), Math.sin(phi2));
}
return tmp;
}
def code(lambda1, lambda2, phi1, phi2): tmp = 0 if (phi2 <= -2.05e+46) or not (phi2 <= 2.6e-18): tmp = math.atan2((math.sin(lambda1) * math.cos(phi2)), math.sin(phi2)) else: tmp = math.atan2(math.sin((lambda1 - lambda2)), math.sin(phi2)) return tmp
function code(lambda1, lambda2, phi1, phi2) tmp = 0.0 if ((phi2 <= -2.05e+46) || !(phi2 <= 2.6e-18)) tmp = atan(Float64(sin(lambda1) * cos(phi2)), sin(phi2)); else tmp = atan(sin(Float64(lambda1 - lambda2)), sin(phi2)); end return tmp end
function tmp_2 = code(lambda1, lambda2, phi1, phi2) tmp = 0.0; if ((phi2 <= -2.05e+46) || ~((phi2 <= 2.6e-18))) tmp = atan2((sin(lambda1) * cos(phi2)), sin(phi2)); else tmp = atan2(sin((lambda1 - lambda2)), sin(phi2)); end tmp_2 = tmp; end
code[lambda1_, lambda2_, phi1_, phi2_] := If[Or[LessEqual[phi2, -2.05e+46], N[Not[LessEqual[phi2, 2.6e-18]], $MachinePrecision]], N[ArcTan[N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] / N[Sin[phi2], $MachinePrecision]], $MachinePrecision], N[ArcTan[N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision] / N[Sin[phi2], $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_2 \leq -2.05 \cdot 10^{+46} \lor \neg \left(\phi_2 \leq 2.6 \cdot 10^{-18}\right):\\
\;\;\;\;\tan^{-1}_* \frac{\sin \lambda_1 \cdot \cos \phi_2}{\sin \phi_2}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{\sin \left(\lambda_1 - \lambda_2\right)}{\sin \phi_2}\\
\end{array}
\end{array}
if phi2 < -2.05e46 or 2.6e-18 < phi2 Initial program 75.8%
associate-*l*75.8%
Simplified75.8%
Taylor expanded in phi2 around 0 50.9%
Taylor expanded in phi1 around 0 45.1%
Taylor expanded in lambda2 around 0 33.7%
*-commutative33.7%
Simplified33.7%
if -2.05e46 < phi2 < 2.6e-18Initial program 82.0%
associate-*l*82.0%
Simplified82.0%
Taylor expanded in phi2 around 0 78.3%
Taylor expanded in phi1 around 0 51.7%
Taylor expanded in phi2 around 0 49.6%
Final simplification41.4%
(FPCore (lambda1 lambda2 phi1 phi2) :precision binary64 (atan2 (* (cos phi2) (sin (- lambda1 lambda2))) (sin phi2)))
double code(double lambda1, double lambda2, double phi1, double phi2) {
return atan2((cos(phi2) * sin((lambda1 - lambda2))), sin(phi2));
}
real(8) function code(lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
code = atan2((cos(phi2) * sin((lambda1 - lambda2))), sin(phi2))
end function
public static double code(double lambda1, double lambda2, double phi1, double phi2) {
return Math.atan2((Math.cos(phi2) * Math.sin((lambda1 - lambda2))), Math.sin(phi2));
}
def code(lambda1, lambda2, phi1, phi2): return math.atan2((math.cos(phi2) * math.sin((lambda1 - lambda2))), math.sin(phi2))
function code(lambda1, lambda2, phi1, phi2) return atan(Float64(cos(phi2) * sin(Float64(lambda1 - lambda2))), sin(phi2)) end
function tmp = code(lambda1, lambda2, phi1, phi2) tmp = atan2((cos(phi2) * sin((lambda1 - lambda2))), sin(phi2)); end
code[lambda1_, lambda2_, phi1_, phi2_] := N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[Sin[phi2], $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\sin \phi_2}
\end{array}
Initial program 78.8%
associate-*l*78.8%
Simplified78.8%
Taylor expanded in phi2 around 0 64.2%
Taylor expanded in phi1 around 0 48.3%
Final simplification48.3%
(FPCore (lambda1 lambda2 phi1 phi2) :precision binary64 (if (or (<= lambda1 -1.5e-44) (not (<= lambda1 4.8e-54))) (atan2 (sin lambda1) (sin phi2)) (atan2 (sin (- lambda2)) (sin phi2))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if ((lambda1 <= -1.5e-44) || !(lambda1 <= 4.8e-54)) {
tmp = atan2(sin(lambda1), sin(phi2));
} else {
tmp = atan2(sin(-lambda2), sin(phi2));
}
return tmp;
}
real(8) function code(lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: tmp
if ((lambda1 <= (-1.5d-44)) .or. (.not. (lambda1 <= 4.8d-54))) then
tmp = atan2(sin(lambda1), sin(phi2))
else
tmp = atan2(sin(-lambda2), sin(phi2))
end if
code = tmp
end function
public static double code(double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if ((lambda1 <= -1.5e-44) || !(lambda1 <= 4.8e-54)) {
tmp = Math.atan2(Math.sin(lambda1), Math.sin(phi2));
} else {
tmp = Math.atan2(Math.sin(-lambda2), Math.sin(phi2));
}
return tmp;
}
def code(lambda1, lambda2, phi1, phi2): tmp = 0 if (lambda1 <= -1.5e-44) or not (lambda1 <= 4.8e-54): tmp = math.atan2(math.sin(lambda1), math.sin(phi2)) else: tmp = math.atan2(math.sin(-lambda2), math.sin(phi2)) return tmp
function code(lambda1, lambda2, phi1, phi2) tmp = 0.0 if ((lambda1 <= -1.5e-44) || !(lambda1 <= 4.8e-54)) tmp = atan(sin(lambda1), sin(phi2)); else tmp = atan(sin(Float64(-lambda2)), sin(phi2)); end return tmp end
function tmp_2 = code(lambda1, lambda2, phi1, phi2) tmp = 0.0; if ((lambda1 <= -1.5e-44) || ~((lambda1 <= 4.8e-54))) tmp = atan2(sin(lambda1), sin(phi2)); else tmp = atan2(sin(-lambda2), sin(phi2)); end tmp_2 = tmp; end
code[lambda1_, lambda2_, phi1_, phi2_] := If[Or[LessEqual[lambda1, -1.5e-44], N[Not[LessEqual[lambda1, 4.8e-54]], $MachinePrecision]], N[ArcTan[N[Sin[lambda1], $MachinePrecision] / N[Sin[phi2], $MachinePrecision]], $MachinePrecision], N[ArcTan[N[Sin[(-lambda2)], $MachinePrecision] / N[Sin[phi2], $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\lambda_1 \leq -1.5 \cdot 10^{-44} \lor \neg \left(\lambda_1 \leq 4.8 \cdot 10^{-54}\right):\\
\;\;\;\;\tan^{-1}_* \frac{\sin \lambda_1}{\sin \phi_2}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{\sin \left(-\lambda_2\right)}{\sin \phi_2}\\
\end{array}
\end{array}
if lambda1 < -1.5000000000000001e-44 or 4.80000000000000026e-54 < lambda1 Initial program 67.6%
associate-*l*67.6%
Simplified67.6%
Taylor expanded in phi2 around 0 56.5%
Taylor expanded in phi1 around 0 43.9%
Taylor expanded in phi2 around 0 29.8%
Taylor expanded in lambda2 around 0 28.6%
if -1.5000000000000001e-44 < lambda1 < 4.80000000000000026e-54Initial program 99.8%
associate-*l*99.8%
Simplified99.8%
Taylor expanded in phi2 around 0 78.7%
Taylor expanded in phi1 around 0 56.4%
Taylor expanded in phi2 around 0 35.6%
Taylor expanded in lambda1 around 0 33.7%
Final simplification30.4%
(FPCore (lambda1 lambda2 phi1 phi2) :precision binary64 (atan2 (sin (- lambda1 lambda2)) (sin phi2)))
double code(double lambda1, double lambda2, double phi1, double phi2) {
return atan2(sin((lambda1 - lambda2)), sin(phi2));
}
real(8) function code(lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
code = atan2(sin((lambda1 - lambda2)), sin(phi2))
end function
public static double code(double lambda1, double lambda2, double phi1, double phi2) {
return Math.atan2(Math.sin((lambda1 - lambda2)), Math.sin(phi2));
}
def code(lambda1, lambda2, phi1, phi2): return math.atan2(math.sin((lambda1 - lambda2)), math.sin(phi2))
function code(lambda1, lambda2, phi1, phi2) return atan(sin(Float64(lambda1 - lambda2)), sin(phi2)) end
function tmp = code(lambda1, lambda2, phi1, phi2) tmp = atan2(sin((lambda1 - lambda2)), sin(phi2)); end
code[lambda1_, lambda2_, phi1_, phi2_] := N[ArcTan[N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision] / N[Sin[phi2], $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\tan^{-1}_* \frac{\sin \left(\lambda_1 - \lambda_2\right)}{\sin \phi_2}
\end{array}
Initial program 78.8%
associate-*l*78.8%
Simplified78.8%
Taylor expanded in phi2 around 0 64.2%
Taylor expanded in phi1 around 0 48.3%
Taylor expanded in phi2 around 0 31.8%
Final simplification31.8%
(FPCore (lambda1 lambda2 phi1 phi2) :precision binary64 (atan2 (sin lambda1) (sin phi2)))
double code(double lambda1, double lambda2, double phi1, double phi2) {
return atan2(sin(lambda1), sin(phi2));
}
real(8) function code(lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
code = atan2(sin(lambda1), sin(phi2))
end function
public static double code(double lambda1, double lambda2, double phi1, double phi2) {
return Math.atan2(Math.sin(lambda1), Math.sin(phi2));
}
def code(lambda1, lambda2, phi1, phi2): return math.atan2(math.sin(lambda1), math.sin(phi2))
function code(lambda1, lambda2, phi1, phi2) return atan(sin(lambda1), sin(phi2)) end
function tmp = code(lambda1, lambda2, phi1, phi2) tmp = atan2(sin(lambda1), sin(phi2)); end
code[lambda1_, lambda2_, phi1_, phi2_] := N[ArcTan[N[Sin[lambda1], $MachinePrecision] / N[Sin[phi2], $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\tan^{-1}_* \frac{\sin \lambda_1}{\sin \phi_2}
\end{array}
Initial program 78.8%
associate-*l*78.8%
Simplified78.8%
Taylor expanded in phi2 around 0 64.2%
Taylor expanded in phi1 around 0 48.3%
Taylor expanded in phi2 around 0 31.8%
Taylor expanded in lambda2 around 0 25.8%
Final simplification25.8%
herbie shell --seed 2023301
(FPCore (lambda1 lambda2 phi1 phi2)
:name "Bearing on a great circle"
:precision binary64
(atan2 (* (sin (- lambda1 lambda2)) (cos phi2)) (- (* (cos phi1) (sin phi2)) (* (* (sin phi1) (cos phi2)) (cos (- lambda1 lambda2))))))