
(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 10 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)
(sqrt
(+ 0.5 (* 0.5 (- (* (cos phi2) (cos phi1)) (* (sin phi2) (sin phi1)))))))
(- phi1 phi2))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * hypot(((lambda1 - lambda2) * sqrt((0.5 + (0.5 * ((cos(phi2) * cos(phi1)) - (sin(phi2) * sin(phi1))))))), (phi1 - phi2));
}
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * Math.hypot(((lambda1 - lambda2) * Math.sqrt((0.5 + (0.5 * ((Math.cos(phi2) * Math.cos(phi1)) - (Math.sin(phi2) * Math.sin(phi1))))))), (phi1 - phi2));
}
def code(R, lambda1, lambda2, phi1, phi2): return R * math.hypot(((lambda1 - lambda2) * math.sqrt((0.5 + (0.5 * ((math.cos(phi2) * math.cos(phi1)) - (math.sin(phi2) * math.sin(phi1))))))), (phi1 - phi2))
function code(R, lambda1, lambda2, phi1, phi2) return Float64(R * hypot(Float64(Float64(lambda1 - lambda2) * sqrt(Float64(0.5 + Float64(0.5 * Float64(Float64(cos(phi2) * cos(phi1)) - Float64(sin(phi2) * sin(phi1))))))), Float64(phi1 - phi2))) end
function tmp = code(R, lambda1, lambda2, phi1, phi2) tmp = R * hypot(((lambda1 - lambda2) * sqrt((0.5 + (0.5 * ((cos(phi2) * cos(phi1)) - (sin(phi2) * sin(phi1))))))), (phi1 - phi2)); end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := N[(R * N[Sqrt[N[(N[(lambda1 - lambda2), $MachinePrecision] * N[Sqrt[N[(0.5 + N[(0.5 * N[(N[(N[Cos[phi2], $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] - N[(N[Sin[phi2], $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $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 \sqrt{0.5 + 0.5 \cdot \left(\cos \phi_2 \cdot \cos \phi_1 - \sin \phi_2 \cdot \sin \phi_1\right)}, \phi_1 - \phi_2\right)
\end{array}
Initial program 59.2%
hypot-def96.8%
Simplified96.8%
add-sqr-sqrt60.7%
sqrt-unprod96.8%
sqr-cos-a96.7%
cos-296.7%
cos-sum96.7%
add-log-exp28.9%
add-log-exp28.9%
sum-log28.9%
exp-sqrt28.9%
exp-sqrt28.9%
add-sqr-sqrt28.9%
add-log-exp96.7%
Applied egg-rr96.7%
+-commutative96.7%
Simplified96.7%
cos-sum99.8%
Applied egg-rr99.8%
Final simplification99.8%
(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 59.2%
hypot-def96.8%
Simplified96.8%
Final simplification96.8%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= phi2 1.02e+37) (* R (hypot phi1 (* (- lambda1 lambda2) (cos (* 0.5 phi1))))) (- (* R phi2) (* R phi1))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 1.02e+37) {
tmp = R * hypot(phi1, ((lambda1 - lambda2) * cos((0.5 * phi1))));
} else {
tmp = (R * phi2) - (R * phi1);
}
return tmp;
}
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 1.02e+37) {
tmp = R * Math.hypot(phi1, ((lambda1 - lambda2) * Math.cos((0.5 * phi1))));
} else {
tmp = (R * phi2) - (R * phi1);
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi2 <= 1.02e+37: tmp = R * math.hypot(phi1, ((lambda1 - lambda2) * math.cos((0.5 * phi1)))) else: tmp = (R * phi2) - (R * phi1) return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi2 <= 1.02e+37) tmp = Float64(R * hypot(phi1, Float64(Float64(lambda1 - lambda2) * cos(Float64(0.5 * phi1))))); else tmp = Float64(Float64(R * phi2) - Float64(R * phi1)); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (phi2 <= 1.02e+37) tmp = R * hypot(phi1, ((lambda1 - lambda2) * cos((0.5 * phi1)))); else tmp = (R * phi2) - (R * phi1); end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi2, 1.02e+37], N[(R * N[Sqrt[phi1 ^ 2 + N[(N[(lambda1 - lambda2), $MachinePrecision] * N[Cos[N[(0.5 * phi1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision], N[(N[(R * phi2), $MachinePrecision] - N[(R * phi1), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_2 \leq 1.02 \cdot 10^{+37}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\phi_1, \left(\lambda_1 - \lambda_2\right) \cdot \cos \left(0.5 \cdot \phi_1\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \phi_2 - R \cdot \phi_1\\
\end{array}
\end{array}
if phi2 < 1.01999999999999995e37Initial program 59.1%
hypot-def96.8%
Simplified96.8%
Taylor expanded in phi2 around 0 47.6%
*-commutative47.6%
+-commutative47.6%
unpow247.6%
unpow247.6%
unpow247.6%
unswap-sqr47.6%
hypot-def73.7%
Simplified73.7%
if 1.01999999999999995e37 < phi2 Initial program 59.4%
hypot-def96.8%
Simplified96.8%
Taylor expanded in phi1 around -inf 82.4%
Final simplification75.3%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= phi2 2.7e+17) (* R (hypot phi1 (* (- lambda1 lambda2) (cos (* 0.5 phi1))))) (* R (hypot phi2 (* (- lambda1 lambda2) (cos (* 0.5 phi2)))))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 2.7e+17) {
tmp = R * hypot(phi1, ((lambda1 - lambda2) * cos((0.5 * phi1))));
} else {
tmp = R * hypot(phi2, ((lambda1 - lambda2) * cos((0.5 * phi2))));
}
return tmp;
}
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 2.7e+17) {
tmp = R * Math.hypot(phi1, ((lambda1 - lambda2) * Math.cos((0.5 * phi1))));
} else {
tmp = R * Math.hypot(phi2, ((lambda1 - lambda2) * Math.cos((0.5 * phi2))));
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi2 <= 2.7e+17: tmp = R * math.hypot(phi1, ((lambda1 - lambda2) * math.cos((0.5 * phi1)))) else: tmp = R * math.hypot(phi2, ((lambda1 - lambda2) * math.cos((0.5 * phi2)))) return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi2 <= 2.7e+17) tmp = Float64(R * hypot(phi1, Float64(Float64(lambda1 - lambda2) * cos(Float64(0.5 * phi1))))); else tmp = Float64(R * hypot(phi2, Float64(Float64(lambda1 - lambda2) * cos(Float64(0.5 * phi2))))); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (phi2 <= 2.7e+17) tmp = R * hypot(phi1, ((lambda1 - lambda2) * cos((0.5 * phi1)))); else tmp = R * hypot(phi2, ((lambda1 - lambda2) * cos((0.5 * phi2)))); end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi2, 2.7e+17], N[(R * N[Sqrt[phi1 ^ 2 + N[(N[(lambda1 - lambda2), $MachinePrecision] * N[Cos[N[(0.5 * phi1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision], N[(R * N[Sqrt[phi2 ^ 2 + N[(N[(lambda1 - lambda2), $MachinePrecision] * N[Cos[N[(0.5 * phi2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_2 \leq 2.7 \cdot 10^{+17}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\phi_1, \left(\lambda_1 - \lambda_2\right) \cdot \cos \left(0.5 \cdot \phi_1\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\phi_2, \left(\lambda_1 - \lambda_2\right) \cdot \cos \left(0.5 \cdot \phi_2\right)\right)\\
\end{array}
\end{array}
if phi2 < 2.7e17Initial program 59.7%
hypot-def97.5%
Simplified97.5%
Taylor expanded in phi2 around 0 48.5%
*-commutative48.5%
+-commutative48.5%
unpow248.5%
unpow248.5%
unpow248.5%
unswap-sqr48.4%
hypot-def75.4%
Simplified75.4%
if 2.7e17 < phi2 Initial program 57.6%
hypot-def94.5%
Simplified94.5%
Taylor expanded in phi1 around 0 54.4%
*-commutative54.4%
unpow254.4%
unpow254.4%
unpow254.4%
unswap-sqr54.4%
hypot-def84.7%
Simplified84.7%
Final simplification77.5%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= phi2 1.02e+37) (* R (hypot phi1 (- lambda1 lambda2))) (- (* R phi2) (* R phi1))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 1.02e+37) {
tmp = R * hypot(phi1, (lambda1 - lambda2));
} else {
tmp = (R * phi2) - (R * phi1);
}
return tmp;
}
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 1.02e+37) {
tmp = R * Math.hypot(phi1, (lambda1 - lambda2));
} else {
tmp = (R * phi2) - (R * phi1);
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi2 <= 1.02e+37: tmp = R * math.hypot(phi1, (lambda1 - lambda2)) else: tmp = (R * phi2) - (R * phi1) return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi2 <= 1.02e+37) tmp = Float64(R * hypot(phi1, Float64(lambda1 - lambda2))); else tmp = Float64(Float64(R * phi2) - Float64(R * phi1)); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (phi2 <= 1.02e+37) tmp = R * hypot(phi1, (lambda1 - lambda2)); else tmp = (R * phi2) - (R * phi1); end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi2, 1.02e+37], N[(R * N[Sqrt[phi1 ^ 2 + N[(lambda1 - lambda2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision], N[(N[(R * phi2), $MachinePrecision] - N[(R * phi1), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_2 \leq 1.02 \cdot 10^{+37}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\phi_1, \lambda_1 - \lambda_2\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \phi_2 - R \cdot \phi_1\\
\end{array}
\end{array}
if phi2 < 1.01999999999999995e37Initial program 59.1%
hypot-def96.8%
Simplified96.8%
Taylor expanded in phi2 around 0 47.6%
*-commutative47.6%
+-commutative47.6%
unpow247.6%
unpow247.6%
unpow247.6%
unswap-sqr47.6%
hypot-def73.7%
Simplified73.7%
Taylor expanded in phi1 around 0 67.3%
if 1.01999999999999995e37 < phi2 Initial program 59.4%
hypot-def96.8%
Simplified96.8%
Taylor expanded in phi1 around -inf 82.4%
Final simplification70.2%
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* R (- lambda1))))
(if (<= phi2 2.3e-275)
t_0
(if (<= phi2 8.5e-167)
(* R lambda2)
(if (<= phi2 4.5e-57)
t_0
(if (<= phi2 2.2e+17) (* R lambda2) (* R phi2)))))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = R * -lambda1;
double tmp;
if (phi2 <= 2.3e-275) {
tmp = t_0;
} else if (phi2 <= 8.5e-167) {
tmp = R * lambda2;
} else if (phi2 <= 4.5e-57) {
tmp = t_0;
} else if (phi2 <= 2.2e+17) {
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) :: t_0
real(8) :: tmp
t_0 = r * -lambda1
if (phi2 <= 2.3d-275) then
tmp = t_0
else if (phi2 <= 8.5d-167) then
tmp = r * lambda2
else if (phi2 <= 4.5d-57) then
tmp = t_0
else if (phi2 <= 2.2d+17) 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 t_0 = R * -lambda1;
double tmp;
if (phi2 <= 2.3e-275) {
tmp = t_0;
} else if (phi2 <= 8.5e-167) {
tmp = R * lambda2;
} else if (phi2 <= 4.5e-57) {
tmp = t_0;
} else if (phi2 <= 2.2e+17) {
tmp = R * lambda2;
} else {
tmp = R * phi2;
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): t_0 = R * -lambda1 tmp = 0 if phi2 <= 2.3e-275: tmp = t_0 elif phi2 <= 8.5e-167: tmp = R * lambda2 elif phi2 <= 4.5e-57: tmp = t_0 elif phi2 <= 2.2e+17: tmp = R * lambda2 else: tmp = R * phi2 return tmp
function code(R, lambda1, lambda2, phi1, phi2) t_0 = Float64(R * Float64(-lambda1)) tmp = 0.0 if (phi2 <= 2.3e-275) tmp = t_0; elseif (phi2 <= 8.5e-167) tmp = Float64(R * lambda2); elseif (phi2 <= 4.5e-57) tmp = t_0; elseif (phi2 <= 2.2e+17) tmp = Float64(R * lambda2); else tmp = Float64(R * phi2); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) t_0 = R * -lambda1; tmp = 0.0; if (phi2 <= 2.3e-275) tmp = t_0; elseif (phi2 <= 8.5e-167) tmp = R * lambda2; elseif (phi2 <= 4.5e-57) tmp = t_0; elseif (phi2 <= 2.2e+17) tmp = R * lambda2; else tmp = R * phi2; end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(R * (-lambda1)), $MachinePrecision]}, If[LessEqual[phi2, 2.3e-275], t$95$0, If[LessEqual[phi2, 8.5e-167], N[(R * lambda2), $MachinePrecision], If[LessEqual[phi2, 4.5e-57], t$95$0, If[LessEqual[phi2, 2.2e+17], N[(R * lambda2), $MachinePrecision], N[(R * phi2), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := R \cdot \left(-\lambda_1\right)\\
\mathbf{if}\;\phi_2 \leq 2.3 \cdot 10^{-275}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;\phi_2 \leq 8.5 \cdot 10^{-167}:\\
\;\;\;\;R \cdot \lambda_2\\
\mathbf{elif}\;\phi_2 \leq 4.5 \cdot 10^{-57}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;\phi_2 \leq 2.2 \cdot 10^{+17}:\\
\;\;\;\;R \cdot \lambda_2\\
\mathbf{else}:\\
\;\;\;\;R \cdot \phi_2\\
\end{array}
\end{array}
if phi2 < 2.2999999999999999e-275 or 8.4999999999999994e-167 < phi2 < 4.49999999999999973e-57Initial program 60.3%
hypot-def97.1%
Simplified97.1%
Taylor expanded in phi2 around 0 47.8%
*-commutative47.8%
+-commutative47.8%
unpow247.8%
unpow247.8%
unpow247.8%
unswap-sqr47.8%
hypot-def72.3%
Simplified72.3%
Taylor expanded in lambda1 around -inf 16.0%
mul-1-neg16.0%
associate-*r*16.0%
*-commutative16.0%
associate-*r*16.0%
distribute-rgt-neg-in16.0%
*-commutative16.0%
*-commutative16.0%
Simplified16.0%
Taylor expanded in phi1 around 0 15.7%
associate-*r*15.7%
neg-mul-115.7%
*-commutative15.7%
Simplified15.7%
if 2.2999999999999999e-275 < phi2 < 8.4999999999999994e-167 or 4.49999999999999973e-57 < phi2 < 2.2e17Initial program 55.8%
hypot-def99.9%
Simplified99.9%
Taylor expanded in phi2 around 0 52.5%
*-commutative52.5%
+-commutative52.5%
unpow252.5%
unpow252.5%
unpow252.5%
unswap-sqr52.5%
hypot-def93.7%
Simplified93.7%
Taylor expanded in lambda1 around 0 76.1%
mul-1-neg76.1%
*-commutative76.1%
*-commutative76.1%
distribute-rgt-neg-out76.1%
Simplified76.1%
Taylor expanded in phi1 around 0 32.7%
if 2.2e17 < phi2 Initial program 57.6%
hypot-def94.5%
Simplified94.5%
Taylor expanded in phi2 around inf 67.6%
*-commutative67.6%
Simplified67.6%
Final simplification29.3%
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(if (<= phi2 3.7e-262)
(* R (- phi1))
(if (<= phi2 9e-167)
(* R lambda2)
(if (<= phi2 1e-56)
(* R (- lambda1))
(if (<= phi2 7.8e+16) (* R lambda2) (* R phi2))))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 3.7e-262) {
tmp = R * -phi1;
} else if (phi2 <= 9e-167) {
tmp = R * lambda2;
} else if (phi2 <= 1e-56) {
tmp = R * -lambda1;
} else if (phi2 <= 7.8e+16) {
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 <= 3.7d-262) then
tmp = r * -phi1
else if (phi2 <= 9d-167) then
tmp = r * lambda2
else if (phi2 <= 1d-56) then
tmp = r * -lambda1
else if (phi2 <= 7.8d+16) 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 <= 3.7e-262) {
tmp = R * -phi1;
} else if (phi2 <= 9e-167) {
tmp = R * lambda2;
} else if (phi2 <= 1e-56) {
tmp = R * -lambda1;
} else if (phi2 <= 7.8e+16) {
tmp = R * lambda2;
} else {
tmp = R * phi2;
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi2 <= 3.7e-262: tmp = R * -phi1 elif phi2 <= 9e-167: tmp = R * lambda2 elif phi2 <= 1e-56: tmp = R * -lambda1 elif phi2 <= 7.8e+16: tmp = R * lambda2 else: tmp = R * phi2 return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi2 <= 3.7e-262) tmp = Float64(R * Float64(-phi1)); elseif (phi2 <= 9e-167) tmp = Float64(R * lambda2); elseif (phi2 <= 1e-56) tmp = Float64(R * Float64(-lambda1)); elseif (phi2 <= 7.8e+16) 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 <= 3.7e-262) tmp = R * -phi1; elseif (phi2 <= 9e-167) tmp = R * lambda2; elseif (phi2 <= 1e-56) tmp = R * -lambda1; elseif (phi2 <= 7.8e+16) tmp = R * lambda2; else tmp = R * phi2; end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi2, 3.7e-262], N[(R * (-phi1)), $MachinePrecision], If[LessEqual[phi2, 9e-167], N[(R * lambda2), $MachinePrecision], If[LessEqual[phi2, 1e-56], N[(R * (-lambda1)), $MachinePrecision], If[LessEqual[phi2, 7.8e+16], N[(R * lambda2), $MachinePrecision], N[(R * phi2), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_2 \leq 3.7 \cdot 10^{-262}:\\
\;\;\;\;R \cdot \left(-\phi_1\right)\\
\mathbf{elif}\;\phi_2 \leq 9 \cdot 10^{-167}:\\
\;\;\;\;R \cdot \lambda_2\\
\mathbf{elif}\;\phi_2 \leq 10^{-56}:\\
\;\;\;\;R \cdot \left(-\lambda_1\right)\\
\mathbf{elif}\;\phi_2 \leq 7.8 \cdot 10^{+16}:\\
\;\;\;\;R \cdot \lambda_2\\
\mathbf{else}:\\
\;\;\;\;R \cdot \phi_2\\
\end{array}
\end{array}
if phi2 < 3.7e-262Initial program 59.2%
hypot-def96.5%
Simplified96.5%
Taylor expanded in phi1 around -inf 17.3%
associate-*r*17.3%
mul-1-neg17.3%
Simplified17.3%
if 3.7e-262 < phi2 < 9.0000000000000002e-167 or 1e-56 < phi2 < 7.8e16Initial program 55.8%
hypot-def99.9%
Simplified99.9%
Taylor expanded in phi2 around 0 52.5%
*-commutative52.5%
+-commutative52.5%
unpow252.5%
unpow252.5%
unpow252.5%
unswap-sqr52.5%
hypot-def93.7%
Simplified93.7%
Taylor expanded in lambda1 around 0 76.1%
mul-1-neg76.1%
*-commutative76.1%
*-commutative76.1%
distribute-rgt-neg-out76.1%
Simplified76.1%
Taylor expanded in phi1 around 0 32.7%
if 9.0000000000000002e-167 < phi2 < 1e-56Initial program 66.0%
hypot-def100.0%
Simplified100.0%
Taylor expanded in phi2 around 0 62.5%
*-commutative62.5%
+-commutative62.5%
unpow262.5%
unpow262.5%
unpow262.5%
unswap-sqr62.5%
hypot-def96.6%
Simplified96.6%
Taylor expanded in lambda1 around -inf 26.1%
mul-1-neg26.1%
associate-*r*26.1%
*-commutative26.1%
associate-*r*26.1%
distribute-rgt-neg-in26.1%
*-commutative26.1%
*-commutative26.1%
Simplified26.1%
Taylor expanded in phi1 around 0 25.5%
associate-*r*25.5%
neg-mul-125.5%
*-commutative25.5%
Simplified25.5%
if 7.8e16 < phi2 Initial program 57.6%
hypot-def94.5%
Simplified94.5%
Taylor expanded in phi2 around inf 67.6%
*-commutative67.6%
Simplified67.6%
Final simplification31.3%
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(if (<= lambda1 -2.8e+132)
(* R (- lambda1))
(if (or (<= lambda1 1.45e-151) (not (<= lambda1 1.7e-123)))
(* R (- phi2 phi1))
(* R lambda2))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (lambda1 <= -2.8e+132) {
tmp = R * -lambda1;
} else if ((lambda1 <= 1.45e-151) || !(lambda1 <= 1.7e-123)) {
tmp = R * (phi2 - phi1);
} else {
tmp = R * 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 (lambda1 <= (-2.8d+132)) then
tmp = r * -lambda1
else if ((lambda1 <= 1.45d-151) .or. (.not. (lambda1 <= 1.7d-123))) then
tmp = r * (phi2 - phi1)
else
tmp = r * lambda2
end if
code = tmp
end function
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (lambda1 <= -2.8e+132) {
tmp = R * -lambda1;
} else if ((lambda1 <= 1.45e-151) || !(lambda1 <= 1.7e-123)) {
tmp = R * (phi2 - phi1);
} else {
tmp = R * lambda2;
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if lambda1 <= -2.8e+132: tmp = R * -lambda1 elif (lambda1 <= 1.45e-151) or not (lambda1 <= 1.7e-123): tmp = R * (phi2 - phi1) else: tmp = R * lambda2 return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (lambda1 <= -2.8e+132) tmp = Float64(R * Float64(-lambda1)); elseif ((lambda1 <= 1.45e-151) || !(lambda1 <= 1.7e-123)) tmp = Float64(R * Float64(phi2 - phi1)); else tmp = Float64(R * lambda2); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (lambda1 <= -2.8e+132) tmp = R * -lambda1; elseif ((lambda1 <= 1.45e-151) || ~((lambda1 <= 1.7e-123))) tmp = R * (phi2 - phi1); else tmp = R * lambda2; end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[lambda1, -2.8e+132], N[(R * (-lambda1)), $MachinePrecision], If[Or[LessEqual[lambda1, 1.45e-151], N[Not[LessEqual[lambda1, 1.7e-123]], $MachinePrecision]], N[(R * N[(phi2 - phi1), $MachinePrecision]), $MachinePrecision], N[(R * lambda2), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\lambda_1 \leq -2.8 \cdot 10^{+132}:\\
\;\;\;\;R \cdot \left(-\lambda_1\right)\\
\mathbf{elif}\;\lambda_1 \leq 1.45 \cdot 10^{-151} \lor \neg \left(\lambda_1 \leq 1.7 \cdot 10^{-123}\right):\\
\;\;\;\;R \cdot \left(\phi_2 - \phi_1\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \lambda_2\\
\end{array}
\end{array}
if lambda1 < -2.7999999999999999e132Initial program 47.3%
hypot-def93.2%
Simplified93.2%
Taylor expanded in phi2 around 0 45.0%
*-commutative45.0%
+-commutative45.0%
unpow245.0%
unpow245.0%
unpow245.0%
unswap-sqr45.0%
hypot-def82.1%
Simplified82.1%
Taylor expanded in lambda1 around -inf 48.5%
mul-1-neg48.5%
associate-*r*48.5%
*-commutative48.5%
associate-*r*48.5%
distribute-rgt-neg-in48.5%
*-commutative48.5%
*-commutative48.5%
Simplified48.5%
Taylor expanded in phi1 around 0 62.1%
associate-*r*62.1%
neg-mul-162.1%
*-commutative62.1%
Simplified62.1%
if -2.7999999999999999e132 < lambda1 < 1.45000000000000006e-151 or 1.7e-123 < lambda1 Initial program 60.1%
hypot-def97.7%
Simplified97.7%
Taylor expanded in phi1 around -inf 30.3%
*-commutative30.3%
associate-*r*30.3%
distribute-rgt-out30.8%
mul-1-neg30.8%
Simplified30.8%
if 1.45000000000000006e-151 < lambda1 < 1.7e-123Initial program 88.3%
hypot-def89.8%
Simplified89.8%
Taylor expanded in phi2 around 0 88.3%
*-commutative88.3%
+-commutative88.3%
unpow288.3%
unpow288.3%
unpow288.3%
unswap-sqr88.3%
hypot-def89.8%
Simplified89.8%
Taylor expanded in lambda1 around 0 78.1%
mul-1-neg78.1%
*-commutative78.1%
*-commutative78.1%
distribute-rgt-neg-out78.1%
Simplified78.1%
Taylor expanded in phi1 around 0 41.5%
Final simplification35.5%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= phi2 4.5e+16) (* R lambda2) (* R phi2)))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 4.5e+16) {
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 <= 4.5d+16) 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 <= 4.5e+16) {
tmp = R * lambda2;
} else {
tmp = R * phi2;
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi2 <= 4.5e+16: tmp = R * lambda2 else: tmp = R * phi2 return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi2 <= 4.5e+16) 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 <= 4.5e+16) tmp = R * lambda2; else tmp = R * phi2; end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi2, 4.5e+16], N[(R * lambda2), $MachinePrecision], N[(R * phi2), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_2 \leq 4.5 \cdot 10^{+16}:\\
\;\;\;\;R \cdot \lambda_2\\
\mathbf{else}:\\
\;\;\;\;R \cdot \phi_2\\
\end{array}
\end{array}
if phi2 < 4.5e16Initial program 59.7%
hypot-def97.5%
Simplified97.5%
Taylor expanded in phi2 around 0 48.5%
*-commutative48.5%
+-commutative48.5%
unpow248.5%
unpow248.5%
unpow248.5%
unswap-sqr48.4%
hypot-def75.4%
Simplified75.4%
Taylor expanded in lambda1 around 0 54.4%
mul-1-neg54.4%
*-commutative54.4%
*-commutative54.4%
distribute-rgt-neg-out54.4%
Simplified54.4%
Taylor expanded in phi1 around 0 13.8%
if 4.5e16 < phi2 Initial program 57.6%
hypot-def94.5%
Simplified94.5%
Taylor expanded in phi2 around inf 67.6%
*-commutative67.6%
Simplified67.6%
Final simplification26.0%
(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 59.2%
hypot-def96.8%
Simplified96.8%
Taylor expanded in phi2 around 0 45.0%
*-commutative45.0%
+-commutative45.0%
unpow245.0%
unpow245.0%
unpow245.0%
unswap-sqr45.0%
hypot-def67.6%
Simplified67.6%
Taylor expanded in lambda1 around 0 48.7%
mul-1-neg48.7%
*-commutative48.7%
*-commutative48.7%
distribute-rgt-neg-out48.7%
Simplified48.7%
Taylor expanded in phi1 around 0 12.3%
Final simplification12.3%
herbie shell --seed 2023214
(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))))))