
(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 12 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (let* ((t_0 (* (- lambda1 lambda2) (cos (/ (+ phi1 phi2) 2.0))))) (* R (sqrt (+ (* t_0 t_0) (* (- phi1 phi2) (- phi1 phi2)))))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = (lambda1 - lambda2) * cos(((phi1 + phi2) / 2.0));
return R * sqrt(((t_0 * t_0) + ((phi1 - phi2) * (phi1 - phi2))));
}
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: t_0
t_0 = (lambda1 - lambda2) * cos(((phi1 + phi2) / 2.0d0))
code = r * sqrt(((t_0 * t_0) + ((phi1 - phi2) * (phi1 - phi2))))
end function
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = (lambda1 - lambda2) * Math.cos(((phi1 + phi2) / 2.0));
return R * Math.sqrt(((t_0 * t_0) + ((phi1 - phi2) * (phi1 - phi2))));
}
def code(R, lambda1, lambda2, phi1, phi2): t_0 = (lambda1 - lambda2) * math.cos(((phi1 + phi2) / 2.0)) return R * math.sqrt(((t_0 * t_0) + ((phi1 - phi2) * (phi1 - phi2))))
function code(R, lambda1, lambda2, phi1, phi2) t_0 = Float64(Float64(lambda1 - lambda2) * cos(Float64(Float64(phi1 + phi2) / 2.0))) return Float64(R * sqrt(Float64(Float64(t_0 * t_0) + Float64(Float64(phi1 - phi2) * Float64(phi1 - phi2))))) end
function tmp = code(R, lambda1, lambda2, phi1, phi2) t_0 = (lambda1 - lambda2) * cos(((phi1 + phi2) / 2.0)); tmp = R * sqrt(((t_0 * t_0) + ((phi1 - phi2) * (phi1 - phi2)))); end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[(lambda1 - lambda2), $MachinePrecision] * N[Cos[N[(N[(phi1 + phi2), $MachinePrecision] / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, N[(R * N[Sqrt[N[(N[(t$95$0 * t$95$0), $MachinePrecision] + N[(N[(phi1 - phi2), $MachinePrecision] * N[(phi1 - phi2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(\lambda_1 - \lambda_2\right) \cdot \cos \left(\frac{\phi_1 + \phi_2}{2}\right)\\
R \cdot \sqrt{t\_0 \cdot t\_0 + \left(\phi_1 - \phi_2\right) \cdot \left(\phi_1 - \phi_2\right)}
\end{array}
\end{array}
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(*
R
(hypot
(*
(- lambda1 lambda2)
(-
(* (cos (* phi2 0.5)) (cos (* 0.5 phi1)))
(* (sin (* phi2 0.5)) (sin (* 0.5 phi1)))))
(- phi1 phi2))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * hypot(((lambda1 - lambda2) * ((cos((phi2 * 0.5)) * cos((0.5 * phi1))) - (sin((phi2 * 0.5)) * sin((0.5 * 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((phi2 * 0.5)) * Math.cos((0.5 * phi1))) - (Math.sin((phi2 * 0.5)) * Math.sin((0.5 * phi1))))), (phi1 - phi2));
}
def code(R, lambda1, lambda2, phi1, phi2): return R * math.hypot(((lambda1 - lambda2) * ((math.cos((phi2 * 0.5)) * math.cos((0.5 * phi1))) - (math.sin((phi2 * 0.5)) * math.sin((0.5 * phi1))))), (phi1 - phi2))
function code(R, lambda1, lambda2, phi1, phi2) return Float64(R * hypot(Float64(Float64(lambda1 - lambda2) * Float64(Float64(cos(Float64(phi2 * 0.5)) * cos(Float64(0.5 * phi1))) - Float64(sin(Float64(phi2 * 0.5)) * sin(Float64(0.5 * phi1))))), Float64(phi1 - phi2))) end
function tmp = code(R, lambda1, lambda2, phi1, phi2) tmp = R * hypot(((lambda1 - lambda2) * ((cos((phi2 * 0.5)) * cos((0.5 * phi1))) - (sin((phi2 * 0.5)) * sin((0.5 * phi1))))), (phi1 - phi2)); end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := N[(R * N[Sqrt[N[(N[(lambda1 - lambda2), $MachinePrecision] * N[(N[(N[Cos[N[(phi2 * 0.5), $MachinePrecision]], $MachinePrecision] * N[Cos[N[(0.5 * phi1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - N[(N[Sin[N[(phi2 * 0.5), $MachinePrecision]], $MachinePrecision] * N[Sin[N[(0.5 * phi1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
R \cdot \mathsf{hypot}\left(\left(\lambda_1 - \lambda_2\right) \cdot \left(\cos \left(\phi_2 \cdot 0.5\right) \cdot \cos \left(0.5 \cdot \phi_1\right) - \sin \left(\phi_2 \cdot 0.5\right) \cdot \sin \left(0.5 \cdot \phi_1\right)\right), \phi_1 - \phi_2\right)
\end{array}
Initial program 64.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--.f6497.1%
Simplified97.1%
Taylor expanded in lambda1 around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f6491.7%
Simplified91.7%
div-invN/A
metadata-evalN/A
*-commutativeN/A
+-commutativeN/A
distribute-rgt-inN/A
cos-sumN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f6493.6%
Applied egg-rr93.6%
Taylor expanded in lambda1 around 0
mul-1-negN/A
sub-negN/A
--lowering--.f6499.9%
Simplified99.9%
Final simplification99.9%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= phi1 -0.0115) (* R (hypot (* (- lambda1 lambda2) (cos (/ phi1 2.0))) (- phi1 phi2))) (* R (hypot (* (- lambda1 lambda2) (cos (/ phi2 2.0))) (- phi1 phi2)))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi1 <= -0.0115) {
tmp = R * hypot(((lambda1 - lambda2) * cos((phi1 / 2.0))), (phi1 - phi2));
} else {
tmp = R * hypot(((lambda1 - lambda2) * cos((phi2 / 2.0))), (phi1 - phi2));
}
return tmp;
}
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi1 <= -0.0115) {
tmp = R * Math.hypot(((lambda1 - lambda2) * Math.cos((phi1 / 2.0))), (phi1 - phi2));
} else {
tmp = R * Math.hypot(((lambda1 - lambda2) * Math.cos((phi2 / 2.0))), (phi1 - phi2));
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi1 <= -0.0115: tmp = R * math.hypot(((lambda1 - lambda2) * math.cos((phi1 / 2.0))), (phi1 - phi2)) else: tmp = R * math.hypot(((lambda1 - lambda2) * math.cos((phi2 / 2.0))), (phi1 - phi2)) return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi1 <= -0.0115) tmp = Float64(R * hypot(Float64(Float64(lambda1 - lambda2) * cos(Float64(phi1 / 2.0))), Float64(phi1 - phi2))); else tmp = Float64(R * hypot(Float64(Float64(lambda1 - lambda2) * cos(Float64(phi2 / 2.0))), Float64(phi1 - phi2))); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (phi1 <= -0.0115) tmp = R * hypot(((lambda1 - lambda2) * cos((phi1 / 2.0))), (phi1 - phi2)); else tmp = R * hypot(((lambda1 - lambda2) * cos((phi2 / 2.0))), (phi1 - phi2)); end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi1, -0.0115], N[(R * N[Sqrt[N[(N[(lambda1 - lambda2), $MachinePrecision] * N[Cos[N[(phi1 / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision], N[(R * N[Sqrt[N[(N[(lambda1 - lambda2), $MachinePrecision] * N[Cos[N[(phi2 / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_1 \leq -0.0115:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\left(\lambda_1 - \lambda_2\right) \cdot \cos \left(\frac{\phi_1}{2}\right), \phi_1 - \phi_2\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\left(\lambda_1 - \lambda_2\right) \cdot \cos \left(\frac{\phi_2}{2}\right), \phi_1 - \phi_2\right)\\
\end{array}
\end{array}
if phi1 < -0.0115Initial program 62.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--.f6492.6%
Simplified92.6%
Taylor expanded in phi1 around inf
Simplified92.4%
if -0.0115 < phi1 Initial program 65.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--.f6498.6%
Simplified98.6%
Taylor expanded in phi1 around 0
Simplified95.1%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (* R (hypot (* (- lambda1 lambda2) (cos (/ (+ phi2 phi1) 2.0))) (- phi1 phi2))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * hypot(((lambda1 - lambda2) * cos(((phi2 + phi1) / 2.0))), (phi1 - phi2));
}
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * Math.hypot(((lambda1 - lambda2) * Math.cos(((phi2 + phi1) / 2.0))), (phi1 - phi2));
}
def code(R, lambda1, lambda2, phi1, phi2): return R * math.hypot(((lambda1 - lambda2) * math.cos(((phi2 + phi1) / 2.0))), (phi1 - phi2))
function code(R, lambda1, lambda2, phi1, phi2) return Float64(R * hypot(Float64(Float64(lambda1 - lambda2) * cos(Float64(Float64(phi2 + phi1) / 2.0))), Float64(phi1 - phi2))) end
function tmp = code(R, lambda1, lambda2, phi1, phi2) tmp = R * hypot(((lambda1 - lambda2) * cos(((phi2 + phi1) / 2.0))), (phi1 - phi2)); end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := N[(R * N[Sqrt[N[(N[(lambda1 - lambda2), $MachinePrecision] * N[Cos[N[(N[(phi2 + phi1), $MachinePrecision] / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
R \cdot \mathsf{hypot}\left(\left(\lambda_1 - \lambda_2\right) \cdot \cos \left(\frac{\phi_2 + \phi_1}{2}\right), \phi_1 - \phi_2\right)
\end{array}
Initial program 64.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--.f6497.1%
Simplified97.1%
Final simplification97.1%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (* R (hypot (* (- lambda1 lambda2) (cos (/ phi1 2.0))) (- phi1 phi2))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * hypot(((lambda1 - lambda2) * cos((phi1 / 2.0))), (phi1 - phi2));
}
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * Math.hypot(((lambda1 - lambda2) * Math.cos((phi1 / 2.0))), (phi1 - phi2));
}
def code(R, lambda1, lambda2, phi1, phi2): return R * math.hypot(((lambda1 - lambda2) * math.cos((phi1 / 2.0))), (phi1 - phi2))
function code(R, lambda1, lambda2, phi1, phi2) return Float64(R * hypot(Float64(Float64(lambda1 - lambda2) * cos(Float64(phi1 / 2.0))), Float64(phi1 - phi2))) end
function tmp = code(R, lambda1, lambda2, phi1, phi2) tmp = R * hypot(((lambda1 - lambda2) * cos((phi1 / 2.0))), (phi1 - phi2)); end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := N[(R * N[Sqrt[N[(N[(lambda1 - lambda2), $MachinePrecision] * N[Cos[N[(phi1 / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
R \cdot \mathsf{hypot}\left(\left(\lambda_1 - \lambda_2\right) \cdot \cos \left(\frac{\phi_1}{2}\right), \phi_1 - \phi_2\right)
\end{array}
Initial program 64.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--.f6497.1%
Simplified97.1%
Taylor expanded in phi1 around inf
Simplified89.7%
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(if (<= phi2 4e-288)
(* phi1 (- (* R (/ phi2 phi1)) R))
(if (<= phi2 0.122)
(*
lambda1
(* (- (/ (* R lambda2) lambda1) R) (cos (* 0.5 (+ phi2 phi1)))))
(* (- 1.0 (/ phi1 phi2)) (* R phi2)))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 4e-288) {
tmp = phi1 * ((R * (phi2 / phi1)) - R);
} else if (phi2 <= 0.122) {
tmp = lambda1 * ((((R * lambda2) / lambda1) - R) * cos((0.5 * (phi2 + phi1))));
} else {
tmp = (1.0 - (phi1 / phi2)) * (R * phi2);
}
return tmp;
}
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: tmp
if (phi2 <= 4d-288) then
tmp = phi1 * ((r * (phi2 / phi1)) - r)
else if (phi2 <= 0.122d0) then
tmp = lambda1 * ((((r * lambda2) / lambda1) - r) * cos((0.5d0 * (phi2 + phi1))))
else
tmp = (1.0d0 - (phi1 / phi2)) * (r * phi2)
end if
code = tmp
end function
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 4e-288) {
tmp = phi1 * ((R * (phi2 / phi1)) - R);
} else if (phi2 <= 0.122) {
tmp = lambda1 * ((((R * lambda2) / lambda1) - R) * Math.cos((0.5 * (phi2 + phi1))));
} else {
tmp = (1.0 - (phi1 / phi2)) * (R * phi2);
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi2 <= 4e-288: tmp = phi1 * ((R * (phi2 / phi1)) - R) elif phi2 <= 0.122: tmp = lambda1 * ((((R * lambda2) / lambda1) - R) * math.cos((0.5 * (phi2 + phi1)))) else: tmp = (1.0 - (phi1 / phi2)) * (R * phi2) return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi2 <= 4e-288) tmp = Float64(phi1 * Float64(Float64(R * Float64(phi2 / phi1)) - R)); elseif (phi2 <= 0.122) tmp = Float64(lambda1 * Float64(Float64(Float64(Float64(R * lambda2) / lambda1) - R) * cos(Float64(0.5 * Float64(phi2 + phi1))))); else tmp = Float64(Float64(1.0 - Float64(phi1 / phi2)) * Float64(R * phi2)); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (phi2 <= 4e-288) tmp = phi1 * ((R * (phi2 / phi1)) - R); elseif (phi2 <= 0.122) tmp = lambda1 * ((((R * lambda2) / lambda1) - R) * cos((0.5 * (phi2 + phi1)))); else tmp = (1.0 - (phi1 / phi2)) * (R * phi2); end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi2, 4e-288], N[(phi1 * N[(N[(R * N[(phi2 / phi1), $MachinePrecision]), $MachinePrecision] - R), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi2, 0.122], N[(lambda1 * N[(N[(N[(N[(R * lambda2), $MachinePrecision] / lambda1), $MachinePrecision] - R), $MachinePrecision] * N[Cos[N[(0.5 * N[(phi2 + phi1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 - N[(phi1 / phi2), $MachinePrecision]), $MachinePrecision] * N[(R * phi2), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_2 \leq 4 \cdot 10^{-288}:\\
\;\;\;\;\phi_1 \cdot \left(R \cdot \frac{\phi_2}{\phi_1} - R\right)\\
\mathbf{elif}\;\phi_2 \leq 0.122:\\
\;\;\;\;\lambda_1 \cdot \left(\left(\frac{R \cdot \lambda_2}{\lambda_1} - R\right) \cdot \cos \left(0.5 \cdot \left(\phi_2 + \phi_1\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(1 - \frac{\phi_1}{\phi_2}\right) \cdot \left(R \cdot \phi_2\right)\\
\end{array}
\end{array}
if phi2 < 4.00000000000000023e-288Initial program 64.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--.f6496.0%
Simplified96.0%
Taylor expanded in phi1 around -inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f6419.6%
Simplified19.6%
if 4.00000000000000023e-288 < phi2 < 0.122Initial program 71.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--.f6499.1%
Simplified99.1%
Taylor expanded in lambda1 around -inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
Simplified35.7%
*-commutativeN/A
associate-/l*N/A
distribute-lft-out--N/A
*-lowering-*.f64N/A
+-commutativeN/A
distribute-rgt-inN/A
cos-lowering-cos.f64N/A
distribute-rgt-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6435.7%
Applied egg-rr35.7%
if 0.122 < phi2 Initial program 59.8%
*-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--.f6497.5%
Simplified97.5%
Taylor expanded in phi2 around inf
*-lowering-*.f64N/A
associate-+r+N/A
+-lowering-+.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
associate-/l*N/A
*-lowering-*.f64N/A
Simplified59.9%
Applied egg-rr70.5%
Taylor expanded in phi1 around inf
/-lowering-/.f6468.6%
Simplified68.6%
Final simplification36.4%
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(if (<= lambda2 -6.2e+170)
(* R (* (- 0.0 lambda1) (cos (* 0.5 (+ phi2 phi1)))))
(if (<= lambda2 9.8e+148)
(* phi2 (- R (/ (* R phi1) phi2)))
(* R lambda2))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (lambda2 <= -6.2e+170) {
tmp = R * ((0.0 - lambda1) * cos((0.5 * (phi2 + phi1))));
} else if (lambda2 <= 9.8e+148) {
tmp = phi2 * (R - ((R * phi1) / phi2));
} else {
tmp = R * lambda2;
}
return tmp;
}
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: tmp
if (lambda2 <= (-6.2d+170)) then
tmp = r * ((0.0d0 - lambda1) * cos((0.5d0 * (phi2 + phi1))))
else if (lambda2 <= 9.8d+148) then
tmp = phi2 * (r - ((r * phi1) / phi2))
else
tmp = r * lambda2
end if
code = tmp
end function
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (lambda2 <= -6.2e+170) {
tmp = R * ((0.0 - lambda1) * Math.cos((0.5 * (phi2 + phi1))));
} else if (lambda2 <= 9.8e+148) {
tmp = phi2 * (R - ((R * phi1) / phi2));
} else {
tmp = R * lambda2;
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if lambda2 <= -6.2e+170: tmp = R * ((0.0 - lambda1) * math.cos((0.5 * (phi2 + phi1)))) elif lambda2 <= 9.8e+148: tmp = phi2 * (R - ((R * phi1) / phi2)) else: tmp = R * lambda2 return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (lambda2 <= -6.2e+170) tmp = Float64(R * Float64(Float64(0.0 - lambda1) * cos(Float64(0.5 * Float64(phi2 + phi1))))); elseif (lambda2 <= 9.8e+148) tmp = Float64(phi2 * Float64(R - Float64(Float64(R * phi1) / phi2))); else tmp = Float64(R * lambda2); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (lambda2 <= -6.2e+170) tmp = R * ((0.0 - lambda1) * cos((0.5 * (phi2 + phi1)))); elseif (lambda2 <= 9.8e+148) tmp = phi2 * (R - ((R * phi1) / phi2)); else tmp = R * lambda2; end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[lambda2, -6.2e+170], N[(R * N[(N[(0.0 - lambda1), $MachinePrecision] * N[Cos[N[(0.5 * N[(phi2 + phi1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[lambda2, 9.8e+148], N[(phi2 * N[(R - N[(N[(R * phi1), $MachinePrecision] / phi2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(R * lambda2), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\lambda_2 \leq -6.2 \cdot 10^{+170}:\\
\;\;\;\;R \cdot \left(\left(0 - \lambda_1\right) \cdot \cos \left(0.5 \cdot \left(\phi_2 + \phi_1\right)\right)\right)\\
\mathbf{elif}\;\lambda_2 \leq 9.8 \cdot 10^{+148}:\\
\;\;\;\;\phi_2 \cdot \left(R - \frac{R \cdot \phi_1}{\phi_2}\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \lambda_2\\
\end{array}
\end{array}
if lambda2 < -6.2e170Initial program 46.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--.f6497.1%
Simplified97.1%
Taylor expanded in lambda1 around -inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
mul-1-negN/A
neg-lowering-neg.f6413.7%
Simplified13.7%
if -6.2e170 < lambda2 < 9.8e148Initial program 68.8%
*-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--.f6497.6%
Simplified97.6%
Taylor expanded in phi2 around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6437.5%
Simplified37.5%
if 9.8e148 < lambda2 Initial program 52.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.2%
Simplified93.2%
Taylor expanded in lambda2 around inf
*-commutativeN/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f6452.5%
Simplified52.5%
Taylor expanded in phi2 around 0
cos-lowering-cos.f64N/A
*-lowering-*.f6448.2%
Simplified48.2%
Taylor expanded in phi1 around 0
*-lowering-*.f6461.2%
Simplified61.2%
Final simplification37.3%
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(if (<= phi2 2.4e-282)
(* phi1 (- (* R (/ phi2 phi1)) R))
(if (<= phi2 3.8e-57)
(*
R
(*
lambda2
(+
(* (* phi1 phi1) (+ (* (* phi1 phi1) 0.0026041666666666665) -0.125))
1.0)))
(* R (* phi2 (- 1.0 (/ phi1 phi2)))))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 2.4e-282) {
tmp = phi1 * ((R * (phi2 / phi1)) - R);
} else if (phi2 <= 3.8e-57) {
tmp = R * (lambda2 * (((phi1 * phi1) * (((phi1 * phi1) * 0.0026041666666666665) + -0.125)) + 1.0));
} else {
tmp = R * (phi2 * (1.0 - (phi1 / phi2)));
}
return tmp;
}
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: tmp
if (phi2 <= 2.4d-282) then
tmp = phi1 * ((r * (phi2 / phi1)) - r)
else if (phi2 <= 3.8d-57) then
tmp = r * (lambda2 * (((phi1 * phi1) * (((phi1 * phi1) * 0.0026041666666666665d0) + (-0.125d0))) + 1.0d0))
else
tmp = r * (phi2 * (1.0d0 - (phi1 / phi2)))
end if
code = tmp
end function
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 2.4e-282) {
tmp = phi1 * ((R * (phi2 / phi1)) - R);
} else if (phi2 <= 3.8e-57) {
tmp = R * (lambda2 * (((phi1 * phi1) * (((phi1 * phi1) * 0.0026041666666666665) + -0.125)) + 1.0));
} else {
tmp = R * (phi2 * (1.0 - (phi1 / phi2)));
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi2 <= 2.4e-282: tmp = phi1 * ((R * (phi2 / phi1)) - R) elif phi2 <= 3.8e-57: tmp = R * (lambda2 * (((phi1 * phi1) * (((phi1 * phi1) * 0.0026041666666666665) + -0.125)) + 1.0)) else: tmp = R * (phi2 * (1.0 - (phi1 / phi2))) return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi2 <= 2.4e-282) tmp = Float64(phi1 * Float64(Float64(R * Float64(phi2 / phi1)) - R)); elseif (phi2 <= 3.8e-57) tmp = Float64(R * Float64(lambda2 * Float64(Float64(Float64(phi1 * phi1) * Float64(Float64(Float64(phi1 * phi1) * 0.0026041666666666665) + -0.125)) + 1.0))); else tmp = Float64(R * Float64(phi2 * Float64(1.0 - Float64(phi1 / phi2)))); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (phi2 <= 2.4e-282) tmp = phi1 * ((R * (phi2 / phi1)) - R); elseif (phi2 <= 3.8e-57) tmp = R * (lambda2 * (((phi1 * phi1) * (((phi1 * phi1) * 0.0026041666666666665) + -0.125)) + 1.0)); else tmp = R * (phi2 * (1.0 - (phi1 / phi2))); end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi2, 2.4e-282], N[(phi1 * N[(N[(R * N[(phi2 / phi1), $MachinePrecision]), $MachinePrecision] - R), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi2, 3.8e-57], N[(R * N[(lambda2 * N[(N[(N[(phi1 * phi1), $MachinePrecision] * N[(N[(N[(phi1 * phi1), $MachinePrecision] * 0.0026041666666666665), $MachinePrecision] + -0.125), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(R * N[(phi2 * N[(1.0 - N[(phi1 / phi2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_2 \leq 2.4 \cdot 10^{-282}:\\
\;\;\;\;\phi_1 \cdot \left(R \cdot \frac{\phi_2}{\phi_1} - R\right)\\
\mathbf{elif}\;\phi_2 \leq 3.8 \cdot 10^{-57}:\\
\;\;\;\;R \cdot \left(\lambda_2 \cdot \left(\left(\phi_1 \cdot \phi_1\right) \cdot \left(\left(\phi_1 \cdot \phi_1\right) \cdot 0.0026041666666666665 + -0.125\right) + 1\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 < 2.39999999999999997e-282Initial program 62.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--.f6496.1%
Simplified96.1%
Taylor expanded in phi1 around -inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f6419.2%
Simplified19.2%
if 2.39999999999999997e-282 < phi2 < 3.7999999999999997e-57Initial program 73.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--.f64100.0%
Simplified100.0%
Taylor expanded in lambda2 around inf
*-commutativeN/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f6420.8%
Simplified20.8%
Taylor expanded in phi2 around 0
cos-lowering-cos.f64N/A
*-lowering-*.f6420.8%
Simplified20.8%
Taylor expanded in phi1 around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6430.2%
Simplified30.2%
if 3.7999999999999997e-57 < phi2 Initial program 62.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--.f6497.2%
Simplified97.2%
Taylor expanded in phi2 around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f6464.9%
Simplified64.9%
Final simplification35.1%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= phi2 2.1e-282) (* phi1 (- 0.0 R)) (if (<= phi2 1.75e-54) (* R lambda2) (* R (* phi2 (- 1.0 (/ phi1 phi2)))))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 2.1e-282) {
tmp = phi1 * (0.0 - R);
} else if (phi2 <= 1.75e-54) {
tmp = R * lambda2;
} else {
tmp = R * (phi2 * (1.0 - (phi1 / phi2)));
}
return tmp;
}
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: tmp
if (phi2 <= 2.1d-282) then
tmp = phi1 * (0.0d0 - r)
else if (phi2 <= 1.75d-54) then
tmp = r * lambda2
else
tmp = r * (phi2 * (1.0d0 - (phi1 / phi2)))
end if
code = tmp
end function
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 2.1e-282) {
tmp = phi1 * (0.0 - R);
} else if (phi2 <= 1.75e-54) {
tmp = R * lambda2;
} else {
tmp = R * (phi2 * (1.0 - (phi1 / phi2)));
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi2 <= 2.1e-282: tmp = phi1 * (0.0 - R) elif phi2 <= 1.75e-54: tmp = R * lambda2 else: tmp = R * (phi2 * (1.0 - (phi1 / phi2))) return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi2 <= 2.1e-282) tmp = Float64(phi1 * Float64(0.0 - R)); elseif (phi2 <= 1.75e-54) tmp = Float64(R * lambda2); else tmp = Float64(R * Float64(phi2 * Float64(1.0 - Float64(phi1 / phi2)))); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (phi2 <= 2.1e-282) tmp = phi1 * (0.0 - R); elseif (phi2 <= 1.75e-54) tmp = R * lambda2; else tmp = R * (phi2 * (1.0 - (phi1 / phi2))); end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi2, 2.1e-282], N[(phi1 * N[(0.0 - R), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi2, 1.75e-54], N[(R * lambda2), $MachinePrecision], N[(R * N[(phi2 * N[(1.0 - N[(phi1 / phi2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_2 \leq 2.1 \cdot 10^{-282}:\\
\;\;\;\;\phi_1 \cdot \left(0 - R\right)\\
\mathbf{elif}\;\phi_2 \leq 1.75 \cdot 10^{-54}:\\
\;\;\;\;R \cdot \lambda_2\\
\mathbf{else}:\\
\;\;\;\;R \cdot \left(\phi_2 \cdot \left(1 - \frac{\phi_1}{\phi_2}\right)\right)\\
\end{array}
\end{array}
if phi2 < 2.10000000000000012e-282Initial program 62.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--.f6496.1%
Simplified96.1%
Taylor expanded in lambda1 around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f6490.2%
Simplified90.2%
div-invN/A
metadata-evalN/A
*-commutativeN/A
+-commutativeN/A
distribute-rgt-inN/A
cos-sumN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f6492.2%
Applied egg-rr92.2%
Taylor expanded in phi1 around -inf
mul-1-negN/A
neg-lowering-neg.f6421.3%
Simplified21.3%
if 2.10000000000000012e-282 < phi2 < 1.74999999999999991e-54Initial program 73.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--.f64100.0%
Simplified100.0%
Taylor expanded in lambda2 around inf
*-commutativeN/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f6420.8%
Simplified20.8%
Taylor expanded in phi2 around 0
cos-lowering-cos.f64N/A
*-lowering-*.f6420.8%
Simplified20.8%
Taylor expanded in phi1 around 0
*-lowering-*.f6422.3%
Simplified22.3%
if 1.74999999999999991e-54 < phi2 Initial program 62.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--.f6497.2%
Simplified97.2%
Taylor expanded in phi2 around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f6464.9%
Simplified64.9%
Final simplification34.9%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= lambda2 1.05e+149) (* phi2 (- R (/ (* R phi1) phi2))) (* R lambda2)))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (lambda2 <= 1.05e+149) {
tmp = phi2 * (R - ((R * phi1) / phi2));
} else {
tmp = R * lambda2;
}
return tmp;
}
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: tmp
if (lambda2 <= 1.05d+149) then
tmp = phi2 * (r - ((r * phi1) / phi2))
else
tmp = r * lambda2
end if
code = tmp
end function
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (lambda2 <= 1.05e+149) {
tmp = phi2 * (R - ((R * phi1) / phi2));
} else {
tmp = R * lambda2;
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if lambda2 <= 1.05e+149: tmp = phi2 * (R - ((R * phi1) / phi2)) else: tmp = R * lambda2 return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (lambda2 <= 1.05e+149) tmp = Float64(phi2 * Float64(R - Float64(Float64(R * phi1) / phi2))); else tmp = Float64(R * lambda2); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (lambda2 <= 1.05e+149) tmp = phi2 * (R - ((R * phi1) / phi2)); else tmp = R * lambda2; end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[lambda2, 1.05e+149], N[(phi2 * N[(R - N[(N[(R * phi1), $MachinePrecision] / phi2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(R * lambda2), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\lambda_2 \leq 1.05 \cdot 10^{+149}:\\
\;\;\;\;\phi_2 \cdot \left(R - \frac{R \cdot \phi_1}{\phi_2}\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \lambda_2\\
\end{array}
\end{array}
if lambda2 < 1.0500000000000001e149Initial program 65.8%
*-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--.f6497.5%
Simplified97.5%
Taylor expanded in phi2 around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6435.9%
Simplified35.9%
if 1.0500000000000001e149 < lambda2 Initial program 52.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.2%
Simplified93.2%
Taylor expanded in lambda2 around inf
*-commutativeN/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f6452.5%
Simplified52.5%
Taylor expanded in phi2 around 0
cos-lowering-cos.f64N/A
*-lowering-*.f6448.2%
Simplified48.2%
Taylor expanded in phi1 around 0
*-lowering-*.f6461.2%
Simplified61.2%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= phi2 2.05e-282) (* phi1 (- 0.0 R)) (if (<= phi2 2.3e-28) (* R lambda2) (* R phi2))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 2.05e-282) {
tmp = phi1 * (0.0 - R);
} else if (phi2 <= 2.3e-28) {
tmp = R * lambda2;
} else {
tmp = R * phi2;
}
return tmp;
}
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: tmp
if (phi2 <= 2.05d-282) then
tmp = phi1 * (0.0d0 - r)
else if (phi2 <= 2.3d-28) then
tmp = r * lambda2
else
tmp = r * phi2
end if
code = tmp
end function
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 2.05e-282) {
tmp = phi1 * (0.0 - R);
} else if (phi2 <= 2.3e-28) {
tmp = R * lambda2;
} else {
tmp = R * phi2;
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi2 <= 2.05e-282: tmp = phi1 * (0.0 - R) elif phi2 <= 2.3e-28: tmp = R * lambda2 else: tmp = R * phi2 return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi2 <= 2.05e-282) tmp = Float64(phi1 * Float64(0.0 - R)); elseif (phi2 <= 2.3e-28) tmp = Float64(R * lambda2); else tmp = Float64(R * phi2); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (phi2 <= 2.05e-282) tmp = phi1 * (0.0 - R); elseif (phi2 <= 2.3e-28) tmp = R * lambda2; else tmp = R * phi2; end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi2, 2.05e-282], N[(phi1 * N[(0.0 - R), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi2, 2.3e-28], N[(R * lambda2), $MachinePrecision], N[(R * phi2), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_2 \leq 2.05 \cdot 10^{-282}:\\
\;\;\;\;\phi_1 \cdot \left(0 - R\right)\\
\mathbf{elif}\;\phi_2 \leq 2.3 \cdot 10^{-28}:\\
\;\;\;\;R \cdot \lambda_2\\
\mathbf{else}:\\
\;\;\;\;R \cdot \phi_2\\
\end{array}
\end{array}
if phi2 < 2.04999999999999989e-282Initial program 62.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--.f6496.1%
Simplified96.1%
Taylor expanded in lambda1 around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f6490.2%
Simplified90.2%
div-invN/A
metadata-evalN/A
*-commutativeN/A
+-commutativeN/A
distribute-rgt-inN/A
cos-sumN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f6492.2%
Applied egg-rr92.2%
Taylor expanded in phi1 around -inf
mul-1-negN/A
neg-lowering-neg.f6421.3%
Simplified21.3%
if 2.04999999999999989e-282 < phi2 < 2.29999999999999986e-28Initial program 75.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--.f64100.0%
Simplified100.0%
Taylor expanded in lambda2 around inf
*-commutativeN/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f6419.4%
Simplified19.4%
Taylor expanded in phi2 around 0
cos-lowering-cos.f64N/A
*-lowering-*.f6419.4%
Simplified19.4%
Taylor expanded in phi1 around 0
*-lowering-*.f6420.7%
Simplified20.7%
if 2.29999999999999986e-28 < phi2 Initial program 60.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--.f6497.0%
Simplified97.0%
Taylor expanded in phi2 around inf
*-lowering-*.f6460.8%
Simplified60.8%
Final simplification32.8%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= phi2 1.05e-28) (* R lambda2) (* R phi2)))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 1.05e-28) {
tmp = R * lambda2;
} else {
tmp = R * phi2;
}
return tmp;
}
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: tmp
if (phi2 <= 1.05d-28) then
tmp = r * lambda2
else
tmp = r * phi2
end if
code = tmp
end function
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 1.05e-28) {
tmp = R * lambda2;
} else {
tmp = R * phi2;
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi2 <= 1.05e-28: tmp = R * lambda2 else: tmp = R * phi2 return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi2 <= 1.05e-28) tmp = Float64(R * lambda2); else tmp = Float64(R * phi2); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (phi2 <= 1.05e-28) tmp = R * lambda2; else tmp = R * phi2; end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi2, 1.05e-28], N[(R * lambda2), $MachinePrecision], N[(R * phi2), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_2 \leq 1.05 \cdot 10^{-28}:\\
\;\;\;\;R \cdot \lambda_2\\
\mathbf{else}:\\
\;\;\;\;R \cdot \phi_2\\
\end{array}
\end{array}
if phi2 < 1.05000000000000003e-28Initial program 65.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--.f6497.1%
Simplified97.1%
Taylor expanded in lambda2 around inf
*-commutativeN/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f6419.5%
Simplified19.5%
Taylor expanded in phi2 around 0
cos-lowering-cos.f64N/A
*-lowering-*.f6418.0%
Simplified18.0%
Taylor expanded in phi1 around 0
*-lowering-*.f6416.3%
Simplified16.3%
if 1.05000000000000003e-28 < phi2 Initial program 60.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--.f6497.0%
Simplified97.0%
Taylor expanded in phi2 around inf
*-lowering-*.f6460.8%
Simplified60.8%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (* R lambda2))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * lambda2;
}
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
code = r * lambda2
end function
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * lambda2;
}
def code(R, lambda1, lambda2, phi1, phi2): return R * lambda2
function code(R, lambda1, lambda2, phi1, phi2) return Float64(R * lambda2) end
function tmp = code(R, lambda1, lambda2, phi1, phi2) tmp = R * lambda2; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := N[(R * lambda2), $MachinePrecision]
\begin{array}{l}
\\
R \cdot \lambda_2
\end{array}
Initial program 64.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--.f6497.1%
Simplified97.1%
Taylor expanded in lambda2 around inf
*-commutativeN/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f6417.7%
Simplified17.7%
Taylor expanded in phi2 around 0
cos-lowering-cos.f64N/A
*-lowering-*.f6414.7%
Simplified14.7%
Taylor expanded in phi1 around 0
*-lowering-*.f6413.8%
Simplified13.8%
herbie shell --seed 2024144
(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))))))