
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (let* ((t_0 (* (- lambda1 lambda2) (cos (/ (+ phi1 phi2) 2.0))))) (* R (sqrt (+ (* t_0 t_0) (* (- phi1 phi2) (- phi1 phi2)))))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = (lambda1 - lambda2) * cos(((phi1 + phi2) / 2.0));
return R * sqrt(((t_0 * t_0) + ((phi1 - phi2) * (phi1 - phi2))));
}
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: t_0
t_0 = (lambda1 - lambda2) * cos(((phi1 + phi2) / 2.0d0))
code = r * sqrt(((t_0 * t_0) + ((phi1 - phi2) * (phi1 - phi2))))
end function
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = (lambda1 - lambda2) * Math.cos(((phi1 + phi2) / 2.0));
return R * Math.sqrt(((t_0 * t_0) + ((phi1 - phi2) * (phi1 - phi2))));
}
def code(R, lambda1, lambda2, phi1, phi2): t_0 = (lambda1 - lambda2) * math.cos(((phi1 + phi2) / 2.0)) return R * math.sqrt(((t_0 * t_0) + ((phi1 - phi2) * (phi1 - phi2))))
function code(R, lambda1, lambda2, phi1, phi2) t_0 = Float64(Float64(lambda1 - lambda2) * cos(Float64(Float64(phi1 + phi2) / 2.0))) return Float64(R * sqrt(Float64(Float64(t_0 * t_0) + Float64(Float64(phi1 - phi2) * Float64(phi1 - phi2))))) end
function tmp = code(R, lambda1, lambda2, phi1, phi2) t_0 = (lambda1 - lambda2) * cos(((phi1 + phi2) / 2.0)); tmp = R * sqrt(((t_0 * t_0) + ((phi1 - phi2) * (phi1 - phi2)))); end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[(lambda1 - lambda2), $MachinePrecision] * N[Cos[N[(N[(phi1 + phi2), $MachinePrecision] / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, N[(R * N[Sqrt[N[(N[(t$95$0 * t$95$0), $MachinePrecision] + N[(N[(phi1 - phi2), $MachinePrecision] * N[(phi1 - phi2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(\lambda_1 - \lambda_2\right) \cdot \cos \left(\frac{\phi_1 + \phi_2}{2}\right)\\
R \cdot \sqrt{t\_0 \cdot t\_0 + \left(\phi_1 - \phi_2\right) \cdot \left(\phi_1 - \phi_2\right)}
\end{array}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 22 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (let* ((t_0 (* (- lambda1 lambda2) (cos (/ (+ phi1 phi2) 2.0))))) (* R (sqrt (+ (* t_0 t_0) (* (- phi1 phi2) (- phi1 phi2)))))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = (lambda1 - lambda2) * cos(((phi1 + phi2) / 2.0));
return R * sqrt(((t_0 * t_0) + ((phi1 - phi2) * (phi1 - phi2))));
}
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: t_0
t_0 = (lambda1 - lambda2) * cos(((phi1 + phi2) / 2.0d0))
code = r * sqrt(((t_0 * t_0) + ((phi1 - phi2) * (phi1 - phi2))))
end function
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = (lambda1 - lambda2) * Math.cos(((phi1 + phi2) / 2.0));
return R * Math.sqrt(((t_0 * t_0) + ((phi1 - phi2) * (phi1 - phi2))));
}
def code(R, lambda1, lambda2, phi1, phi2): t_0 = (lambda1 - lambda2) * math.cos(((phi1 + phi2) / 2.0)) return R * math.sqrt(((t_0 * t_0) + ((phi1 - phi2) * (phi1 - phi2))))
function code(R, lambda1, lambda2, phi1, phi2) t_0 = Float64(Float64(lambda1 - lambda2) * cos(Float64(Float64(phi1 + phi2) / 2.0))) return Float64(R * sqrt(Float64(Float64(t_0 * t_0) + Float64(Float64(phi1 - phi2) * Float64(phi1 - phi2))))) end
function tmp = code(R, lambda1, lambda2, phi1, phi2) t_0 = (lambda1 - lambda2) * cos(((phi1 + phi2) / 2.0)); tmp = R * sqrt(((t_0 * t_0) + ((phi1 - phi2) * (phi1 - phi2)))); end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[(lambda1 - lambda2), $MachinePrecision] * N[Cos[N[(N[(phi1 + phi2), $MachinePrecision] / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, N[(R * N[Sqrt[N[(N[(t$95$0 * t$95$0), $MachinePrecision] + N[(N[(phi1 - phi2), $MachinePrecision] * N[(phi1 - phi2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(\lambda_1 - \lambda_2\right) \cdot \cos \left(\frac{\phi_1 + \phi_2}{2}\right)\\
R \cdot \sqrt{t\_0 \cdot t\_0 + \left(\phi_1 - \phi_2\right) \cdot \left(\phi_1 - \phi_2\right)}
\end{array}
\end{array}
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(*
R
(hypot
(fma
(sin (/ phi2 2.0))
(* (sin (/ phi1 2.0)) (- lambda2 lambda1))
(* (cos (/ phi2 2.0)) (* (- lambda1 lambda2) (cos (/ phi1 2.0)))))
(- phi1 phi2))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * hypot(fma(sin((phi2 / 2.0)), (sin((phi1 / 2.0)) * (lambda2 - lambda1)), (cos((phi2 / 2.0)) * ((lambda1 - lambda2) * cos((phi1 / 2.0))))), (phi1 - phi2));
}
function code(R, lambda1, lambda2, phi1, phi2) return Float64(R * hypot(fma(sin(Float64(phi2 / 2.0)), Float64(sin(Float64(phi1 / 2.0)) * Float64(lambda2 - lambda1)), Float64(cos(Float64(phi2 / 2.0)) * Float64(Float64(lambda1 - lambda2) * cos(Float64(phi1 / 2.0))))), Float64(phi1 - phi2))) end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := N[(R * N[Sqrt[N[(N[Sin[N[(phi2 / 2.0), $MachinePrecision]], $MachinePrecision] * N[(N[Sin[N[(phi1 / 2.0), $MachinePrecision]], $MachinePrecision] * N[(lambda2 - lambda1), $MachinePrecision]), $MachinePrecision] + N[(N[Cos[N[(phi2 / 2.0), $MachinePrecision]], $MachinePrecision] * N[(N[(lambda1 - lambda2), $MachinePrecision] * N[Cos[N[(phi1 / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
R \cdot \mathsf{hypot}\left(\mathsf{fma}\left(\sin \left(\frac{\phi_2}{2}\right), \sin \left(\frac{\phi_1}{2}\right) \cdot \left(\lambda_2 - \lambda_1\right), \cos \left(\frac{\phi_2}{2}\right) \cdot \left(\left(\lambda_1 - \lambda_2\right) \cdot \cos \left(\frac{\phi_1}{2}\right)\right)\right), \phi_1 - \phi_2\right)
\end{array}
Initial program 54.9%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6494.4%
Simplified94.4%
clear-numN/A
associate-/r/N/A
metadata-evalN/A
+-commutativeN/A
distribute-lft-inN/A
cos-sumN/A
*-commutativeN/A
*-commutativeN/A
*-commutativeN/A
fmm-defN/A
fma-lowering-fma.f64N/A
cos-lowering-cos.f64N/A
*-commutativeN/A
metadata-evalN/A
div-invN/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
metadata-evalN/A
div-invN/A
/-lowering-/.f64N/A
Applied egg-rr99.8%
distribute-rgt-inN/A
+-commutativeN/A
distribute-rgt-neg-inN/A
associate-*l*N/A
fma-defineN/A
fma-lowering-fma.f64N/A
Applied egg-rr99.8%
Final simplification99.8%
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(*
R
(hypot
(*
(- lambda1 lambda2)
(fma
(- 0.0 (sin (/ phi2 2.0)))
(sin (/ phi1 2.0))
(* (cos (/ phi2 2.0)) (cos (/ phi1 2.0)))))
(- phi1 phi2))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * hypot(((lambda1 - lambda2) * fma((0.0 - sin((phi2 / 2.0))), sin((phi1 / 2.0)), (cos((phi2 / 2.0)) * cos((phi1 / 2.0))))), (phi1 - phi2));
}
function code(R, lambda1, lambda2, phi1, phi2) return Float64(R * hypot(Float64(Float64(lambda1 - lambda2) * fma(Float64(0.0 - sin(Float64(phi2 / 2.0))), sin(Float64(phi1 / 2.0)), Float64(cos(Float64(phi2 / 2.0)) * cos(Float64(phi1 / 2.0))))), Float64(phi1 - phi2))) end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := N[(R * N[Sqrt[N[(N[(lambda1 - lambda2), $MachinePrecision] * N[(N[(0.0 - N[Sin[N[(phi2 / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Sin[N[(phi1 / 2.0), $MachinePrecision]], $MachinePrecision] + N[(N[Cos[N[(phi2 / 2.0), $MachinePrecision]], $MachinePrecision] * N[Cos[N[(phi1 / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
R \cdot \mathsf{hypot}\left(\left(\lambda_1 - \lambda_2\right) \cdot \mathsf{fma}\left(0 - \sin \left(\frac{\phi_2}{2}\right), \sin \left(\frac{\phi_1}{2}\right), \cos \left(\frac{\phi_2}{2}\right) \cdot \cos \left(\frac{\phi_1}{2}\right)\right), \phi_1 - \phi_2\right)
\end{array}
Initial program 54.9%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6494.4%
Simplified94.4%
clear-numN/A
associate-/r/N/A
metadata-evalN/A
+-commutativeN/A
distribute-lft-inN/A
cos-sumN/A
*-commutativeN/A
*-commutativeN/A
*-commutativeN/A
fmm-defN/A
fma-lowering-fma.f64N/A
cos-lowering-cos.f64N/A
*-commutativeN/A
metadata-evalN/A
div-invN/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
metadata-evalN/A
div-invN/A
/-lowering-/.f64N/A
Applied egg-rr99.8%
+-commutativeN/A
distribute-lft-neg-inN/A
fma-defineN/A
fma-lowering-fma.f64N/A
neg-sub0N/A
--lowering--.f64N/A
sin-lowering-sin.f64N/A
/-lowering-/.f64N/A
sin-lowering-sin.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
div-invN/A
metadata-evalN/A
*-commutativeN/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
metadata-evalN/A
div-invN/A
Applied egg-rr99.8%
Final simplification99.8%
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(*
R
(hypot
(*
(- lambda1 lambda2)
(fma
(cos (/ phi2 2.0))
(cos (/ phi1 2.0))
(* (sin (/ phi2 2.0)) (- 0.0 (sin (/ phi1 2.0))))))
(- phi1 phi2))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * hypot(((lambda1 - lambda2) * fma(cos((phi2 / 2.0)), cos((phi1 / 2.0)), (sin((phi2 / 2.0)) * (0.0 - sin((phi1 / 2.0)))))), (phi1 - phi2));
}
function code(R, lambda1, lambda2, phi1, phi2) return Float64(R * hypot(Float64(Float64(lambda1 - lambda2) * fma(cos(Float64(phi2 / 2.0)), cos(Float64(phi1 / 2.0)), Float64(sin(Float64(phi2 / 2.0)) * Float64(0.0 - sin(Float64(phi1 / 2.0)))))), Float64(phi1 - phi2))) end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := N[(R * N[Sqrt[N[(N[(lambda1 - lambda2), $MachinePrecision] * N[(N[Cos[N[(phi2 / 2.0), $MachinePrecision]], $MachinePrecision] * N[Cos[N[(phi1 / 2.0), $MachinePrecision]], $MachinePrecision] + N[(N[Sin[N[(phi2 / 2.0), $MachinePrecision]], $MachinePrecision] * N[(0.0 - N[Sin[N[(phi1 / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
R \cdot \mathsf{hypot}\left(\left(\lambda_1 - \lambda_2\right) \cdot \mathsf{fma}\left(\cos \left(\frac{\phi_2}{2}\right), \cos \left(\frac{\phi_1}{2}\right), \sin \left(\frac{\phi_2}{2}\right) \cdot \left(0 - \sin \left(\frac{\phi_1}{2}\right)\right)\right), \phi_1 - \phi_2\right)
\end{array}
Initial program 54.9%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6494.4%
Simplified94.4%
clear-numN/A
associate-/r/N/A
metadata-evalN/A
+-commutativeN/A
distribute-lft-inN/A
cos-sumN/A
*-commutativeN/A
*-commutativeN/A
*-commutativeN/A
fmm-defN/A
fma-lowering-fma.f64N/A
cos-lowering-cos.f64N/A
*-commutativeN/A
metadata-evalN/A
div-invN/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
metadata-evalN/A
div-invN/A
/-lowering-/.f64N/A
Applied egg-rr99.8%
Final simplification99.8%
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(*
R
(hypot
(+
(* (cos (/ phi2 2.0)) (* (- lambda1 lambda2) (cos (/ phi1 2.0))))
(* (sin (/ phi2 2.0)) (* (sin (/ phi1 2.0)) (- lambda2 lambda1))))
(- phi1 phi2))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * hypot(((cos((phi2 / 2.0)) * ((lambda1 - lambda2) * cos((phi1 / 2.0)))) + (sin((phi2 / 2.0)) * (sin((phi1 / 2.0)) * (lambda2 - lambda1)))), (phi1 - phi2));
}
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * Math.hypot(((Math.cos((phi2 / 2.0)) * ((lambda1 - lambda2) * Math.cos((phi1 / 2.0)))) + (Math.sin((phi2 / 2.0)) * (Math.sin((phi1 / 2.0)) * (lambda2 - lambda1)))), (phi1 - phi2));
}
def code(R, lambda1, lambda2, phi1, phi2): return R * math.hypot(((math.cos((phi2 / 2.0)) * ((lambda1 - lambda2) * math.cos((phi1 / 2.0)))) + (math.sin((phi2 / 2.0)) * (math.sin((phi1 / 2.0)) * (lambda2 - lambda1)))), (phi1 - phi2))
function code(R, lambda1, lambda2, phi1, phi2) return Float64(R * hypot(Float64(Float64(cos(Float64(phi2 / 2.0)) * Float64(Float64(lambda1 - lambda2) * cos(Float64(phi1 / 2.0)))) + Float64(sin(Float64(phi2 / 2.0)) * Float64(sin(Float64(phi1 / 2.0)) * Float64(lambda2 - lambda1)))), Float64(phi1 - phi2))) end
function tmp = code(R, lambda1, lambda2, phi1, phi2) tmp = R * hypot(((cos((phi2 / 2.0)) * ((lambda1 - lambda2) * cos((phi1 / 2.0)))) + (sin((phi2 / 2.0)) * (sin((phi1 / 2.0)) * (lambda2 - lambda1)))), (phi1 - phi2)); end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := N[(R * N[Sqrt[N[(N[(N[Cos[N[(phi2 / 2.0), $MachinePrecision]], $MachinePrecision] * N[(N[(lambda1 - lambda2), $MachinePrecision] * N[Cos[N[(phi1 / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[Sin[N[(phi2 / 2.0), $MachinePrecision]], $MachinePrecision] * N[(N[Sin[N[(phi1 / 2.0), $MachinePrecision]], $MachinePrecision] * N[(lambda2 - lambda1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
R \cdot \mathsf{hypot}\left(\cos \left(\frac{\phi_2}{2}\right) \cdot \left(\left(\lambda_1 - \lambda_2\right) \cdot \cos \left(\frac{\phi_1}{2}\right)\right) + \sin \left(\frac{\phi_2}{2}\right) \cdot \left(\sin \left(\frac{\phi_1}{2}\right) \cdot \left(\lambda_2 - \lambda_1\right)\right), \phi_1 - \phi_2\right)
\end{array}
Initial program 54.9%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6494.4%
Simplified94.4%
clear-numN/A
associate-/r/N/A
metadata-evalN/A
+-commutativeN/A
distribute-lft-inN/A
cos-sumN/A
*-commutativeN/A
*-commutativeN/A
*-commutativeN/A
fmm-defN/A
fma-lowering-fma.f64N/A
cos-lowering-cos.f64N/A
*-commutativeN/A
metadata-evalN/A
div-invN/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
metadata-evalN/A
div-invN/A
/-lowering-/.f64N/A
Applied egg-rr99.8%
distribute-rgt-inN/A
+-commutativeN/A
distribute-rgt-neg-inN/A
associate-*l*N/A
fma-defineN/A
fma-lowering-fma.f64N/A
Applied egg-rr99.8%
+-commutativeN/A
distribute-rgt-neg-outN/A
unsub-negN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
Applied egg-rr99.8%
Final simplification99.8%
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(if (<= lambda2 1e+182)
(*
R
(hypot (* (- lambda1 lambda2) (cos (/ (+ phi2 phi1) 2.0))) (- phi1 phi2)))
(*
R
(hypot
(*
lambda2
(-
(* (sin (* phi1 0.5)) (sin (* phi2 0.5)))
(* (cos (* phi1 0.5)) (cos (* phi2 0.5)))))
(- phi1 phi2)))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (lambda2 <= 1e+182) {
tmp = R * hypot(((lambda1 - lambda2) * cos(((phi2 + phi1) / 2.0))), (phi1 - phi2));
} else {
tmp = R * hypot((lambda2 * ((sin((phi1 * 0.5)) * sin((phi2 * 0.5))) - (cos((phi1 * 0.5)) * cos((phi2 * 0.5))))), (phi1 - phi2));
}
return tmp;
}
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (lambda2 <= 1e+182) {
tmp = R * Math.hypot(((lambda1 - lambda2) * Math.cos(((phi2 + phi1) / 2.0))), (phi1 - phi2));
} else {
tmp = R * Math.hypot((lambda2 * ((Math.sin((phi1 * 0.5)) * Math.sin((phi2 * 0.5))) - (Math.cos((phi1 * 0.5)) * Math.cos((phi2 * 0.5))))), (phi1 - phi2));
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if lambda2 <= 1e+182: tmp = R * math.hypot(((lambda1 - lambda2) * math.cos(((phi2 + phi1) / 2.0))), (phi1 - phi2)) else: tmp = R * math.hypot((lambda2 * ((math.sin((phi1 * 0.5)) * math.sin((phi2 * 0.5))) - (math.cos((phi1 * 0.5)) * math.cos((phi2 * 0.5))))), (phi1 - phi2)) return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (lambda2 <= 1e+182) tmp = Float64(R * hypot(Float64(Float64(lambda1 - lambda2) * cos(Float64(Float64(phi2 + phi1) / 2.0))), Float64(phi1 - phi2))); else tmp = Float64(R * hypot(Float64(lambda2 * Float64(Float64(sin(Float64(phi1 * 0.5)) * sin(Float64(phi2 * 0.5))) - Float64(cos(Float64(phi1 * 0.5)) * cos(Float64(phi2 * 0.5))))), Float64(phi1 - phi2))); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (lambda2 <= 1e+182) tmp = R * hypot(((lambda1 - lambda2) * cos(((phi2 + phi1) / 2.0))), (phi1 - phi2)); else tmp = R * hypot((lambda2 * ((sin((phi1 * 0.5)) * sin((phi2 * 0.5))) - (cos((phi1 * 0.5)) * cos((phi2 * 0.5))))), (phi1 - phi2)); end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[lambda2, 1e+182], N[(R * N[Sqrt[N[(N[(lambda1 - lambda2), $MachinePrecision] * N[Cos[N[(N[(phi2 + phi1), $MachinePrecision] / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision], N[(R * N[Sqrt[N[(lambda2 * N[(N[(N[Sin[N[(phi1 * 0.5), $MachinePrecision]], $MachinePrecision] * N[Sin[N[(phi2 * 0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - N[(N[Cos[N[(phi1 * 0.5), $MachinePrecision]], $MachinePrecision] * N[Cos[N[(phi2 * 0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\lambda_2 \leq 10^{+182}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\left(\lambda_1 - \lambda_2\right) \cdot \cos \left(\frac{\phi_2 + \phi_1}{2}\right), \phi_1 - \phi_2\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\lambda_2 \cdot \left(\sin \left(\phi_1 \cdot 0.5\right) \cdot \sin \left(\phi_2 \cdot 0.5\right) - \cos \left(\phi_1 \cdot 0.5\right) \cdot \cos \left(\phi_2 \cdot 0.5\right)\right), \phi_1 - \phi_2\right)\\
\end{array}
\end{array}
if lambda2 < 1.0000000000000001e182Initial program 56.0%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6495.0%
Simplified95.0%
if 1.0000000000000001e182 < lambda2 Initial program 45.4%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6489.0%
Simplified89.0%
clear-numN/A
associate-/r/N/A
metadata-evalN/A
+-commutativeN/A
distribute-lft-inN/A
cos-sumN/A
*-commutativeN/A
*-commutativeN/A
*-commutativeN/A
fmm-defN/A
fma-lowering-fma.f64N/A
cos-lowering-cos.f64N/A
*-commutativeN/A
metadata-evalN/A
div-invN/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
metadata-evalN/A
div-invN/A
/-lowering-/.f64N/A
Applied egg-rr99.6%
distribute-rgt-inN/A
+-commutativeN/A
distribute-rgt-neg-inN/A
associate-*l*N/A
fma-defineN/A
fma-lowering-fma.f64N/A
Applied egg-rr99.6%
Taylor expanded in lambda1 around 0
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
distribute-lft-inN/A
*-lowering-*.f64N/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
Simplified87.1%
Final simplification94.2%
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(*
R
(hypot
(*
(- lambda1 lambda2)
(-
(* (cos (/ phi2 2.0)) (cos (/ phi1 2.0)))
(* (sin (/ phi2 2.0)) (sin (/ phi1 2.0)))))
(- phi1 phi2))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * hypot(((lambda1 - lambda2) * ((cos((phi2 / 2.0)) * cos((phi1 / 2.0))) - (sin((phi2 / 2.0)) * sin((phi1 / 2.0))))), (phi1 - phi2));
}
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * Math.hypot(((lambda1 - lambda2) * ((Math.cos((phi2 / 2.0)) * Math.cos((phi1 / 2.0))) - (Math.sin((phi2 / 2.0)) * Math.sin((phi1 / 2.0))))), (phi1 - phi2));
}
def code(R, lambda1, lambda2, phi1, phi2): return R * math.hypot(((lambda1 - lambda2) * ((math.cos((phi2 / 2.0)) * math.cos((phi1 / 2.0))) - (math.sin((phi2 / 2.0)) * math.sin((phi1 / 2.0))))), (phi1 - phi2))
function code(R, lambda1, lambda2, phi1, phi2) return Float64(R * hypot(Float64(Float64(lambda1 - lambda2) * Float64(Float64(cos(Float64(phi2 / 2.0)) * cos(Float64(phi1 / 2.0))) - Float64(sin(Float64(phi2 / 2.0)) * sin(Float64(phi1 / 2.0))))), Float64(phi1 - phi2))) end
function tmp = code(R, lambda1, lambda2, phi1, phi2) tmp = R * hypot(((lambda1 - lambda2) * ((cos((phi2 / 2.0)) * cos((phi1 / 2.0))) - (sin((phi2 / 2.0)) * sin((phi1 / 2.0))))), (phi1 - phi2)); end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := N[(R * N[Sqrt[N[(N[(lambda1 - lambda2), $MachinePrecision] * N[(N[(N[Cos[N[(phi2 / 2.0), $MachinePrecision]], $MachinePrecision] * N[Cos[N[(phi1 / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - N[(N[Sin[N[(phi2 / 2.0), $MachinePrecision]], $MachinePrecision] * N[Sin[N[(phi1 / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
R \cdot \mathsf{hypot}\left(\left(\lambda_1 - \lambda_2\right) \cdot \left(\cos \left(\frac{\phi_2}{2}\right) \cdot \cos \left(\frac{\phi_1}{2}\right) - \sin \left(\frac{\phi_2}{2}\right) \cdot \sin \left(\frac{\phi_1}{2}\right)\right), \phi_1 - \phi_2\right)
\end{array}
Initial program 54.9%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6494.4%
Simplified94.4%
clear-numN/A
associate-/r/N/A
metadata-evalN/A
+-commutativeN/A
distribute-rgt-inN/A
cos-sumN/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
*-commutativeN/A
metadata-evalN/A
div-invN/A
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
metadata-evalN/A
div-invN/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr99.8%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= phi2 0.052) (* R (hypot (* (- lambda1 lambda2) (cos (/ phi1 2.0))) (- phi1 phi2))) (* R (hypot (* (- lambda1 lambda2) (cos (/ phi2 2.0))) (- phi1 phi2)))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 0.052) {
tmp = R * hypot(((lambda1 - lambda2) * cos((phi1 / 2.0))), (phi1 - phi2));
} else {
tmp = R * hypot(((lambda1 - lambda2) * cos((phi2 / 2.0))), (phi1 - phi2));
}
return tmp;
}
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 0.052) {
tmp = R * Math.hypot(((lambda1 - lambda2) * Math.cos((phi1 / 2.0))), (phi1 - phi2));
} else {
tmp = R * Math.hypot(((lambda1 - lambda2) * Math.cos((phi2 / 2.0))), (phi1 - phi2));
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi2 <= 0.052: tmp = R * math.hypot(((lambda1 - lambda2) * math.cos((phi1 / 2.0))), (phi1 - phi2)) else: tmp = R * math.hypot(((lambda1 - lambda2) * math.cos((phi2 / 2.0))), (phi1 - phi2)) return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi2 <= 0.052) tmp = Float64(R * hypot(Float64(Float64(lambda1 - lambda2) * cos(Float64(phi1 / 2.0))), Float64(phi1 - phi2))); else tmp = Float64(R * hypot(Float64(Float64(lambda1 - lambda2) * cos(Float64(phi2 / 2.0))), Float64(phi1 - phi2))); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (phi2 <= 0.052) tmp = R * hypot(((lambda1 - lambda2) * cos((phi1 / 2.0))), (phi1 - phi2)); else tmp = R * hypot(((lambda1 - lambda2) * cos((phi2 / 2.0))), (phi1 - phi2)); end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi2, 0.052], N[(R * N[Sqrt[N[(N[(lambda1 - lambda2), $MachinePrecision] * N[Cos[N[(phi1 / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision], N[(R * N[Sqrt[N[(N[(lambda1 - lambda2), $MachinePrecision] * N[Cos[N[(phi2 / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_2 \leq 0.052:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\left(\lambda_1 - \lambda_2\right) \cdot \cos \left(\frac{\phi_1}{2}\right), \phi_1 - \phi_2\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\left(\lambda_1 - \lambda_2\right) \cdot \cos \left(\frac{\phi_2}{2}\right), \phi_1 - \phi_2\right)\\
\end{array}
\end{array}
if phi2 < 0.0519999999999999976Initial program 59.1%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6496.6%
Simplified96.6%
Taylor expanded in phi1 around inf
Simplified92.4%
if 0.0519999999999999976 < phi2 Initial program 41.6%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6487.6%
Simplified87.6%
Taylor expanded in phi1 around 0
Simplified87.4%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (* R (hypot (* (- lambda1 lambda2) (cos (/ (+ phi2 phi1) 2.0))) (- phi1 phi2))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * hypot(((lambda1 - lambda2) * cos(((phi2 + phi1) / 2.0))), (phi1 - phi2));
}
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * Math.hypot(((lambda1 - lambda2) * Math.cos(((phi2 + phi1) / 2.0))), (phi1 - phi2));
}
def code(R, lambda1, lambda2, phi1, phi2): return R * math.hypot(((lambda1 - lambda2) * math.cos(((phi2 + phi1) / 2.0))), (phi1 - phi2))
function code(R, lambda1, lambda2, phi1, phi2) return Float64(R * hypot(Float64(Float64(lambda1 - lambda2) * cos(Float64(Float64(phi2 + phi1) / 2.0))), Float64(phi1 - phi2))) end
function tmp = code(R, lambda1, lambda2, phi1, phi2) tmp = R * hypot(((lambda1 - lambda2) * cos(((phi2 + phi1) / 2.0))), (phi1 - phi2)); end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := N[(R * N[Sqrt[N[(N[(lambda1 - lambda2), $MachinePrecision] * N[Cos[N[(N[(phi2 + phi1), $MachinePrecision] / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
R \cdot \mathsf{hypot}\left(\left(\lambda_1 - \lambda_2\right) \cdot \cos \left(\frac{\phi_2 + \phi_1}{2}\right), \phi_1 - \phi_2\right)
\end{array}
Initial program 54.9%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6494.4%
Simplified94.4%
Final simplification94.4%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (* R (hypot (* (- lambda1 lambda2) (cos (/ phi1 2.0))) (- phi1 phi2))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * hypot(((lambda1 - lambda2) * cos((phi1 / 2.0))), (phi1 - phi2));
}
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * Math.hypot(((lambda1 - lambda2) * Math.cos((phi1 / 2.0))), (phi1 - phi2));
}
def code(R, lambda1, lambda2, phi1, phi2): return R * math.hypot(((lambda1 - lambda2) * math.cos((phi1 / 2.0))), (phi1 - phi2))
function code(R, lambda1, lambda2, phi1, phi2) return Float64(R * hypot(Float64(Float64(lambda1 - lambda2) * cos(Float64(phi1 / 2.0))), Float64(phi1 - phi2))) end
function tmp = code(R, lambda1, lambda2, phi1, phi2) tmp = R * hypot(((lambda1 - lambda2) * cos((phi1 / 2.0))), (phi1 - phi2)); end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := N[(R * N[Sqrt[N[(N[(lambda1 - lambda2), $MachinePrecision] * N[Cos[N[(phi1 / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
R \cdot \mathsf{hypot}\left(\left(\lambda_1 - \lambda_2\right) \cdot \cos \left(\frac{\phi_1}{2}\right), \phi_1 - \phi_2\right)
\end{array}
Initial program 54.9%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6494.4%
Simplified94.4%
Taylor expanded in phi1 around inf
Simplified88.4%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= phi2 2.15e+23) (* R (hypot phi1 (- lambda1 lambda2))) (* R (hypot lambda1 (- phi1 phi2)))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 2.15e+23) {
tmp = R * hypot(phi1, (lambda1 - lambda2));
} else {
tmp = R * hypot(lambda1, (phi1 - phi2));
}
return tmp;
}
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 2.15e+23) {
tmp = R * Math.hypot(phi1, (lambda1 - lambda2));
} else {
tmp = R * Math.hypot(lambda1, (phi1 - phi2));
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi2 <= 2.15e+23: tmp = R * math.hypot(phi1, (lambda1 - lambda2)) else: tmp = R * math.hypot(lambda1, (phi1 - phi2)) return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi2 <= 2.15e+23) tmp = Float64(R * hypot(phi1, Float64(lambda1 - lambda2))); else tmp = Float64(R * hypot(lambda1, Float64(phi1 - phi2))); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (phi2 <= 2.15e+23) tmp = R * hypot(phi1, (lambda1 - lambda2)); else tmp = R * hypot(lambda1, (phi1 - phi2)); end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi2, 2.15e+23], N[(R * N[Sqrt[phi1 ^ 2 + N[(lambda1 - lambda2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision], N[(R * N[Sqrt[lambda1 ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_2 \leq 2.15 \cdot 10^{+23}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\phi_1, \lambda_1 - \lambda_2\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\lambda_1, \phi_1 - \phi_2\right)\\
\end{array}
\end{array}
if phi2 < 2.1499999999999999e23Initial program 58.9%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6496.3%
Simplified96.3%
Taylor expanded in phi1 around 0
+-lowering-+.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6482.9%
Simplified82.9%
Taylor expanded in phi2 around 0
*-lowering-*.f64N/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
--lowering--.f6469.8%
Simplified69.8%
if 2.1499999999999999e23 < phi2 Initial program 40.5%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6487.7%
Simplified87.7%
Taylor expanded in phi1 around 0
+-lowering-+.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6475.7%
Simplified75.7%
Taylor expanded in phi2 around 0
--lowering--.f6477.5%
Simplified77.5%
Taylor expanded in lambda2 around 0
*-lowering-*.f64N/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
--lowering--.f6476.1%
Simplified76.1%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= lambda2 5.5e+150) (* R (hypot lambda1 (- phi1 phi2))) (* R (* lambda2 (- 1.0 (/ lambda1 lambda2))))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (lambda2 <= 5.5e+150) {
tmp = R * hypot(lambda1, (phi1 - phi2));
} else {
tmp = R * (lambda2 * (1.0 - (lambda1 / lambda2)));
}
return tmp;
}
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (lambda2 <= 5.5e+150) {
tmp = R * Math.hypot(lambda1, (phi1 - phi2));
} else {
tmp = R * (lambda2 * (1.0 - (lambda1 / lambda2)));
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if lambda2 <= 5.5e+150: tmp = R * math.hypot(lambda1, (phi1 - phi2)) else: tmp = R * (lambda2 * (1.0 - (lambda1 / lambda2))) return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (lambda2 <= 5.5e+150) tmp = Float64(R * hypot(lambda1, Float64(phi1 - phi2))); else tmp = Float64(R * Float64(lambda2 * Float64(1.0 - Float64(lambda1 / lambda2)))); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (lambda2 <= 5.5e+150) tmp = R * hypot(lambda1, (phi1 - phi2)); else tmp = R * (lambda2 * (1.0 - (lambda1 / lambda2))); end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[lambda2, 5.5e+150], N[(R * N[Sqrt[lambda1 ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision], N[(R * N[(lambda2 * N[(1.0 - N[(lambda1 / lambda2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\lambda_2 \leq 5.5 \cdot 10^{+150}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\lambda_1, \phi_1 - \phi_2\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \left(\lambda_2 \cdot \left(1 - \frac{\lambda_1}{\lambda_2}\right)\right)\\
\end{array}
\end{array}
if lambda2 < 5.50000000000000017e150Initial program 56.6%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6494.9%
Simplified94.9%
Taylor expanded in phi1 around 0
+-lowering-+.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6482.5%
Simplified82.5%
Taylor expanded in phi2 around 0
--lowering--.f6485.7%
Simplified85.7%
Taylor expanded in lambda2 around 0
*-lowering-*.f64N/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
--lowering--.f6473.7%
Simplified73.7%
if 5.50000000000000017e150 < lambda2 Initial program 41.2%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6490.1%
Simplified90.1%
Taylor expanded in phi1 around 0
+-lowering-+.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6472.0%
Simplified72.0%
Taylor expanded in phi2 around 0
--lowering--.f6462.4%
Simplified62.4%
Taylor expanded in lambda2 around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f6440.1%
Simplified40.1%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (* R (hypot (- lambda1 lambda2) (- phi1 phi2))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * hypot((lambda1 - lambda2), (phi1 - phi2));
}
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * Math.hypot((lambda1 - lambda2), (phi1 - phi2));
}
def code(R, lambda1, lambda2, phi1, phi2): return R * math.hypot((lambda1 - lambda2), (phi1 - phi2))
function code(R, lambda1, lambda2, phi1, phi2) return Float64(R * hypot(Float64(lambda1 - lambda2), Float64(phi1 - phi2))) end
function tmp = code(R, lambda1, lambda2, phi1, phi2) tmp = R * hypot((lambda1 - lambda2), (phi1 - phi2)); end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := N[(R * N[Sqrt[N[(lambda1 - lambda2), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
R \cdot \mathsf{hypot}\left(\lambda_1 - \lambda_2, \phi_1 - \phi_2\right)
\end{array}
Initial program 54.9%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6494.4%
Simplified94.4%
Taylor expanded in phi1 around 0
+-lowering-+.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6481.3%
Simplified81.3%
Taylor expanded in phi2 around 0
--lowering--.f6483.1%
Simplified83.1%
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(if (<= phi1 -3e+17)
(* phi1 (- (/ (* R phi2) phi1) R))
(if (<= phi1 2.55e-204)
(*
lambda1
(-
(/
(+
(* R lambda2)
(/ (* -0.5 (* R (* (- phi1 phi2) (- phi1 phi2)))) lambda1))
lambda1)
R))
(* R phi2))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi1 <= -3e+17) {
tmp = phi1 * (((R * phi2) / phi1) - R);
} else if (phi1 <= 2.55e-204) {
tmp = lambda1 * ((((R * lambda2) + ((-0.5 * (R * ((phi1 - phi2) * (phi1 - phi2)))) / lambda1)) / lambda1) - R);
} else {
tmp = R * phi2;
}
return tmp;
}
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: tmp
if (phi1 <= (-3d+17)) then
tmp = phi1 * (((r * phi2) / phi1) - r)
else if (phi1 <= 2.55d-204) then
tmp = lambda1 * ((((r * lambda2) + (((-0.5d0) * (r * ((phi1 - phi2) * (phi1 - phi2)))) / lambda1)) / lambda1) - r)
else
tmp = r * phi2
end if
code = tmp
end function
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi1 <= -3e+17) {
tmp = phi1 * (((R * phi2) / phi1) - R);
} else if (phi1 <= 2.55e-204) {
tmp = lambda1 * ((((R * lambda2) + ((-0.5 * (R * ((phi1 - phi2) * (phi1 - phi2)))) / lambda1)) / lambda1) - R);
} else {
tmp = R * phi2;
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi1 <= -3e+17: tmp = phi1 * (((R * phi2) / phi1) - R) elif phi1 <= 2.55e-204: tmp = lambda1 * ((((R * lambda2) + ((-0.5 * (R * ((phi1 - phi2) * (phi1 - phi2)))) / lambda1)) / lambda1) - R) else: tmp = R * phi2 return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi1 <= -3e+17) tmp = Float64(phi1 * Float64(Float64(Float64(R * phi2) / phi1) - R)); elseif (phi1 <= 2.55e-204) tmp = Float64(lambda1 * Float64(Float64(Float64(Float64(R * lambda2) + Float64(Float64(-0.5 * Float64(R * Float64(Float64(phi1 - phi2) * Float64(phi1 - phi2)))) / lambda1)) / lambda1) - R)); else tmp = Float64(R * phi2); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (phi1 <= -3e+17) tmp = phi1 * (((R * phi2) / phi1) - R); elseif (phi1 <= 2.55e-204) tmp = lambda1 * ((((R * lambda2) + ((-0.5 * (R * ((phi1 - phi2) * (phi1 - phi2)))) / lambda1)) / lambda1) - R); else tmp = R * phi2; end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi1, -3e+17], N[(phi1 * N[(N[(N[(R * phi2), $MachinePrecision] / phi1), $MachinePrecision] - R), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, 2.55e-204], N[(lambda1 * N[(N[(N[(N[(R * lambda2), $MachinePrecision] + N[(N[(-0.5 * N[(R * N[(N[(phi1 - phi2), $MachinePrecision] * N[(phi1 - phi2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / lambda1), $MachinePrecision]), $MachinePrecision] / lambda1), $MachinePrecision] - R), $MachinePrecision]), $MachinePrecision], N[(R * phi2), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_1 \leq -3 \cdot 10^{+17}:\\
\;\;\;\;\phi_1 \cdot \left(\frac{R \cdot \phi_2}{\phi_1} - R\right)\\
\mathbf{elif}\;\phi_1 \leq 2.55 \cdot 10^{-204}:\\
\;\;\;\;\lambda_1 \cdot \left(\frac{R \cdot \lambda_2 + \frac{-0.5 \cdot \left(R \cdot \left(\left(\phi_1 - \phi_2\right) \cdot \left(\phi_1 - \phi_2\right)\right)\right)}{\lambda_1}}{\lambda_1} - R\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \phi_2\\
\end{array}
\end{array}
if phi1 < -3e17Initial program 55.6%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6489.1%
Simplified89.1%
Taylor expanded in phi1 around -inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6460.2%
Simplified60.2%
if -3e17 < phi1 < 2.55000000000000014e-204Initial program 60.0%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6499.2%
Simplified99.2%
Taylor expanded in phi1 around 0
+-lowering-+.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6498.4%
Simplified98.4%
Taylor expanded in phi2 around 0
--lowering--.f6486.1%
Simplified86.1%
Taylor expanded in lambda1 around -inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
Simplified25.8%
if 2.55000000000000014e-204 < phi1 Initial program 50.9%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6493.7%
Simplified93.7%
Taylor expanded in phi2 around inf
*-lowering-*.f6412.5%
Simplified12.5%
Final simplification27.9%
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(if (<= phi1 -4.2e+17)
(* phi1 (- (/ (* R phi2) phi1) R))
(if (<= phi1 3.3e-204)
(*
R
(*
lambda1
(+
(/
(+ lambda2 (/ (* -0.5 (* (- phi1 phi2) (- phi1 phi2))) lambda1))
lambda1)
-1.0)))
(* R phi2))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi1 <= -4.2e+17) {
tmp = phi1 * (((R * phi2) / phi1) - R);
} else if (phi1 <= 3.3e-204) {
tmp = R * (lambda1 * (((lambda2 + ((-0.5 * ((phi1 - phi2) * (phi1 - phi2))) / lambda1)) / lambda1) + -1.0));
} else {
tmp = R * phi2;
}
return tmp;
}
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: tmp
if (phi1 <= (-4.2d+17)) then
tmp = phi1 * (((r * phi2) / phi1) - r)
else if (phi1 <= 3.3d-204) then
tmp = r * (lambda1 * (((lambda2 + (((-0.5d0) * ((phi1 - phi2) * (phi1 - phi2))) / lambda1)) / lambda1) + (-1.0d0)))
else
tmp = r * phi2
end if
code = tmp
end function
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi1 <= -4.2e+17) {
tmp = phi1 * (((R * phi2) / phi1) - R);
} else if (phi1 <= 3.3e-204) {
tmp = R * (lambda1 * (((lambda2 + ((-0.5 * ((phi1 - phi2) * (phi1 - phi2))) / lambda1)) / lambda1) + -1.0));
} else {
tmp = R * phi2;
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi1 <= -4.2e+17: tmp = phi1 * (((R * phi2) / phi1) - R) elif phi1 <= 3.3e-204: tmp = R * (lambda1 * (((lambda2 + ((-0.5 * ((phi1 - phi2) * (phi1 - phi2))) / lambda1)) / lambda1) + -1.0)) else: tmp = R * phi2 return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi1 <= -4.2e+17) tmp = Float64(phi1 * Float64(Float64(Float64(R * phi2) / phi1) - R)); elseif (phi1 <= 3.3e-204) tmp = Float64(R * Float64(lambda1 * Float64(Float64(Float64(lambda2 + Float64(Float64(-0.5 * Float64(Float64(phi1 - phi2) * Float64(phi1 - phi2))) / lambda1)) / lambda1) + -1.0))); else tmp = Float64(R * phi2); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (phi1 <= -4.2e+17) tmp = phi1 * (((R * phi2) / phi1) - R); elseif (phi1 <= 3.3e-204) tmp = R * (lambda1 * (((lambda2 + ((-0.5 * ((phi1 - phi2) * (phi1 - phi2))) / lambda1)) / lambda1) + -1.0)); else tmp = R * phi2; end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi1, -4.2e+17], N[(phi1 * N[(N[(N[(R * phi2), $MachinePrecision] / phi1), $MachinePrecision] - R), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, 3.3e-204], N[(R * N[(lambda1 * N[(N[(N[(lambda2 + N[(N[(-0.5 * N[(N[(phi1 - phi2), $MachinePrecision] * N[(phi1 - phi2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / lambda1), $MachinePrecision]), $MachinePrecision] / lambda1), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(R * phi2), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_1 \leq -4.2 \cdot 10^{+17}:\\
\;\;\;\;\phi_1 \cdot \left(\frac{R \cdot \phi_2}{\phi_1} - R\right)\\
\mathbf{elif}\;\phi_1 \leq 3.3 \cdot 10^{-204}:\\
\;\;\;\;R \cdot \left(\lambda_1 \cdot \left(\frac{\lambda_2 + \frac{-0.5 \cdot \left(\left(\phi_1 - \phi_2\right) \cdot \left(\phi_1 - \phi_2\right)\right)}{\lambda_1}}{\lambda_1} + -1\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \phi_2\\
\end{array}
\end{array}
if phi1 < -4.2e17Initial program 55.6%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6489.1%
Simplified89.1%
Taylor expanded in phi1 around -inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6460.2%
Simplified60.2%
if -4.2e17 < phi1 < 3.30000000000000009e-204Initial program 60.0%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6499.2%
Simplified99.2%
Taylor expanded in phi1 around 0
+-lowering-+.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6498.4%
Simplified98.4%
Taylor expanded in phi2 around 0
--lowering--.f6486.1%
Simplified86.1%
Taylor expanded in lambda1 around -inf
associate-*r*N/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f6428.0%
Simplified28.0%
if 3.30000000000000009e-204 < phi1 Initial program 50.9%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6493.7%
Simplified93.7%
Taylor expanded in phi2 around inf
*-lowering-*.f6412.5%
Simplified12.5%
Final simplification28.6%
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(if (<= phi1 -3.2e+17)
(* phi1 (- (/ (* R phi2) phi1) R))
(if (<= phi1 3.5e-204)
(* lambda2 (- R (/ (* R lambda1) lambda2)))
(* R phi2))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi1 <= -3.2e+17) {
tmp = phi1 * (((R * phi2) / phi1) - R);
} else if (phi1 <= 3.5e-204) {
tmp = lambda2 * (R - ((R * lambda1) / lambda2));
} else {
tmp = R * phi2;
}
return tmp;
}
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: tmp
if (phi1 <= (-3.2d+17)) then
tmp = phi1 * (((r * phi2) / phi1) - r)
else if (phi1 <= 3.5d-204) then
tmp = lambda2 * (r - ((r * lambda1) / lambda2))
else
tmp = r * phi2
end if
code = tmp
end function
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi1 <= -3.2e+17) {
tmp = phi1 * (((R * phi2) / phi1) - R);
} else if (phi1 <= 3.5e-204) {
tmp = lambda2 * (R - ((R * lambda1) / lambda2));
} else {
tmp = R * phi2;
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi1 <= -3.2e+17: tmp = phi1 * (((R * phi2) / phi1) - R) elif phi1 <= 3.5e-204: tmp = lambda2 * (R - ((R * lambda1) / lambda2)) else: tmp = R * phi2 return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi1 <= -3.2e+17) tmp = Float64(phi1 * Float64(Float64(Float64(R * phi2) / phi1) - R)); elseif (phi1 <= 3.5e-204) tmp = Float64(lambda2 * Float64(R - Float64(Float64(R * lambda1) / lambda2))); else tmp = Float64(R * phi2); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (phi1 <= -3.2e+17) tmp = phi1 * (((R * phi2) / phi1) - R); elseif (phi1 <= 3.5e-204) tmp = lambda2 * (R - ((R * lambda1) / lambda2)); else tmp = R * phi2; end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi1, -3.2e+17], N[(phi1 * N[(N[(N[(R * phi2), $MachinePrecision] / phi1), $MachinePrecision] - R), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, 3.5e-204], N[(lambda2 * N[(R - N[(N[(R * lambda1), $MachinePrecision] / lambda2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(R * phi2), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_1 \leq -3.2 \cdot 10^{+17}:\\
\;\;\;\;\phi_1 \cdot \left(\frac{R \cdot \phi_2}{\phi_1} - R\right)\\
\mathbf{elif}\;\phi_1 \leq 3.5 \cdot 10^{-204}:\\
\;\;\;\;\lambda_2 \cdot \left(R - \frac{R \cdot \lambda_1}{\lambda_2}\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \phi_2\\
\end{array}
\end{array}
if phi1 < -3.2e17Initial program 55.6%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6489.1%
Simplified89.1%
Taylor expanded in phi1 around -inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6460.2%
Simplified60.2%
if -3.2e17 < phi1 < 3.50000000000000027e-204Initial program 60.0%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6499.2%
Simplified99.2%
Taylor expanded in phi1 around 0
+-lowering-+.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6498.4%
Simplified98.4%
Taylor expanded in phi2 around 0
--lowering--.f6486.1%
Simplified86.1%
Taylor expanded in lambda2 around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6426.3%
Simplified26.3%
if 3.50000000000000027e-204 < phi1 Initial program 50.9%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6493.7%
Simplified93.7%
Taylor expanded in phi2 around inf
*-lowering-*.f6412.5%
Simplified12.5%
Final simplification28.1%
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(if (<= phi2 -1.2e-224)
(* phi1 (- 0.0 R))
(if (<= phi2 1.75e+25)
(* lambda2 (- R (/ (* R lambda1) lambda2)))
(* R (* phi2 (- 1.0 (/ phi1 phi2)))))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= -1.2e-224) {
tmp = phi1 * (0.0 - R);
} else if (phi2 <= 1.75e+25) {
tmp = lambda2 * (R - ((R * lambda1) / lambda2));
} else {
tmp = R * (phi2 * (1.0 - (phi1 / phi2)));
}
return tmp;
}
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: tmp
if (phi2 <= (-1.2d-224)) then
tmp = phi1 * (0.0d0 - r)
else if (phi2 <= 1.75d+25) then
tmp = lambda2 * (r - ((r * lambda1) / lambda2))
else
tmp = r * (phi2 * (1.0d0 - (phi1 / phi2)))
end if
code = tmp
end function
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= -1.2e-224) {
tmp = phi1 * (0.0 - R);
} else if (phi2 <= 1.75e+25) {
tmp = lambda2 * (R - ((R * lambda1) / lambda2));
} else {
tmp = R * (phi2 * (1.0 - (phi1 / phi2)));
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi2 <= -1.2e-224: tmp = phi1 * (0.0 - R) elif phi2 <= 1.75e+25: tmp = lambda2 * (R - ((R * lambda1) / lambda2)) else: tmp = R * (phi2 * (1.0 - (phi1 / phi2))) return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi2 <= -1.2e-224) tmp = Float64(phi1 * Float64(0.0 - R)); elseif (phi2 <= 1.75e+25) tmp = Float64(lambda2 * Float64(R - Float64(Float64(R * lambda1) / lambda2))); else tmp = Float64(R * Float64(phi2 * Float64(1.0 - Float64(phi1 / phi2)))); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (phi2 <= -1.2e-224) tmp = phi1 * (0.0 - R); elseif (phi2 <= 1.75e+25) tmp = lambda2 * (R - ((R * lambda1) / lambda2)); else tmp = R * (phi2 * (1.0 - (phi1 / phi2))); end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi2, -1.2e-224], N[(phi1 * N[(0.0 - R), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi2, 1.75e+25], N[(lambda2 * N[(R - N[(N[(R * lambda1), $MachinePrecision] / lambda2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(R * N[(phi2 * N[(1.0 - N[(phi1 / phi2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_2 \leq -1.2 \cdot 10^{-224}:\\
\;\;\;\;\phi_1 \cdot \left(0 - R\right)\\
\mathbf{elif}\;\phi_2 \leq 1.75 \cdot 10^{+25}:\\
\;\;\;\;\lambda_2 \cdot \left(R - \frac{R \cdot \lambda_1}{\lambda_2}\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \left(\phi_2 \cdot \left(1 - \frac{\phi_1}{\phi_2}\right)\right)\\
\end{array}
\end{array}
if phi2 < -1.20000000000000007e-224Initial program 59.5%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6495.0%
Simplified95.0%
Taylor expanded in phi1 around -inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-lowering-*.f6413.3%
Simplified13.3%
sub0-negN/A
neg-lowering-neg.f64N/A
*-commutativeN/A
*-lowering-*.f6413.3%
Applied egg-rr13.3%
if -1.20000000000000007e-224 < phi2 < 1.75e25Initial program 58.2%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6498.0%
Simplified98.0%
Taylor expanded in phi1 around 0
+-lowering-+.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6481.3%
Simplified81.3%
Taylor expanded in phi2 around 0
--lowering--.f6486.6%
Simplified86.6%
Taylor expanded in lambda2 around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6424.6%
Simplified24.6%
if 1.75e25 < phi2 Initial program 40.5%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6487.7%
Simplified87.7%
Taylor expanded in phi2 around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f6465.1%
Simplified65.1%
Final simplification28.4%
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(if (<= phi2 -2.2e-219)
(* phi1 (- 0.0 R))
(if (<= phi2 2.15e+23)
(* R (* lambda2 (- 1.0 (/ lambda1 lambda2))))
(* R (* phi2 (- 1.0 (/ phi1 phi2)))))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= -2.2e-219) {
tmp = phi1 * (0.0 - R);
} else if (phi2 <= 2.15e+23) {
tmp = R * (lambda2 * (1.0 - (lambda1 / lambda2)));
} else {
tmp = R * (phi2 * (1.0 - (phi1 / phi2)));
}
return tmp;
}
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: tmp
if (phi2 <= (-2.2d-219)) then
tmp = phi1 * (0.0d0 - r)
else if (phi2 <= 2.15d+23) then
tmp = r * (lambda2 * (1.0d0 - (lambda1 / lambda2)))
else
tmp = r * (phi2 * (1.0d0 - (phi1 / phi2)))
end if
code = tmp
end function
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= -2.2e-219) {
tmp = phi1 * (0.0 - R);
} else if (phi2 <= 2.15e+23) {
tmp = R * (lambda2 * (1.0 - (lambda1 / lambda2)));
} else {
tmp = R * (phi2 * (1.0 - (phi1 / phi2)));
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi2 <= -2.2e-219: tmp = phi1 * (0.0 - R) elif phi2 <= 2.15e+23: tmp = R * (lambda2 * (1.0 - (lambda1 / lambda2))) else: tmp = R * (phi2 * (1.0 - (phi1 / phi2))) return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi2 <= -2.2e-219) tmp = Float64(phi1 * Float64(0.0 - R)); elseif (phi2 <= 2.15e+23) tmp = Float64(R * Float64(lambda2 * Float64(1.0 - Float64(lambda1 / lambda2)))); else tmp = Float64(R * Float64(phi2 * Float64(1.0 - Float64(phi1 / phi2)))); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (phi2 <= -2.2e-219) tmp = phi1 * (0.0 - R); elseif (phi2 <= 2.15e+23) tmp = R * (lambda2 * (1.0 - (lambda1 / lambda2))); else tmp = R * (phi2 * (1.0 - (phi1 / phi2))); end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi2, -2.2e-219], N[(phi1 * N[(0.0 - R), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi2, 2.15e+23], N[(R * N[(lambda2 * N[(1.0 - N[(lambda1 / lambda2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(R * N[(phi2 * N[(1.0 - N[(phi1 / phi2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_2 \leq -2.2 \cdot 10^{-219}:\\
\;\;\;\;\phi_1 \cdot \left(0 - R\right)\\
\mathbf{elif}\;\phi_2 \leq 2.15 \cdot 10^{+23}:\\
\;\;\;\;R \cdot \left(\lambda_2 \cdot \left(1 - \frac{\lambda_1}{\lambda_2}\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \left(\phi_2 \cdot \left(1 - \frac{\phi_1}{\phi_2}\right)\right)\\
\end{array}
\end{array}
if phi2 < -2.1999999999999999e-219Initial program 59.5%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6495.0%
Simplified95.0%
Taylor expanded in phi1 around -inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-lowering-*.f6413.3%
Simplified13.3%
sub0-negN/A
neg-lowering-neg.f64N/A
*-commutativeN/A
*-lowering-*.f6413.3%
Applied egg-rr13.3%
if -2.1999999999999999e-219 < phi2 < 2.1499999999999999e23Initial program 58.2%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6498.0%
Simplified98.0%
Taylor expanded in phi1 around 0
+-lowering-+.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6481.3%
Simplified81.3%
Taylor expanded in phi2 around 0
--lowering--.f6486.6%
Simplified86.6%
Taylor expanded in lambda2 around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f6424.4%
Simplified24.4%
if 2.1499999999999999e23 < phi2 Initial program 40.5%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6487.7%
Simplified87.7%
Taylor expanded in phi2 around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f6465.1%
Simplified65.1%
Final simplification28.3%
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(if (<= phi2 -6.6e-220)
(* phi1 (- 0.0 R))
(if (<= phi2 1.9e+23)
(* R (* lambda2 (- 1.0 (/ lambda1 lambda2))))
(* R phi2))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= -6.6e-220) {
tmp = phi1 * (0.0 - R);
} else if (phi2 <= 1.9e+23) {
tmp = R * (lambda2 * (1.0 - (lambda1 / lambda2)));
} else {
tmp = R * phi2;
}
return tmp;
}
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
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 <= (-6.6d-220)) then
tmp = phi1 * (0.0d0 - r)
else if (phi2 <= 1.9d+23) then
tmp = r * (lambda2 * (1.0d0 - (lambda1 / lambda2)))
else
tmp = r * phi2
end if
code = tmp
end function
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= -6.6e-220) {
tmp = phi1 * (0.0 - R);
} else if (phi2 <= 1.9e+23) {
tmp = R * (lambda2 * (1.0 - (lambda1 / lambda2)));
} else {
tmp = R * phi2;
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi2 <= -6.6e-220: tmp = phi1 * (0.0 - R) elif phi2 <= 1.9e+23: tmp = R * (lambda2 * (1.0 - (lambda1 / lambda2))) else: tmp = R * phi2 return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi2 <= -6.6e-220) tmp = Float64(phi1 * Float64(0.0 - R)); elseif (phi2 <= 1.9e+23) tmp = Float64(R * Float64(lambda2 * Float64(1.0 - Float64(lambda1 / lambda2)))); else tmp = Float64(R * phi2); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (phi2 <= -6.6e-220) tmp = phi1 * (0.0 - R); elseif (phi2 <= 1.9e+23) tmp = R * (lambda2 * (1.0 - (lambda1 / lambda2))); else tmp = R * phi2; end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi2, -6.6e-220], N[(phi1 * N[(0.0 - R), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi2, 1.9e+23], N[(R * N[(lambda2 * N[(1.0 - N[(lambda1 / lambda2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(R * phi2), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_2 \leq -6.6 \cdot 10^{-220}:\\
\;\;\;\;\phi_1 \cdot \left(0 - R\right)\\
\mathbf{elif}\;\phi_2 \leq 1.9 \cdot 10^{+23}:\\
\;\;\;\;R \cdot \left(\lambda_2 \cdot \left(1 - \frac{\lambda_1}{\lambda_2}\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \phi_2\\
\end{array}
\end{array}
if phi2 < -6.59999999999999999e-220Initial program 59.5%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6495.0%
Simplified95.0%
Taylor expanded in phi1 around -inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-lowering-*.f6413.3%
Simplified13.3%
sub0-negN/A
neg-lowering-neg.f64N/A
*-commutativeN/A
*-lowering-*.f6413.3%
Applied egg-rr13.3%
if -6.59999999999999999e-220 < phi2 < 1.89999999999999987e23Initial program 58.2%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6498.0%
Simplified98.0%
Taylor expanded in phi1 around 0
+-lowering-+.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6481.3%
Simplified81.3%
Taylor expanded in phi2 around 0
--lowering--.f6486.6%
Simplified86.6%
Taylor expanded in lambda2 around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f6424.4%
Simplified24.4%
if 1.89999999999999987e23 < phi2 Initial program 40.5%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6487.7%
Simplified87.7%
Taylor expanded in phi2 around inf
*-lowering-*.f6463.5%
Simplified63.5%
Final simplification28.0%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= phi1 -2.65e+45) (* phi1 (- 0.0 R)) (if (<= phi1 -3.4e-145) (- 0.0 (* R lambda1)) (* R phi2))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi1 <= -2.65e+45) {
tmp = phi1 * (0.0 - R);
} else if (phi1 <= -3.4e-145) {
tmp = 0.0 - (R * lambda1);
} else {
tmp = R * phi2;
}
return tmp;
}
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: tmp
if (phi1 <= (-2.65d+45)) then
tmp = phi1 * (0.0d0 - r)
else if (phi1 <= (-3.4d-145)) then
tmp = 0.0d0 - (r * lambda1)
else
tmp = r * phi2
end if
code = tmp
end function
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi1 <= -2.65e+45) {
tmp = phi1 * (0.0 - R);
} else if (phi1 <= -3.4e-145) {
tmp = 0.0 - (R * lambda1);
} else {
tmp = R * phi2;
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi1 <= -2.65e+45: tmp = phi1 * (0.0 - R) elif phi1 <= -3.4e-145: tmp = 0.0 - (R * lambda1) else: tmp = R * phi2 return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi1 <= -2.65e+45) tmp = Float64(phi1 * Float64(0.0 - R)); elseif (phi1 <= -3.4e-145) tmp = Float64(0.0 - Float64(R * lambda1)); else tmp = Float64(R * phi2); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (phi1 <= -2.65e+45) tmp = phi1 * (0.0 - R); elseif (phi1 <= -3.4e-145) tmp = 0.0 - (R * lambda1); else tmp = R * phi2; end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi1, -2.65e+45], N[(phi1 * N[(0.0 - R), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, -3.4e-145], N[(0.0 - N[(R * lambda1), $MachinePrecision]), $MachinePrecision], N[(R * phi2), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_1 \leq -2.65 \cdot 10^{+45}:\\
\;\;\;\;\phi_1 \cdot \left(0 - R\right)\\
\mathbf{elif}\;\phi_1 \leq -3.4 \cdot 10^{-145}:\\
\;\;\;\;0 - R \cdot \lambda_1\\
\mathbf{else}:\\
\;\;\;\;R \cdot \phi_2\\
\end{array}
\end{array}
if phi1 < -2.64999999999999996e45Initial program 55.5%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6488.7%
Simplified88.7%
Taylor expanded in phi1 around -inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-lowering-*.f6456.3%
Simplified56.3%
sub0-negN/A
neg-lowering-neg.f64N/A
*-commutativeN/A
*-lowering-*.f6456.3%
Applied egg-rr56.3%
if -2.64999999999999996e45 < phi1 < -3.3999999999999999e-145Initial program 63.7%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6496.9%
Simplified96.9%
Taylor expanded in phi1 around 0
+-lowering-+.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6492.6%
Simplified92.6%
Taylor expanded in phi2 around 0
--lowering--.f6484.6%
Simplified84.6%
Taylor expanded in lambda1 around -inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6410.9%
Simplified10.9%
if -3.3999999999999999e-145 < phi1 Initial program 52.5%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6495.6%
Simplified95.6%
Taylor expanded in phi2 around inf
*-lowering-*.f6415.8%
Simplified15.8%
Final simplification23.2%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= phi2 3.5e+39) (* phi1 (- 0.0 R)) (* R phi2)))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 3.5e+39) {
tmp = phi1 * (0.0 - R);
} else {
tmp = R * phi2;
}
return tmp;
}
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
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 <= 3.5d+39) then
tmp = phi1 * (0.0d0 - r)
else
tmp = r * phi2
end if
code = tmp
end function
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 3.5e+39) {
tmp = phi1 * (0.0 - R);
} else {
tmp = R * phi2;
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi2 <= 3.5e+39: tmp = phi1 * (0.0 - R) else: tmp = R * phi2 return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi2 <= 3.5e+39) tmp = Float64(phi1 * Float64(0.0 - R)); else tmp = Float64(R * phi2); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (phi2 <= 3.5e+39) tmp = phi1 * (0.0 - R); else tmp = R * phi2; end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi2, 3.5e+39], N[(phi1 * N[(0.0 - R), $MachinePrecision]), $MachinePrecision], N[(R * phi2), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_2 \leq 3.5 \cdot 10^{+39}:\\
\;\;\;\;\phi_1 \cdot \left(0 - R\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \phi_2\\
\end{array}
\end{array}
if phi2 < 3.5000000000000002e39Initial program 59.3%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6496.3%
Simplified96.3%
Taylor expanded in phi1 around -inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-lowering-*.f6416.4%
Simplified16.4%
sub0-negN/A
neg-lowering-neg.f64N/A
*-commutativeN/A
*-lowering-*.f6416.4%
Applied egg-rr16.4%
if 3.5000000000000002e39 < phi2 Initial program 38.3%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6487.2%
Simplified87.2%
Taylor expanded in phi2 around inf
*-lowering-*.f6463.8%
Simplified63.8%
Final simplification26.4%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= phi2 2.2e+23) (* R lambda2) (* R phi2)))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 2.2e+23) {
tmp = R * lambda2;
} else {
tmp = R * phi2;
}
return tmp;
}
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: tmp
if (phi2 <= 2.2d+23) then
tmp = r * lambda2
else
tmp = r * phi2
end if
code = tmp
end function
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 2.2e+23) {
tmp = R * lambda2;
} else {
tmp = R * phi2;
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi2 <= 2.2e+23: tmp = R * lambda2 else: tmp = R * phi2 return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi2 <= 2.2e+23) tmp = Float64(R * lambda2); else tmp = Float64(R * phi2); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (phi2 <= 2.2e+23) tmp = R * lambda2; else tmp = R * phi2; end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi2, 2.2e+23], N[(R * lambda2), $MachinePrecision], N[(R * phi2), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_2 \leq 2.2 \cdot 10^{+23}:\\
\;\;\;\;R \cdot \lambda_2\\
\mathbf{else}:\\
\;\;\;\;R \cdot \phi_2\\
\end{array}
\end{array}
if phi2 < 2.20000000000000008e23Initial program 58.9%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6496.3%
Simplified96.3%
Taylor expanded in phi1 around 0
+-lowering-+.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6482.9%
Simplified82.9%
Taylor expanded in phi2 around 0
--lowering--.f6484.6%
Simplified84.6%
Taylor expanded in lambda2 around inf
*-commutativeN/A
*-lowering-*.f6414.5%
Simplified14.5%
if 2.20000000000000008e23 < phi2 Initial program 40.5%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6487.7%
Simplified87.7%
Taylor expanded in phi2 around inf
*-lowering-*.f6463.5%
Simplified63.5%
Final simplification25.2%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (* R phi2))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * phi2;
}
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
code = r * phi2
end function
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * phi2;
}
def code(R, lambda1, lambda2, phi1, phi2): return R * phi2
function code(R, lambda1, lambda2, phi1, phi2) return Float64(R * phi2) end
function tmp = code(R, lambda1, lambda2, phi1, phi2) tmp = R * phi2; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := N[(R * phi2), $MachinePrecision]
\begin{array}{l}
\\
R \cdot \phi_2
\end{array}
Initial program 54.9%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6494.4%
Simplified94.4%
Taylor expanded in phi2 around inf
*-lowering-*.f6416.4%
Simplified16.4%
herbie shell --seed 2024164
(FPCore (R lambda1 lambda2 phi1 phi2)
:name "Equirectangular approximation to distance on a great circle"
:precision binary64
(* R (sqrt (+ (* (* (- lambda1 lambda2) (cos (/ (+ phi1 phi2) 2.0))) (* (- lambda1 lambda2) (cos (/ (+ phi1 phi2) 2.0)))) (* (- phi1 phi2) (- phi1 phi2))))))