
(FPCore (w0 M D h l d) :precision binary64 (* w0 (sqrt (- 1.0 (* (pow (/ (* M D) (* 2.0 d)) 2.0) (/ h l))))))
double code(double w0, double M, double D, double h, double l, double d) {
return w0 * sqrt((1.0 - (pow(((M * D) / (2.0 * d)), 2.0) * (h / l))));
}
real(8) function code(w0, m, d, h, l, d_1)
real(8), intent (in) :: w0
real(8), intent (in) :: m
real(8), intent (in) :: d
real(8), intent (in) :: h
real(8), intent (in) :: l
real(8), intent (in) :: d_1
code = w0 * sqrt((1.0d0 - ((((m * d) / (2.0d0 * d_1)) ** 2.0d0) * (h / l))))
end function
public static double code(double w0, double M, double D, double h, double l, double d) {
return w0 * Math.sqrt((1.0 - (Math.pow(((M * D) / (2.0 * d)), 2.0) * (h / l))));
}
def code(w0, M, D, h, l, d): return w0 * math.sqrt((1.0 - (math.pow(((M * D) / (2.0 * d)), 2.0) * (h / l))))
function code(w0, M, D, h, l, d) return Float64(w0 * sqrt(Float64(1.0 - Float64((Float64(Float64(M * D) / Float64(2.0 * d)) ^ 2.0) * Float64(h / l))))) end
function tmp = code(w0, M, D, h, l, d) tmp = w0 * sqrt((1.0 - ((((M * D) / (2.0 * d)) ^ 2.0) * (h / l)))); end
code[w0_, M_, D_, h_, l_, d_] := N[(w0 * N[Sqrt[N[(1.0 - N[(N[Power[N[(N[(M * D), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] * N[(h / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
w0 \cdot \sqrt{1 - {\left(\frac{M \cdot D}{2 \cdot d}\right)}^{2} \cdot \frac{h}{\ell}}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 10 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (w0 M D h l d) :precision binary64 (* w0 (sqrt (- 1.0 (* (pow (/ (* M D) (* 2.0 d)) 2.0) (/ h l))))))
double code(double w0, double M, double D, double h, double l, double d) {
return w0 * sqrt((1.0 - (pow(((M * D) / (2.0 * d)), 2.0) * (h / l))));
}
real(8) function code(w0, m, d, h, l, d_1)
real(8), intent (in) :: w0
real(8), intent (in) :: m
real(8), intent (in) :: d
real(8), intent (in) :: h
real(8), intent (in) :: l
real(8), intent (in) :: d_1
code = w0 * sqrt((1.0d0 - ((((m * d) / (2.0d0 * d_1)) ** 2.0d0) * (h / l))))
end function
public static double code(double w0, double M, double D, double h, double l, double d) {
return w0 * Math.sqrt((1.0 - (Math.pow(((M * D) / (2.0 * d)), 2.0) * (h / l))));
}
def code(w0, M, D, h, l, d): return w0 * math.sqrt((1.0 - (math.pow(((M * D) / (2.0 * d)), 2.0) * (h / l))))
function code(w0, M, D, h, l, d) return Float64(w0 * sqrt(Float64(1.0 - Float64((Float64(Float64(M * D) / Float64(2.0 * d)) ^ 2.0) * Float64(h / l))))) end
function tmp = code(w0, M, D, h, l, d) tmp = w0 * sqrt((1.0 - ((((M * D) / (2.0 * d)) ^ 2.0) * (h / l)))); end
code[w0_, M_, D_, h_, l_, d_] := N[(w0 * N[Sqrt[N[(1.0 - N[(N[Power[N[(N[(M * D), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] * N[(h / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
w0 \cdot \sqrt{1 - {\left(\frac{M \cdot D}{2 \cdot d}\right)}^{2} \cdot \frac{h}{\ell}}
\end{array}
d_m = (fabs.f64 d) (FPCore (w0 M D h l d_m) :precision binary64 (if (<= (* (pow (/ (* M D) (* 2.0 d_m)) 2.0) (/ h l)) -2e+41) (* (* (fabs (* M D)) (sqrt (* (/ h l) -0.25))) (* (/ 1.0 d_m) w0)) w0))
d_m = fabs(d);
double code(double w0, double M, double D, double h, double l, double d_m) {
double tmp;
if ((pow(((M * D) / (2.0 * d_m)), 2.0) * (h / l)) <= -2e+41) {
tmp = (fabs((M * D)) * sqrt(((h / l) * -0.25))) * ((1.0 / d_m) * w0);
} else {
tmp = w0;
}
return tmp;
}
d_m = abs(d)
real(8) function code(w0, m, d, h, l, d_m)
real(8), intent (in) :: w0
real(8), intent (in) :: m
real(8), intent (in) :: d
real(8), intent (in) :: h
real(8), intent (in) :: l
real(8), intent (in) :: d_m
real(8) :: tmp
if (((((m * d) / (2.0d0 * d_m)) ** 2.0d0) * (h / l)) <= (-2d+41)) then
tmp = (abs((m * d)) * sqrt(((h / l) * (-0.25d0)))) * ((1.0d0 / d_m) * w0)
else
tmp = w0
end if
code = tmp
end function
d_m = Math.abs(d);
public static double code(double w0, double M, double D, double h, double l, double d_m) {
double tmp;
if ((Math.pow(((M * D) / (2.0 * d_m)), 2.0) * (h / l)) <= -2e+41) {
tmp = (Math.abs((M * D)) * Math.sqrt(((h / l) * -0.25))) * ((1.0 / d_m) * w0);
} else {
tmp = w0;
}
return tmp;
}
d_m = math.fabs(d) def code(w0, M, D, h, l, d_m): tmp = 0 if (math.pow(((M * D) / (2.0 * d_m)), 2.0) * (h / l)) <= -2e+41: tmp = (math.fabs((M * D)) * math.sqrt(((h / l) * -0.25))) * ((1.0 / d_m) * w0) else: tmp = w0 return tmp
d_m = abs(d) function code(w0, M, D, h, l, d_m) tmp = 0.0 if (Float64((Float64(Float64(M * D) / Float64(2.0 * d_m)) ^ 2.0) * Float64(h / l)) <= -2e+41) tmp = Float64(Float64(abs(Float64(M * D)) * sqrt(Float64(Float64(h / l) * -0.25))) * Float64(Float64(1.0 / d_m) * w0)); else tmp = w0; end return tmp end
d_m = abs(d); function tmp_2 = code(w0, M, D, h, l, d_m) tmp = 0.0; if (((((M * D) / (2.0 * d_m)) ^ 2.0) * (h / l)) <= -2e+41) tmp = (abs((M * D)) * sqrt(((h / l) * -0.25))) * ((1.0 / d_m) * w0); else tmp = w0; end tmp_2 = tmp; end
d_m = N[Abs[d], $MachinePrecision] code[w0_, M_, D_, h_, l_, d$95$m_] := If[LessEqual[N[(N[Power[N[(N[(M * D), $MachinePrecision] / N[(2.0 * d$95$m), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] * N[(h / l), $MachinePrecision]), $MachinePrecision], -2e+41], N[(N[(N[Abs[N[(M * D), $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[(N[(h / l), $MachinePrecision] * -0.25), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(N[(1.0 / d$95$m), $MachinePrecision] * w0), $MachinePrecision]), $MachinePrecision], w0]
\begin{array}{l}
d_m = \left|d\right|
\\
\begin{array}{l}
\mathbf{if}\;{\left(\frac{M \cdot D}{2 \cdot d\_m}\right)}^{2} \cdot \frac{h}{\ell} \leq -2 \cdot 10^{+41}:\\
\;\;\;\;\left(\left|M \cdot D\right| \cdot \sqrt{\frac{h}{\ell} \cdot -0.25}\right) \cdot \left(\frac{1}{d\_m} \cdot w0\right)\\
\mathbf{else}:\\
\;\;\;\;w0\\
\end{array}
\end{array}
if (*.f64 (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) (/.f64 h l)) < -2.00000000000000001e41Initial program 68.1%
Taylor expanded in M around inf
associate-*r/N/A
lower-/.f64N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6434.8
Simplified34.8%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
lower-*.f64N/A
Applied egg-rr47.1%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6447.1
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6449.5
Applied egg-rr49.5%
Applied egg-rr49.7%
if -2.00000000000000001e41 < (*.f64 (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) (/.f64 h l)) Initial program 88.9%
Taylor expanded in M around 0
Simplified96.6%
*-rgt-identity96.6
Applied egg-rr96.6%
Final simplification82.8%
d_m = (fabs.f64 d) (FPCore (w0 M D h l d_m) :precision binary64 (if (<= (* (pow (/ (* M D) (* 2.0 d_m)) 2.0) (/ h l)) -2e+41) (* (/ 1.0 d_m) (* (* (fabs (* M D)) (sqrt (* (/ h l) -0.25))) w0)) w0))
d_m = fabs(d);
double code(double w0, double M, double D, double h, double l, double d_m) {
double tmp;
if ((pow(((M * D) / (2.0 * d_m)), 2.0) * (h / l)) <= -2e+41) {
tmp = (1.0 / d_m) * ((fabs((M * D)) * sqrt(((h / l) * -0.25))) * w0);
} else {
tmp = w0;
}
return tmp;
}
d_m = abs(d)
real(8) function code(w0, m, d, h, l, d_m)
real(8), intent (in) :: w0
real(8), intent (in) :: m
real(8), intent (in) :: d
real(8), intent (in) :: h
real(8), intent (in) :: l
real(8), intent (in) :: d_m
real(8) :: tmp
if (((((m * d) / (2.0d0 * d_m)) ** 2.0d0) * (h / l)) <= (-2d+41)) then
tmp = (1.0d0 / d_m) * ((abs((m * d)) * sqrt(((h / l) * (-0.25d0)))) * w0)
else
tmp = w0
end if
code = tmp
end function
d_m = Math.abs(d);
public static double code(double w0, double M, double D, double h, double l, double d_m) {
double tmp;
if ((Math.pow(((M * D) / (2.0 * d_m)), 2.0) * (h / l)) <= -2e+41) {
tmp = (1.0 / d_m) * ((Math.abs((M * D)) * Math.sqrt(((h / l) * -0.25))) * w0);
} else {
tmp = w0;
}
return tmp;
}
d_m = math.fabs(d) def code(w0, M, D, h, l, d_m): tmp = 0 if (math.pow(((M * D) / (2.0 * d_m)), 2.0) * (h / l)) <= -2e+41: tmp = (1.0 / d_m) * ((math.fabs((M * D)) * math.sqrt(((h / l) * -0.25))) * w0) else: tmp = w0 return tmp
d_m = abs(d) function code(w0, M, D, h, l, d_m) tmp = 0.0 if (Float64((Float64(Float64(M * D) / Float64(2.0 * d_m)) ^ 2.0) * Float64(h / l)) <= -2e+41) tmp = Float64(Float64(1.0 / d_m) * Float64(Float64(abs(Float64(M * D)) * sqrt(Float64(Float64(h / l) * -0.25))) * w0)); else tmp = w0; end return tmp end
d_m = abs(d); function tmp_2 = code(w0, M, D, h, l, d_m) tmp = 0.0; if (((((M * D) / (2.0 * d_m)) ^ 2.0) * (h / l)) <= -2e+41) tmp = (1.0 / d_m) * ((abs((M * D)) * sqrt(((h / l) * -0.25))) * w0); else tmp = w0; end tmp_2 = tmp; end
d_m = N[Abs[d], $MachinePrecision] code[w0_, M_, D_, h_, l_, d$95$m_] := If[LessEqual[N[(N[Power[N[(N[(M * D), $MachinePrecision] / N[(2.0 * d$95$m), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] * N[(h / l), $MachinePrecision]), $MachinePrecision], -2e+41], N[(N[(1.0 / d$95$m), $MachinePrecision] * N[(N[(N[Abs[N[(M * D), $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[(N[(h / l), $MachinePrecision] * -0.25), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * w0), $MachinePrecision]), $MachinePrecision], w0]
\begin{array}{l}
d_m = \left|d\right|
\\
\begin{array}{l}
\mathbf{if}\;{\left(\frac{M \cdot D}{2 \cdot d\_m}\right)}^{2} \cdot \frac{h}{\ell} \leq -2 \cdot 10^{+41}:\\
\;\;\;\;\frac{1}{d\_m} \cdot \left(\left(\left|M \cdot D\right| \cdot \sqrt{\frac{h}{\ell} \cdot -0.25}\right) \cdot w0\right)\\
\mathbf{else}:\\
\;\;\;\;w0\\
\end{array}
\end{array}
if (*.f64 (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) (/.f64 h l)) < -2.00000000000000001e41Initial program 68.1%
Taylor expanded in M around inf
associate-*r/N/A
lower-/.f64N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6434.8
Simplified34.8%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
lower-*.f64N/A
Applied egg-rr47.1%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6447.1
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6449.5
Applied egg-rr49.5%
Applied egg-rr48.6%
if -2.00000000000000001e41 < (*.f64 (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) (/.f64 h l)) Initial program 88.9%
Taylor expanded in M around 0
Simplified96.6%
*-rgt-identity96.6
Applied egg-rr96.6%
Final simplification82.5%
d_m = (fabs.f64 d) (FPCore (w0 M D h l d_m) :precision binary64 (if (<= (* (pow (/ (* M D) (* 2.0 d_m)) 2.0) (/ h l)) -2e+41) (/ (* (* (fabs (* M D)) (sqrt (* (/ h l) -0.25))) w0) d_m) w0))
d_m = fabs(d);
double code(double w0, double M, double D, double h, double l, double d_m) {
double tmp;
if ((pow(((M * D) / (2.0 * d_m)), 2.0) * (h / l)) <= -2e+41) {
tmp = ((fabs((M * D)) * sqrt(((h / l) * -0.25))) * w0) / d_m;
} else {
tmp = w0;
}
return tmp;
}
d_m = abs(d)
real(8) function code(w0, m, d, h, l, d_m)
real(8), intent (in) :: w0
real(8), intent (in) :: m
real(8), intent (in) :: d
real(8), intent (in) :: h
real(8), intent (in) :: l
real(8), intent (in) :: d_m
real(8) :: tmp
if (((((m * d) / (2.0d0 * d_m)) ** 2.0d0) * (h / l)) <= (-2d+41)) then
tmp = ((abs((m * d)) * sqrt(((h / l) * (-0.25d0)))) * w0) / d_m
else
tmp = w0
end if
code = tmp
end function
d_m = Math.abs(d);
public static double code(double w0, double M, double D, double h, double l, double d_m) {
double tmp;
if ((Math.pow(((M * D) / (2.0 * d_m)), 2.0) * (h / l)) <= -2e+41) {
tmp = ((Math.abs((M * D)) * Math.sqrt(((h / l) * -0.25))) * w0) / d_m;
} else {
tmp = w0;
}
return tmp;
}
d_m = math.fabs(d) def code(w0, M, D, h, l, d_m): tmp = 0 if (math.pow(((M * D) / (2.0 * d_m)), 2.0) * (h / l)) <= -2e+41: tmp = ((math.fabs((M * D)) * math.sqrt(((h / l) * -0.25))) * w0) / d_m else: tmp = w0 return tmp
d_m = abs(d) function code(w0, M, D, h, l, d_m) tmp = 0.0 if (Float64((Float64(Float64(M * D) / Float64(2.0 * d_m)) ^ 2.0) * Float64(h / l)) <= -2e+41) tmp = Float64(Float64(Float64(abs(Float64(M * D)) * sqrt(Float64(Float64(h / l) * -0.25))) * w0) / d_m); else tmp = w0; end return tmp end
d_m = abs(d); function tmp_2 = code(w0, M, D, h, l, d_m) tmp = 0.0; if (((((M * D) / (2.0 * d_m)) ^ 2.0) * (h / l)) <= -2e+41) tmp = ((abs((M * D)) * sqrt(((h / l) * -0.25))) * w0) / d_m; else tmp = w0; end tmp_2 = tmp; end
d_m = N[Abs[d], $MachinePrecision] code[w0_, M_, D_, h_, l_, d$95$m_] := If[LessEqual[N[(N[Power[N[(N[(M * D), $MachinePrecision] / N[(2.0 * d$95$m), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] * N[(h / l), $MachinePrecision]), $MachinePrecision], -2e+41], N[(N[(N[(N[Abs[N[(M * D), $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[(N[(h / l), $MachinePrecision] * -0.25), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * w0), $MachinePrecision] / d$95$m), $MachinePrecision], w0]
\begin{array}{l}
d_m = \left|d\right|
\\
\begin{array}{l}
\mathbf{if}\;{\left(\frac{M \cdot D}{2 \cdot d\_m}\right)}^{2} \cdot \frac{h}{\ell} \leq -2 \cdot 10^{+41}:\\
\;\;\;\;\frac{\left(\left|M \cdot D\right| \cdot \sqrt{\frac{h}{\ell} \cdot -0.25}\right) \cdot w0}{d\_m}\\
\mathbf{else}:\\
\;\;\;\;w0\\
\end{array}
\end{array}
if (*.f64 (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) (/.f64 h l)) < -2.00000000000000001e41Initial program 68.1%
Taylor expanded in M around inf
associate-*r/N/A
lower-/.f64N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6434.8
Simplified34.8%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
lower-*.f64N/A
Applied egg-rr47.1%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6447.1
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6449.5
Applied egg-rr49.5%
Applied egg-rr48.6%
if -2.00000000000000001e41 < (*.f64 (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) (/.f64 h l)) Initial program 88.9%
Taylor expanded in M around 0
Simplified96.6%
*-rgt-identity96.6
Applied egg-rr96.6%
Final simplification82.5%
d_m = (fabs.f64 d) (FPCore (w0 M D h l d_m) :precision binary64 (if (<= (* (pow (/ (* M D) (* 2.0 d_m)) 2.0) (/ h l)) -2e+41) (* w0 (/ (* (fabs (* M D)) (sqrt (* (/ h l) -0.25))) d_m)) w0))
d_m = fabs(d);
double code(double w0, double M, double D, double h, double l, double d_m) {
double tmp;
if ((pow(((M * D) / (2.0 * d_m)), 2.0) * (h / l)) <= -2e+41) {
tmp = w0 * ((fabs((M * D)) * sqrt(((h / l) * -0.25))) / d_m);
} else {
tmp = w0;
}
return tmp;
}
d_m = abs(d)
real(8) function code(w0, m, d, h, l, d_m)
real(8), intent (in) :: w0
real(8), intent (in) :: m
real(8), intent (in) :: d
real(8), intent (in) :: h
real(8), intent (in) :: l
real(8), intent (in) :: d_m
real(8) :: tmp
if (((((m * d) / (2.0d0 * d_m)) ** 2.0d0) * (h / l)) <= (-2d+41)) then
tmp = w0 * ((abs((m * d)) * sqrt(((h / l) * (-0.25d0)))) / d_m)
else
tmp = w0
end if
code = tmp
end function
d_m = Math.abs(d);
public static double code(double w0, double M, double D, double h, double l, double d_m) {
double tmp;
if ((Math.pow(((M * D) / (2.0 * d_m)), 2.0) * (h / l)) <= -2e+41) {
tmp = w0 * ((Math.abs((M * D)) * Math.sqrt(((h / l) * -0.25))) / d_m);
} else {
tmp = w0;
}
return tmp;
}
d_m = math.fabs(d) def code(w0, M, D, h, l, d_m): tmp = 0 if (math.pow(((M * D) / (2.0 * d_m)), 2.0) * (h / l)) <= -2e+41: tmp = w0 * ((math.fabs((M * D)) * math.sqrt(((h / l) * -0.25))) / d_m) else: tmp = w0 return tmp
d_m = abs(d) function code(w0, M, D, h, l, d_m) tmp = 0.0 if (Float64((Float64(Float64(M * D) / Float64(2.0 * d_m)) ^ 2.0) * Float64(h / l)) <= -2e+41) tmp = Float64(w0 * Float64(Float64(abs(Float64(M * D)) * sqrt(Float64(Float64(h / l) * -0.25))) / d_m)); else tmp = w0; end return tmp end
d_m = abs(d); function tmp_2 = code(w0, M, D, h, l, d_m) tmp = 0.0; if (((((M * D) / (2.0 * d_m)) ^ 2.0) * (h / l)) <= -2e+41) tmp = w0 * ((abs((M * D)) * sqrt(((h / l) * -0.25))) / d_m); else tmp = w0; end tmp_2 = tmp; end
d_m = N[Abs[d], $MachinePrecision] code[w0_, M_, D_, h_, l_, d$95$m_] := If[LessEqual[N[(N[Power[N[(N[(M * D), $MachinePrecision] / N[(2.0 * d$95$m), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] * N[(h / l), $MachinePrecision]), $MachinePrecision], -2e+41], N[(w0 * N[(N[(N[Abs[N[(M * D), $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[(N[(h / l), $MachinePrecision] * -0.25), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / d$95$m), $MachinePrecision]), $MachinePrecision], w0]
\begin{array}{l}
d_m = \left|d\right|
\\
\begin{array}{l}
\mathbf{if}\;{\left(\frac{M \cdot D}{2 \cdot d\_m}\right)}^{2} \cdot \frac{h}{\ell} \leq -2 \cdot 10^{+41}:\\
\;\;\;\;w0 \cdot \frac{\left|M \cdot D\right| \cdot \sqrt{\frac{h}{\ell} \cdot -0.25}}{d\_m}\\
\mathbf{else}:\\
\;\;\;\;w0\\
\end{array}
\end{array}
if (*.f64 (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) (/.f64 h l)) < -2.00000000000000001e41Initial program 68.1%
Taylor expanded in M around inf
associate-*r/N/A
lower-/.f64N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6434.8
Simplified34.8%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
lower-*.f64N/A
Applied egg-rr47.1%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6447.1
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6449.5
Applied egg-rr49.5%
Applied egg-rr48.6%
if -2.00000000000000001e41 < (*.f64 (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) (/.f64 h l)) Initial program 88.9%
Taylor expanded in M around 0
Simplified96.6%
*-rgt-identity96.6
Applied egg-rr96.6%
Final simplification82.5%
d_m = (fabs.f64 d) (FPCore (w0 M D h l d_m) :precision binary64 (if (<= (* (pow (/ (* M D) (* 2.0 d_m)) 2.0) (/ h l)) -4e+86) (* w0 (* (fabs (* M D)) (sqrt (/ (* h -0.25) (* d_m (* d_m l)))))) w0))
d_m = fabs(d);
double code(double w0, double M, double D, double h, double l, double d_m) {
double tmp;
if ((pow(((M * D) / (2.0 * d_m)), 2.0) * (h / l)) <= -4e+86) {
tmp = w0 * (fabs((M * D)) * sqrt(((h * -0.25) / (d_m * (d_m * l)))));
} else {
tmp = w0;
}
return tmp;
}
d_m = abs(d)
real(8) function code(w0, m, d, h, l, d_m)
real(8), intent (in) :: w0
real(8), intent (in) :: m
real(8), intent (in) :: d
real(8), intent (in) :: h
real(8), intent (in) :: l
real(8), intent (in) :: d_m
real(8) :: tmp
if (((((m * d) / (2.0d0 * d_m)) ** 2.0d0) * (h / l)) <= (-4d+86)) then
tmp = w0 * (abs((m * d)) * sqrt(((h * (-0.25d0)) / (d_m * (d_m * l)))))
else
tmp = w0
end if
code = tmp
end function
d_m = Math.abs(d);
public static double code(double w0, double M, double D, double h, double l, double d_m) {
double tmp;
if ((Math.pow(((M * D) / (2.0 * d_m)), 2.0) * (h / l)) <= -4e+86) {
tmp = w0 * (Math.abs((M * D)) * Math.sqrt(((h * -0.25) / (d_m * (d_m * l)))));
} else {
tmp = w0;
}
return tmp;
}
d_m = math.fabs(d) def code(w0, M, D, h, l, d_m): tmp = 0 if (math.pow(((M * D) / (2.0 * d_m)), 2.0) * (h / l)) <= -4e+86: tmp = w0 * (math.fabs((M * D)) * math.sqrt(((h * -0.25) / (d_m * (d_m * l))))) else: tmp = w0 return tmp
d_m = abs(d) function code(w0, M, D, h, l, d_m) tmp = 0.0 if (Float64((Float64(Float64(M * D) / Float64(2.0 * d_m)) ^ 2.0) * Float64(h / l)) <= -4e+86) tmp = Float64(w0 * Float64(abs(Float64(M * D)) * sqrt(Float64(Float64(h * -0.25) / Float64(d_m * Float64(d_m * l)))))); else tmp = w0; end return tmp end
d_m = abs(d); function tmp_2 = code(w0, M, D, h, l, d_m) tmp = 0.0; if (((((M * D) / (2.0 * d_m)) ^ 2.0) * (h / l)) <= -4e+86) tmp = w0 * (abs((M * D)) * sqrt(((h * -0.25) / (d_m * (d_m * l))))); else tmp = w0; end tmp_2 = tmp; end
d_m = N[Abs[d], $MachinePrecision] code[w0_, M_, D_, h_, l_, d$95$m_] := If[LessEqual[N[(N[Power[N[(N[(M * D), $MachinePrecision] / N[(2.0 * d$95$m), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] * N[(h / l), $MachinePrecision]), $MachinePrecision], -4e+86], N[(w0 * N[(N[Abs[N[(M * D), $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[(N[(h * -0.25), $MachinePrecision] / N[(d$95$m * N[(d$95$m * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], w0]
\begin{array}{l}
d_m = \left|d\right|
\\
\begin{array}{l}
\mathbf{if}\;{\left(\frac{M \cdot D}{2 \cdot d\_m}\right)}^{2} \cdot \frac{h}{\ell} \leq -4 \cdot 10^{+86}:\\
\;\;\;\;w0 \cdot \left(\left|M \cdot D\right| \cdot \sqrt{\frac{h \cdot -0.25}{d\_m \cdot \left(d\_m \cdot \ell\right)}}\right)\\
\mathbf{else}:\\
\;\;\;\;w0\\
\end{array}
\end{array}
if (*.f64 (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) (/.f64 h l)) < -4.0000000000000001e86Initial program 67.2%
Taylor expanded in M around inf
associate-*r/N/A
lower-/.f64N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6435.7
Simplified35.7%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
lower-*.f64N/A
Applied egg-rr47.0%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6447.0
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6449.5
Applied egg-rr49.5%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-sqrt.f64N/A
*-commutativeN/A
lower-*.f6449.5
Applied egg-rr60.8%
if -4.0000000000000001e86 < (*.f64 (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) (/.f64 h l)) Initial program 89.0%
Taylor expanded in M around 0
Simplified95.6%
*-rgt-identity95.6
Applied egg-rr95.6%
Final simplification85.7%
d_m = (fabs.f64 d) (FPCore (w0 M D h l d_m) :precision binary64 (if (<= (* (pow (/ (* M D) (* 2.0 d_m)) 2.0) (/ h l)) -4e-6) (fma (* D D) (* (* h -0.125) (/ (* M (* M w0)) (* d_m (* d_m l)))) w0) w0))
d_m = fabs(d);
double code(double w0, double M, double D, double h, double l, double d_m) {
double tmp;
if ((pow(((M * D) / (2.0 * d_m)), 2.0) * (h / l)) <= -4e-6) {
tmp = fma((D * D), ((h * -0.125) * ((M * (M * w0)) / (d_m * (d_m * l)))), w0);
} else {
tmp = w0;
}
return tmp;
}
d_m = abs(d) function code(w0, M, D, h, l, d_m) tmp = 0.0 if (Float64((Float64(Float64(M * D) / Float64(2.0 * d_m)) ^ 2.0) * Float64(h / l)) <= -4e-6) tmp = fma(Float64(D * D), Float64(Float64(h * -0.125) * Float64(Float64(M * Float64(M * w0)) / Float64(d_m * Float64(d_m * l)))), w0); else tmp = w0; end return tmp end
d_m = N[Abs[d], $MachinePrecision] code[w0_, M_, D_, h_, l_, d$95$m_] := If[LessEqual[N[(N[Power[N[(N[(M * D), $MachinePrecision] / N[(2.0 * d$95$m), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] * N[(h / l), $MachinePrecision]), $MachinePrecision], -4e-6], N[(N[(D * D), $MachinePrecision] * N[(N[(h * -0.125), $MachinePrecision] * N[(N[(M * N[(M * w0), $MachinePrecision]), $MachinePrecision] / N[(d$95$m * N[(d$95$m * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + w0), $MachinePrecision], w0]
\begin{array}{l}
d_m = \left|d\right|
\\
\begin{array}{l}
\mathbf{if}\;{\left(\frac{M \cdot D}{2 \cdot d\_m}\right)}^{2} \cdot \frac{h}{\ell} \leq -4 \cdot 10^{-6}:\\
\;\;\;\;\mathsf{fma}\left(D \cdot D, \left(h \cdot -0.125\right) \cdot \frac{M \cdot \left(M \cdot w0\right)}{d\_m \cdot \left(d\_m \cdot \ell\right)}, w0\right)\\
\mathbf{else}:\\
\;\;\;\;w0\\
\end{array}
\end{array}
if (*.f64 (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) (/.f64 h l)) < -3.99999999999999982e-6Initial program 68.5%
Taylor expanded in M around 0
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
Simplified37.9%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
lift-*.f64N/A
associate-/l*N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-/.f6437.9
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lift-*.f64N/A
lower-*.f6438.5
Applied egg-rr38.5%
if -3.99999999999999982e-6 < (*.f64 (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) (/.f64 h l)) Initial program 88.9%
Taylor expanded in M around 0
Simplified96.8%
*-rgt-identity96.8
Applied egg-rr96.8%
d_m = (fabs.f64 d) (FPCore (w0 M D h l d_m) :precision binary64 (if (<= (* (pow (/ (* M D) (* 2.0 d_m)) 2.0) (/ h l)) -2e+98) (* w0 (fma (* D D) (/ (* -0.125 (* h (* M M))) (* l (* d_m d_m))) 1.0)) w0))
d_m = fabs(d);
double code(double w0, double M, double D, double h, double l, double d_m) {
double tmp;
if ((pow(((M * D) / (2.0 * d_m)), 2.0) * (h / l)) <= -2e+98) {
tmp = w0 * fma((D * D), ((-0.125 * (h * (M * M))) / (l * (d_m * d_m))), 1.0);
} else {
tmp = w0;
}
return tmp;
}
d_m = abs(d) function code(w0, M, D, h, l, d_m) tmp = 0.0 if (Float64((Float64(Float64(M * D) / Float64(2.0 * d_m)) ^ 2.0) * Float64(h / l)) <= -2e+98) tmp = Float64(w0 * fma(Float64(D * D), Float64(Float64(-0.125 * Float64(h * Float64(M * M))) / Float64(l * Float64(d_m * d_m))), 1.0)); else tmp = w0; end return tmp end
d_m = N[Abs[d], $MachinePrecision] code[w0_, M_, D_, h_, l_, d$95$m_] := If[LessEqual[N[(N[Power[N[(N[(M * D), $MachinePrecision] / N[(2.0 * d$95$m), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] * N[(h / l), $MachinePrecision]), $MachinePrecision], -2e+98], N[(w0 * N[(N[(D * D), $MachinePrecision] * N[(N[(-0.125 * N[(h * N[(M * M), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(l * N[(d$95$m * d$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], w0]
\begin{array}{l}
d_m = \left|d\right|
\\
\begin{array}{l}
\mathbf{if}\;{\left(\frac{M \cdot D}{2 \cdot d\_m}\right)}^{2} \cdot \frac{h}{\ell} \leq -2 \cdot 10^{+98}:\\
\;\;\;\;w0 \cdot \mathsf{fma}\left(D \cdot D, \frac{-0.125 \cdot \left(h \cdot \left(M \cdot M\right)\right)}{\ell \cdot \left(d\_m \cdot d\_m\right)}, 1\right)\\
\mathbf{else}:\\
\;\;\;\;w0\\
\end{array}
\end{array}
if (*.f64 (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) (/.f64 h l)) < -2e98Initial program 66.4%
Taylor expanded in M around 0
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f64N/A
associate-*r/N/A
lower-/.f64N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6435.5
Simplified35.5%
if -2e98 < (*.f64 (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) (/.f64 h l)) Initial program 89.2%
Taylor expanded in M around 0
Simplified94.7%
*-rgt-identity94.7
Applied egg-rr94.7%
Final simplification78.2%
d_m = (fabs.f64 d) (FPCore (w0 M D h l d_m) :precision binary64 (if (<= (* (pow (/ (* M D) (* 2.0 d_m)) 2.0) (/ h l)) -2e+98) (* (* D D) (/ (* -0.125 (* w0 (* h (* M M)))) (* l (* d_m d_m)))) w0))
d_m = fabs(d);
double code(double w0, double M, double D, double h, double l, double d_m) {
double tmp;
if ((pow(((M * D) / (2.0 * d_m)), 2.0) * (h / l)) <= -2e+98) {
tmp = (D * D) * ((-0.125 * (w0 * (h * (M * M)))) / (l * (d_m * d_m)));
} else {
tmp = w0;
}
return tmp;
}
d_m = abs(d)
real(8) function code(w0, m, d, h, l, d_m)
real(8), intent (in) :: w0
real(8), intent (in) :: m
real(8), intent (in) :: d
real(8), intent (in) :: h
real(8), intent (in) :: l
real(8), intent (in) :: d_m
real(8) :: tmp
if (((((m * d) / (2.0d0 * d_m)) ** 2.0d0) * (h / l)) <= (-2d+98)) then
tmp = (d * d) * (((-0.125d0) * (w0 * (h * (m * m)))) / (l * (d_m * d_m)))
else
tmp = w0
end if
code = tmp
end function
d_m = Math.abs(d);
public static double code(double w0, double M, double D, double h, double l, double d_m) {
double tmp;
if ((Math.pow(((M * D) / (2.0 * d_m)), 2.0) * (h / l)) <= -2e+98) {
tmp = (D * D) * ((-0.125 * (w0 * (h * (M * M)))) / (l * (d_m * d_m)));
} else {
tmp = w0;
}
return tmp;
}
d_m = math.fabs(d) def code(w0, M, D, h, l, d_m): tmp = 0 if (math.pow(((M * D) / (2.0 * d_m)), 2.0) * (h / l)) <= -2e+98: tmp = (D * D) * ((-0.125 * (w0 * (h * (M * M)))) / (l * (d_m * d_m))) else: tmp = w0 return tmp
d_m = abs(d) function code(w0, M, D, h, l, d_m) tmp = 0.0 if (Float64((Float64(Float64(M * D) / Float64(2.0 * d_m)) ^ 2.0) * Float64(h / l)) <= -2e+98) tmp = Float64(Float64(D * D) * Float64(Float64(-0.125 * Float64(w0 * Float64(h * Float64(M * M)))) / Float64(l * Float64(d_m * d_m)))); else tmp = w0; end return tmp end
d_m = abs(d); function tmp_2 = code(w0, M, D, h, l, d_m) tmp = 0.0; if (((((M * D) / (2.0 * d_m)) ^ 2.0) * (h / l)) <= -2e+98) tmp = (D * D) * ((-0.125 * (w0 * (h * (M * M)))) / (l * (d_m * d_m))); else tmp = w0; end tmp_2 = tmp; end
d_m = N[Abs[d], $MachinePrecision] code[w0_, M_, D_, h_, l_, d$95$m_] := If[LessEqual[N[(N[Power[N[(N[(M * D), $MachinePrecision] / N[(2.0 * d$95$m), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] * N[(h / l), $MachinePrecision]), $MachinePrecision], -2e+98], N[(N[(D * D), $MachinePrecision] * N[(N[(-0.125 * N[(w0 * N[(h * N[(M * M), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(l * N[(d$95$m * d$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], w0]
\begin{array}{l}
d_m = \left|d\right|
\\
\begin{array}{l}
\mathbf{if}\;{\left(\frac{M \cdot D}{2 \cdot d\_m}\right)}^{2} \cdot \frac{h}{\ell} \leq -2 \cdot 10^{+98}:\\
\;\;\;\;\left(D \cdot D\right) \cdot \frac{-0.125 \cdot \left(w0 \cdot \left(h \cdot \left(M \cdot M\right)\right)\right)}{\ell \cdot \left(d\_m \cdot d\_m\right)}\\
\mathbf{else}:\\
\;\;\;\;w0\\
\end{array}
\end{array}
if (*.f64 (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) (/.f64 h l)) < -2e98Initial program 66.4%
Taylor expanded in M around 0
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
Simplified39.6%
Taylor expanded in D around inf
*-commutativeN/A
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
associate-*r/N/A
lower-/.f64N/A
lower-*.f64N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6435.4
Simplified35.4%
if -2e98 < (*.f64 (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) (/.f64 h l)) Initial program 89.2%
Taylor expanded in M around 0
Simplified94.7%
*-rgt-identity94.7
Applied egg-rr94.7%
Final simplification78.2%
d_m = (fabs.f64 d) (FPCore (w0 M D h l d_m) :precision binary64 (if (<= (* M D) 4e-102) w0 (fma (* (* D -0.125) (/ (* M (* h (* M w0))) (* d_m (* d_m l)))) D w0)))
d_m = fabs(d);
double code(double w0, double M, double D, double h, double l, double d_m) {
double tmp;
if ((M * D) <= 4e-102) {
tmp = w0;
} else {
tmp = fma(((D * -0.125) * ((M * (h * (M * w0))) / (d_m * (d_m * l)))), D, w0);
}
return tmp;
}
d_m = abs(d) function code(w0, M, D, h, l, d_m) tmp = 0.0 if (Float64(M * D) <= 4e-102) tmp = w0; else tmp = fma(Float64(Float64(D * -0.125) * Float64(Float64(M * Float64(h * Float64(M * w0))) / Float64(d_m * Float64(d_m * l)))), D, w0); end return tmp end
d_m = N[Abs[d], $MachinePrecision] code[w0_, M_, D_, h_, l_, d$95$m_] := If[LessEqual[N[(M * D), $MachinePrecision], 4e-102], w0, N[(N[(N[(D * -0.125), $MachinePrecision] * N[(N[(M * N[(h * N[(M * w0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(d$95$m * N[(d$95$m * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * D + w0), $MachinePrecision]]
\begin{array}{l}
d_m = \left|d\right|
\\
\begin{array}{l}
\mathbf{if}\;M \cdot D \leq 4 \cdot 10^{-102}:\\
\;\;\;\;w0\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\left(D \cdot -0.125\right) \cdot \frac{M \cdot \left(h \cdot \left(M \cdot w0\right)\right)}{d\_m \cdot \left(d\_m \cdot \ell\right)}, D, w0\right)\\
\end{array}
\end{array}
if (*.f64 M D) < 3.99999999999999973e-102Initial program 85.0%
Taylor expanded in M around 0
Simplified76.4%
*-rgt-identity76.4
Applied egg-rr76.4%
if 3.99999999999999973e-102 < (*.f64 M D) Initial program 76.3%
Taylor expanded in M around 0
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
Simplified36.7%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
Applied egg-rr57.1%
Final simplification71.5%
d_m = (fabs.f64 d) (FPCore (w0 M D h l d_m) :precision binary64 w0)
d_m = fabs(d);
double code(double w0, double M, double D, double h, double l, double d_m) {
return w0;
}
d_m = abs(d)
real(8) function code(w0, m, d, h, l, d_m)
real(8), intent (in) :: w0
real(8), intent (in) :: m
real(8), intent (in) :: d
real(8), intent (in) :: h
real(8), intent (in) :: l
real(8), intent (in) :: d_m
code = w0
end function
d_m = Math.abs(d);
public static double code(double w0, double M, double D, double h, double l, double d_m) {
return w0;
}
d_m = math.fabs(d) def code(w0, M, D, h, l, d_m): return w0
d_m = abs(d) function code(w0, M, D, h, l, d_m) return w0 end
d_m = abs(d); function tmp = code(w0, M, D, h, l, d_m) tmp = w0; end
d_m = N[Abs[d], $MachinePrecision] code[w0_, M_, D_, h_, l_, d$95$m_] := w0
\begin{array}{l}
d_m = \left|d\right|
\\
w0
\end{array}
Initial program 82.8%
Taylor expanded in M around 0
Simplified69.8%
*-rgt-identity69.8
Applied egg-rr69.8%
herbie shell --seed 2024211
(FPCore (w0 M D h l d)
:name "Henrywood and Agarwal, Equation (9a)"
:precision binary64
(* w0 (sqrt (- 1.0 (* (pow (/ (* M D) (* 2.0 d)) 2.0) (/ h l))))))