
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (let* ((t_0 (* (- lambda1 lambda2) (cos (/ (+ phi1 phi2) 2.0))))) (* R (sqrt (+ (* t_0 t_0) (* (- phi1 phi2) (- phi1 phi2)))))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = (lambda1 - lambda2) * cos(((phi1 + phi2) / 2.0));
return R * sqrt(((t_0 * t_0) + ((phi1 - phi2) * (phi1 - phi2))));
}
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: t_0
t_0 = (lambda1 - lambda2) * cos(((phi1 + phi2) / 2.0d0))
code = r * sqrt(((t_0 * t_0) + ((phi1 - phi2) * (phi1 - phi2))))
end function
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = (lambda1 - lambda2) * Math.cos(((phi1 + phi2) / 2.0));
return R * Math.sqrt(((t_0 * t_0) + ((phi1 - phi2) * (phi1 - phi2))));
}
def code(R, lambda1, lambda2, phi1, phi2): t_0 = (lambda1 - lambda2) * math.cos(((phi1 + phi2) / 2.0)) return R * math.sqrt(((t_0 * t_0) + ((phi1 - phi2) * (phi1 - phi2))))
function code(R, lambda1, lambda2, phi1, phi2) t_0 = Float64(Float64(lambda1 - lambda2) * cos(Float64(Float64(phi1 + phi2) / 2.0))) return Float64(R * sqrt(Float64(Float64(t_0 * t_0) + Float64(Float64(phi1 - phi2) * Float64(phi1 - phi2))))) end
function tmp = code(R, lambda1, lambda2, phi1, phi2) t_0 = (lambda1 - lambda2) * cos(((phi1 + phi2) / 2.0)); tmp = R * sqrt(((t_0 * t_0) + ((phi1 - phi2) * (phi1 - phi2)))); end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[(lambda1 - lambda2), $MachinePrecision] * N[Cos[N[(N[(phi1 + phi2), $MachinePrecision] / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, N[(R * N[Sqrt[N[(N[(t$95$0 * t$95$0), $MachinePrecision] + N[(N[(phi1 - phi2), $MachinePrecision] * N[(phi1 - phi2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(\lambda_1 - \lambda_2\right) \cdot \cos \left(\frac{\phi_1 + \phi_2}{2}\right)\\
R \cdot \sqrt{t\_0 \cdot t\_0 + \left(\phi_1 - \phi_2\right) \cdot \left(\phi_1 - \phi_2\right)}
\end{array}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 15 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (let* ((t_0 (* (- lambda1 lambda2) (cos (/ (+ phi1 phi2) 2.0))))) (* R (sqrt (+ (* t_0 t_0) (* (- phi1 phi2) (- phi1 phi2)))))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = (lambda1 - lambda2) * cos(((phi1 + phi2) / 2.0));
return R * sqrt(((t_0 * t_0) + ((phi1 - phi2) * (phi1 - phi2))));
}
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: t_0
t_0 = (lambda1 - lambda2) * cos(((phi1 + phi2) / 2.0d0))
code = r * sqrt(((t_0 * t_0) + ((phi1 - phi2) * (phi1 - phi2))))
end function
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = (lambda1 - lambda2) * Math.cos(((phi1 + phi2) / 2.0));
return R * Math.sqrt(((t_0 * t_0) + ((phi1 - phi2) * (phi1 - phi2))));
}
def code(R, lambda1, lambda2, phi1, phi2): t_0 = (lambda1 - lambda2) * math.cos(((phi1 + phi2) / 2.0)) return R * math.sqrt(((t_0 * t_0) + ((phi1 - phi2) * (phi1 - phi2))))
function code(R, lambda1, lambda2, phi1, phi2) t_0 = Float64(Float64(lambda1 - lambda2) * cos(Float64(Float64(phi1 + phi2) / 2.0))) return Float64(R * sqrt(Float64(Float64(t_0 * t_0) + Float64(Float64(phi1 - phi2) * Float64(phi1 - phi2))))) end
function tmp = code(R, lambda1, lambda2, phi1, phi2) t_0 = (lambda1 - lambda2) * cos(((phi1 + phi2) / 2.0)); tmp = R * sqrt(((t_0 * t_0) + ((phi1 - phi2) * (phi1 - phi2)))); end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[(lambda1 - lambda2), $MachinePrecision] * N[Cos[N[(N[(phi1 + phi2), $MachinePrecision] / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, N[(R * N[Sqrt[N[(N[(t$95$0 * t$95$0), $MachinePrecision] + N[(N[(phi1 - phi2), $MachinePrecision] * N[(phi1 - phi2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(\lambda_1 - \lambda_2\right) \cdot \cos \left(\frac{\phi_1 + \phi_2}{2}\right)\\
R \cdot \sqrt{t\_0 \cdot t\_0 + \left(\phi_1 - \phi_2\right) \cdot \left(\phi_1 - \phi_2\right)}
\end{array}
\end{array}
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(*
R
(hypot
(*
(- lambda1 lambda2)
(fma
(cos (* phi2 0.5))
(cos (* 0.5 phi1))
(* (sin (* phi2 0.5)) (- (sin (* 0.5 phi1))))))
(- phi1 phi2))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * hypot(((lambda1 - lambda2) * fma(cos((phi2 * 0.5)), cos((0.5 * phi1)), (sin((phi2 * 0.5)) * -sin((0.5 * phi1))))), (phi1 - phi2));
}
function code(R, lambda1, lambda2, phi1, phi2) return Float64(R * hypot(Float64(Float64(lambda1 - lambda2) * fma(cos(Float64(phi2 * 0.5)), cos(Float64(0.5 * phi1)), Float64(sin(Float64(phi2 * 0.5)) * Float64(-sin(Float64(0.5 * phi1)))))), Float64(phi1 - phi2))) end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := N[(R * N[Sqrt[N[(N[(lambda1 - lambda2), $MachinePrecision] * N[(N[Cos[N[(phi2 * 0.5), $MachinePrecision]], $MachinePrecision] * N[Cos[N[(0.5 * phi1), $MachinePrecision]], $MachinePrecision] + N[(N[Sin[N[(phi2 * 0.5), $MachinePrecision]], $MachinePrecision] * (-N[Sin[N[(0.5 * phi1), $MachinePrecision]], $MachinePrecision])), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
R \cdot \mathsf{hypot}\left(\left(\lambda_1 - \lambda_2\right) \cdot \mathsf{fma}\left(\cos \left(\phi_2 \cdot 0.5\right), \cos \left(0.5 \cdot \phi_1\right), \sin \left(\phi_2 \cdot 0.5\right) \cdot \left(-\sin \left(0.5 \cdot \phi_1\right)\right)\right), \phi_1 - \phi_2\right)
\end{array}
Initial program 56.0%
hypot-define96.9%
Simplified96.9%
add-cube-cbrt96.6%
pow296.6%
div-inv96.6%
metadata-eval96.6%
div-inv96.6%
metadata-eval96.6%
Applied egg-rr96.6%
*-commutative96.6%
+-commutative96.6%
distribute-lft-in96.6%
cos-sum96.7%
*-commutative96.7%
*-commutative96.7%
*-commutative96.7%
*-commutative96.7%
Applied egg-rr96.7%
*-commutative96.6%
+-commutative96.6%
distribute-lft-in96.6%
cos-sum96.7%
*-commutative96.7%
*-commutative96.7%
*-commutative96.7%
*-commutative96.7%
Applied egg-rr99.5%
unpow299.5%
add-cube-cbrt99.9%
cancel-sign-sub-inv99.9%
fma-define99.9%
*-commutative99.9%
*-commutative99.9%
Applied egg-rr99.9%
Final simplification99.9%
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(*
R
(hypot
(*
(- lambda1 lambda2)
(-
(* (cos (* 0.5 phi1)) (cos (* phi2 0.5)))
(* (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((0.5 * phi1)) * cos((phi2 * 0.5))) - (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((0.5 * phi1)) * Math.cos((phi2 * 0.5))) - (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((0.5 * phi1)) * math.cos((phi2 * 0.5))) - (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(0.5 * phi1)) * cos(Float64(phi2 * 0.5))) - 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((0.5 * phi1)) * cos((phi2 * 0.5))) - (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[(0.5 * phi1), $MachinePrecision]], $MachinePrecision] * N[Cos[N[(phi2 * 0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - N[(N[Sin[N[(phi2 * 0.5), $MachinePrecision]], $MachinePrecision] * N[Sin[N[(0.5 * phi1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
R \cdot \mathsf{hypot}\left(\left(\lambda_1 - \lambda_2\right) \cdot \left(\cos \left(0.5 \cdot \phi_1\right) \cdot \cos \left(\phi_2 \cdot 0.5\right) - \sin \left(\phi_2 \cdot 0.5\right) \cdot \sin \left(0.5 \cdot \phi_1\right)\right), \phi_1 - \phi_2\right)
\end{array}
Initial program 56.0%
hypot-define96.9%
Simplified96.9%
add-cube-cbrt96.6%
pow296.6%
div-inv96.6%
metadata-eval96.6%
div-inv96.6%
metadata-eval96.6%
Applied egg-rr96.6%
*-commutative96.6%
+-commutative96.6%
distribute-lft-in96.6%
cos-sum96.7%
*-commutative96.7%
*-commutative96.7%
*-commutative96.7%
*-commutative96.7%
Applied egg-rr96.7%
*-commutative96.6%
+-commutative96.6%
distribute-lft-in96.6%
cos-sum96.7%
*-commutative96.7%
*-commutative96.7%
*-commutative96.7%
*-commutative96.7%
Applied egg-rr99.5%
unpow299.5%
add-cube-cbrt99.9%
*-commutative99.9%
*-commutative99.9%
Applied egg-rr99.9%
Final simplification99.9%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= phi2 5.1e+20) (* R (hypot phi1 (* (- lambda1 lambda2) (cos (* 0.5 phi1))))) (* R (hypot phi2 (* (cos (* phi2 0.5)) (- lambda2))))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 5.1e+20) {
tmp = R * hypot(phi1, ((lambda1 - lambda2) * cos((0.5 * phi1))));
} else {
tmp = R * hypot(phi2, (cos((phi2 * 0.5)) * -lambda2));
}
return tmp;
}
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 5.1e+20) {
tmp = R * Math.hypot(phi1, ((lambda1 - lambda2) * Math.cos((0.5 * phi1))));
} else {
tmp = R * Math.hypot(phi2, (Math.cos((phi2 * 0.5)) * -lambda2));
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi2 <= 5.1e+20: tmp = R * math.hypot(phi1, ((lambda1 - lambda2) * math.cos((0.5 * phi1)))) else: tmp = R * math.hypot(phi2, (math.cos((phi2 * 0.5)) * -lambda2)) return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi2 <= 5.1e+20) tmp = Float64(R * hypot(phi1, Float64(Float64(lambda1 - lambda2) * cos(Float64(0.5 * phi1))))); else tmp = Float64(R * hypot(phi2, Float64(cos(Float64(phi2 * 0.5)) * Float64(-lambda2)))); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (phi2 <= 5.1e+20) tmp = R * hypot(phi1, ((lambda1 - lambda2) * cos((0.5 * phi1)))); else tmp = R * hypot(phi2, (cos((phi2 * 0.5)) * -lambda2)); end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi2, 5.1e+20], N[(R * N[Sqrt[phi1 ^ 2 + N[(N[(lambda1 - lambda2), $MachinePrecision] * N[Cos[N[(0.5 * phi1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision], N[(R * N[Sqrt[phi2 ^ 2 + N[(N[Cos[N[(phi2 * 0.5), $MachinePrecision]], $MachinePrecision] * (-lambda2)), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_2 \leq 5.1 \cdot 10^{+20}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\phi_1, \left(\lambda_1 - \lambda_2\right) \cdot \cos \left(0.5 \cdot \phi_1\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\phi_2, \cos \left(\phi_2 \cdot 0.5\right) \cdot \left(-\lambda_2\right)\right)\\
\end{array}
\end{array}
if phi2 < 5.1e20Initial program 57.3%
hypot-define97.0%
Simplified97.0%
Taylor expanded in phi2 around 0 45.3%
+-commutative45.3%
unpow245.3%
unpow245.3%
unpow245.3%
unswap-sqr45.3%
hypot-define73.9%
Simplified73.9%
if 5.1e20 < phi2 Initial program 50.3%
hypot-define96.6%
Simplified96.6%
Taylor expanded in phi1 around 0 49.3%
+-commutative49.3%
unpow249.3%
unpow249.3%
unpow249.3%
unswap-sqr49.3%
hypot-define91.7%
Simplified91.7%
Taylor expanded in lambda1 around 0 74.3%
mul-1-neg74.3%
*-commutative74.3%
*-commutative74.3%
distribute-rgt-neg-out74.3%
*-commutative74.3%
Simplified74.3%
Final simplification74.0%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= phi1 -76000000000.0) (* R (hypot phi1 (* (- lambda1 lambda2) (cos (* 0.5 phi1))))) (* R (hypot phi2 (* (- lambda1 lambda2) (cos (* phi2 0.5)))))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi1 <= -76000000000.0) {
tmp = R * hypot(phi1, ((lambda1 - lambda2) * cos((0.5 * phi1))));
} else {
tmp = R * hypot(phi2, ((lambda1 - lambda2) * cos((phi2 * 0.5))));
}
return tmp;
}
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi1 <= -76000000000.0) {
tmp = R * Math.hypot(phi1, ((lambda1 - lambda2) * Math.cos((0.5 * phi1))));
} else {
tmp = R * Math.hypot(phi2, ((lambda1 - lambda2) * Math.cos((phi2 * 0.5))));
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi1 <= -76000000000.0: tmp = R * math.hypot(phi1, ((lambda1 - lambda2) * math.cos((0.5 * phi1)))) else: tmp = R * math.hypot(phi2, ((lambda1 - lambda2) * math.cos((phi2 * 0.5)))) return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi1 <= -76000000000.0) tmp = Float64(R * hypot(phi1, Float64(Float64(lambda1 - lambda2) * cos(Float64(0.5 * phi1))))); else tmp = Float64(R * hypot(phi2, Float64(Float64(lambda1 - lambda2) * cos(Float64(phi2 * 0.5))))); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (phi1 <= -76000000000.0) tmp = R * hypot(phi1, ((lambda1 - lambda2) * cos((0.5 * phi1)))); else tmp = R * hypot(phi2, ((lambda1 - lambda2) * cos((phi2 * 0.5)))); end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi1, -76000000000.0], N[(R * N[Sqrt[phi1 ^ 2 + N[(N[(lambda1 - lambda2), $MachinePrecision] * N[Cos[N[(0.5 * phi1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision], N[(R * N[Sqrt[phi2 ^ 2 + N[(N[(lambda1 - lambda2), $MachinePrecision] * N[Cos[N[(phi2 * 0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_1 \leq -76000000000:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\phi_1, \left(\lambda_1 - \lambda_2\right) \cdot \cos \left(0.5 \cdot \phi_1\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\phi_2, \left(\lambda_1 - \lambda_2\right) \cdot \cos \left(\phi_2 \cdot 0.5\right)\right)\\
\end{array}
\end{array}
if phi1 < -7.6e10Initial program 48.9%
hypot-define94.2%
Simplified94.2%
Taylor expanded in phi2 around 0 45.3%
+-commutative45.3%
unpow245.3%
unpow245.3%
unpow245.3%
unswap-sqr45.3%
hypot-define80.8%
Simplified80.8%
if -7.6e10 < phi1 Initial program 58.4%
hypot-define97.9%
Simplified97.9%
Taylor expanded in phi1 around 0 49.8%
+-commutative49.8%
unpow249.8%
unpow249.8%
unpow249.8%
unswap-sqr49.8%
hypot-define79.5%
Simplified79.5%
Final simplification79.9%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (* R (hypot (* (- lambda1 lambda2) (cos (/ (+ phi2 phi1) 2.0))) (- phi1 phi2))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * hypot(((lambda1 - lambda2) * cos(((phi2 + phi1) / 2.0))), (phi1 - phi2));
}
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * Math.hypot(((lambda1 - lambda2) * Math.cos(((phi2 + phi1) / 2.0))), (phi1 - phi2));
}
def code(R, lambda1, lambda2, phi1, phi2): return R * math.hypot(((lambda1 - lambda2) * math.cos(((phi2 + phi1) / 2.0))), (phi1 - phi2))
function code(R, lambda1, lambda2, phi1, phi2) return Float64(R * hypot(Float64(Float64(lambda1 - lambda2) * cos(Float64(Float64(phi2 + phi1) / 2.0))), Float64(phi1 - phi2))) end
function tmp = code(R, lambda1, lambda2, phi1, phi2) tmp = R * hypot(((lambda1 - lambda2) * cos(((phi2 + phi1) / 2.0))), (phi1 - phi2)); end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := N[(R * N[Sqrt[N[(N[(lambda1 - lambda2), $MachinePrecision] * N[Cos[N[(N[(phi2 + phi1), $MachinePrecision] / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] ^ 2 + N[(phi1 - phi2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
R \cdot \mathsf{hypot}\left(\left(\lambda_1 - \lambda_2\right) \cdot \cos \left(\frac{\phi_2 + \phi_1}{2}\right), \phi_1 - \phi_2\right)
\end{array}
Initial program 56.0%
hypot-define96.9%
Simplified96.9%
Final simplification96.9%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= phi1 -205000000000.0) (* phi1 (- (* R (/ phi2 phi1)) R)) (* R (hypot phi2 (- lambda1 lambda2)))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi1 <= -205000000000.0) {
tmp = phi1 * ((R * (phi2 / phi1)) - R);
} else {
tmp = R * hypot(phi2, (lambda1 - lambda2));
}
return tmp;
}
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi1 <= -205000000000.0) {
tmp = phi1 * ((R * (phi2 / phi1)) - R);
} else {
tmp = R * Math.hypot(phi2, (lambda1 - lambda2));
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi1 <= -205000000000.0: tmp = phi1 * ((R * (phi2 / phi1)) - R) else: tmp = R * math.hypot(phi2, (lambda1 - lambda2)) return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi1 <= -205000000000.0) tmp = Float64(phi1 * Float64(Float64(R * Float64(phi2 / phi1)) - R)); else tmp = Float64(R * hypot(phi2, Float64(lambda1 - lambda2))); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (phi1 <= -205000000000.0) tmp = phi1 * ((R * (phi2 / phi1)) - R); else tmp = R * hypot(phi2, (lambda1 - lambda2)); end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi1, -205000000000.0], N[(phi1 * N[(N[(R * N[(phi2 / phi1), $MachinePrecision]), $MachinePrecision] - R), $MachinePrecision]), $MachinePrecision], N[(R * N[Sqrt[phi2 ^ 2 + N[(lambda1 - lambda2), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_1 \leq -205000000000:\\
\;\;\;\;\phi_1 \cdot \left(R \cdot \frac{\phi_2}{\phi_1} - R\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \mathsf{hypot}\left(\phi_2, \lambda_1 - \lambda_2\right)\\
\end{array}
\end{array}
if phi1 < -2.05e11Initial program 48.9%
hypot-define94.2%
Simplified94.2%
Taylor expanded in phi1 around -inf 52.7%
associate-*r*52.7%
mul-1-neg52.7%
mul-1-neg52.7%
unsub-neg52.7%
associate-/l*55.6%
Simplified55.6%
if -2.05e11 < phi1 Initial program 58.4%
hypot-define97.9%
Simplified97.9%
Taylor expanded in phi1 around 0 49.8%
+-commutative49.8%
unpow249.8%
unpow249.8%
unpow249.8%
unswap-sqr49.8%
hypot-define79.5%
Simplified79.5%
Taylor expanded in phi2 around 0 70.0%
Final simplification66.2%
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(if (<= phi1 -160000000000.0)
(* phi1 (- R))
(if (or (<= phi1 -3.05e-143)
(and (not (<= phi1 -1.05e-177)) (<= phi1 4.4e-211)))
(* lambda2 (- R (* R (/ lambda1 lambda2))))
(* R phi2))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi1 <= -160000000000.0) {
tmp = phi1 * -R;
} else if ((phi1 <= -3.05e-143) || (!(phi1 <= -1.05e-177) && (phi1 <= 4.4e-211))) {
tmp = lambda2 * (R - (R * (lambda1 / 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 (phi1 <= (-160000000000.0d0)) then
tmp = phi1 * -r
else if ((phi1 <= (-3.05d-143)) .or. (.not. (phi1 <= (-1.05d-177))) .and. (phi1 <= 4.4d-211)) then
tmp = lambda2 * (r - (r * (lambda1 / 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 (phi1 <= -160000000000.0) {
tmp = phi1 * -R;
} else if ((phi1 <= -3.05e-143) || (!(phi1 <= -1.05e-177) && (phi1 <= 4.4e-211))) {
tmp = lambda2 * (R - (R * (lambda1 / lambda2)));
} else {
tmp = R * phi2;
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi1 <= -160000000000.0: tmp = phi1 * -R elif (phi1 <= -3.05e-143) or (not (phi1 <= -1.05e-177) and (phi1 <= 4.4e-211)): tmp = lambda2 * (R - (R * (lambda1 / lambda2))) else: tmp = R * phi2 return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi1 <= -160000000000.0) tmp = Float64(phi1 * Float64(-R)); elseif ((phi1 <= -3.05e-143) || (!(phi1 <= -1.05e-177) && (phi1 <= 4.4e-211))) tmp = Float64(lambda2 * Float64(R - Float64(R * Float64(lambda1 / lambda2)))); else tmp = Float64(R * phi2); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (phi1 <= -160000000000.0) tmp = phi1 * -R; elseif ((phi1 <= -3.05e-143) || (~((phi1 <= -1.05e-177)) && (phi1 <= 4.4e-211))) tmp = lambda2 * (R - (R * (lambda1 / lambda2))); else tmp = R * phi2; end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi1, -160000000000.0], N[(phi1 * (-R)), $MachinePrecision], If[Or[LessEqual[phi1, -3.05e-143], And[N[Not[LessEqual[phi1, -1.05e-177]], $MachinePrecision], LessEqual[phi1, 4.4e-211]]], N[(lambda2 * N[(R - N[(R * N[(lambda1 / lambda2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(R * phi2), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_1 \leq -160000000000:\\
\;\;\;\;\phi_1 \cdot \left(-R\right)\\
\mathbf{elif}\;\phi_1 \leq -3.05 \cdot 10^{-143} \lor \neg \left(\phi_1 \leq -1.05 \cdot 10^{-177}\right) \land \phi_1 \leq 4.4 \cdot 10^{-211}:\\
\;\;\;\;\lambda_2 \cdot \left(R - R \cdot \frac{\lambda_1}{\lambda_2}\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \phi_2\\
\end{array}
\end{array}
if phi1 < -1.6e11Initial program 48.9%
hypot-define94.2%
Simplified94.2%
Taylor expanded in phi1 around -inf 55.8%
mul-1-neg55.8%
*-commutative55.8%
distribute-rgt-neg-in55.8%
Simplified55.8%
if -1.6e11 < phi1 < -3.04999999999999996e-143 or -1.05e-177 < phi1 < 4.39999999999999996e-211Initial program 58.4%
hypot-define98.5%
Simplified98.5%
Taylor expanded in phi1 around 0 55.4%
+-commutative55.4%
unpow255.4%
unpow255.4%
unpow255.4%
unswap-sqr55.4%
hypot-define95.5%
Simplified95.5%
Taylor expanded in lambda2 around inf 31.4%
+-commutative31.4%
mul-1-neg31.4%
unsub-neg31.4%
*-commutative31.4%
associate-/l*27.8%
*-commutative27.8%
Simplified27.8%
Taylor expanded in phi2 around 0 27.0%
associate-/l*23.4%
Simplified23.4%
if -3.04999999999999996e-143 < phi1 < -1.05e-177 or 4.39999999999999996e-211 < phi1 Initial program 58.5%
hypot-define97.5%
Simplified97.5%
Taylor expanded in phi2 around inf 18.2%
*-commutative18.2%
Simplified18.2%
Final simplification29.7%
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(if (<= phi1 -210000000000.0)
(* phi1 (- R))
(if (or (<= phi1 -3e-143) (and (not (<= phi1 -1.75e-177)) (<= phi1 5e-211)))
(* lambda2 (- R (/ (* R lambda1) lambda2)))
(* R phi2))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi1 <= -210000000000.0) {
tmp = phi1 * -R;
} else if ((phi1 <= -3e-143) || (!(phi1 <= -1.75e-177) && (phi1 <= 5e-211))) {
tmp = lambda2 * (R - ((R * lambda1) / 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 (phi1 <= (-210000000000.0d0)) then
tmp = phi1 * -r
else if ((phi1 <= (-3d-143)) .or. (.not. (phi1 <= (-1.75d-177))) .and. (phi1 <= 5d-211)) then
tmp = lambda2 * (r - ((r * lambda1) / 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 (phi1 <= -210000000000.0) {
tmp = phi1 * -R;
} else if ((phi1 <= -3e-143) || (!(phi1 <= -1.75e-177) && (phi1 <= 5e-211))) {
tmp = lambda2 * (R - ((R * lambda1) / lambda2));
} else {
tmp = R * phi2;
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi1 <= -210000000000.0: tmp = phi1 * -R elif (phi1 <= -3e-143) or (not (phi1 <= -1.75e-177) and (phi1 <= 5e-211)): tmp = lambda2 * (R - ((R * lambda1) / lambda2)) else: tmp = R * phi2 return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi1 <= -210000000000.0) tmp = Float64(phi1 * Float64(-R)); elseif ((phi1 <= -3e-143) || (!(phi1 <= -1.75e-177) && (phi1 <= 5e-211))) tmp = Float64(lambda2 * Float64(R - Float64(Float64(R * lambda1) / lambda2))); else tmp = Float64(R * phi2); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (phi1 <= -210000000000.0) tmp = phi1 * -R; elseif ((phi1 <= -3e-143) || (~((phi1 <= -1.75e-177)) && (phi1 <= 5e-211))) tmp = lambda2 * (R - ((R * lambda1) / lambda2)); else tmp = R * phi2; end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi1, -210000000000.0], N[(phi1 * (-R)), $MachinePrecision], If[Or[LessEqual[phi1, -3e-143], And[N[Not[LessEqual[phi1, -1.75e-177]], $MachinePrecision], LessEqual[phi1, 5e-211]]], N[(lambda2 * N[(R - N[(N[(R * lambda1), $MachinePrecision] / lambda2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(R * phi2), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_1 \leq -210000000000:\\
\;\;\;\;\phi_1 \cdot \left(-R\right)\\
\mathbf{elif}\;\phi_1 \leq -3 \cdot 10^{-143} \lor \neg \left(\phi_1 \leq -1.75 \cdot 10^{-177}\right) \land \phi_1 \leq 5 \cdot 10^{-211}:\\
\;\;\;\;\lambda_2 \cdot \left(R - \frac{R \cdot \lambda_1}{\lambda_2}\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \phi_2\\
\end{array}
\end{array}
if phi1 < -2.1e11Initial program 48.9%
hypot-define94.2%
Simplified94.2%
Taylor expanded in phi1 around -inf 55.8%
mul-1-neg55.8%
*-commutative55.8%
distribute-rgt-neg-in55.8%
Simplified55.8%
if -2.1e11 < phi1 < -2.99999999999999985e-143 or -1.7500000000000001e-177 < phi1 < 5.0000000000000002e-211Initial program 58.4%
hypot-define98.5%
Simplified98.5%
Taylor expanded in phi1 around 0 55.4%
+-commutative55.4%
unpow255.4%
unpow255.4%
unpow255.4%
unswap-sqr55.4%
hypot-define95.5%
Simplified95.5%
Taylor expanded in lambda2 around inf 31.4%
+-commutative31.4%
mul-1-neg31.4%
unsub-neg31.4%
*-commutative31.4%
associate-/l*27.8%
*-commutative27.8%
Simplified27.8%
Taylor expanded in phi2 around 0 27.0%
if -2.99999999999999985e-143 < phi1 < -1.7500000000000001e-177 or 5.0000000000000002e-211 < phi1 Initial program 58.5%
hypot-define97.5%
Simplified97.5%
Taylor expanded in phi2 around inf 18.2%
*-commutative18.2%
Simplified18.2%
Final simplification30.9%
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* lambda2 (- R (/ (* R lambda1) lambda2)))))
(if (<= phi1 -6.2e-25)
(* phi1 (- (* R (/ phi2 phi1)) R))
(if (<= phi1 -6.5e-143)
t_0
(if (<= phi1 -1.8e-177)
(* phi2 (- R (* R (/ phi1 phi2))))
(if (<= phi1 6e-211) t_0 (* R phi2)))))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = lambda2 * (R - ((R * lambda1) / lambda2));
double tmp;
if (phi1 <= -6.2e-25) {
tmp = phi1 * ((R * (phi2 / phi1)) - R);
} else if (phi1 <= -6.5e-143) {
tmp = t_0;
} else if (phi1 <= -1.8e-177) {
tmp = phi2 * (R - (R * (phi1 / phi2)));
} else if (phi1 <= 6e-211) {
tmp = t_0;
} 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) :: t_0
real(8) :: tmp
t_0 = lambda2 * (r - ((r * lambda1) / lambda2))
if (phi1 <= (-6.2d-25)) then
tmp = phi1 * ((r * (phi2 / phi1)) - r)
else if (phi1 <= (-6.5d-143)) then
tmp = t_0
else if (phi1 <= (-1.8d-177)) then
tmp = phi2 * (r - (r * (phi1 / phi2)))
else if (phi1 <= 6d-211) then
tmp = t_0
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 t_0 = lambda2 * (R - ((R * lambda1) / lambda2));
double tmp;
if (phi1 <= -6.2e-25) {
tmp = phi1 * ((R * (phi2 / phi1)) - R);
} else if (phi1 <= -6.5e-143) {
tmp = t_0;
} else if (phi1 <= -1.8e-177) {
tmp = phi2 * (R - (R * (phi1 / phi2)));
} else if (phi1 <= 6e-211) {
tmp = t_0;
} else {
tmp = R * phi2;
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): t_0 = lambda2 * (R - ((R * lambda1) / lambda2)) tmp = 0 if phi1 <= -6.2e-25: tmp = phi1 * ((R * (phi2 / phi1)) - R) elif phi1 <= -6.5e-143: tmp = t_0 elif phi1 <= -1.8e-177: tmp = phi2 * (R - (R * (phi1 / phi2))) elif phi1 <= 6e-211: tmp = t_0 else: tmp = R * phi2 return tmp
function code(R, lambda1, lambda2, phi1, phi2) t_0 = Float64(lambda2 * Float64(R - Float64(Float64(R * lambda1) / lambda2))) tmp = 0.0 if (phi1 <= -6.2e-25) tmp = Float64(phi1 * Float64(Float64(R * Float64(phi2 / phi1)) - R)); elseif (phi1 <= -6.5e-143) tmp = t_0; elseif (phi1 <= -1.8e-177) tmp = Float64(phi2 * Float64(R - Float64(R * Float64(phi1 / phi2)))); elseif (phi1 <= 6e-211) tmp = t_0; else tmp = Float64(R * phi2); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) t_0 = lambda2 * (R - ((R * lambda1) / lambda2)); tmp = 0.0; if (phi1 <= -6.2e-25) tmp = phi1 * ((R * (phi2 / phi1)) - R); elseif (phi1 <= -6.5e-143) tmp = t_0; elseif (phi1 <= -1.8e-177) tmp = phi2 * (R - (R * (phi1 / phi2))); elseif (phi1 <= 6e-211) tmp = t_0; else tmp = R * phi2; end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(lambda2 * N[(R - N[(N[(R * lambda1), $MachinePrecision] / lambda2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[phi1, -6.2e-25], N[(phi1 * N[(N[(R * N[(phi2 / phi1), $MachinePrecision]), $MachinePrecision] - R), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, -6.5e-143], t$95$0, If[LessEqual[phi1, -1.8e-177], N[(phi2 * N[(R - N[(R * N[(phi1 / phi2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, 6e-211], t$95$0, N[(R * phi2), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \lambda_2 \cdot \left(R - \frac{R \cdot \lambda_1}{\lambda_2}\right)\\
\mathbf{if}\;\phi_1 \leq -6.2 \cdot 10^{-25}:\\
\;\;\;\;\phi_1 \cdot \left(R \cdot \frac{\phi_2}{\phi_1} - R\right)\\
\mathbf{elif}\;\phi_1 \leq -6.5 \cdot 10^{-143}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;\phi_1 \leq -1.8 \cdot 10^{-177}:\\
\;\;\;\;\phi_2 \cdot \left(R - R \cdot \frac{\phi_1}{\phi_2}\right)\\
\mathbf{elif}\;\phi_1 \leq 6 \cdot 10^{-211}:\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;R \cdot \phi_2\\
\end{array}
\end{array}
if phi1 < -6.19999999999999989e-25Initial program 53.2%
hypot-define93.5%
Simplified93.5%
Taylor expanded in phi1 around -inf 49.5%
associate-*r*49.5%
mul-1-neg49.5%
mul-1-neg49.5%
unsub-neg49.5%
associate-/l*52.1%
Simplified52.1%
if -6.19999999999999989e-25 < phi1 < -6.4999999999999999e-143 or -1.79999999999999991e-177 < phi1 < 6.00000000000000009e-211Initial program 55.1%
hypot-define99.9%
Simplified99.9%
Taylor expanded in phi1 around 0 55.1%
+-commutative55.1%
unpow255.1%
unpow255.1%
unpow255.1%
unswap-sqr55.1%
hypot-define99.9%
Simplified99.9%
Taylor expanded in lambda2 around inf 34.3%
+-commutative34.3%
mul-1-neg34.3%
unsub-neg34.3%
*-commutative34.3%
associate-/l*30.1%
*-commutative30.1%
Simplified30.1%
Taylor expanded in phi2 around 0 29.0%
if -6.4999999999999999e-143 < phi1 < -1.79999999999999991e-177Initial program 72.4%
hypot-define100.0%
Simplified100.0%
expm1-log1p-u56.2%
expm1-undefine33.2%
*-commutative33.2%
div-inv33.2%
metadata-eval33.2%
Applied egg-rr33.2%
Simplified56.2%
Taylor expanded in phi2 around inf 30.5%
mul-1-neg30.5%
unsub-neg30.5%
associate-/l*30.5%
Simplified30.5%
if 6.00000000000000009e-211 < phi1 Initial program 57.5%
hypot-define97.3%
Simplified97.3%
Taylor expanded in phi2 around inf 18.1%
*-commutative18.1%
Simplified18.1%
Final simplification31.8%
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(if (<= lambda1 -1.1e+158)
(* lambda1 (- R))
(if (<= lambda1 1.85e-50)
(* phi2 (- R (* R (/ phi1 phi2))))
(* R lambda2))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (lambda1 <= -1.1e+158) {
tmp = lambda1 * -R;
} else if (lambda1 <= 1.85e-50) {
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 (lambda1 <= (-1.1d+158)) then
tmp = lambda1 * -r
else if (lambda1 <= 1.85d-50) 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 (lambda1 <= -1.1e+158) {
tmp = lambda1 * -R;
} else if (lambda1 <= 1.85e-50) {
tmp = phi2 * (R - (R * (phi1 / phi2)));
} else {
tmp = R * lambda2;
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if lambda1 <= -1.1e+158: tmp = lambda1 * -R elif lambda1 <= 1.85e-50: tmp = phi2 * (R - (R * (phi1 / phi2))) else: tmp = R * lambda2 return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (lambda1 <= -1.1e+158) tmp = Float64(lambda1 * Float64(-R)); elseif (lambda1 <= 1.85e-50) tmp = Float64(phi2 * Float64(R - Float64(R * Float64(phi1 / phi2)))); else tmp = Float64(R * lambda2); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (lambda1 <= -1.1e+158) tmp = lambda1 * -R; elseif (lambda1 <= 1.85e-50) tmp = phi2 * (R - (R * (phi1 / phi2))); else tmp = R * lambda2; end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[lambda1, -1.1e+158], N[(lambda1 * (-R)), $MachinePrecision], If[LessEqual[lambda1, 1.85e-50], N[(phi2 * N[(R - N[(R * N[(phi1 / phi2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(R * lambda2), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\lambda_1 \leq -1.1 \cdot 10^{+158}:\\
\;\;\;\;\lambda_1 \cdot \left(-R\right)\\
\mathbf{elif}\;\lambda_1 \leq 1.85 \cdot 10^{-50}:\\
\;\;\;\;\phi_2 \cdot \left(R - R \cdot \frac{\phi_1}{\phi_2}\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \lambda_2\\
\end{array}
\end{array}
if lambda1 < -1.1000000000000001e158Initial program 40.7%
hypot-define91.9%
Simplified91.9%
Taylor expanded in phi1 around 0 40.7%
+-commutative40.7%
unpow240.7%
unpow240.7%
unpow240.7%
unswap-sqr40.7%
hypot-define73.3%
Simplified73.3%
Taylor expanded in lambda2 around inf 45.3%
+-commutative45.3%
mul-1-neg45.3%
unsub-neg45.3%
*-commutative45.3%
associate-/l*35.1%
*-commutative35.1%
Simplified35.1%
Taylor expanded in lambda2 around 0 45.7%
*-commutative45.7%
*-commutative45.7%
neg-mul-145.7%
distribute-rgt-neg-in45.7%
*-commutative45.7%
distribute-rgt-neg-in45.7%
Simplified45.7%
Taylor expanded in phi2 around 0 57.5%
mul-1-neg57.5%
distribute-rgt-neg-in57.5%
Simplified57.5%
if -1.1000000000000001e158 < lambda1 < 1.85e-50Initial program 63.0%
hypot-define97.9%
Simplified97.9%
expm1-log1p-u66.1%
expm1-undefine43.5%
*-commutative43.5%
div-inv43.5%
metadata-eval43.5%
Applied egg-rr43.5%
Simplified66.1%
Taylor expanded in phi2 around inf 32.0%
mul-1-neg32.0%
unsub-neg32.0%
associate-/l*31.3%
Simplified31.3%
if 1.85e-50 < lambda1 Initial program 48.9%
hypot-define96.9%
Simplified96.9%
Taylor expanded in lambda2 around inf 14.9%
*-commutative14.9%
associate-*r*14.9%
*-commutative14.9%
associate-*l*14.9%
+-commutative14.9%
Simplified14.9%
Taylor expanded in phi1 around 0 13.0%
associate-*r*13.0%
Simplified13.0%
Taylor expanded in phi2 around 0 14.3%
Final simplification28.8%
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(if (<= lambda1 -1.9e+159)
(* R (- lambda1))
(if (<= lambda1 1.85e-50)
(* phi2 (- R (/ (* R phi1) phi2)))
(* R lambda2))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (lambda1 <= -1.9e+159) {
tmp = R * -lambda1;
} else if (lambda1 <= 1.85e-50) {
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 (lambda1 <= (-1.9d+159)) then
tmp = r * -lambda1
else if (lambda1 <= 1.85d-50) 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 (lambda1 <= -1.9e+159) {
tmp = R * -lambda1;
} else if (lambda1 <= 1.85e-50) {
tmp = phi2 * (R - ((R * phi1) / phi2));
} else {
tmp = R * lambda2;
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if lambda1 <= -1.9e+159: tmp = R * -lambda1 elif lambda1 <= 1.85e-50: tmp = phi2 * (R - ((R * phi1) / phi2)) else: tmp = R * lambda2 return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (lambda1 <= -1.9e+159) tmp = Float64(R * Float64(-lambda1)); elseif (lambda1 <= 1.85e-50) 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 (lambda1 <= -1.9e+159) tmp = R * -lambda1; elseif (lambda1 <= 1.85e-50) tmp = phi2 * (R - ((R * phi1) / phi2)); else tmp = R * lambda2; end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[lambda1, -1.9e+159], N[(R * (-lambda1)), $MachinePrecision], If[LessEqual[lambda1, 1.85e-50], 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_1 \leq -1.9 \cdot 10^{+159}:\\
\;\;\;\;R \cdot \left(-\lambda_1\right)\\
\mathbf{elif}\;\lambda_1 \leq 1.85 \cdot 10^{-50}:\\
\;\;\;\;\phi_2 \cdot \left(R - \frac{R \cdot \phi_1}{\phi_2}\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \lambda_2\\
\end{array}
\end{array}
if lambda1 < -1.89999999999999983e159Initial program 40.7%
hypot-define91.9%
Simplified91.9%
Taylor expanded in phi1 around 0 40.7%
+-commutative40.7%
unpow240.7%
unpow240.7%
unpow240.7%
unswap-sqr40.7%
hypot-define73.3%
Simplified73.3%
Taylor expanded in lambda2 around inf 45.3%
+-commutative45.3%
mul-1-neg45.3%
unsub-neg45.3%
*-commutative45.3%
associate-/l*35.1%
*-commutative35.1%
Simplified35.1%
Taylor expanded in lambda2 around 0 45.7%
*-commutative45.7%
*-commutative45.7%
neg-mul-145.7%
distribute-rgt-neg-in45.7%
*-commutative45.7%
distribute-rgt-neg-in45.7%
Simplified45.7%
Taylor expanded in phi2 around 0 57.5%
mul-1-neg57.5%
distribute-rgt-neg-in57.5%
Simplified57.5%
if -1.89999999999999983e159 < lambda1 < 1.85e-50Initial program 63.0%
hypot-define97.9%
Simplified97.9%
Taylor expanded in phi2 around inf 32.0%
associate-*r/32.0%
mul-1-neg32.0%
*-commutative32.0%
Simplified32.0%
if 1.85e-50 < lambda1 Initial program 48.9%
hypot-define96.9%
Simplified96.9%
Taylor expanded in lambda2 around inf 14.9%
*-commutative14.9%
associate-*r*14.9%
*-commutative14.9%
associate-*l*14.9%
+-commutative14.9%
Simplified14.9%
Taylor expanded in phi1 around 0 13.0%
associate-*r*13.0%
Simplified13.0%
Taylor expanded in phi2 around 0 14.3%
Final simplification29.2%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= lambda1 -4.8e+37) (* lambda1 (- R)) (if (<= lambda1 6.4e-135) (* R phi2) (* R lambda2))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (lambda1 <= -4.8e+37) {
tmp = lambda1 * -R;
} else if (lambda1 <= 6.4e-135) {
tmp = R * 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 (lambda1 <= (-4.8d+37)) then
tmp = lambda1 * -r
else if (lambda1 <= 6.4d-135) then
tmp = r * 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 (lambda1 <= -4.8e+37) {
tmp = lambda1 * -R;
} else if (lambda1 <= 6.4e-135) {
tmp = R * phi2;
} else {
tmp = R * lambda2;
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if lambda1 <= -4.8e+37: tmp = lambda1 * -R elif lambda1 <= 6.4e-135: tmp = R * phi2 else: tmp = R * lambda2 return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (lambda1 <= -4.8e+37) tmp = Float64(lambda1 * Float64(-R)); elseif (lambda1 <= 6.4e-135) tmp = Float64(R * phi2); else tmp = Float64(R * lambda2); end return tmp end
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0; if (lambda1 <= -4.8e+37) tmp = lambda1 * -R; elseif (lambda1 <= 6.4e-135) tmp = R * phi2; else tmp = R * lambda2; end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[lambda1, -4.8e+37], N[(lambda1 * (-R)), $MachinePrecision], If[LessEqual[lambda1, 6.4e-135], N[(R * phi2), $MachinePrecision], N[(R * lambda2), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\lambda_1 \leq -4.8 \cdot 10^{+37}:\\
\;\;\;\;\lambda_1 \cdot \left(-R\right)\\
\mathbf{elif}\;\lambda_1 \leq 6.4 \cdot 10^{-135}:\\
\;\;\;\;R \cdot \phi_2\\
\mathbf{else}:\\
\;\;\;\;R \cdot \lambda_2\\
\end{array}
\end{array}
if lambda1 < -4.8e37Initial program 49.6%
hypot-define92.8%
Simplified92.8%
Taylor expanded in phi1 around 0 43.9%
+-commutative43.9%
unpow243.9%
unpow243.9%
unpow243.9%
unswap-sqr43.9%
hypot-define67.1%
Simplified67.1%
Taylor expanded in lambda2 around inf 43.7%
+-commutative43.7%
mul-1-neg43.7%
unsub-neg43.7%
*-commutative43.7%
associate-/l*35.8%
*-commutative35.8%
Simplified35.8%
Taylor expanded in lambda2 around 0 42.4%
*-commutative42.4%
*-commutative42.4%
neg-mul-142.4%
distribute-rgt-neg-in42.4%
*-commutative42.4%
distribute-rgt-neg-in42.4%
Simplified42.4%
Taylor expanded in phi2 around 0 48.5%
mul-1-neg48.5%
distribute-rgt-neg-in48.5%
Simplified48.5%
if -4.8e37 < lambda1 < 6.40000000000000001e-135Initial program 63.7%
hypot-define98.5%
Simplified98.5%
Taylor expanded in phi2 around inf 21.9%
*-commutative21.9%
Simplified21.9%
if 6.40000000000000001e-135 < lambda1 Initial program 49.9%
hypot-define97.3%
Simplified97.3%
Taylor expanded in lambda2 around inf 13.5%
*-commutative13.5%
associate-*r*13.5%
*-commutative13.5%
associate-*l*13.5%
+-commutative13.5%
Simplified13.5%
Taylor expanded in phi1 around 0 12.9%
associate-*r*12.9%
Simplified12.9%
Taylor expanded in phi2 around 0 14.3%
Final simplification24.3%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= phi1 -6.8e-25) (* R (- phi1)) (if (<= phi1 -1.56e-139) (* R lambda2) (* R phi2))))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi1 <= -6.8e-25) {
tmp = R * -phi1;
} else if (phi1 <= -1.56e-139) {
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 (phi1 <= (-6.8d-25)) then
tmp = r * -phi1
else if (phi1 <= (-1.56d-139)) 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 (phi1 <= -6.8e-25) {
tmp = R * -phi1;
} else if (phi1 <= -1.56e-139) {
tmp = R * lambda2;
} else {
tmp = R * phi2;
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi1 <= -6.8e-25: tmp = R * -phi1 elif phi1 <= -1.56e-139: tmp = R * lambda2 else: tmp = R * phi2 return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi1 <= -6.8e-25) tmp = Float64(R * Float64(-phi1)); elseif (phi1 <= -1.56e-139) 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 (phi1 <= -6.8e-25) tmp = R * -phi1; elseif (phi1 <= -1.56e-139) tmp = R * lambda2; else tmp = R * phi2; end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi1, -6.8e-25], N[(R * (-phi1)), $MachinePrecision], If[LessEqual[phi1, -1.56e-139], N[(R * lambda2), $MachinePrecision], N[(R * phi2), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_1 \leq -6.8 \cdot 10^{-25}:\\
\;\;\;\;R \cdot \left(-\phi_1\right)\\
\mathbf{elif}\;\phi_1 \leq -1.56 \cdot 10^{-139}:\\
\;\;\;\;R \cdot \lambda_2\\
\mathbf{else}:\\
\;\;\;\;R \cdot \phi_2\\
\end{array}
\end{array}
if phi1 < -6.80000000000000003e-25Initial program 53.2%
hypot-define93.5%
Simplified93.5%
Taylor expanded in phi1 around -inf 51.2%
mul-1-neg51.2%
*-commutative51.2%
distribute-rgt-neg-in51.2%
Simplified51.2%
if -6.80000000000000003e-25 < phi1 < -1.56000000000000008e-139Initial program 39.0%
hypot-define99.8%
Simplified99.8%
Taylor expanded in lambda2 around inf 22.6%
*-commutative22.6%
associate-*r*22.6%
*-commutative22.6%
associate-*l*22.6%
+-commutative22.6%
Simplified22.6%
Taylor expanded in phi1 around 0 22.6%
associate-*r*22.6%
Simplified22.6%
Taylor expanded in phi2 around 0 20.3%
if -1.56000000000000008e-139 < phi1 Initial program 60.1%
hypot-define98.2%
Simplified98.2%
Taylor expanded in phi2 around inf 19.5%
*-commutative19.5%
Simplified19.5%
Final simplification29.2%
(FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= phi2 3100000000000.0) (* R lambda2) (* R phi2)))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 3100000000000.0) {
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 <= 3100000000000.0d0) 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 <= 3100000000000.0) {
tmp = R * lambda2;
} else {
tmp = R * phi2;
}
return tmp;
}
def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi2 <= 3100000000000.0: tmp = R * lambda2 else: tmp = R * phi2 return tmp
function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi2 <= 3100000000000.0) 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 <= 3100000000000.0) tmp = R * lambda2; else tmp = R * phi2; end tmp_2 = tmp; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi2, 3100000000000.0], N[(R * lambda2), $MachinePrecision], N[(R * phi2), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_2 \leq 3100000000000:\\
\;\;\;\;R \cdot \lambda_2\\
\mathbf{else}:\\
\;\;\;\;R \cdot \phi_2\\
\end{array}
\end{array}
if phi2 < 3.1e12Initial program 57.1%
hypot-define97.0%
Simplified97.0%
Taylor expanded in lambda2 around inf 14.1%
*-commutative14.1%
associate-*r*14.1%
*-commutative14.1%
associate-*l*14.1%
+-commutative14.1%
Simplified14.1%
Taylor expanded in phi1 around 0 11.2%
associate-*r*11.2%
Simplified11.2%
Taylor expanded in phi2 around 0 12.1%
if 3.1e12 < phi2 Initial program 51.3%
hypot-define96.7%
Simplified96.7%
Taylor expanded in phi2 around inf 55.4%
*-commutative55.4%
Simplified55.4%
Final simplification20.4%
(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 56.0%
hypot-define96.9%
Simplified96.9%
Taylor expanded in lambda2 around inf 14.8%
*-commutative14.8%
associate-*r*14.7%
*-commutative14.7%
associate-*l*14.7%
+-commutative14.7%
Simplified14.7%
Taylor expanded in phi1 around 0 12.0%
associate-*r*12.0%
Simplified12.0%
Taylor expanded in phi2 around 0 11.5%
Final simplification11.5%
herbie shell --seed 2024076
(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))))))