
(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 31 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
(let* ((t_0 (* (cos lambda2) (cos lambda1)))
(t_1 (* (sin lambda1) (sin lambda2))))
(atan2
(*
(cos phi2)
(- (* (sin lambda1) (cos lambda2)) (* (cos lambda1) (sin lambda2))))
(-
(* (cos phi1) (sin phi2))
(*
(* (cos phi2) (sin phi1))
(/
(+ (pow t_0 3.0) (pow t_1 3.0))
(fma (cos lambda2) (* (cos lambda1) t_0) (* t_1 (- t_1 t_0)))))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos(lambda2) * cos(lambda1);
double t_1 = sin(lambda1) * sin(lambda2);
return atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), ((cos(phi1) * sin(phi2)) - ((cos(phi2) * sin(phi1)) * ((pow(t_0, 3.0) + pow(t_1, 3.0)) / fma(cos(lambda2), (cos(lambda1) * t_0), (t_1 * (t_1 - t_0)))))));
}
function code(lambda1, lambda2, phi1, phi2) t_0 = Float64(cos(lambda2) * cos(lambda1)) t_1 = Float64(sin(lambda1) * sin(lambda2)) return atan(Float64(cos(phi2) * Float64(Float64(sin(lambda1) * cos(lambda2)) - Float64(cos(lambda1) * sin(lambda2)))), Float64(Float64(cos(phi1) * sin(phi2)) - Float64(Float64(cos(phi2) * sin(phi1)) * Float64(Float64((t_0 ^ 3.0) + (t_1 ^ 3.0)) / fma(cos(lambda2), Float64(cos(lambda1) * t_0), Float64(t_1 * Float64(t_1 - t_0))))))) end
code[lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[Cos[lambda2], $MachinePrecision] * N[Cos[lambda1], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[Sin[lambda1], $MachinePrecision] * N[Sin[lambda2], $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[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] - N[(N[(N[Cos[phi2], $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision] * N[(N[(N[Power[t$95$0, 3.0], $MachinePrecision] + N[Power[t$95$1, 3.0], $MachinePrecision]), $MachinePrecision] / N[(N[Cos[lambda2], $MachinePrecision] * N[(N[Cos[lambda1], $MachinePrecision] * t$95$0), $MachinePrecision] + N[(t$95$1 * N[(t$95$1 - t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \cos \lambda_2 \cdot \cos \lambda_1\\
t_1 := \sin \lambda_1 \cdot \sin \lambda_2\\
\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 - \left(\cos \phi_2 \cdot \sin \phi_1\right) \cdot \frac{{t_0}^{3} + {t_1}^{3}}{\mathsf{fma}\left(\cos \lambda_2, \cos \lambda_1 \cdot t_0, t_1 \cdot \left(t_1 - t_0\right)\right)}}
\end{array}
\end{array}
Initial program 81.9%
sin-diff90.3%
cancel-sign-sub-inv90.3%
fma-def90.3%
Applied egg-rr90.3%
cos-diff99.8%
flip3-+99.8%
*-commutative99.8%
fma-def99.8%
*-commutative99.8%
*-commutative99.8%
*-commutative99.8%
Applied egg-rr99.8%
fma-udef99.8%
cos-neg99.8%
associate-*l*99.8%
fma-def99.8%
cos-neg99.8%
Simplified99.8%
Taylor expanded in lambda1 around inf 99.8%
neg-mul-199.8%
distribute-lft-neg-in99.8%
+-commutative99.8%
*-commutative99.8%
cancel-sign-sub-inv99.8%
Simplified99.8%
Final simplification99.8%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (cos lambda2) (cos lambda1)))
(t_1 (* (sin lambda1) (sin lambda2))))
(atan2
(*
(cos phi2)
(- (* (sin lambda1) (cos lambda2)) (* (cos lambda1) (sin lambda2))))
(-
(* (cos phi1) (sin phi2))
(*
(* (cos phi2) (sin phi1))
(/
(+ (pow t_0 3.0) (pow t_1 3.0))
(fma
(pow (cos lambda1) 2.0)
(pow (cos lambda2) 2.0)
(* t_1 (- t_1 t_0)))))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos(lambda2) * cos(lambda1);
double t_1 = sin(lambda1) * sin(lambda2);
return atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), ((cos(phi1) * sin(phi2)) - ((cos(phi2) * sin(phi1)) * ((pow(t_0, 3.0) + pow(t_1, 3.0)) / fma(pow(cos(lambda1), 2.0), pow(cos(lambda2), 2.0), (t_1 * (t_1 - t_0)))))));
}
function code(lambda1, lambda2, phi1, phi2) t_0 = Float64(cos(lambda2) * cos(lambda1)) t_1 = Float64(sin(lambda1) * sin(lambda2)) return atan(Float64(cos(phi2) * Float64(Float64(sin(lambda1) * cos(lambda2)) - Float64(cos(lambda1) * sin(lambda2)))), Float64(Float64(cos(phi1) * sin(phi2)) - Float64(Float64(cos(phi2) * sin(phi1)) * Float64(Float64((t_0 ^ 3.0) + (t_1 ^ 3.0)) / fma((cos(lambda1) ^ 2.0), (cos(lambda2) ^ 2.0), Float64(t_1 * Float64(t_1 - t_0))))))) end
code[lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[Cos[lambda2], $MachinePrecision] * N[Cos[lambda1], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[Sin[lambda1], $MachinePrecision] * N[Sin[lambda2], $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[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] - N[(N[(N[Cos[phi2], $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision] * N[(N[(N[Power[t$95$0, 3.0], $MachinePrecision] + N[Power[t$95$1, 3.0], $MachinePrecision]), $MachinePrecision] / N[(N[Power[N[Cos[lambda1], $MachinePrecision], 2.0], $MachinePrecision] * N[Power[N[Cos[lambda2], $MachinePrecision], 2.0], $MachinePrecision] + N[(t$95$1 * N[(t$95$1 - t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \cos \lambda_2 \cdot \cos \lambda_1\\
t_1 := \sin \lambda_1 \cdot \sin \lambda_2\\
\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 - \left(\cos \phi_2 \cdot \sin \phi_1\right) \cdot \frac{{t_0}^{3} + {t_1}^{3}}{\mathsf{fma}\left({\cos \lambda_1}^{2}, {\cos \lambda_2}^{2}, t_1 \cdot \left(t_1 - t_0\right)\right)}}
\end{array}
\end{array}
Initial program 81.9%
sin-diff90.3%
cancel-sign-sub-inv90.3%
fma-def90.3%
Applied egg-rr90.3%
cos-diff99.8%
flip3-+99.8%
*-commutative99.8%
fma-def99.8%
*-commutative99.8%
*-commutative99.8%
*-commutative99.8%
Applied egg-rr99.8%
fma-udef99.8%
cos-neg99.8%
associate-*l*99.8%
fma-def99.8%
cos-neg99.8%
Simplified99.8%
Taylor expanded in lambda1 around inf 99.8%
neg-mul-199.8%
distribute-lft-neg-in99.8%
+-commutative99.8%
*-commutative99.8%
cancel-sign-sub-inv99.8%
Simplified99.8%
Taylor expanded in lambda2 around inf 99.8%
cube-prod99.8%
cube-prod99.8%
*-commutative99.8%
+-commutative99.8%
fma-def99.8%
associate-*r*99.8%
*-commutative99.8%
*-commutative99.8%
Simplified99.8%
Final simplification99.8%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(atan2
(*
(cos phi2)
(fma (sin lambda1) (cos lambda2) (* (cos lambda1) (- (sin lambda2)))))
(-
(* (cos phi1) (sin phi2))
(*
(* (cos phi2) (sin phi1))
(fma (cos lambda2) (cos lambda1) (* (sin lambda1) (sin lambda2)))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
return atan2((cos(phi2) * fma(sin(lambda1), cos(lambda2), (cos(lambda1) * -sin(lambda2)))), ((cos(phi1) * sin(phi2)) - ((cos(phi2) * sin(phi1)) * fma(cos(lambda2), cos(lambda1), (sin(lambda1) * sin(lambda2))))));
}
function code(lambda1, lambda2, phi1, phi2) return atan(Float64(cos(phi2) * fma(sin(lambda1), cos(lambda2), Float64(cos(lambda1) * Float64(-sin(lambda2))))), Float64(Float64(cos(phi1) * sin(phi2)) - Float64(Float64(cos(phi2) * sin(phi1)) * fma(cos(lambda2), cos(lambda1), Float64(sin(lambda1) * sin(lambda2)))))) end
code[lambda1_, lambda2_, phi1_, phi2_] := N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $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[(N[Cos[phi2], $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision] * N[(N[Cos[lambda2], $MachinePrecision] * N[Cos[lambda1], $MachinePrecision] + N[(N[Sin[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\tan^{-1}_* \frac{\cos \phi_2 \cdot \mathsf{fma}\left(\sin \lambda_1, \cos \lambda_2, \cos \lambda_1 \cdot \left(-\sin \lambda_2\right)\right)}{\cos \phi_1 \cdot \sin \phi_2 - \left(\cos \phi_2 \cdot \sin \phi_1\right) \cdot \mathsf{fma}\left(\cos \lambda_2, \cos \lambda_1, \sin \lambda_1 \cdot \sin \lambda_2\right)}
\end{array}
Initial program 81.9%
sin-diff90.3%
cancel-sign-sub-inv90.3%
fma-def90.3%
Applied egg-rr90.3%
cos-diff82.5%
*-commutative82.5%
Applied egg-rr99.8%
fma-def82.5%
Simplified99.8%
Final simplification99.8%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (cos phi1) (sin phi2)))
(t_1
(*
(cos phi2)
(fma
(sin lambda1)
(cos lambda2)
(* (cos lambda1) (- (sin lambda2))))))
(t_2 (cos (- lambda1 lambda2))))
(if (<= phi2 -200000000000.0)
(atan2 t_1 (- t_0 (log (exp (* (sin phi1) (* (cos phi2) t_2))))))
(if (<= phi2 5.5e-9)
(atan2
t_1
(-
t_0
(*
(sin phi1)
(fma (cos lambda2) (cos lambda1) (* (sin lambda1) (sin lambda2))))))
(atan2 t_1 (- t_0 (* (* (cos phi2) (sin phi1)) t_2)))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos(phi1) * sin(phi2);
double t_1 = cos(phi2) * fma(sin(lambda1), cos(lambda2), (cos(lambda1) * -sin(lambda2)));
double t_2 = cos((lambda1 - lambda2));
double tmp;
if (phi2 <= -200000000000.0) {
tmp = atan2(t_1, (t_0 - log(exp((sin(phi1) * (cos(phi2) * t_2))))));
} else if (phi2 <= 5.5e-9) {
tmp = atan2(t_1, (t_0 - (sin(phi1) * fma(cos(lambda2), cos(lambda1), (sin(lambda1) * sin(lambda2))))));
} else {
tmp = atan2(t_1, (t_0 - ((cos(phi2) * sin(phi1)) * t_2)));
}
return tmp;
}
function code(lambda1, lambda2, phi1, phi2) t_0 = Float64(cos(phi1) * sin(phi2)) t_1 = Float64(cos(phi2) * fma(sin(lambda1), cos(lambda2), Float64(cos(lambda1) * Float64(-sin(lambda2))))) t_2 = cos(Float64(lambda1 - lambda2)) tmp = 0.0 if (phi2 <= -200000000000.0) tmp = atan(t_1, Float64(t_0 - log(exp(Float64(sin(phi1) * Float64(cos(phi2) * t_2)))))); elseif (phi2 <= 5.5e-9) tmp = atan(t_1, Float64(t_0 - Float64(sin(phi1) * fma(cos(lambda2), cos(lambda1), Float64(sin(lambda1) * sin(lambda2)))))); else tmp = atan(t_1, Float64(t_0 - Float64(Float64(cos(phi2) * sin(phi1)) * t_2))); 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[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision] + N[(N[Cos[lambda1], $MachinePrecision] * (-N[Sin[lambda2], $MachinePrecision])), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[phi2, -200000000000.0], N[ArcTan[t$95$1 / N[(t$95$0 - N[Log[N[Exp[N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * t$95$2), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[phi2, 5.5e-9], N[ArcTan[t$95$1 / N[(t$95$0 - N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[lambda2], $MachinePrecision] * N[Cos[lambda1], $MachinePrecision] + N[(N[Sin[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[t$95$1 / N[(t$95$0 - N[(N[(N[Cos[phi2], $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision] * t$95$2), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \cos \phi_1 \cdot \sin \phi_2\\
t_1 := \cos \phi_2 \cdot \mathsf{fma}\left(\sin \lambda_1, \cos \lambda_2, \cos \lambda_1 \cdot \left(-\sin \lambda_2\right)\right)\\
t_2 := \cos \left(\lambda_1 - \lambda_2\right)\\
\mathbf{if}\;\phi_2 \leq -200000000000:\\
\;\;\;\;\tan^{-1}_* \frac{t_1}{t_0 - \log \left(e^{\sin \phi_1 \cdot \left(\cos \phi_2 \cdot t_2\right)}\right)}\\
\mathbf{elif}\;\phi_2 \leq 5.5 \cdot 10^{-9}:\\
\;\;\;\;\tan^{-1}_* \frac{t_1}{t_0 - \sin \phi_1 \cdot \mathsf{fma}\left(\cos \lambda_2, \cos \lambda_1, \sin \lambda_1 \cdot \sin \lambda_2\right)}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{t_1}{t_0 - \left(\cos \phi_2 \cdot \sin \phi_1\right) \cdot t_2}\\
\end{array}
\end{array}
if phi2 < -2e11Initial program 84.7%
sin-diff88.8%
cancel-sign-sub-inv88.8%
fma-def88.8%
Applied egg-rr88.8%
add-log-exp88.8%
associate-*l*88.8%
Applied egg-rr88.8%
if -2e11 < phi2 < 5.4999999999999996e-9Initial program 81.5%
sin-diff91.0%
cancel-sign-sub-inv91.0%
fma-def91.0%
Applied egg-rr91.0%
Taylor expanded in phi2 around 0 91.0%
*-commutative91.0%
Simplified91.0%
cos-diff99.3%
*-commutative99.3%
Applied egg-rr99.3%
fma-def99.3%
Simplified99.3%
if 5.4999999999999996e-9 < phi2 Initial program 80.4%
sin-diff90.1%
cancel-sign-sub-inv90.1%
fma-def90.1%
Applied egg-rr90.1%
Final simplification94.6%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(atan2
(*
(cos phi2)
(fma (sin lambda1) (cos lambda2) (* (cos lambda1) (- (sin lambda2)))))
(-
(* (cos phi1) (sin phi2))
(*
(* (cos phi2) (sin phi1))
(+ (* (cos lambda2) (cos lambda1)) (* (sin lambda1) (sin lambda2)))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
return atan2((cos(phi2) * fma(sin(lambda1), cos(lambda2), (cos(lambda1) * -sin(lambda2)))), ((cos(phi1) * sin(phi2)) - ((cos(phi2) * sin(phi1)) * ((cos(lambda2) * cos(lambda1)) + (sin(lambda1) * sin(lambda2))))));
}
function code(lambda1, lambda2, phi1, phi2) return atan(Float64(cos(phi2) * fma(sin(lambda1), cos(lambda2), Float64(cos(lambda1) * Float64(-sin(lambda2))))), Float64(Float64(cos(phi1) * sin(phi2)) - Float64(Float64(cos(phi2) * sin(phi1)) * Float64(Float64(cos(lambda2) * cos(lambda1)) + Float64(sin(lambda1) * sin(lambda2)))))) end
code[lambda1_, lambda2_, phi1_, phi2_] := N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $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[(N[Cos[phi2], $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision] * N[(N[(N[Cos[lambda2], $MachinePrecision] * N[Cos[lambda1], $MachinePrecision]), $MachinePrecision] + N[(N[Sin[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\tan^{-1}_* \frac{\cos \phi_2 \cdot \mathsf{fma}\left(\sin \lambda_1, \cos \lambda_2, \cos \lambda_1 \cdot \left(-\sin \lambda_2\right)\right)}{\cos \phi_1 \cdot \sin \phi_2 - \left(\cos \phi_2 \cdot \sin \phi_1\right) \cdot \left(\cos \lambda_2 \cdot \cos \lambda_1 + \sin \lambda_1 \cdot \sin \lambda_2\right)}
\end{array}
Initial program 81.9%
sin-diff90.3%
cancel-sign-sub-inv90.3%
fma-def90.3%
Applied egg-rr90.3%
cos-diff82.5%
+-commutative82.5%
*-commutative82.5%
Applied egg-rr99.8%
Final simplification99.8%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (cos phi1) (sin phi2)))
(t_1
(*
(cos phi2)
(fma
(sin lambda1)
(cos lambda2)
(* (cos lambda1) (- (sin lambda2))))))
(t_2 (cos (- lambda1 lambda2))))
(if (<= phi2 -200000000000.0)
(atan2 t_1 (- t_0 (log (exp (* (sin phi1) (* (cos phi2) t_2))))))
(if (<= phi2 5.5e-9)
(atan2
t_1
(-
t_0
(*
(sin phi1)
(+
(* (cos lambda2) (cos lambda1))
(* (sin lambda1) (sin lambda2))))))
(atan2 t_1 (- t_0 (* (* (cos phi2) (sin phi1)) t_2)))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos(phi1) * sin(phi2);
double t_1 = cos(phi2) * fma(sin(lambda1), cos(lambda2), (cos(lambda1) * -sin(lambda2)));
double t_2 = cos((lambda1 - lambda2));
double tmp;
if (phi2 <= -200000000000.0) {
tmp = atan2(t_1, (t_0 - log(exp((sin(phi1) * (cos(phi2) * t_2))))));
} else if (phi2 <= 5.5e-9) {
tmp = atan2(t_1, (t_0 - (sin(phi1) * ((cos(lambda2) * cos(lambda1)) + (sin(lambda1) * sin(lambda2))))));
} else {
tmp = atan2(t_1, (t_0 - ((cos(phi2) * sin(phi1)) * t_2)));
}
return tmp;
}
function code(lambda1, lambda2, phi1, phi2) t_0 = Float64(cos(phi1) * sin(phi2)) t_1 = Float64(cos(phi2) * fma(sin(lambda1), cos(lambda2), Float64(cos(lambda1) * Float64(-sin(lambda2))))) t_2 = cos(Float64(lambda1 - lambda2)) tmp = 0.0 if (phi2 <= -200000000000.0) tmp = atan(t_1, Float64(t_0 - log(exp(Float64(sin(phi1) * Float64(cos(phi2) * t_2)))))); elseif (phi2 <= 5.5e-9) tmp = atan(t_1, Float64(t_0 - Float64(sin(phi1) * Float64(Float64(cos(lambda2) * cos(lambda1)) + Float64(sin(lambda1) * sin(lambda2)))))); else tmp = atan(t_1, Float64(t_0 - Float64(Float64(cos(phi2) * sin(phi1)) * t_2))); 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[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision] + N[(N[Cos[lambda1], $MachinePrecision] * (-N[Sin[lambda2], $MachinePrecision])), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[phi2, -200000000000.0], N[ArcTan[t$95$1 / N[(t$95$0 - N[Log[N[Exp[N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * t$95$2), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[phi2, 5.5e-9], N[ArcTan[t$95$1 / N[(t$95$0 - N[(N[Sin[phi1], $MachinePrecision] * N[(N[(N[Cos[lambda2], $MachinePrecision] * N[Cos[lambda1], $MachinePrecision]), $MachinePrecision] + N[(N[Sin[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[t$95$1 / N[(t$95$0 - N[(N[(N[Cos[phi2], $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision] * t$95$2), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \cos \phi_1 \cdot \sin \phi_2\\
t_1 := \cos \phi_2 \cdot \mathsf{fma}\left(\sin \lambda_1, \cos \lambda_2, \cos \lambda_1 \cdot \left(-\sin \lambda_2\right)\right)\\
t_2 := \cos \left(\lambda_1 - \lambda_2\right)\\
\mathbf{if}\;\phi_2 \leq -200000000000:\\
\;\;\;\;\tan^{-1}_* \frac{t_1}{t_0 - \log \left(e^{\sin \phi_1 \cdot \left(\cos \phi_2 \cdot t_2\right)}\right)}\\
\mathbf{elif}\;\phi_2 \leq 5.5 \cdot 10^{-9}:\\
\;\;\;\;\tan^{-1}_* \frac{t_1}{t_0 - \sin \phi_1 \cdot \left(\cos \lambda_2 \cdot \cos \lambda_1 + \sin \lambda_1 \cdot \sin \lambda_2\right)}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{t_1}{t_0 - \left(\cos \phi_2 \cdot \sin \phi_1\right) \cdot t_2}\\
\end{array}
\end{array}
if phi2 < -2e11Initial program 84.7%
sin-diff88.8%
cancel-sign-sub-inv88.8%
fma-def88.8%
Applied egg-rr88.8%
add-log-exp88.8%
associate-*l*88.8%
Applied egg-rr88.8%
if -2e11 < phi2 < 5.4999999999999996e-9Initial program 81.5%
sin-diff91.0%
cancel-sign-sub-inv91.0%
fma-def91.0%
Applied egg-rr91.0%
Taylor expanded in phi2 around 0 91.0%
*-commutative91.0%
Simplified91.0%
cos-diff99.3%
+-commutative99.3%
*-commutative99.3%
Applied egg-rr99.3%
if 5.4999999999999996e-9 < phi2 Initial program 80.4%
sin-diff90.1%
cancel-sign-sub-inv90.1%
fma-def90.1%
Applied egg-rr90.1%
Final simplification94.6%
(FPCore (lambda1 lambda2 phi1 phi2) :precision binary64 (atan2 (* (cos phi2) (fma (sin lambda1) (cos lambda2) (* (cos lambda1) (- (sin lambda2))))) (- (* (cos phi1) (sin phi2)) (* (* (cos phi2) (sin phi1)) (cos (- lambda1 lambda2))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
return atan2((cos(phi2) * fma(sin(lambda1), cos(lambda2), (cos(lambda1) * -sin(lambda2)))), ((cos(phi1) * sin(phi2)) - ((cos(phi2) * sin(phi1)) * cos((lambda1 - lambda2)))));
}
function code(lambda1, lambda2, phi1, phi2) return atan(Float64(cos(phi2) * fma(sin(lambda1), cos(lambda2), Float64(cos(lambda1) * Float64(-sin(lambda2))))), Float64(Float64(cos(phi1) * sin(phi2)) - Float64(Float64(cos(phi2) * sin(phi1)) * cos(Float64(lambda1 - lambda2))))) end
code[lambda1_, lambda2_, phi1_, phi2_] := N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $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[(N[Cos[phi2], $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\tan^{-1}_* \frac{\cos \phi_2 \cdot \mathsf{fma}\left(\sin \lambda_1, \cos \lambda_2, \cos \lambda_1 \cdot \left(-\sin \lambda_2\right)\right)}{\cos \phi_1 \cdot \sin \phi_2 - \left(\cos \phi_2 \cdot \sin \phi_1\right) \cdot \cos \left(\lambda_1 - \lambda_2\right)}
\end{array}
Initial program 81.9%
sin-diff90.3%
cancel-sign-sub-inv90.3%
fma-def90.3%
Applied egg-rr90.3%
Final simplification90.3%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (cos phi1) (sin phi2))))
(if (or (<= lambda1 -0.0033) (not (<= lambda1 65000.0)))
(atan2
(*
(cos phi2)
(- (* (sin lambda1) (cos lambda2)) (* (cos lambda1) (sin lambda2))))
(- t_0 (* (cos lambda1) (* (cos phi2) (sin phi1)))))
(atan2
(* (cos phi2) (sin (- lambda1 lambda2)))
(fma (cos phi2) (* (sin phi1) (- (cos (- lambda1 lambda2)))) t_0)))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos(phi1) * sin(phi2);
double tmp;
if ((lambda1 <= -0.0033) || !(lambda1 <= 65000.0)) {
tmp = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), (t_0 - (cos(lambda1) * (cos(phi2) * sin(phi1)))));
} else {
tmp = atan2((cos(phi2) * sin((lambda1 - lambda2))), fma(cos(phi2), (sin(phi1) * -cos((lambda1 - lambda2))), t_0));
}
return tmp;
}
function code(lambda1, lambda2, phi1, phi2) t_0 = Float64(cos(phi1) * sin(phi2)) tmp = 0.0 if ((lambda1 <= -0.0033) || !(lambda1 <= 65000.0)) tmp = atan(Float64(cos(phi2) * Float64(Float64(sin(lambda1) * cos(lambda2)) - Float64(cos(lambda1) * sin(lambda2)))), Float64(t_0 - Float64(cos(lambda1) * Float64(cos(phi2) * sin(phi1))))); else tmp = atan(Float64(cos(phi2) * sin(Float64(lambda1 - lambda2))), fma(cos(phi2), Float64(sin(phi1) * Float64(-cos(Float64(lambda1 - lambda2)))), t_0)); 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[lambda1, -0.0033], N[Not[LessEqual[lambda1, 65000.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[Cos[lambda1], $MachinePrecision] * N[(N[Cos[phi2], $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[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[phi1], $MachinePrecision] * (-N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision])), $MachinePrecision] + t$95$0), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \cos \phi_1 \cdot \sin \phi_2\\
\mathbf{if}\;\lambda_1 \leq -0.0033 \lor \neg \left(\lambda_1 \leq 65000\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 \lambda_1 \cdot \left(\cos \phi_2 \cdot \sin \phi_1\right)}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\mathsf{fma}\left(\cos \phi_2, \sin \phi_1 \cdot \left(-\cos \left(\lambda_1 - \lambda_2\right)\right), t_0\right)}\\
\end{array}
\end{array}
if lambda1 < -0.0033 or 65000 < lambda1 Initial program 63.9%
sin-diff80.8%
cancel-sign-sub-inv80.8%
fma-def80.8%
Applied egg-rr80.8%
cos-diff99.7%
flip3-+99.7%
*-commutative99.7%
fma-def99.7%
*-commutative99.7%
*-commutative99.7%
*-commutative99.7%
Applied egg-rr99.7%
fma-udef99.7%
cos-neg99.7%
associate-*l*99.7%
fma-def99.7%
cos-neg99.7%
Simplified99.8%
Taylor expanded in lambda1 around inf 99.8%
neg-mul-199.8%
distribute-lft-neg-in99.8%
+-commutative99.8%
*-commutative99.8%
cancel-sign-sub-inv99.8%
Simplified99.8%
Taylor expanded in lambda2 around 0 81.0%
if -0.0033 < lambda1 < 65000Initial program 99.6%
sub-neg99.6%
+-commutative99.6%
distribute-rgt-neg-in99.6%
*-commutative99.6%
associate-*l*99.6%
fma-def99.7%
distribute-rgt-neg-in99.7%
*-commutative99.7%
distribute-rgt-neg-out99.7%
Simplified99.7%
Final simplification90.4%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (cos phi1) (sin phi2))))
(if (or (<= phi1 -2050000000.0) (not (<= phi1 275000.0)))
(atan2
(* (cos phi2) (fma (sin lambda1) (cos lambda2) (- (sin lambda2))))
(- t_0 (* (* (cos phi2) (sin phi1)) (cos (- lambda1 lambda2)))))
(atan2
(*
(cos phi2)
(- (* (sin lambda1) (cos lambda2)) (* (cos lambda1) (sin lambda2))))
(- t_0 (* (sin phi1) (cos (- lambda2 lambda1))))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos(phi1) * sin(phi2);
double tmp;
if ((phi1 <= -2050000000.0) || !(phi1 <= 275000.0)) {
tmp = atan2((cos(phi2) * fma(sin(lambda1), cos(lambda2), -sin(lambda2))), (t_0 - ((cos(phi2) * sin(phi1)) * cos((lambda1 - lambda2)))));
} else {
tmp = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), (t_0 - (sin(phi1) * cos((lambda2 - lambda1)))));
}
return tmp;
}
function code(lambda1, lambda2, phi1, phi2) t_0 = Float64(cos(phi1) * sin(phi2)) tmp = 0.0 if ((phi1 <= -2050000000.0) || !(phi1 <= 275000.0)) tmp = atan(Float64(cos(phi2) * fma(sin(lambda1), cos(lambda2), Float64(-sin(lambda2)))), Float64(t_0 - Float64(Float64(cos(phi2) * sin(phi1)) * cos(Float64(lambda1 - lambda2))))); else tmp = atan(Float64(cos(phi2) * Float64(Float64(sin(lambda1) * cos(lambda2)) - Float64(cos(lambda1) * sin(lambda2)))), Float64(t_0 - Float64(sin(phi1) * cos(Float64(lambda2 - lambda1))))); 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[phi1, -2050000000.0], N[Not[LessEqual[phi1, 275000.0]], $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[(N[Cos[phi2], $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $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] * N[Cos[N[(lambda2 - lambda1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \cos \phi_1 \cdot \sin \phi_2\\
\mathbf{if}\;\phi_1 \leq -2050000000 \lor \neg \left(\phi_1 \leq 275000\right):\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \mathsf{fma}\left(\sin \lambda_1, \cos \lambda_2, -\sin \lambda_2\right)}{t_0 - \left(\cos \phi_2 \cdot \sin \phi_1\right) \cdot \cos \left(\lambda_1 - \lambda_2\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 \cos \left(\lambda_2 - \lambda_1\right)}\\
\end{array}
\end{array}
if phi1 < -2.05e9 or 275000 < phi1 Initial program 77.2%
sin-diff80.2%
cancel-sign-sub-inv80.2%
fma-def80.2%
Applied egg-rr80.2%
Taylor expanded in lambda1 around 0 78.4%
neg-mul-178.4%
Simplified78.4%
if -2.05e9 < phi1 < 275000Initial program 86.1%
associate-*l*86.1%
Simplified86.1%
Taylor expanded in phi2 around 0 86.1%
sub-neg86.1%
remove-double-neg86.1%
mul-1-neg86.1%
distribute-neg-in86.1%
+-commutative86.1%
cos-neg86.1%
mul-1-neg86.1%
unsub-neg86.1%
Simplified86.1%
sin-diff97.5%
Applied egg-rr99.4%
Final simplification89.4%
(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 81.9%
associate-*l*81.9%
Simplified81.9%
sin-diff59.0%
Applied egg-rr90.3%
Final simplification90.3%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (cos phi1) (sin phi2)))
(t_1 (* (cos phi2) (sin phi1)))
(t_2 (cos (- lambda1 lambda2)))
(t_3 (* (cos phi2) (sin (- lambda1 lambda2)))))
(if (<= phi1 -2050000000.0)
(atan2 t_3 (- t_0 (* t_1 t_2)))
(if (<= phi1 275000.0)
(atan2
(*
(cos phi2)
(- (* (sin lambda1) (cos lambda2)) (* (cos lambda1) (sin lambda2))))
(- t_0 (* (sin phi1) (cos (- lambda2 lambda1)))))
(atan2 t_3 (- t_0 (* t_1 (log (exp t_2)))))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos(phi1) * sin(phi2);
double t_1 = cos(phi2) * sin(phi1);
double t_2 = cos((lambda1 - lambda2));
double t_3 = cos(phi2) * sin((lambda1 - lambda2));
double tmp;
if (phi1 <= -2050000000.0) {
tmp = atan2(t_3, (t_0 - (t_1 * t_2)));
} else if (phi1 <= 275000.0) {
tmp = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), (t_0 - (sin(phi1) * cos((lambda2 - lambda1)))));
} else {
tmp = atan2(t_3, (t_0 - (t_1 * log(exp(t_2)))));
}
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) :: t_2
real(8) :: t_3
real(8) :: tmp
t_0 = cos(phi1) * sin(phi2)
t_1 = cos(phi2) * sin(phi1)
t_2 = cos((lambda1 - lambda2))
t_3 = cos(phi2) * sin((lambda1 - lambda2))
if (phi1 <= (-2050000000.0d0)) then
tmp = atan2(t_3, (t_0 - (t_1 * t_2)))
else if (phi1 <= 275000.0d0) then
tmp = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), (t_0 - (sin(phi1) * cos((lambda2 - lambda1)))))
else
tmp = atan2(t_3, (t_0 - (t_1 * log(exp(t_2)))))
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 t_1 = Math.cos(phi2) * Math.sin(phi1);
double t_2 = Math.cos((lambda1 - lambda2));
double t_3 = Math.cos(phi2) * Math.sin((lambda1 - lambda2));
double tmp;
if (phi1 <= -2050000000.0) {
tmp = Math.atan2(t_3, (t_0 - (t_1 * t_2)));
} else if (phi1 <= 275000.0) {
tmp = Math.atan2((Math.cos(phi2) * ((Math.sin(lambda1) * Math.cos(lambda2)) - (Math.cos(lambda1) * Math.sin(lambda2)))), (t_0 - (Math.sin(phi1) * Math.cos((lambda2 - lambda1)))));
} else {
tmp = Math.atan2(t_3, (t_0 - (t_1 * Math.log(Math.exp(t_2)))));
}
return tmp;
}
def code(lambda1, lambda2, phi1, phi2): t_0 = math.cos(phi1) * math.sin(phi2) t_1 = math.cos(phi2) * math.sin(phi1) t_2 = math.cos((lambda1 - lambda2)) t_3 = math.cos(phi2) * math.sin((lambda1 - lambda2)) tmp = 0 if phi1 <= -2050000000.0: tmp = math.atan2(t_3, (t_0 - (t_1 * t_2))) elif phi1 <= 275000.0: tmp = math.atan2((math.cos(phi2) * ((math.sin(lambda1) * math.cos(lambda2)) - (math.cos(lambda1) * math.sin(lambda2)))), (t_0 - (math.sin(phi1) * math.cos((lambda2 - lambda1))))) else: tmp = math.atan2(t_3, (t_0 - (t_1 * math.log(math.exp(t_2))))) return tmp
function code(lambda1, lambda2, phi1, phi2) t_0 = Float64(cos(phi1) * sin(phi2)) t_1 = Float64(cos(phi2) * sin(phi1)) t_2 = cos(Float64(lambda1 - lambda2)) t_3 = Float64(cos(phi2) * sin(Float64(lambda1 - lambda2))) tmp = 0.0 if (phi1 <= -2050000000.0) tmp = atan(t_3, Float64(t_0 - Float64(t_1 * t_2))); elseif (phi1 <= 275000.0) tmp = atan(Float64(cos(phi2) * Float64(Float64(sin(lambda1) * cos(lambda2)) - Float64(cos(lambda1) * sin(lambda2)))), Float64(t_0 - Float64(sin(phi1) * cos(Float64(lambda2 - lambda1))))); else tmp = atan(t_3, Float64(t_0 - Float64(t_1 * log(exp(t_2))))); end return tmp end
function tmp_2 = code(lambda1, lambda2, phi1, phi2) t_0 = cos(phi1) * sin(phi2); t_1 = cos(phi2) * sin(phi1); t_2 = cos((lambda1 - lambda2)); t_3 = cos(phi2) * sin((lambda1 - lambda2)); tmp = 0.0; if (phi1 <= -2050000000.0) tmp = atan2(t_3, (t_0 - (t_1 * t_2))); elseif (phi1 <= 275000.0) tmp = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), (t_0 - (sin(phi1) * cos((lambda2 - lambda1))))); else tmp = atan2(t_3, (t_0 - (t_1 * log(exp(t_2))))); end tmp_2 = 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[(N[Cos[phi2], $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$3 = N[(N[Cos[phi2], $MachinePrecision] * N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[phi1, -2050000000.0], N[ArcTan[t$95$3 / N[(t$95$0 - N[(t$95$1 * t$95$2), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[phi1, 275000.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] / N[(t$95$0 - N[(N[Sin[phi1], $MachinePrecision] * N[Cos[N[(lambda2 - lambda1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[t$95$3 / N[(t$95$0 - N[(t$95$1 * N[Log[N[Exp[t$95$2], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \cos \phi_1 \cdot \sin \phi_2\\
t_1 := \cos \phi_2 \cdot \sin \phi_1\\
t_2 := \cos \left(\lambda_1 - \lambda_2\right)\\
t_3 := \cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)\\
\mathbf{if}\;\phi_1 \leq -2050000000:\\
\;\;\;\;\tan^{-1}_* \frac{t_3}{t_0 - t_1 \cdot t_2}\\
\mathbf{elif}\;\phi_1 \leq 275000:\\
\;\;\;\;\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 \cos \left(\lambda_2 - \lambda_1\right)}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{t_3}{t_0 - t_1 \cdot \log \left(e^{t_2}\right)}\\
\end{array}
\end{array}
if phi1 < -2.05e9Initial program 76.8%
if -2.05e9 < phi1 < 275000Initial program 86.1%
associate-*l*86.1%
Simplified86.1%
Taylor expanded in phi2 around 0 86.1%
sub-neg86.1%
remove-double-neg86.1%
mul-1-neg86.1%
distribute-neg-in86.1%
+-commutative86.1%
cos-neg86.1%
mul-1-neg86.1%
unsub-neg86.1%
Simplified86.1%
sin-diff97.5%
Applied egg-rr99.4%
if 275000 < phi1 Initial program 77.6%
add-log-exp77.6%
Applied egg-rr77.6%
Final simplification88.9%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (cos phi1) (sin phi2)))
(t_1 (* (cos phi2) (sin phi1)))
(t_2 (cos (- lambda1 lambda2)))
(t_3 (* (cos phi2) (sin (- lambda1 lambda2)))))
(if (<= phi1 -0.007)
(atan2 t_3 (- t_0 (* t_1 t_2)))
(if (<= phi1 1.02e-22)
(atan2
(*
(cos phi2)
(- (* (sin lambda1) (cos lambda2)) (* (cos lambda1) (sin lambda2))))
(- t_0 (* phi1 (cos (- lambda2 lambda1)))))
(atan2 t_3 (- t_0 (* t_1 (log (exp t_2)))))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos(phi1) * sin(phi2);
double t_1 = cos(phi2) * sin(phi1);
double t_2 = cos((lambda1 - lambda2));
double t_3 = cos(phi2) * sin((lambda1 - lambda2));
double tmp;
if (phi1 <= -0.007) {
tmp = atan2(t_3, (t_0 - (t_1 * t_2)));
} else if (phi1 <= 1.02e-22) {
tmp = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), (t_0 - (phi1 * cos((lambda2 - lambda1)))));
} else {
tmp = atan2(t_3, (t_0 - (t_1 * log(exp(t_2)))));
}
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) :: t_2
real(8) :: t_3
real(8) :: tmp
t_0 = cos(phi1) * sin(phi2)
t_1 = cos(phi2) * sin(phi1)
t_2 = cos((lambda1 - lambda2))
t_3 = cos(phi2) * sin((lambda1 - lambda2))
if (phi1 <= (-0.007d0)) then
tmp = atan2(t_3, (t_0 - (t_1 * t_2)))
else if (phi1 <= 1.02d-22) then
tmp = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), (t_0 - (phi1 * cos((lambda2 - lambda1)))))
else
tmp = atan2(t_3, (t_0 - (t_1 * log(exp(t_2)))))
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 t_1 = Math.cos(phi2) * Math.sin(phi1);
double t_2 = Math.cos((lambda1 - lambda2));
double t_3 = Math.cos(phi2) * Math.sin((lambda1 - lambda2));
double tmp;
if (phi1 <= -0.007) {
tmp = Math.atan2(t_3, (t_0 - (t_1 * t_2)));
} else if (phi1 <= 1.02e-22) {
tmp = Math.atan2((Math.cos(phi2) * ((Math.sin(lambda1) * Math.cos(lambda2)) - (Math.cos(lambda1) * Math.sin(lambda2)))), (t_0 - (phi1 * Math.cos((lambda2 - lambda1)))));
} else {
tmp = Math.atan2(t_3, (t_0 - (t_1 * Math.log(Math.exp(t_2)))));
}
return tmp;
}
def code(lambda1, lambda2, phi1, phi2): t_0 = math.cos(phi1) * math.sin(phi2) t_1 = math.cos(phi2) * math.sin(phi1) t_2 = math.cos((lambda1 - lambda2)) t_3 = math.cos(phi2) * math.sin((lambda1 - lambda2)) tmp = 0 if phi1 <= -0.007: tmp = math.atan2(t_3, (t_0 - (t_1 * t_2))) elif phi1 <= 1.02e-22: tmp = math.atan2((math.cos(phi2) * ((math.sin(lambda1) * math.cos(lambda2)) - (math.cos(lambda1) * math.sin(lambda2)))), (t_0 - (phi1 * math.cos((lambda2 - lambda1))))) else: tmp = math.atan2(t_3, (t_0 - (t_1 * math.log(math.exp(t_2))))) return tmp
function code(lambda1, lambda2, phi1, phi2) t_0 = Float64(cos(phi1) * sin(phi2)) t_1 = Float64(cos(phi2) * sin(phi1)) t_2 = cos(Float64(lambda1 - lambda2)) t_3 = Float64(cos(phi2) * sin(Float64(lambda1 - lambda2))) tmp = 0.0 if (phi1 <= -0.007) tmp = atan(t_3, Float64(t_0 - Float64(t_1 * t_2))); elseif (phi1 <= 1.02e-22) tmp = atan(Float64(cos(phi2) * Float64(Float64(sin(lambda1) * cos(lambda2)) - Float64(cos(lambda1) * sin(lambda2)))), Float64(t_0 - Float64(phi1 * cos(Float64(lambda2 - lambda1))))); else tmp = atan(t_3, Float64(t_0 - Float64(t_1 * log(exp(t_2))))); end return tmp end
function tmp_2 = code(lambda1, lambda2, phi1, phi2) t_0 = cos(phi1) * sin(phi2); t_1 = cos(phi2) * sin(phi1); t_2 = cos((lambda1 - lambda2)); t_3 = cos(phi2) * sin((lambda1 - lambda2)); tmp = 0.0; if (phi1 <= -0.007) tmp = atan2(t_3, (t_0 - (t_1 * t_2))); elseif (phi1 <= 1.02e-22) tmp = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), (t_0 - (phi1 * cos((lambda2 - lambda1))))); else tmp = atan2(t_3, (t_0 - (t_1 * log(exp(t_2))))); end tmp_2 = 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[(N[Cos[phi2], $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$3 = N[(N[Cos[phi2], $MachinePrecision] * N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[phi1, -0.007], N[ArcTan[t$95$3 / N[(t$95$0 - N[(t$95$1 * t$95$2), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[phi1, 1.02e-22], 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[(phi1 * N[Cos[N[(lambda2 - lambda1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[t$95$3 / N[(t$95$0 - N[(t$95$1 * N[Log[N[Exp[t$95$2], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \cos \phi_1 \cdot \sin \phi_2\\
t_1 := \cos \phi_2 \cdot \sin \phi_1\\
t_2 := \cos \left(\lambda_1 - \lambda_2\right)\\
t_3 := \cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)\\
\mathbf{if}\;\phi_1 \leq -0.007:\\
\;\;\;\;\tan^{-1}_* \frac{t_3}{t_0 - t_1 \cdot t_2}\\
\mathbf{elif}\;\phi_1 \leq 1.02 \cdot 10^{-22}:\\
\;\;\;\;\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 - \phi_1 \cdot \cos \left(\lambda_2 - \lambda_1\right)}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{t_3}{t_0 - t_1 \cdot \log \left(e^{t_2}\right)}\\
\end{array}
\end{array}
if phi1 < -0.00700000000000000015Initial program 77.6%
if -0.00700000000000000015 < phi1 < 1.02000000000000002e-22Initial program 85.7%
associate-*l*85.7%
Simplified85.7%
Taylor expanded in phi2 around 0 85.7%
sub-neg85.7%
remove-double-neg85.7%
mul-1-neg85.7%
distribute-neg-in85.7%
+-commutative85.7%
cos-neg85.7%
mul-1-neg85.7%
unsub-neg85.7%
Simplified85.7%
Taylor expanded in phi1 around 0 85.7%
sin-diff99.4%
Applied egg-rr99.4%
if 1.02000000000000002e-22 < phi1 Initial program 78.1%
add-log-exp78.1%
Applied egg-rr78.1%
Final simplification88.9%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (cos phi1) (sin phi2)))
(t_1 (cos (- lambda1 lambda2)))
(t_2 (* (cos phi2) (sin (- lambda1 lambda2)))))
(if (<= phi1 -0.007)
(atan2 t_2 (- t_0 (* (* (cos phi2) (sin phi1)) t_1)))
(if (<= phi1 5e-23)
(atan2
(*
(cos phi2)
(- (* (sin lambda1) (cos lambda2)) (* (cos lambda1) (sin lambda2))))
(- t_0 (* phi1 (cos (- lambda2 lambda1)))))
(atan2 t_2 (fma (cos phi2) (* (sin phi1) (- t_1)) t_0))))))
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 = cos(phi2) * sin((lambda1 - lambda2));
double tmp;
if (phi1 <= -0.007) {
tmp = atan2(t_2, (t_0 - ((cos(phi2) * sin(phi1)) * t_1)));
} else if (phi1 <= 5e-23) {
tmp = atan2((cos(phi2) * ((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2)))), (t_0 - (phi1 * cos((lambda2 - lambda1)))));
} else {
tmp = atan2(t_2, fma(cos(phi2), (sin(phi1) * -t_1), t_0));
}
return tmp;
}
function code(lambda1, lambda2, phi1, phi2) t_0 = Float64(cos(phi1) * sin(phi2)) t_1 = cos(Float64(lambda1 - lambda2)) t_2 = Float64(cos(phi2) * sin(Float64(lambda1 - lambda2))) tmp = 0.0 if (phi1 <= -0.007) tmp = atan(t_2, Float64(t_0 - Float64(Float64(cos(phi2) * sin(phi1)) * t_1))); elseif (phi1 <= 5e-23) tmp = atan(Float64(cos(phi2) * Float64(Float64(sin(lambda1) * cos(lambda2)) - Float64(cos(lambda1) * sin(lambda2)))), Float64(t_0 - Float64(phi1 * cos(Float64(lambda2 - lambda1))))); else tmp = atan(t_2, fma(cos(phi2), Float64(sin(phi1) * Float64(-t_1)), t_0)); 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[(N[Cos[phi2], $MachinePrecision] * N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[phi1, -0.007], N[ArcTan[t$95$2 / N[(t$95$0 - N[(N[(N[Cos[phi2], $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[phi1, 5e-23], 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[(phi1 * N[Cos[N[(lambda2 - lambda1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[t$95$2 / N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[phi1], $MachinePrecision] * (-t$95$1)), $MachinePrecision] + t$95$0), $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 := \cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)\\
\mathbf{if}\;\phi_1 \leq -0.007:\\
\;\;\;\;\tan^{-1}_* \frac{t_2}{t_0 - \left(\cos \phi_2 \cdot \sin \phi_1\right) \cdot t_1}\\
\mathbf{elif}\;\phi_1 \leq 5 \cdot 10^{-23}:\\
\;\;\;\;\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 - \phi_1 \cdot \cos \left(\lambda_2 - \lambda_1\right)}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{t_2}{\mathsf{fma}\left(\cos \phi_2, \sin \phi_1 \cdot \left(-t_1\right), t_0\right)}\\
\end{array}
\end{array}
if phi1 < -0.00700000000000000015Initial program 77.6%
if -0.00700000000000000015 < phi1 < 5.0000000000000002e-23Initial program 85.7%
associate-*l*85.7%
Simplified85.7%
Taylor expanded in phi2 around 0 85.7%
sub-neg85.7%
remove-double-neg85.7%
mul-1-neg85.7%
distribute-neg-in85.7%
+-commutative85.7%
cos-neg85.7%
mul-1-neg85.7%
unsub-neg85.7%
Simplified85.7%
Taylor expanded in phi1 around 0 85.7%
sin-diff99.4%
Applied egg-rr99.4%
if 5.0000000000000002e-23 < phi1 Initial program 78.1%
sub-neg78.1%
+-commutative78.1%
distribute-rgt-neg-in78.1%
*-commutative78.1%
associate-*l*78.1%
fma-def78.1%
distribute-rgt-neg-in78.1%
*-commutative78.1%
distribute-rgt-neg-out78.1%
Simplified78.1%
Final simplification88.9%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (cos phi1) (sin phi2)))
(t_1 (cos (- lambda1 lambda2)))
(t_2 (* (cos phi2) (sin (- lambda1 lambda2)))))
(if (<= phi2 -750.0)
(atan2 t_2 (- t_0 (* (sin phi1) (* (cos phi2) t_1))))
(if (<= phi2 1950000000.0)
(atan2
(- (* (sin lambda1) (cos lambda2)) (* (cos lambda1) (sin lambda2)))
(- t_0 (* (sin phi1) t_1)))
(atan2 t_2 (fma (cos phi2) (* (sin phi1) (- t_1)) t_0))))))
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 = cos(phi2) * sin((lambda1 - lambda2));
double tmp;
if (phi2 <= -750.0) {
tmp = atan2(t_2, (t_0 - (sin(phi1) * (cos(phi2) * t_1))));
} else if (phi2 <= 1950000000.0) {
tmp = atan2(((sin(lambda1) * cos(lambda2)) - (cos(lambda1) * sin(lambda2))), (t_0 - (sin(phi1) * t_1)));
} else {
tmp = atan2(t_2, fma(cos(phi2), (sin(phi1) * -t_1), t_0));
}
return tmp;
}
function code(lambda1, lambda2, phi1, phi2) t_0 = Float64(cos(phi1) * sin(phi2)) t_1 = cos(Float64(lambda1 - lambda2)) t_2 = Float64(cos(phi2) * sin(Float64(lambda1 - lambda2))) tmp = 0.0 if (phi2 <= -750.0) tmp = atan(t_2, Float64(t_0 - Float64(sin(phi1) * Float64(cos(phi2) * t_1)))); elseif (phi2 <= 1950000000.0) tmp = atan(Float64(Float64(sin(lambda1) * cos(lambda2)) - Float64(cos(lambda1) * sin(lambda2))), Float64(t_0 - Float64(sin(phi1) * t_1))); else tmp = atan(t_2, fma(cos(phi2), Float64(sin(phi1) * Float64(-t_1)), t_0)); 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[(N[Cos[phi2], $MachinePrecision] * N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[phi2, -750.0], N[ArcTan[t$95$2 / N[(t$95$0 - N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[phi2, 1950000000.0], N[ArcTan[N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision] - N[(N[Cos[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(t$95$0 - N[(N[Sin[phi1], $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[t$95$2 / N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[phi1], $MachinePrecision] * (-t$95$1)), $MachinePrecision] + t$95$0), $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 := \cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)\\
\mathbf{if}\;\phi_2 \leq -750:\\
\;\;\;\;\tan^{-1}_* \frac{t_2}{t_0 - \sin \phi_1 \cdot \left(\cos \phi_2 \cdot t_1\right)}\\
\mathbf{elif}\;\phi_2 \leq 1950000000:\\
\;\;\;\;\tan^{-1}_* \frac{\sin \lambda_1 \cdot \cos \lambda_2 - \cos \lambda_1 \cdot \sin \lambda_2}{t_0 - \sin \phi_1 \cdot t_1}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{t_2}{\mathsf{fma}\left(\cos \phi_2, \sin \phi_1 \cdot \left(-t_1\right), t_0\right)}\\
\end{array}
\end{array}
if phi2 < -750Initial program 85.0%
associate-*l*85.0%
Simplified85.0%
if -750 < phi2 < 1.95e9Initial program 81.0%
sin-diff90.5%
cancel-sign-sub-inv90.5%
fma-def90.5%
Applied egg-rr90.5%
Taylor expanded in phi2 around 0 90.5%
*-commutative90.5%
Simplified90.5%
Taylor expanded in phi2 around 0 90.6%
neg-mul-190.6%
distribute-lft-neg-in90.6%
+-commutative90.6%
*-commutative90.6%
cancel-sign-sub-inv90.6%
Simplified90.6%
if 1.95e9 < phi2 Initial program 81.1%
sub-neg81.1%
+-commutative81.1%
distribute-rgt-neg-in81.1%
*-commutative81.1%
associate-*l*81.1%
fma-def81.1%
distribute-rgt-neg-in81.1%
*-commutative81.1%
distribute-rgt-neg-out81.1%
Simplified81.1%
Final simplification86.9%
(FPCore (lambda1 lambda2 phi1 phi2) :precision binary64 (atan2 (* (cos phi2) (sin (- lambda1 lambda2))) (fma (cos phi2) (* (sin phi1) (- (cos (- lambda1 lambda2)))) (* (cos phi1) (sin phi2)))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
return atan2((cos(phi2) * sin((lambda1 - lambda2))), fma(cos(phi2), (sin(phi1) * -cos((lambda1 - lambda2))), (cos(phi1) * sin(phi2))));
}
function code(lambda1, lambda2, phi1, phi2) return atan(Float64(cos(phi2) * sin(Float64(lambda1 - lambda2))), fma(cos(phi2), Float64(sin(phi1) * Float64(-cos(Float64(lambda1 - lambda2)))), Float64(cos(phi1) * sin(phi2)))) end
code[lambda1_, lambda2_, phi1_, phi2_] := N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[phi1], $MachinePrecision] * (-N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision])), $MachinePrecision] + N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\mathsf{fma}\left(\cos \phi_2, \sin \phi_1 \cdot \left(-\cos \left(\lambda_1 - \lambda_2\right)\right), \cos \phi_1 \cdot \sin \phi_2\right)}
\end{array}
Initial program 81.9%
sub-neg81.9%
+-commutative81.9%
distribute-rgt-neg-in81.9%
*-commutative81.9%
associate-*l*81.9%
fma-def81.9%
distribute-rgt-neg-in81.9%
*-commutative81.9%
distribute-rgt-neg-out81.9%
Simplified81.9%
Final simplification81.9%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (cos phi1) (sin phi2))))
(if (or (<= lambda1 -1e+51) (not (<= lambda1 0.0052)))
(atan2
(* (cos phi2) (sin lambda1))
(- t_0 (* (sin phi1) (* (cos phi2) (cos (- lambda1 lambda2))))))
(atan2
(* (cos phi2) (sin (- lambda1 lambda2)))
(- t_0 (* (sin phi1) (cos (- lambda2 lambda1))))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos(phi1) * sin(phi2);
double tmp;
if ((lambda1 <= -1e+51) || !(lambda1 <= 0.0052)) {
tmp = atan2((cos(phi2) * sin(lambda1)), (t_0 - (sin(phi1) * (cos(phi2) * cos((lambda1 - lambda2))))));
} else {
tmp = atan2((cos(phi2) * sin((lambda1 - lambda2))), (t_0 - (sin(phi1) * cos((lambda2 - lambda1)))));
}
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 <= (-1d+51)) .or. (.not. (lambda1 <= 0.0052d0))) then
tmp = atan2((cos(phi2) * sin(lambda1)), (t_0 - (sin(phi1) * (cos(phi2) * cos((lambda1 - lambda2))))))
else
tmp = atan2((cos(phi2) * sin((lambda1 - lambda2))), (t_0 - (sin(phi1) * cos((lambda2 - lambda1)))))
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 <= -1e+51) || !(lambda1 <= 0.0052)) {
tmp = Math.atan2((Math.cos(phi2) * Math.sin(lambda1)), (t_0 - (Math.sin(phi1) * (Math.cos(phi2) * Math.cos((lambda1 - lambda2))))));
} else {
tmp = Math.atan2((Math.cos(phi2) * Math.sin((lambda1 - lambda2))), (t_0 - (Math.sin(phi1) * Math.cos((lambda2 - lambda1)))));
}
return tmp;
}
def code(lambda1, lambda2, phi1, phi2): t_0 = math.cos(phi1) * math.sin(phi2) tmp = 0 if (lambda1 <= -1e+51) or not (lambda1 <= 0.0052): tmp = math.atan2((math.cos(phi2) * math.sin(lambda1)), (t_0 - (math.sin(phi1) * (math.cos(phi2) * math.cos((lambda1 - lambda2)))))) else: tmp = math.atan2((math.cos(phi2) * math.sin((lambda1 - lambda2))), (t_0 - (math.sin(phi1) * math.cos((lambda2 - lambda1))))) return tmp
function code(lambda1, lambda2, phi1, phi2) t_0 = Float64(cos(phi1) * sin(phi2)) tmp = 0.0 if ((lambda1 <= -1e+51) || !(lambda1 <= 0.0052)) tmp = atan(Float64(cos(phi2) * sin(lambda1)), Float64(t_0 - Float64(sin(phi1) * Float64(cos(phi2) * cos(Float64(lambda1 - lambda2)))))); else tmp = atan(Float64(cos(phi2) * sin(Float64(lambda1 - lambda2))), Float64(t_0 - Float64(sin(phi1) * cos(Float64(lambda2 - lambda1))))); end return tmp end
function tmp_2 = code(lambda1, lambda2, phi1, phi2) t_0 = cos(phi1) * sin(phi2); tmp = 0.0; if ((lambda1 <= -1e+51) || ~((lambda1 <= 0.0052))) tmp = atan2((cos(phi2) * sin(lambda1)), (t_0 - (sin(phi1) * (cos(phi2) * cos((lambda1 - lambda2)))))); else tmp = atan2((cos(phi2) * sin((lambda1 - lambda2))), (t_0 - (sin(phi1) * cos((lambda2 - lambda1))))); 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, -1e+51], N[Not[LessEqual[lambda1, 0.0052]], $MachinePrecision]], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[Sin[lambda1], $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[Cos[phi2], $MachinePrecision] * N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(t$95$0 - N[(N[Sin[phi1], $MachinePrecision] * N[Cos[N[(lambda2 - lambda1), $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 -1 \cdot 10^{+51} \lor \neg \left(\lambda_1 \leq 0.0052\right):\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \lambda_1}{t_0 - \sin \phi_1 \cdot \left(\cos \phi_2 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{t_0 - \sin \phi_1 \cdot \cos \left(\lambda_2 - \lambda_1\right)}\\
\end{array}
\end{array}
if lambda1 < -1e51 or 0.0051999999999999998 < lambda1 Initial program 64.0%
associate-*l*64.0%
Simplified64.0%
Taylor expanded in lambda2 around 0 62.6%
if -1e51 < lambda1 < 0.0051999999999999998Initial program 98.0%
associate-*l*98.0%
Simplified98.0%
Taylor expanded in phi2 around 0 86.8%
sub-neg86.8%
remove-double-neg86.8%
mul-1-neg86.8%
distribute-neg-in86.8%
+-commutative86.8%
cos-neg86.8%
mul-1-neg86.8%
unsub-neg86.8%
Simplified86.8%
Final simplification75.4%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (cos phi1) (sin phi2)))
(t_1 (- t_0 (* (sin phi1) (cos (- lambda2 lambda1))))))
(if (<= lambda2 -0.122)
(atan2 (* (cos phi2) (sin (- lambda2))) t_1)
(if (<= lambda2 5.6e+23)
(atan2
(* (cos phi2) (sin (- lambda1 lambda2)))
(- t_0 (* (sin phi1) (* (cos phi2) (cos lambda1)))))
(atan2 (* (cos phi2) (- lambda1 (sin lambda2))) t_1)))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos(phi1) * sin(phi2);
double t_1 = t_0 - (sin(phi1) * cos((lambda2 - lambda1)));
double tmp;
if (lambda2 <= -0.122) {
tmp = atan2((cos(phi2) * sin(-lambda2)), t_1);
} else if (lambda2 <= 5.6e+23) {
tmp = atan2((cos(phi2) * sin((lambda1 - lambda2))), (t_0 - (sin(phi1) * (cos(phi2) * cos(lambda1)))));
} else {
tmp = atan2((cos(phi2) * (lambda1 - sin(lambda2))), t_1);
}
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(phi1) * sin(phi2)
t_1 = t_0 - (sin(phi1) * cos((lambda2 - lambda1)))
if (lambda2 <= (-0.122d0)) then
tmp = atan2((cos(phi2) * sin(-lambda2)), t_1)
else if (lambda2 <= 5.6d+23) then
tmp = atan2((cos(phi2) * sin((lambda1 - lambda2))), (t_0 - (sin(phi1) * (cos(phi2) * cos(lambda1)))))
else
tmp = atan2((cos(phi2) * (lambda1 - sin(lambda2))), t_1)
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 t_1 = t_0 - (Math.sin(phi1) * Math.cos((lambda2 - lambda1)));
double tmp;
if (lambda2 <= -0.122) {
tmp = Math.atan2((Math.cos(phi2) * Math.sin(-lambda2)), t_1);
} else if (lambda2 <= 5.6e+23) {
tmp = Math.atan2((Math.cos(phi2) * Math.sin((lambda1 - lambda2))), (t_0 - (Math.sin(phi1) * (Math.cos(phi2) * Math.cos(lambda1)))));
} else {
tmp = Math.atan2((Math.cos(phi2) * (lambda1 - Math.sin(lambda2))), t_1);
}
return tmp;
}
def code(lambda1, lambda2, phi1, phi2): t_0 = math.cos(phi1) * math.sin(phi2) t_1 = t_0 - (math.sin(phi1) * math.cos((lambda2 - lambda1))) tmp = 0 if lambda2 <= -0.122: tmp = math.atan2((math.cos(phi2) * math.sin(-lambda2)), t_1) elif lambda2 <= 5.6e+23: tmp = math.atan2((math.cos(phi2) * math.sin((lambda1 - lambda2))), (t_0 - (math.sin(phi1) * (math.cos(phi2) * math.cos(lambda1))))) else: tmp = math.atan2((math.cos(phi2) * (lambda1 - math.sin(lambda2))), t_1) return tmp
function code(lambda1, lambda2, phi1, phi2) t_0 = Float64(cos(phi1) * sin(phi2)) t_1 = Float64(t_0 - Float64(sin(phi1) * cos(Float64(lambda2 - lambda1)))) tmp = 0.0 if (lambda2 <= -0.122) tmp = atan(Float64(cos(phi2) * sin(Float64(-lambda2))), t_1); elseif (lambda2 <= 5.6e+23) tmp = atan(Float64(cos(phi2) * sin(Float64(lambda1 - lambda2))), Float64(t_0 - Float64(sin(phi1) * Float64(cos(phi2) * cos(lambda1))))); else tmp = atan(Float64(cos(phi2) * Float64(lambda1 - sin(lambda2))), t_1); end return tmp end
function tmp_2 = code(lambda1, lambda2, phi1, phi2) t_0 = cos(phi1) * sin(phi2); t_1 = t_0 - (sin(phi1) * cos((lambda2 - lambda1))); tmp = 0.0; if (lambda2 <= -0.122) tmp = atan2((cos(phi2) * sin(-lambda2)), t_1); elseif (lambda2 <= 5.6e+23) tmp = atan2((cos(phi2) * sin((lambda1 - lambda2))), (t_0 - (sin(phi1) * (cos(phi2) * cos(lambda1))))); else tmp = atan2((cos(phi2) * (lambda1 - sin(lambda2))), t_1); end tmp_2 = 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[(t$95$0 - N[(N[Sin[phi1], $MachinePrecision] * N[Cos[N[(lambda2 - lambda1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[lambda2, -0.122], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[Sin[(-lambda2)], $MachinePrecision]), $MachinePrecision] / t$95$1], $MachinePrecision], If[LessEqual[lambda2, 5.6e+23], 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[Cos[lambda1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[(lambda1 - N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$1], $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \cos \phi_1 \cdot \sin \phi_2\\
t_1 := t_0 - \sin \phi_1 \cdot \cos \left(\lambda_2 - \lambda_1\right)\\
\mathbf{if}\;\lambda_2 \leq -0.122:\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(-\lambda_2\right)}{t_1}\\
\mathbf{elif}\;\lambda_2 \leq 5.6 \cdot 10^{+23}:\\
\;\;\;\;\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 \cos \lambda_1\right)}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \left(\lambda_1 - \sin \lambda_2\right)}{t_1}\\
\end{array}
\end{array}
if lambda2 < -0.122Initial program 65.7%
associate-*l*65.7%
Simplified65.7%
Taylor expanded in phi2 around 0 58.1%
sub-neg58.1%
remove-double-neg58.1%
mul-1-neg58.1%
distribute-neg-in58.1%
+-commutative58.1%
cos-neg58.1%
mul-1-neg58.1%
unsub-neg58.1%
Simplified58.1%
Taylor expanded in lambda1 around 0 63.0%
if -0.122 < lambda2 < 5.6e23Initial program 97.1%
associate-*l*97.0%
Simplified97.0%
Taylor expanded in lambda2 around 0 96.7%
if 5.6e23 < lambda2 Initial program 57.0%
associate-*l*57.0%
Simplified57.0%
Taylor expanded in phi2 around 0 48.5%
sub-neg48.5%
remove-double-neg48.5%
mul-1-neg48.5%
distribute-neg-in48.5%
+-commutative48.5%
cos-neg48.5%
mul-1-neg48.5%
unsub-neg48.5%
Simplified48.5%
Taylor expanded in lambda1 around 0 53.5%
+-commutative53.5%
sin-neg53.5%
unsub-neg53.5%
cos-neg53.5%
Simplified53.5%
Taylor expanded in lambda2 around 0 55.6%
Final simplification80.8%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (cos phi2) (sin (- lambda1 lambda2))))
(t_1 (* (cos phi1) (sin phi2))))
(if (<= lambda1 -0.0028)
(atan2
(* (cos phi2) (sin lambda1))
(- t_1 (* (sin phi1) (* (cos phi2) (cos (- lambda1 lambda2))))))
(if (<= lambda1 5.8e-68)
(atan2 t_0 (- t_1 (* (cos lambda2) (* (cos phi2) (sin phi1)))))
(atan2 t_0 (- t_1 (* (sin phi1) (* (cos phi2) (cos lambda1)))))))))
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.0028) {
tmp = atan2((cos(phi2) * sin(lambda1)), (t_1 - (sin(phi1) * (cos(phi2) * cos((lambda1 - lambda2))))));
} else if (lambda1 <= 5.8e-68) {
tmp = atan2(t_0, (t_1 - (cos(lambda2) * (cos(phi2) * sin(phi1)))));
} else {
tmp = atan2(t_0, (t_1 - (sin(phi1) * (cos(phi2) * cos(lambda1)))));
}
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.0028d0)) then
tmp = atan2((cos(phi2) * sin(lambda1)), (t_1 - (sin(phi1) * (cos(phi2) * cos((lambda1 - lambda2))))))
else if (lambda1 <= 5.8d-68) then
tmp = atan2(t_0, (t_1 - (cos(lambda2) * (cos(phi2) * sin(phi1)))))
else
tmp = atan2(t_0, (t_1 - (sin(phi1) * (cos(phi2) * cos(lambda1)))))
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.0028) {
tmp = Math.atan2((Math.cos(phi2) * Math.sin(lambda1)), (t_1 - (Math.sin(phi1) * (Math.cos(phi2) * Math.cos((lambda1 - lambda2))))));
} else if (lambda1 <= 5.8e-68) {
tmp = Math.atan2(t_0, (t_1 - (Math.cos(lambda2) * (Math.cos(phi2) * Math.sin(phi1)))));
} else {
tmp = Math.atan2(t_0, (t_1 - (Math.sin(phi1) * (Math.cos(phi2) * Math.cos(lambda1)))));
}
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.0028: tmp = math.atan2((math.cos(phi2) * math.sin(lambda1)), (t_1 - (math.sin(phi1) * (math.cos(phi2) * math.cos((lambda1 - lambda2)))))) elif lambda1 <= 5.8e-68: tmp = math.atan2(t_0, (t_1 - (math.cos(lambda2) * (math.cos(phi2) * math.sin(phi1))))) else: tmp = math.atan2(t_0, (t_1 - (math.sin(phi1) * (math.cos(phi2) * math.cos(lambda1))))) 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.0028) tmp = atan(Float64(cos(phi2) * sin(lambda1)), Float64(t_1 - Float64(sin(phi1) * Float64(cos(phi2) * cos(Float64(lambda1 - lambda2)))))); elseif (lambda1 <= 5.8e-68) tmp = atan(t_0, Float64(t_1 - Float64(cos(lambda2) * Float64(cos(phi2) * sin(phi1))))); else tmp = atan(t_0, Float64(t_1 - Float64(sin(phi1) * Float64(cos(phi2) * cos(lambda1))))); 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.0028) tmp = atan2((cos(phi2) * sin(lambda1)), (t_1 - (sin(phi1) * (cos(phi2) * cos((lambda1 - lambda2)))))); elseif (lambda1 <= 5.8e-68) tmp = atan2(t_0, (t_1 - (cos(lambda2) * (cos(phi2) * sin(phi1))))); else tmp = atan2(t_0, (t_1 - (sin(phi1) * (cos(phi2) * cos(lambda1))))); 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.0028], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[Sin[lambda1], $MachinePrecision]), $MachinePrecision] / N[(t$95$1 - N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[lambda1, 5.8e-68], N[ArcTan[t$95$0 / N[(t$95$1 - N[(N[Cos[lambda2], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[t$95$0 / N[(t$95$1 - N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * N[Cos[lambda1], $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.0028:\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \lambda_1}{t_1 - \sin \phi_1 \cdot \left(\cos \phi_2 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)}\\
\mathbf{elif}\;\lambda_1 \leq 5.8 \cdot 10^{-68}:\\
\;\;\;\;\tan^{-1}_* \frac{t_0}{t_1 - \cos \lambda_2 \cdot \left(\cos \phi_2 \cdot \sin \phi_1\right)}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{t_0}{t_1 - \sin \phi_1 \cdot \left(\cos \phi_2 \cdot \cos \lambda_1\right)}\\
\end{array}
\end{array}
if lambda1 < -0.00279999999999999997Initial program 63.7%
associate-*l*63.7%
Simplified63.7%
Taylor expanded in lambda2 around 0 64.6%
if -0.00279999999999999997 < lambda1 < 5.8000000000000001e-68Initial program 99.9%
Taylor expanded in lambda1 around 0 99.9%
cos-neg99.9%
Simplified99.9%
if 5.8000000000000001e-68 < lambda1 Initial program 71.6%
associate-*l*71.6%
Simplified71.6%
Taylor expanded in lambda2 around 0 71.3%
Final simplification82.1%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (cos phi2) (sin phi1)))
(t_1 (* (cos phi2) (sin (- lambda1 lambda2))))
(t_2 (* (cos phi1) (sin phi2))))
(if (<= lambda2 -0.0074)
(atan2
(* (cos phi2) (sin (- lambda2)))
(- t_2 (* t_0 (cos (- lambda1 lambda2)))))
(if (<= lambda2 240000000.0)
(atan2 t_1 (- t_2 (* (sin phi1) (* (cos phi2) (cos lambda1)))))
(atan2 t_1 (- t_2 (* (cos lambda2) t_0)))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos(phi2) * sin(phi1);
double t_1 = cos(phi2) * sin((lambda1 - lambda2));
double t_2 = cos(phi1) * sin(phi2);
double tmp;
if (lambda2 <= -0.0074) {
tmp = atan2((cos(phi2) * sin(-lambda2)), (t_2 - (t_0 * cos((lambda1 - lambda2)))));
} else if (lambda2 <= 240000000.0) {
tmp = atan2(t_1, (t_2 - (sin(phi1) * (cos(phi2) * cos(lambda1)))));
} else {
tmp = atan2(t_1, (t_2 - (cos(lambda2) * 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) :: t_2
real(8) :: tmp
t_0 = cos(phi2) * sin(phi1)
t_1 = cos(phi2) * sin((lambda1 - lambda2))
t_2 = cos(phi1) * sin(phi2)
if (lambda2 <= (-0.0074d0)) then
tmp = atan2((cos(phi2) * sin(-lambda2)), (t_2 - (t_0 * cos((lambda1 - lambda2)))))
else if (lambda2 <= 240000000.0d0) then
tmp = atan2(t_1, (t_2 - (sin(phi1) * (cos(phi2) * cos(lambda1)))))
else
tmp = atan2(t_1, (t_2 - (cos(lambda2) * 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(phi2) * Math.sin(phi1);
double t_1 = Math.cos(phi2) * Math.sin((lambda1 - lambda2));
double t_2 = Math.cos(phi1) * Math.sin(phi2);
double tmp;
if (lambda2 <= -0.0074) {
tmp = Math.atan2((Math.cos(phi2) * Math.sin(-lambda2)), (t_2 - (t_0 * Math.cos((lambda1 - lambda2)))));
} else if (lambda2 <= 240000000.0) {
tmp = Math.atan2(t_1, (t_2 - (Math.sin(phi1) * (Math.cos(phi2) * Math.cos(lambda1)))));
} else {
tmp = Math.atan2(t_1, (t_2 - (Math.cos(lambda2) * t_0)));
}
return tmp;
}
def code(lambda1, lambda2, phi1, phi2): t_0 = math.cos(phi2) * math.sin(phi1) t_1 = math.cos(phi2) * math.sin((lambda1 - lambda2)) t_2 = math.cos(phi1) * math.sin(phi2) tmp = 0 if lambda2 <= -0.0074: tmp = math.atan2((math.cos(phi2) * math.sin(-lambda2)), (t_2 - (t_0 * math.cos((lambda1 - lambda2))))) elif lambda2 <= 240000000.0: tmp = math.atan2(t_1, (t_2 - (math.sin(phi1) * (math.cos(phi2) * math.cos(lambda1))))) else: tmp = math.atan2(t_1, (t_2 - (math.cos(lambda2) * t_0))) return tmp
function code(lambda1, lambda2, phi1, phi2) t_0 = Float64(cos(phi2) * sin(phi1)) t_1 = Float64(cos(phi2) * sin(Float64(lambda1 - lambda2))) t_2 = Float64(cos(phi1) * sin(phi2)) tmp = 0.0 if (lambda2 <= -0.0074) tmp = atan(Float64(cos(phi2) * sin(Float64(-lambda2))), Float64(t_2 - Float64(t_0 * cos(Float64(lambda1 - lambda2))))); elseif (lambda2 <= 240000000.0) tmp = atan(t_1, Float64(t_2 - Float64(sin(phi1) * Float64(cos(phi2) * cos(lambda1))))); else tmp = atan(t_1, Float64(t_2 - Float64(cos(lambda2) * t_0))); end return tmp end
function tmp_2 = code(lambda1, lambda2, phi1, phi2) t_0 = cos(phi2) * sin(phi1); t_1 = cos(phi2) * sin((lambda1 - lambda2)); t_2 = cos(phi1) * sin(phi2); tmp = 0.0; if (lambda2 <= -0.0074) tmp = atan2((cos(phi2) * sin(-lambda2)), (t_2 - (t_0 * cos((lambda1 - lambda2))))); elseif (lambda2 <= 240000000.0) tmp = atan2(t_1, (t_2 - (sin(phi1) * (cos(phi2) * cos(lambda1))))); else tmp = atan2(t_1, (t_2 - (cos(lambda2) * t_0))); end tmp_2 = tmp; end
code[lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[Cos[phi2], $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[Cos[phi2], $MachinePrecision] * N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[lambda2, -0.0074], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[Sin[(-lambda2)], $MachinePrecision]), $MachinePrecision] / N[(t$95$2 - N[(t$95$0 * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[lambda2, 240000000.0], N[ArcTan[t$95$1 / N[(t$95$2 - N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * N[Cos[lambda1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[t$95$1 / N[(t$95$2 - N[(N[Cos[lambda2], $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \cos \phi_2 \cdot \sin \phi_1\\
t_1 := \cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)\\
t_2 := \cos \phi_1 \cdot \sin \phi_2\\
\mathbf{if}\;\lambda_2 \leq -0.0074:\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(-\lambda_2\right)}{t_2 - t_0 \cdot \cos \left(\lambda_1 - \lambda_2\right)}\\
\mathbf{elif}\;\lambda_2 \leq 240000000:\\
\;\;\;\;\tan^{-1}_* \frac{t_1}{t_2 - \sin \phi_1 \cdot \left(\cos \phi_2 \cdot \cos \lambda_1\right)}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{t_1}{t_2 - \cos \lambda_2 \cdot t_0}\\
\end{array}
\end{array}
if lambda2 < -0.0074000000000000003Initial program 65.7%
Taylor expanded in lambda1 around 0 70.6%
if -0.0074000000000000003 < lambda2 < 2.4e8Initial program 97.6%
associate-*l*97.5%
Simplified97.5%
Taylor expanded in lambda2 around 0 97.3%
if 2.4e8 < lambda2 Initial program 57.9%
Taylor expanded in lambda1 around 0 58.2%
cos-neg58.2%
Simplified58.2%
Final simplification82.9%
(FPCore (lambda1 lambda2 phi1 phi2) :precision binary64 (atan2 (* (cos phi2) (sin (- lambda1 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 - 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 - 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 - 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 - 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) * sin(Float64(lambda1 - 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 - 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[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]
\begin{array}{l}
\\
\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)}
\end{array}
Initial program 81.9%
associate-*l*81.9%
Simplified81.9%
Final simplification81.9%
(FPCore (lambda1 lambda2 phi1 phi2) :precision binary64 (atan2 (* (cos phi2) (sin (- lambda1 lambda2))) (- (* (cos phi1) (sin phi2)) (* (* (cos phi2) (sin phi1)) (cos (- lambda1 lambda2))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
return atan2((cos(phi2) * sin((lambda1 - lambda2))), ((cos(phi1) * sin(phi2)) - ((cos(phi2) * sin(phi1)) * 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 - lambda2))), ((cos(phi1) * sin(phi2)) - ((cos(phi2) * sin(phi1)) * 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 - lambda2))), ((Math.cos(phi1) * Math.sin(phi2)) - ((Math.cos(phi2) * Math.sin(phi1)) * Math.cos((lambda1 - lambda2)))));
}
def code(lambda1, lambda2, phi1, phi2): return math.atan2((math.cos(phi2) * math.sin((lambda1 - lambda2))), ((math.cos(phi1) * math.sin(phi2)) - ((math.cos(phi2) * math.sin(phi1)) * math.cos((lambda1 - lambda2)))))
function code(lambda1, lambda2, phi1, phi2) return atan(Float64(cos(phi2) * sin(Float64(lambda1 - lambda2))), Float64(Float64(cos(phi1) * sin(phi2)) - Float64(Float64(cos(phi2) * sin(phi1)) * cos(Float64(lambda1 - lambda2))))) end
function tmp = code(lambda1, lambda2, phi1, phi2) tmp = atan2((cos(phi2) * sin((lambda1 - lambda2))), ((cos(phi1) * sin(phi2)) - ((cos(phi2) * sin(phi1)) * cos((lambda1 - lambda2))))); end
code[lambda1_, lambda2_, phi1_, phi2_] := 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[(N[Cos[phi2], $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\cos \phi_1 \cdot \sin \phi_2 - \left(\cos \phi_2 \cdot \sin \phi_1\right) \cdot \cos \left(\lambda_1 - \lambda_2\right)}
\end{array}
Initial program 81.9%
Final simplification81.9%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (cos phi1) (sin phi2))))
(if (or (<= lambda2 -420000.0) (not (<= lambda2 1.45e+81)))
(atan2
(* (cos phi2) (sin (- lambda2)))
(- t_0 (* (sin phi1) (cos (- lambda2 lambda1)))))
(atan2
(* (cos phi2) (sin (- lambda1 lambda2)))
(- t_0 (* (cos lambda1) (sin phi1)))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos(phi1) * sin(phi2);
double tmp;
if ((lambda2 <= -420000.0) || !(lambda2 <= 1.45e+81)) {
tmp = atan2((cos(phi2) * sin(-lambda2)), (t_0 - (sin(phi1) * cos((lambda2 - lambda1)))));
} else {
tmp = atan2((cos(phi2) * sin((lambda1 - lambda2))), (t_0 - (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) :: tmp
t_0 = cos(phi1) * sin(phi2)
if ((lambda2 <= (-420000.0d0)) .or. (.not. (lambda2 <= 1.45d+81))) then
tmp = atan2((cos(phi2) * sin(-lambda2)), (t_0 - (sin(phi1) * cos((lambda2 - lambda1)))))
else
tmp = atan2((cos(phi2) * sin((lambda1 - lambda2))), (t_0 - (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(phi1) * Math.sin(phi2);
double tmp;
if ((lambda2 <= -420000.0) || !(lambda2 <= 1.45e+81)) {
tmp = Math.atan2((Math.cos(phi2) * Math.sin(-lambda2)), (t_0 - (Math.sin(phi1) * Math.cos((lambda2 - lambda1)))));
} else {
tmp = Math.atan2((Math.cos(phi2) * Math.sin((lambda1 - lambda2))), (t_0 - (Math.cos(lambda1) * Math.sin(phi1))));
}
return tmp;
}
def code(lambda1, lambda2, phi1, phi2): t_0 = math.cos(phi1) * math.sin(phi2) tmp = 0 if (lambda2 <= -420000.0) or not (lambda2 <= 1.45e+81): tmp = math.atan2((math.cos(phi2) * math.sin(-lambda2)), (t_0 - (math.sin(phi1) * math.cos((lambda2 - lambda1))))) else: tmp = math.atan2((math.cos(phi2) * math.sin((lambda1 - lambda2))), (t_0 - (math.cos(lambda1) * math.sin(phi1)))) return tmp
function code(lambda1, lambda2, phi1, phi2) t_0 = Float64(cos(phi1) * sin(phi2)) tmp = 0.0 if ((lambda2 <= -420000.0) || !(lambda2 <= 1.45e+81)) tmp = atan(Float64(cos(phi2) * sin(Float64(-lambda2))), Float64(t_0 - Float64(sin(phi1) * cos(Float64(lambda2 - lambda1))))); else tmp = atan(Float64(cos(phi2) * sin(Float64(lambda1 - lambda2))), Float64(t_0 - Float64(cos(lambda1) * sin(phi1)))); end return tmp end
function tmp_2 = code(lambda1, lambda2, phi1, phi2) t_0 = cos(phi1) * sin(phi2); tmp = 0.0; if ((lambda2 <= -420000.0) || ~((lambda2 <= 1.45e+81))) tmp = atan2((cos(phi2) * sin(-lambda2)), (t_0 - (sin(phi1) * cos((lambda2 - lambda1))))); else tmp = atan2((cos(phi2) * sin((lambda1 - lambda2))), (t_0 - (cos(lambda1) * sin(phi1)))); 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[lambda2, -420000.0], N[Not[LessEqual[lambda2, 1.45e+81]], $MachinePrecision]], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[Sin[(-lambda2)], $MachinePrecision]), $MachinePrecision] / N[(t$95$0 - N[(N[Sin[phi1], $MachinePrecision] * N[Cos[N[(lambda2 - lambda1), $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[Cos[lambda1], $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \cos \phi_1 \cdot \sin \phi_2\\
\mathbf{if}\;\lambda_2 \leq -420000 \lor \neg \left(\lambda_2 \leq 1.45 \cdot 10^{+81}\right):\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(-\lambda_2\right)}{t_0 - \sin \phi_1 \cdot \cos \left(\lambda_2 - \lambda_1\right)}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{t_0 - \cos \lambda_1 \cdot \sin \phi_1}\\
\end{array}
\end{array}
if lambda2 < -4.2e5 or 1.45e81 < lambda2 Initial program 61.6%
associate-*l*61.6%
Simplified61.6%
Taylor expanded in phi2 around 0 54.7%
sub-neg54.7%
remove-double-neg54.7%
mul-1-neg54.7%
distribute-neg-in54.7%
+-commutative54.7%
cos-neg54.7%
mul-1-neg54.7%
unsub-neg54.7%
Simplified54.7%
Taylor expanded in lambda1 around 0 58.5%
if -4.2e5 < lambda2 < 1.45e81Initial program 94.3%
associate-*l*94.3%
Simplified94.3%
Taylor expanded in phi2 around 0 79.1%
sub-neg79.1%
remove-double-neg79.1%
mul-1-neg79.1%
distribute-neg-in79.1%
+-commutative79.1%
cos-neg79.1%
mul-1-neg79.1%
unsub-neg79.1%
Simplified79.1%
Taylor expanded in lambda2 around 0 79.2%
cos-neg79.2%
*-commutative79.2%
Simplified79.2%
Final simplification71.3%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (cos phi1) (sin phi2))) (t_1 (sin (- lambda1 lambda2))))
(if (or (<= phi2 -1.45e-31) (not (<= phi2 5.5e-9)))
(atan2 (* (cos phi2) t_1) (- t_0 (* (cos lambda1) (sin phi1))))
(atan2
(* t_1 (+ 1.0 (* -0.5 (* phi2 phi2))))
(- t_0 (* (sin phi1) (cos (- lambda2 lambda1))))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos(phi1) * sin(phi2);
double t_1 = sin((lambda1 - lambda2));
double tmp;
if ((phi2 <= -1.45e-31) || !(phi2 <= 5.5e-9)) {
tmp = atan2((cos(phi2) * t_1), (t_0 - (cos(lambda1) * sin(phi1))));
} else {
tmp = atan2((t_1 * (1.0 + (-0.5 * (phi2 * phi2)))), (t_0 - (sin(phi1) * cos((lambda2 - lambda1)))));
}
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(phi1) * sin(phi2)
t_1 = sin((lambda1 - lambda2))
if ((phi2 <= (-1.45d-31)) .or. (.not. (phi2 <= 5.5d-9))) then
tmp = atan2((cos(phi2) * t_1), (t_0 - (cos(lambda1) * sin(phi1))))
else
tmp = atan2((t_1 * (1.0d0 + ((-0.5d0) * (phi2 * phi2)))), (t_0 - (sin(phi1) * cos((lambda2 - lambda1)))))
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 t_1 = Math.sin((lambda1 - lambda2));
double tmp;
if ((phi2 <= -1.45e-31) || !(phi2 <= 5.5e-9)) {
tmp = Math.atan2((Math.cos(phi2) * t_1), (t_0 - (Math.cos(lambda1) * Math.sin(phi1))));
} else {
tmp = Math.atan2((t_1 * (1.0 + (-0.5 * (phi2 * phi2)))), (t_0 - (Math.sin(phi1) * Math.cos((lambda2 - lambda1)))));
}
return tmp;
}
def code(lambda1, lambda2, phi1, phi2): t_0 = math.cos(phi1) * math.sin(phi2) t_1 = math.sin((lambda1 - lambda2)) tmp = 0 if (phi2 <= -1.45e-31) or not (phi2 <= 5.5e-9): tmp = math.atan2((math.cos(phi2) * t_1), (t_0 - (math.cos(lambda1) * math.sin(phi1)))) else: tmp = math.atan2((t_1 * (1.0 + (-0.5 * (phi2 * phi2)))), (t_0 - (math.sin(phi1) * math.cos((lambda2 - lambda1))))) return tmp
function code(lambda1, lambda2, phi1, phi2) t_0 = Float64(cos(phi1) * sin(phi2)) t_1 = sin(Float64(lambda1 - lambda2)) tmp = 0.0 if ((phi2 <= -1.45e-31) || !(phi2 <= 5.5e-9)) tmp = atan(Float64(cos(phi2) * t_1), Float64(t_0 - Float64(cos(lambda1) * sin(phi1)))); else tmp = atan(Float64(t_1 * Float64(1.0 + Float64(-0.5 * Float64(phi2 * phi2)))), Float64(t_0 - Float64(sin(phi1) * cos(Float64(lambda2 - lambda1))))); end return tmp end
function tmp_2 = code(lambda1, lambda2, phi1, phi2) t_0 = cos(phi1) * sin(phi2); t_1 = sin((lambda1 - lambda2)); tmp = 0.0; if ((phi2 <= -1.45e-31) || ~((phi2 <= 5.5e-9))) tmp = atan2((cos(phi2) * t_1), (t_0 - (cos(lambda1) * sin(phi1)))); else tmp = atan2((t_1 * (1.0 + (-0.5 * (phi2 * phi2)))), (t_0 - (sin(phi1) * cos((lambda2 - lambda1))))); end tmp_2 = 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[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]}, If[Or[LessEqual[phi2, -1.45e-31], N[Not[LessEqual[phi2, 5.5e-9]], $MachinePrecision]], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * t$95$1), $MachinePrecision] / N[(t$95$0 - N[(N[Cos[lambda1], $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[N[(t$95$1 * N[(1.0 + N[(-0.5 * N[(phi2 * phi2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(t$95$0 - N[(N[Sin[phi1], $MachinePrecision] * N[Cos[N[(lambda2 - lambda1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \cos \phi_1 \cdot \sin \phi_2\\
t_1 := \sin \left(\lambda_1 - \lambda_2\right)\\
\mathbf{if}\;\phi_2 \leq -1.45 \cdot 10^{-31} \lor \neg \left(\phi_2 \leq 5.5 \cdot 10^{-9}\right):\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot t_1}{t_0 - \cos \lambda_1 \cdot \sin \phi_1}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{t_1 \cdot \left(1 + -0.5 \cdot \left(\phi_2 \cdot \phi_2\right)\right)}{t_0 - \sin \phi_1 \cdot \cos \left(\lambda_2 - \lambda_1\right)}\\
\end{array}
\end{array}
if phi2 < -1.45e-31 or 5.4999999999999996e-9 < phi2 Initial program 82.4%
associate-*l*82.4%
Simplified82.4%
Taylor expanded in phi2 around 0 59.3%
sub-neg59.3%
remove-double-neg59.3%
mul-1-neg59.3%
distribute-neg-in59.3%
+-commutative59.3%
cos-neg59.3%
mul-1-neg59.3%
unsub-neg59.3%
Simplified59.3%
Taylor expanded in lambda2 around 0 59.2%
cos-neg59.2%
*-commutative59.2%
Simplified59.2%
if -1.45e-31 < phi2 < 5.4999999999999996e-9Initial program 81.4%
associate-*l*81.4%
Simplified81.4%
Taylor expanded in phi2 around 0 81.4%
sub-neg81.4%
remove-double-neg81.4%
mul-1-neg81.4%
distribute-neg-in81.4%
+-commutative81.4%
cos-neg81.4%
mul-1-neg81.4%
unsub-neg81.4%
Simplified81.4%
Taylor expanded in phi2 around 0 81.4%
*-lft-identity49.2%
associate-*r*49.2%
distribute-rgt-out49.2%
unpow249.2%
Simplified81.4%
Final simplification69.8%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (cos phi2) (sin (- lambda1 lambda2))))
(t_1 (* (cos phi1) (sin phi2))))
(if (<= lambda1 -0.0028)
(atan2
(* (cos phi2) (sin lambda1))
(- t_1 (* (sin phi1) (cos (- lambda2 lambda1)))))
(if (<= lambda1 5.8e-68)
(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.0028) {
tmp = atan2((cos(phi2) * sin(lambda1)), (t_1 - (sin(phi1) * cos((lambda2 - lambda1)))));
} else if (lambda1 <= 5.8e-68) {
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.0028d0)) then
tmp = atan2((cos(phi2) * sin(lambda1)), (t_1 - (sin(phi1) * cos((lambda2 - lambda1)))))
else if (lambda1 <= 5.8d-68) 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.0028) {
tmp = Math.atan2((Math.cos(phi2) * Math.sin(lambda1)), (t_1 - (Math.sin(phi1) * Math.cos((lambda2 - lambda1)))));
} else if (lambda1 <= 5.8e-68) {
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.0028: tmp = math.atan2((math.cos(phi2) * math.sin(lambda1)), (t_1 - (math.sin(phi1) * math.cos((lambda2 - lambda1))))) elif lambda1 <= 5.8e-68: 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.0028) tmp = atan(Float64(cos(phi2) * sin(lambda1)), Float64(t_1 - Float64(sin(phi1) * cos(Float64(lambda2 - lambda1))))); elseif (lambda1 <= 5.8e-68) 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.0028) tmp = atan2((cos(phi2) * sin(lambda1)), (t_1 - (sin(phi1) * cos((lambda2 - lambda1))))); elseif (lambda1 <= 5.8e-68) 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.0028], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[Sin[lambda1], $MachinePrecision]), $MachinePrecision] / N[(t$95$1 - N[(N[Sin[phi1], $MachinePrecision] * N[Cos[N[(lambda2 - lambda1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[lambda1, 5.8e-68], 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.0028:\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \lambda_1}{t_1 - \sin \phi_1 \cdot \cos \left(\lambda_2 - \lambda_1\right)}\\
\mathbf{elif}\;\lambda_1 \leq 5.8 \cdot 10^{-68}:\\
\;\;\;\;\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.00279999999999999997Initial program 63.7%
associate-*l*63.7%
Simplified63.7%
Taylor expanded in phi2 around 0 53.8%
sub-neg53.8%
remove-double-neg53.8%
mul-1-neg53.8%
distribute-neg-in53.8%
+-commutative53.8%
cos-neg53.8%
mul-1-neg53.8%
unsub-neg53.8%
Simplified53.8%
Taylor expanded in lambda2 around 0 54.8%
if -0.00279999999999999997 < lambda1 < 5.8000000000000001e-68Initial program 99.9%
associate-*l*99.8%
Simplified99.8%
Taylor expanded in phi2 around 0 86.6%
sub-neg86.6%
remove-double-neg86.6%
mul-1-neg86.6%
distribute-neg-in86.6%
+-commutative86.6%
cos-neg86.6%
mul-1-neg86.6%
unsub-neg86.6%
Simplified86.6%
Taylor expanded in lambda1 around 0 86.6%
*-commutative86.6%
Simplified86.6%
if 5.8000000000000001e-68 < lambda1 Initial program 71.6%
associate-*l*71.6%
Simplified71.6%
Taylor expanded in phi2 around 0 59.5%
sub-neg59.5%
remove-double-neg59.5%
mul-1-neg59.5%
distribute-neg-in59.5%
+-commutative59.5%
cos-neg59.5%
mul-1-neg59.5%
unsub-neg59.5%
Simplified59.5%
Taylor expanded in lambda2 around 0 59.7%
cos-neg59.7%
*-commutative59.7%
Simplified59.7%
Final simplification70.2%
(FPCore (lambda1 lambda2 phi1 phi2) :precision binary64 (atan2 (* (cos phi2) (sin (- lambda1 lambda2))) (- (* (cos phi1) (sin phi2)) (* (sin phi1) (cos (- lambda2 lambda1))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
return atan2((cos(phi2) * sin((lambda1 - lambda2))), ((cos(phi1) * sin(phi2)) - (sin(phi1) * cos((lambda2 - lambda1)))));
}
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))), ((cos(phi1) * sin(phi2)) - (sin(phi1) * cos((lambda2 - lambda1)))))
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.cos(phi1) * Math.sin(phi2)) - (Math.sin(phi1) * Math.cos((lambda2 - lambda1)))));
}
def code(lambda1, lambda2, phi1, phi2): return math.atan2((math.cos(phi2) * math.sin((lambda1 - lambda2))), ((math.cos(phi1) * math.sin(phi2)) - (math.sin(phi1) * math.cos((lambda2 - lambda1)))))
function code(lambda1, lambda2, phi1, phi2) return atan(Float64(cos(phi2) * sin(Float64(lambda1 - lambda2))), Float64(Float64(cos(phi1) * sin(phi2)) - Float64(sin(phi1) * cos(Float64(lambda2 - lambda1))))) end
function tmp = code(lambda1, lambda2, phi1, phi2) tmp = atan2((cos(phi2) * sin((lambda1 - lambda2))), ((cos(phi1) * sin(phi2)) - (sin(phi1) * cos((lambda2 - lambda1))))); end
code[lambda1_, lambda2_, phi1_, phi2_] := 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[(lambda2 - lambda1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\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_2 - \lambda_1\right)}
\end{array}
Initial program 81.9%
associate-*l*81.9%
Simplified81.9%
Taylor expanded in phi2 around 0 69.9%
sub-neg69.9%
remove-double-neg69.9%
mul-1-neg69.9%
distribute-neg-in69.9%
+-commutative69.9%
cos-neg69.9%
mul-1-neg69.9%
unsub-neg69.9%
Simplified69.9%
Final simplification69.9%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (cos phi1) (sin phi2))) (t_1 (sin (- lambda1 lambda2))))
(if (or (<= phi2 -0.053) (not (<= phi2 0.029)))
(atan2 (* (cos phi2) t_1) (- t_0 (* (cos lambda1) phi1)))
(atan2
(* t_1 (+ 1.0 (* -0.5 (* phi2 phi2))))
(- t_0 (* (sin phi1) (cos (- lambda2 lambda1))))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos(phi1) * sin(phi2);
double t_1 = sin((lambda1 - lambda2));
double tmp;
if ((phi2 <= -0.053) || !(phi2 <= 0.029)) {
tmp = atan2((cos(phi2) * t_1), (t_0 - (cos(lambda1) * phi1)));
} else {
tmp = atan2((t_1 * (1.0 + (-0.5 * (phi2 * phi2)))), (t_0 - (sin(phi1) * cos((lambda2 - lambda1)))));
}
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(phi1) * sin(phi2)
t_1 = sin((lambda1 - lambda2))
if ((phi2 <= (-0.053d0)) .or. (.not. (phi2 <= 0.029d0))) then
tmp = atan2((cos(phi2) * t_1), (t_0 - (cos(lambda1) * phi1)))
else
tmp = atan2((t_1 * (1.0d0 + ((-0.5d0) * (phi2 * phi2)))), (t_0 - (sin(phi1) * cos((lambda2 - lambda1)))))
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 t_1 = Math.sin((lambda1 - lambda2));
double tmp;
if ((phi2 <= -0.053) || !(phi2 <= 0.029)) {
tmp = Math.atan2((Math.cos(phi2) * t_1), (t_0 - (Math.cos(lambda1) * phi1)));
} else {
tmp = Math.atan2((t_1 * (1.0 + (-0.5 * (phi2 * phi2)))), (t_0 - (Math.sin(phi1) * Math.cos((lambda2 - lambda1)))));
}
return tmp;
}
def code(lambda1, lambda2, phi1, phi2): t_0 = math.cos(phi1) * math.sin(phi2) t_1 = math.sin((lambda1 - lambda2)) tmp = 0 if (phi2 <= -0.053) or not (phi2 <= 0.029): tmp = math.atan2((math.cos(phi2) * t_1), (t_0 - (math.cos(lambda1) * phi1))) else: tmp = math.atan2((t_1 * (1.0 + (-0.5 * (phi2 * phi2)))), (t_0 - (math.sin(phi1) * math.cos((lambda2 - lambda1))))) return tmp
function code(lambda1, lambda2, phi1, phi2) t_0 = Float64(cos(phi1) * sin(phi2)) t_1 = sin(Float64(lambda1 - lambda2)) tmp = 0.0 if ((phi2 <= -0.053) || !(phi2 <= 0.029)) tmp = atan(Float64(cos(phi2) * t_1), Float64(t_0 - Float64(cos(lambda1) * phi1))); else tmp = atan(Float64(t_1 * Float64(1.0 + Float64(-0.5 * Float64(phi2 * phi2)))), Float64(t_0 - Float64(sin(phi1) * cos(Float64(lambda2 - lambda1))))); end return tmp end
function tmp_2 = code(lambda1, lambda2, phi1, phi2) t_0 = cos(phi1) * sin(phi2); t_1 = sin((lambda1 - lambda2)); tmp = 0.0; if ((phi2 <= -0.053) || ~((phi2 <= 0.029))) tmp = atan2((cos(phi2) * t_1), (t_0 - (cos(lambda1) * phi1))); else tmp = atan2((t_1 * (1.0 + (-0.5 * (phi2 * phi2)))), (t_0 - (sin(phi1) * cos((lambda2 - lambda1))))); end tmp_2 = 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[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]}, If[Or[LessEqual[phi2, -0.053], N[Not[LessEqual[phi2, 0.029]], $MachinePrecision]], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * t$95$1), $MachinePrecision] / N[(t$95$0 - N[(N[Cos[lambda1], $MachinePrecision] * phi1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[ArcTan[N[(t$95$1 * N[(1.0 + N[(-0.5 * N[(phi2 * phi2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(t$95$0 - N[(N[Sin[phi1], $MachinePrecision] * N[Cos[N[(lambda2 - lambda1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \cos \phi_1 \cdot \sin \phi_2\\
t_1 := \sin \left(\lambda_1 - \lambda_2\right)\\
\mathbf{if}\;\phi_2 \leq -0.053 \lor \neg \left(\phi_2 \leq 0.029\right):\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot t_1}{t_0 - \cos \lambda_1 \cdot \phi_1}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{t_1 \cdot \left(1 + -0.5 \cdot \left(\phi_2 \cdot \phi_2\right)\right)}{t_0 - \sin \phi_1 \cdot \cos \left(\lambda_2 - \lambda_1\right)}\\
\end{array}
\end{array}
if phi2 < -0.0529999999999999985 or 0.0290000000000000015 < phi2 Initial program 81.8%
associate-*l*81.8%
Simplified81.8%
Taylor expanded in phi2 around 0 57.0%
sub-neg57.0%
remove-double-neg57.0%
mul-1-neg57.0%
distribute-neg-in57.0%
+-commutative57.0%
cos-neg57.0%
mul-1-neg57.0%
unsub-neg57.0%
Simplified57.0%
Taylor expanded in phi1 around 0 52.7%
Taylor expanded in lambda2 around 0 52.9%
cos-neg52.9%
*-commutative52.9%
Simplified52.9%
if -0.0529999999999999985 < phi2 < 0.0290000000000000015Initial program 82.0%
associate-*l*82.0%
Simplified82.0%
Taylor expanded in phi2 around 0 82.0%
sub-neg82.0%
remove-double-neg82.0%
mul-1-neg82.0%
distribute-neg-in82.0%
+-commutative82.0%
cos-neg82.0%
mul-1-neg82.0%
unsub-neg82.0%
Simplified82.0%
Taylor expanded in phi2 around 0 82.0%
*-lft-identity50.7%
associate-*r*50.7%
distribute-rgt-out50.7%
unpow250.7%
Simplified82.0%
Final simplification67.9%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (cos phi1) (sin phi2))))
(if (<= phi1 -2.5e+22)
(atan2
(* (cos phi2) (- lambda1 lambda2))
(- t_0 (* (sin phi1) (cos (- lambda2 lambda1)))))
(atan2
(* (cos phi2) (sin (- lambda1 lambda2)))
(- t_0 (* (cos lambda1) phi1))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos(phi1) * sin(phi2);
double tmp;
if (phi1 <= -2.5e+22) {
tmp = atan2((cos(phi2) * (lambda1 - lambda2)), (t_0 - (sin(phi1) * cos((lambda2 - lambda1)))));
} else {
tmp = atan2((cos(phi2) * sin((lambda1 - lambda2))), (t_0 - (cos(lambda1) * 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) :: tmp
t_0 = cos(phi1) * sin(phi2)
if (phi1 <= (-2.5d+22)) then
tmp = atan2((cos(phi2) * (lambda1 - lambda2)), (t_0 - (sin(phi1) * cos((lambda2 - lambda1)))))
else
tmp = atan2((cos(phi2) * sin((lambda1 - lambda2))), (t_0 - (cos(lambda1) * phi1)))
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 (phi1 <= -2.5e+22) {
tmp = Math.atan2((Math.cos(phi2) * (lambda1 - lambda2)), (t_0 - (Math.sin(phi1) * Math.cos((lambda2 - lambda1)))));
} else {
tmp = Math.atan2((Math.cos(phi2) * Math.sin((lambda1 - lambda2))), (t_0 - (Math.cos(lambda1) * phi1)));
}
return tmp;
}
def code(lambda1, lambda2, phi1, phi2): t_0 = math.cos(phi1) * math.sin(phi2) tmp = 0 if phi1 <= -2.5e+22: tmp = math.atan2((math.cos(phi2) * (lambda1 - lambda2)), (t_0 - (math.sin(phi1) * math.cos((lambda2 - lambda1))))) else: tmp = math.atan2((math.cos(phi2) * math.sin((lambda1 - lambda2))), (t_0 - (math.cos(lambda1) * phi1))) return tmp
function code(lambda1, lambda2, phi1, phi2) t_0 = Float64(cos(phi1) * sin(phi2)) tmp = 0.0 if (phi1 <= -2.5e+22) tmp = atan(Float64(cos(phi2) * Float64(lambda1 - lambda2)), Float64(t_0 - Float64(sin(phi1) * cos(Float64(lambda2 - lambda1))))); else tmp = atan(Float64(cos(phi2) * sin(Float64(lambda1 - lambda2))), Float64(t_0 - Float64(cos(lambda1) * phi1))); end return tmp end
function tmp_2 = code(lambda1, lambda2, phi1, phi2) t_0 = cos(phi1) * sin(phi2); tmp = 0.0; if (phi1 <= -2.5e+22) tmp = atan2((cos(phi2) * (lambda1 - lambda2)), (t_0 - (sin(phi1) * cos((lambda2 - lambda1))))); else tmp = atan2((cos(phi2) * sin((lambda1 - lambda2))), (t_0 - (cos(lambda1) * phi1))); 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[LessEqual[phi1, -2.5e+22], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[(lambda1 - lambda2), $MachinePrecision]), $MachinePrecision] / N[(t$95$0 - N[(N[Sin[phi1], $MachinePrecision] * N[Cos[N[(lambda2 - lambda1), $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[Cos[lambda1], $MachinePrecision] * phi1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \cos \phi_1 \cdot \sin \phi_2\\
\mathbf{if}\;\phi_1 \leq -2.5 \cdot 10^{+22}:\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \left(\lambda_1 - \lambda_2\right)}{t_0 - \sin \phi_1 \cdot \cos \left(\lambda_2 - \lambda_1\right)}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{t_0 - \cos \lambda_1 \cdot \phi_1}\\
\end{array}
\end{array}
if phi1 < -2.4999999999999998e22Initial program 77.9%
associate-*l*77.9%
Simplified77.9%
Taylor expanded in phi2 around 0 58.2%
sub-neg58.2%
remove-double-neg58.2%
mul-1-neg58.2%
distribute-neg-in58.2%
+-commutative58.2%
cos-neg58.2%
mul-1-neg58.2%
unsub-neg58.2%
Simplified58.2%
Taylor expanded in lambda1 around 0 48.3%
+-commutative48.3%
sin-neg48.3%
unsub-neg48.3%
cos-neg48.3%
Simplified48.3%
Taylor expanded in lambda2 around 0 35.2%
+-commutative35.2%
associate-*r*35.2%
neg-mul-135.2%
distribute-rgt-out35.2%
sub-neg35.2%
Simplified35.2%
if -2.4999999999999998e22 < phi1 Initial program 82.9%
associate-*l*82.9%
Simplified82.9%
Taylor expanded in phi2 around 0 72.8%
sub-neg72.8%
remove-double-neg72.8%
mul-1-neg72.8%
distribute-neg-in72.8%
+-commutative72.8%
cos-neg72.8%
mul-1-neg72.8%
unsub-neg72.8%
Simplified72.8%
Taylor expanded in phi1 around 0 62.5%
Taylor expanded in lambda2 around 0 62.6%
cos-neg62.6%
*-commutative62.6%
Simplified62.6%
Final simplification57.2%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (cos phi1) (sin phi2))))
(if (<= phi1 -0.0068)
(atan2
(* (cos phi2) lambda1)
(- t_0 (* (sin phi1) (cos (- lambda2 lambda1)))))
(atan2
(* (cos phi2) (sin (- lambda1 lambda2)))
(- t_0 (* (cos lambda1) phi1))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos(phi1) * sin(phi2);
double tmp;
if (phi1 <= -0.0068) {
tmp = atan2((cos(phi2) * lambda1), (t_0 - (sin(phi1) * cos((lambda2 - lambda1)))));
} else {
tmp = atan2((cos(phi2) * sin((lambda1 - lambda2))), (t_0 - (cos(lambda1) * 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) :: tmp
t_0 = cos(phi1) * sin(phi2)
if (phi1 <= (-0.0068d0)) then
tmp = atan2((cos(phi2) * lambda1), (t_0 - (sin(phi1) * cos((lambda2 - lambda1)))))
else
tmp = atan2((cos(phi2) * sin((lambda1 - lambda2))), (t_0 - (cos(lambda1) * phi1)))
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 (phi1 <= -0.0068) {
tmp = Math.atan2((Math.cos(phi2) * lambda1), (t_0 - (Math.sin(phi1) * Math.cos((lambda2 - lambda1)))));
} else {
tmp = Math.atan2((Math.cos(phi2) * Math.sin((lambda1 - lambda2))), (t_0 - (Math.cos(lambda1) * phi1)));
}
return tmp;
}
def code(lambda1, lambda2, phi1, phi2): t_0 = math.cos(phi1) * math.sin(phi2) tmp = 0 if phi1 <= -0.0068: tmp = math.atan2((math.cos(phi2) * lambda1), (t_0 - (math.sin(phi1) * math.cos((lambda2 - lambda1))))) else: tmp = math.atan2((math.cos(phi2) * math.sin((lambda1 - lambda2))), (t_0 - (math.cos(lambda1) * phi1))) return tmp
function code(lambda1, lambda2, phi1, phi2) t_0 = Float64(cos(phi1) * sin(phi2)) tmp = 0.0 if (phi1 <= -0.0068) tmp = atan(Float64(cos(phi2) * lambda1), Float64(t_0 - Float64(sin(phi1) * cos(Float64(lambda2 - lambda1))))); else tmp = atan(Float64(cos(phi2) * sin(Float64(lambda1 - lambda2))), Float64(t_0 - Float64(cos(lambda1) * phi1))); end return tmp end
function tmp_2 = code(lambda1, lambda2, phi1, phi2) t_0 = cos(phi1) * sin(phi2); tmp = 0.0; if (phi1 <= -0.0068) tmp = atan2((cos(phi2) * lambda1), (t_0 - (sin(phi1) * cos((lambda2 - lambda1))))); else tmp = atan2((cos(phi2) * sin((lambda1 - lambda2))), (t_0 - (cos(lambda1) * phi1))); 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[LessEqual[phi1, -0.0068], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * lambda1), $MachinePrecision] / N[(t$95$0 - N[(N[Sin[phi1], $MachinePrecision] * N[Cos[N[(lambda2 - lambda1), $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[Cos[lambda1], $MachinePrecision] * phi1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \cos \phi_1 \cdot \sin \phi_2\\
\mathbf{if}\;\phi_1 \leq -0.0068:\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \lambda_1}{t_0 - \sin \phi_1 \cdot \cos \left(\lambda_2 - \lambda_1\right)}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{t_0 - \cos \lambda_1 \cdot \phi_1}\\
\end{array}
\end{array}
if phi1 < -0.00679999999999999962Initial program 76.2%
associate-*l*76.2%
Simplified76.2%
Taylor expanded in phi2 around 0 58.0%
sub-neg58.0%
remove-double-neg58.0%
mul-1-neg58.0%
distribute-neg-in58.0%
+-commutative58.0%
cos-neg58.0%
mul-1-neg58.0%
unsub-neg58.0%
Simplified58.0%
Taylor expanded in lambda1 around 0 47.0%
+-commutative47.0%
sin-neg47.0%
unsub-neg47.0%
cos-neg47.0%
Simplified47.0%
Taylor expanded in lambda2 around 0 23.8%
if -0.00679999999999999962 < phi1 Initial program 83.4%
associate-*l*83.4%
Simplified83.4%
Taylor expanded in phi2 around 0 73.1%
sub-neg73.1%
remove-double-neg73.1%
mul-1-neg73.1%
distribute-neg-in73.1%
+-commutative73.1%
cos-neg73.1%
mul-1-neg73.1%
unsub-neg73.1%
Simplified73.1%
Taylor expanded in phi1 around 0 63.5%
Taylor expanded in lambda2 around 0 63.6%
cos-neg63.6%
*-commutative63.6%
Simplified63.6%
Final simplification55.1%
(FPCore (lambda1 lambda2 phi1 phi2)
:precision binary64
(if (or (<= phi2 -0.0136) (not (<= phi2 1.4e-16)))
(atan2 (* (cos phi2) (sin lambda1)) (sin phi2))
(atan2
(* (sin (- lambda1 lambda2)) (+ 1.0 (* -0.5 (* phi2 phi2))))
(- (* (cos phi1) (sin phi2)) (* phi1 (cos (- lambda2 lambda1)))))))
double code(double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if ((phi2 <= -0.0136) || !(phi2 <= 1.4e-16)) {
tmp = atan2((cos(phi2) * sin(lambda1)), sin(phi2));
} else {
tmp = atan2((sin((lambda1 - lambda2)) * (1.0 + (-0.5 * (phi2 * phi2)))), ((cos(phi1) * sin(phi2)) - (phi1 * cos((lambda2 - lambda1)))));
}
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 <= (-0.0136d0)) .or. (.not. (phi2 <= 1.4d-16))) then
tmp = atan2((cos(phi2) * sin(lambda1)), sin(phi2))
else
tmp = atan2((sin((lambda1 - lambda2)) * (1.0d0 + ((-0.5d0) * (phi2 * phi2)))), ((cos(phi1) * sin(phi2)) - (phi1 * cos((lambda2 - lambda1)))))
end if
code = tmp
end function
public static double code(double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if ((phi2 <= -0.0136) || !(phi2 <= 1.4e-16)) {
tmp = Math.atan2((Math.cos(phi2) * Math.sin(lambda1)), Math.sin(phi2));
} else {
tmp = Math.atan2((Math.sin((lambda1 - lambda2)) * (1.0 + (-0.5 * (phi2 * phi2)))), ((Math.cos(phi1) * Math.sin(phi2)) - (phi1 * Math.cos((lambda2 - lambda1)))));
}
return tmp;
}
def code(lambda1, lambda2, phi1, phi2): tmp = 0 if (phi2 <= -0.0136) or not (phi2 <= 1.4e-16): tmp = math.atan2((math.cos(phi2) * math.sin(lambda1)), math.sin(phi2)) else: tmp = math.atan2((math.sin((lambda1 - lambda2)) * (1.0 + (-0.5 * (phi2 * phi2)))), ((math.cos(phi1) * math.sin(phi2)) - (phi1 * math.cos((lambda2 - lambda1))))) return tmp
function code(lambda1, lambda2, phi1, phi2) tmp = 0.0 if ((phi2 <= -0.0136) || !(phi2 <= 1.4e-16)) tmp = atan(Float64(cos(phi2) * sin(lambda1)), sin(phi2)); else tmp = atan(Float64(sin(Float64(lambda1 - lambda2)) * Float64(1.0 + Float64(-0.5 * Float64(phi2 * phi2)))), Float64(Float64(cos(phi1) * sin(phi2)) - Float64(phi1 * cos(Float64(lambda2 - lambda1))))); end return tmp end
function tmp_2 = code(lambda1, lambda2, phi1, phi2) tmp = 0.0; if ((phi2 <= -0.0136) || ~((phi2 <= 1.4e-16))) tmp = atan2((cos(phi2) * sin(lambda1)), sin(phi2)); else tmp = atan2((sin((lambda1 - lambda2)) * (1.0 + (-0.5 * (phi2 * phi2)))), ((cos(phi1) * sin(phi2)) - (phi1 * cos((lambda2 - lambda1))))); end tmp_2 = tmp; end
code[lambda1_, lambda2_, phi1_, phi2_] := If[Or[LessEqual[phi2, -0.0136], N[Not[LessEqual[phi2, 1.4e-16]], $MachinePrecision]], N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[Sin[lambda1], $MachinePrecision]), $MachinePrecision] / N[Sin[phi2], $MachinePrecision]], $MachinePrecision], N[ArcTan[N[(N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision] * N[(1.0 + N[(-0.5 * N[(phi2 * phi2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] - N[(phi1 * N[Cos[N[(lambda2 - lambda1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_2 \leq -0.0136 \lor \neg \left(\phi_2 \leq 1.4 \cdot 10^{-16}\right):\\
\;\;\;\;\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \lambda_1}{\sin \phi_2}\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{\sin \left(\lambda_1 - \lambda_2\right) \cdot \left(1 + -0.5 \cdot \left(\phi_2 \cdot \phi_2\right)\right)}{\cos \phi_1 \cdot \sin \phi_2 - \phi_1 \cdot \cos \left(\lambda_2 - \lambda_1\right)}\\
\end{array}
\end{array}
if phi2 < -0.0135999999999999992 or 1.4000000000000001e-16 < phi2 Initial program 81.4%
sub-neg81.4%
+-commutative81.4%
distribute-rgt-neg-in81.4%
*-commutative81.4%
associate-*l*81.4%
fma-def81.4%
distribute-rgt-neg-in81.4%
*-commutative81.4%
distribute-rgt-neg-out81.4%
Simplified81.4%
add-sqr-sqrt42.0%
sqrt-unprod65.9%
sqr-neg65.9%
sqrt-unprod23.9%
add-sqr-sqrt54.5%
pow154.5%
Applied egg-rr54.5%
Taylor expanded in lambda2 around 0 36.4%
Taylor expanded in phi1 around 0 36.2%
if -0.0135999999999999992 < phi2 < 1.4000000000000001e-16Initial program 82.4%
associate-*l*82.4%
Simplified82.4%
Taylor expanded in phi2 around 0 82.4%
sub-neg82.4%
remove-double-neg82.4%
mul-1-neg82.4%
distribute-neg-in82.4%
+-commutative82.4%
cos-neg82.4%
mul-1-neg82.4%
unsub-neg82.4%
Simplified82.4%
Taylor expanded in phi1 around 0 51.0%
Taylor expanded in phi2 around 0 51.0%
*-lft-identity51.0%
associate-*r*51.0%
distribute-rgt-out51.0%
unpow251.0%
Simplified51.0%
Final simplification43.6%
(FPCore (lambda1 lambda2 phi1 phi2) :precision binary64 (atan2 (* (cos phi2) (sin lambda1)) (sin phi2)))
double code(double lambda1, double lambda2, double phi1, double phi2) {
return atan2((cos(phi2) * 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((cos(phi2) * sin(lambda1)), 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)), Math.sin(phi2));
}
def code(lambda1, lambda2, phi1, phi2): return math.atan2((math.cos(phi2) * math.sin(lambda1)), math.sin(phi2))
function code(lambda1, lambda2, phi1, phi2) return atan(Float64(cos(phi2) * sin(lambda1)), sin(phi2)) end
function tmp = code(lambda1, lambda2, phi1, phi2) tmp = atan2((cos(phi2) * sin(lambda1)), sin(phi2)); end
code[lambda1_, lambda2_, phi1_, phi2_] := N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[Sin[lambda1], $MachinePrecision]), $MachinePrecision] / N[Sin[phi2], $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \lambda_1}{\sin \phi_2}
\end{array}
Initial program 81.9%
sub-neg81.9%
+-commutative81.9%
distribute-rgt-neg-in81.9%
*-commutative81.9%
associate-*l*81.9%
fma-def81.9%
distribute-rgt-neg-in81.9%
*-commutative81.9%
distribute-rgt-neg-out81.9%
Simplified81.9%
add-sqr-sqrt43.7%
sqrt-unprod66.8%
sqr-neg66.8%
sqrt-unprod23.4%
add-sqr-sqrt50.7%
pow150.7%
Applied egg-rr50.7%
Taylor expanded in lambda2 around 0 34.7%
Taylor expanded in phi1 around 0 35.8%
Final simplification35.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 81.9%
sub-neg81.9%
+-commutative81.9%
distribute-rgt-neg-in81.9%
*-commutative81.9%
associate-*l*81.9%
fma-def81.9%
distribute-rgt-neg-in81.9%
*-commutative81.9%
distribute-rgt-neg-out81.9%
Simplified81.9%
add-sqr-sqrt43.7%
sqrt-unprod66.8%
sqr-neg66.8%
sqrt-unprod23.4%
add-sqr-sqrt50.7%
pow150.7%
Applied egg-rr50.7%
Taylor expanded in lambda2 around 0 34.7%
Taylor expanded in phi1 around 0 35.8%
Taylor expanded in phi2 around 0 24.5%
Final simplification24.5%
herbie shell --seed 2023279
(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))))))