
(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}
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.2e+15) (* 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 (phi1 <= -1.2e+15) {
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 (phi1 <= -1.2e+15) {
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 phi1 <= -1.2e+15: 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 (phi1 <= -1.2e+15) 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 (phi1 <= -1.2e+15)
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[phi1, -1.2e+15], 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_1 \leq -1.2 \cdot 10^{+15}:\\
\;\;\;\;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 phi1 < -1.2e15Initial program 52.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.9
Applied rewrites79.9%
if -1.2e15 < phi1 Initial program 58.3%
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--.f6478.0
Applied rewrites78.0%
Final simplification78.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 (<= phi1 -1.2e+15) (* R (hypot phi1 (* (- lambda1 lambda2) (cos (* phi1 0.5))))) (* R (hypot phi2 (- lambda1 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 (phi1 <= -1.2e+15) {
tmp = R * hypot(phi1, ((lambda1 - lambda2) * cos((phi1 * 0.5))));
} else {
tmp = R * hypot(phi2, (lambda1 - lambda2));
}
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 (phi1 <= -1.2e+15) {
tmp = R * Math.hypot(phi1, ((lambda1 - lambda2) * Math.cos((phi1 * 0.5))));
} else {
tmp = R * Math.hypot(phi2, (lambda1 - lambda2));
}
return tmp;
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi1 <= -1.2e+15: tmp = R * math.hypot(phi1, ((lambda1 - lambda2) * math.cos((phi1 * 0.5)))) else: tmp = R * math.hypot(phi2, (lambda1 - 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 (phi1 <= -1.2e+15) tmp = Float64(R * hypot(phi1, Float64(Float64(lambda1 - lambda2) * cos(Float64(phi1 * 0.5))))); else tmp = Float64(R * hypot(phi2, Float64(lambda1 - lambda2))); 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 (phi1 <= -1.2e+15)
tmp = R * hypot(phi1, ((lambda1 - lambda2) * cos((phi1 * 0.5))));
else
tmp = R * hypot(phi2, (lambda1 - lambda2));
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[phi1, -1.2e+15], 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[(lambda1 - lambda2), $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_1 \leq -1.2 \cdot 10^{+15}:\\
\;\;\;\;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, \lambda_1 - \lambda_2\right)\\
\end{array}
\end{array}
if phi1 < -1.2e15Initial program 52.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.9
Applied rewrites79.9%
if -1.2e15 < phi1 Initial program 58.3%
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-*.f6463.2
Applied rewrites63.2%
Taylor expanded in phi1 around 0
+-commutativeN/A
unpow2N/A
*-commutativeN/A
unpow2N/A
unpow2N/A
unswap-sqrN/A
lower-hypot.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower-cos.f64N/A
lower-*.f6478.0
Applied rewrites78.0%
Taylor expanded in phi2 around 0
Applied rewrites72.2%
Final simplification74.0%
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 -3.8e+15) (* R (hypot phi1 (* lambda2 (cos (* phi1 0.5))))) (* R (hypot phi2 (- lambda1 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 (phi1 <= -3.8e+15) {
tmp = R * hypot(phi1, (lambda2 * cos((phi1 * 0.5))));
} else {
tmp = R * hypot(phi2, (lambda1 - lambda2));
}
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 (phi1 <= -3.8e+15) {
tmp = R * Math.hypot(phi1, (lambda2 * Math.cos((phi1 * 0.5))));
} else {
tmp = R * Math.hypot(phi2, (lambda1 - lambda2));
}
return tmp;
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi1 <= -3.8e+15: tmp = R * math.hypot(phi1, (lambda2 * math.cos((phi1 * 0.5)))) else: tmp = R * math.hypot(phi2, (lambda1 - 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 (phi1 <= -3.8e+15) tmp = Float64(R * hypot(phi1, Float64(lambda2 * cos(Float64(phi1 * 0.5))))); else tmp = Float64(R * hypot(phi2, Float64(lambda1 - lambda2))); 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 (phi1 <= -3.8e+15)
tmp = R * hypot(phi1, (lambda2 * cos((phi1 * 0.5))));
else
tmp = R * hypot(phi2, (lambda1 - lambda2));
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[phi1, -3.8e+15], N[(R * N[Sqrt[phi1 ^ 2 + N[(lambda2 * N[Cos[N[(phi1 * 0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision], N[(R * N[Sqrt[phi2 ^ 2 + N[(lambda1 - lambda2), $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_1 \leq -3.8 \cdot 10^{+15}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\phi_1, \lambda_2 \cdot \cos \left(\phi_1 \cdot 0.5\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\phi_2, \lambda_1 - \lambda_2\right)\\
\end{array}
\end{array}
if phi1 < -3.8e15Initial program 52.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.9
Applied rewrites79.9%
Taylor expanded in lambda1 around 0
Applied rewrites74.8%
if -3.8e15 < phi1 Initial program 58.3%
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-*.f6463.2
Applied rewrites63.2%
Taylor expanded in phi1 around 0
+-commutativeN/A
unpow2N/A
*-commutativeN/A
unpow2N/A
unpow2N/A
unswap-sqrN/A
lower-hypot.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower-cos.f64N/A
lower-*.f6478.0
Applied rewrites78.0%
Taylor expanded in phi2 around 0
Applied rewrites72.2%
Final simplification72.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.1e+120)
(* (- phi1) (fma R (/ phi2 (- phi1)) R))
(if (<= phi1 -2.5e+15)
(*
R
(sqrt
(fma
(* (- lambda1 lambda2) (- lambda1 lambda2))
(+ 0.5 (* 0.5 (cos (+ phi1 phi2))))
(* (- phi1 phi2) (- phi1 phi2)))))
(* R (hypot phi2 (- lambda1 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 (phi1 <= -1.1e+120) {
tmp = -phi1 * fma(R, (phi2 / -phi1), R);
} else if (phi1 <= -2.5e+15) {
tmp = R * sqrt(fma(((lambda1 - lambda2) * (lambda1 - lambda2)), (0.5 + (0.5 * cos((phi1 + phi2)))), ((phi1 - phi2) * (phi1 - phi2))));
} else {
tmp = R * hypot(phi2, (lambda1 - 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 (phi1 <= -1.1e+120) tmp = Float64(Float64(-phi1) * fma(R, Float64(phi2 / Float64(-phi1)), R)); elseif (phi1 <= -2.5e+15) tmp = Float64(R * sqrt(fma(Float64(Float64(lambda1 - lambda2) * Float64(lambda1 - lambda2)), Float64(0.5 + Float64(0.5 * cos(Float64(phi1 + phi2)))), Float64(Float64(phi1 - phi2) * Float64(phi1 - phi2))))); else tmp = Float64(R * hypot(phi2, Float64(lambda1 - 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[phi1, -1.1e+120], N[((-phi1) * N[(R * N[(phi2 / (-phi1)), $MachinePrecision] + R), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, -2.5e+15], N[(R * N[Sqrt[N[(N[(N[(lambda1 - lambda2), $MachinePrecision] * N[(lambda1 - lambda2), $MachinePrecision]), $MachinePrecision] * N[(0.5 + N[(0.5 * N[Cos[N[(phi1 + phi2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(phi1 - phi2), $MachinePrecision] * N[(phi1 - phi2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[Sqrt[phi2 ^ 2 + N[(lambda1 - lambda2), $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_1 \leq -1.1 \cdot 10^{+120}:\\
\;\;\;\;\left(-\phi_1\right) \cdot \mathsf{fma}\left(R, \frac{\phi_2}{-\phi_1}, R\right)\\
\mathbf{elif}\;\phi_1 \leq -2.5 \cdot 10^{+15}:\\
\;\;\;\;R \cdot \sqrt{\mathsf{fma}\left(\left(\lambda_1 - \lambda_2\right) \cdot \left(\lambda_1 - \lambda_2\right), 0.5 + 0.5 \cdot \cos \left(\phi_1 + \phi_2\right), \left(\phi_1 - \phi_2\right) \cdot \left(\phi_1 - \phi_2\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\phi_2, \lambda_1 - \lambda_2\right)\\
\end{array}
\end{array}
if phi1 < -1.1000000000000001e120Initial program 45.8%
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-*.f6484.6
Applied rewrites84.6%
Taylor expanded in phi1 around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
+-commutativeN/A
mul-1-negN/A
associate-/l*N/A
distribute-rgt-neg-inN/A
mul-1-negN/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.f6485.6
Applied rewrites85.6%
if -1.1000000000000001e120 < phi1 < -2.5e15Initial program 63.1%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6463.1
Applied rewrites63.2%
if -2.5e15 < phi1 Initial program 58.3%
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-*.f6463.2
Applied rewrites63.2%
Taylor expanded in phi1 around 0
+-commutativeN/A
unpow2N/A
*-commutativeN/A
unpow2N/A
unpow2N/A
unswap-sqrN/A
lower-hypot.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower-cos.f64N/A
lower-*.f6478.0
Applied rewrites78.0%
Taylor expanded in phi2 around 0
Applied rewrites72.2%
Final simplification73.3%
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.1e+120)
(* (- phi1) (fma R (/ phi2 (- phi1)) R))
(if (<= phi1 -2.5e+15)
(*
R
(sqrt
(fma
(- phi1 phi2)
(- phi1 phi2)
(*
(* (- lambda1 lambda2) (- lambda1 lambda2))
(+ 0.5 (* 0.5 (cos (+ phi1 phi2))))))))
(* R (hypot phi2 (- lambda1 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 (phi1 <= -1.1e+120) {
tmp = -phi1 * fma(R, (phi2 / -phi1), R);
} else if (phi1 <= -2.5e+15) {
tmp = R * sqrt(fma((phi1 - phi2), (phi1 - phi2), (((lambda1 - lambda2) * (lambda1 - lambda2)) * (0.5 + (0.5 * cos((phi1 + phi2)))))));
} else {
tmp = R * hypot(phi2, (lambda1 - 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 (phi1 <= -1.1e+120) tmp = Float64(Float64(-phi1) * fma(R, Float64(phi2 / Float64(-phi1)), R)); elseif (phi1 <= -2.5e+15) tmp = Float64(R * sqrt(fma(Float64(phi1 - phi2), Float64(phi1 - phi2), Float64(Float64(Float64(lambda1 - lambda2) * Float64(lambda1 - lambda2)) * Float64(0.5 + Float64(0.5 * cos(Float64(phi1 + phi2)))))))); else tmp = Float64(R * hypot(phi2, Float64(lambda1 - 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[phi1, -1.1e+120], N[((-phi1) * N[(R * N[(phi2 / (-phi1)), $MachinePrecision] + R), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, -2.5e+15], N[(R * N[Sqrt[N[(N[(phi1 - phi2), $MachinePrecision] * N[(phi1 - phi2), $MachinePrecision] + N[(N[(N[(lambda1 - lambda2), $MachinePrecision] * N[(lambda1 - lambda2), $MachinePrecision]), $MachinePrecision] * N[(0.5 + N[(0.5 * N[Cos[N[(phi1 + phi2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[Sqrt[phi2 ^ 2 + N[(lambda1 - lambda2), $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_1 \leq -1.1 \cdot 10^{+120}:\\
\;\;\;\;\left(-\phi_1\right) \cdot \mathsf{fma}\left(R, \frac{\phi_2}{-\phi_1}, R\right)\\
\mathbf{elif}\;\phi_1 \leq -2.5 \cdot 10^{+15}:\\
\;\;\;\;R \cdot \sqrt{\mathsf{fma}\left(\phi_1 - \phi_2, \phi_1 - \phi_2, \left(\left(\lambda_1 - \lambda_2\right) \cdot \left(\lambda_1 - \lambda_2\right)\right) \cdot \left(0.5 + 0.5 \cdot \cos \left(\phi_1 + \phi_2\right)\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\phi_2, \lambda_1 - \lambda_2\right)\\
\end{array}
\end{array}
if phi1 < -1.1000000000000001e120Initial program 45.8%
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-*.f6484.6
Applied rewrites84.6%
Taylor expanded in phi1 around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
+-commutativeN/A
mul-1-negN/A
associate-/l*N/A
distribute-rgt-neg-inN/A
mul-1-negN/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.f6485.6
Applied rewrites85.6%
if -1.1000000000000001e120 < phi1 < -2.5e15Initial program 63.1%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6463.1
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
swap-sqrN/A
lower-*.f64N/A
lower-*.f64N/A
lift-cos.f64N/A
lift-cos.f64N/A
Applied rewrites63.1%
if -2.5e15 < phi1 Initial program 58.3%
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-*.f6463.2
Applied rewrites63.2%
Taylor expanded in phi1 around 0
+-commutativeN/A
unpow2N/A
*-commutativeN/A
unpow2N/A
unpow2N/A
unswap-sqrN/A
lower-hypot.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower-cos.f64N/A
lower-*.f6478.0
Applied rewrites78.0%
Taylor expanded in phi2 around 0
Applied rewrites72.2%
Final simplification73.3%
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.45e+118)
(* (- phi1) (fma R (/ phi2 (- phi1)) R))
(if (<= phi1 -4e+15)
(* R (hypot phi1 (- lambda1 lambda2)))
(* R (hypot phi2 (- lambda1 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 (phi1 <= -1.45e+118) {
tmp = -phi1 * fma(R, (phi2 / -phi1), R);
} else if (phi1 <= -4e+15) {
tmp = R * hypot(phi1, (lambda1 - lambda2));
} else {
tmp = R * hypot(phi2, (lambda1 - 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 (phi1 <= -1.45e+118) tmp = Float64(Float64(-phi1) * fma(R, Float64(phi2 / Float64(-phi1)), R)); elseif (phi1 <= -4e+15) tmp = Float64(R * hypot(phi1, Float64(lambda1 - lambda2))); else tmp = Float64(R * hypot(phi2, Float64(lambda1 - 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[phi1, -1.45e+118], N[((-phi1) * N[(R * N[(phi2 / (-phi1)), $MachinePrecision] + R), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, -4e+15], N[(R * N[Sqrt[phi1 ^ 2 + N[(lambda1 - lambda2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision], N[(R * N[Sqrt[phi2 ^ 2 + N[(lambda1 - lambda2), $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_1 \leq -1.45 \cdot 10^{+118}:\\
\;\;\;\;\left(-\phi_1\right) \cdot \mathsf{fma}\left(R, \frac{\phi_2}{-\phi_1}, R\right)\\
\mathbf{elif}\;\phi_1 \leq -4 \cdot 10^{+15}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\phi_1, \lambda_1 - \lambda_2\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\phi_2, \lambda_1 - \lambda_2\right)\\
\end{array}
\end{array}
if phi1 < -1.45000000000000008e118Initial program 44.8%
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-*.f6482.5
Applied rewrites82.5%
Taylor expanded in phi1 around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
+-commutativeN/A
mul-1-negN/A
associate-/l*N/A
distribute-rgt-neg-inN/A
mul-1-negN/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.f6483.3
Applied rewrites83.3%
if -1.45000000000000008e118 < phi1 < -4e15Initial program 65.6%
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-*.f6475.3
Applied rewrites75.3%
Taylor expanded in phi1 around 0
Applied rewrites54.1%
if -4e15 < phi1 Initial program 58.3%
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-*.f6463.2
Applied rewrites63.2%
Taylor expanded in phi1 around 0
+-commutativeN/A
unpow2N/A
*-commutativeN/A
unpow2N/A
unpow2N/A
unswap-sqrN/A
lower-hypot.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower-cos.f64N/A
lower-*.f6478.0
Applied rewrites78.0%
Taylor expanded in phi2 around 0
Applied rewrites72.2%
Final simplification72.3%
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.45e+118)
(* (- phi1) (fma R (/ phi2 (- phi1)) R))
(if (<= phi1 -1.02e-85)
(* R (sqrt (fma (- lambda1 lambda2) (- lambda1 lambda2) (* phi1 phi1))))
(* R (hypot phi2 (- 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 (phi1 <= -1.45e+118) {
tmp = -phi1 * fma(R, (phi2 / -phi1), R);
} else if (phi1 <= -1.02e-85) {
tmp = R * sqrt(fma((lambda1 - lambda2), (lambda1 - lambda2), (phi1 * phi1)));
} else {
tmp = R * hypot(phi2, -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 (phi1 <= -1.45e+118) tmp = Float64(Float64(-phi1) * fma(R, Float64(phi2 / Float64(-phi1)), R)); elseif (phi1 <= -1.02e-85) tmp = Float64(R * sqrt(fma(Float64(lambda1 - lambda2), Float64(lambda1 - lambda2), Float64(phi1 * phi1)))); else tmp = Float64(R * hypot(phi2, Float64(-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[phi1, -1.45e+118], N[((-phi1) * N[(R * N[(phi2 / (-phi1)), $MachinePrecision] + R), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, -1.02e-85], N[(R * N[Sqrt[N[(N[(lambda1 - lambda2), $MachinePrecision] * N[(lambda1 - lambda2), $MachinePrecision] + N[(phi1 * phi1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[Sqrt[phi2 ^ 2 + (-lambda2) ^ 2], $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.45 \cdot 10^{+118}:\\
\;\;\;\;\left(-\phi_1\right) \cdot \mathsf{fma}\left(R, \frac{\phi_2}{-\phi_1}, R\right)\\
\mathbf{elif}\;\phi_1 \leq -1.02 \cdot 10^{-85}:\\
\;\;\;\;R \cdot \sqrt{\mathsf{fma}\left(\lambda_1 - \lambda_2, \lambda_1 - \lambda_2, \phi_1 \cdot \phi_1\right)}\\
\mathbf{else}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\phi_2, -\lambda_2\right)\\
\end{array}
\end{array}
if phi1 < -1.45000000000000008e118Initial program 44.8%
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-*.f6482.5
Applied rewrites82.5%
Taylor expanded in phi1 around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
+-commutativeN/A
mul-1-negN/A
associate-/l*N/A
distribute-rgt-neg-inN/A
mul-1-negN/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.f6483.3
Applied rewrites83.3%
if -1.45000000000000008e118 < phi1 < -1.02000000000000001e-85Initial program 61.0%
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-*.f6465.9
Applied rewrites65.9%
Taylor expanded in phi1 around 0
Applied rewrites54.0%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6454.0
Applied rewrites45.2%
if -1.02000000000000001e-85 < phi1 Initial program 58.6%
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-*.f6464.1
Applied rewrites64.1%
Taylor expanded in phi1 around 0
+-commutativeN/A
unpow2N/A
*-commutativeN/A
unpow2N/A
unpow2N/A
unswap-sqrN/A
lower-hypot.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower-cos.f64N/A
lower-*.f6477.4
Applied rewrites77.4%
Taylor expanded in phi2 around 0
Applied rewrites71.6%
Taylor expanded in lambda1 around 0
Applied rewrites61.1%
Final simplification61.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 6.8e+47) (* R (hypot phi1 (- lambda1 lambda2))) (* phi2 (fma R (/ phi1 (- 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 <= 6.8e+47) {
tmp = R * hypot(phi1, (lambda1 - lambda2));
} else {
tmp = phi2 * fma(R, (phi1 / -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 <= 6.8e+47) tmp = Float64(R * hypot(phi1, Float64(lambda1 - lambda2))); else tmp = Float64(phi2 * fma(R, Float64(phi1 / 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[phi2, 6.8e+47], N[(R * N[Sqrt[phi1 ^ 2 + N[(lambda1 - lambda2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision], N[(phi2 * N[(R * N[(phi1 / (-phi2)), $MachinePrecision] + R), $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 6.8 \cdot 10^{+47}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\phi_1, \lambda_1 - \lambda_2\right)\\
\mathbf{else}:\\
\;\;\;\;\phi_2 \cdot \mathsf{fma}\left(R, \frac{\phi_1}{-\phi_2}, R\right)\\
\end{array}
\end{array}
if phi2 < 6.7999999999999996e47Initial program 59.6%
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-*.f6472.2
Applied rewrites72.2%
Taylor expanded in phi1 around 0
Applied rewrites66.7%
if 6.7999999999999996e47 < phi2 Initial program 45.8%
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-*.f6445.7
Applied rewrites45.7%
Taylor expanded in phi2 around inf
lower-*.f64N/A
+-commutativeN/A
mul-1-negN/A
associate-/l*N/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
associate-*r/N/A
lower-/.f64N/A
mul-1-negN/A
lower-neg.f6477.7
Applied rewrites77.7%
Final simplification68.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 -4.5e+15)
(* (- phi1) (fma R (/ phi2 (- phi1)) R))
(if (<= phi1 1.6e-202)
(* R (sqrt (fma (- lambda1 lambda2) (- lambda1 lambda2) (* phi2 phi2))))
(* phi2 (fma R (/ phi1 (- 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 <= -4.5e+15) {
tmp = -phi1 * fma(R, (phi2 / -phi1), R);
} else if (phi1 <= 1.6e-202) {
tmp = R * sqrt(fma((lambda1 - lambda2), (lambda1 - lambda2), (phi2 * phi2)));
} else {
tmp = phi2 * fma(R, (phi1 / -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 <= -4.5e+15) tmp = Float64(Float64(-phi1) * fma(R, Float64(phi2 / Float64(-phi1)), R)); elseif (phi1 <= 1.6e-202) tmp = Float64(R * sqrt(fma(Float64(lambda1 - lambda2), Float64(lambda1 - lambda2), Float64(phi2 * phi2)))); else tmp = Float64(phi2 * fma(R, Float64(phi1 / 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, -4.5e+15], N[((-phi1) * N[(R * N[(phi2 / (-phi1)), $MachinePrecision] + R), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, 1.6e-202], N[(R * N[Sqrt[N[(N[(lambda1 - lambda2), $MachinePrecision] * N[(lambda1 - lambda2), $MachinePrecision] + N[(phi2 * phi2), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(phi2 * N[(R * N[(phi1 / (-phi2)), $MachinePrecision] + R), $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 -4.5 \cdot 10^{+15}:\\
\;\;\;\;\left(-\phi_1\right) \cdot \mathsf{fma}\left(R, \frac{\phi_2}{-\phi_1}, R\right)\\
\mathbf{elif}\;\phi_1 \leq 1.6 \cdot 10^{-202}:\\
\;\;\;\;R \cdot \sqrt{\mathsf{fma}\left(\lambda_1 - \lambda_2, \lambda_1 - \lambda_2, \phi_2 \cdot \phi_2\right)}\\
\mathbf{else}:\\
\;\;\;\;\phi_2 \cdot \mathsf{fma}\left(R, \frac{\phi_1}{-\phi_2}, R\right)\\
\end{array}
\end{array}
if phi1 < -4.5e15Initial program 51.6%
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.6
Applied rewrites79.6%
Taylor expanded in phi1 around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
+-commutativeN/A
mul-1-negN/A
associate-/l*N/A
distribute-rgt-neg-inN/A
mul-1-negN/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.f6471.2
Applied rewrites71.2%
if -4.5e15 < phi1 < 1.6000000000000001e-202Initial program 62.6%
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-*.f6454.7
Applied rewrites54.7%
Taylor expanded in phi1 around 0
+-commutativeN/A
unpow2N/A
*-commutativeN/A
unpow2N/A
unpow2N/A
unswap-sqrN/A
lower-hypot.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower-cos.f64N/A
lower-*.f6496.3
Applied rewrites96.3%
Taylor expanded in phi2 around 0
Applied rewrites89.9%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6489.9
Applied rewrites60.0%
if 1.6000000000000001e-202 < phi1 Initial program 55.0%
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-*.f6471.0
Applied rewrites71.0%
Taylor expanded in phi2 around inf
lower-*.f64N/A
+-commutativeN/A
mul-1-negN/A
associate-/l*N/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
associate-*r/N/A
lower-/.f64N/A
mul-1-negN/A
lower-neg.f6417.3
Applied rewrites17.3%
Final simplification45.1%
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.25e-167)
(* (- phi1) (fma R (/ phi2 (- phi1)) R))
(if (<= phi2 4e-46)
(* R (sqrt (fma (- lambda1 lambda2) (- lambda1 lambda2) (* phi1 phi1))))
(* 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 <= -2.25e-167) {
tmp = -phi1 * fma(R, (phi2 / -phi1), R);
} else if (phi2 <= 4e-46) {
tmp = R * sqrt(fma((lambda1 - lambda2), (lambda1 - lambda2), (phi1 * phi1)));
} 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 <= -2.25e-167) tmp = Float64(Float64(-phi1) * fma(R, Float64(phi2 / Float64(-phi1)), R)); elseif (phi2 <= 4e-46) tmp = Float64(R * sqrt(fma(Float64(lambda1 - lambda2), Float64(lambda1 - lambda2), Float64(phi1 * phi1)))); 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, -2.25e-167], N[((-phi1) * N[(R * N[(phi2 / (-phi1)), $MachinePrecision] + R), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi2, 4e-46], N[(R * N[Sqrt[N[(N[(lambda1 - lambda2), $MachinePrecision] * N[(lambda1 - lambda2), $MachinePrecision] + N[(phi1 * phi1), $MachinePrecision]), $MachinePrecision]], $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 -2.25 \cdot 10^{-167}:\\
\;\;\;\;\left(-\phi_1\right) \cdot \mathsf{fma}\left(R, \frac{\phi_2}{-\phi_1}, R\right)\\
\mathbf{elif}\;\phi_2 \leq 4 \cdot 10^{-46}:\\
\;\;\;\;R \cdot \sqrt{\mathsf{fma}\left(\lambda_1 - \lambda_2, \lambda_1 - \lambda_2, \phi_1 \cdot \phi_1\right)}\\
\mathbf{else}:\\
\;\;\;\;R \cdot \mathsf{fma}\left(\phi_2, \frac{\phi_1}{-\phi_2}, \phi_2\right)\\
\end{array}
\end{array}
if phi2 < -2.2500000000000001e-167Initial program 55.6%
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-*.f6449.9
Applied rewrites49.9%
Taylor expanded in phi1 around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
+-commutativeN/A
mul-1-negN/A
associate-/l*N/A
distribute-rgt-neg-inN/A
mul-1-negN/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.f6412.4
Applied rewrites12.4%
if -2.2500000000000001e-167 < phi2 < 4.00000000000000009e-46Initial program 65.0%
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-*.f6498.9
Applied rewrites98.9%
Taylor expanded in phi1 around 0
Applied rewrites87.2%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6487.2
Applied rewrites62.1%
if 4.00000000000000009e-46 < phi2 Initial program 49.0%
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.f6467.8
Applied rewrites67.8%
Final simplification43.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 -4e+15) (* (- phi1) (fma R (/ phi2 (- phi1)) R)) (* phi2 (- R (* phi1 (/ R 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 <= -4e+15) {
tmp = -phi1 * fma(R, (phi2 / -phi1), R);
} else {
tmp = phi2 * (R - (phi1 * (R / 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 <= -4e+15) tmp = Float64(Float64(-phi1) * fma(R, Float64(phi2 / Float64(-phi1)), R)); else tmp = Float64(phi2 * Float64(R - Float64(phi1 * Float64(R / 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, -4e+15], N[((-phi1) * N[(R * N[(phi2 / (-phi1)), $MachinePrecision] + R), $MachinePrecision]), $MachinePrecision], N[(phi2 * N[(R - N[(phi1 * N[(R / 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 -4 \cdot 10^{+15}:\\
\;\;\;\;\left(-\phi_1\right) \cdot \mathsf{fma}\left(R, \frac{\phi_2}{-\phi_1}, R\right)\\
\mathbf{else}:\\
\;\;\;\;\phi_2 \cdot \left(R - \phi_1 \cdot \frac{R}{\phi_2}\right)\\
\end{array}
\end{array}
if phi1 < -4e15Initial program 52.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.9
Applied rewrites79.9%
Taylor expanded in phi1 around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
+-commutativeN/A
mul-1-negN/A
associate-/l*N/A
distribute-rgt-neg-inN/A
mul-1-negN/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.f6470.2
Applied rewrites70.2%
if -4e15 < phi1 Initial program 58.3%
Taylor expanded in phi2 around inf
lower-*.f64N/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f6420.2
Applied rewrites20.2%
Final simplification31.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 (<= phi1 -9.2e-5) (* phi1 (- (/ (* R phi2) phi1) R)) (* phi2 (- R (* phi1 (/ R 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 <= -9.2e-5) {
tmp = phi1 * (((R * phi2) / phi1) - R);
} else {
tmp = phi2 * (R - (phi1 * (R / phi2)));
}
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 (phi1 <= (-9.2d-5)) then
tmp = phi1 * (((r * phi2) / phi1) - r)
else
tmp = phi2 * (r - (phi1 * (r / phi2)))
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 (phi1 <= -9.2e-5) {
tmp = phi1 * (((R * phi2) / phi1) - R);
} else {
tmp = phi2 * (R - (phi1 * (R / phi2)));
}
return tmp;
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi1 <= -9.2e-5: tmp = phi1 * (((R * phi2) / phi1) - R) else: tmp = phi2 * (R - (phi1 * (R / 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 <= -9.2e-5) tmp = Float64(phi1 * Float64(Float64(Float64(R * phi2) / phi1) - R)); else tmp = Float64(phi2 * Float64(R - Float64(phi1 * Float64(R / phi2)))); 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 (phi1 <= -9.2e-5)
tmp = phi1 * (((R * phi2) / phi1) - R);
else
tmp = phi2 * (R - (phi1 * (R / phi2)));
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[phi1, -9.2e-5], N[(phi1 * N[(N[(N[(R * phi2), $MachinePrecision] / phi1), $MachinePrecision] - R), $MachinePrecision]), $MachinePrecision], N[(phi2 * N[(R - N[(phi1 * N[(R / 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 -9.2 \cdot 10^{-5}:\\
\;\;\;\;\phi_1 \cdot \left(\frac{R \cdot \phi_2}{\phi_1} - R\right)\\
\mathbf{else}:\\
\;\;\;\;\phi_2 \cdot \left(R - \phi_1 \cdot \frac{R}{\phi_2}\right)\\
\end{array}
\end{array}
if phi1 < -9.20000000000000001e-5Initial program 50.9%
Taylor expanded in phi1 around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6464.8
Applied rewrites64.8%
if -9.20000000000000001e-5 < phi1 Initial program 58.9%
Taylor expanded in phi2 around inf
lower-*.f64N/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f6420.3
Applied rewrites20.3%
Final simplification31.1%
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 -3.7e+121) (* R (- phi1)) (* phi2 (- R (* phi1 (/ R 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 <= -3.7e+121) {
tmp = R * -phi1;
} else {
tmp = phi2 * (R - (phi1 * (R / phi2)));
}
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 (phi1 <= (-3.7d+121)) then
tmp = r * -phi1
else
tmp = phi2 * (r - (phi1 * (r / phi2)))
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 (phi1 <= -3.7e+121) {
tmp = R * -phi1;
} else {
tmp = phi2 * (R - (phi1 * (R / phi2)));
}
return tmp;
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi1 <= -3.7e+121: tmp = R * -phi1 else: tmp = phi2 * (R - (phi1 * (R / 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 <= -3.7e+121) tmp = Float64(R * Float64(-phi1)); else tmp = Float64(phi2 * Float64(R - Float64(phi1 * Float64(R / phi2)))); 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 (phi1 <= -3.7e+121)
tmp = R * -phi1;
else
tmp = phi2 * (R - (phi1 * (R / phi2)));
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[phi1, -3.7e+121], N[(R * (-phi1)), $MachinePrecision], N[(phi2 * N[(R - N[(phi1 * N[(R / 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 -3.7 \cdot 10^{+121}:\\
\;\;\;\;R \cdot \left(-\phi_1\right)\\
\mathbf{else}:\\
\;\;\;\;\phi_2 \cdot \left(R - \phi_1 \cdot \frac{R}{\phi_2}\right)\\
\end{array}
\end{array}
if phi1 < -3.70000000000000013e121Initial program 45.8%
Taylor expanded in phi1 around -inf
mul-1-negN/A
lower-neg.f6478.3
Applied rewrites78.3%
if -3.70000000000000013e121 < phi1 Initial program 58.8%
Taylor expanded in phi2 around inf
lower-*.f64N/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f6422.4
Applied rewrites22.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 (<= phi1 -3.8e+15) (* R (- phi1)) (* R 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 <= -3.8e+15) {
tmp = R * -phi1;
} else {
tmp = R * phi2;
}
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 (phi1 <= (-3.8d+15)) then
tmp = r * -phi1
else
tmp = r * phi2
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 (phi1 <= -3.8e+15) {
tmp = R * -phi1;
} else {
tmp = R * phi2;
}
return tmp;
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi1 <= -3.8e+15: tmp = R * -phi1 else: tmp = R * 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 <= -3.8e+15) tmp = Float64(R * Float64(-phi1)); else tmp = Float64(R * phi2); 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 (phi1 <= -3.8e+15)
tmp = R * -phi1;
else
tmp = R * phi2;
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[phi1, -3.8e+15], N[(R * (-phi1)), $MachinePrecision], N[(R * phi2), $MachinePrecision]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
\mathbf{if}\;\phi_1 \leq -3.8 \cdot 10^{+15}:\\
\;\;\;\;R \cdot \left(-\phi_1\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \phi_2\\
\end{array}
\end{array}
if phi1 < -3.8e15Initial program 52.4%
Taylor expanded in phi1 around -inf
mul-1-negN/A
lower-neg.f6461.4
Applied rewrites61.4%
if -3.8e15 < phi1 Initial program 58.3%
Taylor expanded in phi2 around inf
*-commutativeN/A
lower-*.f6417.5
Applied rewrites17.5%
Final simplification27.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 (* R phi2))
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * phi2;
}
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 = r * phi2
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 R * phi2;
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): return R * phi2
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) return Float64(R * phi2) end
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
function tmp = code(R, lambda1, lambda2, phi1, phi2)
tmp = R * phi2;
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[(R * phi2), $MachinePrecision]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
R \cdot \phi_2
\end{array}
Initial program 56.9%
Taylor expanded in phi2 around inf
*-commutativeN/A
lower-*.f6417.5
Applied rewrites17.5%
Final simplification17.5%
herbie shell --seed 2024223
(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))))))