
(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)
(fma
(cos (* phi2 0.5))
(cos (* 0.5 phi1))
(* (sin (* phi2 0.5)) (- (sin (* 0.5 phi1))))))
(- phi1 phi2))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * hypot(((lambda1 - lambda2) * fma(cos((phi2 * 0.5)), cos((0.5 * phi1)), (sin((phi2 * 0.5)) * -sin((0.5 * phi1))))), (phi1 - phi2));
}
function code(R, lambda1, lambda2, phi1, phi2) return Float64(R * hypot(Float64(Float64(lambda1 - lambda2) * fma(cos(Float64(phi2 * 0.5)), cos(Float64(0.5 * phi1)), Float64(sin(Float64(phi2 * 0.5)) * Float64(-sin(Float64(0.5 * phi1)))))), Float64(phi1 - phi2))) end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := N[(R * N[Sqrt[N[(N[(lambda1 - lambda2), $MachinePrecision] * N[(N[Cos[N[(phi2 * 0.5), $MachinePrecision]], $MachinePrecision] * N[Cos[N[(0.5 * phi1), $MachinePrecision]], $MachinePrecision] + N[(N[Sin[N[(phi2 * 0.5), $MachinePrecision]], $MachinePrecision] * (-N[Sin[N[(0.5 * phi1), $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(\phi_2 \cdot 0.5\right), \cos \left(0.5 \cdot \phi_1\right), \sin \left(\phi_2 \cdot 0.5\right) \cdot \left(-\sin \left(0.5 \cdot \phi_1\right)\right)\right), \phi_1 - \phi_2\right)
\end{array}
Initial program 56.5%
hypot-def96.5%
Simplified96.5%
expm1-log1p-u96.5%
div-inv96.5%
metadata-eval96.5%
Applied egg-rr96.5%
+-commutative96.5%
*-commutative96.5%
distribute-rgt-in96.5%
cos-sum99.8%
Applied egg-rr99.8%
expm1-log1p-u99.8%
cancel-sign-sub-inv99.8%
*-commutative99.8%
fma-def99.9%
*-commutative99.9%
Applied egg-rr99.9%
Final simplification99.9%
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(if (<= lambda2 2e-134)
(*
R
(hypot
(*
lambda1
(-
(* (cos (* 0.5 phi1)) (cos (* phi2 0.5)))
(* (sin (* phi2 0.5)) (sin (* 0.5 phi1)))))
(- phi1 phi2)))
(*
R
(hypot
(* (- lambda1 lambda2) (expm1 (log1p (cos (* 0.5 (+ phi2 phi1))))))
(- phi1 phi2)))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (lambda2 <= 2e-134) {
tmp = R * hypot((lambda1 * ((cos((0.5 * phi1)) * cos((phi2 * 0.5))) - (sin((phi2 * 0.5)) * sin((0.5 * phi1))))), (phi1 - phi2));
} else {
tmp = R * hypot(((lambda1 - lambda2) * expm1(log1p(cos((0.5 * (phi2 + phi1)))))), (phi1 - phi2));
}
return tmp;
}
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (lambda2 <= 2e-134) {
tmp = R * Math.hypot((lambda1 * ((Math.cos((0.5 * phi1)) * Math.cos((phi2 * 0.5))) - (Math.sin((phi2 * 0.5)) * Math.sin((0.5 * phi1))))), (phi1 - phi2));
} else {
tmp = R * Math.hypot(((lambda1 - lambda2) * Math.expm1(Math.log1p(Math.cos((0.5 * (phi2 + phi1)))))), (phi1 - phi2));
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if lambda2 <= 2e-134: tmp = R * math.hypot((lambda1 * ((math.cos((0.5 * phi1)) * math.cos((phi2 * 0.5))) - (math.sin((phi2 * 0.5)) * math.sin((0.5 * phi1))))), (phi1 - phi2)) else: tmp = R * math.hypot(((lambda1 - lambda2) * math.expm1(math.log1p(math.cos((0.5 * (phi2 + phi1)))))), (phi1 - phi2)) return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (lambda2 <= 2e-134) tmp = Float64(R * hypot(Float64(lambda1 * Float64(Float64(cos(Float64(0.5 * phi1)) * cos(Float64(phi2 * 0.5))) - Float64(sin(Float64(phi2 * 0.5)) * sin(Float64(0.5 * phi1))))), Float64(phi1 - phi2))); else tmp = Float64(R * hypot(Float64(Float64(lambda1 - lambda2) * expm1(log1p(cos(Float64(0.5 * Float64(phi2 + phi1)))))), Float64(phi1 - phi2))); end return tmp end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[lambda2, 2e-134], N[(R * N[Sqrt[N[(lambda1 * N[(N[(N[Cos[N[(0.5 * phi1), $MachinePrecision]], $MachinePrecision] * N[Cos[N[(phi2 * 0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - N[(N[Sin[N[(phi2 * 0.5), $MachinePrecision]], $MachinePrecision] * N[Sin[N[(0.5 * phi1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision], N[(R * N[Sqrt[N[(N[(lambda1 - lambda2), $MachinePrecision] * N[(Exp[N[Log[1 + N[Cos[N[(0.5 * N[(phi2 + phi1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]] - 1), $MachinePrecision]), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\lambda_2 \leq 2 \cdot 10^{-134}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\lambda_1 \cdot \left(\cos \left(0.5 \cdot \phi_1\right) \cdot \cos \left(\phi_2 \cdot 0.5\right) - \sin \left(\phi_2 \cdot 0.5\right) \cdot \sin \left(0.5 \cdot \phi_1\right)\right), \phi_1 - \phi_2\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\left(\lambda_1 - \lambda_2\right) \cdot \mathsf{expm1}\left(\mathsf{log1p}\left(\cos \left(0.5 \cdot \left(\phi_2 + \phi_1\right)\right)\right)\right), \phi_1 - \phi_2\right)\\
\end{array}
\end{array}
if lambda2 < 2.00000000000000008e-134Initial program 60.9%
hypot-def95.0%
Simplified95.0%
expm1-log1p-u95.0%
div-inv95.0%
metadata-eval95.0%
Applied egg-rr95.0%
+-commutative95.0%
*-commutative95.0%
distribute-rgt-in95.0%
cos-sum99.9%
Applied egg-rr99.9%
Taylor expanded in lambda1 around inf 84.1%
*-commutative84.1%
Simplified84.1%
if 2.00000000000000008e-134 < lambda2 Initial program 49.1%
hypot-def99.0%
Simplified99.0%
expm1-log1p-u99.0%
div-inv99.0%
metadata-eval99.0%
Applied egg-rr99.0%
Final simplification89.6%
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (cos (* 0.5 (+ phi2 phi1)))))
(if (<= lambda2 4e-148)
(* R (hypot (* lambda1 t_0) (- phi1 phi2)))
(if (<= lambda2 3.9e+68)
(* R (hypot (- lambda1 lambda2) (- phi1 phi2)))
(if (<= lambda2 8.5e+237)
(* R (hypot (* (cos (* 0.5 phi1)) (- lambda2)) (- phi1 phi2)))
(fabs (* t_0 (* R (- lambda1 lambda2)))))))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos((0.5 * (phi2 + phi1)));
double tmp;
if (lambda2 <= 4e-148) {
tmp = R * hypot((lambda1 * t_0), (phi1 - phi2));
} else if (lambda2 <= 3.9e+68) {
tmp = R * hypot((lambda1 - lambda2), (phi1 - phi2));
} else if (lambda2 <= 8.5e+237) {
tmp = R * hypot((cos((0.5 * phi1)) * -lambda2), (phi1 - phi2));
} else {
tmp = fabs((t_0 * (R * (lambda1 - lambda2))));
}
return tmp;
}
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = Math.cos((0.5 * (phi2 + phi1)));
double tmp;
if (lambda2 <= 4e-148) {
tmp = R * Math.hypot((lambda1 * t_0), (phi1 - phi2));
} else if (lambda2 <= 3.9e+68) {
tmp = R * Math.hypot((lambda1 - lambda2), (phi1 - phi2));
} else if (lambda2 <= 8.5e+237) {
tmp = R * Math.hypot((Math.cos((0.5 * phi1)) * -lambda2), (phi1 - phi2));
} else {
tmp = Math.abs((t_0 * (R * (lambda1 - lambda2))));
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): t_0 = math.cos((0.5 * (phi2 + phi1))) tmp = 0 if lambda2 <= 4e-148: tmp = R * math.hypot((lambda1 * t_0), (phi1 - phi2)) elif lambda2 <= 3.9e+68: tmp = R * math.hypot((lambda1 - lambda2), (phi1 - phi2)) elif lambda2 <= 8.5e+237: tmp = R * math.hypot((math.cos((0.5 * phi1)) * -lambda2), (phi1 - phi2)) else: tmp = math.fabs((t_0 * (R * (lambda1 - lambda2)))) return tmp
function code(R, lambda1, lambda2, phi1, phi2) t_0 = cos(Float64(0.5 * Float64(phi2 + phi1))) tmp = 0.0 if (lambda2 <= 4e-148) tmp = Float64(R * hypot(Float64(lambda1 * t_0), Float64(phi1 - phi2))); elseif (lambda2 <= 3.9e+68) tmp = Float64(R * hypot(Float64(lambda1 - lambda2), Float64(phi1 - phi2))); elseif (lambda2 <= 8.5e+237) tmp = Float64(R * hypot(Float64(cos(Float64(0.5 * phi1)) * Float64(-lambda2)), Float64(phi1 - phi2))); else tmp = abs(Float64(t_0 * Float64(R * Float64(lambda1 - lambda2)))); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) t_0 = cos((0.5 * (phi2 + phi1))); tmp = 0.0; if (lambda2 <= 4e-148) tmp = R * hypot((lambda1 * t_0), (phi1 - phi2)); elseif (lambda2 <= 3.9e+68) tmp = R * hypot((lambda1 - lambda2), (phi1 - phi2)); elseif (lambda2 <= 8.5e+237) tmp = R * hypot((cos((0.5 * phi1)) * -lambda2), (phi1 - phi2)); else tmp = abs((t_0 * (R * (lambda1 - lambda2)))); end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[Cos[N[(0.5 * N[(phi2 + phi1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[lambda2, 4e-148], N[(R * N[Sqrt[N[(lambda1 * t$95$0), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision], If[LessEqual[lambda2, 3.9e+68], N[(R * N[Sqrt[N[(lambda1 - lambda2), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision], If[LessEqual[lambda2, 8.5e+237], N[(R * N[Sqrt[N[(N[Cos[N[(0.5 * phi1), $MachinePrecision]], $MachinePrecision] * (-lambda2)), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision], N[Abs[N[(t$95$0 * N[(R * N[(lambda1 - lambda2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \cos \left(0.5 \cdot \left(\phi_2 + \phi_1\right)\right)\\
\mathbf{if}\;\lambda_2 \leq 4 \cdot 10^{-148}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\lambda_1 \cdot t_0, \phi_1 - \phi_2\right)\\
\mathbf{elif}\;\lambda_2 \leq 3.9 \cdot 10^{+68}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\lambda_1 - \lambda_2, \phi_1 - \phi_2\right)\\
\mathbf{elif}\;\lambda_2 \leq 8.5 \cdot 10^{+237}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\cos \left(0.5 \cdot \phi_1\right) \cdot \left(-\lambda_2\right), \phi_1 - \phi_2\right)\\
\mathbf{else}:\\
\;\;\;\;\left|t_0 \cdot \left(R \cdot \left(\lambda_1 - \lambda_2\right)\right)\right|\\
\end{array}
\end{array}
if lambda2 < 3.99999999999999974e-148Initial program 61.2%
hypot-def95.4%
Simplified95.4%
expm1-log1p-u95.4%
div-inv95.4%
metadata-eval95.4%
Applied egg-rr95.4%
+-commutative95.4%
*-commutative95.4%
distribute-rgt-in95.4%
cos-sum99.9%
Applied egg-rr99.9%
expm1-log1p-u99.9%
cos-sum95.4%
distribute-rgt-in95.4%
expm1-log1p-u95.4%
expm1-udef95.3%
log1p-udef95.3%
add-exp-log95.3%
Applied egg-rr95.3%
Taylor expanded in lambda1 around inf 80.6%
+-commutative80.6%
Simplified80.6%
if 3.99999999999999974e-148 < lambda2 < 3.90000000000000019e68Initial program 59.1%
hypot-def98.1%
Simplified98.1%
expm1-log1p-u98.1%
div-inv98.1%
metadata-eval98.1%
Applied egg-rr98.1%
Taylor expanded in phi2 around 0 95.5%
Taylor expanded in phi1 around 0 91.4%
if 3.90000000000000019e68 < lambda2 < 8.4999999999999994e237Initial program 37.6%
hypot-def97.9%
Simplified97.9%
expm1-log1p-u97.9%
div-inv97.9%
metadata-eval97.9%
Applied egg-rr97.9%
Taylor expanded in phi2 around 0 92.4%
Taylor expanded in lambda1 around 0 90.2%
mul-1-neg90.2%
*-commutative90.2%
distribute-rgt-neg-in90.2%
Simplified90.2%
if 8.4999999999999994e237 < lambda2 Initial program 52.5%
hypot-def99.7%
Simplified99.7%
Taylor expanded in lambda1 around inf 40.2%
+-commutative40.2%
mul-1-neg40.2%
unsub-neg40.2%
*-commutative40.2%
*-commutative40.2%
associate-*l*40.2%
+-commutative40.2%
*-commutative40.2%
*-commutative40.2%
associate-*l*40.3%
+-commutative40.3%
Simplified40.3%
add-sqr-sqrt10.1%
sqrt-unprod39.8%
pow239.8%
distribute-lft-out--39.8%
+-commutative39.8%
distribute-rgt-out--39.8%
Applied egg-rr39.8%
unpow239.8%
rem-sqrt-square39.9%
+-commutative39.9%
*-commutative39.9%
Simplified39.9%
Final simplification82.6%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= (- lambda1 lambda2) -2e+181) (fabs (* (cos (* 0.5 (+ phi2 phi1))) (* R (- lambda1 lambda2)))) (* R (hypot (- lambda1 lambda2) (- phi1 phi2)))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if ((lambda1 - lambda2) <= -2e+181) {
tmp = fabs((cos((0.5 * (phi2 + phi1))) * (R * (lambda1 - lambda2))));
} 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 ((lambda1 - lambda2) <= -2e+181) {
tmp = Math.abs((Math.cos((0.5 * (phi2 + phi1))) * (R * (lambda1 - lambda2))));
} else {
tmp = R * Math.hypot((lambda1 - lambda2), (phi1 - phi2));
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if (lambda1 - lambda2) <= -2e+181: tmp = math.fabs((math.cos((0.5 * (phi2 + phi1))) * (R * (lambda1 - lambda2)))) else: tmp = R * math.hypot((lambda1 - lambda2), (phi1 - phi2)) return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (Float64(lambda1 - lambda2) <= -2e+181) tmp = abs(Float64(cos(Float64(0.5 * Float64(phi2 + phi1))) * Float64(R * Float64(lambda1 - lambda2)))); 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 ((lambda1 - lambda2) <= -2e+181) tmp = abs((cos((0.5 * (phi2 + phi1))) * (R * (lambda1 - lambda2)))); else tmp = R * hypot((lambda1 - lambda2), (phi1 - phi2)); end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[N[(lambda1 - lambda2), $MachinePrecision], -2e+181], N[Abs[N[(N[Cos[N[(0.5 * N[(phi2 + phi1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(R * N[(lambda1 - lambda2), $MachinePrecision]), $MachinePrecision]), $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_1 - \lambda_2 \leq -2 \cdot 10^{+181}:\\
\;\;\;\;\left|\cos \left(0.5 \cdot \left(\phi_2 + \phi_1\right)\right) \cdot \left(R \cdot \left(\lambda_1 - \lambda_2\right)\right)\right|\\
\mathbf{else}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\lambda_1 - \lambda_2, \phi_1 - \phi_2\right)\\
\end{array}
\end{array}
if (-.f64 lambda1 lambda2) < -1.9999999999999998e181Initial program 37.2%
hypot-def91.3%
Simplified91.3%
Taylor expanded in lambda1 around inf 31.3%
+-commutative31.3%
mul-1-neg31.3%
unsub-neg31.3%
*-commutative31.3%
*-commutative31.3%
associate-*l*31.3%
+-commutative31.3%
*-commutative31.3%
*-commutative31.3%
associate-*l*31.3%
+-commutative31.3%
Simplified31.3%
add-sqr-sqrt15.1%
sqrt-unprod35.5%
pow235.5%
distribute-lft-out--35.5%
+-commutative35.5%
distribute-rgt-out--35.4%
Applied egg-rr35.4%
unpow235.4%
rem-sqrt-square39.2%
+-commutative39.2%
*-commutative39.2%
Simplified39.2%
if -1.9999999999999998e181 < (-.f64 lambda1 lambda2) Initial program 60.8%
hypot-def97.6%
Simplified97.6%
expm1-log1p-u97.6%
div-inv97.6%
metadata-eval97.6%
Applied egg-rr97.6%
Taylor expanded in phi2 around 0 92.2%
Taylor expanded in phi1 around 0 86.9%
Final simplification78.1%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= lambda2 3.2e+238) (* R (hypot (* (- lambda1 lambda2) (cos (* 0.5 phi1))) (- phi1 phi2))) (fabs (* (cos (* 0.5 (+ phi2 phi1))) (* R (- lambda1 lambda2))))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (lambda2 <= 3.2e+238) {
tmp = R * hypot(((lambda1 - lambda2) * cos((0.5 * phi1))), (phi1 - phi2));
} else {
tmp = fabs((cos((0.5 * (phi2 + phi1))) * (R * (lambda1 - lambda2))));
}
return tmp;
}
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (lambda2 <= 3.2e+238) {
tmp = R * Math.hypot(((lambda1 - lambda2) * Math.cos((0.5 * phi1))), (phi1 - phi2));
} else {
tmp = Math.abs((Math.cos((0.5 * (phi2 + phi1))) * (R * (lambda1 - lambda2))));
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if lambda2 <= 3.2e+238: tmp = R * math.hypot(((lambda1 - lambda2) * math.cos((0.5 * phi1))), (phi1 - phi2)) else: tmp = math.fabs((math.cos((0.5 * (phi2 + phi1))) * (R * (lambda1 - lambda2)))) return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (lambda2 <= 3.2e+238) tmp = Float64(R * hypot(Float64(Float64(lambda1 - lambda2) * cos(Float64(0.5 * phi1))), Float64(phi1 - phi2))); else tmp = abs(Float64(cos(Float64(0.5 * Float64(phi2 + phi1))) * Float64(R * Float64(lambda1 - lambda2)))); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (lambda2 <= 3.2e+238) tmp = R * hypot(((lambda1 - lambda2) * cos((0.5 * phi1))), (phi1 - phi2)); else tmp = abs((cos((0.5 * (phi2 + phi1))) * (R * (lambda1 - lambda2)))); end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[lambda2, 3.2e+238], N[(R * N[Sqrt[N[(N[(lambda1 - lambda2), $MachinePrecision] * N[Cos[N[(0.5 * phi1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision], N[Abs[N[(N[Cos[N[(0.5 * N[(phi2 + phi1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(R * N[(lambda1 - lambda2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\lambda_2 \leq 3.2 \cdot 10^{+238}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\left(\lambda_1 - \lambda_2\right) \cdot \cos \left(0.5 \cdot \phi_1\right), \phi_1 - \phi_2\right)\\
\mathbf{else}:\\
\;\;\;\;\left|\cos \left(0.5 \cdot \left(\phi_2 + \phi_1\right)\right) \cdot \left(R \cdot \left(\lambda_1 - \lambda_2\right)\right)\right|\\
\end{array}
\end{array}
if lambda2 < 3.19999999999999981e238Initial program 56.6%
hypot-def96.3%
Simplified96.3%
Taylor expanded in phi2 around 0 90.5%
if 3.19999999999999981e238 < lambda2 Initial program 52.5%
hypot-def99.7%
Simplified99.7%
Taylor expanded in lambda1 around inf 40.2%
+-commutative40.2%
mul-1-neg40.2%
unsub-neg40.2%
*-commutative40.2%
*-commutative40.2%
associate-*l*40.2%
+-commutative40.2%
*-commutative40.2%
*-commutative40.2%
associate-*l*40.3%
+-commutative40.3%
Simplified40.3%
add-sqr-sqrt10.1%
sqrt-unprod39.8%
pow239.8%
distribute-lft-out--39.8%
+-commutative39.8%
distribute-rgt-out--39.8%
Applied egg-rr39.8%
unpow239.8%
rem-sqrt-square39.9%
+-commutative39.9%
*-commutative39.9%
Simplified39.9%
Final simplification88.5%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= phi2 1e-18) (* R (hypot (* (- lambda1 lambda2) (cos (* 0.5 phi1))) (- 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 <= 1e-18) {
tmp = R * hypot(((lambda1 - lambda2) * cos((0.5 * phi1))), (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 <= 1e-18) {
tmp = R * Math.hypot(((lambda1 - lambda2) * Math.cos((0.5 * phi1))), (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 <= 1e-18: tmp = R * math.hypot(((lambda1 - lambda2) * math.cos((0.5 * phi1))), (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 <= 1e-18) tmp = Float64(R * hypot(Float64(Float64(lambda1 - lambda2) * cos(Float64(0.5 * phi1))), 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 <= 1e-18) tmp = R * hypot(((lambda1 - lambda2) * cos((0.5 * phi1))), (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, 1e-18], N[(R * N[Sqrt[N[(N[(lambda1 - lambda2), $MachinePrecision] * N[Cos[N[(0.5 * phi1), $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 10^{-18}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\left(\lambda_1 - \lambda_2\right) \cdot \cos \left(0.5 \cdot \phi_1\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 < 1.0000000000000001e-18Initial program 61.1%
hypot-def98.1%
Simplified98.1%
Taylor expanded in phi2 around 0 93.7%
if 1.0000000000000001e-18 < phi2 Initial program 44.6%
hypot-def92.2%
Simplified92.2%
Taylor expanded in phi1 around 0 92.2%
Final simplification93.3%
(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 56.5%
hypot-def96.5%
Simplified96.5%
Final simplification96.5%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= (- lambda1 lambda2) -5e+238) (fabs (* (- lambda1 lambda2) (* R (cos (* phi2 0.5))))) (* R (hypot (- lambda1 lambda2) (- phi1 phi2)))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if ((lambda1 - lambda2) <= -5e+238) {
tmp = fabs(((lambda1 - lambda2) * (R * cos((phi2 * 0.5)))));
} 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 ((lambda1 - lambda2) <= -5e+238) {
tmp = Math.abs(((lambda1 - lambda2) * (R * Math.cos((phi2 * 0.5)))));
} else {
tmp = R * Math.hypot((lambda1 - lambda2), (phi1 - phi2));
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if (lambda1 - lambda2) <= -5e+238: tmp = math.fabs(((lambda1 - lambda2) * (R * math.cos((phi2 * 0.5))))) else: tmp = R * math.hypot((lambda1 - lambda2), (phi1 - phi2)) return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (Float64(lambda1 - lambda2) <= -5e+238) tmp = abs(Float64(Float64(lambda1 - lambda2) * Float64(R * cos(Float64(phi2 * 0.5))))); 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 ((lambda1 - lambda2) <= -5e+238) tmp = abs(((lambda1 - lambda2) * (R * cos((phi2 * 0.5))))); else tmp = R * hypot((lambda1 - lambda2), (phi1 - phi2)); end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[N[(lambda1 - lambda2), $MachinePrecision], -5e+238], N[Abs[N[(N[(lambda1 - lambda2), $MachinePrecision] * N[(R * N[Cos[N[(phi2 * 0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $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_1 - \lambda_2 \leq -5 \cdot 10^{+238}:\\
\;\;\;\;\left|\left(\lambda_1 - \lambda_2\right) \cdot \left(R \cdot \cos \left(\phi_2 \cdot 0.5\right)\right)\right|\\
\mathbf{else}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\lambda_1 - \lambda_2, \phi_1 - \phi_2\right)\\
\end{array}
\end{array}
if (-.f64 lambda1 lambda2) < -4.99999999999999995e238Initial program 62.0%
hypot-def88.1%
Simplified88.1%
Taylor expanded in lambda1 around inf 27.0%
+-commutative27.0%
mul-1-neg27.0%
unsub-neg27.0%
*-commutative27.0%
*-commutative27.0%
associate-*l*27.0%
+-commutative27.0%
*-commutative27.0%
*-commutative27.0%
associate-*l*27.1%
+-commutative27.1%
Simplified27.1%
Taylor expanded in phi1 around 0 12.0%
associate-*r*12.0%
*-commutative12.0%
associate-*r*12.0%
distribute-rgt-out--12.0%
unsub-neg12.0%
*-commutative12.0%
distribute-lft-neg-in12.0%
distribute-rgt-in12.0%
sub-neg12.0%
*-commutative12.0%
Simplified12.0%
add-sqr-sqrt1.0%
sqrt-unprod32.7%
pow232.7%
*-commutative32.7%
Applied egg-rr32.7%
unpow232.7%
rem-sqrt-square32.7%
associate-*r*32.7%
*-commutative32.7%
*-commutative32.7%
associate-*r*32.7%
*-commutative32.7%
Simplified32.7%
if -4.99999999999999995e238 < (-.f64 lambda1 lambda2) Initial program 56.0%
hypot-def97.2%
Simplified97.2%
expm1-log1p-u97.2%
div-inv97.2%
metadata-eval97.2%
Applied egg-rr97.2%
Taylor expanded in phi2 around 0 91.0%
Taylor expanded in phi1 around 0 84.5%
Final simplification80.4%
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* R (- phi2 phi1))))
(if (<= lambda2 2.4e+96)
t_0
(if (<= lambda2 2.6e+108)
(* (cos (* phi2 0.5)) (* R lambda2))
(if (<= lambda2 1.65e+138) t_0 (* (cos (* 0.5 phi1)) (* R lambda2)))))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = R * (phi2 - phi1);
double tmp;
if (lambda2 <= 2.4e+96) {
tmp = t_0;
} else if (lambda2 <= 2.6e+108) {
tmp = cos((phi2 * 0.5)) * (R * lambda2);
} else if (lambda2 <= 1.65e+138) {
tmp = t_0;
} else {
tmp = cos((0.5 * phi1)) * (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) :: t_0
real(8) :: tmp
t_0 = r * (phi2 - phi1)
if (lambda2 <= 2.4d+96) then
tmp = t_0
else if (lambda2 <= 2.6d+108) then
tmp = cos((phi2 * 0.5d0)) * (r * lambda2)
else if (lambda2 <= 1.65d+138) then
tmp = t_0
else
tmp = cos((0.5d0 * phi1)) * (r * lambda2)
end if
code = tmp
end function
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = R * (phi2 - phi1);
double tmp;
if (lambda2 <= 2.4e+96) {
tmp = t_0;
} else if (lambda2 <= 2.6e+108) {
tmp = Math.cos((phi2 * 0.5)) * (R * lambda2);
} else if (lambda2 <= 1.65e+138) {
tmp = t_0;
} else {
tmp = Math.cos((0.5 * phi1)) * (R * lambda2);
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): t_0 = R * (phi2 - phi1) tmp = 0 if lambda2 <= 2.4e+96: tmp = t_0 elif lambda2 <= 2.6e+108: tmp = math.cos((phi2 * 0.5)) * (R * lambda2) elif lambda2 <= 1.65e+138: tmp = t_0 else: tmp = math.cos((0.5 * phi1)) * (R * lambda2) return tmp
function code(R, lambda1, lambda2, phi1, phi2) t_0 = Float64(R * Float64(phi2 - phi1)) tmp = 0.0 if (lambda2 <= 2.4e+96) tmp = t_0; elseif (lambda2 <= 2.6e+108) tmp = Float64(cos(Float64(phi2 * 0.5)) * Float64(R * lambda2)); elseif (lambda2 <= 1.65e+138) tmp = t_0; else tmp = Float64(cos(Float64(0.5 * phi1)) * Float64(R * lambda2)); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) t_0 = R * (phi2 - phi1); tmp = 0.0; if (lambda2 <= 2.4e+96) tmp = t_0; elseif (lambda2 <= 2.6e+108) tmp = cos((phi2 * 0.5)) * (R * lambda2); elseif (lambda2 <= 1.65e+138) tmp = t_0; else tmp = cos((0.5 * phi1)) * (R * lambda2); end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(R * N[(phi2 - phi1), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[lambda2, 2.4e+96], t$95$0, If[LessEqual[lambda2, 2.6e+108], N[(N[Cos[N[(phi2 * 0.5), $MachinePrecision]], $MachinePrecision] * N[(R * lambda2), $MachinePrecision]), $MachinePrecision], If[LessEqual[lambda2, 1.65e+138], t$95$0, N[(N[Cos[N[(0.5 * phi1), $MachinePrecision]], $MachinePrecision] * N[(R * lambda2), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := R \cdot \left(\phi_2 - \phi_1\right)\\
\mathbf{if}\;\lambda_2 \leq 2.4 \cdot 10^{+96}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;\lambda_2 \leq 2.6 \cdot 10^{+108}:\\
\;\;\;\;\cos \left(\phi_2 \cdot 0.5\right) \cdot \left(R \cdot \lambda_2\right)\\
\mathbf{elif}\;\lambda_2 \leq 1.65 \cdot 10^{+138}:\\
\;\;\;\;t_0\\
\mathbf{else}:\\
\;\;\;\;\cos \left(0.5 \cdot \phi_1\right) \cdot \left(R \cdot \lambda_2\right)\\
\end{array}
\end{array}
if lambda2 < 2.39999999999999993e96 or 2.6000000000000002e108 < lambda2 < 1.64999999999999989e138Initial program 60.4%
hypot-def96.2%
Simplified96.2%
Taylor expanded in phi1 around -inf 29.9%
mul-1-neg29.9%
unsub-neg29.9%
Simplified29.9%
if 2.39999999999999993e96 < lambda2 < 2.6000000000000002e108Initial program 100.0%
hypot-def100.0%
Simplified100.0%
Taylor expanded in lambda2 around inf 100.0%
*-commutative100.0%
*-commutative100.0%
+-commutative100.0%
Simplified100.0%
Taylor expanded in phi1 around 0 76.8%
associate-*r*76.8%
*-commutative76.8%
Simplified76.8%
if 1.64999999999999989e138 < lambda2 Initial program 30.3%
hypot-def97.6%
Simplified97.6%
Taylor expanded in lambda2 around inf 47.0%
*-commutative47.0%
*-commutative47.0%
+-commutative47.0%
Simplified47.0%
Taylor expanded in phi2 around 0 49.3%
associate-*r*49.3%
*-commutative49.3%
Simplified49.3%
Final simplification33.2%
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* R (- phi2 phi1))))
(if (<= lambda2 1.1e+97)
t_0
(if (<= lambda2 5.4e+108)
(* R (* lambda2 (cos (* phi2 0.5))))
(if (<= lambda2 1.05e+138) t_0 (* (cos (* 0.5 phi1)) (* R lambda2)))))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = R * (phi2 - phi1);
double tmp;
if (lambda2 <= 1.1e+97) {
tmp = t_0;
} else if (lambda2 <= 5.4e+108) {
tmp = R * (lambda2 * cos((phi2 * 0.5)));
} else if (lambda2 <= 1.05e+138) {
tmp = t_0;
} else {
tmp = cos((0.5 * phi1)) * (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) :: t_0
real(8) :: tmp
t_0 = r * (phi2 - phi1)
if (lambda2 <= 1.1d+97) then
tmp = t_0
else if (lambda2 <= 5.4d+108) then
tmp = r * (lambda2 * cos((phi2 * 0.5d0)))
else if (lambda2 <= 1.05d+138) then
tmp = t_0
else
tmp = cos((0.5d0 * phi1)) * (r * lambda2)
end if
code = tmp
end function
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = R * (phi2 - phi1);
double tmp;
if (lambda2 <= 1.1e+97) {
tmp = t_0;
} else if (lambda2 <= 5.4e+108) {
tmp = R * (lambda2 * Math.cos((phi2 * 0.5)));
} else if (lambda2 <= 1.05e+138) {
tmp = t_0;
} else {
tmp = Math.cos((0.5 * phi1)) * (R * lambda2);
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): t_0 = R * (phi2 - phi1) tmp = 0 if lambda2 <= 1.1e+97: tmp = t_0 elif lambda2 <= 5.4e+108: tmp = R * (lambda2 * math.cos((phi2 * 0.5))) elif lambda2 <= 1.05e+138: tmp = t_0 else: tmp = math.cos((0.5 * phi1)) * (R * lambda2) return tmp
function code(R, lambda1, lambda2, phi1, phi2) t_0 = Float64(R * Float64(phi2 - phi1)) tmp = 0.0 if (lambda2 <= 1.1e+97) tmp = t_0; elseif (lambda2 <= 5.4e+108) tmp = Float64(R * Float64(lambda2 * cos(Float64(phi2 * 0.5)))); elseif (lambda2 <= 1.05e+138) tmp = t_0; else tmp = Float64(cos(Float64(0.5 * phi1)) * Float64(R * lambda2)); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) t_0 = R * (phi2 - phi1); tmp = 0.0; if (lambda2 <= 1.1e+97) tmp = t_0; elseif (lambda2 <= 5.4e+108) tmp = R * (lambda2 * cos((phi2 * 0.5))); elseif (lambda2 <= 1.05e+138) tmp = t_0; else tmp = cos((0.5 * phi1)) * (R * lambda2); end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(R * N[(phi2 - phi1), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[lambda2, 1.1e+97], t$95$0, If[LessEqual[lambda2, 5.4e+108], N[(R * N[(lambda2 * N[Cos[N[(phi2 * 0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[lambda2, 1.05e+138], t$95$0, N[(N[Cos[N[(0.5 * phi1), $MachinePrecision]], $MachinePrecision] * N[(R * lambda2), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := R \cdot \left(\phi_2 - \phi_1\right)\\
\mathbf{if}\;\lambda_2 \leq 1.1 \cdot 10^{+97}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;\lambda_2 \leq 5.4 \cdot 10^{+108}:\\
\;\;\;\;R \cdot \left(\lambda_2 \cdot \cos \left(\phi_2 \cdot 0.5\right)\right)\\
\mathbf{elif}\;\lambda_2 \leq 1.05 \cdot 10^{+138}:\\
\;\;\;\;t_0\\
\mathbf{else}:\\
\;\;\;\;\cos \left(0.5 \cdot \phi_1\right) \cdot \left(R \cdot \lambda_2\right)\\
\end{array}
\end{array}
if lambda2 < 1.1e97 or 5.4e108 < lambda2 < 1.05000000000000003e138Initial program 60.4%
hypot-def96.2%
Simplified96.2%
Taylor expanded in phi1 around -inf 29.9%
mul-1-neg29.9%
unsub-neg29.9%
Simplified29.9%
if 1.1e97 < lambda2 < 5.4e108Initial program 100.0%
hypot-def100.0%
Simplified100.0%
Taylor expanded in lambda2 around inf 100.0%
*-commutative100.0%
*-commutative100.0%
+-commutative100.0%
Simplified100.0%
Taylor expanded in phi1 around 0 76.8%
*-commutative76.8%
Simplified76.8%
if 1.05000000000000003e138 < lambda2 Initial program 30.3%
hypot-def97.6%
Simplified97.6%
Taylor expanded in lambda2 around inf 47.0%
*-commutative47.0%
*-commutative47.0%
+-commutative47.0%
Simplified47.0%
Taylor expanded in phi2 around 0 49.3%
associate-*r*49.3%
*-commutative49.3%
Simplified49.3%
Final simplification33.2%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= lambda2 3.4e+138) (* R (- phi2 phi1)) (* (cos (* 0.5 phi1)) (* R lambda2))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (lambda2 <= 3.4e+138) {
tmp = R * (phi2 - phi1);
} else {
tmp = cos((0.5 * phi1)) * (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 (lambda2 <= 3.4d+138) then
tmp = r * (phi2 - phi1)
else
tmp = cos((0.5d0 * phi1)) * (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 (lambda2 <= 3.4e+138) {
tmp = R * (phi2 - phi1);
} else {
tmp = Math.cos((0.5 * phi1)) * (R * lambda2);
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if lambda2 <= 3.4e+138: tmp = R * (phi2 - phi1) else: tmp = math.cos((0.5 * phi1)) * (R * lambda2) return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (lambda2 <= 3.4e+138) tmp = Float64(R * Float64(phi2 - phi1)); else tmp = Float64(cos(Float64(0.5 * phi1)) * Float64(R * lambda2)); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (lambda2 <= 3.4e+138) tmp = R * (phi2 - phi1); else tmp = cos((0.5 * phi1)) * (R * lambda2); end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[lambda2, 3.4e+138], N[(R * N[(phi2 - phi1), $MachinePrecision]), $MachinePrecision], N[(N[Cos[N[(0.5 * phi1), $MachinePrecision]], $MachinePrecision] * N[(R * lambda2), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\lambda_2 \leq 3.4 \cdot 10^{+138}:\\
\;\;\;\;R \cdot \left(\phi_2 - \phi_1\right)\\
\mathbf{else}:\\
\;\;\;\;\cos \left(0.5 \cdot \phi_1\right) \cdot \left(R \cdot \lambda_2\right)\\
\end{array}
\end{array}
if lambda2 < 3.40000000000000011e138Initial program 60.9%
hypot-def96.3%
Simplified96.3%
Taylor expanded in phi1 around -inf 29.5%
mul-1-neg29.5%
unsub-neg29.5%
Simplified29.5%
if 3.40000000000000011e138 < lambda2 Initial program 30.3%
hypot-def97.6%
Simplified97.6%
Taylor expanded in lambda2 around inf 47.0%
*-commutative47.0%
*-commutative47.0%
+-commutative47.0%
Simplified47.0%
Taylor expanded in phi2 around 0 49.3%
associate-*r*49.3%
*-commutative49.3%
Simplified49.3%
Final simplification32.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 56.5%
hypot-def96.5%
Simplified96.5%
expm1-log1p-u96.5%
div-inv96.5%
metadata-eval96.5%
Applied egg-rr96.5%
Taylor expanded in phi2 around 0 90.5%
Taylor expanded in phi1 around 0 83.9%
Final simplification83.9%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= phi1 -175000000.0) (* R (- phi1)) (* R phi2)))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi1 <= -175000000.0) {
tmp = R * -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 <= (-175000000.0d0)) then
tmp = r * -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 <= -175000000.0) {
tmp = R * -phi1;
} else {
tmp = R * phi2;
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi1 <= -175000000.0: tmp = R * -phi1 else: tmp = R * phi2 return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi1 <= -175000000.0) tmp = Float64(R * Float64(-phi1)); else tmp = Float64(R * phi2); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (phi1 <= -175000000.0) tmp = R * -phi1; else tmp = R * phi2; end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi1, -175000000.0], N[(R * (-phi1)), $MachinePrecision], N[(R * phi2), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_1 \leq -175000000:\\
\;\;\;\;R \cdot \left(-\phi_1\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \phi_2\\
\end{array}
\end{array}
if phi1 < -1.75e8Initial program 48.3%
hypot-def91.5%
Simplified91.5%
Taylor expanded in phi1 around -inf 65.6%
mul-1-neg65.6%
*-commutative65.6%
distribute-rgt-neg-in65.6%
Simplified65.6%
if -1.75e8 < phi1 Initial program 58.8%
hypot-def97.9%
Simplified97.9%
Taylor expanded in phi2 around inf 16.9%
*-commutative16.9%
Simplified16.9%
Final simplification27.8%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (* R (- phi2 phi1)))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * (phi2 - phi1);
}
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 - phi1)
end function
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * (phi2 - phi1);
}
def code(R, lambda1, lambda2, phi1, phi2): return R * (phi2 - phi1)
function code(R, lambda1, lambda2, phi1, phi2) return Float64(R * Float64(phi2 - phi1)) end
function tmp = code(R, lambda1, lambda2, phi1, phi2) tmp = R * (phi2 - phi1); end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := N[(R * N[(phi2 - phi1), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
R \cdot \left(\phi_2 - \phi_1\right)
\end{array}
Initial program 56.5%
hypot-def96.5%
Simplified96.5%
Taylor expanded in phi1 around -inf 28.4%
mul-1-neg28.4%
unsub-neg28.4%
Simplified28.4%
Final simplification28.4%
(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 56.5%
hypot-def96.5%
Simplified96.5%
Taylor expanded in phi2 around inf 15.8%
*-commutative15.8%
Simplified15.8%
Final simplification15.8%
herbie shell --seed 2023338
(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))))))