
(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 14 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 (<= D_m 50.0)
(* (sqrt (fma (/ (pow (* 2.0 (/ (/ d M_m) D_m)) -2.0) l) (- h) 1.0)) w0)
(*
(sqrt
(fma
(* (/ (* (* M_m D_m) -0.5) (* l d)) h)
(* (* (/ 0.5 d) M_m) D_m)
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 (D_m <= 50.0) {
tmp = sqrt(fma((pow((2.0 * ((d / M_m) / D_m)), -2.0) / l), -h, 1.0)) * w0;
} else {
tmp = sqrt(fma(((((M_m * D_m) * -0.5) / (l * d)) * h), (((0.5 / d) * M_m) * D_m), 1.0)) * 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 (D_m <= 50.0) tmp = Float64(sqrt(fma(Float64((Float64(2.0 * Float64(Float64(d / M_m) / D_m)) ^ -2.0) / l), Float64(-h), 1.0)) * w0); else tmp = Float64(sqrt(fma(Float64(Float64(Float64(Float64(M_m * D_m) * -0.5) / Float64(l * d)) * h), Float64(Float64(Float64(0.5 / d) * M_m) * D_m), 1.0)) * 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[D$95$m, 50.0], N[(N[Sqrt[N[(N[(N[Power[N[(2.0 * N[(N[(d / M$95$m), $MachinePrecision] / D$95$m), $MachinePrecision]), $MachinePrecision], -2.0], $MachinePrecision] / l), $MachinePrecision] * (-h) + 1.0), $MachinePrecision]], $MachinePrecision] * w0), $MachinePrecision], N[(N[Sqrt[N[(N[(N[(N[(N[(M$95$m * D$95$m), $MachinePrecision] * -0.5), $MachinePrecision] / N[(l * d), $MachinePrecision]), $MachinePrecision] * h), $MachinePrecision] * N[(N[(N[(0.5 / d), $MachinePrecision] * M$95$m), $MachinePrecision] * D$95$m), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision] * w0), $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}\;D\_m \leq 50:\\
\;\;\;\;\sqrt{\mathsf{fma}\left(\frac{{\left(2 \cdot \frac{\frac{d}{M\_m}}{D\_m}\right)}^{-2}}{\ell}, -h, 1\right)} \cdot w0\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\mathsf{fma}\left(\frac{\left(M\_m \cdot D\_m\right) \cdot -0.5}{\ell \cdot d} \cdot h, \left(\frac{0.5}{d} \cdot M\_m\right) \cdot D\_m, 1\right)} \cdot w0\\
\end{array}
\end{array}
if D < 50Initial program 85.9%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
distribute-lft-neg-inN/A
lift-/.f64N/A
clear-numN/A
un-div-invN/A
frac-2negN/A
associate-/r/N/A
neg-mul-1N/A
associate-*l/N/A
metadata-evalN/A
frac-2negN/A
Applied rewrites87.5%
if 50 < D Initial program 76.4%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-rgt-neg-inN/A
lift-pow.f64N/A
unpow2N/A
distribute-lft-neg-inN/A
associate-*r*N/A
lower-fma.f64N/A
Applied rewrites77.9%
lift-*.f64N/A
lift-/.f64N/A
lift-/.f64N/A
frac-timesN/A
lower-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
lower-*.f6481.4
Applied rewrites81.4%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6484.5
lift-*.f64N/A
*-commutativeN/A
lower-*.f6484.5
lift-*.f64N/A
*-commutativeN/A
lift-*.f6484.5
Applied rewrites84.5%
Final simplification86.8%
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 (<= (- 1.0 (* (/ h l) (pow (/ (* M_m D_m) (* 2.0 d)) 2.0))) 50.0)
(* 1.0 w0)
(*
(sqrt (fma (* -0.25 h) (* (* (* (/ D_m (* l d)) M_m) (/ D_m d)) M_m) 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 ((1.0 - ((h / l) * pow(((M_m * D_m) / (2.0 * d)), 2.0))) <= 50.0) {
tmp = 1.0 * w0;
} else {
tmp = sqrt(fma((-0.25 * h), ((((D_m / (l * d)) * M_m) * (D_m / d)) * M_m), 1.0)) * 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(1.0 - Float64(Float64(h / l) * (Float64(Float64(M_m * D_m) / Float64(2.0 * d)) ^ 2.0))) <= 50.0) tmp = Float64(1.0 * w0); else tmp = Float64(sqrt(fma(Float64(-0.25 * h), Float64(Float64(Float64(Float64(D_m / Float64(l * d)) * M_m) * Float64(D_m / d)) * M_m), 1.0)) * 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[(1.0 - N[(N[(h / l), $MachinePrecision] * N[Power[N[(N[(M$95$m * D$95$m), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 50.0], N[(1.0 * w0), $MachinePrecision], N[(N[Sqrt[N[(N[(-0.25 * h), $MachinePrecision] * N[(N[(N[(N[(D$95$m / N[(l * d), $MachinePrecision]), $MachinePrecision] * M$95$m), $MachinePrecision] * N[(D$95$m / d), $MachinePrecision]), $MachinePrecision] * M$95$m), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision] * w0), $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}\;1 - \frac{h}{\ell} \cdot {\left(\frac{M\_m \cdot D\_m}{2 \cdot d}\right)}^{2} \leq 50:\\
\;\;\;\;1 \cdot w0\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\mathsf{fma}\left(-0.25 \cdot h, \left(\left(\frac{D\_m}{\ell \cdot d} \cdot M\_m\right) \cdot \frac{D\_m}{d}\right) \cdot M\_m, 1\right)} \cdot w0\\
\end{array}
\end{array}
if (-.f64 #s(literal 1 binary64) (*.f64 (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) (/.f64 h l))) < 50Initial program 99.9%
Taylor expanded in h around 0
Applied rewrites98.1%
if 50 < (-.f64 #s(literal 1 binary64) (*.f64 (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) (/.f64 h l))) Initial program 54.1%
Taylor expanded in h around 0
+-commutativeN/A
associate-*r/N/A
associate-*r*N/A
associate-*r*N/A
associate-*l/N/A
associate-*r/N/A
lft-mult-inverseN/A
distribute-rgt-inN/A
distribute-lft-inN/A
associate-*r*N/A
rgt-mult-inverseN/A
lower-fma.f64N/A
Applied rewrites47.2%
Applied rewrites48.5%
Applied rewrites60.5%
Final simplification84.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 (<= (* (/ h l) (pow (/ (* M_m D_m) (* 2.0 d)) 2.0)) -2e+31)
(*
(sqrt (fma (* -0.25 h) (* (/ (* (* D_m D_m) M_m) (* (* d d) l)) M_m) 1.0))
w0)
(* 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 (((h / l) * pow(((M_m * D_m) / (2.0 * d)), 2.0)) <= -2e+31) {
tmp = sqrt(fma((-0.25 * h), ((((D_m * D_m) * M_m) / ((d * d) * l)) * M_m), 1.0)) * w0;
} else {
tmp = 1.0 * 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(h / l) * (Float64(Float64(M_m * D_m) / Float64(2.0 * d)) ^ 2.0)) <= -2e+31) tmp = Float64(sqrt(fma(Float64(-0.25 * h), Float64(Float64(Float64(Float64(D_m * D_m) * M_m) / Float64(Float64(d * d) * l)) * M_m), 1.0)) * w0); else tmp = Float64(1.0 * 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[(h / l), $MachinePrecision] * N[Power[N[(N[(M$95$m * D$95$m), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], -2e+31], N[(N[Sqrt[N[(N[(-0.25 * h), $MachinePrecision] * N[(N[(N[(N[(D$95$m * D$95$m), $MachinePrecision] * M$95$m), $MachinePrecision] / N[(N[(d * d), $MachinePrecision] * l), $MachinePrecision]), $MachinePrecision] * M$95$m), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision] * w0), $MachinePrecision], N[(1.0 * w0), $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}\;\frac{h}{\ell} \cdot {\left(\frac{M\_m \cdot D\_m}{2 \cdot d}\right)}^{2} \leq -2 \cdot 10^{+31}:\\
\;\;\;\;\sqrt{\mathsf{fma}\left(-0.25 \cdot h, \frac{\left(D\_m \cdot D\_m\right) \cdot M\_m}{\left(d \cdot d\right) \cdot \ell} \cdot M\_m, 1\right)} \cdot w0\\
\mathbf{else}:\\
\;\;\;\;1 \cdot 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.9999999999999999e31Initial program 65.6%
Taylor expanded in h around 0
+-commutativeN/A
associate-*r/N/A
associate-*r*N/A
associate-*r*N/A
associate-*l/N/A
associate-*r/N/A
lft-mult-inverseN/A
distribute-rgt-inN/A
distribute-lft-inN/A
associate-*r*N/A
rgt-mult-inverseN/A
lower-fma.f64N/A
Applied rewrites48.3%
Taylor expanded in h around inf
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
distribute-lft-inN/A
associate-*r*N/A
rgt-mult-inverseN/A
lower-fma.f64N/A
Applied rewrites48.8%
Applied rewrites50.0%
if -1.9999999999999999e31 < (*.f64 (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) (/.f64 h l)) Initial program 91.1%
Taylor expanded in h around 0
Applied rewrites94.2%
Final simplification81.3%
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 (<= (* (/ h l) (pow (/ (* M_m D_m) (* 2.0 d)) 2.0)) -5e+137) (fma (* -0.125 w0) (/ (* (* h M_m) (* (* D_m D_m) M_m)) (* (* d d) l)) w0) (* 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 (((h / l) * pow(((M_m * D_m) / (2.0 * d)), 2.0)) <= -5e+137) {
tmp = fma((-0.125 * w0), (((h * M_m) * ((D_m * D_m) * M_m)) / ((d * d) * l)), w0);
} else {
tmp = 1.0 * 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(h / l) * (Float64(Float64(M_m * D_m) / Float64(2.0 * d)) ^ 2.0)) <= -5e+137) tmp = fma(Float64(-0.125 * w0), Float64(Float64(Float64(h * M_m) * Float64(Float64(D_m * D_m) * M_m)) / Float64(Float64(d * d) * l)), w0); else tmp = Float64(1.0 * 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[(h / l), $MachinePrecision] * N[Power[N[(N[(M$95$m * D$95$m), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], -5e+137], N[(N[(-0.125 * w0), $MachinePrecision] * N[(N[(N[(h * M$95$m), $MachinePrecision] * N[(N[(D$95$m * D$95$m), $MachinePrecision] * M$95$m), $MachinePrecision]), $MachinePrecision] / N[(N[(d * d), $MachinePrecision] * l), $MachinePrecision]), $MachinePrecision] + w0), $MachinePrecision], N[(1.0 * w0), $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}\;\frac{h}{\ell} \cdot {\left(\frac{M\_m \cdot D\_m}{2 \cdot d}\right)}^{2} \leq -5 \cdot 10^{+137}:\\
\;\;\;\;\mathsf{fma}\left(-0.125 \cdot w0, \frac{\left(h \cdot M\_m\right) \cdot \left(\left(D\_m \cdot D\_m\right) \cdot M\_m\right)}{\left(d \cdot d\right) \cdot \ell}, w0\right)\\
\mathbf{else}:\\
\;\;\;\;1 \cdot 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)) < -5.0000000000000002e137Initial program 63.2%
Taylor expanded in h around 0
Applied rewrites5.1%
Taylor expanded in h around 0
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
Applied rewrites44.0%
Taylor expanded in w0 around 0
Applied rewrites49.0%
Applied rewrites47.4%
if -5.0000000000000002e137 < (*.f64 (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) (/.f64 h l)) Initial program 91.3%
Taylor expanded in h around 0
Applied rewrites91.9%
Final simplification79.8%
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
(*
(sqrt
(fma
(/ (/ (* (* M_m D_m) -0.5) d) l)
(/ (* (* (/ 0.5 d) M_m) D_m) (pow h -1.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) {
return sqrt(fma(((((M_m * D_m) * -0.5) / d) / l), ((((0.5 / d) * M_m) * D_m) / pow(h, -1.0)), 1.0)) * 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 Float64(sqrt(fma(Float64(Float64(Float64(Float64(M_m * D_m) * -0.5) / d) / l), Float64(Float64(Float64(Float64(0.5 / d) * M_m) * D_m) / (h ^ -1.0)), 1.0)) * 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_] := N[(N[Sqrt[N[(N[(N[(N[(N[(M$95$m * D$95$m), $MachinePrecision] * -0.5), $MachinePrecision] / d), $MachinePrecision] / l), $MachinePrecision] * N[(N[(N[(N[(0.5 / d), $MachinePrecision] * M$95$m), $MachinePrecision] * D$95$m), $MachinePrecision] / N[Power[h, -1.0], $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision] * w0), $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])\\
\\
\sqrt{\mathsf{fma}\left(\frac{\frac{\left(M\_m \cdot D\_m\right) \cdot -0.5}{d}}{\ell}, \frac{\left(\frac{0.5}{d} \cdot M\_m\right) \cdot D\_m}{{h}^{-1}}, 1\right)} \cdot w0
\end{array}
Initial program 83.6%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
distribute-lft-neg-inN/A
lift-/.f64N/A
clear-numN/A
un-div-invN/A
lift-pow.f64N/A
unpow2N/A
distribute-lft-neg-inN/A
div-invN/A
times-fracN/A
lower-fma.f64N/A
Applied rewrites89.7%
Final simplification89.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) 5e+202) (* 1.0 w0) (fma (* -0.125 w0) (/ (* (* (* M_m M_m) D_m) (* h D_m)) (* (* 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) <= 5e+202) {
tmp = 1.0 * w0;
} else {
tmp = fma((-0.125 * w0), ((((M_m * M_m) * D_m) * (h * D_m)) / ((d * d) * l)), 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(M_m * D_m) / Float64(2.0 * d)) ^ 2.0) <= 5e+202) tmp = Float64(1.0 * w0); else tmp = fma(Float64(-0.125 * w0), Float64(Float64(Float64(Float64(M_m * M_m) * D_m) * Float64(h * D_m)) / Float64(Float64(d * d) * l)), 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[Power[N[(N[(M$95$m * D$95$m), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], 5e+202], N[(1.0 * w0), $MachinePrecision], N[(N[(-0.125 * w0), $MachinePrecision] * N[(N[(N[(N[(M$95$m * M$95$m), $MachinePrecision] * D$95$m), $MachinePrecision] * N[(h * D$95$m), $MachinePrecision]), $MachinePrecision] / N[(N[(d * d), $MachinePrecision] * l), $MachinePrecision]), $MachinePrecision] + w0), $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}\;{\left(\frac{M\_m \cdot D\_m}{2 \cdot d}\right)}^{2} \leq 5 \cdot 10^{+202}:\\
\;\;\;\;1 \cdot w0\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-0.125 \cdot w0, \frac{\left(\left(M\_m \cdot M\_m\right) \cdot D\_m\right) \cdot \left(h \cdot D\_m\right)}{\left(d \cdot d\right) \cdot \ell}, w0\right)\\
\end{array}
\end{array}
if (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) < 4.9999999999999999e202Initial program 91.6%
Taylor expanded in h around 0
Applied rewrites88.2%
if 4.9999999999999999e202 < (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) Initial program 60.6%
Taylor expanded in h around 0
Applied rewrites10.5%
Taylor expanded in h around 0
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
Applied rewrites49.6%
Taylor expanded in w0 around 0
Applied rewrites53.1%
Applied rewrites53.1%
Final simplification79.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 (if (<= (pow (/ (* M_m D_m) (* 2.0 d)) 2.0) 1e+193) (* 1.0 w0) (fma (* -0.125 w0) (* (/ (* (* (* M_m M_m) h) D_m) (* (* d d) l)) D_m) 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) <= 1e+193) {
tmp = 1.0 * w0;
} else {
tmp = fma((-0.125 * w0), (((((M_m * M_m) * h) * D_m) / ((d * d) * l)) * D_m), 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(M_m * D_m) / Float64(2.0 * d)) ^ 2.0) <= 1e+193) tmp = Float64(1.0 * w0); else tmp = fma(Float64(-0.125 * w0), Float64(Float64(Float64(Float64(Float64(M_m * M_m) * h) * D_m) / Float64(Float64(d * d) * l)) * D_m), 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[Power[N[(N[(M$95$m * D$95$m), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision], 1e+193], N[(1.0 * w0), $MachinePrecision], N[(N[(-0.125 * w0), $MachinePrecision] * N[(N[(N[(N[(N[(M$95$m * M$95$m), $MachinePrecision] * h), $MachinePrecision] * D$95$m), $MachinePrecision] / N[(N[(d * d), $MachinePrecision] * l), $MachinePrecision]), $MachinePrecision] * D$95$m), $MachinePrecision] + w0), $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}\;{\left(\frac{M\_m \cdot D\_m}{2 \cdot d}\right)}^{2} \leq 10^{+193}:\\
\;\;\;\;1 \cdot w0\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-0.125 \cdot w0, \frac{\left(\left(M\_m \cdot M\_m\right) \cdot h\right) \cdot D\_m}{\left(d \cdot d\right) \cdot \ell} \cdot D\_m, w0\right)\\
\end{array}
\end{array}
if (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) < 1.00000000000000007e193Initial program 91.6%
Taylor expanded in h around 0
Applied rewrites88.6%
if 1.00000000000000007e193 < (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) Initial program 61.7%
Taylor expanded in h around 0
Applied rewrites11.7%
Taylor expanded in h around 0
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
Applied rewrites49.6%
Taylor expanded in w0 around 0
Applied rewrites54.5%
Applied rewrites54.4%
Final simplification79.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
(if (<= (/ (* M_m D_m) (* 2.0 d)) 5e+51)
(*
(sqrt (fma (* -0.25 h) (* (* (* (/ M_m l) M_m) (/ D_m d)) (/ D_m d)) 1.0))
w0)
(*
(sqrt
(fma
(* (/ (* (* M_m D_m) -0.5) (* l d)) h)
(* (* (/ 0.5 d) M_m) D_m)
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 (((M_m * D_m) / (2.0 * d)) <= 5e+51) {
tmp = sqrt(fma((-0.25 * h), ((((M_m / l) * M_m) * (D_m / d)) * (D_m / d)), 1.0)) * w0;
} else {
tmp = sqrt(fma(((((M_m * D_m) * -0.5) / (l * d)) * h), (((0.5 / d) * M_m) * D_m), 1.0)) * 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(M_m * D_m) / Float64(2.0 * d)) <= 5e+51) tmp = Float64(sqrt(fma(Float64(-0.25 * h), Float64(Float64(Float64(Float64(M_m / l) * M_m) * Float64(D_m / d)) * Float64(D_m / d)), 1.0)) * w0); else tmp = Float64(sqrt(fma(Float64(Float64(Float64(Float64(M_m * D_m) * -0.5) / Float64(l * d)) * h), Float64(Float64(Float64(0.5 / d) * M_m) * D_m), 1.0)) * 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[(M$95$m * D$95$m), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision], 5e+51], N[(N[Sqrt[N[(N[(-0.25 * h), $MachinePrecision] * N[(N[(N[(N[(M$95$m / l), $MachinePrecision] * M$95$m), $MachinePrecision] * N[(D$95$m / d), $MachinePrecision]), $MachinePrecision] * N[(D$95$m / d), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision] * w0), $MachinePrecision], N[(N[Sqrt[N[(N[(N[(N[(N[(M$95$m * D$95$m), $MachinePrecision] * -0.5), $MachinePrecision] / N[(l * d), $MachinePrecision]), $MachinePrecision] * h), $MachinePrecision] * N[(N[(N[(0.5 / d), $MachinePrecision] * M$95$m), $MachinePrecision] * D$95$m), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision] * w0), $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}\;\frac{M\_m \cdot D\_m}{2 \cdot d} \leq 5 \cdot 10^{+51}:\\
\;\;\;\;\sqrt{\mathsf{fma}\left(-0.25 \cdot h, \left(\left(\frac{M\_m}{\ell} \cdot M\_m\right) \cdot \frac{D\_m}{d}\right) \cdot \frac{D\_m}{d}, 1\right)} \cdot w0\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\mathsf{fma}\left(\frac{\left(M\_m \cdot D\_m\right) \cdot -0.5}{\ell \cdot d} \cdot h, \left(\frac{0.5}{d} \cdot M\_m\right) \cdot D\_m, 1\right)} \cdot w0\\
\end{array}
\end{array}
if (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) < 5e51Initial program 86.3%
Taylor expanded in h around 0
+-commutativeN/A
associate-*r/N/A
associate-*r*N/A
associate-*r*N/A
associate-*l/N/A
associate-*r/N/A
lft-mult-inverseN/A
distribute-rgt-inN/A
distribute-lft-inN/A
associate-*r*N/A
rgt-mult-inverseN/A
lower-fma.f64N/A
Applied rewrites64.2%
Taylor expanded in h around inf
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
distribute-lft-inN/A
associate-*r*N/A
rgt-mult-inverseN/A
lower-fma.f64N/A
Applied rewrites64.4%
Applied rewrites75.9%
Applied rewrites84.9%
if 5e51 < (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) Initial program 70.3%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-rgt-neg-inN/A
lift-pow.f64N/A
unpow2N/A
distribute-lft-neg-inN/A
associate-*r*N/A
lower-fma.f64N/A
Applied rewrites77.3%
lift-*.f64N/A
lift-/.f64N/A
lift-/.f64N/A
frac-timesN/A
lower-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
lower-*.f6477.1
Applied rewrites77.1%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6477.1
lift-*.f64N/A
*-commutativeN/A
lower-*.f6477.1
lift-*.f64N/A
*-commutativeN/A
lift-*.f6477.1
Applied rewrites77.1%
Final simplification83.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 (* (/ 0.5 d) M_m)))
(if (<= (* 2.0 d) 2e-109)
(* (sqrt (fma t_0 (* (* (/ -0.5 d) (/ (* M_m D_m) l)) (* h D_m)) 1.0)) w0)
(*
(sqrt (fma (* (/ (* (* M_m D_m) -0.5) (* l d)) h) (* t_0 D_m) 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 = (0.5 / d) * M_m;
double tmp;
if ((2.0 * d) <= 2e-109) {
tmp = sqrt(fma(t_0, (((-0.5 / d) * ((M_m * D_m) / l)) * (h * D_m)), 1.0)) * w0;
} else {
tmp = sqrt(fma(((((M_m * D_m) * -0.5) / (l * d)) * h), (t_0 * D_m), 1.0)) * 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(0.5 / d) * M_m) tmp = 0.0 if (Float64(2.0 * d) <= 2e-109) tmp = Float64(sqrt(fma(t_0, Float64(Float64(Float64(-0.5 / d) * Float64(Float64(M_m * D_m) / l)) * Float64(h * D_m)), 1.0)) * w0); else tmp = Float64(sqrt(fma(Float64(Float64(Float64(Float64(M_m * D_m) * -0.5) / Float64(l * d)) * h), Float64(t_0 * D_m), 1.0)) * 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[(0.5 / d), $MachinePrecision] * M$95$m), $MachinePrecision]}, If[LessEqual[N[(2.0 * d), $MachinePrecision], 2e-109], N[(N[Sqrt[N[(t$95$0 * N[(N[(N[(-0.5 / d), $MachinePrecision] * N[(N[(M$95$m * D$95$m), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision] * N[(h * D$95$m), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision] * w0), $MachinePrecision], N[(N[Sqrt[N[(N[(N[(N[(N[(M$95$m * D$95$m), $MachinePrecision] * -0.5), $MachinePrecision] / N[(l * d), $MachinePrecision]), $MachinePrecision] * h), $MachinePrecision] * N[(t$95$0 * D$95$m), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision] * w0), $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{0.5}{d} \cdot M\_m\\
\mathbf{if}\;2 \cdot d \leq 2 \cdot 10^{-109}:\\
\;\;\;\;\sqrt{\mathsf{fma}\left(t\_0, \left(\frac{-0.5}{d} \cdot \frac{M\_m \cdot D\_m}{\ell}\right) \cdot \left(h \cdot D\_m\right), 1\right)} \cdot w0\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\mathsf{fma}\left(\frac{\left(M\_m \cdot D\_m\right) \cdot -0.5}{\ell \cdot d} \cdot h, t\_0 \cdot D\_m, 1\right)} \cdot w0\\
\end{array}
\end{array}
if (*.f64 #s(literal 2 binary64) d) < 2e-109Initial program 81.7%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
distribute-lft-neg-inN/A
lift-/.f64N/A
clear-numN/A
un-div-invN/A
lift-pow.f64N/A
unpow2N/A
distribute-lft-neg-inN/A
div-invN/A
times-fracN/A
lower-fma.f64N/A
Applied rewrites88.5%
lift-fma.f64N/A
*-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
associate-*l*N/A
lower-fma.f64N/A
Applied rewrites83.0%
if 2e-109 < (*.f64 #s(literal 2 binary64) d) Initial program 87.5%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-rgt-neg-inN/A
lift-pow.f64N/A
unpow2N/A
distribute-lft-neg-inN/A
associate-*r*N/A
lower-fma.f64N/A
Applied rewrites88.1%
lift-*.f64N/A
lift-/.f64N/A
lift-/.f64N/A
frac-timesN/A
lower-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
lower-*.f6488.6
Applied rewrites88.6%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6492.0
lift-*.f64N/A
*-commutativeN/A
lower-*.f6492.0
lift-*.f64N/A
*-commutativeN/A
lift-*.f6492.0
Applied rewrites92.0%
Final simplification86.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 (<= (* M_m D_m) 2e-73)
(* 1.0 w0)
(if (<= (* M_m D_m) 5e+221)
(*
(sqrt
(fma (* -0.25 h) (* (/ (* (* M_m M_m) D_m) (* (* d d) l)) D_m) 1.0))
w0)
(fma
(* -0.125 w0)
(* (/ (* (* (* M_m M_m) h) D_m) (* l d)) (/ 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 tmp;
if ((M_m * D_m) <= 2e-73) {
tmp = 1.0 * w0;
} else if ((M_m * D_m) <= 5e+221) {
tmp = sqrt(fma((-0.25 * h), ((((M_m * M_m) * D_m) / ((d * d) * l)) * D_m), 1.0)) * w0;
} else {
tmp = fma((-0.125 * w0), (((((M_m * M_m) * h) * D_m) / (l * d)) * (D_m / d)), 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(M_m * D_m) <= 2e-73) tmp = Float64(1.0 * w0); elseif (Float64(M_m * D_m) <= 5e+221) tmp = Float64(sqrt(fma(Float64(-0.25 * h), Float64(Float64(Float64(Float64(M_m * M_m) * D_m) / Float64(Float64(d * d) * l)) * D_m), 1.0)) * w0); else tmp = fma(Float64(-0.125 * w0), Float64(Float64(Float64(Float64(Float64(M_m * M_m) * h) * D_m) / Float64(l * d)) * Float64(D_m / d)), 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[(M$95$m * D$95$m), $MachinePrecision], 2e-73], N[(1.0 * w0), $MachinePrecision], If[LessEqual[N[(M$95$m * D$95$m), $MachinePrecision], 5e+221], N[(N[Sqrt[N[(N[(-0.25 * h), $MachinePrecision] * N[(N[(N[(N[(M$95$m * M$95$m), $MachinePrecision] * D$95$m), $MachinePrecision] / N[(N[(d * d), $MachinePrecision] * l), $MachinePrecision]), $MachinePrecision] * D$95$m), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision] * w0), $MachinePrecision], N[(N[(-0.125 * w0), $MachinePrecision] * N[(N[(N[(N[(N[(M$95$m * M$95$m), $MachinePrecision] * h), $MachinePrecision] * D$95$m), $MachinePrecision] / N[(l * d), $MachinePrecision]), $MachinePrecision] * N[(D$95$m / d), $MachinePrecision]), $MachinePrecision] + w0), $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 \cdot D\_m \leq 2 \cdot 10^{-73}:\\
\;\;\;\;1 \cdot w0\\
\mathbf{elif}\;M\_m \cdot D\_m \leq 5 \cdot 10^{+221}:\\
\;\;\;\;\sqrt{\mathsf{fma}\left(-0.25 \cdot h, \frac{\left(M\_m \cdot M\_m\right) \cdot D\_m}{\left(d \cdot d\right) \cdot \ell} \cdot D\_m, 1\right)} \cdot w0\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-0.125 \cdot w0, \frac{\left(\left(M\_m \cdot M\_m\right) \cdot h\right) \cdot D\_m}{\ell \cdot d} \cdot \frac{D\_m}{d}, w0\right)\\
\end{array}
\end{array}
if (*.f64 M D) < 1.99999999999999999e-73Initial program 84.0%
Taylor expanded in h around 0
Applied rewrites73.6%
if 1.99999999999999999e-73 < (*.f64 M D) < 5.0000000000000002e221Initial program 81.0%
Taylor expanded in h around 0
+-commutativeN/A
associate-*r/N/A
associate-*r*N/A
associate-*r*N/A
associate-*l/N/A
associate-*r/N/A
lft-mult-inverseN/A
distribute-rgt-inN/A
distribute-lft-inN/A
associate-*r*N/A
rgt-mult-inverseN/A
lower-fma.f64N/A
Applied rewrites52.0%
Applied rewrites58.0%
if 5.0000000000000002e221 < (*.f64 M D) Initial program 87.6%
Taylor expanded in h around 0
Applied rewrites17.3%
Taylor expanded in h around 0
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
Applied rewrites53.3%
Taylor expanded in w0 around 0
Applied rewrites53.6%
Applied rewrites74.3%
Final simplification70.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
(*
(sqrt
(fma
(* (* (/ 0.5 d) M_m) D_m)
(/ (* (* (/ M_m d) h) (* 0.5 D_m)) (- 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) {
return sqrt(fma((((0.5 / d) * M_m) * D_m), ((((M_m / d) * h) * (0.5 * D_m)) / -l), 1.0)) * 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 Float64(sqrt(fma(Float64(Float64(Float64(0.5 / d) * M_m) * D_m), Float64(Float64(Float64(Float64(M_m / d) * h) * Float64(0.5 * D_m)) / Float64(-l)), 1.0)) * 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_] := N[(N[Sqrt[N[(N[(N[(N[(0.5 / d), $MachinePrecision] * M$95$m), $MachinePrecision] * D$95$m), $MachinePrecision] * N[(N[(N[(N[(M$95$m / d), $MachinePrecision] * h), $MachinePrecision] * N[(0.5 * D$95$m), $MachinePrecision]), $MachinePrecision] / (-l)), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision] * w0), $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])\\
\\
\sqrt{\mathsf{fma}\left(\left(\frac{0.5}{d} \cdot M\_m\right) \cdot D\_m, \frac{\left(\frac{M\_m}{d} \cdot h\right) \cdot \left(0.5 \cdot D\_m\right)}{-\ell}, 1\right)} \cdot w0
\end{array}
Initial program 83.6%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
distribute-neg-frac2N/A
lift-pow.f64N/A
unpow2N/A
associate-*l*N/A
associate-/l*N/A
lower-fma.f64N/A
Applied rewrites88.6%
Final simplification88.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 (<= D_m 5.5e-36)
(* 1.0 w0)
(*
(sqrt
(fma
(* (/ (* (* M_m D_m) -0.5) (* l d)) h)
(* (* (/ 0.5 d) M_m) D_m)
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 (D_m <= 5.5e-36) {
tmp = 1.0 * w0;
} else {
tmp = sqrt(fma(((((M_m * D_m) * -0.5) / (l * d)) * h), (((0.5 / d) * M_m) * D_m), 1.0)) * 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 (D_m <= 5.5e-36) tmp = Float64(1.0 * w0); else tmp = Float64(sqrt(fma(Float64(Float64(Float64(Float64(M_m * D_m) * -0.5) / Float64(l * d)) * h), Float64(Float64(Float64(0.5 / d) * M_m) * D_m), 1.0)) * 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[D$95$m, 5.5e-36], N[(1.0 * w0), $MachinePrecision], N[(N[Sqrt[N[(N[(N[(N[(N[(M$95$m * D$95$m), $MachinePrecision] * -0.5), $MachinePrecision] / N[(l * d), $MachinePrecision]), $MachinePrecision] * h), $MachinePrecision] * N[(N[(N[(0.5 / d), $MachinePrecision] * M$95$m), $MachinePrecision] * D$95$m), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision] * w0), $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}\;D\_m \leq 5.5 \cdot 10^{-36}:\\
\;\;\;\;1 \cdot w0\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\mathsf{fma}\left(\frac{\left(M\_m \cdot D\_m\right) \cdot -0.5}{\ell \cdot d} \cdot h, \left(\frac{0.5}{d} \cdot M\_m\right) \cdot D\_m, 1\right)} \cdot w0\\
\end{array}
\end{array}
if D < 5.49999999999999984e-36Initial program 85.6%
Taylor expanded in h around 0
Applied rewrites72.4%
if 5.49999999999999984e-36 < D Initial program 78.2%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-rgt-neg-inN/A
lift-pow.f64N/A
unpow2N/A
distribute-lft-neg-inN/A
associate-*r*N/A
lower-fma.f64N/A
Applied rewrites79.6%
lift-*.f64N/A
lift-/.f64N/A
lift-/.f64N/A
frac-timesN/A
lower-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
lower-*.f6481.3
Applied rewrites81.3%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6484.2
lift-*.f64N/A
*-commutativeN/A
lower-*.f6484.2
lift-*.f64N/A
*-commutativeN/A
lift-*.f6484.2
Applied rewrites84.2%
Final simplification75.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 (<= (* M_m D_m) 2e-73)
(* 1.0 w0)
(*
(sqrt (fma (* -0.25 h) (* (/ (* M_m D_m) (* (* d d) l)) (* M_m D_m)) 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 ((M_m * D_m) <= 2e-73) {
tmp = 1.0 * w0;
} else {
tmp = sqrt(fma((-0.25 * h), (((M_m * D_m) / ((d * d) * l)) * (M_m * D_m)), 1.0)) * 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(M_m * D_m) <= 2e-73) tmp = Float64(1.0 * w0); else tmp = Float64(sqrt(fma(Float64(-0.25 * h), Float64(Float64(Float64(M_m * D_m) / Float64(Float64(d * d) * l)) * Float64(M_m * D_m)), 1.0)) * 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[(M$95$m * D$95$m), $MachinePrecision], 2e-73], N[(1.0 * w0), $MachinePrecision], N[(N[Sqrt[N[(N[(-0.25 * h), $MachinePrecision] * N[(N[(N[(M$95$m * D$95$m), $MachinePrecision] / N[(N[(d * d), $MachinePrecision] * l), $MachinePrecision]), $MachinePrecision] * N[(M$95$m * D$95$m), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision] * w0), $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 \cdot D\_m \leq 2 \cdot 10^{-73}:\\
\;\;\;\;1 \cdot w0\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\mathsf{fma}\left(-0.25 \cdot h, \frac{M\_m \cdot D\_m}{\left(d \cdot d\right) \cdot \ell} \cdot \left(M\_m \cdot D\_m\right), 1\right)} \cdot w0\\
\end{array}
\end{array}
if (*.f64 M D) < 1.99999999999999999e-73Initial program 84.0%
Taylor expanded in h around 0
Applied rewrites73.6%
if 1.99999999999999999e-73 < (*.f64 M D) Initial program 82.5%
Taylor expanded in h around 0
+-commutativeN/A
associate-*r/N/A
associate-*r*N/A
associate-*r*N/A
associate-*l/N/A
associate-*r/N/A
lft-mult-inverseN/A
distribute-rgt-inN/A
distribute-lft-inN/A
associate-*r*N/A
rgt-mult-inverseN/A
lower-fma.f64N/A
Applied rewrites52.4%
Applied rewrites61.4%
Applied rewrites75.4%
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 (* 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) {
return 1.0 * 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 = 1.0d0 * 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 1.0 * 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 1.0 * 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 Float64(1.0 * 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 = 1.0 * 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_] := N[(1.0 * w0), $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])\\
\\
1 \cdot w0
\end{array}
Initial program 83.6%
Taylor expanded in h around 0
Applied rewrites68.2%
Final simplification68.2%
herbie shell --seed 2024241
(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))))))