
(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 15 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 (* (- lambda1 lambda2) (cos (/ (+ phi1 phi2) 2.0))) (- phi1 phi2))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * hypot(((lambda1 - lambda2) * cos(((phi1 + phi2) / 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 + phi2) / 2.0))), (phi1 - phi2));
}
def code(R, lambda1, lambda2, phi1, phi2): return R * math.hypot(((lambda1 - lambda2) * math.cos(((phi1 + phi2) / 2.0))), (phi1 - phi2))
function code(R, lambda1, lambda2, phi1, phi2) return Float64(R * hypot(Float64(Float64(lambda1 - lambda2) * cos(Float64(Float64(phi1 + phi2) / 2.0))), Float64(phi1 - phi2))) end
function tmp = code(R, lambda1, lambda2, phi1, phi2) tmp = R * hypot(((lambda1 - lambda2) * cos(((phi1 + phi2) / 2.0))), (phi1 - phi2)); end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := N[(R * N[Sqrt[N[(N[(lambda1 - lambda2), $MachinePrecision] * N[Cos[N[(N[(phi1 + phi2), $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_1 + \phi_2}{2}\right), \phi_1 - \phi_2\right)
\end{array}
Initial program 57.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--.f6497.4%
Simplified97.4%
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(if (<= lambda2 5e-196)
(* R (hypot (* lambda1 (cos (* phi1 0.5))) (- phi1 phi2)))
(if (<= lambda2 7e+156)
(* R (hypot (- lambda1 lambda2) (- phi1 phi2)))
(* (* R lambda2) (sqrt (+ 0.5 (* 0.5 (cos (+ phi1 phi2)))))))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (lambda2 <= 5e-196) {
tmp = R * hypot((lambda1 * cos((phi1 * 0.5))), (phi1 - phi2));
} else if (lambda2 <= 7e+156) {
tmp = R * hypot((lambda1 - lambda2), (phi1 - phi2));
} else {
tmp = (R * lambda2) * sqrt((0.5 + (0.5 * cos((phi1 + phi2)))));
}
return tmp;
}
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (lambda2 <= 5e-196) {
tmp = R * Math.hypot((lambda1 * Math.cos((phi1 * 0.5))), (phi1 - phi2));
} else if (lambda2 <= 7e+156) {
tmp = R * Math.hypot((lambda1 - lambda2), (phi1 - phi2));
} else {
tmp = (R * lambda2) * Math.sqrt((0.5 + (0.5 * Math.cos((phi1 + phi2)))));
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if lambda2 <= 5e-196: tmp = R * math.hypot((lambda1 * math.cos((phi1 * 0.5))), (phi1 - phi2)) elif lambda2 <= 7e+156: tmp = R * math.hypot((lambda1 - lambda2), (phi1 - phi2)) else: tmp = (R * lambda2) * math.sqrt((0.5 + (0.5 * math.cos((phi1 + phi2))))) return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (lambda2 <= 5e-196) tmp = Float64(R * hypot(Float64(lambda1 * cos(Float64(phi1 * 0.5))), Float64(phi1 - phi2))); elseif (lambda2 <= 7e+156) tmp = Float64(R * hypot(Float64(lambda1 - lambda2), Float64(phi1 - phi2))); else tmp = Float64(Float64(R * lambda2) * sqrt(Float64(0.5 + Float64(0.5 * cos(Float64(phi1 + phi2)))))); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (lambda2 <= 5e-196) tmp = R * hypot((lambda1 * cos((phi1 * 0.5))), (phi1 - phi2)); elseif (lambda2 <= 7e+156) tmp = R * hypot((lambda1 - lambda2), (phi1 - phi2)); else tmp = (R * lambda2) * sqrt((0.5 + (0.5 * cos((phi1 + phi2))))); end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[lambda2, 5e-196], N[(R * N[Sqrt[N[(lambda1 * N[Cos[N[(phi1 * 0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision], If[LessEqual[lambda2, 7e+156], N[(R * N[Sqrt[N[(lambda1 - lambda2), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision], N[(N[(R * lambda2), $MachinePrecision] * N[Sqrt[N[(0.5 + N[(0.5 * N[Cos[N[(phi1 + phi2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\lambda_2 \leq 5 \cdot 10^{-196}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\lambda_1 \cdot \cos \left(\phi_1 \cdot 0.5\right), \phi_1 - \phi_2\right)\\
\mathbf{elif}\;\lambda_2 \leq 7 \cdot 10^{+156}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\lambda_1 - \lambda_2, \phi_1 - \phi_2\right)\\
\mathbf{else}:\\
\;\;\;\;\left(R \cdot \lambda_2\right) \cdot \sqrt{0.5 + 0.5 \cdot \cos \left(\phi_1 + \phi_2\right)}\\
\end{array}
\end{array}
if lambda2 < 5.0000000000000005e-196Initial program 56.8%
*-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--.f6497.3%
Simplified97.3%
Taylor expanded in phi2 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6490.4%
Simplified90.4%
Taylor expanded in lambda1 around inf
*-commutativeN/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6475.2%
Simplified75.2%
if 5.0000000000000005e-196 < lambda2 < 7.0000000000000006e156Initial program 63.8%
*-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.9%
Simplified99.9%
Taylor expanded in phi2 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6495.1%
Simplified95.1%
Taylor expanded in phi1 around 0
--lowering--.f6492.0%
Simplified92.0%
if 7.0000000000000006e156 < lambda2 Initial program 45.8%
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
--lowering--.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr45.8%
Taylor expanded in lambda2 around inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
+-commutativeN/A
+-lowering-+.f6481.8%
Simplified81.8%
Final simplification80.4%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= phi2 5e-29) (* R (hypot (* (- lambda1 lambda2) (cos (* phi1 0.5))) (- phi1 phi2))) (* R (hypot (* (- lambda1 lambda2) (cos (* phi2 0.5))) (- phi1 phi2)))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 5e-29) {
tmp = R * hypot(((lambda1 - lambda2) * cos((phi1 * 0.5))), (phi1 - phi2));
} else {
tmp = R * hypot(((lambda1 - lambda2) * 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 (phi2 <= 5e-29) {
tmp = R * Math.hypot(((lambda1 - lambda2) * Math.cos((phi1 * 0.5))), (phi1 - phi2));
} else {
tmp = R * Math.hypot(((lambda1 - lambda2) * Math.cos((phi2 * 0.5))), (phi1 - phi2));
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi2 <= 5e-29: tmp = R * math.hypot(((lambda1 - lambda2) * math.cos((phi1 * 0.5))), (phi1 - phi2)) else: tmp = R * math.hypot(((lambda1 - lambda2) * math.cos((phi2 * 0.5))), (phi1 - phi2)) return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi2 <= 5e-29) tmp = Float64(R * hypot(Float64(Float64(lambda1 - lambda2) * cos(Float64(phi1 * 0.5))), Float64(phi1 - phi2))); else tmp = Float64(R * hypot(Float64(Float64(lambda1 - lambda2) * 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 (phi2 <= 5e-29) tmp = R * hypot(((lambda1 - lambda2) * cos((phi1 * 0.5))), (phi1 - phi2)); else tmp = R * hypot(((lambda1 - lambda2) * cos((phi2 * 0.5))), (phi1 - phi2)); end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi2, 5e-29], N[(R * N[Sqrt[N[(N[(lambda1 - lambda2), $MachinePrecision] * N[Cos[N[(phi1 * 0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision], N[(R * N[Sqrt[N[(N[(lambda1 - lambda2), $MachinePrecision] * N[Cos[N[(phi2 * 0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_2 \leq 5 \cdot 10^{-29}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\left(\lambda_1 - \lambda_2\right) \cdot \cos \left(\phi_1 \cdot 0.5\right), \phi_1 - \phi_2\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\left(\lambda_1 - \lambda_2\right) \cdot \cos \left(\phi_2 \cdot 0.5\right), \phi_1 - \phi_2\right)\\
\end{array}
\end{array}
if phi2 < 4.99999999999999986e-29Initial program 58.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--.f6498.8%
Simplified98.8%
Taylor expanded in phi2 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6493.5%
Simplified93.5%
if 4.99999999999999986e-29 < phi2 Initial program 55.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--.f6494.4%
Simplified94.4%
Taylor expanded in phi1 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6494.4%
Simplified94.4%
Final simplification93.8%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= lambda2 1e-199) (* R (hypot (* lambda1 (cos (* phi1 0.5))) (- phi1 phi2))) (* R (hypot (- lambda1 lambda2) (- phi1 phi2)))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (lambda2 <= 1e-199) {
tmp = R * hypot((lambda1 * cos((phi1 * 0.5))), (phi1 - phi2));
} else {
tmp = R * hypot((lambda1 - lambda2), (phi1 - phi2));
}
return tmp;
}
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (lambda2 <= 1e-199) {
tmp = R * Math.hypot((lambda1 * Math.cos((phi1 * 0.5))), (phi1 - phi2));
} else {
tmp = R * Math.hypot((lambda1 - lambda2), (phi1 - phi2));
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if lambda2 <= 1e-199: tmp = R * math.hypot((lambda1 * math.cos((phi1 * 0.5))), (phi1 - phi2)) else: tmp = R * math.hypot((lambda1 - lambda2), (phi1 - phi2)) return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (lambda2 <= 1e-199) tmp = Float64(R * hypot(Float64(lambda1 * cos(Float64(phi1 * 0.5))), Float64(phi1 - phi2))); else tmp = Float64(R * hypot(Float64(lambda1 - lambda2), Float64(phi1 - phi2))); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (lambda2 <= 1e-199) tmp = R * hypot((lambda1 * cos((phi1 * 0.5))), (phi1 - phi2)); else tmp = R * hypot((lambda1 - lambda2), (phi1 - phi2)); end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[lambda2, 1e-199], N[(R * N[Sqrt[N[(lambda1 * N[Cos[N[(phi1 * 0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision], N[(R * N[Sqrt[N[(lambda1 - lambda2), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\lambda_2 \leq 10^{-199}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\lambda_1 \cdot \cos \left(\phi_1 \cdot 0.5\right), \phi_1 - \phi_2\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\lambda_1 - \lambda_2, \phi_1 - \phi_2\right)\\
\end{array}
\end{array}
if lambda2 < 9.99999999999999982e-200Initial program 57.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--.f6497.2%
Simplified97.2%
Taylor expanded in phi2 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6490.4%
Simplified90.4%
Taylor expanded in lambda1 around inf
*-commutativeN/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6475.0%
Simplified75.0%
if 9.99999999999999982e-200 < lambda2 Initial program 57.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--.f6497.6%
Simplified97.6%
Taylor expanded in phi2 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6490.7%
Simplified90.7%
Taylor expanded in phi1 around 0
--lowering--.f6485.7%
Simplified85.7%
Final simplification79.3%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (* R (hypot (* (- lambda1 lambda2) (cos (* phi1 0.5))) (- phi1 phi2))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * hypot(((lambda1 - lambda2) * cos((phi1 * 0.5))), (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 * 0.5))), (phi1 - phi2));
}
def code(R, lambda1, lambda2, phi1, phi2): return R * math.hypot(((lambda1 - lambda2) * math.cos((phi1 * 0.5))), (phi1 - phi2))
function code(R, lambda1, lambda2, phi1, phi2) return Float64(R * hypot(Float64(Float64(lambda1 - lambda2) * cos(Float64(phi1 * 0.5))), Float64(phi1 - phi2))) end
function tmp = code(R, lambda1, lambda2, phi1, phi2) tmp = R * hypot(((lambda1 - lambda2) * cos((phi1 * 0.5))), (phi1 - phi2)); end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := N[(R * N[Sqrt[N[(N[(lambda1 - lambda2), $MachinePrecision] * N[Cos[N[(phi1 * 0.5), $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(\phi_1 \cdot 0.5\right), \phi_1 - \phi_2\right)
\end{array}
Initial program 57.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--.f6497.4%
Simplified97.4%
Taylor expanded in phi2 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6490.5%
Simplified90.5%
Final simplification90.5%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= phi1 -4.5e+40) (* R (hypot (- lambda1 lambda2) phi1)) (* R (hypot (- lambda1 lambda2) phi2))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi1 <= -4.5e+40) {
tmp = R * hypot((lambda1 - lambda2), phi1);
} else {
tmp = R * hypot((lambda1 - lambda2), phi2);
}
return tmp;
}
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi1 <= -4.5e+40) {
tmp = R * Math.hypot((lambda1 - lambda2), phi1);
} else {
tmp = R * Math.hypot((lambda1 - lambda2), phi2);
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi1 <= -4.5e+40: tmp = R * math.hypot((lambda1 - lambda2), phi1) else: tmp = R * math.hypot((lambda1 - lambda2), phi2) return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi1 <= -4.5e+40) tmp = Float64(R * hypot(Float64(lambda1 - lambda2), phi1)); else tmp = Float64(R * hypot(Float64(lambda1 - lambda2), phi2)); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (phi1 <= -4.5e+40) tmp = R * hypot((lambda1 - lambda2), phi1); else tmp = R * hypot((lambda1 - lambda2), phi2); end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi1, -4.5e+40], N[(R * N[Sqrt[N[(lambda1 - lambda2), $MachinePrecision] ^ 2 + phi1 ^ 2], $MachinePrecision]), $MachinePrecision], N[(R * N[Sqrt[N[(lambda1 - lambda2), $MachinePrecision] ^ 2 + phi2 ^ 2], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_1 \leq -4.5 \cdot 10^{+40}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\lambda_1 - \lambda_2, \phi_1\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\lambda_1 - \lambda_2, \phi_2\right)\\
\end{array}
\end{array}
if phi1 < -4.50000000000000032e40Initial 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--.f6495.0%
Simplified95.0%
Taylor expanded in phi1 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6484.6%
Simplified84.6%
Taylor expanded in phi2 around 0
*-lowering-*.f64N/A
+-commutativeN/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
--lowering--.f6477.4%
Simplified77.4%
if -4.50000000000000032e40 < phi1 Initial program 60.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--.f6498.1%
Simplified98.1%
Taylor expanded in phi2 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6489.1%
Simplified89.1%
Taylor expanded in phi1 around 0
*-lowering-*.f64N/A
+-commutativeN/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
--lowering--.f6472.9%
Simplified72.9%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= phi2 3.4e+52) (* R (hypot (- lambda1 lambda2) phi1)) (* R (* phi2 (- 1.0 (/ phi1 phi2))))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 3.4e+52) {
tmp = R * hypot((lambda1 - lambda2), phi1);
} else {
tmp = R * (phi2 * (1.0 - (phi1 / phi2)));
}
return tmp;
}
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 3.4e+52) {
tmp = R * Math.hypot((lambda1 - lambda2), phi1);
} else {
tmp = R * (phi2 * (1.0 - (phi1 / phi2)));
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi2 <= 3.4e+52: tmp = R * math.hypot((lambda1 - lambda2), phi1) else: tmp = R * (phi2 * (1.0 - (phi1 / phi2))) return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi2 <= 3.4e+52) tmp = Float64(R * hypot(Float64(lambda1 - lambda2), phi1)); 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 <= 3.4e+52) tmp = R * hypot((lambda1 - lambda2), phi1); else tmp = R * (phi2 * (1.0 - (phi1 / phi2))); end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi2, 3.4e+52], N[(R * N[Sqrt[N[(lambda1 - lambda2), $MachinePrecision] ^ 2 + phi1 ^ 2], $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 3.4 \cdot 10^{+52}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\lambda_1 - \lambda_2, \phi_1\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \left(\phi_2 \cdot \left(1 - \frac{\phi_1}{\phi_2}\right)\right)\\
\end{array}
\end{array}
if phi2 < 3.4e52Initial program 56.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--.f6499.0%
Simplified99.0%
Taylor expanded in phi1 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6491.8%
Simplified91.8%
Taylor expanded in phi2 around 0
*-lowering-*.f64N/A
+-commutativeN/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
--lowering--.f6470.7%
Simplified70.7%
if 3.4e52 < phi2 Initial program 58.3%
Taylor expanded in phi2 around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f6480.4%
Simplified80.4%
(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 57.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--.f6497.4%
Simplified97.4%
Taylor expanded in phi2 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6490.5%
Simplified90.5%
Taylor expanded in phi1 around 0
--lowering--.f6485.2%
Simplified85.2%
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(if (<= lambda2 -7e-117)
(- 0.0 (* R lambda1))
(if (<= lambda2 1.9e+130)
(* phi1 (- (/ (* R phi2) phi1) R))
(* R (* lambda2 (- 1.0 (/ lambda1 lambda2)))))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (lambda2 <= -7e-117) {
tmp = 0.0 - (R * lambda1);
} else if (lambda2 <= 1.9e+130) {
tmp = phi1 * (((R * phi2) / phi1) - R);
} else {
tmp = R * (lambda2 * (1.0 - (lambda1 / lambda2)));
}
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 (lambda2 <= (-7d-117)) then
tmp = 0.0d0 - (r * lambda1)
else if (lambda2 <= 1.9d+130) then
tmp = phi1 * (((r * phi2) / phi1) - r)
else
tmp = r * (lambda2 * (1.0d0 - (lambda1 / lambda2)))
end if
code = tmp
end function
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (lambda2 <= -7e-117) {
tmp = 0.0 - (R * lambda1);
} else if (lambda2 <= 1.9e+130) {
tmp = phi1 * (((R * phi2) / phi1) - R);
} else {
tmp = R * (lambda2 * (1.0 - (lambda1 / lambda2)));
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if lambda2 <= -7e-117: tmp = 0.0 - (R * lambda1) elif lambda2 <= 1.9e+130: tmp = phi1 * (((R * phi2) / phi1) - R) else: tmp = R * (lambda2 * (1.0 - (lambda1 / lambda2))) return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (lambda2 <= -7e-117) tmp = Float64(0.0 - Float64(R * lambda1)); elseif (lambda2 <= 1.9e+130) tmp = Float64(phi1 * Float64(Float64(Float64(R * phi2) / phi1) - R)); 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 <= -7e-117) tmp = 0.0 - (R * lambda1); elseif (lambda2 <= 1.9e+130) tmp = phi1 * (((R * phi2) / phi1) - R); else tmp = R * (lambda2 * (1.0 - (lambda1 / lambda2))); end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[lambda2, -7e-117], N[(0.0 - N[(R * lambda1), $MachinePrecision]), $MachinePrecision], If[LessEqual[lambda2, 1.9e+130], N[(phi1 * N[(N[(N[(R * phi2), $MachinePrecision] / phi1), $MachinePrecision] - R), $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 -7 \cdot 10^{-117}:\\
\;\;\;\;0 - R \cdot \lambda_1\\
\mathbf{elif}\;\lambda_2 \leq 1.9 \cdot 10^{+130}:\\
\;\;\;\;\phi_1 \cdot \left(\frac{R \cdot \phi_2}{\phi_1} - R\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \left(\lambda_2 \cdot \left(1 - \frac{\lambda_1}{\lambda_2}\right)\right)\\
\end{array}
\end{array}
if lambda2 < -6.9999999999999997e-117Initial program 51.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--.f6495.7%
Simplified95.7%
Taylor expanded in phi1 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6489.0%
Simplified89.0%
Taylor expanded in lambda1 around -inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6411.4%
Simplified11.4%
Taylor expanded in phi2 around 0
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-lowering-*.f649.5%
Simplified9.5%
if -6.9999999999999997e-117 < lambda2 < 1.9000000000000001e130Initial program 64.2%
Taylor expanded in phi1 around -inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6441.3%
Simplified41.3%
if 1.9000000000000001e130 < lambda2 Initial program 48.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.8%
Simplified93.8%
Taylor expanded in phi1 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6485.4%
Simplified85.4%
Taylor expanded in lambda2 around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6451.7%
Simplified51.7%
Taylor expanded in phi2 around 0
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
/-lowering-/.f6460.8%
Simplified60.8%
Final simplification32.6%
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(if (<= lambda2 -7e-117)
(- 0.0 (* R lambda1))
(if (<= lambda2 3.9e+128)
(* phi2 (- R (/ (* R phi1) phi2)))
(* R (* lambda2 (- 1.0 (/ lambda1 lambda2)))))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (lambda2 <= -7e-117) {
tmp = 0.0 - (R * lambda1);
} else if (lambda2 <= 3.9e+128) {
tmp = phi2 * (R - ((R * phi1) / phi2));
} else {
tmp = R * (lambda2 * (1.0 - (lambda1 / lambda2)));
}
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 (lambda2 <= (-7d-117)) then
tmp = 0.0d0 - (r * lambda1)
else if (lambda2 <= 3.9d+128) then
tmp = phi2 * (r - ((r * phi1) / phi2))
else
tmp = r * (lambda2 * (1.0d0 - (lambda1 / lambda2)))
end if
code = tmp
end function
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (lambda2 <= -7e-117) {
tmp = 0.0 - (R * lambda1);
} else if (lambda2 <= 3.9e+128) {
tmp = phi2 * (R - ((R * phi1) / phi2));
} else {
tmp = R * (lambda2 * (1.0 - (lambda1 / lambda2)));
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if lambda2 <= -7e-117: tmp = 0.0 - (R * lambda1) elif lambda2 <= 3.9e+128: tmp = phi2 * (R - ((R * phi1) / phi2)) else: tmp = R * (lambda2 * (1.0 - (lambda1 / lambda2))) return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (lambda2 <= -7e-117) tmp = Float64(0.0 - Float64(R * lambda1)); elseif (lambda2 <= 3.9e+128) tmp = Float64(phi2 * Float64(R - Float64(Float64(R * 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 <= -7e-117) tmp = 0.0 - (R * lambda1); elseif (lambda2 <= 3.9e+128) tmp = phi2 * (R - ((R * phi1) / phi2)); else tmp = R * (lambda2 * (1.0 - (lambda1 / lambda2))); end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[lambda2, -7e-117], N[(0.0 - N[(R * lambda1), $MachinePrecision]), $MachinePrecision], If[LessEqual[lambda2, 3.9e+128], N[(phi2 * N[(R - N[(N[(R * phi1), $MachinePrecision] / phi2), $MachinePrecision]), $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 -7 \cdot 10^{-117}:\\
\;\;\;\;0 - R \cdot \lambda_1\\
\mathbf{elif}\;\lambda_2 \leq 3.9 \cdot 10^{+128}:\\
\;\;\;\;\phi_2 \cdot \left(R - \frac{R \cdot \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 < -6.9999999999999997e-117Initial program 51.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--.f6495.7%
Simplified95.7%
Taylor expanded in phi1 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6489.0%
Simplified89.0%
Taylor expanded in lambda1 around -inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6411.4%
Simplified11.4%
Taylor expanded in phi2 around 0
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-lowering-*.f649.5%
Simplified9.5%
if -6.9999999999999997e-117 < lambda2 < 3.8999999999999997e128Initial program 64.2%
Taylor expanded in phi2 around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6441.6%
Simplified41.6%
if 3.8999999999999997e128 < lambda2 Initial program 48.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.8%
Simplified93.8%
Taylor expanded in phi1 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6485.4%
Simplified85.4%
Taylor expanded in lambda2 around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6451.7%
Simplified51.7%
Taylor expanded in phi2 around 0
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
/-lowering-/.f6460.8%
Simplified60.8%
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(if (<= phi2 2.3e-279)
(* R (- 0.0 phi1))
(if (<= phi2 2.05e-7)
(* 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.3e-279) {
tmp = R * (0.0 - phi1);
} else if (phi2 <= 2.05e-7) {
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.3d-279) then
tmp = r * (0.0d0 - phi1)
else if (phi2 <= 2.05d-7) 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.3e-279) {
tmp = R * (0.0 - phi1);
} else if (phi2 <= 2.05e-7) {
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.3e-279: tmp = R * (0.0 - phi1) elif phi2 <= 2.05e-7: 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.3e-279) tmp = Float64(R * Float64(0.0 - phi1)); elseif (phi2 <= 2.05e-7) 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.3e-279) tmp = R * (0.0 - phi1); elseif (phi2 <= 2.05e-7) 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.3e-279], N[(R * N[(0.0 - phi1), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi2, 2.05e-7], 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.3 \cdot 10^{-279}:\\
\;\;\;\;R \cdot \left(0 - \phi_1\right)\\
\mathbf{elif}\;\phi_2 \leq 2.05 \cdot 10^{-7}:\\
\;\;\;\;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.29999999999999995e-279Initial program 56.0%
Taylor expanded in phi1 around -inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-lowering-*.f6421.1%
Simplified21.1%
sub0-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
*-lowering-*.f64N/A
neg-lowering-neg.f6421.1%
Applied egg-rr21.1%
if 2.29999999999999995e-279 < phi2 < 2.05e-7Initial program 61.8%
*-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--.f64100.0%
Simplified100.0%
Taylor expanded in phi1 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6488.4%
Simplified88.4%
Taylor expanded in lambda2 around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6428.5%
Simplified28.5%
Taylor expanded in phi2 around 0
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
/-lowering-/.f6428.5%
Simplified28.5%
if 2.05e-7 < phi2 Initial program 54.8%
Taylor expanded in phi2 around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f6470.0%
Simplified70.0%
Final simplification38.3%
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(if (<= phi1 -2.16e+49)
(* R (- 0.0 phi1))
(if (<= phi1 2.5e-246)
(* R (* lambda2 (- 1.0 (/ lambda1 lambda2))))
(* R phi2))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi1 <= -2.16e+49) {
tmp = R * (0.0 - phi1);
} else if (phi1 <= 2.5e-246) {
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 (phi1 <= (-2.16d+49)) then
tmp = r * (0.0d0 - phi1)
else if (phi1 <= 2.5d-246) 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 (phi1 <= -2.16e+49) {
tmp = R * (0.0 - phi1);
} else if (phi1 <= 2.5e-246) {
tmp = R * (lambda2 * (1.0 - (lambda1 / lambda2)));
} else {
tmp = R * phi2;
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi1 <= -2.16e+49: tmp = R * (0.0 - phi1) elif phi1 <= 2.5e-246: tmp = R * (lambda2 * (1.0 - (lambda1 / lambda2))) else: tmp = R * phi2 return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi1 <= -2.16e+49) tmp = Float64(R * Float64(0.0 - phi1)); elseif (phi1 <= 2.5e-246) 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 (phi1 <= -2.16e+49) tmp = R * (0.0 - phi1); elseif (phi1 <= 2.5e-246) tmp = R * (lambda2 * (1.0 - (lambda1 / lambda2))); else tmp = R * phi2; end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi1, -2.16e+49], N[(R * N[(0.0 - phi1), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, 2.5e-246], 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_1 \leq -2.16 \cdot 10^{+49}:\\
\;\;\;\;R \cdot \left(0 - \phi_1\right)\\
\mathbf{elif}\;\phi_1 \leq 2.5 \cdot 10^{-246}:\\
\;\;\;\;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 phi1 < -2.16000000000000003e49Initial program 45.2%
Taylor expanded in phi1 around -inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-lowering-*.f6470.9%
Simplified70.9%
sub0-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
*-lowering-*.f64N/A
neg-lowering-neg.f6470.9%
Applied egg-rr70.9%
if -2.16000000000000003e49 < phi1 < 2.4999999999999998e-246Initial program 68.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--.f6499.7%
Simplified99.7%
Taylor expanded in phi1 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6498.0%
Simplified98.0%
Taylor expanded in lambda2 around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6429.0%
Simplified29.0%
Taylor expanded in phi2 around 0
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
/-lowering-/.f6429.1%
Simplified29.1%
if 2.4999999999999998e-246 < phi1 Initial program 53.7%
Taylor expanded in phi2 around inf
*-lowering-*.f6422.7%
Simplified22.7%
Final simplification36.6%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= phi1 -2e+20) (* R (- 0.0 phi1)) (* R phi2)))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi1 <= -2e+20) {
tmp = R * (0.0 - phi1);
} 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 <= (-2d+20)) then
tmp = r * (0.0d0 - phi1)
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 <= -2e+20) {
tmp = R * (0.0 - phi1);
} else {
tmp = R * phi2;
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi1 <= -2e+20: tmp = R * (0.0 - phi1) else: tmp = R * phi2 return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi1 <= -2e+20) tmp = Float64(R * Float64(0.0 - phi1)); else tmp = Float64(R * phi2); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (phi1 <= -2e+20) tmp = R * (0.0 - phi1); else tmp = R * phi2; end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi1, -2e+20], N[(R * N[(0.0 - phi1), $MachinePrecision]), $MachinePrecision], N[(R * phi2), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_1 \leq -2 \cdot 10^{+20}:\\
\;\;\;\;R \cdot \left(0 - \phi_1\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \phi_2\\
\end{array}
\end{array}
if phi1 < -2e20Initial program 44.5%
Taylor expanded in phi1 around -inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-lowering-*.f6465.0%
Simplified65.0%
sub0-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
*-lowering-*.f64N/A
neg-lowering-neg.f6465.0%
Applied egg-rr65.0%
if -2e20 < phi1 Initial program 61.6%
Taylor expanded in phi2 around inf
*-lowering-*.f6425.2%
Simplified25.2%
Final simplification35.6%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= phi2 6.2e+52) (* R lambda2) (* R phi2)))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 6.2e+52) {
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 <= 6.2d+52) 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 <= 6.2e+52) {
tmp = R * lambda2;
} else {
tmp = R * phi2;
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi2 <= 6.2e+52: tmp = R * lambda2 else: tmp = R * phi2 return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi2 <= 6.2e+52) 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 <= 6.2e+52) tmp = R * lambda2; else tmp = R * phi2; end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi2, 6.2e+52], N[(R * lambda2), $MachinePrecision], N[(R * phi2), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_2 \leq 6.2 \cdot 10^{+52}:\\
\;\;\;\;R \cdot \lambda_2\\
\mathbf{else}:\\
\;\;\;\;R \cdot \phi_2\\
\end{array}
\end{array}
if phi2 < 6.2e52Initial program 56.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--.f6499.0%
Simplified99.0%
Taylor expanded in phi2 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6491.9%
Simplified91.9%
Taylor expanded in lambda2 around inf
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6417.7%
Simplified17.7%
Taylor expanded in phi1 around 0
*-lowering-*.f6418.2%
Simplified18.2%
if 6.2e52 < phi2 Initial program 58.3%
Taylor expanded in phi2 around inf
*-lowering-*.f6473.6%
Simplified73.6%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (* R lambda2))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * lambda2;
}
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 * lambda2
end function
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * lambda2;
}
def code(R, lambda1, lambda2, phi1, phi2): return R * lambda2
function code(R, lambda1, lambda2, phi1, phi2) return Float64(R * lambda2) end
function tmp = code(R, lambda1, lambda2, phi1, phi2) tmp = R * lambda2; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := N[(R * lambda2), $MachinePrecision]
\begin{array}{l}
\\
R \cdot \lambda_2
\end{array}
Initial program 57.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--.f6497.4%
Simplified97.4%
Taylor expanded in phi2 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6490.5%
Simplified90.5%
Taylor expanded in lambda2 around inf
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6415.5%
Simplified15.5%
Taylor expanded in phi1 around 0
*-lowering-*.f6415.1%
Simplified15.1%
herbie shell --seed 2024152
(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))))))