
(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 17 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.05e-6) (* R (hypot (* (- lambda1 lambda2) (cos (* phi1 0.5))) (- phi1 phi2))) (* R (hypot (* (- lambda1 lambda2) (cos (* phi2 0.5))) (- 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 (phi2 <= 2.05e-6) {
tmp = R * hypot(((lambda1 - lambda2) * cos((phi1 * 0.5))), (phi1 - phi2));
} else {
tmp = R * hypot(((lambda1 - lambda2) * cos((phi2 * 0.5))), (phi1 - phi2));
}
return tmp;
}
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.05e-6) {
tmp = R * Math.hypot(((lambda1 - lambda2) * Math.cos((phi1 * 0.5))), (phi1 - phi2));
} else {
tmp = R * Math.hypot(((lambda1 - lambda2) * Math.cos((phi2 * 0.5))), (phi1 - phi2));
}
return tmp;
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi2 <= 2.05e-6: tmp = R * math.hypot(((lambda1 - lambda2) * math.cos((phi1 * 0.5))), (phi1 - phi2)) else: tmp = R * math.hypot(((lambda1 - lambda2) * math.cos((phi2 * 0.5))), (phi1 - phi2)) return tmp
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi2 <= 2.05e-6) tmp = Float64(R * hypot(Float64(Float64(lambda1 - lambda2) * cos(Float64(phi1 * 0.5))), Float64(phi1 - phi2))); else tmp = Float64(R * hypot(Float64(Float64(lambda1 - lambda2) * cos(Float64(phi2 * 0.5))), Float64(phi1 - phi2))); end return tmp end
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.05e-6)
tmp = R * hypot(((lambda1 - lambda2) * cos((phi1 * 0.5))), (phi1 - phi2));
else
tmp = R * hypot(((lambda1 - lambda2) * cos((phi2 * 0.5))), (phi1 - phi2));
end
tmp_2 = tmp;
end
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.05e-6], N[(R * N[Sqrt[N[(N[(lambda1 - lambda2), $MachinePrecision] * N[Cos[N[(phi1 * 0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision], N[(R * N[Sqrt[N[(N[(lambda1 - lambda2), $MachinePrecision] * N[Cos[N[(phi2 * 0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
\mathbf{if}\;\phi_2 \leq 2.05 \cdot 10^{-6}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\left(\lambda_1 - \lambda_2\right) \cdot \cos \left(\phi_1 \cdot 0.5\right), \phi_1 - \phi_2\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\left(\lambda_1 - \lambda_2\right) \cdot \cos \left(\phi_2 \cdot 0.5\right), \phi_1 - \phi_2\right)\\
\end{array}
\end{array}
if phi2 < 2.0499999999999999e-6Initial program 58.5%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6495.8%
Simplified95.8%
Taylor expanded in phi2 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6491.2%
Simplified91.2%
if 2.0499999999999999e-6 < phi2 Initial program 60.0%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6494.2%
Simplified94.2%
Taylor expanded in phi1 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6494.4%
Simplified94.4%
Final simplification92.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 (<= lambda2 6e-43) (* R (hypot (* lambda1 (cos (* phi2 0.5))) (- phi1 phi2))) (* R (hypot (- lambda1 lambda2) (- 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 (lambda2 <= 6e-43) {
tmp = R * hypot((lambda1 * cos((phi2 * 0.5))), (phi1 - phi2));
} else {
tmp = R * hypot((lambda1 - lambda2), (phi1 - phi2));
}
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 (lambda2 <= 6e-43) {
tmp = R * Math.hypot((lambda1 * Math.cos((phi2 * 0.5))), (phi1 - phi2));
} else {
tmp = R * Math.hypot((lambda1 - lambda2), (phi1 - phi2));
}
return tmp;
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if lambda2 <= 6e-43: tmp = R * math.hypot((lambda1 * math.cos((phi2 * 0.5))), (phi1 - phi2)) else: tmp = R * math.hypot((lambda1 - lambda2), (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 (lambda2 <= 6e-43) tmp = Float64(R * hypot(Float64(lambda1 * cos(Float64(phi2 * 0.5))), Float64(phi1 - phi2))); else tmp = Float64(R * hypot(Float64(lambda1 - lambda2), Float64(phi1 - 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 (lambda2 <= 6e-43)
tmp = R * hypot((lambda1 * cos((phi2 * 0.5))), (phi1 - phi2));
else
tmp = R * hypot((lambda1 - lambda2), (phi1 - 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[lambda2, 6e-43], N[(R * N[Sqrt[N[(lambda1 * N[Cos[N[(phi2 * 0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision], N[(R * N[Sqrt[N[(lambda1 - lambda2), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
\mathbf{if}\;\lambda_2 \leq 6 \cdot 10^{-43}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\lambda_1 \cdot \cos \left(\phi_2 \cdot 0.5\right), \phi_1 - \phi_2\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\lambda_1 - \lambda_2, \phi_1 - \phi_2\right)\\
\end{array}
\end{array}
if lambda2 < 6.00000000000000007e-43Initial program 58.2%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6496.0%
Simplified96.0%
Taylor expanded in phi1 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6490.9%
Simplified90.9%
Taylor expanded in lambda1 around inf
*-commutativeN/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6478.2%
Simplified78.2%
if 6.00000000000000007e-43 < lambda2 Initial program 61.5%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6493.0%
Simplified93.0%
Taylor expanded in phi2 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6486.2%
Simplified86.2%
Taylor expanded in phi1 around 0
--lowering--.f6480.9%
Simplified80.9%
Final simplification78.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 (<= lambda2 2e-116) (* R (hypot (* lambda1 (cos (* phi1 0.5))) (- phi1 phi2))) (* R (hypot (- lambda1 lambda2) (- 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 (lambda2 <= 2e-116) {
tmp = R * hypot((lambda1 * cos((phi1 * 0.5))), (phi1 - phi2));
} else {
tmp = R * hypot((lambda1 - lambda2), (phi1 - phi2));
}
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 (lambda2 <= 2e-116) {
tmp = R * Math.hypot((lambda1 * Math.cos((phi1 * 0.5))), (phi1 - phi2));
} else {
tmp = R * Math.hypot((lambda1 - lambda2), (phi1 - phi2));
}
return tmp;
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if lambda2 <= 2e-116: tmp = R * math.hypot((lambda1 * math.cos((phi1 * 0.5))), (phi1 - phi2)) else: tmp = R * math.hypot((lambda1 - lambda2), (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 (lambda2 <= 2e-116) tmp = Float64(R * hypot(Float64(lambda1 * cos(Float64(phi1 * 0.5))), Float64(phi1 - phi2))); else tmp = Float64(R * hypot(Float64(lambda1 - lambda2), Float64(phi1 - phi2))); end return tmp end
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 (lambda2 <= 2e-116)
tmp = R * hypot((lambda1 * cos((phi1 * 0.5))), (phi1 - phi2));
else
tmp = R * hypot((lambda1 - lambda2), (phi1 - 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[lambda2, 2e-116], N[(R * N[Sqrt[N[(lambda1 * N[Cos[N[(phi1 * 0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision], N[(R * N[Sqrt[N[(lambda1 - lambda2), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
\mathbf{if}\;\lambda_2 \leq 2 \cdot 10^{-116}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\lambda_1 \cdot \cos \left(\phi_1 \cdot 0.5\right), \phi_1 - \phi_2\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\lambda_1 - \lambda_2, \phi_1 - \phi_2\right)\\
\end{array}
\end{array}
if lambda2 < 2e-116Initial program 56.3%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6495.7%
Simplified95.7%
Taylor expanded in phi2 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6491.8%
Simplified91.8%
Taylor expanded in lambda1 around inf
*-commutativeN/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6478.0%
Simplified78.0%
if 2e-116 < lambda2 Initial program 65.4%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6494.4%
Simplified94.4%
Taylor expanded in phi2 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6487.9%
Simplified87.9%
Taylor expanded in phi1 around 0
--lowering--.f6482.6%
Simplified82.6%
Final simplification79.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 (* R (hypot (* (- lambda1 lambda2) (cos (/ (+ phi1 phi2) 2.0))) (- phi1 phi2))))
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * hypot(((lambda1 - lambda2) * cos(((phi1 + phi2) / 2.0))), (phi1 - phi2));
}
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 * Math.hypot(((lambda1 - lambda2) * Math.cos(((phi1 + phi2) / 2.0))), (phi1 - phi2));
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): return R * math.hypot(((lambda1 - lambda2) * math.cos(((phi1 + phi2) / 2.0))), (phi1 - phi2))
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) return Float64(R * hypot(Float64(Float64(lambda1 - lambda2) * cos(Float64(Float64(phi1 + phi2) / 2.0))), Float64(phi1 - phi2))) end
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
function tmp = code(R, lambda1, lambda2, phi1, phi2)
tmp = R * hypot(((lambda1 - lambda2) * cos(((phi1 + phi2) / 2.0))), (phi1 - 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 * N[Sqrt[N[(N[(lambda1 - lambda2), $MachinePrecision] * N[Cos[N[(N[(phi1 + phi2), $MachinePrecision] / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
R \cdot \mathsf{hypot}\left(\left(\lambda_1 - \lambda_2\right) \cdot \cos \left(\frac{\phi_1 + \phi_2}{2}\right), \phi_1 - \phi_2\right)
\end{array}
Initial program 58.9%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6495.3%
Simplified95.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 (* R (hypot (* (- lambda1 lambda2) (cos (* phi1 0.5))) (- phi1 phi2))))
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * hypot(((lambda1 - lambda2) * cos((phi1 * 0.5))), (phi1 - phi2));
}
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 * Math.hypot(((lambda1 - lambda2) * Math.cos((phi1 * 0.5))), (phi1 - phi2));
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): return R * math.hypot(((lambda1 - lambda2) * math.cos((phi1 * 0.5))), (phi1 - phi2))
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) return Float64(R * hypot(Float64(Float64(lambda1 - lambda2) * cos(Float64(phi1 * 0.5))), Float64(phi1 - phi2))) end
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
function tmp = code(R, lambda1, lambda2, phi1, phi2)
tmp = R * hypot(((lambda1 - lambda2) * cos((phi1 * 0.5))), (phi1 - 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 * N[Sqrt[N[(N[(lambda1 - lambda2), $MachinePrecision] * N[Cos[N[(phi1 * 0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
R \cdot \mathsf{hypot}\left(\left(\lambda_1 - \lambda_2\right) \cdot \cos \left(\phi_1 \cdot 0.5\right), \phi_1 - \phi_2\right)
\end{array}
Initial program 58.9%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6495.3%
Simplified95.3%
Taylor expanded in phi2 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6490.7%
Simplified90.7%
Final simplification90.7%
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 1.35e+26) (* R (hypot (- lambda1 lambda2) phi1)) (* R (hypot lambda1 (- 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 (phi2 <= 1.35e+26) {
tmp = R * hypot((lambda1 - lambda2), phi1);
} else {
tmp = R * hypot(lambda1, (phi1 - phi2));
}
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 <= 1.35e+26) {
tmp = R * Math.hypot((lambda1 - lambda2), phi1);
} else {
tmp = R * Math.hypot(lambda1, (phi1 - phi2));
}
return tmp;
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi2 <= 1.35e+26: tmp = R * math.hypot((lambda1 - lambda2), phi1) else: tmp = R * math.hypot(lambda1, (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 (phi2 <= 1.35e+26) tmp = Float64(R * hypot(Float64(lambda1 - lambda2), phi1)); else tmp = Float64(R * hypot(lambda1, Float64(phi1 - 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 (phi2 <= 1.35e+26)
tmp = R * hypot((lambda1 - lambda2), phi1);
else
tmp = R * hypot(lambda1, (phi1 - 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[phi2, 1.35e+26], N[(R * N[Sqrt[N[(lambda1 - lambda2), $MachinePrecision] ^ 2 + phi1 ^ 2], $MachinePrecision]), $MachinePrecision], N[(R * N[Sqrt[lambda1 ^ 2 + N[(phi1 - phi2), $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 1.35 \cdot 10^{+26}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\lambda_1 - \lambda_2, \phi_1\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\lambda_1, \phi_1 - \phi_2\right)\\
\end{array}
\end{array}
if phi2 < 1.35e26Initial program 59.4%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6495.9%
Simplified95.9%
Taylor expanded in phi1 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6488.9%
Simplified88.9%
Taylor expanded in phi2 around 0
*-lowering-*.f64N/A
+-commutativeN/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
--lowering--.f6472.4%
Simplified72.4%
if 1.35e26 < phi2 Initial program 57.6%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6493.6%
Simplified93.6%
Taylor expanded in phi2 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6490.6%
Simplified90.6%
Taylor expanded in phi1 around 0
--lowering--.f6490.6%
Simplified90.6%
Taylor expanded in lambda1 around inf
Simplified88.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 (<= lambda2 4.2e+127) (* R (hypot lambda1 (- phi1 phi2))) (* R (* lambda2 (- 1.0 (/ 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 (lambda2 <= 4.2e+127) {
tmp = R * hypot(lambda1, (phi1 - phi2));
} else {
tmp = R * (lambda2 * (1.0 - (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 (lambda2 <= 4.2e+127) {
tmp = R * Math.hypot(lambda1, (phi1 - phi2));
} else {
tmp = R * (lambda2 * (1.0 - (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 lambda2 <= 4.2e+127: tmp = R * math.hypot(lambda1, (phi1 - phi2)) else: tmp = R * (lambda2 * (1.0 - (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 (lambda2 <= 4.2e+127) tmp = Float64(R * hypot(lambda1, Float64(phi1 - phi2))); else tmp = Float64(R * Float64(lambda2 * Float64(1.0 - 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 (lambda2 <= 4.2e+127)
tmp = R * hypot(lambda1, (phi1 - phi2));
else
tmp = R * (lambda2 * (1.0 - (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[lambda2, 4.2e+127], N[(R * N[Sqrt[lambda1 ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision], N[(R * N[(lambda2 * N[(1.0 - N[(lambda1 / lambda2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
\mathbf{if}\;\lambda_2 \leq 4.2 \cdot 10^{+127}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\lambda_1, \phi_1 - \phi_2\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \left(\lambda_2 \cdot \left(1 - \frac{\lambda_1}{\lambda_2}\right)\right)\\
\end{array}
\end{array}
if lambda2 < 4.19999999999999983e127Initial program 59.9%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6496.3%
Simplified96.3%
Taylor expanded in phi2 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6491.5%
Simplified91.5%
Taylor expanded in phi1 around 0
--lowering--.f6486.4%
Simplified86.4%
Taylor expanded in lambda1 around inf
Simplified75.4%
if 4.19999999999999983e127 < lambda2 Initial program 48.5%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6485.0%
Simplified85.0%
Taylor expanded in phi2 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6481.5%
Simplified81.5%
Taylor expanded in phi1 around 0
--lowering--.f6474.6%
Simplified74.6%
Taylor expanded in lambda2 around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f6452.9%
Simplified52.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 (* R (hypot (- lambda1 lambda2) (- phi1 phi2))))
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * hypot((lambda1 - lambda2), (phi1 - phi2));
}
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 * Math.hypot((lambda1 - lambda2), (phi1 - phi2));
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): return R * math.hypot((lambda1 - lambda2), (phi1 - phi2))
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) return Float64(R * hypot(Float64(lambda1 - lambda2), Float64(phi1 - phi2))) end
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
function tmp = code(R, lambda1, lambda2, phi1, phi2)
tmp = R * hypot((lambda1 - lambda2), (phi1 - 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 * N[Sqrt[N[(lambda1 - lambda2), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
R \cdot \mathsf{hypot}\left(\lambda_1 - \lambda_2, \phi_1 - \phi_2\right)
\end{array}
Initial program 58.9%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6495.3%
Simplified95.3%
Taylor expanded in phi2 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6490.7%
Simplified90.7%
Taylor expanded in phi1 around 0
--lowering--.f6485.4%
Simplified85.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
(let* ((t_0 (/ (- lambda1 lambda2) phi1)))
(if (<= phi2 -2.6e-242)
(* (* R phi1) (+ (+ (/ phi2 phi1) (* -0.5 (* t_0 t_0))) -1.0))
(if (<= phi2 1.1e+26)
(* lambda2 (- R (/ (* R lambda1) lambda2)))
(* R (* phi2 (- 1.0 (/ phi1 phi2))))))))assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = (lambda1 - lambda2) / phi1;
double tmp;
if (phi2 <= -2.6e-242) {
tmp = (R * phi1) * (((phi2 / phi1) + (-0.5 * (t_0 * t_0))) + -1.0);
} else if (phi2 <= 1.1e+26) {
tmp = lambda2 * (R - ((R * lambda1) / lambda2));
} else {
tmp = R * (phi2 * (1.0 - (phi1 / 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) :: t_0
real(8) :: tmp
t_0 = (lambda1 - lambda2) / phi1
if (phi2 <= (-2.6d-242)) then
tmp = (r * phi1) * (((phi2 / phi1) + ((-0.5d0) * (t_0 * t_0))) + (-1.0d0))
else if (phi2 <= 1.1d+26) then
tmp = lambda2 * (r - ((r * lambda1) / lambda2))
else
tmp = r * (phi2 * (1.0d0 - (phi1 / 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 t_0 = (lambda1 - lambda2) / phi1;
double tmp;
if (phi2 <= -2.6e-242) {
tmp = (R * phi1) * (((phi2 / phi1) + (-0.5 * (t_0 * t_0))) + -1.0);
} else if (phi2 <= 1.1e+26) {
tmp = lambda2 * (R - ((R * lambda1) / lambda2));
} else {
tmp = R * (phi2 * (1.0 - (phi1 / phi2)));
}
return tmp;
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): t_0 = (lambda1 - lambda2) / phi1 tmp = 0 if phi2 <= -2.6e-242: tmp = (R * phi1) * (((phi2 / phi1) + (-0.5 * (t_0 * t_0))) + -1.0) elif phi2 <= 1.1e+26: tmp = lambda2 * (R - ((R * lambda1) / lambda2)) else: tmp = R * (phi2 * (1.0 - (phi1 / phi2))) return tmp
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) t_0 = Float64(Float64(lambda1 - lambda2) / phi1) tmp = 0.0 if (phi2 <= -2.6e-242) tmp = Float64(Float64(R * phi1) * Float64(Float64(Float64(phi2 / phi1) + Float64(-0.5 * Float64(t_0 * t_0))) + -1.0)); elseif (phi2 <= 1.1e+26) tmp = Float64(lambda2 * Float64(R - Float64(Float64(R * lambda1) / lambda2))); else tmp = Float64(R * Float64(phi2 * Float64(1.0 - Float64(phi1 / 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)
t_0 = (lambda1 - lambda2) / phi1;
tmp = 0.0;
if (phi2 <= -2.6e-242)
tmp = (R * phi1) * (((phi2 / phi1) + (-0.5 * (t_0 * t_0))) + -1.0);
elseif (phi2 <= 1.1e+26)
tmp = lambda2 * (R - ((R * lambda1) / lambda2));
else
tmp = R * (phi2 * (1.0 - (phi1 / 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_] := Block[{t$95$0 = N[(N[(lambda1 - lambda2), $MachinePrecision] / phi1), $MachinePrecision]}, If[LessEqual[phi2, -2.6e-242], N[(N[(R * phi1), $MachinePrecision] * N[(N[(N[(phi2 / phi1), $MachinePrecision] + N[(-0.5 * N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi2, 1.1e+26], N[(lambda2 * N[(R - N[(N[(R * lambda1), $MachinePrecision] / lambda2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(R * N[(phi2 * N[(1.0 - N[(phi1 / phi2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
t_0 := \frac{\lambda_1 - \lambda_2}{\phi_1}\\
\mathbf{if}\;\phi_2 \leq -2.6 \cdot 10^{-242}:\\
\;\;\;\;\left(R \cdot \phi_1\right) \cdot \left(\left(\frac{\phi_2}{\phi_1} + -0.5 \cdot \left(t\_0 \cdot t\_0\right)\right) + -1\right)\\
\mathbf{elif}\;\phi_2 \leq 1.1 \cdot 10^{+26}:\\
\;\;\;\;\lambda_2 \cdot \left(R - \frac{R \cdot \lambda_1}{\lambda_2}\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \left(\phi_2 \cdot \left(1 - \frac{\phi_1}{\phi_2}\right)\right)\\
\end{array}
\end{array}
if phi2 < -2.60000000000000017e-242Initial program 57.2%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6492.6%
Simplified92.6%
Taylor expanded in phi2 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6484.7%
Simplified84.7%
Taylor expanded in phi1 around 0
--lowering--.f6479.7%
Simplified79.7%
Taylor expanded in phi1 around -inf
associate-*r*N/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified16.0%
Taylor expanded in R around 0
mul-1-negN/A
associate-*r*N/A
distribute-lft-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
unpow2N/A
times-fracN/A
*-lowering-*.f64N/A
Simplified20.4%
if -2.60000000000000017e-242 < phi2 < 1.10000000000000004e26Initial program 62.1%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6499.9%
Simplified99.9%
Taylor expanded in phi2 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6498.1%
Simplified98.1%
Taylor expanded in phi1 around 0
--lowering--.f6488.7%
Simplified88.7%
Taylor expanded in lambda2 around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6425.7%
Simplified25.7%
if 1.10000000000000004e26 < phi2 Initial program 57.6%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6493.6%
Simplified93.6%
Taylor expanded in phi2 around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f6477.7%
Simplified77.7%
Final simplification36.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 (<= phi2 -2.6e-242)
(* phi1 (- (/ (* -0.5 (* R (/ (* lambda1 lambda1) phi1))) phi1) R))
(if (<= phi2 1.7e+26)
(* lambda2 (- R (/ (* R lambda1) lambda2)))
(* R (* phi2 (- 1.0 (/ 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 (phi2 <= -2.6e-242) {
tmp = phi1 * (((-0.5 * (R * ((lambda1 * lambda1) / phi1))) / phi1) - R);
} else if (phi2 <= 1.7e+26) {
tmp = lambda2 * (R - ((R * lambda1) / lambda2));
} else {
tmp = R * (phi2 * (1.0 - (phi1 / 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 (phi2 <= (-2.6d-242)) then
tmp = phi1 * ((((-0.5d0) * (r * ((lambda1 * lambda1) / phi1))) / phi1) - r)
else if (phi2 <= 1.7d+26) then
tmp = lambda2 * (r - ((r * lambda1) / lambda2))
else
tmp = r * (phi2 * (1.0d0 - (phi1 / 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 (phi2 <= -2.6e-242) {
tmp = phi1 * (((-0.5 * (R * ((lambda1 * lambda1) / phi1))) / phi1) - R);
} else if (phi2 <= 1.7e+26) {
tmp = lambda2 * (R - ((R * lambda1) / lambda2));
} else {
tmp = R * (phi2 * (1.0 - (phi1 / phi2)));
}
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.6e-242: tmp = phi1 * (((-0.5 * (R * ((lambda1 * lambda1) / phi1))) / phi1) - R) elif phi2 <= 1.7e+26: tmp = lambda2 * (R - ((R * lambda1) / lambda2)) else: tmp = R * (phi2 * (1.0 - (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 (phi2 <= -2.6e-242) tmp = Float64(phi1 * Float64(Float64(Float64(-0.5 * Float64(R * Float64(Float64(lambda1 * lambda1) / phi1))) / phi1) - R)); elseif (phi2 <= 1.7e+26) tmp = Float64(lambda2 * Float64(R - Float64(Float64(R * lambda1) / lambda2))); else tmp = Float64(R * Float64(phi2 * Float64(1.0 - Float64(phi1 / 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 (phi2 <= -2.6e-242)
tmp = phi1 * (((-0.5 * (R * ((lambda1 * lambda1) / phi1))) / phi1) - R);
elseif (phi2 <= 1.7e+26)
tmp = lambda2 * (R - ((R * lambda1) / lambda2));
else
tmp = R * (phi2 * (1.0 - (phi1 / 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[phi2, -2.6e-242], N[(phi1 * N[(N[(N[(-0.5 * N[(R * N[(N[(lambda1 * lambda1), $MachinePrecision] / phi1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / phi1), $MachinePrecision] - R), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi2, 1.7e+26], N[(lambda2 * N[(R - N[(N[(R * lambda1), $MachinePrecision] / lambda2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(R * N[(phi2 * N[(1.0 - N[(phi1 / 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_2 \leq -2.6 \cdot 10^{-242}:\\
\;\;\;\;\phi_1 \cdot \left(\frac{-0.5 \cdot \left(R \cdot \frac{\lambda_1 \cdot \lambda_1}{\phi_1}\right)}{\phi_1} - R\right)\\
\mathbf{elif}\;\phi_2 \leq 1.7 \cdot 10^{+26}:\\
\;\;\;\;\lambda_2 \cdot \left(R - \frac{R \cdot \lambda_1}{\lambda_2}\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \left(\phi_2 \cdot \left(1 - \frac{\phi_1}{\phi_2}\right)\right)\\
\end{array}
\end{array}
if phi2 < -2.60000000000000017e-242Initial program 57.2%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6492.6%
Simplified92.6%
Taylor expanded in phi2 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6484.7%
Simplified84.7%
Taylor expanded in phi1 around 0
--lowering--.f6479.7%
Simplified79.7%
Taylor expanded in phi1 around -inf
associate-*r*N/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified16.0%
Taylor expanded in lambda1 around inf
*-lowering-*.f64N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f6421.0%
Simplified21.0%
if -2.60000000000000017e-242 < phi2 < 1.7000000000000001e26Initial program 62.1%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6499.9%
Simplified99.9%
Taylor expanded in phi2 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6498.1%
Simplified98.1%
Taylor expanded in phi1 around 0
--lowering--.f6488.7%
Simplified88.7%
Taylor expanded in lambda2 around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6425.7%
Simplified25.7%
if 1.7000000000000001e26 < phi2 Initial program 57.6%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6493.6%
Simplified93.6%
Taylor expanded in phi2 around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f6477.7%
Simplified77.7%
Final simplification36.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 -2.15e-215)
(- 0.0 (* R phi1))
(if (<= phi2 1.1e+26)
(* lambda2 (- R (/ (* R lambda1) lambda2)))
(* R (* phi2 (- 1.0 (/ 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 (phi2 <= -2.15e-215) {
tmp = 0.0 - (R * phi1);
} else if (phi2 <= 1.1e+26) {
tmp = lambda2 * (R - ((R * lambda1) / lambda2));
} else {
tmp = R * (phi2 * (1.0 - (phi1 / 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 (phi2 <= (-2.15d-215)) then
tmp = 0.0d0 - (r * phi1)
else if (phi2 <= 1.1d+26) then
tmp = lambda2 * (r - ((r * lambda1) / lambda2))
else
tmp = r * (phi2 * (1.0d0 - (phi1 / 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 (phi2 <= -2.15e-215) {
tmp = 0.0 - (R * phi1);
} else if (phi2 <= 1.1e+26) {
tmp = lambda2 * (R - ((R * lambda1) / lambda2));
} else {
tmp = R * (phi2 * (1.0 - (phi1 / phi2)));
}
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.15e-215: tmp = 0.0 - (R * phi1) elif phi2 <= 1.1e+26: tmp = lambda2 * (R - ((R * lambda1) / lambda2)) else: tmp = R * (phi2 * (1.0 - (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 (phi2 <= -2.15e-215) tmp = Float64(0.0 - Float64(R * phi1)); elseif (phi2 <= 1.1e+26) tmp = Float64(lambda2 * Float64(R - Float64(Float64(R * lambda1) / lambda2))); else tmp = Float64(R * Float64(phi2 * Float64(1.0 - Float64(phi1 / 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 (phi2 <= -2.15e-215)
tmp = 0.0 - (R * phi1);
elseif (phi2 <= 1.1e+26)
tmp = lambda2 * (R - ((R * lambda1) / lambda2));
else
tmp = R * (phi2 * (1.0 - (phi1 / 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[phi2, -2.15e-215], N[(0.0 - N[(R * phi1), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi2, 1.1e+26], N[(lambda2 * N[(R - N[(N[(R * lambda1), $MachinePrecision] / lambda2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(R * N[(phi2 * N[(1.0 - N[(phi1 / 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_2 \leq -2.15 \cdot 10^{-215}:\\
\;\;\;\;0 - R \cdot \phi_1\\
\mathbf{elif}\;\phi_2 \leq 1.1 \cdot 10^{+26}:\\
\;\;\;\;\lambda_2 \cdot \left(R - \frac{R \cdot \lambda_1}{\lambda_2}\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \left(\phi_2 \cdot \left(1 - \frac{\phi_1}{\phi_2}\right)\right)\\
\end{array}
\end{array}
if phi2 < -2.15000000000000012e-215Initial program 55.0%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6492.2%
Simplified92.2%
Taylor expanded in phi1 around -inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-lowering-*.f6418.3%
Simplified18.3%
sub0-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
*-lowering-*.f64N/A
neg-lowering-neg.f6418.3%
Applied egg-rr18.3%
if -2.15000000000000012e-215 < phi2 < 1.10000000000000004e26Initial program 64.2%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6499.9%
Simplified99.9%
Taylor expanded in phi2 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6498.2%
Simplified98.2%
Taylor expanded in phi1 around 0
--lowering--.f6489.3%
Simplified89.3%
Taylor expanded in lambda2 around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6427.7%
Simplified27.7%
if 1.10000000000000004e26 < phi2 Initial program 57.6%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6493.6%
Simplified93.6%
Taylor expanded in phi2 around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f6477.7%
Simplified77.7%
Final simplification36.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 (<= phi2 -1.65e-216)
(- 0.0 (* R phi1))
(if (<= phi2 1.45e+26)
(* R (* lambda2 (- 1.0 (/ lambda1 lambda2))))
(* R (* phi2 (- 1.0 (/ 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 (phi2 <= -1.65e-216) {
tmp = 0.0 - (R * phi1);
} else if (phi2 <= 1.45e+26) {
tmp = R * (lambda2 * (1.0 - (lambda1 / lambda2)));
} else {
tmp = R * (phi2 * (1.0 - (phi1 / 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 (phi2 <= (-1.65d-216)) then
tmp = 0.0d0 - (r * phi1)
else if (phi2 <= 1.45d+26) then
tmp = r * (lambda2 * (1.0d0 - (lambda1 / lambda2)))
else
tmp = r * (phi2 * (1.0d0 - (phi1 / 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 (phi2 <= -1.65e-216) {
tmp = 0.0 - (R * phi1);
} else if (phi2 <= 1.45e+26) {
tmp = R * (lambda2 * (1.0 - (lambda1 / lambda2)));
} else {
tmp = R * (phi2 * (1.0 - (phi1 / phi2)));
}
return tmp;
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi2 <= -1.65e-216: tmp = 0.0 - (R * phi1) elif phi2 <= 1.45e+26: tmp = R * (lambda2 * (1.0 - (lambda1 / lambda2))) else: tmp = R * (phi2 * (1.0 - (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 (phi2 <= -1.65e-216) tmp = Float64(0.0 - Float64(R * phi1)); elseif (phi2 <= 1.45e+26) tmp = Float64(R * Float64(lambda2 * Float64(1.0 - Float64(lambda1 / lambda2)))); else tmp = Float64(R * Float64(phi2 * Float64(1.0 - Float64(phi1 / phi2)))); end return tmp end
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 <= -1.65e-216)
tmp = 0.0 - (R * phi1);
elseif (phi2 <= 1.45e+26)
tmp = R * (lambda2 * (1.0 - (lambda1 / lambda2)));
else
tmp = R * (phi2 * (1.0 - (phi1 / 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[phi2, -1.65e-216], N[(0.0 - N[(R * phi1), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi2, 1.45e+26], N[(R * N[(lambda2 * N[(1.0 - N[(lambda1 / lambda2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(R * N[(phi2 * N[(1.0 - N[(phi1 / phi2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
\mathbf{if}\;\phi_2 \leq -1.65 \cdot 10^{-216}:\\
\;\;\;\;0 - R \cdot \phi_1\\
\mathbf{elif}\;\phi_2 \leq 1.45 \cdot 10^{+26}:\\
\;\;\;\;R \cdot \left(\lambda_2 \cdot \left(1 - \frac{\lambda_1}{\lambda_2}\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \left(\phi_2 \cdot \left(1 - \frac{\phi_1}{\phi_2}\right)\right)\\
\end{array}
\end{array}
if phi2 < -1.64999999999999984e-216Initial program 55.0%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6492.2%
Simplified92.2%
Taylor expanded in phi1 around -inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-lowering-*.f6418.3%
Simplified18.3%
sub0-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
*-lowering-*.f64N/A
neg-lowering-neg.f6418.3%
Applied egg-rr18.3%
if -1.64999999999999984e-216 < phi2 < 1.45e26Initial program 64.2%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6499.9%
Simplified99.9%
Taylor expanded in phi2 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6498.2%
Simplified98.2%
Taylor expanded in phi1 around 0
--lowering--.f6489.3%
Simplified89.3%
Taylor expanded in lambda2 around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f6424.5%
Simplified24.5%
if 1.45e26 < phi2 Initial program 57.6%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6493.6%
Simplified93.6%
Taylor expanded in phi2 around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f6477.7%
Simplified77.7%
Final simplification35.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 (<= phi2 -5.4e-217)
(- 0.0 (* R phi1))
(if (<= phi2 4.8e+26)
(* R (* lambda2 (- 1.0 (/ lambda1 lambda2))))
(* 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 (phi2 <= -5.4e-217) {
tmp = 0.0 - (R * phi1);
} else if (phi2 <= 4.8e+26) {
tmp = R * (lambda2 * (1.0 - (lambda1 / lambda2)));
} 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 (phi2 <= (-5.4d-217)) then
tmp = 0.0d0 - (r * phi1)
else if (phi2 <= 4.8d+26) then
tmp = r * (lambda2 * (1.0d0 - (lambda1 / lambda2)))
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 (phi2 <= -5.4e-217) {
tmp = 0.0 - (R * phi1);
} else if (phi2 <= 4.8e+26) {
tmp = R * (lambda2 * (1.0 - (lambda1 / lambda2)));
} 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 phi2 <= -5.4e-217: tmp = 0.0 - (R * phi1) elif phi2 <= 4.8e+26: tmp = R * (lambda2 * (1.0 - (lambda1 / lambda2))) 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 (phi2 <= -5.4e-217) tmp = Float64(0.0 - Float64(R * phi1)); elseif (phi2 <= 4.8e+26) tmp = Float64(R * Float64(lambda2 * Float64(1.0 - Float64(lambda1 / lambda2)))); 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 (phi2 <= -5.4e-217)
tmp = 0.0 - (R * phi1);
elseif (phi2 <= 4.8e+26)
tmp = R * (lambda2 * (1.0 - (lambda1 / lambda2)));
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[phi2, -5.4e-217], N[(0.0 - N[(R * phi1), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi2, 4.8e+26], N[(R * N[(lambda2 * N[(1.0 - N[(lambda1 / lambda2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $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_2 \leq -5.4 \cdot 10^{-217}:\\
\;\;\;\;0 - R \cdot \phi_1\\
\mathbf{elif}\;\phi_2 \leq 4.8 \cdot 10^{+26}:\\
\;\;\;\;R \cdot \left(\lambda_2 \cdot \left(1 - \frac{\lambda_1}{\lambda_2}\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \phi_2\\
\end{array}
\end{array}
if phi2 < -5.40000000000000032e-217Initial program 55.0%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6492.2%
Simplified92.2%
Taylor expanded in phi1 around -inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-lowering-*.f6418.3%
Simplified18.3%
sub0-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
*-lowering-*.f64N/A
neg-lowering-neg.f6418.3%
Applied egg-rr18.3%
if -5.40000000000000032e-217 < phi2 < 4.80000000000000009e26Initial program 64.2%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6499.9%
Simplified99.9%
Taylor expanded in phi2 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6498.2%
Simplified98.2%
Taylor expanded in phi1 around 0
--lowering--.f6489.3%
Simplified89.3%
Taylor expanded in lambda2 around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f6424.5%
Simplified24.5%
if 4.80000000000000009e26 < phi2 Initial program 57.6%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6493.6%
Simplified93.6%
Taylor expanded in phi2 around inf
*-lowering-*.f6470.0%
Simplified70.0%
Final simplification33.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 -8.4e-91)
(- 0.0 (* R phi1))
(if (<= phi1 4.4e-294)
(* R (- 0.0 lambda1))
(if (<= phi1 6.2e-232) (* R lambda2) (* 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 <= -8.4e-91) {
tmp = 0.0 - (R * phi1);
} else if (phi1 <= 4.4e-294) {
tmp = R * (0.0 - lambda1);
} else if (phi1 <= 6.2e-232) {
tmp = R * lambda2;
} 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 <= (-8.4d-91)) then
tmp = 0.0d0 - (r * phi1)
else if (phi1 <= 4.4d-294) then
tmp = r * (0.0d0 - lambda1)
else if (phi1 <= 6.2d-232) then
tmp = r * lambda2
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 <= -8.4e-91) {
tmp = 0.0 - (R * phi1);
} else if (phi1 <= 4.4e-294) {
tmp = R * (0.0 - lambda1);
} else if (phi1 <= 6.2e-232) {
tmp = R * lambda2;
} 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 <= -8.4e-91: tmp = 0.0 - (R * phi1) elif phi1 <= 4.4e-294: tmp = R * (0.0 - lambda1) elif phi1 <= 6.2e-232: tmp = R * lambda2 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 <= -8.4e-91) tmp = Float64(0.0 - Float64(R * phi1)); elseif (phi1 <= 4.4e-294) tmp = Float64(R * Float64(0.0 - lambda1)); elseif (phi1 <= 6.2e-232) tmp = Float64(R * lambda2); 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 <= -8.4e-91)
tmp = 0.0 - (R * phi1);
elseif (phi1 <= 4.4e-294)
tmp = R * (0.0 - lambda1);
elseif (phi1 <= 6.2e-232)
tmp = R * lambda2;
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, -8.4e-91], N[(0.0 - N[(R * phi1), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, 4.4e-294], N[(R * N[(0.0 - lambda1), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, 6.2e-232], N[(R * lambda2), $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 -8.4 \cdot 10^{-91}:\\
\;\;\;\;0 - R \cdot \phi_1\\
\mathbf{elif}\;\phi_1 \leq 4.4 \cdot 10^{-294}:\\
\;\;\;\;R \cdot \left(0 - \lambda_1\right)\\
\mathbf{elif}\;\phi_1 \leq 6.2 \cdot 10^{-232}:\\
\;\;\;\;R \cdot \lambda_2\\
\mathbf{else}:\\
\;\;\;\;R \cdot \phi_2\\
\end{array}
\end{array}
if phi1 < -8.3999999999999997e-91Initial program 52.1%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6492.1%
Simplified92.1%
Taylor expanded in phi1 around -inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-lowering-*.f6448.4%
Simplified48.4%
sub0-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
*-lowering-*.f64N/A
neg-lowering-neg.f6448.4%
Applied egg-rr48.4%
if -8.3999999999999997e-91 < phi1 < 4.4e-294Initial program 71.9%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f64100.0%
Simplified100.0%
Taylor expanded in phi2 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6493.4%
Simplified93.4%
Taylor expanded in phi1 around 0
--lowering--.f6493.4%
Simplified93.4%
Taylor expanded in lambda1 around -inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-lowering-*.f6421.0%
Simplified21.0%
if 4.4e-294 < phi1 < 6.1999999999999998e-232Initial program 73.7%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6499.9%
Simplified99.9%
Taylor expanded in phi2 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6485.6%
Simplified85.6%
Taylor expanded in phi1 around 0
--lowering--.f6485.6%
Simplified85.6%
Taylor expanded in lambda2 around inf
*-lowering-*.f6420.4%
Simplified20.4%
if 6.1999999999999998e-232 < phi1 Initial program 56.9%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6495.1%
Simplified95.1%
Taylor expanded in phi2 around inf
*-lowering-*.f6424.3%
Simplified24.3%
Final simplification30.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 -4.5e-294) (- 0.0 (* R phi1)) (if (<= phi2 1.6e+27) (* R lambda2) (* 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 (phi2 <= -4.5e-294) {
tmp = 0.0 - (R * phi1);
} else if (phi2 <= 1.6e+27) {
tmp = R * lambda2;
} 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 (phi2 <= (-4.5d-294)) then
tmp = 0.0d0 - (r * phi1)
else if (phi2 <= 1.6d+27) then
tmp = r * lambda2
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 (phi2 <= -4.5e-294) {
tmp = 0.0 - (R * phi1);
} else if (phi2 <= 1.6e+27) {
tmp = R * lambda2;
} 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 phi2 <= -4.5e-294: tmp = 0.0 - (R * phi1) elif phi2 <= 1.6e+27: tmp = R * lambda2 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 (phi2 <= -4.5e-294) tmp = Float64(0.0 - Float64(R * phi1)); elseif (phi2 <= 1.6e+27) tmp = Float64(R * lambda2); 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 (phi2 <= -4.5e-294)
tmp = 0.0 - (R * phi1);
elseif (phi2 <= 1.6e+27)
tmp = R * lambda2;
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[phi2, -4.5e-294], N[(0.0 - N[(R * phi1), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi2, 1.6e+27], N[(R * lambda2), $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_2 \leq -4.5 \cdot 10^{-294}:\\
\;\;\;\;0 - R \cdot \phi_1\\
\mathbf{elif}\;\phi_2 \leq 1.6 \cdot 10^{+27}:\\
\;\;\;\;R \cdot \lambda_2\\
\mathbf{else}:\\
\;\;\;\;R \cdot \phi_2\\
\end{array}
\end{array}
if phi2 < -4.49999999999999981e-294Initial program 55.3%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6493.5%
Simplified93.5%
Taylor expanded in phi1 around -inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-lowering-*.f6417.4%
Simplified17.4%
sub0-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
*-lowering-*.f64N/A
neg-lowering-neg.f6417.4%
Applied egg-rr17.4%
if -4.49999999999999981e-294 < phi2 < 1.60000000000000008e27Initial program 66.3%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6499.9%
Simplified99.9%
Taylor expanded in phi2 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6497.7%
Simplified97.7%
Taylor expanded in phi1 around 0
--lowering--.f6487.4%
Simplified87.4%
Taylor expanded in lambda2 around inf
*-lowering-*.f6413.1%
Simplified13.1%
if 1.60000000000000008e27 < phi2 Initial program 57.6%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6493.6%
Simplified93.6%
Taylor expanded in phi2 around inf
*-lowering-*.f6470.0%
Simplified70.0%
Final simplification29.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 1.45e+26) (* R lambda2) (* 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 (phi2 <= 1.45e+26) {
tmp = R * lambda2;
} 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 (phi2 <= 1.45d+26) then
tmp = r * lambda2
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 (phi2 <= 1.45e+26) {
tmp = R * lambda2;
} 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 phi2 <= 1.45e+26: tmp = R * lambda2 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 (phi2 <= 1.45e+26) tmp = Float64(R * lambda2); 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 (phi2 <= 1.45e+26)
tmp = R * lambda2;
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[phi2, 1.45e+26], N[(R * lambda2), $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_2 \leq 1.45 \cdot 10^{+26}:\\
\;\;\;\;R \cdot \lambda_2\\
\mathbf{else}:\\
\;\;\;\;R \cdot \phi_2\\
\end{array}
\end{array}
if phi2 < 1.45e26Initial program 59.4%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6495.9%
Simplified95.9%
Taylor expanded in phi2 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6490.7%
Simplified90.7%
Taylor expanded in phi1 around 0
--lowering--.f6483.7%
Simplified83.7%
Taylor expanded in lambda2 around inf
*-lowering-*.f6411.4%
Simplified11.4%
if 1.45e26 < phi2 Initial program 57.6%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6493.6%
Simplified93.6%
Taylor expanded in phi2 around inf
*-lowering-*.f6470.0%
Simplified70.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 (* R lambda2))
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * lambda2;
}
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 * lambda2
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 * lambda2;
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): return R * lambda2
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) return Float64(R * lambda2) end
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
function tmp = code(R, lambda1, lambda2, phi1, phi2)
tmp = R * lambda2;
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 * lambda2), $MachinePrecision]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
R \cdot \lambda_2
\end{array}
Initial program 58.9%
*-lowering-*.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6495.3%
Simplified95.3%
Taylor expanded in phi2 around 0
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6490.7%
Simplified90.7%
Taylor expanded in phi1 around 0
--lowering--.f6485.4%
Simplified85.4%
Taylor expanded in lambda2 around inf
*-lowering-*.f6410.1%
Simplified10.1%
herbie shell --seed 2024138
(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))))))