
(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 15 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)
M_m = (fabs.f64 M)
NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function.
(FPCore (w0 M_m D_m h l d)
:precision binary64
(if (<= M_m 2e-90)
(*
w0
(sqrt
(fma
(/ (* M_m D_m) (* 2.0 d))
(/ (/ (* (* M_m D_m) h) (* 2.0 d)) (- l))
1.0)))
(*
w0
(sqrt
(+
1.0
(*
(/ (* (/ D_m d) (* (* M_m M_m) 0.25)) l)
(/ (/ D_m d) (/ -1.0 h))))))))D_m = fabs(D);
M_m = fabs(M);
assert(w0 < M_m && M_m < D_m && D_m < h && h < l && l < d);
double code(double w0, double M_m, double D_m, double h, double l, double d) {
double tmp;
if (M_m <= 2e-90) {
tmp = w0 * sqrt(fma(((M_m * D_m) / (2.0 * d)), ((((M_m * D_m) * h) / (2.0 * d)) / -l), 1.0));
} else {
tmp = w0 * sqrt((1.0 + ((((D_m / d) * ((M_m * M_m) * 0.25)) / l) * ((D_m / d) / (-1.0 / h)))));
}
return tmp;
}
D_m = abs(D) M_m = abs(M) w0, M_m, D_m, h, l, d = sort([w0, M_m, D_m, h, l, d]) function code(w0, M_m, D_m, h, l, d) tmp = 0.0 if (M_m <= 2e-90) tmp = Float64(w0 * sqrt(fma(Float64(Float64(M_m * D_m) / Float64(2.0 * d)), Float64(Float64(Float64(Float64(M_m * D_m) * h) / Float64(2.0 * d)) / Float64(-l)), 1.0))); else tmp = Float64(w0 * sqrt(Float64(1.0 + Float64(Float64(Float64(Float64(D_m / d) * Float64(Float64(M_m * M_m) * 0.25)) / l) * Float64(Float64(D_m / d) / Float64(-1.0 / h)))))); end return tmp end
D_m = N[Abs[D], $MachinePrecision] M_m = N[Abs[M], $MachinePrecision] NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function. code[w0_, M$95$m_, D$95$m_, h_, l_, d_] := If[LessEqual[M$95$m, 2e-90], N[(w0 * N[Sqrt[N[(N[(N[(M$95$m * D$95$m), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision] * N[(N[(N[(N[(M$95$m * D$95$m), $MachinePrecision] * h), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision] / (-l)), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(w0 * N[Sqrt[N[(1.0 + N[(N[(N[(N[(D$95$m / d), $MachinePrecision] * N[(N[(M$95$m * M$95$m), $MachinePrecision] * 0.25), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision] * N[(N[(D$95$m / d), $MachinePrecision] / N[(-1.0 / h), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
D_m = \left|D\right|
\\
M_m = \left|M\right|
\\
[w0, M_m, D_m, h, l, d] = \mathsf{sort}([w0, M_m, D_m, h, l, d])\\
\\
\begin{array}{l}
\mathbf{if}\;M\_m \leq 2 \cdot 10^{-90}:\\
\;\;\;\;w0 \cdot \sqrt{\mathsf{fma}\left(\frac{M\_m \cdot D\_m}{2 \cdot d}, \frac{\frac{\left(M\_m \cdot D\_m\right) \cdot h}{2 \cdot d}}{-\ell}, 1\right)}\\
\mathbf{else}:\\
\;\;\;\;w0 \cdot \sqrt{1 + \frac{\frac{D\_m}{d} \cdot \left(\left(M\_m \cdot M\_m\right) \cdot 0.25\right)}{\ell} \cdot \frac{\frac{D\_m}{d}}{\frac{-1}{h}}}\\
\end{array}
\end{array}
if M < 1.99999999999999999e-90Initial program 82.9%
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-pow.f64N/A
lift-/.f64N/A
lift-*.f64N/A
sub-negN/A
+-commutativeN/A
Applied egg-rr90.3%
if 1.99999999999999999e-90 < M Initial program 77.1%
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-pow.f64N/A
clear-numN/A
un-div-invN/A
lift-pow.f64N/A
unpow2N/A
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
associate-*r*N/A
div-invN/A
times-fracN/A
lower-*.f64N/A
Applied egg-rr68.4%
Final simplification84.5%
D_m = (fabs.f64 D)
M_m = (fabs.f64 M)
NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function.
(FPCore (w0 M_m D_m h l d)
:precision binary64
(let* ((t_0 (* (pow (/ (* M_m D_m) (* 2.0 d)) 2.0) (/ h l))))
(if (<= t_0 -2e+163)
(* D_m (* w0 (sqrt (/ (* M_m (* -0.25 (* M_m h))) (* d (* d l))))))
(if (<= t_0 -4e-5)
(*
w0
(sqrt
(fma (* -0.25 (/ h (* d l))) (* M_m (/ (* D_m (* M_m D_m)) d)) 1.0)))
w0))))D_m = fabs(D);
M_m = fabs(M);
assert(w0 < M_m && M_m < D_m && D_m < h && h < l && l < d);
double code(double w0, double M_m, double D_m, double h, double l, double d) {
double t_0 = pow(((M_m * D_m) / (2.0 * d)), 2.0) * (h / l);
double tmp;
if (t_0 <= -2e+163) {
tmp = D_m * (w0 * sqrt(((M_m * (-0.25 * (M_m * h))) / (d * (d * l)))));
} else if (t_0 <= -4e-5) {
tmp = w0 * sqrt(fma((-0.25 * (h / (d * l))), (M_m * ((D_m * (M_m * D_m)) / d)), 1.0));
} else {
tmp = w0;
}
return tmp;
}
D_m = abs(D) M_m = abs(M) w0, M_m, D_m, h, l, d = sort([w0, M_m, D_m, h, l, d]) function code(w0, M_m, D_m, h, l, d) t_0 = Float64((Float64(Float64(M_m * D_m) / Float64(2.0 * d)) ^ 2.0) * Float64(h / l)) tmp = 0.0 if (t_0 <= -2e+163) tmp = Float64(D_m * Float64(w0 * sqrt(Float64(Float64(M_m * Float64(-0.25 * Float64(M_m * h))) / Float64(d * Float64(d * l)))))); elseif (t_0 <= -4e-5) tmp = Float64(w0 * sqrt(fma(Float64(-0.25 * Float64(h / Float64(d * l))), Float64(M_m * Float64(Float64(D_m * Float64(M_m * D_m)) / d)), 1.0))); else tmp = w0; end return tmp end
D_m = N[Abs[D], $MachinePrecision]
M_m = N[Abs[M], $MachinePrecision]
NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function.
code[w0_, M$95$m_, D$95$m_, h_, l_, d_] := Block[{t$95$0 = N[(N[Power[N[(N[(M$95$m * D$95$m), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] * N[(h / l), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, -2e+163], N[(D$95$m * N[(w0 * N[Sqrt[N[(N[(M$95$m * N[(-0.25 * N[(M$95$m * h), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(d * N[(d * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, -4e-5], N[(w0 * N[Sqrt[N[(N[(-0.25 * N[(h / N[(d * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(M$95$m * N[(N[(D$95$m * N[(M$95$m * D$95$m), $MachinePrecision]), $MachinePrecision] / d), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], w0]]]
\begin{array}{l}
D_m = \left|D\right|
\\
M_m = \left|M\right|
\\
[w0, M_m, D_m, h, l, d] = \mathsf{sort}([w0, M_m, D_m, h, l, d])\\
\\
\begin{array}{l}
t_0 := {\left(\frac{M\_m \cdot D\_m}{2 \cdot d}\right)}^{2} \cdot \frac{h}{\ell}\\
\mathbf{if}\;t\_0 \leq -2 \cdot 10^{+163}:\\
\;\;\;\;D\_m \cdot \left(w0 \cdot \sqrt{\frac{M\_m \cdot \left(-0.25 \cdot \left(M\_m \cdot h\right)\right)}{d \cdot \left(d \cdot \ell\right)}}\right)\\
\mathbf{elif}\;t\_0 \leq -4 \cdot 10^{-5}:\\
\;\;\;\;w0 \cdot \sqrt{\mathsf{fma}\left(-0.25 \cdot \frac{h}{d \cdot \ell}, M\_m \cdot \frac{D\_m \cdot \left(M\_m \cdot D\_m\right)}{d}, 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)) < -1.9999999999999999e163Initial program 60.7%
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-pow.f64N/A
lift-/.f64N/A
lift-*.f64N/A
sub-negN/A
+-commutativeN/A
Applied egg-rr69.8%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
distribute-frac-neg2N/A
distribute-frac-negN/A
lift-/.f64N/A
distribute-neg-frac2N/A
associate-/r*N/A
lift-*.f64N/A
distribute-lft-neg-inN/A
metadata-evalN/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f64N/A
Applied egg-rr65.7%
Taylor expanded in M 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
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6448.7
Simplified48.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-sqrt.f64N/A
*-commutativeN/A
Applied egg-rr28.6%
if -1.9999999999999999e163 < (*.f64 (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) (/.f64 h l)) < -4.00000000000000033e-5Initial program 99.5%
Taylor expanded in w0 around 0
lower-*.f64N/A
lower-sqrt.f64N/A
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
*-commutativeN/A
Simplified37.8%
lift-*.f64N/A
associate-*r*N/A
lift-*.f64N/A
times-fracN/A
lift-/.f64N/A
lower-*.f64N/A
lower-/.f64N/A
lower-*.f6449.4
Applied egg-rr49.4%
Applied egg-rr88.1%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-*.f64N/A
lift-/.f64N/A
*-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
associate-*r*N/A
lower-fma.f64N/A
Applied egg-rr82.5%
if -4.00000000000000033e-5 < (*.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
Simplified97.0%
*-rgt-identity97.0
Applied egg-rr97.0%
Final simplification76.9%
D_m = (fabs.f64 D)
M_m = (fabs.f64 M)
NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function.
(FPCore (w0 M_m D_m h l d)
:precision binary64
(let* ((t_0 (* (pow (/ (* M_m D_m) (* 2.0 d)) 2.0) (/ h l))))
(if (<= t_0 -2e+163)
(* D_m (* w0 (sqrt (/ (* M_m (* -0.25 (* M_m h))) (* d (* d l))))))
(if (<= t_0 -40.0)
(*
w0
(sqrt (* (* -0.25 (/ h (* d l))) (* M_m (/ (* D_m (* M_m D_m)) d)))))
w0))))D_m = fabs(D);
M_m = fabs(M);
assert(w0 < M_m && M_m < D_m && D_m < h && h < l && l < d);
double code(double w0, double M_m, double D_m, double h, double l, double d) {
double t_0 = pow(((M_m * D_m) / (2.0 * d)), 2.0) * (h / l);
double tmp;
if (t_0 <= -2e+163) {
tmp = D_m * (w0 * sqrt(((M_m * (-0.25 * (M_m * h))) / (d * (d * l)))));
} else if (t_0 <= -40.0) {
tmp = w0 * sqrt(((-0.25 * (h / (d * l))) * (M_m * ((D_m * (M_m * D_m)) / d))));
} else {
tmp = w0;
}
return tmp;
}
D_m = abs(d)
M_m = abs(m)
NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function.
real(8) function code(w0, m_m, d_m, h, l, d)
real(8), intent (in) :: w0
real(8), intent (in) :: m_m
real(8), intent (in) :: d_m
real(8), intent (in) :: h
real(8), intent (in) :: l
real(8), intent (in) :: d
real(8) :: t_0
real(8) :: tmp
t_0 = (((m_m * d_m) / (2.0d0 * d)) ** 2.0d0) * (h / l)
if (t_0 <= (-2d+163)) then
tmp = d_m * (w0 * sqrt(((m_m * ((-0.25d0) * (m_m * h))) / (d * (d * l)))))
else if (t_0 <= (-40.0d0)) then
tmp = w0 * sqrt((((-0.25d0) * (h / (d * l))) * (m_m * ((d_m * (m_m * d_m)) / d))))
else
tmp = w0
end if
code = tmp
end function
D_m = Math.abs(D);
M_m = Math.abs(M);
assert w0 < M_m && M_m < D_m && D_m < h && h < l && l < d;
public static double code(double w0, double M_m, double D_m, double h, double l, double d) {
double t_0 = Math.pow(((M_m * D_m) / (2.0 * d)), 2.0) * (h / l);
double tmp;
if (t_0 <= -2e+163) {
tmp = D_m * (w0 * Math.sqrt(((M_m * (-0.25 * (M_m * h))) / (d * (d * l)))));
} else if (t_0 <= -40.0) {
tmp = w0 * Math.sqrt(((-0.25 * (h / (d * l))) * (M_m * ((D_m * (M_m * D_m)) / d))));
} else {
tmp = w0;
}
return tmp;
}
D_m = math.fabs(D) M_m = math.fabs(M) [w0, M_m, D_m, h, l, d] = sort([w0, M_m, D_m, h, l, d]) def code(w0, M_m, D_m, h, l, d): t_0 = math.pow(((M_m * D_m) / (2.0 * d)), 2.0) * (h / l) tmp = 0 if t_0 <= -2e+163: tmp = D_m * (w0 * math.sqrt(((M_m * (-0.25 * (M_m * h))) / (d * (d * l))))) elif t_0 <= -40.0: tmp = w0 * math.sqrt(((-0.25 * (h / (d * l))) * (M_m * ((D_m * (M_m * D_m)) / d)))) else: tmp = w0 return tmp
D_m = abs(D) M_m = abs(M) w0, M_m, D_m, h, l, d = sort([w0, M_m, D_m, h, l, d]) function code(w0, M_m, D_m, h, l, d) t_0 = Float64((Float64(Float64(M_m * D_m) / Float64(2.0 * d)) ^ 2.0) * Float64(h / l)) tmp = 0.0 if (t_0 <= -2e+163) tmp = Float64(D_m * Float64(w0 * sqrt(Float64(Float64(M_m * Float64(-0.25 * Float64(M_m * h))) / Float64(d * Float64(d * l)))))); elseif (t_0 <= -40.0) tmp = Float64(w0 * sqrt(Float64(Float64(-0.25 * Float64(h / Float64(d * l))) * Float64(M_m * Float64(Float64(D_m * Float64(M_m * D_m)) / d))))); else tmp = w0; end return tmp end
D_m = abs(D);
M_m = abs(M);
w0, M_m, D_m, h, l, d = num2cell(sort([w0, M_m, D_m, h, l, d])){:}
function tmp_2 = code(w0, M_m, D_m, h, l, d)
t_0 = (((M_m * D_m) / (2.0 * d)) ^ 2.0) * (h / l);
tmp = 0.0;
if (t_0 <= -2e+163)
tmp = D_m * (w0 * sqrt(((M_m * (-0.25 * (M_m * h))) / (d * (d * l)))));
elseif (t_0 <= -40.0)
tmp = w0 * sqrt(((-0.25 * (h / (d * l))) * (M_m * ((D_m * (M_m * D_m)) / d))));
else
tmp = w0;
end
tmp_2 = tmp;
end
D_m = N[Abs[D], $MachinePrecision]
M_m = N[Abs[M], $MachinePrecision]
NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function.
code[w0_, M$95$m_, D$95$m_, h_, l_, d_] := Block[{t$95$0 = N[(N[Power[N[(N[(M$95$m * D$95$m), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] * N[(h / l), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, -2e+163], N[(D$95$m * N[(w0 * N[Sqrt[N[(N[(M$95$m * N[(-0.25 * N[(M$95$m * h), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(d * N[(d * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, -40.0], N[(w0 * N[Sqrt[N[(N[(-0.25 * N[(h / N[(d * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(M$95$m * N[(N[(D$95$m * N[(M$95$m * D$95$m), $MachinePrecision]), $MachinePrecision] / d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], w0]]]
\begin{array}{l}
D_m = \left|D\right|
\\
M_m = \left|M\right|
\\
[w0, M_m, D_m, h, l, d] = \mathsf{sort}([w0, M_m, D_m, h, l, d])\\
\\
\begin{array}{l}
t_0 := {\left(\frac{M\_m \cdot D\_m}{2 \cdot d}\right)}^{2} \cdot \frac{h}{\ell}\\
\mathbf{if}\;t\_0 \leq -2 \cdot 10^{+163}:\\
\;\;\;\;D\_m \cdot \left(w0 \cdot \sqrt{\frac{M\_m \cdot \left(-0.25 \cdot \left(M\_m \cdot h\right)\right)}{d \cdot \left(d \cdot \ell\right)}}\right)\\
\mathbf{elif}\;t\_0 \leq -40:\\
\;\;\;\;w0 \cdot \sqrt{\left(-0.25 \cdot \frac{h}{d \cdot \ell}\right) \cdot \left(M\_m \cdot \frac{D\_m \cdot \left(M\_m \cdot D\_m\right)}{d}\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)) < -1.9999999999999999e163Initial program 60.7%
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-pow.f64N/A
lift-/.f64N/A
lift-*.f64N/A
sub-negN/A
+-commutativeN/A
Applied egg-rr69.8%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
distribute-frac-neg2N/A
distribute-frac-negN/A
lift-/.f64N/A
distribute-neg-frac2N/A
associate-/r*N/A
lift-*.f64N/A
distribute-lft-neg-inN/A
metadata-evalN/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f64N/A
Applied egg-rr65.7%
Taylor expanded in M 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
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6448.7
Simplified48.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-sqrt.f64N/A
*-commutativeN/A
Applied egg-rr28.6%
if -1.9999999999999999e163 < (*.f64 (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) (/.f64 h l)) < -40Initial program 99.4%
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-pow.f64N/A
lift-/.f64N/A
lift-*.f64N/A
sub-negN/A
+-commutativeN/A
Applied egg-rr90.8%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
distribute-frac-neg2N/A
distribute-frac-negN/A
lift-/.f64N/A
distribute-neg-frac2N/A
associate-/r*N/A
lift-*.f64N/A
distribute-lft-neg-inN/A
metadata-evalN/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f64N/A
Applied egg-rr99.8%
Taylor expanded in M 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
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6419.8
Simplified19.8%
Applied egg-rr63.4%
if -40 < (*.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
Simplified96.7%
*-rgt-identity96.7
Applied egg-rr96.7%
Final simplification76.0%
D_m = (fabs.f64 D)
M_m = (fabs.f64 M)
NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function.
(FPCore (w0 M_m D_m h l d)
:precision binary64
(let* ((t_0 (/ (* M_m D_m) (* 2.0 d))))
(if (<= (* (pow t_0 2.0) (/ h l)) 2e-14)
(* w0 (sqrt (fma t_0 (* (/ h l) (/ (* M_m D_m) (* d -2.0))) 1.0)))
(*
w0
(sqrt
(-
1.0
(* (/ D_m d) (* (/ D_m d) (/ (* h (* (* M_m M_m) 0.25)) l)))))))))D_m = fabs(D);
M_m = fabs(M);
assert(w0 < M_m && M_m < D_m && D_m < h && h < l && l < d);
double code(double w0, double M_m, double D_m, double h, double l, double d) {
double t_0 = (M_m * D_m) / (2.0 * d);
double tmp;
if ((pow(t_0, 2.0) * (h / l)) <= 2e-14) {
tmp = w0 * sqrt(fma(t_0, ((h / l) * ((M_m * D_m) / (d * -2.0))), 1.0));
} else {
tmp = w0 * sqrt((1.0 - ((D_m / d) * ((D_m / d) * ((h * ((M_m * M_m) * 0.25)) / l)))));
}
return tmp;
}
D_m = abs(D) M_m = abs(M) w0, M_m, D_m, h, l, d = sort([w0, M_m, D_m, h, l, d]) function code(w0, M_m, D_m, h, l, d) t_0 = Float64(Float64(M_m * D_m) / Float64(2.0 * d)) tmp = 0.0 if (Float64((t_0 ^ 2.0) * Float64(h / l)) <= 2e-14) tmp = Float64(w0 * sqrt(fma(t_0, Float64(Float64(h / l) * Float64(Float64(M_m * D_m) / Float64(d * -2.0))), 1.0))); else tmp = Float64(w0 * sqrt(Float64(1.0 - Float64(Float64(D_m / d) * Float64(Float64(D_m / d) * Float64(Float64(h * Float64(Float64(M_m * M_m) * 0.25)) / l)))))); end return tmp end
D_m = N[Abs[D], $MachinePrecision]
M_m = N[Abs[M], $MachinePrecision]
NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function.
code[w0_, M$95$m_, D$95$m_, h_, l_, d_] := Block[{t$95$0 = N[(N[(M$95$m * D$95$m), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(N[Power[t$95$0, 2.0], $MachinePrecision] * N[(h / l), $MachinePrecision]), $MachinePrecision], 2e-14], N[(w0 * N[Sqrt[N[(t$95$0 * N[(N[(h / l), $MachinePrecision] * N[(N[(M$95$m * D$95$m), $MachinePrecision] / N[(d * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(w0 * N[Sqrt[N[(1.0 - N[(N[(D$95$m / d), $MachinePrecision] * N[(N[(D$95$m / d), $MachinePrecision] * N[(N[(h * N[(N[(M$95$m * M$95$m), $MachinePrecision] * 0.25), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
D_m = \left|D\right|
\\
M_m = \left|M\right|
\\
[w0, M_m, D_m, h, l, d] = \mathsf{sort}([w0, M_m, D_m, h, l, d])\\
\\
\begin{array}{l}
t_0 := \frac{M\_m \cdot D\_m}{2 \cdot d}\\
\mathbf{if}\;{t\_0}^{2} \cdot \frac{h}{\ell} \leq 2 \cdot 10^{-14}:\\
\;\;\;\;w0 \cdot \sqrt{\mathsf{fma}\left(t\_0, \frac{h}{\ell} \cdot \frac{M\_m \cdot D\_m}{d \cdot -2}, 1\right)}\\
\mathbf{else}:\\
\;\;\;\;w0 \cdot \sqrt{1 - \frac{D\_m}{d} \cdot \left(\frac{D\_m}{d} \cdot \frac{h \cdot \left(\left(M\_m \cdot M\_m\right) \cdot 0.25\right)}{\ell}\right)}\\
\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)) < 2e-14Initial program 87.9%
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-pow.f64N/A
lift-/.f64N/A
lift-*.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
distribute-lft-neg-inN/A
lift-pow.f64N/A
unpow2N/A
distribute-rgt-neg-inN/A
associate-*l*N/A
Applied egg-rr90.3%
if 2e-14 < (*.f64 (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) (/.f64 h l)) Initial program 0.0%
times-fracN/A
unpow-prod-downN/A
*-commutativeN/A
lower-*.f64N/A
pow2N/A
associate-*r/N/A
lower-/.f64N/A
lower-*.f64N/A
lower-/.f64N/A
div-invN/A
metadata-evalN/A
unpow-prod-downN/A
metadata-evalN/A
metadata-evalN/A
lower-*.f64N/A
pow2N/A
lower-*.f64N/A
metadata-eval0.0
Applied egg-rr0.0%
lift-/.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
associate-*l*N/A
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
lift-/.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
lower-*.f6438.1
Applied egg-rr38.1%
Final simplification86.4%
D_m = (fabs.f64 D)
M_m = (fabs.f64 M)
NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function.
(FPCore (w0 M_m D_m h l d)
:precision binary64
(if (<= (* (pow (/ (* M_m D_m) (* 2.0 d)) 2.0) (/ h l)) -4e-5)
(*
w0
(sqrt
(fma
(* D_m (/ M_m (* 2.0 d)))
(* h (/ (* M_m D_m) (* l (* d -2.0))))
1.0)))
w0))D_m = fabs(D);
M_m = fabs(M);
assert(w0 < M_m && M_m < D_m && D_m < h && h < l && l < d);
double code(double w0, double M_m, double D_m, double h, double l, double d) {
double tmp;
if ((pow(((M_m * D_m) / (2.0 * d)), 2.0) * (h / l)) <= -4e-5) {
tmp = w0 * sqrt(fma((D_m * (M_m / (2.0 * d))), (h * ((M_m * D_m) / (l * (d * -2.0)))), 1.0));
} else {
tmp = w0;
}
return tmp;
}
D_m = abs(D) M_m = abs(M) w0, M_m, D_m, h, l, d = sort([w0, M_m, D_m, h, l, d]) function code(w0, M_m, D_m, h, l, d) tmp = 0.0 if (Float64((Float64(Float64(M_m * D_m) / Float64(2.0 * d)) ^ 2.0) * Float64(h / l)) <= -4e-5) tmp = Float64(w0 * sqrt(fma(Float64(D_m * Float64(M_m / Float64(2.0 * d))), Float64(h * Float64(Float64(M_m * D_m) / Float64(l * Float64(d * -2.0)))), 1.0))); else tmp = w0; end return tmp end
D_m = N[Abs[D], $MachinePrecision] M_m = N[Abs[M], $MachinePrecision] NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function. code[w0_, M$95$m_, D$95$m_, h_, l_, d_] := If[LessEqual[N[(N[Power[N[(N[(M$95$m * D$95$m), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] * N[(h / l), $MachinePrecision]), $MachinePrecision], -4e-5], N[(w0 * N[Sqrt[N[(N[(D$95$m * N[(M$95$m / N[(2.0 * d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(h * N[(N[(M$95$m * D$95$m), $MachinePrecision] / N[(l * N[(d * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], w0]
\begin{array}{l}
D_m = \left|D\right|
\\
M_m = \left|M\right|
\\
[w0, M_m, D_m, h, l, d] = \mathsf{sort}([w0, M_m, D_m, h, l, d])\\
\\
\begin{array}{l}
\mathbf{if}\;{\left(\frac{M\_m \cdot D\_m}{2 \cdot d}\right)}^{2} \cdot \frac{h}{\ell} \leq -4 \cdot 10^{-5}:\\
\;\;\;\;w0 \cdot \sqrt{\mathsf{fma}\left(D\_m \cdot \frac{M\_m}{2 \cdot d}, h \cdot \frac{M\_m \cdot D\_m}{\ell \cdot \left(d \cdot -2\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)) < -4.00000000000000033e-5Initial program 65.8%
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-pow.f64N/A
lift-/.f64N/A
lift-*.f64N/A
sub-negN/A
+-commutativeN/A
Applied egg-rr72.7%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
distribute-frac-neg2N/A
distribute-frac-negN/A
lift-/.f64N/A
distribute-neg-frac2N/A
associate-/r*N/A
lift-*.f64N/A
distribute-lft-neg-inN/A
metadata-evalN/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f64N/A
Applied egg-rr70.1%
*-commutativeN/A
lift-*.f64N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f6467.9
Applied egg-rr67.9%
if -4.00000000000000033e-5 < (*.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
Simplified97.0%
*-rgt-identity97.0
Applied egg-rr97.0%
D_m = (fabs.f64 D)
M_m = (fabs.f64 M)
NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function.
(FPCore (w0 M_m D_m h l d)
:precision binary64
(if (<= (* (pow (/ (* M_m D_m) (* 2.0 d)) 2.0) (/ h l)) -4e-5)
(*
w0
(sqrt (fma (/ (* -0.25 (* (* M_m D_m) (* M_m D_m))) d) (/ h (* d l)) 1.0)))
w0))D_m = fabs(D);
M_m = fabs(M);
assert(w0 < M_m && M_m < D_m && D_m < h && h < l && l < d);
double code(double w0, double M_m, double D_m, double h, double l, double d) {
double tmp;
if ((pow(((M_m * D_m) / (2.0 * d)), 2.0) * (h / l)) <= -4e-5) {
tmp = w0 * sqrt(fma(((-0.25 * ((M_m * D_m) * (M_m * D_m))) / d), (h / (d * l)), 1.0));
} else {
tmp = w0;
}
return tmp;
}
D_m = abs(D) M_m = abs(M) w0, M_m, D_m, h, l, d = sort([w0, M_m, D_m, h, l, d]) function code(w0, M_m, D_m, h, l, d) tmp = 0.0 if (Float64((Float64(Float64(M_m * D_m) / Float64(2.0 * d)) ^ 2.0) * Float64(h / l)) <= -4e-5) tmp = Float64(w0 * sqrt(fma(Float64(Float64(-0.25 * Float64(Float64(M_m * D_m) * Float64(M_m * D_m))) / d), Float64(h / Float64(d * l)), 1.0))); else tmp = w0; end return tmp end
D_m = N[Abs[D], $MachinePrecision] M_m = N[Abs[M], $MachinePrecision] NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function. code[w0_, M$95$m_, D$95$m_, h_, l_, d_] := If[LessEqual[N[(N[Power[N[(N[(M$95$m * D$95$m), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] * N[(h / l), $MachinePrecision]), $MachinePrecision], -4e-5], N[(w0 * N[Sqrt[N[(N[(N[(-0.25 * N[(N[(M$95$m * D$95$m), $MachinePrecision] * N[(M$95$m * D$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / d), $MachinePrecision] * N[(h / N[(d * l), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], w0]
\begin{array}{l}
D_m = \left|D\right|
\\
M_m = \left|M\right|
\\
[w0, M_m, D_m, h, l, d] = \mathsf{sort}([w0, M_m, D_m, h, l, d])\\
\\
\begin{array}{l}
\mathbf{if}\;{\left(\frac{M\_m \cdot D\_m}{2 \cdot d}\right)}^{2} \cdot \frac{h}{\ell} \leq -4 \cdot 10^{-5}:\\
\;\;\;\;w0 \cdot \sqrt{\mathsf{fma}\left(\frac{-0.25 \cdot \left(\left(M\_m \cdot D\_m\right) \cdot \left(M\_m \cdot D\_m\right)\right)}{d}, \frac{h}{d \cdot \ell}, 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)) < -4.00000000000000033e-5Initial program 65.8%
Taylor expanded in w0 around 0
lower-*.f64N/A
lower-sqrt.f64N/A
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
*-commutativeN/A
Simplified44.9%
lift-*.f64N/A
associate-*r*N/A
lift-*.f64N/A
times-fracN/A
lift-/.f64N/A
lower-*.f64N/A
lower-/.f64N/A
lower-*.f6449.2
Applied egg-rr49.2%
Applied egg-rr63.9%
if -4.00000000000000033e-5 < (*.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
Simplified97.0%
*-rgt-identity97.0
Applied egg-rr97.0%
D_m = (fabs.f64 D) M_m = (fabs.f64 M) NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function. (FPCore (w0 M_m D_m h l d) :precision binary64 (if (<= (* (pow (/ (* M_m D_m) (* 2.0 d)) 2.0) (/ h l)) -40.0) (* w0 (sqrt (* (/ (* -0.25 (* (* M_m D_m) (* M_m D_m))) d) (/ h (* d l))))) w0))
D_m = fabs(D);
M_m = fabs(M);
assert(w0 < M_m && M_m < D_m && D_m < h && h < l && l < d);
double code(double w0, double M_m, double D_m, double h, double l, double d) {
double tmp;
if ((pow(((M_m * D_m) / (2.0 * d)), 2.0) * (h / l)) <= -40.0) {
tmp = w0 * sqrt((((-0.25 * ((M_m * D_m) * (M_m * D_m))) / d) * (h / (d * l))));
} else {
tmp = w0;
}
return tmp;
}
D_m = abs(d)
M_m = abs(m)
NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function.
real(8) function code(w0, m_m, d_m, h, l, d)
real(8), intent (in) :: w0
real(8), intent (in) :: m_m
real(8), intent (in) :: d_m
real(8), intent (in) :: h
real(8), intent (in) :: l
real(8), intent (in) :: d
real(8) :: tmp
if (((((m_m * d_m) / (2.0d0 * d)) ** 2.0d0) * (h / l)) <= (-40.0d0)) then
tmp = w0 * sqrt(((((-0.25d0) * ((m_m * d_m) * (m_m * d_m))) / d) * (h / (d * l))))
else
tmp = w0
end if
code = tmp
end function
D_m = Math.abs(D);
M_m = Math.abs(M);
assert w0 < M_m && M_m < D_m && D_m < h && h < l && l < d;
public static double code(double w0, double M_m, double D_m, double h, double l, double d) {
double tmp;
if ((Math.pow(((M_m * D_m) / (2.0 * d)), 2.0) * (h / l)) <= -40.0) {
tmp = w0 * Math.sqrt((((-0.25 * ((M_m * D_m) * (M_m * D_m))) / d) * (h / (d * l))));
} else {
tmp = w0;
}
return tmp;
}
D_m = math.fabs(D) M_m = math.fabs(M) [w0, M_m, D_m, h, l, d] = sort([w0, M_m, D_m, h, l, d]) def code(w0, M_m, D_m, h, l, d): tmp = 0 if (math.pow(((M_m * D_m) / (2.0 * d)), 2.0) * (h / l)) <= -40.0: tmp = w0 * math.sqrt((((-0.25 * ((M_m * D_m) * (M_m * D_m))) / d) * (h / (d * l)))) else: tmp = w0 return tmp
D_m = abs(D) M_m = abs(M) w0, M_m, D_m, h, l, d = sort([w0, M_m, D_m, h, l, d]) function code(w0, M_m, D_m, h, l, d) tmp = 0.0 if (Float64((Float64(Float64(M_m * D_m) / Float64(2.0 * d)) ^ 2.0) * Float64(h / l)) <= -40.0) tmp = Float64(w0 * sqrt(Float64(Float64(Float64(-0.25 * Float64(Float64(M_m * D_m) * Float64(M_m * D_m))) / d) * Float64(h / Float64(d * l))))); else tmp = w0; end return tmp end
D_m = abs(D);
M_m = abs(M);
w0, M_m, D_m, h, l, d = num2cell(sort([w0, M_m, D_m, h, l, d])){:}
function tmp_2 = code(w0, M_m, D_m, h, l, d)
tmp = 0.0;
if (((((M_m * D_m) / (2.0 * d)) ^ 2.0) * (h / l)) <= -40.0)
tmp = w0 * sqrt((((-0.25 * ((M_m * D_m) * (M_m * D_m))) / d) * (h / (d * l))));
else
tmp = w0;
end
tmp_2 = tmp;
end
D_m = N[Abs[D], $MachinePrecision] M_m = N[Abs[M], $MachinePrecision] NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function. code[w0_, M$95$m_, D$95$m_, h_, l_, d_] := If[LessEqual[N[(N[Power[N[(N[(M$95$m * D$95$m), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] * N[(h / l), $MachinePrecision]), $MachinePrecision], -40.0], N[(w0 * N[Sqrt[N[(N[(N[(-0.25 * N[(N[(M$95$m * D$95$m), $MachinePrecision] * N[(M$95$m * D$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / d), $MachinePrecision] * N[(h / N[(d * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], w0]
\begin{array}{l}
D_m = \left|D\right|
\\
M_m = \left|M\right|
\\
[w0, M_m, D_m, h, l, d] = \mathsf{sort}([w0, M_m, D_m, h, l, d])\\
\\
\begin{array}{l}
\mathbf{if}\;{\left(\frac{M\_m \cdot D\_m}{2 \cdot d}\right)}^{2} \cdot \frac{h}{\ell} \leq -40:\\
\;\;\;\;w0 \cdot \sqrt{\frac{-0.25 \cdot \left(\left(M\_m \cdot D\_m\right) \cdot \left(M\_m \cdot D\_m\right)\right)}{d} \cdot \frac{h}{d \cdot \ell}}\\
\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)) < -40Initial program 65.4%
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-*.f6442.7
Simplified42.7%
Applied egg-rr61.5%
if -40 < (*.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
Simplified96.7%
*-rgt-identity96.7
Applied egg-rr96.7%
D_m = (fabs.f64 D) M_m = (fabs.f64 M) NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function. (FPCore (w0 M_m D_m h l d) :precision binary64 (if (<= (* (pow (/ (* M_m D_m) (* 2.0 d)) 2.0) (/ h l)) -40.0) (* D_m (* w0 (sqrt (/ (* M_m (* -0.25 (* M_m h))) (* d (* d l)))))) w0))
D_m = fabs(D);
M_m = fabs(M);
assert(w0 < M_m && M_m < D_m && D_m < h && h < l && l < d);
double code(double w0, double M_m, double D_m, double h, double l, double d) {
double tmp;
if ((pow(((M_m * D_m) / (2.0 * d)), 2.0) * (h / l)) <= -40.0) {
tmp = D_m * (w0 * sqrt(((M_m * (-0.25 * (M_m * h))) / (d * (d * l)))));
} else {
tmp = w0;
}
return tmp;
}
D_m = abs(d)
M_m = abs(m)
NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function.
real(8) function code(w0, m_m, d_m, h, l, d)
real(8), intent (in) :: w0
real(8), intent (in) :: m_m
real(8), intent (in) :: d_m
real(8), intent (in) :: h
real(8), intent (in) :: l
real(8), intent (in) :: d
real(8) :: tmp
if (((((m_m * d_m) / (2.0d0 * d)) ** 2.0d0) * (h / l)) <= (-40.0d0)) then
tmp = d_m * (w0 * sqrt(((m_m * ((-0.25d0) * (m_m * h))) / (d * (d * l)))))
else
tmp = w0
end if
code = tmp
end function
D_m = Math.abs(D);
M_m = Math.abs(M);
assert w0 < M_m && M_m < D_m && D_m < h && h < l && l < d;
public static double code(double w0, double M_m, double D_m, double h, double l, double d) {
double tmp;
if ((Math.pow(((M_m * D_m) / (2.0 * d)), 2.0) * (h / l)) <= -40.0) {
tmp = D_m * (w0 * Math.sqrt(((M_m * (-0.25 * (M_m * h))) / (d * (d * l)))));
} else {
tmp = w0;
}
return tmp;
}
D_m = math.fabs(D) M_m = math.fabs(M) [w0, M_m, D_m, h, l, d] = sort([w0, M_m, D_m, h, l, d]) def code(w0, M_m, D_m, h, l, d): tmp = 0 if (math.pow(((M_m * D_m) / (2.0 * d)), 2.0) * (h / l)) <= -40.0: tmp = D_m * (w0 * math.sqrt(((M_m * (-0.25 * (M_m * h))) / (d * (d * l))))) else: tmp = w0 return tmp
D_m = abs(D) M_m = abs(M) w0, M_m, D_m, h, l, d = sort([w0, M_m, D_m, h, l, d]) function code(w0, M_m, D_m, h, l, d) tmp = 0.0 if (Float64((Float64(Float64(M_m * D_m) / Float64(2.0 * d)) ^ 2.0) * Float64(h / l)) <= -40.0) tmp = Float64(D_m * Float64(w0 * sqrt(Float64(Float64(M_m * Float64(-0.25 * Float64(M_m * h))) / Float64(d * Float64(d * l)))))); else tmp = w0; end return tmp end
D_m = abs(D);
M_m = abs(M);
w0, M_m, D_m, h, l, d = num2cell(sort([w0, M_m, D_m, h, l, d])){:}
function tmp_2 = code(w0, M_m, D_m, h, l, d)
tmp = 0.0;
if (((((M_m * D_m) / (2.0 * d)) ^ 2.0) * (h / l)) <= -40.0)
tmp = D_m * (w0 * sqrt(((M_m * (-0.25 * (M_m * h))) / (d * (d * l)))));
else
tmp = w0;
end
tmp_2 = tmp;
end
D_m = N[Abs[D], $MachinePrecision] M_m = N[Abs[M], $MachinePrecision] NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function. code[w0_, M$95$m_, D$95$m_, h_, l_, d_] := If[LessEqual[N[(N[Power[N[(N[(M$95$m * D$95$m), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] * N[(h / l), $MachinePrecision]), $MachinePrecision], -40.0], N[(D$95$m * N[(w0 * N[Sqrt[N[(N[(M$95$m * N[(-0.25 * N[(M$95$m * h), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(d * N[(d * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], w0]
\begin{array}{l}
D_m = \left|D\right|
\\
M_m = \left|M\right|
\\
[w0, M_m, D_m, h, l, d] = \mathsf{sort}([w0, M_m, D_m, h, l, d])\\
\\
\begin{array}{l}
\mathbf{if}\;{\left(\frac{M\_m \cdot D\_m}{2 \cdot d}\right)}^{2} \cdot \frac{h}{\ell} \leq -40:\\
\;\;\;\;D\_m \cdot \left(w0 \cdot \sqrt{\frac{M\_m \cdot \left(-0.25 \cdot \left(M\_m \cdot h\right)\right)}{d \cdot \left(d \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)) < -40Initial program 65.4%
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-pow.f64N/A
lift-/.f64N/A
lift-*.f64N/A
sub-negN/A
+-commutativeN/A
Applied egg-rr72.3%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
distribute-frac-neg2N/A
distribute-frac-negN/A
lift-/.f64N/A
distribute-neg-frac2N/A
associate-/r*N/A
lift-*.f64N/A
distribute-lft-neg-inN/A
metadata-evalN/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f64N/A
Applied egg-rr69.8%
Taylor expanded in M 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
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6445.2
Simplified45.2%
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
Applied egg-rr26.8%
if -40 < (*.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
Simplified96.7%
*-rgt-identity96.7
Applied egg-rr96.7%
Final simplification74.1%
D_m = (fabs.f64 D) M_m = (fabs.f64 M) NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function. (FPCore (w0 M_m D_m h l d) :precision binary64 (if (<= (* (pow (/ (* M_m D_m) (* 2.0 d)) 2.0) (/ h l)) -1e+182) (* w0 (fma (* D_m D_m) (* (* (* M_m M_m) -0.125) (/ h (* d (* d l)))) 1.0)) w0))
D_m = fabs(D);
M_m = fabs(M);
assert(w0 < M_m && M_m < D_m && D_m < h && h < l && l < d);
double code(double w0, double M_m, double D_m, double h, double l, double d) {
double tmp;
if ((pow(((M_m * D_m) / (2.0 * d)), 2.0) * (h / l)) <= -1e+182) {
tmp = w0 * fma((D_m * D_m), (((M_m * M_m) * -0.125) * (h / (d * (d * l)))), 1.0);
} else {
tmp = w0;
}
return tmp;
}
D_m = abs(D) M_m = abs(M) w0, M_m, D_m, h, l, d = sort([w0, M_m, D_m, h, l, d]) function code(w0, M_m, D_m, h, l, d) tmp = 0.0 if (Float64((Float64(Float64(M_m * D_m) / Float64(2.0 * d)) ^ 2.0) * Float64(h / l)) <= -1e+182) tmp = Float64(w0 * fma(Float64(D_m * D_m), Float64(Float64(Float64(M_m * M_m) * -0.125) * Float64(h / Float64(d * Float64(d * l)))), 1.0)); else tmp = w0; end return tmp end
D_m = N[Abs[D], $MachinePrecision] M_m = N[Abs[M], $MachinePrecision] NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function. code[w0_, M$95$m_, D$95$m_, h_, l_, d_] := If[LessEqual[N[(N[Power[N[(N[(M$95$m * D$95$m), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] * N[(h / l), $MachinePrecision]), $MachinePrecision], -1e+182], N[(w0 * N[(N[(D$95$m * D$95$m), $MachinePrecision] * N[(N[(N[(M$95$m * M$95$m), $MachinePrecision] * -0.125), $MachinePrecision] * N[(h / N[(d * N[(d * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], w0]
\begin{array}{l}
D_m = \left|D\right|
\\
M_m = \left|M\right|
\\
[w0, M_m, D_m, h, l, d] = \mathsf{sort}([w0, M_m, D_m, h, l, d])\\
\\
\begin{array}{l}
\mathbf{if}\;{\left(\frac{M\_m \cdot D\_m}{2 \cdot d}\right)}^{2} \cdot \frac{h}{\ell} \leq -1 \cdot 10^{+182}:\\
\;\;\;\;w0 \cdot \mathsf{fma}\left(D\_m \cdot D\_m, \left(\left(M\_m \cdot M\_m\right) \cdot -0.125\right) \cdot \frac{h}{d \cdot \left(d \cdot \ell\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)) < -1.0000000000000001e182Initial program 60.2%
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-pow.f64N/A
lift-/.f64N/A
lift-*.f64N/A
sub-negN/A
+-commutativeN/A
Applied egg-rr69.4%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
distribute-frac-neg2N/A
distribute-frac-negN/A
lift-/.f64N/A
distribute-neg-frac2N/A
associate-/r*N/A
lift-*.f64N/A
distribute-lft-neg-inN/A
metadata-evalN/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f64N/A
Applied egg-rr65.2%
Taylor expanded in M around 0
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
Simplified45.8%
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
lower-*.f64N/A
lower-/.f6447.3
Applied egg-rr47.3%
if -1.0000000000000001e182 < (*.f64 (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) (/.f64 h l)) Initial program 89.6%
Taylor expanded in M around 0
Simplified91.5%
*-rgt-identity91.5
Applied egg-rr91.5%
Final simplification79.1%
D_m = (fabs.f64 D) M_m = (fabs.f64 M) NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function. (FPCore (w0 M_m D_m h l d) :precision binary64 (if (<= (* (pow (/ (* M_m D_m) (* 2.0 d)) 2.0) (/ h l)) -1e+182) (* (* D_m D_m) (/ (* -0.125 (* h (* w0 (* M_m M_m)))) (* l (* d d)))) w0))
D_m = fabs(D);
M_m = fabs(M);
assert(w0 < M_m && M_m < D_m && D_m < h && h < l && l < d);
double code(double w0, double M_m, double D_m, double h, double l, double d) {
double tmp;
if ((pow(((M_m * D_m) / (2.0 * d)), 2.0) * (h / l)) <= -1e+182) {
tmp = (D_m * D_m) * ((-0.125 * (h * (w0 * (M_m * M_m)))) / (l * (d * d)));
} else {
tmp = w0;
}
return tmp;
}
D_m = abs(d)
M_m = abs(m)
NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function.
real(8) function code(w0, m_m, d_m, h, l, d)
real(8), intent (in) :: w0
real(8), intent (in) :: m_m
real(8), intent (in) :: d_m
real(8), intent (in) :: h
real(8), intent (in) :: l
real(8), intent (in) :: d
real(8) :: tmp
if (((((m_m * d_m) / (2.0d0 * d)) ** 2.0d0) * (h / l)) <= (-1d+182)) then
tmp = (d_m * d_m) * (((-0.125d0) * (h * (w0 * (m_m * m_m)))) / (l * (d * d)))
else
tmp = w0
end if
code = tmp
end function
D_m = Math.abs(D);
M_m = Math.abs(M);
assert w0 < M_m && M_m < D_m && D_m < h && h < l && l < d;
public static double code(double w0, double M_m, double D_m, double h, double l, double d) {
double tmp;
if ((Math.pow(((M_m * D_m) / (2.0 * d)), 2.0) * (h / l)) <= -1e+182) {
tmp = (D_m * D_m) * ((-0.125 * (h * (w0 * (M_m * M_m)))) / (l * (d * d)));
} else {
tmp = w0;
}
return tmp;
}
D_m = math.fabs(D) M_m = math.fabs(M) [w0, M_m, D_m, h, l, d] = sort([w0, M_m, D_m, h, l, d]) def code(w0, M_m, D_m, h, l, d): tmp = 0 if (math.pow(((M_m * D_m) / (2.0 * d)), 2.0) * (h / l)) <= -1e+182: tmp = (D_m * D_m) * ((-0.125 * (h * (w0 * (M_m * M_m)))) / (l * (d * d))) else: tmp = w0 return tmp
D_m = abs(D) M_m = abs(M) w0, M_m, D_m, h, l, d = sort([w0, M_m, D_m, h, l, d]) function code(w0, M_m, D_m, h, l, d) tmp = 0.0 if (Float64((Float64(Float64(M_m * D_m) / Float64(2.0 * d)) ^ 2.0) * Float64(h / l)) <= -1e+182) tmp = Float64(Float64(D_m * D_m) * Float64(Float64(-0.125 * Float64(h * Float64(w0 * Float64(M_m * M_m)))) / Float64(l * Float64(d * d)))); else tmp = w0; end return tmp end
D_m = abs(D);
M_m = abs(M);
w0, M_m, D_m, h, l, d = num2cell(sort([w0, M_m, D_m, h, l, d])){:}
function tmp_2 = code(w0, M_m, D_m, h, l, d)
tmp = 0.0;
if (((((M_m * D_m) / (2.0 * d)) ^ 2.0) * (h / l)) <= -1e+182)
tmp = (D_m * D_m) * ((-0.125 * (h * (w0 * (M_m * M_m)))) / (l * (d * d)));
else
tmp = w0;
end
tmp_2 = tmp;
end
D_m = N[Abs[D], $MachinePrecision] M_m = N[Abs[M], $MachinePrecision] NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function. code[w0_, M$95$m_, D$95$m_, h_, l_, d_] := If[LessEqual[N[(N[Power[N[(N[(M$95$m * D$95$m), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] * N[(h / l), $MachinePrecision]), $MachinePrecision], -1e+182], N[(N[(D$95$m * D$95$m), $MachinePrecision] * N[(N[(-0.125 * N[(h * N[(w0 * N[(M$95$m * M$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(l * N[(d * d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], w0]
\begin{array}{l}
D_m = \left|D\right|
\\
M_m = \left|M\right|
\\
[w0, M_m, D_m, h, l, d] = \mathsf{sort}([w0, M_m, D_m, h, l, d])\\
\\
\begin{array}{l}
\mathbf{if}\;{\left(\frac{M\_m \cdot D\_m}{2 \cdot d}\right)}^{2} \cdot \frac{h}{\ell} \leq -1 \cdot 10^{+182}:\\
\;\;\;\;\left(D\_m \cdot D\_m\right) \cdot \frac{-0.125 \cdot \left(h \cdot \left(w0 \cdot \left(M\_m \cdot M\_m\right)\right)\right)}{\ell \cdot \left(d \cdot d\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)) < -1.0000000000000001e182Initial program 60.2%
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-pow.f64N/A
lift-/.f64N/A
lift-*.f64N/A
sub-negN/A
+-commutativeN/A
Applied egg-rr69.4%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
distribute-frac-neg2N/A
distribute-frac-negN/A
lift-/.f64N/A
distribute-neg-frac2N/A
associate-/r*N/A
lift-*.f64N/A
distribute-lft-neg-inN/A
metadata-evalN/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f64N/A
Applied egg-rr65.2%
Taylor expanded in M around 0
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
Simplified45.8%
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
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6445.6
Simplified45.6%
if -1.0000000000000001e182 < (*.f64 (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) (/.f64 h l)) Initial program 89.6%
Taylor expanded in M around 0
Simplified91.5%
*-rgt-identity91.5
Applied egg-rr91.5%
Final simplification78.6%
D_m = (fabs.f64 D) M_m = (fabs.f64 M) NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function. (FPCore (w0 M_m D_m h l d) :precision binary64 (if (<= (* (pow (/ (* M_m D_m) (* 2.0 d)) 2.0) (/ h l)) -1e+182) (* w0 (* (* (* D_m D_m) -0.125) (/ (* h (* M_m M_m)) (* l (* d d))))) w0))
D_m = fabs(D);
M_m = fabs(M);
assert(w0 < M_m && M_m < D_m && D_m < h && h < l && l < d);
double code(double w0, double M_m, double D_m, double h, double l, double d) {
double tmp;
if ((pow(((M_m * D_m) / (2.0 * d)), 2.0) * (h / l)) <= -1e+182) {
tmp = w0 * (((D_m * D_m) * -0.125) * ((h * (M_m * M_m)) / (l * (d * d))));
} else {
tmp = w0;
}
return tmp;
}
D_m = abs(d)
M_m = abs(m)
NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function.
real(8) function code(w0, m_m, d_m, h, l, d)
real(8), intent (in) :: w0
real(8), intent (in) :: m_m
real(8), intent (in) :: d_m
real(8), intent (in) :: h
real(8), intent (in) :: l
real(8), intent (in) :: d
real(8) :: tmp
if (((((m_m * d_m) / (2.0d0 * d)) ** 2.0d0) * (h / l)) <= (-1d+182)) then
tmp = w0 * (((d_m * d_m) * (-0.125d0)) * ((h * (m_m * m_m)) / (l * (d * d))))
else
tmp = w0
end if
code = tmp
end function
D_m = Math.abs(D);
M_m = Math.abs(M);
assert w0 < M_m && M_m < D_m && D_m < h && h < l && l < d;
public static double code(double w0, double M_m, double D_m, double h, double l, double d) {
double tmp;
if ((Math.pow(((M_m * D_m) / (2.0 * d)), 2.0) * (h / l)) <= -1e+182) {
tmp = w0 * (((D_m * D_m) * -0.125) * ((h * (M_m * M_m)) / (l * (d * d))));
} else {
tmp = w0;
}
return tmp;
}
D_m = math.fabs(D) M_m = math.fabs(M) [w0, M_m, D_m, h, l, d] = sort([w0, M_m, D_m, h, l, d]) def code(w0, M_m, D_m, h, l, d): tmp = 0 if (math.pow(((M_m * D_m) / (2.0 * d)), 2.0) * (h / l)) <= -1e+182: tmp = w0 * (((D_m * D_m) * -0.125) * ((h * (M_m * M_m)) / (l * (d * d)))) else: tmp = w0 return tmp
D_m = abs(D) M_m = abs(M) w0, M_m, D_m, h, l, d = sort([w0, M_m, D_m, h, l, d]) function code(w0, M_m, D_m, h, l, d) tmp = 0.0 if (Float64((Float64(Float64(M_m * D_m) / Float64(2.0 * d)) ^ 2.0) * Float64(h / l)) <= -1e+182) tmp = Float64(w0 * Float64(Float64(Float64(D_m * D_m) * -0.125) * Float64(Float64(h * Float64(M_m * M_m)) / Float64(l * Float64(d * d))))); else tmp = w0; end return tmp end
D_m = abs(D);
M_m = abs(M);
w0, M_m, D_m, h, l, d = num2cell(sort([w0, M_m, D_m, h, l, d])){:}
function tmp_2 = code(w0, M_m, D_m, h, l, d)
tmp = 0.0;
if (((((M_m * D_m) / (2.0 * d)) ^ 2.0) * (h / l)) <= -1e+182)
tmp = w0 * (((D_m * D_m) * -0.125) * ((h * (M_m * M_m)) / (l * (d * d))));
else
tmp = w0;
end
tmp_2 = tmp;
end
D_m = N[Abs[D], $MachinePrecision] M_m = N[Abs[M], $MachinePrecision] NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function. code[w0_, M$95$m_, D$95$m_, h_, l_, d_] := If[LessEqual[N[(N[Power[N[(N[(M$95$m * D$95$m), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] * N[(h / l), $MachinePrecision]), $MachinePrecision], -1e+182], N[(w0 * N[(N[(N[(D$95$m * D$95$m), $MachinePrecision] * -0.125), $MachinePrecision] * N[(N[(h * N[(M$95$m * M$95$m), $MachinePrecision]), $MachinePrecision] / N[(l * N[(d * d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], w0]
\begin{array}{l}
D_m = \left|D\right|
\\
M_m = \left|M\right|
\\
[w0, M_m, D_m, h, l, d] = \mathsf{sort}([w0, M_m, D_m, h, l, d])\\
\\
\begin{array}{l}
\mathbf{if}\;{\left(\frac{M\_m \cdot D\_m}{2 \cdot d}\right)}^{2} \cdot \frac{h}{\ell} \leq -1 \cdot 10^{+182}:\\
\;\;\;\;w0 \cdot \left(\left(\left(D\_m \cdot D\_m\right) \cdot -0.125\right) \cdot \frac{h \cdot \left(M\_m \cdot M\_m\right)}{\ell \cdot \left(d \cdot d\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)) < -1.0000000000000001e182Initial program 60.2%
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-pow.f64N/A
lift-/.f64N/A
lift-*.f64N/A
sub-negN/A
+-commutativeN/A
Applied egg-rr69.4%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
distribute-frac-neg2N/A
distribute-frac-negN/A
lift-/.f64N/A
distribute-neg-frac2N/A
associate-/r*N/A
lift-*.f64N/A
distribute-lft-neg-inN/A
metadata-evalN/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f64N/A
Applied egg-rr65.2%
Taylor expanded in M around 0
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
Simplified45.8%
Taylor expanded in D around inf
*-commutativeN/A
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower-/.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6445.7
Simplified45.7%
if -1.0000000000000001e182 < (*.f64 (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) (/.f64 h l)) Initial program 89.6%
Taylor expanded in M around 0
Simplified91.5%
*-rgt-identity91.5
Applied egg-rr91.5%
Final simplification78.6%
D_m = (fabs.f64 D)
M_m = (fabs.f64 M)
NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function.
(FPCore (w0 M_m D_m h l d)
:precision binary64
(let* ((t_0 (* (* M_m M_m) 0.25)))
(if (<= (* M_m D_m) 5e-307)
(* w0 (sqrt (- 1.0 (* (/ D_m d) (* (/ D_m d) (/ (* h t_0) l))))))
(if (<= (* M_m D_m) 1e+111)
(*
w0
(sqrt
(fma
(* D_m (/ M_m (* 2.0 d)))
(* h (/ (* M_m D_m) (* l (* d -2.0))))
1.0)))
(* w0 (sqrt (fma (* (* (/ D_m d) t_0) (/ h (- l))) (/ D_m d) 1.0)))))))D_m = fabs(D);
M_m = fabs(M);
assert(w0 < M_m && M_m < D_m && D_m < h && h < l && l < d);
double code(double w0, double M_m, double D_m, double h, double l, double d) {
double t_0 = (M_m * M_m) * 0.25;
double tmp;
if ((M_m * D_m) <= 5e-307) {
tmp = w0 * sqrt((1.0 - ((D_m / d) * ((D_m / d) * ((h * t_0) / l)))));
} else if ((M_m * D_m) <= 1e+111) {
tmp = w0 * sqrt(fma((D_m * (M_m / (2.0 * d))), (h * ((M_m * D_m) / (l * (d * -2.0)))), 1.0));
} else {
tmp = w0 * sqrt(fma((((D_m / d) * t_0) * (h / -l)), (D_m / d), 1.0));
}
return tmp;
}
D_m = abs(D) M_m = abs(M) w0, M_m, D_m, h, l, d = sort([w0, M_m, D_m, h, l, d]) function code(w0, M_m, D_m, h, l, d) t_0 = Float64(Float64(M_m * M_m) * 0.25) tmp = 0.0 if (Float64(M_m * D_m) <= 5e-307) tmp = Float64(w0 * sqrt(Float64(1.0 - Float64(Float64(D_m / d) * Float64(Float64(D_m / d) * Float64(Float64(h * t_0) / l)))))); elseif (Float64(M_m * D_m) <= 1e+111) tmp = Float64(w0 * sqrt(fma(Float64(D_m * Float64(M_m / Float64(2.0 * d))), Float64(h * Float64(Float64(M_m * D_m) / Float64(l * Float64(d * -2.0)))), 1.0))); else tmp = Float64(w0 * sqrt(fma(Float64(Float64(Float64(D_m / d) * t_0) * Float64(h / Float64(-l))), Float64(D_m / d), 1.0))); end return tmp end
D_m = N[Abs[D], $MachinePrecision]
M_m = N[Abs[M], $MachinePrecision]
NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function.
code[w0_, M$95$m_, D$95$m_, h_, l_, d_] := Block[{t$95$0 = N[(N[(M$95$m * M$95$m), $MachinePrecision] * 0.25), $MachinePrecision]}, If[LessEqual[N[(M$95$m * D$95$m), $MachinePrecision], 5e-307], N[(w0 * N[Sqrt[N[(1.0 - N[(N[(D$95$m / d), $MachinePrecision] * N[(N[(D$95$m / d), $MachinePrecision] * N[(N[(h * t$95$0), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(M$95$m * D$95$m), $MachinePrecision], 1e+111], N[(w0 * N[Sqrt[N[(N[(D$95$m * N[(M$95$m / N[(2.0 * d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(h * N[(N[(M$95$m * D$95$m), $MachinePrecision] / N[(l * N[(d * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(w0 * N[Sqrt[N[(N[(N[(N[(D$95$m / d), $MachinePrecision] * t$95$0), $MachinePrecision] * N[(h / (-l)), $MachinePrecision]), $MachinePrecision] * N[(D$95$m / d), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
D_m = \left|D\right|
\\
M_m = \left|M\right|
\\
[w0, M_m, D_m, h, l, d] = \mathsf{sort}([w0, M_m, D_m, h, l, d])\\
\\
\begin{array}{l}
t_0 := \left(M\_m \cdot M\_m\right) \cdot 0.25\\
\mathbf{if}\;M\_m \cdot D\_m \leq 5 \cdot 10^{-307}:\\
\;\;\;\;w0 \cdot \sqrt{1 - \frac{D\_m}{d} \cdot \left(\frac{D\_m}{d} \cdot \frac{h \cdot t\_0}{\ell}\right)}\\
\mathbf{elif}\;M\_m \cdot D\_m \leq 10^{+111}:\\
\;\;\;\;w0 \cdot \sqrt{\mathsf{fma}\left(D\_m \cdot \frac{M\_m}{2 \cdot d}, h \cdot \frac{M\_m \cdot D\_m}{\ell \cdot \left(d \cdot -2\right)}, 1\right)}\\
\mathbf{else}:\\
\;\;\;\;w0 \cdot \sqrt{\mathsf{fma}\left(\left(\frac{D\_m}{d} \cdot t\_0\right) \cdot \frac{h}{-\ell}, \frac{D\_m}{d}, 1\right)}\\
\end{array}
\end{array}
if (*.f64 M D) < 5.00000000000000014e-307Initial program 84.6%
times-fracN/A
unpow-prod-downN/A
*-commutativeN/A
lower-*.f64N/A
pow2N/A
associate-*r/N/A
lower-/.f64N/A
lower-*.f64N/A
lower-/.f64N/A
div-invN/A
metadata-evalN/A
unpow-prod-downN/A
metadata-evalN/A
metadata-evalN/A
lower-*.f64N/A
pow2N/A
lower-*.f64N/A
metadata-eval71.1
Applied egg-rr71.1%
lift-/.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
associate-*l*N/A
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
lift-/.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
lower-*.f6477.0
Applied egg-rr77.0%
if 5.00000000000000014e-307 < (*.f64 M D) < 9.99999999999999957e110Initial program 86.9%
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-pow.f64N/A
lift-/.f64N/A
lift-*.f64N/A
sub-negN/A
+-commutativeN/A
Applied egg-rr94.1%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
distribute-frac-neg2N/A
distribute-frac-negN/A
lift-/.f64N/A
distribute-neg-frac2N/A
associate-/r*N/A
lift-*.f64N/A
distribute-lft-neg-inN/A
metadata-evalN/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f64N/A
Applied egg-rr92.9%
*-commutativeN/A
lift-*.f64N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f6491.7
Applied egg-rr91.7%
if 9.99999999999999957e110 < (*.f64 M D) Initial program 60.5%
Applied egg-rr55.8%
Final simplification78.2%
D_m = (fabs.f64 D)
M_m = (fabs.f64 M)
NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function.
(FPCore (w0 M_m D_m h l d)
:precision binary64
(let* ((t_0
(*
w0
(sqrt
(-
1.0
(* (/ D_m d) (* (/ D_m d) (/ (* h (* (* M_m M_m) 0.25)) l))))))))
(if (<= (* M_m D_m) 5e-307)
t_0
(if (<= (* M_m D_m) 5e+230)
(*
w0
(sqrt
(fma
(* D_m (/ M_m (* 2.0 d)))
(* h (/ (* M_m D_m) (* l (* d -2.0))))
1.0)))
t_0))))D_m = fabs(D);
M_m = fabs(M);
assert(w0 < M_m && M_m < D_m && D_m < h && h < l && l < d);
double code(double w0, double M_m, double D_m, double h, double l, double d) {
double t_0 = w0 * sqrt((1.0 - ((D_m / d) * ((D_m / d) * ((h * ((M_m * M_m) * 0.25)) / l)))));
double tmp;
if ((M_m * D_m) <= 5e-307) {
tmp = t_0;
} else if ((M_m * D_m) <= 5e+230) {
tmp = w0 * sqrt(fma((D_m * (M_m / (2.0 * d))), (h * ((M_m * D_m) / (l * (d * -2.0)))), 1.0));
} else {
tmp = t_0;
}
return tmp;
}
D_m = abs(D) M_m = abs(M) w0, M_m, D_m, h, l, d = sort([w0, M_m, D_m, h, l, d]) function code(w0, M_m, D_m, h, l, d) t_0 = Float64(w0 * sqrt(Float64(1.0 - Float64(Float64(D_m / d) * Float64(Float64(D_m / d) * Float64(Float64(h * Float64(Float64(M_m * M_m) * 0.25)) / l)))))) tmp = 0.0 if (Float64(M_m * D_m) <= 5e-307) tmp = t_0; elseif (Float64(M_m * D_m) <= 5e+230) tmp = Float64(w0 * sqrt(fma(Float64(D_m * Float64(M_m / Float64(2.0 * d))), Float64(h * Float64(Float64(M_m * D_m) / Float64(l * Float64(d * -2.0)))), 1.0))); else tmp = t_0; end return tmp end
D_m = N[Abs[D], $MachinePrecision]
M_m = N[Abs[M], $MachinePrecision]
NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function.
code[w0_, M$95$m_, D$95$m_, h_, l_, d_] := Block[{t$95$0 = N[(w0 * N[Sqrt[N[(1.0 - N[(N[(D$95$m / d), $MachinePrecision] * N[(N[(D$95$m / d), $MachinePrecision] * N[(N[(h * N[(N[(M$95$m * M$95$m), $MachinePrecision] * 0.25), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(M$95$m * D$95$m), $MachinePrecision], 5e-307], t$95$0, If[LessEqual[N[(M$95$m * D$95$m), $MachinePrecision], 5e+230], N[(w0 * N[Sqrt[N[(N[(D$95$m * N[(M$95$m / N[(2.0 * d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(h * N[(N[(M$95$m * D$95$m), $MachinePrecision] / N[(l * N[(d * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], t$95$0]]]
\begin{array}{l}
D_m = \left|D\right|
\\
M_m = \left|M\right|
\\
[w0, M_m, D_m, h, l, d] = \mathsf{sort}([w0, M_m, D_m, h, l, d])\\
\\
\begin{array}{l}
t_0 := w0 \cdot \sqrt{1 - \frac{D\_m}{d} \cdot \left(\frac{D\_m}{d} \cdot \frac{h \cdot \left(\left(M\_m \cdot M\_m\right) \cdot 0.25\right)}{\ell}\right)}\\
\mathbf{if}\;M\_m \cdot D\_m \leq 5 \cdot 10^{-307}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;M\_m \cdot D\_m \leq 5 \cdot 10^{+230}:\\
\;\;\;\;w0 \cdot \sqrt{\mathsf{fma}\left(D\_m \cdot \frac{M\_m}{2 \cdot d}, h \cdot \frac{M\_m \cdot D\_m}{\ell \cdot \left(d \cdot -2\right)}, 1\right)}\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if (*.f64 M D) < 5.00000000000000014e-307 or 5.0000000000000003e230 < (*.f64 M D) Initial program 80.7%
times-fracN/A
unpow-prod-downN/A
*-commutativeN/A
lower-*.f64N/A
pow2N/A
associate-*r/N/A
lower-/.f64N/A
lower-*.f64N/A
lower-/.f64N/A
div-invN/A
metadata-evalN/A
unpow-prod-downN/A
metadata-evalN/A
metadata-evalN/A
lower-*.f64N/A
pow2N/A
lower-*.f64N/A
metadata-eval68.7
Applied egg-rr68.7%
lift-/.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
associate-*l*N/A
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
lift-/.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
lower-*.f6475.1
Applied egg-rr75.1%
if 5.00000000000000014e-307 < (*.f64 M D) < 5.0000000000000003e230Initial program 82.3%
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-pow.f64N/A
lift-/.f64N/A
lift-*.f64N/A
sub-negN/A
+-commutativeN/A
Applied egg-rr88.3%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
distribute-frac-neg2N/A
distribute-frac-negN/A
lift-/.f64N/A
distribute-neg-frac2N/A
associate-/r*N/A
lift-*.f64N/A
distribute-lft-neg-inN/A
metadata-evalN/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f64N/A
Applied egg-rr88.3%
*-commutativeN/A
lift-*.f64N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f6487.4
Applied egg-rr87.4%
Final simplification79.9%
D_m = (fabs.f64 D)
M_m = (fabs.f64 M)
NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function.
(FPCore (w0 M_m D_m h l d)
:precision binary64
(if (<= (* 2.0 d) 1e+21)
(*
w0
(sqrt
(fma
(/ (* M_m D_m) (* 2.0 d))
(/ (/ (* (* M_m D_m) h) (* 2.0 d)) (- l))
1.0)))
(*
w0
(sqrt
(- 1.0 (* (/ D_m d) (* (/ D_m d) (/ (* h (* (* M_m M_m) 0.25)) l))))))))D_m = fabs(D);
M_m = fabs(M);
assert(w0 < M_m && M_m < D_m && D_m < h && h < l && l < d);
double code(double w0, double M_m, double D_m, double h, double l, double d) {
double tmp;
if ((2.0 * d) <= 1e+21) {
tmp = w0 * sqrt(fma(((M_m * D_m) / (2.0 * d)), ((((M_m * D_m) * h) / (2.0 * d)) / -l), 1.0));
} else {
tmp = w0 * sqrt((1.0 - ((D_m / d) * ((D_m / d) * ((h * ((M_m * M_m) * 0.25)) / l)))));
}
return tmp;
}
D_m = abs(D) M_m = abs(M) w0, M_m, D_m, h, l, d = sort([w0, M_m, D_m, h, l, d]) function code(w0, M_m, D_m, h, l, d) tmp = 0.0 if (Float64(2.0 * d) <= 1e+21) tmp = Float64(w0 * sqrt(fma(Float64(Float64(M_m * D_m) / Float64(2.0 * d)), Float64(Float64(Float64(Float64(M_m * D_m) * h) / Float64(2.0 * d)) / Float64(-l)), 1.0))); else tmp = Float64(w0 * sqrt(Float64(1.0 - Float64(Float64(D_m / d) * Float64(Float64(D_m / d) * Float64(Float64(h * Float64(Float64(M_m * M_m) * 0.25)) / l)))))); end return tmp end
D_m = N[Abs[D], $MachinePrecision] M_m = N[Abs[M], $MachinePrecision] NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function. code[w0_, M$95$m_, D$95$m_, h_, l_, d_] := If[LessEqual[N[(2.0 * d), $MachinePrecision], 1e+21], N[(w0 * N[Sqrt[N[(N[(N[(M$95$m * D$95$m), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision] * N[(N[(N[(N[(M$95$m * D$95$m), $MachinePrecision] * h), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision] / (-l)), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(w0 * N[Sqrt[N[(1.0 - N[(N[(D$95$m / d), $MachinePrecision] * N[(N[(D$95$m / d), $MachinePrecision] * N[(N[(h * N[(N[(M$95$m * M$95$m), $MachinePrecision] * 0.25), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
D_m = \left|D\right|
\\
M_m = \left|M\right|
\\
[w0, M_m, D_m, h, l, d] = \mathsf{sort}([w0, M_m, D_m, h, l, d])\\
\\
\begin{array}{l}
\mathbf{if}\;2 \cdot d \leq 10^{+21}:\\
\;\;\;\;w0 \cdot \sqrt{\mathsf{fma}\left(\frac{M\_m \cdot D\_m}{2 \cdot d}, \frac{\frac{\left(M\_m \cdot D\_m\right) \cdot h}{2 \cdot d}}{-\ell}, 1\right)}\\
\mathbf{else}:\\
\;\;\;\;w0 \cdot \sqrt{1 - \frac{D\_m}{d} \cdot \left(\frac{D\_m}{d} \cdot \frac{h \cdot \left(\left(M\_m \cdot M\_m\right) \cdot 0.25\right)}{\ell}\right)}\\
\end{array}
\end{array}
if (*.f64 #s(literal 2 binary64) d) < 1e21Initial program 79.8%
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-pow.f64N/A
lift-/.f64N/A
lift-*.f64N/A
sub-negN/A
+-commutativeN/A
Applied egg-rr86.4%
if 1e21 < (*.f64 #s(literal 2 binary64) d) Initial program 86.6%
times-fracN/A
unpow-prod-downN/A
*-commutativeN/A
lower-*.f64N/A
pow2N/A
associate-*r/N/A
lower-/.f64N/A
lower-*.f64N/A
lower-/.f64N/A
div-invN/A
metadata-evalN/A
unpow-prod-downN/A
metadata-evalN/A
metadata-evalN/A
lower-*.f64N/A
pow2N/A
lower-*.f64N/A
metadata-eval71.4
Applied egg-rr71.4%
lift-/.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
associate-*l*N/A
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
lift-/.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lower-/.f64N/A
lower-*.f6476.5
Applied egg-rr76.5%
Final simplification84.1%
D_m = (fabs.f64 D) M_m = (fabs.f64 M) NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function. (FPCore (w0 M_m D_m h l d) :precision binary64 w0)
D_m = fabs(D);
M_m = fabs(M);
assert(w0 < M_m && M_m < D_m && D_m < h && h < l && l < d);
double code(double w0, double M_m, double D_m, double h, double l, double d) {
return w0;
}
D_m = abs(d)
M_m = abs(m)
NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function.
real(8) function code(w0, m_m, d_m, h, l, d)
real(8), intent (in) :: w0
real(8), intent (in) :: m_m
real(8), intent (in) :: d_m
real(8), intent (in) :: h
real(8), intent (in) :: l
real(8), intent (in) :: d
code = w0
end function
D_m = Math.abs(D);
M_m = Math.abs(M);
assert w0 < M_m && M_m < D_m && D_m < h && h < l && l < d;
public static double code(double w0, double M_m, double D_m, double h, double l, double d) {
return w0;
}
D_m = math.fabs(D) M_m = math.fabs(M) [w0, M_m, D_m, h, l, d] = sort([w0, M_m, D_m, h, l, d]) def code(w0, M_m, D_m, h, l, d): return w0
D_m = abs(D) M_m = abs(M) w0, M_m, D_m, h, l, d = sort([w0, M_m, D_m, h, l, d]) function code(w0, M_m, D_m, h, l, d) return w0 end
D_m = abs(D);
M_m = abs(M);
w0, M_m, D_m, h, l, d = num2cell(sort([w0, M_m, D_m, h, l, d])){:}
function tmp = code(w0, M_m, D_m, h, l, d)
tmp = w0;
end
D_m = N[Abs[D], $MachinePrecision] M_m = N[Abs[M], $MachinePrecision] NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function. code[w0_, M$95$m_, D$95$m_, h_, l_, d_] := w0
\begin{array}{l}
D_m = \left|D\right|
\\
M_m = \left|M\right|
\\
[w0, M_m, D_m, h, l, d] = \mathsf{sort}([w0, M_m, D_m, h, l, d])\\
\\
w0
\end{array}
Initial program 81.4%
Taylor expanded in M around 0
Simplified67.2%
*-rgt-identity67.2
Applied egg-rr67.2%
herbie shell --seed 2024207
(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))))))