
(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 13 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}
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. (FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= phi2 2.1e-17) (* R (hypot phi1 (* (- lambda1 lambda2) (cos (* phi1 0.5))))) (* R (hypot phi2 (* (- lambda1 lambda2) (cos (* phi2 0.5)))))))
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 2.1e-17) {
tmp = R * hypot(phi1, ((lambda1 - lambda2) * cos((phi1 * 0.5))));
} else {
tmp = R * hypot(phi2, ((lambda1 - lambda2) * cos((phi2 * 0.5))));
}
return tmp;
}
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 2.1e-17) {
tmp = R * Math.hypot(phi1, ((lambda1 - lambda2) * Math.cos((phi1 * 0.5))));
} else {
tmp = R * Math.hypot(phi2, ((lambda1 - lambda2) * Math.cos((phi2 * 0.5))));
}
return tmp;
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi2 <= 2.1e-17: tmp = R * math.hypot(phi1, ((lambda1 - lambda2) * math.cos((phi1 * 0.5)))) else: tmp = R * math.hypot(phi2, ((lambda1 - lambda2) * math.cos((phi2 * 0.5)))) return tmp
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi2 <= 2.1e-17) tmp = Float64(R * hypot(phi1, Float64(Float64(lambda1 - lambda2) * cos(Float64(phi1 * 0.5))))); else tmp = Float64(R * hypot(phi2, Float64(Float64(lambda1 - lambda2) * cos(Float64(phi2 * 0.5))))); end return tmp end
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2)
tmp = 0.0;
if (phi2 <= 2.1e-17)
tmp = R * hypot(phi1, ((lambda1 - lambda2) * cos((phi1 * 0.5))));
else
tmp = R * hypot(phi2, ((lambda1 - lambda2) * cos((phi2 * 0.5))));
end
tmp_2 = tmp;
end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi2, 2.1e-17], N[(R * N[Sqrt[phi1 ^ 2 + N[(N[(lambda1 - lambda2), $MachinePrecision] * N[Cos[N[(phi1 * 0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision], N[(R * N[Sqrt[phi2 ^ 2 + N[(N[(lambda1 - lambda2), $MachinePrecision] * N[Cos[N[(phi2 * 0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
\mathbf{if}\;\phi_2 \leq 2.1 \cdot 10^{-17}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\phi_1, \left(\lambda_1 - \lambda_2\right) \cdot \cos \left(\phi_1 \cdot 0.5\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\phi_2, \left(\lambda_1 - \lambda_2\right) \cdot \cos \left(\phi_2 \cdot 0.5\right)\right)\\
\end{array}
\end{array}
if phi2 < 2.09999999999999992e-17Initial program 64.4%
Taylor expanded in phi2 around 0
+-commutativeN/A
unpow2N/A
unpow2N/A
unpow2N/A
unswap-sqrN/A
lower-hypot.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower--.f64N/A
lower-cos.f64N/A
lower-*.f6479.5
Simplified79.5%
if 2.09999999999999992e-17 < phi2 Initial program 53.9%
Taylor expanded in phi1 around 0
+-commutativeN/A
unpow2N/A
unpow2N/A
unpow2N/A
unswap-sqrN/A
lower-hypot.f64N/A
lower-*.f64N/A
lower-cos.f64N/A
lower-*.f64N/A
lower--.f6484.2
Simplified84.2%
Final simplification80.9%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. (FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= phi2 8.2e+14) (* R (hypot phi1 (* (- lambda1 lambda2) (cos (* phi1 0.5))))) (* R (fma phi2 (/ phi1 (- phi2)) phi2))))
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 8.2e+14) {
tmp = R * hypot(phi1, ((lambda1 - lambda2) * cos((phi1 * 0.5))));
} else {
tmp = R * fma(phi2, (phi1 / -phi2), phi2);
}
return tmp;
}
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi2 <= 8.2e+14) tmp = Float64(R * hypot(phi1, Float64(Float64(lambda1 - lambda2) * cos(Float64(phi1 * 0.5))))); else tmp = Float64(R * fma(phi2, Float64(phi1 / Float64(-phi2)), phi2)); end return tmp end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi2, 8.2e+14], N[(R * N[Sqrt[phi1 ^ 2 + N[(N[(lambda1 - lambda2), $MachinePrecision] * N[Cos[N[(phi1 * 0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision], N[(R * N[(phi2 * N[(phi1 / (-phi2)), $MachinePrecision] + phi2), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
\mathbf{if}\;\phi_2 \leq 8.2 \cdot 10^{+14}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\phi_1, \left(\lambda_1 - \lambda_2\right) \cdot \cos \left(\phi_1 \cdot 0.5\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \mathsf{fma}\left(\phi_2, \frac{\phi_1}{-\phi_2}, \phi_2\right)\\
\end{array}
\end{array}
if phi2 < 8.2e14Initial program 64.4%
Taylor expanded in phi2 around 0
+-commutativeN/A
unpow2N/A
unpow2N/A
unpow2N/A
unswap-sqrN/A
lower-hypot.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower--.f64N/A
lower-cos.f64N/A
lower-*.f6478.7
Simplified78.7%
if 8.2e14 < phi2 Initial program 52.6%
Taylor expanded in phi2 around inf
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
lower-fma.f64N/A
mul-1-negN/A
distribute-neg-frac2N/A
mul-1-negN/A
lower-/.f64N/A
mul-1-negN/A
lower-neg.f6474.8
Simplified74.8%
Final simplification77.8%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. (FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= phi2 8.2e+14) (* R (hypot phi1 (- lambda1 lambda2))) (* R (fma phi2 (/ phi1 (- phi2)) phi2))))
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 8.2e+14) {
tmp = R * hypot(phi1, (lambda1 - lambda2));
} else {
tmp = R * fma(phi2, (phi1 / -phi2), phi2);
}
return tmp;
}
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi2 <= 8.2e+14) tmp = Float64(R * hypot(phi1, Float64(lambda1 - lambda2))); else tmp = Float64(R * fma(phi2, Float64(phi1 / Float64(-phi2)), phi2)); end return tmp end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi2, 8.2e+14], N[(R * N[Sqrt[phi1 ^ 2 + N[(lambda1 - lambda2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision], N[(R * N[(phi2 * N[(phi1 / (-phi2)), $MachinePrecision] + phi2), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
\mathbf{if}\;\phi_2 \leq 8.2 \cdot 10^{+14}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\phi_1, \lambda_1 - \lambda_2\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \mathsf{fma}\left(\phi_2, \frac{\phi_1}{-\phi_2}, \phi_2\right)\\
\end{array}
\end{array}
if phi2 < 8.2e14Initial program 64.4%
Taylor expanded in phi2 around 0
+-commutativeN/A
unpow2N/A
unpow2N/A
unpow2N/A
unswap-sqrN/A
lower-hypot.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower--.f64N/A
lower-cos.f64N/A
lower-*.f6478.7
Simplified78.7%
Taylor expanded in phi1 around 0
lower--.f6471.5
Simplified71.5%
if 8.2e14 < phi2 Initial program 52.6%
Taylor expanded in phi2 around inf
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
lower-fma.f64N/A
mul-1-negN/A
distribute-neg-frac2N/A
mul-1-negN/A
lower-/.f64N/A
mul-1-negN/A
lower-neg.f6474.8
Simplified74.8%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(if (<= phi1 -1.35e+117)
(* R (fma phi1 (/ phi2 phi1) (- phi1)))
(if (<= phi1 -1.86e-51)
(* phi2 (- R (/ (* R phi1) phi2)))
(if (<= phi1 -5.1e-142)
(* R (fma -0.5 (/ (* phi2 phi2) lambda1) (- lambda2 lambda1)))
(*
R
(sqrt (fma (- lambda1 lambda2) (- lambda1 lambda2) (* phi2 phi2))))))))assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi1 <= -1.35e+117) {
tmp = R * fma(phi1, (phi2 / phi1), -phi1);
} else if (phi1 <= -1.86e-51) {
tmp = phi2 * (R - ((R * phi1) / phi2));
} else if (phi1 <= -5.1e-142) {
tmp = R * fma(-0.5, ((phi2 * phi2) / lambda1), (lambda2 - lambda1));
} else {
tmp = R * sqrt(fma((lambda1 - lambda2), (lambda1 - lambda2), (phi2 * phi2)));
}
return tmp;
}
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi1 <= -1.35e+117) tmp = Float64(R * fma(phi1, Float64(phi2 / phi1), Float64(-phi1))); elseif (phi1 <= -1.86e-51) tmp = Float64(phi2 * Float64(R - Float64(Float64(R * phi1) / phi2))); elseif (phi1 <= -5.1e-142) tmp = Float64(R * fma(-0.5, Float64(Float64(phi2 * phi2) / lambda1), Float64(lambda2 - lambda1))); else tmp = Float64(R * sqrt(fma(Float64(lambda1 - lambda2), Float64(lambda1 - lambda2), Float64(phi2 * phi2)))); end return tmp end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi1, -1.35e+117], N[(R * N[(phi1 * N[(phi2 / phi1), $MachinePrecision] + (-phi1)), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, -1.86e-51], N[(phi2 * N[(R - N[(N[(R * phi1), $MachinePrecision] / phi2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, -5.1e-142], N[(R * N[(-0.5 * N[(N[(phi2 * phi2), $MachinePrecision] / lambda1), $MachinePrecision] + N[(lambda2 - lambda1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(R * N[Sqrt[N[(N[(lambda1 - lambda2), $MachinePrecision] * N[(lambda1 - lambda2), $MachinePrecision] + N[(phi2 * phi2), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
\mathbf{if}\;\phi_1 \leq -1.35 \cdot 10^{+117}:\\
\;\;\;\;R \cdot \mathsf{fma}\left(\phi_1, \frac{\phi_2}{\phi_1}, -\phi_1\right)\\
\mathbf{elif}\;\phi_1 \leq -1.86 \cdot 10^{-51}:\\
\;\;\;\;\phi_2 \cdot \left(R - \frac{R \cdot \phi_1}{\phi_2}\right)\\
\mathbf{elif}\;\phi_1 \leq -5.1 \cdot 10^{-142}:\\
\;\;\;\;R \cdot \mathsf{fma}\left(-0.5, \frac{\phi_2 \cdot \phi_2}{\lambda_1}, \lambda_2 - \lambda_1\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \sqrt{\mathsf{fma}\left(\lambda_1 - \lambda_2, \lambda_1 - \lambda_2, \phi_2 \cdot \phi_2\right)}\\
\end{array}
\end{array}
if phi1 < -1.3500000000000001e117Initial program 46.3%
Taylor expanded in phi1 around -inf
associate-*r*N/A
+-commutativeN/A
distribute-lft-inN/A
mul-1-negN/A
distribute-lft-neg-inN/A
mul-1-negN/A
distribute-rgt-neg-outN/A
remove-double-negN/A
*-rgt-identityN/A
lower-fma.f64N/A
lower-/.f64N/A
mul-1-negN/A
lower-neg.f6486.1
Simplified86.1%
if -1.3500000000000001e117 < phi1 < -1.8600000000000001e-51Initial program 55.6%
Taylor expanded in phi2 around 0
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-cos.f64N/A
lower-*.f6455.8
Simplified55.8%
Taylor expanded in phi2 around inf
lower-*.f64N/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6442.9
Simplified42.9%
if -1.8600000000000001e-51 < phi1 < -5.1000000000000001e-142Initial program 72.8%
Taylor expanded in phi2 around 0
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-cos.f64N/A
lower-*.f6472.8
Simplified72.8%
Taylor expanded in phi1 around 0
lower-sqrt.f64N/A
+-commutativeN/A
unpow2N/A
lower-fma.f64N/A
lower--.f64N/A
lower--.f64N/A
unpow2N/A
lower-*.f6472.8
Simplified72.8%
Taylor expanded in lambda1 around -inf
associate-*r*N/A
+-commutativeN/A
distribute-lft-inN/A
mul-1-negN/A
distribute-lft-neg-inN/A
mul-1-negN/A
distribute-rgt-neg-outN/A
remove-double-negN/A
*-rgt-identityN/A
lower-fma.f64N/A
Simplified58.8%
Taylor expanded in phi2 around 0
+-commutativeN/A
associate--l+N/A
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
lower--.f6458.8
Simplified58.8%
if -5.1000000000000001e-142 < phi1 Initial program 66.9%
Taylor expanded in phi2 around 0
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-cos.f64N/A
lower-*.f6464.4
Simplified64.4%
Taylor expanded in phi1 around 0
lower-sqrt.f64N/A
+-commutativeN/A
unpow2N/A
lower-fma.f64N/A
lower--.f64N/A
lower--.f64N/A
unpow2N/A
lower-*.f6455.1
Simplified55.1%
Final simplification60.5%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(if (<= phi1 -1.35e+117)
(* R (fma phi1 (/ phi2 phi1) (- phi1)))
(if (<= phi1 -1.86e-51)
(* phi2 (- R (/ (* R phi1) phi2)))
(if (<= phi1 2.2e-187)
(* R (fma -0.5 (/ (* phi2 phi2) lambda1) (- lambda2 lambda1)))
(* phi2 R)))))assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi1 <= -1.35e+117) {
tmp = R * fma(phi1, (phi2 / phi1), -phi1);
} else if (phi1 <= -1.86e-51) {
tmp = phi2 * (R - ((R * phi1) / phi2));
} else if (phi1 <= 2.2e-187) {
tmp = R * fma(-0.5, ((phi2 * phi2) / lambda1), (lambda2 - lambda1));
} else {
tmp = phi2 * R;
}
return tmp;
}
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi1 <= -1.35e+117) tmp = Float64(R * fma(phi1, Float64(phi2 / phi1), Float64(-phi1))); elseif (phi1 <= -1.86e-51) tmp = Float64(phi2 * Float64(R - Float64(Float64(R * phi1) / phi2))); elseif (phi1 <= 2.2e-187) tmp = Float64(R * fma(-0.5, Float64(Float64(phi2 * phi2) / lambda1), Float64(lambda2 - lambda1))); else tmp = Float64(phi2 * R); end return tmp end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi1, -1.35e+117], N[(R * N[(phi1 * N[(phi2 / phi1), $MachinePrecision] + (-phi1)), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, -1.86e-51], N[(phi2 * N[(R - N[(N[(R * phi1), $MachinePrecision] / phi2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, 2.2e-187], N[(R * N[(-0.5 * N[(N[(phi2 * phi2), $MachinePrecision] / lambda1), $MachinePrecision] + N[(lambda2 - lambda1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(phi2 * R), $MachinePrecision]]]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
\mathbf{if}\;\phi_1 \leq -1.35 \cdot 10^{+117}:\\
\;\;\;\;R \cdot \mathsf{fma}\left(\phi_1, \frac{\phi_2}{\phi_1}, -\phi_1\right)\\
\mathbf{elif}\;\phi_1 \leq -1.86 \cdot 10^{-51}:\\
\;\;\;\;\phi_2 \cdot \left(R - \frac{R \cdot \phi_1}{\phi_2}\right)\\
\mathbf{elif}\;\phi_1 \leq 2.2 \cdot 10^{-187}:\\
\;\;\;\;R \cdot \mathsf{fma}\left(-0.5, \frac{\phi_2 \cdot \phi_2}{\lambda_1}, \lambda_2 - \lambda_1\right)\\
\mathbf{else}:\\
\;\;\;\;\phi_2 \cdot R\\
\end{array}
\end{array}
if phi1 < -1.3500000000000001e117Initial program 46.3%
Taylor expanded in phi1 around -inf
associate-*r*N/A
+-commutativeN/A
distribute-lft-inN/A
mul-1-negN/A
distribute-lft-neg-inN/A
mul-1-negN/A
distribute-rgt-neg-outN/A
remove-double-negN/A
*-rgt-identityN/A
lower-fma.f64N/A
lower-/.f64N/A
mul-1-negN/A
lower-neg.f6486.1
Simplified86.1%
if -1.3500000000000001e117 < phi1 < -1.8600000000000001e-51Initial program 55.6%
Taylor expanded in phi2 around 0
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-cos.f64N/A
lower-*.f6455.8
Simplified55.8%
Taylor expanded in phi2 around inf
lower-*.f64N/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6442.9
Simplified42.9%
if -1.8600000000000001e-51 < phi1 < 2.20000000000000008e-187Initial program 71.8%
Taylor expanded in phi2 around 0
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-cos.f64N/A
lower-*.f6469.7
Simplified69.7%
Taylor expanded in phi1 around 0
lower-sqrt.f64N/A
+-commutativeN/A
unpow2N/A
lower-fma.f64N/A
lower--.f64N/A
lower--.f64N/A
unpow2N/A
lower-*.f6469.7
Simplified69.7%
Taylor expanded in lambda1 around -inf
associate-*r*N/A
+-commutativeN/A
distribute-lft-inN/A
mul-1-negN/A
distribute-lft-neg-inN/A
mul-1-negN/A
distribute-rgt-neg-outN/A
remove-double-negN/A
*-rgt-identityN/A
lower-fma.f64N/A
Simplified36.6%
Taylor expanded in phi2 around 0
+-commutativeN/A
associate--l+N/A
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
lower--.f6436.8
Simplified36.8%
if 2.20000000000000008e-187 < phi1 Initial program 63.7%
Taylor expanded in phi2 around 0
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-cos.f64N/A
lower-*.f6461.3
Simplified61.3%
Taylor expanded in phi2 around inf
lower-*.f6419.0
Simplified19.0%
Final simplification41.6%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(if (<= phi1 -5e+124)
(* R (fma phi1 (/ phi2 phi1) (- phi1)))
(*
R
(sqrt
(+
(* (- lambda1 lambda2) (- lambda1 lambda2))
(* (- phi1 phi2) (- phi1 phi2)))))))assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi1 <= -5e+124) {
tmp = R * fma(phi1, (phi2 / phi1), -phi1);
} else {
tmp = R * sqrt((((lambda1 - lambda2) * (lambda1 - lambda2)) + ((phi1 - phi2) * (phi1 - phi2))));
}
return tmp;
}
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi1 <= -5e+124) tmp = Float64(R * fma(phi1, Float64(phi2 / phi1), Float64(-phi1))); else tmp = Float64(R * sqrt(Float64(Float64(Float64(lambda1 - lambda2) * Float64(lambda1 - lambda2)) + Float64(Float64(phi1 - phi2) * Float64(phi1 - phi2))))); end return tmp end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi1, -5e+124], N[(R * N[(phi1 * N[(phi2 / phi1), $MachinePrecision] + (-phi1)), $MachinePrecision]), $MachinePrecision], N[(R * N[Sqrt[N[(N[(N[(lambda1 - lambda2), $MachinePrecision] * N[(lambda1 - lambda2), $MachinePrecision]), $MachinePrecision] + N[(N[(phi1 - phi2), $MachinePrecision] * N[(phi1 - phi2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
\mathbf{if}\;\phi_1 \leq -5 \cdot 10^{+124}:\\
\;\;\;\;R \cdot \mathsf{fma}\left(\phi_1, \frac{\phi_2}{\phi_1}, -\phi_1\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \sqrt{\left(\lambda_1 - \lambda_2\right) \cdot \left(\lambda_1 - \lambda_2\right) + \left(\phi_1 - \phi_2\right) \cdot \left(\phi_1 - \phi_2\right)}\\
\end{array}
\end{array}
if phi1 < -4.9999999999999996e124Initial program 45.3%
Taylor expanded in phi1 around -inf
associate-*r*N/A
+-commutativeN/A
distribute-lft-inN/A
mul-1-negN/A
distribute-lft-neg-inN/A
mul-1-negN/A
distribute-rgt-neg-outN/A
remove-double-negN/A
*-rgt-identityN/A
lower-fma.f64N/A
lower-/.f64N/A
mul-1-negN/A
lower-neg.f6485.9
Simplified85.9%
if -4.9999999999999996e124 < phi1 Initial program 65.8%
Taylor expanded in phi2 around 0
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-cos.f64N/A
lower-*.f6463.9
Simplified63.9%
Taylor expanded in phi1 around 0
unpow2N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f6463.2
Simplified63.2%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(if (<= phi1 -1.35e+117)
(* R (fma phi1 (/ phi2 phi1) (- phi1)))
(if (<= phi1 -1.86e-51)
(* phi2 (- R (/ (* R phi1) phi2)))
(if (<= phi1 4.6e-183)
(* lambda2 (- R (/ (* R lambda1) lambda2)))
(* phi2 R)))))assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi1 <= -1.35e+117) {
tmp = R * fma(phi1, (phi2 / phi1), -phi1);
} else if (phi1 <= -1.86e-51) {
tmp = phi2 * (R - ((R * phi1) / phi2));
} else if (phi1 <= 4.6e-183) {
tmp = lambda2 * (R - ((R * lambda1) / lambda2));
} else {
tmp = phi2 * R;
}
return tmp;
}
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi1 <= -1.35e+117) tmp = Float64(R * fma(phi1, Float64(phi2 / phi1), Float64(-phi1))); elseif (phi1 <= -1.86e-51) tmp = Float64(phi2 * Float64(R - Float64(Float64(R * phi1) / phi2))); elseif (phi1 <= 4.6e-183) tmp = Float64(lambda2 * Float64(R - Float64(Float64(R * lambda1) / lambda2))); else tmp = Float64(phi2 * R); end return tmp end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi1, -1.35e+117], N[(R * N[(phi1 * N[(phi2 / phi1), $MachinePrecision] + (-phi1)), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, -1.86e-51], N[(phi2 * N[(R - N[(N[(R * phi1), $MachinePrecision] / phi2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, 4.6e-183], N[(lambda2 * N[(R - N[(N[(R * lambda1), $MachinePrecision] / lambda2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(phi2 * R), $MachinePrecision]]]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
\mathbf{if}\;\phi_1 \leq -1.35 \cdot 10^{+117}:\\
\;\;\;\;R \cdot \mathsf{fma}\left(\phi_1, \frac{\phi_2}{\phi_1}, -\phi_1\right)\\
\mathbf{elif}\;\phi_1 \leq -1.86 \cdot 10^{-51}:\\
\;\;\;\;\phi_2 \cdot \left(R - \frac{R \cdot \phi_1}{\phi_2}\right)\\
\mathbf{elif}\;\phi_1 \leq 4.6 \cdot 10^{-183}:\\
\;\;\;\;\lambda_2 \cdot \left(R - \frac{R \cdot \lambda_1}{\lambda_2}\right)\\
\mathbf{else}:\\
\;\;\;\;\phi_2 \cdot R\\
\end{array}
\end{array}
if phi1 < -1.3500000000000001e117Initial program 46.3%
Taylor expanded in phi1 around -inf
associate-*r*N/A
+-commutativeN/A
distribute-lft-inN/A
mul-1-negN/A
distribute-lft-neg-inN/A
mul-1-negN/A
distribute-rgt-neg-outN/A
remove-double-negN/A
*-rgt-identityN/A
lower-fma.f64N/A
lower-/.f64N/A
mul-1-negN/A
lower-neg.f6486.1
Simplified86.1%
if -1.3500000000000001e117 < phi1 < -1.8600000000000001e-51Initial program 55.6%
Taylor expanded in phi2 around 0
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-cos.f64N/A
lower-*.f6455.8
Simplified55.8%
Taylor expanded in phi2 around inf
lower-*.f64N/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6442.9
Simplified42.9%
if -1.8600000000000001e-51 < phi1 < 4.60000000000000032e-183Initial program 72.2%
Taylor expanded in phi2 around 0
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-cos.f64N/A
lower-*.f6470.1
Simplified70.1%
Taylor expanded in phi1 around 0
lower-sqrt.f64N/A
+-commutativeN/A
unpow2N/A
lower-fma.f64N/A
lower--.f64N/A
lower--.f64N/A
unpow2N/A
lower-*.f6470.1
Simplified70.1%
Taylor expanded in lambda2 around inf
lower-*.f64N/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6426.5
Simplified26.5%
if 4.60000000000000032e-183 < phi1 Initial program 63.3%
Taylor expanded in phi2 around 0
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-cos.f64N/A
lower-*.f6460.9
Simplified60.9%
Taylor expanded in phi2 around inf
lower-*.f6419.2
Simplified19.2%
Final simplification38.6%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(if (<= phi1 -2.05e-51)
(* R (fma phi1 (/ phi2 phi1) (- phi1)))
(if (<= phi1 4.6e-183)
(* lambda2 (- R (/ (* R lambda1) lambda2)))
(* phi2 R))))assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi1 <= -2.05e-51) {
tmp = R * fma(phi1, (phi2 / phi1), -phi1);
} else if (phi1 <= 4.6e-183) {
tmp = lambda2 * (R - ((R * lambda1) / lambda2));
} else {
tmp = phi2 * R;
}
return tmp;
}
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi1 <= -2.05e-51) tmp = Float64(R * fma(phi1, Float64(phi2 / phi1), Float64(-phi1))); elseif (phi1 <= 4.6e-183) tmp = Float64(lambda2 * Float64(R - Float64(Float64(R * lambda1) / lambda2))); else tmp = Float64(phi2 * R); end return tmp end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi1, -2.05e-51], N[(R * N[(phi1 * N[(phi2 / phi1), $MachinePrecision] + (-phi1)), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, 4.6e-183], N[(lambda2 * N[(R - N[(N[(R * lambda1), $MachinePrecision] / lambda2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(phi2 * R), $MachinePrecision]]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
\mathbf{if}\;\phi_1 \leq -2.05 \cdot 10^{-51}:\\
\;\;\;\;R \cdot \mathsf{fma}\left(\phi_1, \frac{\phi_2}{\phi_1}, -\phi_1\right)\\
\mathbf{elif}\;\phi_1 \leq 4.6 \cdot 10^{-183}:\\
\;\;\;\;\lambda_2 \cdot \left(R - \frac{R \cdot \lambda_1}{\lambda_2}\right)\\
\mathbf{else}:\\
\;\;\;\;\phi_2 \cdot R\\
\end{array}
\end{array}
if phi1 < -2.04999999999999987e-51Initial program 49.6%
Taylor expanded in phi1 around -inf
associate-*r*N/A
+-commutativeN/A
distribute-lft-inN/A
mul-1-negN/A
distribute-lft-neg-inN/A
mul-1-negN/A
distribute-rgt-neg-outN/A
remove-double-negN/A
*-rgt-identityN/A
lower-fma.f64N/A
lower-/.f64N/A
mul-1-negN/A
lower-neg.f6467.5
Simplified67.5%
if -2.04999999999999987e-51 < phi1 < 4.60000000000000032e-183Initial program 72.2%
Taylor expanded in phi2 around 0
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-cos.f64N/A
lower-*.f6470.1
Simplified70.1%
Taylor expanded in phi1 around 0
lower-sqrt.f64N/A
+-commutativeN/A
unpow2N/A
lower-fma.f64N/A
lower--.f64N/A
lower--.f64N/A
unpow2N/A
lower-*.f6470.1
Simplified70.1%
Taylor expanded in lambda2 around inf
lower-*.f64N/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6426.5
Simplified26.5%
if 4.60000000000000032e-183 < phi1 Initial program 63.3%
Taylor expanded in phi2 around 0
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-cos.f64N/A
lower-*.f6460.9
Simplified60.9%
Taylor expanded in phi2 around inf
lower-*.f6419.2
Simplified19.2%
Final simplification37.4%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. (FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= lambda2 9.4e+190) (* R (fma phi1 (/ phi2 phi1) (- phi1))) (* R lambda2)))
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (lambda2 <= 9.4e+190) {
tmp = R * fma(phi1, (phi2 / phi1), -phi1);
} else {
tmp = R * lambda2;
}
return tmp;
}
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (lambda2 <= 9.4e+190) tmp = Float64(R * fma(phi1, Float64(phi2 / phi1), Float64(-phi1))); else tmp = Float64(R * lambda2); end return tmp end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[lambda2, 9.4e+190], N[(R * N[(phi1 * N[(phi2 / phi1), $MachinePrecision] + (-phi1)), $MachinePrecision]), $MachinePrecision], N[(R * lambda2), $MachinePrecision]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
\mathbf{if}\;\lambda_2 \leq 9.4 \cdot 10^{+190}:\\
\;\;\;\;R \cdot \mathsf{fma}\left(\phi_1, \frac{\phi_2}{\phi_1}, -\phi_1\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \lambda_2\\
\end{array}
\end{array}
if lambda2 < 9.3999999999999996e190Initial program 62.1%
Taylor expanded in phi1 around -inf
associate-*r*N/A
+-commutativeN/A
distribute-lft-inN/A
mul-1-negN/A
distribute-lft-neg-inN/A
mul-1-negN/A
distribute-rgt-neg-outN/A
remove-double-negN/A
*-rgt-identityN/A
lower-fma.f64N/A
lower-/.f64N/A
mul-1-negN/A
lower-neg.f6434.8
Simplified34.8%
if 9.3999999999999996e190 < lambda2 Initial program 54.8%
Taylor expanded in phi2 around 0
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-cos.f64N/A
lower-*.f6454.8
Simplified54.8%
Taylor expanded in phi1 around 0
lower-sqrt.f64N/A
+-commutativeN/A
unpow2N/A
lower-fma.f64N/A
lower--.f64N/A
lower--.f64N/A
unpow2N/A
lower-*.f6454.8
Simplified54.8%
Taylor expanded in lambda2 around inf
*-commutativeN/A
lower-*.f6465.8
Simplified65.8%
Final simplification37.4%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(if (<= phi2 9.2e-189)
(- (* R phi1))
(if (<= phi2 4.9e-116)
(- (* R lambda1))
(if (<= phi2 3.3e+14) (* R lambda2) (* phi2 R)))))assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 9.2e-189) {
tmp = -(R * phi1);
} else if (phi2 <= 4.9e-116) {
tmp = -(R * lambda1);
} else if (phi2 <= 3.3e+14) {
tmp = R * lambda2;
} else {
tmp = phi2 * R;
}
return tmp;
}
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
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 <= 9.2d-189) then
tmp = -(r * phi1)
else if (phi2 <= 4.9d-116) then
tmp = -(r * lambda1)
else if (phi2 <= 3.3d+14) then
tmp = r * lambda2
else
tmp = phi2 * r
end if
code = tmp
end function
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 9.2e-189) {
tmp = -(R * phi1);
} else if (phi2 <= 4.9e-116) {
tmp = -(R * lambda1);
} else if (phi2 <= 3.3e+14) {
tmp = R * lambda2;
} else {
tmp = phi2 * R;
}
return tmp;
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi2 <= 9.2e-189: tmp = -(R * phi1) elif phi2 <= 4.9e-116: tmp = -(R * lambda1) elif phi2 <= 3.3e+14: tmp = R * lambda2 else: tmp = phi2 * R return tmp
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi2 <= 9.2e-189) tmp = Float64(-Float64(R * phi1)); elseif (phi2 <= 4.9e-116) tmp = Float64(-Float64(R * lambda1)); elseif (phi2 <= 3.3e+14) tmp = Float64(R * lambda2); else tmp = Float64(phi2 * R); end return tmp end
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2)
tmp = 0.0;
if (phi2 <= 9.2e-189)
tmp = -(R * phi1);
elseif (phi2 <= 4.9e-116)
tmp = -(R * lambda1);
elseif (phi2 <= 3.3e+14)
tmp = R * lambda2;
else
tmp = phi2 * R;
end
tmp_2 = tmp;
end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi2, 9.2e-189], (-N[(R * phi1), $MachinePrecision]), If[LessEqual[phi2, 4.9e-116], (-N[(R * lambda1), $MachinePrecision]), If[LessEqual[phi2, 3.3e+14], N[(R * lambda2), $MachinePrecision], N[(phi2 * R), $MachinePrecision]]]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
\mathbf{if}\;\phi_2 \leq 9.2 \cdot 10^{-189}:\\
\;\;\;\;-R \cdot \phi_1\\
\mathbf{elif}\;\phi_2 \leq 4.9 \cdot 10^{-116}:\\
\;\;\;\;-R \cdot \lambda_1\\
\mathbf{elif}\;\phi_2 \leq 3.3 \cdot 10^{+14}:\\
\;\;\;\;R \cdot \lambda_2\\
\mathbf{else}:\\
\;\;\;\;\phi_2 \cdot R\\
\end{array}
\end{array}
if phi2 < 9.1999999999999993e-189Initial program 63.2%
Taylor expanded in phi1 around -inf
mul-1-negN/A
lower-neg.f6421.7
Simplified21.7%
if 9.1999999999999993e-189 < phi2 < 4.89999999999999977e-116Initial program 73.2%
Taylor expanded in phi2 around 0
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-cos.f64N/A
lower-*.f6473.2
Simplified73.2%
Taylor expanded in phi1 around 0
lower-sqrt.f64N/A
+-commutativeN/A
unpow2N/A
lower-fma.f64N/A
lower--.f64N/A
lower--.f64N/A
unpow2N/A
lower-*.f6453.1
Simplified53.1%
Taylor expanded in lambda1 around -inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6416.4
Simplified16.4%
if 4.89999999999999977e-116 < phi2 < 3.3e14Initial program 67.9%
Taylor expanded in phi2 around 0
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-cos.f64N/A
lower-*.f6460.8
Simplified60.8%
Taylor expanded in phi1 around 0
lower-sqrt.f64N/A
+-commutativeN/A
unpow2N/A
lower-fma.f64N/A
lower--.f64N/A
lower--.f64N/A
unpow2N/A
lower-*.f6445.5
Simplified45.5%
Taylor expanded in lambda2 around inf
*-commutativeN/A
lower-*.f6420.3
Simplified20.3%
if 3.3e14 < phi2 Initial program 52.6%
Taylor expanded in phi2 around 0
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-cos.f64N/A
lower-*.f6450.2
Simplified50.2%
Taylor expanded in phi2 around inf
lower-*.f6467.7
Simplified67.7%
Final simplification32.8%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. (FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= phi2 6e-130) (- (* R phi1)) (if (<= phi2 3.3e+14) (* R lambda2) (* phi2 R))))
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 6e-130) {
tmp = -(R * phi1);
} else if (phi2 <= 3.3e+14) {
tmp = R * lambda2;
} else {
tmp = phi2 * R;
}
return tmp;
}
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
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 <= 6d-130) then
tmp = -(r * phi1)
else if (phi2 <= 3.3d+14) then
tmp = r * lambda2
else
tmp = phi2 * r
end if
code = tmp
end function
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 6e-130) {
tmp = -(R * phi1);
} else if (phi2 <= 3.3e+14) {
tmp = R * lambda2;
} else {
tmp = phi2 * R;
}
return tmp;
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi2 <= 6e-130: tmp = -(R * phi1) elif phi2 <= 3.3e+14: tmp = R * lambda2 else: tmp = phi2 * R return tmp
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi2 <= 6e-130) tmp = Float64(-Float64(R * phi1)); elseif (phi2 <= 3.3e+14) tmp = Float64(R * lambda2); else tmp = Float64(phi2 * R); end return tmp end
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2)
tmp = 0.0;
if (phi2 <= 6e-130)
tmp = -(R * phi1);
elseif (phi2 <= 3.3e+14)
tmp = R * lambda2;
else
tmp = phi2 * R;
end
tmp_2 = tmp;
end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi2, 6e-130], (-N[(R * phi1), $MachinePrecision]), If[LessEqual[phi2, 3.3e+14], N[(R * lambda2), $MachinePrecision], N[(phi2 * R), $MachinePrecision]]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
\mathbf{if}\;\phi_2 \leq 6 \cdot 10^{-130}:\\
\;\;\;\;-R \cdot \phi_1\\
\mathbf{elif}\;\phi_2 \leq 3.3 \cdot 10^{+14}:\\
\;\;\;\;R \cdot \lambda_2\\
\mathbf{else}:\\
\;\;\;\;\phi_2 \cdot R\\
\end{array}
\end{array}
if phi2 < 5.99999999999999972e-130Initial program 63.9%
Taylor expanded in phi1 around -inf
mul-1-negN/A
lower-neg.f6422.2
Simplified22.2%
if 5.99999999999999972e-130 < phi2 < 3.3e14Initial program 68.1%
Taylor expanded in phi2 around 0
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-cos.f64N/A
lower-*.f6461.8
Simplified61.8%
Taylor expanded in phi1 around 0
lower-sqrt.f64N/A
+-commutativeN/A
unpow2N/A
lower-fma.f64N/A
lower--.f64N/A
lower--.f64N/A
unpow2N/A
lower-*.f6448.4
Simplified48.4%
Taylor expanded in lambda2 around inf
*-commutativeN/A
lower-*.f6418.2
Simplified18.2%
if 3.3e14 < phi2 Initial program 52.6%
Taylor expanded in phi2 around 0
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-cos.f64N/A
lower-*.f6450.2
Simplified50.2%
Taylor expanded in phi2 around inf
lower-*.f6467.7
Simplified67.7%
Final simplification33.2%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. (FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= phi2 3.3e+14) (* R lambda2) (* phi2 R)))
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 3.3e+14) {
tmp = R * lambda2;
} else {
tmp = phi2 * R;
}
return tmp;
}
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
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.3d+14) then
tmp = r * lambda2
else
tmp = phi2 * r
end if
code = tmp
end function
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 3.3e+14) {
tmp = R * lambda2;
} else {
tmp = phi2 * R;
}
return tmp;
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi2 <= 3.3e+14: tmp = R * lambda2 else: tmp = phi2 * R return tmp
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi2 <= 3.3e+14) tmp = Float64(R * lambda2); else tmp = Float64(phi2 * R); end return tmp end
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2)
tmp = 0.0;
if (phi2 <= 3.3e+14)
tmp = R * lambda2;
else
tmp = phi2 * R;
end
tmp_2 = tmp;
end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi2, 3.3e+14], N[(R * lambda2), $MachinePrecision], N[(phi2 * R), $MachinePrecision]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
\mathbf{if}\;\phi_2 \leq 3.3 \cdot 10^{+14}:\\
\;\;\;\;R \cdot \lambda_2\\
\mathbf{else}:\\
\;\;\;\;\phi_2 \cdot R\\
\end{array}
\end{array}
if phi2 < 3.3e14Initial program 64.4%
Taylor expanded in phi2 around 0
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-cos.f64N/A
lower-*.f6463.2
Simplified63.2%
Taylor expanded in phi1 around 0
lower-sqrt.f64N/A
+-commutativeN/A
unpow2N/A
lower-fma.f64N/A
lower--.f64N/A
lower--.f64N/A
unpow2N/A
lower-*.f6448.8
Simplified48.8%
Taylor expanded in lambda2 around inf
*-commutativeN/A
lower-*.f6413.7
Simplified13.7%
if 3.3e14 < phi2 Initial program 52.6%
Taylor expanded in phi2 around 0
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-cos.f64N/A
lower-*.f6450.2
Simplified50.2%
Taylor expanded in phi2 around inf
lower-*.f6467.7
Simplified67.7%
Final simplification27.2%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. (FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (* phi2 R))
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return phi2 * R;
}
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
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 = phi2 * r
end function
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return phi2 * R;
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): return phi2 * R
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) return Float64(phi2 * R) end
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
function tmp = code(R, lambda1, lambda2, phi1, phi2)
tmp = phi2 * R;
end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. code[R_, lambda1_, lambda2_, phi1_, phi2_] := N[(phi2 * R), $MachinePrecision]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\phi_2 \cdot R
\end{array}
Initial program 61.5%
Taylor expanded in phi2 around 0
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-cos.f64N/A
lower-*.f6459.9
Simplified59.9%
Taylor expanded in phi2 around inf
lower-*.f6419.6
Simplified19.6%
Final simplification19.6%
herbie shell --seed 2024215
(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))))))