
(FPCore (c0 w h D d M) :precision binary64 (let* ((t_0 (/ (* c0 (* d d)) (* (* w h) (* D D))))) (* (/ c0 (* 2.0 w)) (+ t_0 (sqrt (- (* t_0 t_0) (* M M)))))))
double code(double c0, double w, double h, double D, double d, double M) {
double t_0 = (c0 * (d * d)) / ((w * h) * (D * D));
return (c0 / (2.0 * w)) * (t_0 + sqrt(((t_0 * t_0) - (M * M))));
}
real(8) function code(c0, w, h, d, d_1, m)
real(8), intent (in) :: c0
real(8), intent (in) :: w
real(8), intent (in) :: h
real(8), intent (in) :: d
real(8), intent (in) :: d_1
real(8), intent (in) :: m
real(8) :: t_0
t_0 = (c0 * (d_1 * d_1)) / ((w * h) * (d * d))
code = (c0 / (2.0d0 * w)) * (t_0 + sqrt(((t_0 * t_0) - (m * m))))
end function
public static double code(double c0, double w, double h, double D, double d, double M) {
double t_0 = (c0 * (d * d)) / ((w * h) * (D * D));
return (c0 / (2.0 * w)) * (t_0 + Math.sqrt(((t_0 * t_0) - (M * M))));
}
def code(c0, w, h, D, d, M): t_0 = (c0 * (d * d)) / ((w * h) * (D * D)) return (c0 / (2.0 * w)) * (t_0 + math.sqrt(((t_0 * t_0) - (M * M))))
function code(c0, w, h, D, d, M) t_0 = Float64(Float64(c0 * Float64(d * d)) / Float64(Float64(w * h) * Float64(D * D))) return Float64(Float64(c0 / Float64(2.0 * w)) * Float64(t_0 + sqrt(Float64(Float64(t_0 * t_0) - Float64(M * M))))) end
function tmp = code(c0, w, h, D, d, M) t_0 = (c0 * (d * d)) / ((w * h) * (D * D)); tmp = (c0 / (2.0 * w)) * (t_0 + sqrt(((t_0 * t_0) - (M * M)))); end
code[c0_, w_, h_, D_, d_, M_] := Block[{t$95$0 = N[(N[(c0 * N[(d * d), $MachinePrecision]), $MachinePrecision] / N[(N[(w * h), $MachinePrecision] * N[(D * D), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, N[(N[(c0 / N[(2.0 * w), $MachinePrecision]), $MachinePrecision] * N[(t$95$0 + N[Sqrt[N[(N[(t$95$0 * t$95$0), $MachinePrecision] - N[(M * M), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{c0 \cdot \left(d \cdot d\right)}{\left(w \cdot h\right) \cdot \left(D \cdot D\right)}\\
\frac{c0}{2 \cdot w} \cdot \left(t_0 + \sqrt{t_0 \cdot t_0 - M \cdot M}\right)
\end{array}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 7 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (c0 w h D d M) :precision binary64 (let* ((t_0 (/ (* c0 (* d d)) (* (* w h) (* D D))))) (* (/ c0 (* 2.0 w)) (+ t_0 (sqrt (- (* t_0 t_0) (* M M)))))))
double code(double c0, double w, double h, double D, double d, double M) {
double t_0 = (c0 * (d * d)) / ((w * h) * (D * D));
return (c0 / (2.0 * w)) * (t_0 + sqrt(((t_0 * t_0) - (M * M))));
}
real(8) function code(c0, w, h, d, d_1, m)
real(8), intent (in) :: c0
real(8), intent (in) :: w
real(8), intent (in) :: h
real(8), intent (in) :: d
real(8), intent (in) :: d_1
real(8), intent (in) :: m
real(8) :: t_0
t_0 = (c0 * (d_1 * d_1)) / ((w * h) * (d * d))
code = (c0 / (2.0d0 * w)) * (t_0 + sqrt(((t_0 * t_0) - (m * m))))
end function
public static double code(double c0, double w, double h, double D, double d, double M) {
double t_0 = (c0 * (d * d)) / ((w * h) * (D * D));
return (c0 / (2.0 * w)) * (t_0 + Math.sqrt(((t_0 * t_0) - (M * M))));
}
def code(c0, w, h, D, d, M): t_0 = (c0 * (d * d)) / ((w * h) * (D * D)) return (c0 / (2.0 * w)) * (t_0 + math.sqrt(((t_0 * t_0) - (M * M))))
function code(c0, w, h, D, d, M) t_0 = Float64(Float64(c0 * Float64(d * d)) / Float64(Float64(w * h) * Float64(D * D))) return Float64(Float64(c0 / Float64(2.0 * w)) * Float64(t_0 + sqrt(Float64(Float64(t_0 * t_0) - Float64(M * M))))) end
function tmp = code(c0, w, h, D, d, M) t_0 = (c0 * (d * d)) / ((w * h) * (D * D)); tmp = (c0 / (2.0 * w)) * (t_0 + sqrt(((t_0 * t_0) - (M * M)))); end
code[c0_, w_, h_, D_, d_, M_] := Block[{t$95$0 = N[(N[(c0 * N[(d * d), $MachinePrecision]), $MachinePrecision] / N[(N[(w * h), $MachinePrecision] * N[(D * D), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, N[(N[(c0 / N[(2.0 * w), $MachinePrecision]), $MachinePrecision] * N[(t$95$0 + N[Sqrt[N[(N[(t$95$0 * t$95$0), $MachinePrecision] - N[(M * M), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{c0 \cdot \left(d \cdot d\right)}{\left(w \cdot h\right) \cdot \left(D \cdot D\right)}\\
\frac{c0}{2 \cdot w} \cdot \left(t_0 + \sqrt{t_0 \cdot t_0 - M \cdot M}\right)
\end{array}
\end{array}
(FPCore (c0 w h D d M)
:precision binary64
(let* ((t_0 (* (/ c0 (* w h)) (pow (/ d D) 2.0)))
(t_1 (/ (* c0 (* d d)) (* (* w h) (* D D)))))
(if (<=
(* (/ c0 (* 2.0 w)) (+ t_1 (sqrt (- (* t_1 t_1) (* M M)))))
INFINITY)
(* (/ (/ c0 w) 2.0) (+ t_0 (sqrt (- (pow t_0 2.0) (pow M 2.0)))))
0.0)))
double code(double c0, double w, double h, double D, double d, double M) {
double t_0 = (c0 / (w * h)) * pow((d / D), 2.0);
double t_1 = (c0 * (d * d)) / ((w * h) * (D * D));
double tmp;
if (((c0 / (2.0 * w)) * (t_1 + sqrt(((t_1 * t_1) - (M * M))))) <= ((double) INFINITY)) {
tmp = ((c0 / w) / 2.0) * (t_0 + sqrt((pow(t_0, 2.0) - pow(M, 2.0))));
} else {
tmp = 0.0;
}
return tmp;
}
public static double code(double c0, double w, double h, double D, double d, double M) {
double t_0 = (c0 / (w * h)) * Math.pow((d / D), 2.0);
double t_1 = (c0 * (d * d)) / ((w * h) * (D * D));
double tmp;
if (((c0 / (2.0 * w)) * (t_1 + Math.sqrt(((t_1 * t_1) - (M * M))))) <= Double.POSITIVE_INFINITY) {
tmp = ((c0 / w) / 2.0) * (t_0 + Math.sqrt((Math.pow(t_0, 2.0) - Math.pow(M, 2.0))));
} else {
tmp = 0.0;
}
return tmp;
}
def code(c0, w, h, D, d, M): t_0 = (c0 / (w * h)) * math.pow((d / D), 2.0) t_1 = (c0 * (d * d)) / ((w * h) * (D * D)) tmp = 0 if ((c0 / (2.0 * w)) * (t_1 + math.sqrt(((t_1 * t_1) - (M * M))))) <= math.inf: tmp = ((c0 / w) / 2.0) * (t_0 + math.sqrt((math.pow(t_0, 2.0) - math.pow(M, 2.0)))) else: tmp = 0.0 return tmp
function code(c0, w, h, D, d, M) t_0 = Float64(Float64(c0 / Float64(w * h)) * (Float64(d / D) ^ 2.0)) t_1 = Float64(Float64(c0 * Float64(d * d)) / Float64(Float64(w * h) * Float64(D * D))) tmp = 0.0 if (Float64(Float64(c0 / Float64(2.0 * w)) * Float64(t_1 + sqrt(Float64(Float64(t_1 * t_1) - Float64(M * M))))) <= Inf) tmp = Float64(Float64(Float64(c0 / w) / 2.0) * Float64(t_0 + sqrt(Float64((t_0 ^ 2.0) - (M ^ 2.0))))); else tmp = 0.0; end return tmp end
function tmp_2 = code(c0, w, h, D, d, M) t_0 = (c0 / (w * h)) * ((d / D) ^ 2.0); t_1 = (c0 * (d * d)) / ((w * h) * (D * D)); tmp = 0.0; if (((c0 / (2.0 * w)) * (t_1 + sqrt(((t_1 * t_1) - (M * M))))) <= Inf) tmp = ((c0 / w) / 2.0) * (t_0 + sqrt(((t_0 ^ 2.0) - (M ^ 2.0)))); else tmp = 0.0; end tmp_2 = tmp; end
code[c0_, w_, h_, D_, d_, M_] := Block[{t$95$0 = N[(N[(c0 / N[(w * h), $MachinePrecision]), $MachinePrecision] * N[Power[N[(d / D), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(c0 * N[(d * d), $MachinePrecision]), $MachinePrecision] / N[(N[(w * h), $MachinePrecision] * N[(D * D), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(N[(c0 / N[(2.0 * w), $MachinePrecision]), $MachinePrecision] * N[(t$95$1 + N[Sqrt[N[(N[(t$95$1 * t$95$1), $MachinePrecision] - N[(M * M), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], Infinity], N[(N[(N[(c0 / w), $MachinePrecision] / 2.0), $MachinePrecision] * N[(t$95$0 + N[Sqrt[N[(N[Power[t$95$0, 2.0], $MachinePrecision] - N[Power[M, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{c0}{w \cdot h} \cdot {\left(\frac{d}{D}\right)}^{2}\\
t_1 := \frac{c0 \cdot \left(d \cdot d\right)}{\left(w \cdot h\right) \cdot \left(D \cdot D\right)}\\
\mathbf{if}\;\frac{c0}{2 \cdot w} \cdot \left(t_1 + \sqrt{t_1 \cdot t_1 - M \cdot M}\right) \leq \infty:\\
\;\;\;\;\frac{\frac{c0}{w}}{2} \cdot \left(t_0 + \sqrt{{t_0}^{2} - {M}^{2}}\right)\\
\mathbf{else}:\\
\;\;\;\;0\\
\end{array}
\end{array}
if (*.f64 (/.f64 c0 (*.f64 2 w)) (+.f64 (/.f64 (*.f64 c0 (*.f64 d d)) (*.f64 (*.f64 w h) (*.f64 D D))) (sqrt.f64 (-.f64 (*.f64 (/.f64 (*.f64 c0 (*.f64 d d)) (*.f64 (*.f64 w h) (*.f64 D D))) (/.f64 (*.f64 c0 (*.f64 d d)) (*.f64 (*.f64 w h) (*.f64 D D)))) (*.f64 M M))))) < +inf.0Initial program 77.3%
Simplified75.3%
fma-udef77.7%
associate-/r*77.7%
pow277.7%
fma-udef77.7%
associate-/r*77.7%
frac-times74.2%
Applied egg-rr77.7%
if +inf.0 < (*.f64 (/.f64 c0 (*.f64 2 w)) (+.f64 (/.f64 (*.f64 c0 (*.f64 d d)) (*.f64 (*.f64 w h) (*.f64 D D))) (sqrt.f64 (-.f64 (*.f64 (/.f64 (*.f64 c0 (*.f64 d d)) (*.f64 (*.f64 w h) (*.f64 D D))) (/.f64 (*.f64 c0 (*.f64 d d)) (*.f64 (*.f64 w h) (*.f64 D D)))) (*.f64 M M))))) Initial program 0.0%
+-commutative0.0%
+-commutative0.0%
times-frac0.0%
fma-neg0.0%
Simplified1.8%
Taylor expanded in c0 around -inf 2.3%
mul-1-neg2.3%
distribute-lft-in0.6%
Simplified43.4%
Taylor expanded in c0 around 0 49.2%
Final simplification57.9%
(FPCore (c0 w h D d M)
:precision binary64
(let* ((t_0 (/ (* c0 (* d d)) (* (* w h) (* D D))))
(t_1 (* (/ c0 (* 2.0 w)) (+ t_0 (sqrt (- (* t_0 t_0) (* M M)))))))
(if (<= t_1 INFINITY) t_1 0.0)))
double code(double c0, double w, double h, double D, double d, double M) {
double t_0 = (c0 * (d * d)) / ((w * h) * (D * D));
double t_1 = (c0 / (2.0 * w)) * (t_0 + sqrt(((t_0 * t_0) - (M * M))));
double tmp;
if (t_1 <= ((double) INFINITY)) {
tmp = t_1;
} else {
tmp = 0.0;
}
return tmp;
}
public static double code(double c0, double w, double h, double D, double d, double M) {
double t_0 = (c0 * (d * d)) / ((w * h) * (D * D));
double t_1 = (c0 / (2.0 * w)) * (t_0 + Math.sqrt(((t_0 * t_0) - (M * M))));
double tmp;
if (t_1 <= Double.POSITIVE_INFINITY) {
tmp = t_1;
} else {
tmp = 0.0;
}
return tmp;
}
def code(c0, w, h, D, d, M): t_0 = (c0 * (d * d)) / ((w * h) * (D * D)) t_1 = (c0 / (2.0 * w)) * (t_0 + math.sqrt(((t_0 * t_0) - (M * M)))) tmp = 0 if t_1 <= math.inf: tmp = t_1 else: tmp = 0.0 return tmp
function code(c0, w, h, D, d, M) t_0 = Float64(Float64(c0 * Float64(d * d)) / Float64(Float64(w * h) * Float64(D * D))) t_1 = Float64(Float64(c0 / Float64(2.0 * w)) * Float64(t_0 + sqrt(Float64(Float64(t_0 * t_0) - Float64(M * M))))) tmp = 0.0 if (t_1 <= Inf) tmp = t_1; else tmp = 0.0; end return tmp end
function tmp_2 = code(c0, w, h, D, d, M) t_0 = (c0 * (d * d)) / ((w * h) * (D * D)); t_1 = (c0 / (2.0 * w)) * (t_0 + sqrt(((t_0 * t_0) - (M * M)))); tmp = 0.0; if (t_1 <= Inf) tmp = t_1; else tmp = 0.0; end tmp_2 = tmp; end
code[c0_, w_, h_, D_, d_, M_] := Block[{t$95$0 = N[(N[(c0 * N[(d * d), $MachinePrecision]), $MachinePrecision] / N[(N[(w * h), $MachinePrecision] * N[(D * D), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(c0 / N[(2.0 * w), $MachinePrecision]), $MachinePrecision] * N[(t$95$0 + N[Sqrt[N[(N[(t$95$0 * t$95$0), $MachinePrecision] - N[(M * M), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, Infinity], t$95$1, 0.0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{c0 \cdot \left(d \cdot d\right)}{\left(w \cdot h\right) \cdot \left(D \cdot D\right)}\\
t_1 := \frac{c0}{2 \cdot w} \cdot \left(t_0 + \sqrt{t_0 \cdot t_0 - M \cdot M}\right)\\
\mathbf{if}\;t_1 \leq \infty:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;0\\
\end{array}
\end{array}
if (*.f64 (/.f64 c0 (*.f64 2 w)) (+.f64 (/.f64 (*.f64 c0 (*.f64 d d)) (*.f64 (*.f64 w h) (*.f64 D D))) (sqrt.f64 (-.f64 (*.f64 (/.f64 (*.f64 c0 (*.f64 d d)) (*.f64 (*.f64 w h) (*.f64 D D))) (/.f64 (*.f64 c0 (*.f64 d d)) (*.f64 (*.f64 w h) (*.f64 D D)))) (*.f64 M M))))) < +inf.0Initial program 77.3%
if +inf.0 < (*.f64 (/.f64 c0 (*.f64 2 w)) (+.f64 (/.f64 (*.f64 c0 (*.f64 d d)) (*.f64 (*.f64 w h) (*.f64 D D))) (sqrt.f64 (-.f64 (*.f64 (/.f64 (*.f64 c0 (*.f64 d d)) (*.f64 (*.f64 w h) (*.f64 D D))) (/.f64 (*.f64 c0 (*.f64 d d)) (*.f64 (*.f64 w h) (*.f64 D D)))) (*.f64 M M))))) Initial program 0.0%
+-commutative0.0%
+-commutative0.0%
times-frac0.0%
fma-neg0.0%
Simplified1.8%
Taylor expanded in c0 around -inf 2.3%
mul-1-neg2.3%
distribute-lft-in0.6%
Simplified43.4%
Taylor expanded in c0 around 0 49.2%
Final simplification57.7%
(FPCore (c0 w h D d M)
:precision binary64
(let* ((t_0 (pow (/ d D) 2.0)))
(if (<= (* M M) 4e-232)
0.0
(if (<= (* M M) 1e-197)
(/ (* c0 (+ M (* (/ c0 (* w h)) t_0))) (* 2.0 w))
(if (<= (* M M) 5e-107)
0.0
(if (or (<= (* M M) 2e+55) (not (<= (* M M) 5e+190)))
(* (/ (/ c0 w) 2.0) (* t_0 (* 2.0 (/ (/ c0 h) w))))
0.0))))))
double code(double c0, double w, double h, double D, double d, double M) {
double t_0 = pow((d / D), 2.0);
double tmp;
if ((M * M) <= 4e-232) {
tmp = 0.0;
} else if ((M * M) <= 1e-197) {
tmp = (c0 * (M + ((c0 / (w * h)) * t_0))) / (2.0 * w);
} else if ((M * M) <= 5e-107) {
tmp = 0.0;
} else if (((M * M) <= 2e+55) || !((M * M) <= 5e+190)) {
tmp = ((c0 / w) / 2.0) * (t_0 * (2.0 * ((c0 / h) / w)));
} else {
tmp = 0.0;
}
return tmp;
}
real(8) function code(c0, w, h, d, d_1, m)
real(8), intent (in) :: c0
real(8), intent (in) :: w
real(8), intent (in) :: h
real(8), intent (in) :: d
real(8), intent (in) :: d_1
real(8), intent (in) :: m
real(8) :: t_0
real(8) :: tmp
t_0 = (d_1 / d) ** 2.0d0
if ((m * m) <= 4d-232) then
tmp = 0.0d0
else if ((m * m) <= 1d-197) then
tmp = (c0 * (m + ((c0 / (w * h)) * t_0))) / (2.0d0 * w)
else if ((m * m) <= 5d-107) then
tmp = 0.0d0
else if (((m * m) <= 2d+55) .or. (.not. ((m * m) <= 5d+190))) then
tmp = ((c0 / w) / 2.0d0) * (t_0 * (2.0d0 * ((c0 / h) / w)))
else
tmp = 0.0d0
end if
code = tmp
end function
public static double code(double c0, double w, double h, double D, double d, double M) {
double t_0 = Math.pow((d / D), 2.0);
double tmp;
if ((M * M) <= 4e-232) {
tmp = 0.0;
} else if ((M * M) <= 1e-197) {
tmp = (c0 * (M + ((c0 / (w * h)) * t_0))) / (2.0 * w);
} else if ((M * M) <= 5e-107) {
tmp = 0.0;
} else if (((M * M) <= 2e+55) || !((M * M) <= 5e+190)) {
tmp = ((c0 / w) / 2.0) * (t_0 * (2.0 * ((c0 / h) / w)));
} else {
tmp = 0.0;
}
return tmp;
}
def code(c0, w, h, D, d, M): t_0 = math.pow((d / D), 2.0) tmp = 0 if (M * M) <= 4e-232: tmp = 0.0 elif (M * M) <= 1e-197: tmp = (c0 * (M + ((c0 / (w * h)) * t_0))) / (2.0 * w) elif (M * M) <= 5e-107: tmp = 0.0 elif ((M * M) <= 2e+55) or not ((M * M) <= 5e+190): tmp = ((c0 / w) / 2.0) * (t_0 * (2.0 * ((c0 / h) / w))) else: tmp = 0.0 return tmp
function code(c0, w, h, D, d, M) t_0 = Float64(d / D) ^ 2.0 tmp = 0.0 if (Float64(M * M) <= 4e-232) tmp = 0.0; elseif (Float64(M * M) <= 1e-197) tmp = Float64(Float64(c0 * Float64(M + Float64(Float64(c0 / Float64(w * h)) * t_0))) / Float64(2.0 * w)); elseif (Float64(M * M) <= 5e-107) tmp = 0.0; elseif ((Float64(M * M) <= 2e+55) || !(Float64(M * M) <= 5e+190)) tmp = Float64(Float64(Float64(c0 / w) / 2.0) * Float64(t_0 * Float64(2.0 * Float64(Float64(c0 / h) / w)))); else tmp = 0.0; end return tmp end
function tmp_2 = code(c0, w, h, D, d, M) t_0 = (d / D) ^ 2.0; tmp = 0.0; if ((M * M) <= 4e-232) tmp = 0.0; elseif ((M * M) <= 1e-197) tmp = (c0 * (M + ((c0 / (w * h)) * t_0))) / (2.0 * w); elseif ((M * M) <= 5e-107) tmp = 0.0; elseif (((M * M) <= 2e+55) || ~(((M * M) <= 5e+190))) tmp = ((c0 / w) / 2.0) * (t_0 * (2.0 * ((c0 / h) / w))); else tmp = 0.0; end tmp_2 = tmp; end
code[c0_, w_, h_, D_, d_, M_] := Block[{t$95$0 = N[Power[N[(d / D), $MachinePrecision], 2.0], $MachinePrecision]}, If[LessEqual[N[(M * M), $MachinePrecision], 4e-232], 0.0, If[LessEqual[N[(M * M), $MachinePrecision], 1e-197], N[(N[(c0 * N[(M + N[(N[(c0 / N[(w * h), $MachinePrecision]), $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(2.0 * w), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(M * M), $MachinePrecision], 5e-107], 0.0, If[Or[LessEqual[N[(M * M), $MachinePrecision], 2e+55], N[Not[LessEqual[N[(M * M), $MachinePrecision], 5e+190]], $MachinePrecision]], N[(N[(N[(c0 / w), $MachinePrecision] / 2.0), $MachinePrecision] * N[(t$95$0 * N[(2.0 * N[(N[(c0 / h), $MachinePrecision] / w), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.0]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := {\left(\frac{d}{D}\right)}^{2}\\
\mathbf{if}\;M \cdot M \leq 4 \cdot 10^{-232}:\\
\;\;\;\;0\\
\mathbf{elif}\;M \cdot M \leq 10^{-197}:\\
\;\;\;\;\frac{c0 \cdot \left(M + \frac{c0}{w \cdot h} \cdot t_0\right)}{2 \cdot w}\\
\mathbf{elif}\;M \cdot M \leq 5 \cdot 10^{-107}:\\
\;\;\;\;0\\
\mathbf{elif}\;M \cdot M \leq 2 \cdot 10^{+55} \lor \neg \left(M \cdot M \leq 5 \cdot 10^{+190}\right):\\
\;\;\;\;\frac{\frac{c0}{w}}{2} \cdot \left(t_0 \cdot \left(2 \cdot \frac{\frac{c0}{h}}{w}\right)\right)\\
\mathbf{else}:\\
\;\;\;\;0\\
\end{array}
\end{array}
if (*.f64 M M) < 4.0000000000000001e-232 or 9.9999999999999999e-198 < (*.f64 M M) < 4.99999999999999971e-107 or 2.00000000000000002e55 < (*.f64 M M) < 5.00000000000000036e190Initial program 24.2%
+-commutative24.2%
+-commutative24.2%
times-frac21.0%
fma-neg21.0%
Simplified23.3%
Taylor expanded in c0 around -inf 7.2%
mul-1-neg7.2%
distribute-lft-in5.3%
Simplified46.9%
Taylor expanded in c0 around 0 53.2%
if 4.0000000000000001e-232 < (*.f64 M M) < 9.9999999999999999e-198Initial program 80.0%
+-commutative80.0%
+-commutative80.0%
times-frac80.0%
fma-neg80.0%
Simplified80.0%
Applied egg-rr80.0%
associate-*l/100.0%
Applied egg-rr100.0%
Taylor expanded in c0 around 0 100.0%
if 4.99999999999999971e-107 < (*.f64 M M) < 2.00000000000000002e55 or 5.00000000000000036e190 < (*.f64 M M) Initial program 19.3%
Simplified47.2%
fma-udef47.2%
*-commutative47.2%
associate-/r*47.2%
pow247.2%
Applied egg-rr47.2%
fma-udef47.2%
pow247.2%
rem-log-exp43.0%
rem-log-exp47.2%
add-sqr-sqrt21.3%
sqrt-unprod46.8%
sqr-neg46.8%
sqrt-unprod25.5%
add-sqr-sqrt47.9%
Applied egg-rr47.9%
Taylor expanded in c0 around inf 44.5%
*-commutative44.5%
*-commutative44.5%
times-frac45.7%
unpow245.7%
unpow245.7%
times-frac55.5%
unpow255.5%
associate-*r*55.5%
associate-/l/55.3%
Simplified55.3%
Final simplification54.8%
(FPCore (c0 w h D d M)
:precision binary64
(if (<= M 9.2e-54)
0.0
(if (or (<= M 1.5e+29) (not (<= M 2.05e+100)))
(* (/ c0 (* 2.0 w)) (+ M (* (pow (/ d D) 2.0) (/ (/ c0 w) h))))
0.0)))
double code(double c0, double w, double h, double D, double d, double M) {
double tmp;
if (M <= 9.2e-54) {
tmp = 0.0;
} else if ((M <= 1.5e+29) || !(M <= 2.05e+100)) {
tmp = (c0 / (2.0 * w)) * (M + (pow((d / D), 2.0) * ((c0 / w) / h)));
} else {
tmp = 0.0;
}
return tmp;
}
real(8) function code(c0, w, h, d, d_1, m)
real(8), intent (in) :: c0
real(8), intent (in) :: w
real(8), intent (in) :: h
real(8), intent (in) :: d
real(8), intent (in) :: d_1
real(8), intent (in) :: m
real(8) :: tmp
if (m <= 9.2d-54) then
tmp = 0.0d0
else if ((m <= 1.5d+29) .or. (.not. (m <= 2.05d+100))) then
tmp = (c0 / (2.0d0 * w)) * (m + (((d_1 / d) ** 2.0d0) * ((c0 / w) / h)))
else
tmp = 0.0d0
end if
code = tmp
end function
public static double code(double c0, double w, double h, double D, double d, double M) {
double tmp;
if (M <= 9.2e-54) {
tmp = 0.0;
} else if ((M <= 1.5e+29) || !(M <= 2.05e+100)) {
tmp = (c0 / (2.0 * w)) * (M + (Math.pow((d / D), 2.0) * ((c0 / w) / h)));
} else {
tmp = 0.0;
}
return tmp;
}
def code(c0, w, h, D, d, M): tmp = 0 if M <= 9.2e-54: tmp = 0.0 elif (M <= 1.5e+29) or not (M <= 2.05e+100): tmp = (c0 / (2.0 * w)) * (M + (math.pow((d / D), 2.0) * ((c0 / w) / h))) else: tmp = 0.0 return tmp
function code(c0, w, h, D, d, M) tmp = 0.0 if (M <= 9.2e-54) tmp = 0.0; elseif ((M <= 1.5e+29) || !(M <= 2.05e+100)) tmp = Float64(Float64(c0 / Float64(2.0 * w)) * Float64(M + Float64((Float64(d / D) ^ 2.0) * Float64(Float64(c0 / w) / h)))); else tmp = 0.0; end return tmp end
function tmp_2 = code(c0, w, h, D, d, M) tmp = 0.0; if (M <= 9.2e-54) tmp = 0.0; elseif ((M <= 1.5e+29) || ~((M <= 2.05e+100))) tmp = (c0 / (2.0 * w)) * (M + (((d / D) ^ 2.0) * ((c0 / w) / h))); else tmp = 0.0; end tmp_2 = tmp; end
code[c0_, w_, h_, D_, d_, M_] := If[LessEqual[M, 9.2e-54], 0.0, If[Or[LessEqual[M, 1.5e+29], N[Not[LessEqual[M, 2.05e+100]], $MachinePrecision]], N[(N[(c0 / N[(2.0 * w), $MachinePrecision]), $MachinePrecision] * N[(M + N[(N[Power[N[(d / D), $MachinePrecision], 2.0], $MachinePrecision] * N[(N[(c0 / w), $MachinePrecision] / h), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.0]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;M \leq 9.2 \cdot 10^{-54}:\\
\;\;\;\;0\\
\mathbf{elif}\;M \leq 1.5 \cdot 10^{+29} \lor \neg \left(M \leq 2.05 \cdot 10^{+100}\right):\\
\;\;\;\;\frac{c0}{2 \cdot w} \cdot \left(M + {\left(\frac{d}{D}\right)}^{2} \cdot \frac{\frac{c0}{w}}{h}\right)\\
\mathbf{else}:\\
\;\;\;\;0\\
\end{array}
\end{array}
if M < 9.1999999999999996e-54 or 1.5e29 < M < 2.0500000000000001e100Initial program 24.5%
+-commutative24.5%
+-commutative24.5%
times-frac22.1%
fma-neg22.1%
Simplified24.3%
Taylor expanded in c0 around -inf 5.6%
mul-1-neg5.6%
distribute-lft-in4.1%
Simplified38.1%
Taylor expanded in c0 around 0 43.1%
if 9.1999999999999996e-54 < M < 1.5e29 or 2.0500000000000001e100 < M Initial program 19.2%
+-commutative19.2%
+-commutative19.2%
times-frac19.2%
fma-neg19.2%
Simplified21.4%
Applied egg-rr50.6%
expm1-log1p-u22.8%
expm1-udef22.8%
Applied egg-rr22.7%
expm1-def22.7%
expm1-log1p50.8%
*-commutative50.8%
+-commutative50.8%
associate-/r*50.8%
associate-/r*50.8%
Simplified50.8%
Taylor expanded in c0 around 0 48.1%
Final simplification44.0%
(FPCore (c0 w h D d M)
:precision binary64
(if (<= M 1.46e-52)
0.0
(if (or (<= M 2.2e+29) (not (<= M 1.12e+96)))
(* (/ (/ c0 w) 2.0) (* (pow (/ d D) 2.0) (* 2.0 (/ (/ c0 h) w))))
0.0)))
double code(double c0, double w, double h, double D, double d, double M) {
double tmp;
if (M <= 1.46e-52) {
tmp = 0.0;
} else if ((M <= 2.2e+29) || !(M <= 1.12e+96)) {
tmp = ((c0 / w) / 2.0) * (pow((d / D), 2.0) * (2.0 * ((c0 / h) / w)));
} else {
tmp = 0.0;
}
return tmp;
}
real(8) function code(c0, w, h, d, d_1, m)
real(8), intent (in) :: c0
real(8), intent (in) :: w
real(8), intent (in) :: h
real(8), intent (in) :: d
real(8), intent (in) :: d_1
real(8), intent (in) :: m
real(8) :: tmp
if (m <= 1.46d-52) then
tmp = 0.0d0
else if ((m <= 2.2d+29) .or. (.not. (m <= 1.12d+96))) then
tmp = ((c0 / w) / 2.0d0) * (((d_1 / d) ** 2.0d0) * (2.0d0 * ((c0 / h) / w)))
else
tmp = 0.0d0
end if
code = tmp
end function
public static double code(double c0, double w, double h, double D, double d, double M) {
double tmp;
if (M <= 1.46e-52) {
tmp = 0.0;
} else if ((M <= 2.2e+29) || !(M <= 1.12e+96)) {
tmp = ((c0 / w) / 2.0) * (Math.pow((d / D), 2.0) * (2.0 * ((c0 / h) / w)));
} else {
tmp = 0.0;
}
return tmp;
}
def code(c0, w, h, D, d, M): tmp = 0 if M <= 1.46e-52: tmp = 0.0 elif (M <= 2.2e+29) or not (M <= 1.12e+96): tmp = ((c0 / w) / 2.0) * (math.pow((d / D), 2.0) * (2.0 * ((c0 / h) / w))) else: tmp = 0.0 return tmp
function code(c0, w, h, D, d, M) tmp = 0.0 if (M <= 1.46e-52) tmp = 0.0; elseif ((M <= 2.2e+29) || !(M <= 1.12e+96)) tmp = Float64(Float64(Float64(c0 / w) / 2.0) * Float64((Float64(d / D) ^ 2.0) * Float64(2.0 * Float64(Float64(c0 / h) / w)))); else tmp = 0.0; end return tmp end
function tmp_2 = code(c0, w, h, D, d, M) tmp = 0.0; if (M <= 1.46e-52) tmp = 0.0; elseif ((M <= 2.2e+29) || ~((M <= 1.12e+96))) tmp = ((c0 / w) / 2.0) * (((d / D) ^ 2.0) * (2.0 * ((c0 / h) / w))); else tmp = 0.0; end tmp_2 = tmp; end
code[c0_, w_, h_, D_, d_, M_] := If[LessEqual[M, 1.46e-52], 0.0, If[Or[LessEqual[M, 2.2e+29], N[Not[LessEqual[M, 1.12e+96]], $MachinePrecision]], N[(N[(N[(c0 / w), $MachinePrecision] / 2.0), $MachinePrecision] * N[(N[Power[N[(d / D), $MachinePrecision], 2.0], $MachinePrecision] * N[(2.0 * N[(N[(c0 / h), $MachinePrecision] / w), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.0]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;M \leq 1.46 \cdot 10^{-52}:\\
\;\;\;\;0\\
\mathbf{elif}\;M \leq 2.2 \cdot 10^{+29} \lor \neg \left(M \leq 1.12 \cdot 10^{+96}\right):\\
\;\;\;\;\frac{\frac{c0}{w}}{2} \cdot \left({\left(\frac{d}{D}\right)}^{2} \cdot \left(2 \cdot \frac{\frac{c0}{h}}{w}\right)\right)\\
\mathbf{else}:\\
\;\;\;\;0\\
\end{array}
\end{array}
if M < 1.46000000000000003e-52 or 2.2000000000000001e29 < M < 1.1199999999999999e96Initial program 24.5%
+-commutative24.5%
+-commutative24.5%
times-frac22.1%
fma-neg22.1%
Simplified24.3%
Taylor expanded in c0 around -inf 5.6%
mul-1-neg5.6%
distribute-lft-in4.1%
Simplified38.1%
Taylor expanded in c0 around 0 43.1%
if 1.46000000000000003e-52 < M < 2.2000000000000001e29 or 1.1199999999999999e96 < M Initial program 19.2%
Simplified48.6%
fma-udef48.6%
*-commutative48.6%
associate-/r*48.6%
pow248.6%
Applied egg-rr48.6%
fma-udef48.6%
pow248.6%
rem-log-exp44.5%
rem-log-exp48.6%
add-sqr-sqrt0.0%
sqrt-unprod47.9%
sqr-neg47.9%
sqrt-unprod47.9%
add-sqr-sqrt47.9%
Applied egg-rr47.9%
Taylor expanded in c0 around inf 45.1%
*-commutative45.1%
*-commutative45.1%
times-frac47.2%
unpow247.2%
unpow247.2%
times-frac51.5%
unpow251.5%
associate-*r*51.5%
associate-/l/51.1%
Simplified51.1%
Final simplification44.6%
(FPCore (c0 w h D d M) :precision binary64 (if (<= M 7.5e+103) 0.0 (* 0.5 (* c0 (/ M w)))))
double code(double c0, double w, double h, double D, double d, double M) {
double tmp;
if (M <= 7.5e+103) {
tmp = 0.0;
} else {
tmp = 0.5 * (c0 * (M / w));
}
return tmp;
}
real(8) function code(c0, w, h, d, d_1, m)
real(8), intent (in) :: c0
real(8), intent (in) :: w
real(8), intent (in) :: h
real(8), intent (in) :: d
real(8), intent (in) :: d_1
real(8), intent (in) :: m
real(8) :: tmp
if (m <= 7.5d+103) then
tmp = 0.0d0
else
tmp = 0.5d0 * (c0 * (m / w))
end if
code = tmp
end function
public static double code(double c0, double w, double h, double D, double d, double M) {
double tmp;
if (M <= 7.5e+103) {
tmp = 0.0;
} else {
tmp = 0.5 * (c0 * (M / w));
}
return tmp;
}
def code(c0, w, h, D, d, M): tmp = 0 if M <= 7.5e+103: tmp = 0.0 else: tmp = 0.5 * (c0 * (M / w)) return tmp
function code(c0, w, h, D, d, M) tmp = 0.0 if (M <= 7.5e+103) tmp = 0.0; else tmp = Float64(0.5 * Float64(c0 * Float64(M / w))); end return tmp end
function tmp_2 = code(c0, w, h, D, d, M) tmp = 0.0; if (M <= 7.5e+103) tmp = 0.0; else tmp = 0.5 * (c0 * (M / w)); end tmp_2 = tmp; end
code[c0_, w_, h_, D_, d_, M_] := If[LessEqual[M, 7.5e+103], 0.0, N[(0.5 * N[(c0 * N[(M / w), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;M \leq 7.5 \cdot 10^{+103}:\\
\;\;\;\;0\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \left(c0 \cdot \frac{M}{w}\right)\\
\end{array}
\end{array}
if M < 7.49999999999999922e103Initial program 25.1%
+-commutative25.1%
+-commutative25.1%
times-frac22.8%
fma-neg22.8%
Simplified25.4%
Taylor expanded in c0 around -inf 5.2%
mul-1-neg5.2%
distribute-lft-in3.9%
Simplified37.0%
Taylor expanded in c0 around 0 41.6%
if 7.49999999999999922e103 < M Initial program 12.7%
+-commutative12.7%
+-commutative12.7%
times-frac12.7%
fma-neg12.7%
Simplified12.7%
Applied egg-rr50.2%
expm1-log1p-u21.9%
expm1-udef21.9%
Applied egg-rr22.5%
expm1-def22.5%
expm1-log1p51.3%
*-commutative51.3%
+-commutative51.3%
associate-/r*51.3%
associate-/r*51.3%
Simplified51.3%
Taylor expanded in c0 around 0 36.4%
associate-/l*36.7%
associate-/r/36.4%
Simplified36.4%
Final simplification40.9%
(FPCore (c0 w h D d M) :precision binary64 0.0)
double code(double c0, double w, double h, double D, double d, double M) {
return 0.0;
}
real(8) function code(c0, w, h, d, d_1, m)
real(8), intent (in) :: c0
real(8), intent (in) :: w
real(8), intent (in) :: h
real(8), intent (in) :: d
real(8), intent (in) :: d_1
real(8), intent (in) :: m
code = 0.0d0
end function
public static double code(double c0, double w, double h, double D, double d, double M) {
return 0.0;
}
def code(c0, w, h, D, d, M): return 0.0
function code(c0, w, h, D, d, M) return 0.0 end
function tmp = code(c0, w, h, D, d, M) tmp = 0.0; end
code[c0_, w_, h_, D_, d_, M_] := 0.0
\begin{array}{l}
\\
0
\end{array}
Initial program 23.5%
+-commutative23.5%
+-commutative23.5%
times-frac21.6%
fma-neg21.6%
Simplified23.8%
Taylor expanded in c0 around -inf 4.6%
mul-1-neg4.6%
distribute-lft-in3.4%
Simplified33.9%
Taylor expanded in c0 around 0 38.0%
Final simplification38.0%
herbie shell --seed 2024021
(FPCore (c0 w h D d M)
:name "Henrywood and Agarwal, Equation (13)"
:precision binary64
(* (/ c0 (* 2.0 w)) (+ (/ (* c0 (* d d)) (* (* w h) (* D D))) (sqrt (- (* (/ (* c0 (* d d)) (* (* w h) (* D D))) (/ (* c0 (* d d)) (* (* w h) (* D D)))) (* M M))))))