
(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)
D_m = (fabs.f64 D)
M_m = (fabs.f64 M)
(FPCore (w0 M_m D_m h l d_m)
:precision binary64
(let* ((t_0 (/ (* M_m D_m) (* 2.0 d_m))))
(if (<= t_0 1e-151)
w0
(if (<= t_0 5e+257)
(* w0 (sqrt (fma t_0 (* (/ (* M_m D_m) (* d_m -2.0)) (/ h l)) 1.0)))
(*
(fabs M_m)
(* D_m (* w0 (sqrt (/ (* h -0.25) (* d_m (* d_m l)))))))))))d_m = fabs(d);
D_m = fabs(D);
M_m = fabs(M);
double code(double w0, double M_m, double D_m, double h, double l, double d_m) {
double t_0 = (M_m * D_m) / (2.0 * d_m);
double tmp;
if (t_0 <= 1e-151) {
tmp = w0;
} else if (t_0 <= 5e+257) {
tmp = w0 * sqrt(fma(t_0, (((M_m * D_m) / (d_m * -2.0)) * (h / l)), 1.0));
} else {
tmp = fabs(M_m) * (D_m * (w0 * sqrt(((h * -0.25) / (d_m * (d_m * l))))));
}
return tmp;
}
d_m = abs(d) D_m = abs(D) M_m = abs(M) function code(w0, M_m, D_m, h, l, d_m) t_0 = Float64(Float64(M_m * D_m) / Float64(2.0 * d_m)) tmp = 0.0 if (t_0 <= 1e-151) tmp = w0; elseif (t_0 <= 5e+257) tmp = Float64(w0 * sqrt(fma(t_0, Float64(Float64(Float64(M_m * D_m) / Float64(d_m * -2.0)) * Float64(h / l)), 1.0))); else tmp = Float64(abs(M_m) * Float64(D_m * Float64(w0 * sqrt(Float64(Float64(h * -0.25) / Float64(d_m * Float64(d_m * l))))))); end return tmp end
d_m = N[Abs[d], $MachinePrecision]
D_m = N[Abs[D], $MachinePrecision]
M_m = N[Abs[M], $MachinePrecision]
code[w0_, M$95$m_, D$95$m_, h_, l_, d$95$m_] := Block[{t$95$0 = N[(N[(M$95$m * D$95$m), $MachinePrecision] / N[(2.0 * d$95$m), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, 1e-151], w0, If[LessEqual[t$95$0, 5e+257], N[(w0 * N[Sqrt[N[(t$95$0 * N[(N[(N[(M$95$m * D$95$m), $MachinePrecision] / N[(d$95$m * -2.0), $MachinePrecision]), $MachinePrecision] * N[(h / l), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[Abs[M$95$m], $MachinePrecision] * N[(D$95$m * N[(w0 * N[Sqrt[N[(N[(h * -0.25), $MachinePrecision] / N[(d$95$m * N[(d$95$m * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
d_m = \left|d\right|
\\
D_m = \left|D\right|
\\
M_m = \left|M\right|
\\
\begin{array}{l}
t_0 := \frac{M\_m \cdot D\_m}{2 \cdot d\_m}\\
\mathbf{if}\;t\_0 \leq 10^{-151}:\\
\;\;\;\;w0\\
\mathbf{elif}\;t\_0 \leq 5 \cdot 10^{+257}:\\
\;\;\;\;w0 \cdot \sqrt{\mathsf{fma}\left(t\_0, \frac{M\_m \cdot D\_m}{d\_m \cdot -2} \cdot \frac{h}{\ell}, 1\right)}\\
\mathbf{else}:\\
\;\;\;\;\left|M\_m\right| \cdot \left(D\_m \cdot \left(w0 \cdot \sqrt{\frac{h \cdot -0.25}{d\_m \cdot \left(d\_m \cdot \ell\right)}}\right)\right)\\
\end{array}
\end{array}
if (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) < 9.9999999999999994e-152Initial program 85.4%
Taylor expanded in M around 0
Applied rewrites80.6%
*-rgt-identity80.6
Applied rewrites80.6%
if 9.9999999999999994e-152 < (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) < 5.00000000000000028e257Initial program 92.1%
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 rewrites95.0%
if 5.00000000000000028e257 < (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) Initial program 58.3%
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-*.f6454.0
Applied rewrites54.0%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
lift-*.f64N/A
associate-/l*N/A
lower-*.f64N/A
Applied rewrites54.0%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-sqrt.f64N/A
*-commutativeN/A
lower-*.f6454.0
Applied rewrites63.1%
lift-*.f64N/A
lift-fabs.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-*.f64N/A
lift-sqrt.f64N/A
associate-*l*N/A
lift-fabs.f64N/A
lift-*.f64N/A
fabs-mulN/A
associate-*l*N/A
lower-*.f64N/A
lower-fabs.f64N/A
Applied rewrites48.2%
d_m = (fabs.f64 d)
D_m = (fabs.f64 D)
M_m = (fabs.f64 M)
(FPCore (w0 M_m D_m h l d_m)
:precision binary64
(if (<=
(* w0 (sqrt (- 1.0 (* (/ h l) (pow (/ (* M_m D_m) (* 2.0 d_m)) 2.0)))))
4e+270)
w0
(*
w0
(fma (* D_m D_m) (* (* M_m (* M_m h)) (/ -0.125 (* d_m (* d_m l)))) 1.0))))d_m = fabs(d);
D_m = fabs(D);
M_m = fabs(M);
double code(double w0, double M_m, double D_m, double h, double l, double d_m) {
double tmp;
if ((w0 * sqrt((1.0 - ((h / l) * pow(((M_m * D_m) / (2.0 * d_m)), 2.0))))) <= 4e+270) {
tmp = w0;
} else {
tmp = w0 * fma((D_m * D_m), ((M_m * (M_m * h)) * (-0.125 / (d_m * (d_m * l)))), 1.0);
}
return tmp;
}
d_m = abs(d) D_m = abs(D) M_m = abs(M) function code(w0, M_m, D_m, h, l, d_m) tmp = 0.0 if (Float64(w0 * sqrt(Float64(1.0 - Float64(Float64(h / l) * (Float64(Float64(M_m * D_m) / Float64(2.0 * d_m)) ^ 2.0))))) <= 4e+270) tmp = w0; else tmp = Float64(w0 * fma(Float64(D_m * D_m), Float64(Float64(M_m * Float64(M_m * h)) * Float64(-0.125 / Float64(d_m * Float64(d_m * l)))), 1.0)); end return tmp end
d_m = N[Abs[d], $MachinePrecision] D_m = N[Abs[D], $MachinePrecision] M_m = N[Abs[M], $MachinePrecision] code[w0_, M$95$m_, D$95$m_, h_, l_, d$95$m_] := If[LessEqual[N[(w0 * N[Sqrt[N[(1.0 - N[(N[(h / l), $MachinePrecision] * N[Power[N[(N[(M$95$m * D$95$m), $MachinePrecision] / N[(2.0 * d$95$m), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 4e+270], w0, N[(w0 * N[(N[(D$95$m * D$95$m), $MachinePrecision] * N[(N[(M$95$m * N[(M$95$m * h), $MachinePrecision]), $MachinePrecision] * N[(-0.125 / N[(d$95$m * N[(d$95$m * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
d_m = \left|d\right|
\\
D_m = \left|D\right|
\\
M_m = \left|M\right|
\\
\begin{array}{l}
\mathbf{if}\;w0 \cdot \sqrt{1 - \frac{h}{\ell} \cdot {\left(\frac{M\_m \cdot D\_m}{2 \cdot d\_m}\right)}^{2}} \leq 4 \cdot 10^{+270}:\\
\;\;\;\;w0\\
\mathbf{else}:\\
\;\;\;\;w0 \cdot \mathsf{fma}\left(D\_m \cdot D\_m, \left(M\_m \cdot \left(M\_m \cdot h\right)\right) \cdot \frac{-0.125}{d\_m \cdot \left(d\_m \cdot \ell\right)}, 1\right)\\
\end{array}
\end{array}
if (*.f64 w0 (sqrt.f64 (-.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))))) < 4.0000000000000002e270Initial program 96.1%
Taylor expanded in M around 0
Applied rewrites81.5%
*-rgt-identity81.5
Applied rewrites81.5%
if 4.0000000000000002e270 < (*.f64 w0 (sqrt.f64 (-.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 40.6%
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 rewrites72.5%
Taylor expanded in M around 0
associate-*r/N/A
lower-/.f64N/A
lower-*.f64N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f6470.4
Applied rewrites70.4%
Taylor expanded in M around 0
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites59.2%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-/l*N/A
lower-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-/.f6457.5
Applied rewrites57.5%
Final simplification76.3%
d_m = (fabs.f64 d) D_m = (fabs.f64 D) M_m = (fabs.f64 M) (FPCore (w0 M_m D_m h l d_m) :precision binary64 (if (<= (* (/ h l) (pow (/ (* M_m D_m) (* 2.0 d_m)) 2.0)) -40000.0) (* w0 (* (fabs (* M_m D_m)) (sqrt (* -0.25 (/ (/ h (* d_m l)) d_m))))) w0))
d_m = fabs(d);
D_m = fabs(D);
M_m = fabs(M);
double code(double w0, double M_m, double D_m, double h, double l, double d_m) {
double tmp;
if (((h / l) * pow(((M_m * D_m) / (2.0 * d_m)), 2.0)) <= -40000.0) {
tmp = w0 * (fabs((M_m * D_m)) * sqrt((-0.25 * ((h / (d_m * l)) / d_m))));
} else {
tmp = w0;
}
return tmp;
}
d_m = abs(d)
D_m = abs(d)
M_m = abs(m)
real(8) function code(w0, m_m, d_m, h, l, d_m_1)
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_m_1
real(8) :: tmp
if (((h / l) * (((m_m * d_m) / (2.0d0 * d_m_1)) ** 2.0d0)) <= (-40000.0d0)) then
tmp = w0 * (abs((m_m * d_m)) * sqrt(((-0.25d0) * ((h / (d_m_1 * l)) / d_m_1))))
else
tmp = w0
end if
code = tmp
end function
d_m = Math.abs(d);
D_m = Math.abs(D);
M_m = Math.abs(M);
public static double code(double w0, double M_m, double D_m, double h, double l, double d_m) {
double tmp;
if (((h / l) * Math.pow(((M_m * D_m) / (2.0 * d_m)), 2.0)) <= -40000.0) {
tmp = w0 * (Math.abs((M_m * D_m)) * Math.sqrt((-0.25 * ((h / (d_m * l)) / d_m))));
} else {
tmp = w0;
}
return tmp;
}
d_m = math.fabs(d) D_m = math.fabs(D) M_m = math.fabs(M) def code(w0, M_m, D_m, h, l, d_m): tmp = 0 if ((h / l) * math.pow(((M_m * D_m) / (2.0 * d_m)), 2.0)) <= -40000.0: tmp = w0 * (math.fabs((M_m * D_m)) * math.sqrt((-0.25 * ((h / (d_m * l)) / d_m)))) else: tmp = w0 return tmp
d_m = abs(d) D_m = abs(D) M_m = abs(M) function code(w0, M_m, D_m, h, l, d_m) tmp = 0.0 if (Float64(Float64(h / l) * (Float64(Float64(M_m * D_m) / Float64(2.0 * d_m)) ^ 2.0)) <= -40000.0) tmp = Float64(w0 * Float64(abs(Float64(M_m * D_m)) * sqrt(Float64(-0.25 * Float64(Float64(h / Float64(d_m * l)) / d_m))))); else tmp = w0; end return tmp end
d_m = abs(d); D_m = abs(D); M_m = abs(M); function tmp_2 = code(w0, M_m, D_m, h, l, d_m) tmp = 0.0; if (((h / l) * (((M_m * D_m) / (2.0 * d_m)) ^ 2.0)) <= -40000.0) tmp = w0 * (abs((M_m * D_m)) * sqrt((-0.25 * ((h / (d_m * l)) / d_m)))); else tmp = w0; end tmp_2 = tmp; end
d_m = N[Abs[d], $MachinePrecision] D_m = N[Abs[D], $MachinePrecision] M_m = N[Abs[M], $MachinePrecision] code[w0_, M$95$m_, D$95$m_, h_, l_, d$95$m_] := If[LessEqual[N[(N[(h / l), $MachinePrecision] * N[Power[N[(N[(M$95$m * D$95$m), $MachinePrecision] / N[(2.0 * d$95$m), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], -40000.0], N[(w0 * N[(N[Abs[N[(M$95$m * D$95$m), $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[(-0.25 * N[(N[(h / N[(d$95$m * l), $MachinePrecision]), $MachinePrecision] / d$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], w0]
\begin{array}{l}
d_m = \left|d\right|
\\
D_m = \left|D\right|
\\
M_m = \left|M\right|
\\
\begin{array}{l}
\mathbf{if}\;\frac{h}{\ell} \cdot {\left(\frac{M\_m \cdot D\_m}{2 \cdot d\_m}\right)}^{2} \leq -40000:\\
\;\;\;\;w0 \cdot \left(\left|M\_m \cdot D\_m\right| \cdot \sqrt{-0.25 \cdot \frac{\frac{h}{d\_m \cdot \ell}}{d\_m}}\right)\\
\mathbf{else}:\\
\;\;\;\;w0\\
\end{array}
\end{array}
if (*.f64 (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) (/.f64 h l)) < -4e4Initial program 77.9%
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-*.f6448.3
Applied rewrites48.3%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
lift-*.f64N/A
associate-/l*N/A
lower-*.f64N/A
Applied rewrites56.8%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-sqrt.f64N/A
*-commutativeN/A
lower-*.f6456.8
Applied rewrites70.4%
lift-*.f64N/A
*-commutativeN/A
associate-/r*N/A
lower-/.f64N/A
lower-/.f6475.3
Applied rewrites75.3%
if -4e4 < (*.f64 (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) (/.f64 h l)) Initial program 86.1%
Taylor expanded in M around 0
Applied rewrites91.5%
*-rgt-identity91.5
Applied rewrites91.5%
Final simplification87.6%
d_m = (fabs.f64 d) D_m = (fabs.f64 D) M_m = (fabs.f64 M) (FPCore (w0 M_m D_m h l d_m) :precision binary64 (if (<= (- 1.0 (* (/ h l) (pow (/ (* M_m D_m) (* 2.0 d_m)) 2.0))) 2.0) w0 (* (fabs M_m) (* D_m (* w0 (sqrt (/ (* h -0.25) (* d_m (* d_m l)))))))))
d_m = fabs(d);
D_m = fabs(D);
M_m = fabs(M);
double code(double w0, double M_m, double D_m, double h, double l, double d_m) {
double tmp;
if ((1.0 - ((h / l) * pow(((M_m * D_m) / (2.0 * d_m)), 2.0))) <= 2.0) {
tmp = w0;
} else {
tmp = fabs(M_m) * (D_m * (w0 * sqrt(((h * -0.25) / (d_m * (d_m * l))))));
}
return tmp;
}
d_m = abs(d)
D_m = abs(d)
M_m = abs(m)
real(8) function code(w0, m_m, d_m, h, l, d_m_1)
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_m_1
real(8) :: tmp
if ((1.0d0 - ((h / l) * (((m_m * d_m) / (2.0d0 * d_m_1)) ** 2.0d0))) <= 2.0d0) then
tmp = w0
else
tmp = abs(m_m) * (d_m * (w0 * sqrt(((h * (-0.25d0)) / (d_m_1 * (d_m_1 * l))))))
end if
code = tmp
end function
d_m = Math.abs(d);
D_m = Math.abs(D);
M_m = Math.abs(M);
public static double code(double w0, double M_m, double D_m, double h, double l, double d_m) {
double tmp;
if ((1.0 - ((h / l) * Math.pow(((M_m * D_m) / (2.0 * d_m)), 2.0))) <= 2.0) {
tmp = w0;
} else {
tmp = Math.abs(M_m) * (D_m * (w0 * Math.sqrt(((h * -0.25) / (d_m * (d_m * l))))));
}
return tmp;
}
d_m = math.fabs(d) D_m = math.fabs(D) M_m = math.fabs(M) def code(w0, M_m, D_m, h, l, d_m): tmp = 0 if (1.0 - ((h / l) * math.pow(((M_m * D_m) / (2.0 * d_m)), 2.0))) <= 2.0: tmp = w0 else: tmp = math.fabs(M_m) * (D_m * (w0 * math.sqrt(((h * -0.25) / (d_m * (d_m * l)))))) return tmp
d_m = abs(d) D_m = abs(D) M_m = abs(M) function code(w0, M_m, D_m, h, l, d_m) tmp = 0.0 if (Float64(1.0 - Float64(Float64(h / l) * (Float64(Float64(M_m * D_m) / Float64(2.0 * d_m)) ^ 2.0))) <= 2.0) tmp = w0; else tmp = Float64(abs(M_m) * Float64(D_m * Float64(w0 * sqrt(Float64(Float64(h * -0.25) / Float64(d_m * Float64(d_m * l))))))); end return tmp end
d_m = abs(d); D_m = abs(D); M_m = abs(M); function tmp_2 = code(w0, M_m, D_m, h, l, d_m) tmp = 0.0; if ((1.0 - ((h / l) * (((M_m * D_m) / (2.0 * d_m)) ^ 2.0))) <= 2.0) tmp = w0; else tmp = abs(M_m) * (D_m * (w0 * sqrt(((h * -0.25) / (d_m * (d_m * l)))))); end tmp_2 = tmp; end
d_m = N[Abs[d], $MachinePrecision] D_m = N[Abs[D], $MachinePrecision] M_m = N[Abs[M], $MachinePrecision] code[w0_, M$95$m_, D$95$m_, h_, l_, d$95$m_] := 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$95$m), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], w0, N[(N[Abs[M$95$m], $MachinePrecision] * N[(D$95$m * N[(w0 * N[Sqrt[N[(N[(h * -0.25), $MachinePrecision] / N[(d$95$m * N[(d$95$m * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
d_m = \left|d\right|
\\
D_m = \left|D\right|
\\
M_m = \left|M\right|
\\
\begin{array}{l}
\mathbf{if}\;1 - \frac{h}{\ell} \cdot {\left(\frac{M\_m \cdot D\_m}{2 \cdot d\_m}\right)}^{2} \leq 2:\\
\;\;\;\;w0\\
\mathbf{else}:\\
\;\;\;\;\left|M\_m\right| \cdot \left(D\_m \cdot \left(w0 \cdot \sqrt{\frac{h \cdot -0.25}{d\_m \cdot \left(d\_m \cdot \ell\right)}}\right)\right)\\
\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))) < 2Initial program 100.0%
Taylor expanded in M around 0
Applied rewrites99.1%
*-rgt-identity99.1
Applied rewrites99.1%
if 2 < (-.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.0%
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-*.f6438.7
Applied rewrites38.7%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
lift-*.f64N/A
associate-/l*N/A
lower-*.f64N/A
Applied rewrites46.8%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-sqrt.f64N/A
*-commutativeN/A
lower-*.f6446.8
Applied rewrites60.5%
lift-*.f64N/A
lift-fabs.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-*.f64N/A
lift-sqrt.f64N/A
associate-*l*N/A
lift-fabs.f64N/A
lift-*.f64N/A
fabs-mulN/A
associate-*l*N/A
lower-*.f64N/A
lower-fabs.f64N/A
Applied rewrites29.7%
Final simplification75.3%
d_m = (fabs.f64 d) D_m = (fabs.f64 D) M_m = (fabs.f64 M) (FPCore (w0 M_m D_m h l d_m) :precision binary64 (if (<= (* (/ h l) (pow (/ (* M_m D_m) (* 2.0 d_m)) 2.0)) -40000.0) (* (* w0 (sqrt (/ (* h -0.25) (* d_m (* d_m l))))) (fabs (* M_m D_m))) w0))
d_m = fabs(d);
D_m = fabs(D);
M_m = fabs(M);
double code(double w0, double M_m, double D_m, double h, double l, double d_m) {
double tmp;
if (((h / l) * pow(((M_m * D_m) / (2.0 * d_m)), 2.0)) <= -40000.0) {
tmp = (w0 * sqrt(((h * -0.25) / (d_m * (d_m * l))))) * fabs((M_m * D_m));
} else {
tmp = w0;
}
return tmp;
}
d_m = abs(d)
D_m = abs(d)
M_m = abs(m)
real(8) function code(w0, m_m, d_m, h, l, d_m_1)
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_m_1
real(8) :: tmp
if (((h / l) * (((m_m * d_m) / (2.0d0 * d_m_1)) ** 2.0d0)) <= (-40000.0d0)) then
tmp = (w0 * sqrt(((h * (-0.25d0)) / (d_m_1 * (d_m_1 * l))))) * abs((m_m * d_m))
else
tmp = w0
end if
code = tmp
end function
d_m = Math.abs(d);
D_m = Math.abs(D);
M_m = Math.abs(M);
public static double code(double w0, double M_m, double D_m, double h, double l, double d_m) {
double tmp;
if (((h / l) * Math.pow(((M_m * D_m) / (2.0 * d_m)), 2.0)) <= -40000.0) {
tmp = (w0 * Math.sqrt(((h * -0.25) / (d_m * (d_m * l))))) * Math.abs((M_m * D_m));
} else {
tmp = w0;
}
return tmp;
}
d_m = math.fabs(d) D_m = math.fabs(D) M_m = math.fabs(M) def code(w0, M_m, D_m, h, l, d_m): tmp = 0 if ((h / l) * math.pow(((M_m * D_m) / (2.0 * d_m)), 2.0)) <= -40000.0: tmp = (w0 * math.sqrt(((h * -0.25) / (d_m * (d_m * l))))) * math.fabs((M_m * D_m)) else: tmp = w0 return tmp
d_m = abs(d) D_m = abs(D) M_m = abs(M) function code(w0, M_m, D_m, h, l, d_m) tmp = 0.0 if (Float64(Float64(h / l) * (Float64(Float64(M_m * D_m) / Float64(2.0 * d_m)) ^ 2.0)) <= -40000.0) tmp = Float64(Float64(w0 * sqrt(Float64(Float64(h * -0.25) / Float64(d_m * Float64(d_m * l))))) * abs(Float64(M_m * D_m))); else tmp = w0; end return tmp end
d_m = abs(d); D_m = abs(D); M_m = abs(M); function tmp_2 = code(w0, M_m, D_m, h, l, d_m) tmp = 0.0; if (((h / l) * (((M_m * D_m) / (2.0 * d_m)) ^ 2.0)) <= -40000.0) tmp = (w0 * sqrt(((h * -0.25) / (d_m * (d_m * l))))) * abs((M_m * D_m)); else tmp = w0; end tmp_2 = tmp; end
d_m = N[Abs[d], $MachinePrecision] D_m = N[Abs[D], $MachinePrecision] M_m = N[Abs[M], $MachinePrecision] code[w0_, M$95$m_, D$95$m_, h_, l_, d$95$m_] := If[LessEqual[N[(N[(h / l), $MachinePrecision] * N[Power[N[(N[(M$95$m * D$95$m), $MachinePrecision] / N[(2.0 * d$95$m), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], -40000.0], N[(N[(w0 * N[Sqrt[N[(N[(h * -0.25), $MachinePrecision] / N[(d$95$m * N[(d$95$m * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Abs[N[(M$95$m * D$95$m), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], w0]
\begin{array}{l}
d_m = \left|d\right|
\\
D_m = \left|D\right|
\\
M_m = \left|M\right|
\\
\begin{array}{l}
\mathbf{if}\;\frac{h}{\ell} \cdot {\left(\frac{M\_m \cdot D\_m}{2 \cdot d\_m}\right)}^{2} \leq -40000:\\
\;\;\;\;\left(w0 \cdot \sqrt{\frac{h \cdot -0.25}{d\_m \cdot \left(d\_m \cdot \ell\right)}}\right) \cdot \left|M\_m \cdot D\_m\right|\\
\mathbf{else}:\\
\;\;\;\;w0\\
\end{array}
\end{array}
if (*.f64 (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) (/.f64 h l)) < -4e4Initial program 77.9%
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-*.f6448.3
Applied rewrites48.3%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
lift-*.f64N/A
associate-/l*N/A
lower-*.f64N/A
Applied rewrites56.8%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-sqrt.f64N/A
*-commutativeN/A
lower-*.f6456.8
Applied rewrites70.4%
lift-*.f64N/A
lift-fabs.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-*.f64N/A
lift-sqrt.f64N/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites75.0%
if -4e4 < (*.f64 (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) (/.f64 h l)) Initial program 86.1%
Taylor expanded in M around 0
Applied rewrites91.5%
*-rgt-identity91.5
Applied rewrites91.5%
Final simplification87.6%
d_m = (fabs.f64 d) D_m = (fabs.f64 D) M_m = (fabs.f64 M) (FPCore (w0 M_m D_m h l d_m) :precision binary64 (if (<= (* (/ h l) (pow (/ (* M_m D_m) (* 2.0 d_m)) 2.0)) -40000.0) (* (sqrt (/ (* h -0.25) (* d_m (* d_m l)))) (* w0 (fabs (* M_m D_m)))) w0))
d_m = fabs(d);
D_m = fabs(D);
M_m = fabs(M);
double code(double w0, double M_m, double D_m, double h, double l, double d_m) {
double tmp;
if (((h / l) * pow(((M_m * D_m) / (2.0 * d_m)), 2.0)) <= -40000.0) {
tmp = sqrt(((h * -0.25) / (d_m * (d_m * l)))) * (w0 * fabs((M_m * D_m)));
} else {
tmp = w0;
}
return tmp;
}
d_m = abs(d)
D_m = abs(d)
M_m = abs(m)
real(8) function code(w0, m_m, d_m, h, l, d_m_1)
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_m_1
real(8) :: tmp
if (((h / l) * (((m_m * d_m) / (2.0d0 * d_m_1)) ** 2.0d0)) <= (-40000.0d0)) then
tmp = sqrt(((h * (-0.25d0)) / (d_m_1 * (d_m_1 * l)))) * (w0 * abs((m_m * d_m)))
else
tmp = w0
end if
code = tmp
end function
d_m = Math.abs(d);
D_m = Math.abs(D);
M_m = Math.abs(M);
public static double code(double w0, double M_m, double D_m, double h, double l, double d_m) {
double tmp;
if (((h / l) * Math.pow(((M_m * D_m) / (2.0 * d_m)), 2.0)) <= -40000.0) {
tmp = Math.sqrt(((h * -0.25) / (d_m * (d_m * l)))) * (w0 * Math.abs((M_m * D_m)));
} else {
tmp = w0;
}
return tmp;
}
d_m = math.fabs(d) D_m = math.fabs(D) M_m = math.fabs(M) def code(w0, M_m, D_m, h, l, d_m): tmp = 0 if ((h / l) * math.pow(((M_m * D_m) / (2.0 * d_m)), 2.0)) <= -40000.0: tmp = math.sqrt(((h * -0.25) / (d_m * (d_m * l)))) * (w0 * math.fabs((M_m * D_m))) else: tmp = w0 return tmp
d_m = abs(d) D_m = abs(D) M_m = abs(M) function code(w0, M_m, D_m, h, l, d_m) tmp = 0.0 if (Float64(Float64(h / l) * (Float64(Float64(M_m * D_m) / Float64(2.0 * d_m)) ^ 2.0)) <= -40000.0) tmp = Float64(sqrt(Float64(Float64(h * -0.25) / Float64(d_m * Float64(d_m * l)))) * Float64(w0 * abs(Float64(M_m * D_m)))); else tmp = w0; end return tmp end
d_m = abs(d); D_m = abs(D); M_m = abs(M); function tmp_2 = code(w0, M_m, D_m, h, l, d_m) tmp = 0.0; if (((h / l) * (((M_m * D_m) / (2.0 * d_m)) ^ 2.0)) <= -40000.0) tmp = sqrt(((h * -0.25) / (d_m * (d_m * l)))) * (w0 * abs((M_m * D_m))); else tmp = w0; end tmp_2 = tmp; end
d_m = N[Abs[d], $MachinePrecision] D_m = N[Abs[D], $MachinePrecision] M_m = N[Abs[M], $MachinePrecision] code[w0_, M$95$m_, D$95$m_, h_, l_, d$95$m_] := If[LessEqual[N[(N[(h / l), $MachinePrecision] * N[Power[N[(N[(M$95$m * D$95$m), $MachinePrecision] / N[(2.0 * d$95$m), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], -40000.0], N[(N[Sqrt[N[(N[(h * -0.25), $MachinePrecision] / N[(d$95$m * N[(d$95$m * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(w0 * N[Abs[N[(M$95$m * D$95$m), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], w0]
\begin{array}{l}
d_m = \left|d\right|
\\
D_m = \left|D\right|
\\
M_m = \left|M\right|
\\
\begin{array}{l}
\mathbf{if}\;\frac{h}{\ell} \cdot {\left(\frac{M\_m \cdot D\_m}{2 \cdot d\_m}\right)}^{2} \leq -40000:\\
\;\;\;\;\sqrt{\frac{h \cdot -0.25}{d\_m \cdot \left(d\_m \cdot \ell\right)}} \cdot \left(w0 \cdot \left|M\_m \cdot D\_m\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)) < -4e4Initial program 77.9%
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-*.f6448.3
Applied rewrites48.3%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
lift-*.f64N/A
associate-/l*N/A
lower-*.f64N/A
Applied rewrites56.8%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-sqrt.f64N/A
*-commutativeN/A
lower-*.f6456.8
Applied rewrites70.4%
lift-*.f64N/A
lift-fabs.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-*.f64N/A
lift-sqrt.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6473.0
lift-*.f64N/A
Applied rewrites73.0%
if -4e4 < (*.f64 (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64)) (/.f64 h l)) Initial program 86.1%
Taylor expanded in M around 0
Applied rewrites91.5%
*-rgt-identity91.5
Applied rewrites91.5%
Final simplification87.1%
d_m = (fabs.f64 d)
D_m = (fabs.f64 D)
M_m = (fabs.f64 M)
(FPCore (w0 M_m D_m h l d_m)
:precision binary64
(let* ((t_0 (/ (* M_m D_m) (* 2.0 d_m))))
(if (<= t_0 1e-117)
w0
(if (<= t_0 5e+257)
(* w0 (sqrt (fma t_0 (/ (* -0.5 (* (* M_m D_m) h)) (* d_m l)) 1.0)))
(*
(fabs M_m)
(* D_m (* w0 (sqrt (/ (* h -0.25) (* d_m (* d_m l)))))))))))d_m = fabs(d);
D_m = fabs(D);
M_m = fabs(M);
double code(double w0, double M_m, double D_m, double h, double l, double d_m) {
double t_0 = (M_m * D_m) / (2.0 * d_m);
double tmp;
if (t_0 <= 1e-117) {
tmp = w0;
} else if (t_0 <= 5e+257) {
tmp = w0 * sqrt(fma(t_0, ((-0.5 * ((M_m * D_m) * h)) / (d_m * l)), 1.0));
} else {
tmp = fabs(M_m) * (D_m * (w0 * sqrt(((h * -0.25) / (d_m * (d_m * l))))));
}
return tmp;
}
d_m = abs(d) D_m = abs(D) M_m = abs(M) function code(w0, M_m, D_m, h, l, d_m) t_0 = Float64(Float64(M_m * D_m) / Float64(2.0 * d_m)) tmp = 0.0 if (t_0 <= 1e-117) tmp = w0; elseif (t_0 <= 5e+257) tmp = Float64(w0 * sqrt(fma(t_0, Float64(Float64(-0.5 * Float64(Float64(M_m * D_m) * h)) / Float64(d_m * l)), 1.0))); else tmp = Float64(abs(M_m) * Float64(D_m * Float64(w0 * sqrt(Float64(Float64(h * -0.25) / Float64(d_m * Float64(d_m * l))))))); end return tmp end
d_m = N[Abs[d], $MachinePrecision]
D_m = N[Abs[D], $MachinePrecision]
M_m = N[Abs[M], $MachinePrecision]
code[w0_, M$95$m_, D$95$m_, h_, l_, d$95$m_] := Block[{t$95$0 = N[(N[(M$95$m * D$95$m), $MachinePrecision] / N[(2.0 * d$95$m), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, 1e-117], w0, If[LessEqual[t$95$0, 5e+257], N[(w0 * N[Sqrt[N[(t$95$0 * N[(N[(-0.5 * N[(N[(M$95$m * D$95$m), $MachinePrecision] * h), $MachinePrecision]), $MachinePrecision] / N[(d$95$m * l), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[Abs[M$95$m], $MachinePrecision] * N[(D$95$m * N[(w0 * N[Sqrt[N[(N[(h * -0.25), $MachinePrecision] / N[(d$95$m * N[(d$95$m * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
d_m = \left|d\right|
\\
D_m = \left|D\right|
\\
M_m = \left|M\right|
\\
\begin{array}{l}
t_0 := \frac{M\_m \cdot D\_m}{2 \cdot d\_m}\\
\mathbf{if}\;t\_0 \leq 10^{-117}:\\
\;\;\;\;w0\\
\mathbf{elif}\;t\_0 \leq 5 \cdot 10^{+257}:\\
\;\;\;\;w0 \cdot \sqrt{\mathsf{fma}\left(t\_0, \frac{-0.5 \cdot \left(\left(M\_m \cdot D\_m\right) \cdot h\right)}{d\_m \cdot \ell}, 1\right)}\\
\mathbf{else}:\\
\;\;\;\;\left|M\_m\right| \cdot \left(D\_m \cdot \left(w0 \cdot \sqrt{\frac{h \cdot -0.25}{d\_m \cdot \left(d\_m \cdot \ell\right)}}\right)\right)\\
\end{array}
\end{array}
if (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) < 1.00000000000000003e-117Initial program 85.7%
Taylor expanded in M around 0
Applied rewrites80.9%
*-rgt-identity80.9
Applied rewrites80.9%
if 1.00000000000000003e-117 < (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) < 5.00000000000000028e257Initial program 91.0%
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 rewrites96.9%
Taylor expanded in M around 0
associate-*r/N/A
lower-/.f64N/A
lower-*.f64N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f6494.2
Applied rewrites94.2%
if 5.00000000000000028e257 < (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) Initial program 58.3%
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-*.f6454.0
Applied rewrites54.0%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
lift-*.f64N/A
associate-/l*N/A
lower-*.f64N/A
Applied rewrites54.0%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-sqrt.f64N/A
*-commutativeN/A
lower-*.f6454.0
Applied rewrites63.1%
lift-*.f64N/A
lift-fabs.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-*.f64N/A
lift-sqrt.f64N/A
associate-*l*N/A
lift-fabs.f64N/A
lift-*.f64N/A
fabs-mulN/A
associate-*l*N/A
lower-*.f64N/A
lower-fabs.f64N/A
Applied rewrites48.2%
Final simplification80.0%
d_m = (fabs.f64 d)
D_m = (fabs.f64 D)
M_m = (fabs.f64 M)
(FPCore (w0 M_m D_m h l d_m)
:precision binary64
(let* ((t_0 (/ (* M_m D_m) (* 2.0 d_m))))
(if (<= t_0 5e-74)
w0
(if (<= t_0 5e+257)
(*
w0
(sqrt
(fma
(/ (* (* M_m D_m) (* M_m 0.25)) d_m)
(/ (* D_m h) (- (* d_m l)))
1.0)))
(*
(fabs M_m)
(* D_m (* w0 (sqrt (/ (* h -0.25) (* d_m (* d_m l)))))))))))d_m = fabs(d);
D_m = fabs(D);
M_m = fabs(M);
double code(double w0, double M_m, double D_m, double h, double l, double d_m) {
double t_0 = (M_m * D_m) / (2.0 * d_m);
double tmp;
if (t_0 <= 5e-74) {
tmp = w0;
} else if (t_0 <= 5e+257) {
tmp = w0 * sqrt(fma((((M_m * D_m) * (M_m * 0.25)) / d_m), ((D_m * h) / -(d_m * l)), 1.0));
} else {
tmp = fabs(M_m) * (D_m * (w0 * sqrt(((h * -0.25) / (d_m * (d_m * l))))));
}
return tmp;
}
d_m = abs(d) D_m = abs(D) M_m = abs(M) function code(w0, M_m, D_m, h, l, d_m) t_0 = Float64(Float64(M_m * D_m) / Float64(2.0 * d_m)) tmp = 0.0 if (t_0 <= 5e-74) tmp = w0; elseif (t_0 <= 5e+257) tmp = Float64(w0 * sqrt(fma(Float64(Float64(Float64(M_m * D_m) * Float64(M_m * 0.25)) / d_m), Float64(Float64(D_m * h) / Float64(-Float64(d_m * l))), 1.0))); else tmp = Float64(abs(M_m) * Float64(D_m * Float64(w0 * sqrt(Float64(Float64(h * -0.25) / Float64(d_m * Float64(d_m * l))))))); end return tmp end
d_m = N[Abs[d], $MachinePrecision]
D_m = N[Abs[D], $MachinePrecision]
M_m = N[Abs[M], $MachinePrecision]
code[w0_, M$95$m_, D$95$m_, h_, l_, d$95$m_] := Block[{t$95$0 = N[(N[(M$95$m * D$95$m), $MachinePrecision] / N[(2.0 * d$95$m), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, 5e-74], w0, If[LessEqual[t$95$0, 5e+257], N[(w0 * N[Sqrt[N[(N[(N[(N[(M$95$m * D$95$m), $MachinePrecision] * N[(M$95$m * 0.25), $MachinePrecision]), $MachinePrecision] / d$95$m), $MachinePrecision] * N[(N[(D$95$m * h), $MachinePrecision] / (-N[(d$95$m * l), $MachinePrecision])), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[Abs[M$95$m], $MachinePrecision] * N[(D$95$m * N[(w0 * N[Sqrt[N[(N[(h * -0.25), $MachinePrecision] / N[(d$95$m * N[(d$95$m * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
d_m = \left|d\right|
\\
D_m = \left|D\right|
\\
M_m = \left|M\right|
\\
\begin{array}{l}
t_0 := \frac{M\_m \cdot D\_m}{2 \cdot d\_m}\\
\mathbf{if}\;t\_0 \leq 5 \cdot 10^{-74}:\\
\;\;\;\;w0\\
\mathbf{elif}\;t\_0 \leq 5 \cdot 10^{+257}:\\
\;\;\;\;w0 \cdot \sqrt{\mathsf{fma}\left(\frac{\left(M\_m \cdot D\_m\right) \cdot \left(M\_m \cdot 0.25\right)}{d\_m}, \frac{D\_m \cdot h}{-d\_m \cdot \ell}, 1\right)}\\
\mathbf{else}:\\
\;\;\;\;\left|M\_m\right| \cdot \left(D\_m \cdot \left(w0 \cdot \sqrt{\frac{h \cdot -0.25}{d\_m \cdot \left(d\_m \cdot \ell\right)}}\right)\right)\\
\end{array}
\end{array}
if (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) < 4.99999999999999998e-74Initial program 85.9%
Taylor expanded in M around 0
Applied rewrites80.8%
*-rgt-identity80.8
Applied rewrites80.8%
if 4.99999999999999998e-74 < (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) < 5.00000000000000028e257Initial program 90.2%
Applied rewrites77.4%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-/.f64N/A
lift-neg.f64N/A
lift-*.f64N/A
lift-fma.f6477.4
Applied rewrites71.7%
associate-*l*N/A
associate-*r*N/A
*-commutativeN/A
lift-*.f64N/A
lower-*.f64N/A
lower-*.f6480.9
Applied rewrites80.9%
if 5.00000000000000028e257 < (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) Initial program 58.3%
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-*.f6454.0
Applied rewrites54.0%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
lift-*.f64N/A
associate-/l*N/A
lower-*.f64N/A
Applied rewrites54.0%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-sqrt.f64N/A
*-commutativeN/A
lower-*.f6454.0
Applied rewrites63.1%
lift-*.f64N/A
lift-fabs.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-*.f64N/A
lift-sqrt.f64N/A
associate-*l*N/A
lift-fabs.f64N/A
lift-*.f64N/A
fabs-mulN/A
associate-*l*N/A
lower-*.f64N/A
lower-fabs.f64N/A
Applied rewrites48.2%
Final simplification78.1%
d_m = (fabs.f64 d)
D_m = (fabs.f64 D)
M_m = (fabs.f64 M)
(FPCore (w0 M_m D_m h l d_m)
:precision binary64
(let* ((t_0 (/ (* M_m D_m) (* 2.0 d_m))))
(if (<= t_0 1e-104)
w0
(if (<= t_0 5e+217)
(*
w0
(sqrt
(fma
(* (/ D_m d_m) (* 0.25 (* M_m M_m)))
(- (* D_m (/ h (* d_m l))))
1.0)))
(*
(fabs M_m)
(* D_m (* w0 (sqrt (/ (* h -0.25) (* d_m (* d_m l)))))))))))d_m = fabs(d);
D_m = fabs(D);
M_m = fabs(M);
double code(double w0, double M_m, double D_m, double h, double l, double d_m) {
double t_0 = (M_m * D_m) / (2.0 * d_m);
double tmp;
if (t_0 <= 1e-104) {
tmp = w0;
} else if (t_0 <= 5e+217) {
tmp = w0 * sqrt(fma(((D_m / d_m) * (0.25 * (M_m * M_m))), -(D_m * (h / (d_m * l))), 1.0));
} else {
tmp = fabs(M_m) * (D_m * (w0 * sqrt(((h * -0.25) / (d_m * (d_m * l))))));
}
return tmp;
}
d_m = abs(d) D_m = abs(D) M_m = abs(M) function code(w0, M_m, D_m, h, l, d_m) t_0 = Float64(Float64(M_m * D_m) / Float64(2.0 * d_m)) tmp = 0.0 if (t_0 <= 1e-104) tmp = w0; elseif (t_0 <= 5e+217) tmp = Float64(w0 * sqrt(fma(Float64(Float64(D_m / d_m) * Float64(0.25 * Float64(M_m * M_m))), Float64(-Float64(D_m * Float64(h / Float64(d_m * l)))), 1.0))); else tmp = Float64(abs(M_m) * Float64(D_m * Float64(w0 * sqrt(Float64(Float64(h * -0.25) / Float64(d_m * Float64(d_m * l))))))); end return tmp end
d_m = N[Abs[d], $MachinePrecision]
D_m = N[Abs[D], $MachinePrecision]
M_m = N[Abs[M], $MachinePrecision]
code[w0_, M$95$m_, D$95$m_, h_, l_, d$95$m_] := Block[{t$95$0 = N[(N[(M$95$m * D$95$m), $MachinePrecision] / N[(2.0 * d$95$m), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, 1e-104], w0, If[LessEqual[t$95$0, 5e+217], N[(w0 * N[Sqrt[N[(N[(N[(D$95$m / d$95$m), $MachinePrecision] * N[(0.25 * N[(M$95$m * M$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * (-N[(D$95$m * N[(h / N[(d$95$m * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]) + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[Abs[M$95$m], $MachinePrecision] * N[(D$95$m * N[(w0 * N[Sqrt[N[(N[(h * -0.25), $MachinePrecision] / N[(d$95$m * N[(d$95$m * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
d_m = \left|d\right|
\\
D_m = \left|D\right|
\\
M_m = \left|M\right|
\\
\begin{array}{l}
t_0 := \frac{M\_m \cdot D\_m}{2 \cdot d\_m}\\
\mathbf{if}\;t\_0 \leq 10^{-104}:\\
\;\;\;\;w0\\
\mathbf{elif}\;t\_0 \leq 5 \cdot 10^{+217}:\\
\;\;\;\;w0 \cdot \sqrt{\mathsf{fma}\left(\frac{D\_m}{d\_m} \cdot \left(0.25 \cdot \left(M\_m \cdot M\_m\right)\right), -D\_m \cdot \frac{h}{d\_m \cdot \ell}, 1\right)}\\
\mathbf{else}:\\
\;\;\;\;\left|M\_m\right| \cdot \left(D\_m \cdot \left(w0 \cdot \sqrt{\frac{h \cdot -0.25}{d\_m \cdot \left(d\_m \cdot \ell\right)}}\right)\right)\\
\end{array}
\end{array}
if (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) < 9.99999999999999927e-105Initial program 85.7%
Taylor expanded in M around 0
Applied rewrites80.9%
*-rgt-identity80.9
Applied rewrites80.9%
if 9.99999999999999927e-105 < (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) < 5.00000000000000041e217Initial program 93.8%
Applied rewrites81.8%
Taylor expanded in D around 0
mul-1-negN/A
lower-neg.f64N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f64N/A
lower-*.f6479.1
Applied rewrites79.1%
if 5.00000000000000041e217 < (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) Initial program 55.6%
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-*.f6451.5
Applied rewrites51.5%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
lift-*.f64N/A
associate-/l*N/A
lower-*.f64N/A
Applied rewrites51.5%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-sqrt.f64N/A
*-commutativeN/A
lower-*.f6451.5
Applied rewrites60.3%
lift-*.f64N/A
lift-fabs.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-*.f64N/A
lift-sqrt.f64N/A
associate-*l*N/A
lift-fabs.f64N/A
lift-*.f64N/A
fabs-mulN/A
associate-*l*N/A
lower-*.f64N/A
lower-fabs.f64N/A
Applied rewrites46.0%
Final simplification77.7%
d_m = (fabs.f64 d)
D_m = (fabs.f64 D)
M_m = (fabs.f64 M)
(FPCore (w0 M_m D_m h l d_m)
:precision binary64
(let* ((t_0 (/ (* M_m D_m) (* 2.0 d_m))))
(if (<= t_0 5e+257)
(* w0 (sqrt (fma t_0 (/ (/ (* (* M_m D_m) h) (* 2.0 d_m)) (- l)) 1.0)))
(* (fabs M_m) (* D_m (* w0 (sqrt (/ (* h -0.25) (* d_m (* d_m l))))))))))d_m = fabs(d);
D_m = fabs(D);
M_m = fabs(M);
double code(double w0, double M_m, double D_m, double h, double l, double d_m) {
double t_0 = (M_m * D_m) / (2.0 * d_m);
double tmp;
if (t_0 <= 5e+257) {
tmp = w0 * sqrt(fma(t_0, ((((M_m * D_m) * h) / (2.0 * d_m)) / -l), 1.0));
} else {
tmp = fabs(M_m) * (D_m * (w0 * sqrt(((h * -0.25) / (d_m * (d_m * l))))));
}
return tmp;
}
d_m = abs(d) D_m = abs(D) M_m = abs(M) function code(w0, M_m, D_m, h, l, d_m) t_0 = Float64(Float64(M_m * D_m) / Float64(2.0 * d_m)) tmp = 0.0 if (t_0 <= 5e+257) tmp = Float64(w0 * sqrt(fma(t_0, Float64(Float64(Float64(Float64(M_m * D_m) * h) / Float64(2.0 * d_m)) / Float64(-l)), 1.0))); else tmp = Float64(abs(M_m) * Float64(D_m * Float64(w0 * sqrt(Float64(Float64(h * -0.25) / Float64(d_m * Float64(d_m * l))))))); end return tmp end
d_m = N[Abs[d], $MachinePrecision]
D_m = N[Abs[D], $MachinePrecision]
M_m = N[Abs[M], $MachinePrecision]
code[w0_, M$95$m_, D$95$m_, h_, l_, d$95$m_] := Block[{t$95$0 = N[(N[(M$95$m * D$95$m), $MachinePrecision] / N[(2.0 * d$95$m), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, 5e+257], N[(w0 * N[Sqrt[N[(t$95$0 * N[(N[(N[(N[(M$95$m * D$95$m), $MachinePrecision] * h), $MachinePrecision] / N[(2.0 * d$95$m), $MachinePrecision]), $MachinePrecision] / (-l)), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[Abs[M$95$m], $MachinePrecision] * N[(D$95$m * N[(w0 * N[Sqrt[N[(N[(h * -0.25), $MachinePrecision] / N[(d$95$m * N[(d$95$m * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
d_m = \left|d\right|
\\
D_m = \left|D\right|
\\
M_m = \left|M\right|
\\
\begin{array}{l}
t_0 := \frac{M\_m \cdot D\_m}{2 \cdot d\_m}\\
\mathbf{if}\;t\_0 \leq 5 \cdot 10^{+257}:\\
\;\;\;\;w0 \cdot \sqrt{\mathsf{fma}\left(t\_0, \frac{\frac{\left(M\_m \cdot D\_m\right) \cdot h}{2 \cdot d\_m}}{-\ell}, 1\right)}\\
\mathbf{else}:\\
\;\;\;\;\left|M\_m\right| \cdot \left(D\_m \cdot \left(w0 \cdot \sqrt{\frac{h \cdot -0.25}{d\_m \cdot \left(d\_m \cdot \ell\right)}}\right)\right)\\
\end{array}
\end{array}
if (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) < 5.00000000000000028e257Initial program 86.5%
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 rewrites93.5%
if 5.00000000000000028e257 < (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) Initial program 58.3%
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-*.f6454.0
Applied rewrites54.0%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
lift-*.f64N/A
associate-/l*N/A
lower-*.f64N/A
Applied rewrites54.0%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-sqrt.f64N/A
*-commutativeN/A
lower-*.f6454.0
Applied rewrites63.1%
lift-*.f64N/A
lift-fabs.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-*.f64N/A
lift-sqrt.f64N/A
associate-*l*N/A
lift-fabs.f64N/A
lift-*.f64N/A
fabs-mulN/A
associate-*l*N/A
lower-*.f64N/A
lower-fabs.f64N/A
Applied rewrites48.2%
d_m = (fabs.f64 d)
D_m = (fabs.f64 D)
M_m = (fabs.f64 M)
(FPCore (w0 M_m D_m h l d_m)
:precision binary64
(if (<= (/ (* M_m D_m) (* 2.0 d_m)) 2e+176)
w0
(fma
(* D_m D_m)
(/ (* -0.125 (* h (* w0 (* M_m M_m)))) (* d_m (* d_m l)))
w0)))d_m = fabs(d);
D_m = fabs(D);
M_m = fabs(M);
double code(double w0, double M_m, double D_m, double h, double l, double d_m) {
double tmp;
if (((M_m * D_m) / (2.0 * d_m)) <= 2e+176) {
tmp = w0;
} else {
tmp = fma((D_m * D_m), ((-0.125 * (h * (w0 * (M_m * M_m)))) / (d_m * (d_m * l))), w0);
}
return tmp;
}
d_m = abs(d) D_m = abs(D) M_m = abs(M) function code(w0, M_m, D_m, h, l, d_m) tmp = 0.0 if (Float64(Float64(M_m * D_m) / Float64(2.0 * d_m)) <= 2e+176) tmp = w0; else tmp = fma(Float64(D_m * D_m), Float64(Float64(-0.125 * Float64(h * Float64(w0 * Float64(M_m * M_m)))) / Float64(d_m * Float64(d_m * l))), w0); end return tmp end
d_m = N[Abs[d], $MachinePrecision] D_m = N[Abs[D], $MachinePrecision] M_m = N[Abs[M], $MachinePrecision] code[w0_, M$95$m_, D$95$m_, h_, l_, d$95$m_] := If[LessEqual[N[(N[(M$95$m * D$95$m), $MachinePrecision] / N[(2.0 * d$95$m), $MachinePrecision]), $MachinePrecision], 2e+176], w0, 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[(d$95$m * N[(d$95$m * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + w0), $MachinePrecision]]
\begin{array}{l}
d_m = \left|d\right|
\\
D_m = \left|D\right|
\\
M_m = \left|M\right|
\\
\begin{array}{l}
\mathbf{if}\;\frac{M\_m \cdot D\_m}{2 \cdot d\_m} \leq 2 \cdot 10^{+176}:\\
\;\;\;\;w0\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(D\_m \cdot D\_m, \frac{-0.125 \cdot \left(h \cdot \left(w0 \cdot \left(M\_m \cdot M\_m\right)\right)\right)}{d\_m \cdot \left(d\_m \cdot \ell\right)}, w0\right)\\
\end{array}
\end{array}
if (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) < 2e176Initial program 87.2%
Taylor expanded in M around 0
Applied rewrites77.8%
*-rgt-identity77.8
Applied rewrites77.8%
if 2e176 < (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) Initial program 55.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 rewrites64.5%
Taylor expanded in M around 0
associate-*r/N/A
lower-/.f64N/A
lower-*.f64N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f6460.1
Applied rewrites60.1%
Taylor expanded in M around 0
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites51.4%
Final simplification75.4%
d_m = (fabs.f64 d) D_m = (fabs.f64 D) M_m = (fabs.f64 M) (FPCore (w0 M_m D_m h l d_m) :precision binary64 (if (<= (/ (* M_m D_m) (* 2.0 d_m)) 5e+297) w0 (* w0 (* -0.125 (/ (* (* D_m D_m) (* h (* M_m M_m))) (* l (* d_m d_m)))))))
d_m = fabs(d);
D_m = fabs(D);
M_m = fabs(M);
double code(double w0, double M_m, double D_m, double h, double l, double d_m) {
double tmp;
if (((M_m * D_m) / (2.0 * d_m)) <= 5e+297) {
tmp = w0;
} else {
tmp = w0 * (-0.125 * (((D_m * D_m) * (h * (M_m * M_m))) / (l * (d_m * d_m))));
}
return tmp;
}
d_m = abs(d)
D_m = abs(d)
M_m = abs(m)
real(8) function code(w0, m_m, d_m, h, l, d_m_1)
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_m_1
real(8) :: tmp
if (((m_m * d_m) / (2.0d0 * d_m_1)) <= 5d+297) then
tmp = w0
else
tmp = w0 * ((-0.125d0) * (((d_m * d_m) * (h * (m_m * m_m))) / (l * (d_m_1 * d_m_1))))
end if
code = tmp
end function
d_m = Math.abs(d);
D_m = Math.abs(D);
M_m = Math.abs(M);
public static double code(double w0, double M_m, double D_m, double h, double l, double d_m) {
double tmp;
if (((M_m * D_m) / (2.0 * d_m)) <= 5e+297) {
tmp = w0;
} else {
tmp = w0 * (-0.125 * (((D_m * D_m) * (h * (M_m * M_m))) / (l * (d_m * d_m))));
}
return tmp;
}
d_m = math.fabs(d) D_m = math.fabs(D) M_m = math.fabs(M) def code(w0, M_m, D_m, h, l, d_m): tmp = 0 if ((M_m * D_m) / (2.0 * d_m)) <= 5e+297: tmp = w0 else: tmp = w0 * (-0.125 * (((D_m * D_m) * (h * (M_m * M_m))) / (l * (d_m * d_m)))) return tmp
d_m = abs(d) D_m = abs(D) M_m = abs(M) function code(w0, M_m, D_m, h, l, d_m) tmp = 0.0 if (Float64(Float64(M_m * D_m) / Float64(2.0 * d_m)) <= 5e+297) tmp = w0; else tmp = Float64(w0 * Float64(-0.125 * Float64(Float64(Float64(D_m * D_m) * Float64(h * Float64(M_m * M_m))) / Float64(l * Float64(d_m * d_m))))); end return tmp end
d_m = abs(d); D_m = abs(D); M_m = abs(M); function tmp_2 = code(w0, M_m, D_m, h, l, d_m) tmp = 0.0; if (((M_m * D_m) / (2.0 * d_m)) <= 5e+297) tmp = w0; else tmp = w0 * (-0.125 * (((D_m * D_m) * (h * (M_m * M_m))) / (l * (d_m * d_m)))); end tmp_2 = tmp; end
d_m = N[Abs[d], $MachinePrecision] D_m = N[Abs[D], $MachinePrecision] M_m = N[Abs[M], $MachinePrecision] code[w0_, M$95$m_, D$95$m_, h_, l_, d$95$m_] := If[LessEqual[N[(N[(M$95$m * D$95$m), $MachinePrecision] / N[(2.0 * d$95$m), $MachinePrecision]), $MachinePrecision], 5e+297], w0, N[(w0 * N[(-0.125 * N[(N[(N[(D$95$m * D$95$m), $MachinePrecision] * N[(h * N[(M$95$m * M$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(l * N[(d$95$m * d$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
d_m = \left|d\right|
\\
D_m = \left|D\right|
\\
M_m = \left|M\right|
\\
\begin{array}{l}
\mathbf{if}\;\frac{M\_m \cdot D\_m}{2 \cdot d\_m} \leq 5 \cdot 10^{+297}:\\
\;\;\;\;w0\\
\mathbf{else}:\\
\;\;\;\;w0 \cdot \left(-0.125 \cdot \frac{\left(D\_m \cdot D\_m\right) \cdot \left(h \cdot \left(M\_m \cdot M\_m\right)\right)}{\ell \cdot \left(d\_m \cdot d\_m\right)}\right)\\
\end{array}
\end{array}
if (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) < 4.9999999999999998e297Initial program 86.2%
Taylor expanded in M around 0
Applied rewrites76.3%
*-rgt-identity76.3
Applied rewrites76.3%
if 4.9999999999999998e297 < (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) Initial program 58.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 rewrites65.2%
Taylor expanded in M around 0
associate-*r/N/A
lower-/.f64N/A
lower-*.f64N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f6459.6
Applied rewrites59.6%
Taylor expanded in M around 0
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites54.1%
Taylor expanded in D around inf
*-commutativeN/A
lower-*.f64N/A
lower-/.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f6454.1
Applied rewrites54.1%
Final simplification74.7%
d_m = (fabs.f64 d) D_m = (fabs.f64 D) M_m = (fabs.f64 M) (FPCore (w0 M_m D_m h l d_m) :precision binary64 (if (<= (/ (* M_m D_m) (* 2.0 d_m)) 5e+297) w0 (* -0.125 (/ (* (* D_m D_m) (* w0 (* h (* M_m M_m)))) (* l (* d_m d_m))))))
d_m = fabs(d);
D_m = fabs(D);
M_m = fabs(M);
double code(double w0, double M_m, double D_m, double h, double l, double d_m) {
double tmp;
if (((M_m * D_m) / (2.0 * d_m)) <= 5e+297) {
tmp = w0;
} else {
tmp = -0.125 * (((D_m * D_m) * (w0 * (h * (M_m * M_m)))) / (l * (d_m * d_m)));
}
return tmp;
}
d_m = abs(d)
D_m = abs(d)
M_m = abs(m)
real(8) function code(w0, m_m, d_m, h, l, d_m_1)
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_m_1
real(8) :: tmp
if (((m_m * d_m) / (2.0d0 * d_m_1)) <= 5d+297) then
tmp = w0
else
tmp = (-0.125d0) * (((d_m * d_m) * (w0 * (h * (m_m * m_m)))) / (l * (d_m_1 * d_m_1)))
end if
code = tmp
end function
d_m = Math.abs(d);
D_m = Math.abs(D);
M_m = Math.abs(M);
public static double code(double w0, double M_m, double D_m, double h, double l, double d_m) {
double tmp;
if (((M_m * D_m) / (2.0 * d_m)) <= 5e+297) {
tmp = w0;
} else {
tmp = -0.125 * (((D_m * D_m) * (w0 * (h * (M_m * M_m)))) / (l * (d_m * d_m)));
}
return tmp;
}
d_m = math.fabs(d) D_m = math.fabs(D) M_m = math.fabs(M) def code(w0, M_m, D_m, h, l, d_m): tmp = 0 if ((M_m * D_m) / (2.0 * d_m)) <= 5e+297: tmp = w0 else: tmp = -0.125 * (((D_m * D_m) * (w0 * (h * (M_m * M_m)))) / (l * (d_m * d_m))) return tmp
d_m = abs(d) D_m = abs(D) M_m = abs(M) function code(w0, M_m, D_m, h, l, d_m) tmp = 0.0 if (Float64(Float64(M_m * D_m) / Float64(2.0 * d_m)) <= 5e+297) tmp = w0; else tmp = Float64(-0.125 * Float64(Float64(Float64(D_m * D_m) * Float64(w0 * Float64(h * Float64(M_m * M_m)))) / Float64(l * Float64(d_m * d_m)))); end return tmp end
d_m = abs(d); D_m = abs(D); M_m = abs(M); function tmp_2 = code(w0, M_m, D_m, h, l, d_m) tmp = 0.0; if (((M_m * D_m) / (2.0 * d_m)) <= 5e+297) tmp = w0; else tmp = -0.125 * (((D_m * D_m) * (w0 * (h * (M_m * M_m)))) / (l * (d_m * d_m))); end tmp_2 = tmp; end
d_m = N[Abs[d], $MachinePrecision] D_m = N[Abs[D], $MachinePrecision] M_m = N[Abs[M], $MachinePrecision] code[w0_, M$95$m_, D$95$m_, h_, l_, d$95$m_] := If[LessEqual[N[(N[(M$95$m * D$95$m), $MachinePrecision] / N[(2.0 * d$95$m), $MachinePrecision]), $MachinePrecision], 5e+297], w0, N[(-0.125 * N[(N[(N[(D$95$m * D$95$m), $MachinePrecision] * N[(w0 * N[(h * N[(M$95$m * M$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(l * N[(d$95$m * d$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
d_m = \left|d\right|
\\
D_m = \left|D\right|
\\
M_m = \left|M\right|
\\
\begin{array}{l}
\mathbf{if}\;\frac{M\_m \cdot D\_m}{2 \cdot d\_m} \leq 5 \cdot 10^{+297}:\\
\;\;\;\;w0\\
\mathbf{else}:\\
\;\;\;\;-0.125 \cdot \frac{\left(D\_m \cdot D\_m\right) \cdot \left(w0 \cdot \left(h \cdot \left(M\_m \cdot M\_m\right)\right)\right)}{\ell \cdot \left(d\_m \cdot d\_m\right)}\\
\end{array}
\end{array}
if (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) < 4.9999999999999998e297Initial program 86.2%
Taylor expanded in M around 0
Applied rewrites76.3%
*-rgt-identity76.3
Applied rewrites76.3%
if 4.9999999999999998e297 < (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) Initial program 58.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 rewrites65.2%
Taylor expanded in M around 0
associate-*r/N/A
lower-/.f64N/A
lower-*.f64N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f6459.6
Applied rewrites59.6%
Taylor expanded in M around 0
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites54.1%
Taylor expanded in D around inf
lower-*.f64N/A
lower-/.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
associate-*r*N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f6454.1
Applied rewrites54.1%
Final simplification74.7%
d_m = (fabs.f64 d)
D_m = (fabs.f64 D)
M_m = (fabs.f64 M)
(FPCore (w0 M_m D_m h l d_m)
:precision binary64
(if (<= M_m 6.3e-118)
w0
(fma
D_m
(* w0 (* D_m (/ (* h (* (* M_m M_m) -0.125)) (* d_m (* d_m l)))))
w0)))d_m = fabs(d);
D_m = fabs(D);
M_m = fabs(M);
double code(double w0, double M_m, double D_m, double h, double l, double d_m) {
double tmp;
if (M_m <= 6.3e-118) {
tmp = w0;
} else {
tmp = fma(D_m, (w0 * (D_m * ((h * ((M_m * M_m) * -0.125)) / (d_m * (d_m * l))))), w0);
}
return tmp;
}
d_m = abs(d) D_m = abs(D) M_m = abs(M) function code(w0, M_m, D_m, h, l, d_m) tmp = 0.0 if (M_m <= 6.3e-118) tmp = w0; else tmp = fma(D_m, Float64(w0 * Float64(D_m * Float64(Float64(h * Float64(Float64(M_m * M_m) * -0.125)) / Float64(d_m * Float64(d_m * l))))), w0); end return tmp end
d_m = N[Abs[d], $MachinePrecision] D_m = N[Abs[D], $MachinePrecision] M_m = N[Abs[M], $MachinePrecision] code[w0_, M$95$m_, D$95$m_, h_, l_, d$95$m_] := If[LessEqual[M$95$m, 6.3e-118], w0, N[(D$95$m * N[(w0 * N[(D$95$m * N[(N[(h * N[(N[(M$95$m * M$95$m), $MachinePrecision] * -0.125), $MachinePrecision]), $MachinePrecision] / N[(d$95$m * N[(d$95$m * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + w0), $MachinePrecision]]
\begin{array}{l}
d_m = \left|d\right|
\\
D_m = \left|D\right|
\\
M_m = \left|M\right|
\\
\begin{array}{l}
\mathbf{if}\;M\_m \leq 6.3 \cdot 10^{-118}:\\
\;\;\;\;w0\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(D\_m, w0 \cdot \left(D\_m \cdot \frac{h \cdot \left(\left(M\_m \cdot M\_m\right) \cdot -0.125\right)}{d\_m \cdot \left(d\_m \cdot \ell\right)}\right), w0\right)\\
\end{array}
\end{array}
if M < 6.2999999999999997e-118Initial program 84.4%
Taylor expanded in M around 0
Applied rewrites74.1%
*-rgt-identity74.1
Applied rewrites74.1%
if 6.2999999999999997e-118 < M Initial program 83.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 rewrites91.6%
Taylor expanded in M around 0
associate-*r/N/A
lower-/.f64N/A
lower-*.f64N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f6490.2
Applied rewrites90.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
Applied rewrites59.1%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-/.f64N/A
distribute-rgt-inN/A
lift-*.f64N/A
associate-*l*N/A
associate-*l*N/A
*-lft-identityN/A
Applied rewrites63.3%
Final simplification70.8%
d_m = (fabs.f64 d) D_m = (fabs.f64 D) M_m = (fabs.f64 M) (FPCore (w0 M_m D_m h l d_m) :precision binary64 w0)
d_m = fabs(d);
D_m = fabs(D);
M_m = fabs(M);
double code(double w0, double M_m, double D_m, double h, double l, double d_m) {
return w0;
}
d_m = abs(d)
D_m = abs(d)
M_m = abs(m)
real(8) function code(w0, m_m, d_m, h, l, d_m_1)
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_m_1
code = w0
end function
d_m = Math.abs(d);
D_m = Math.abs(D);
M_m = Math.abs(M);
public static double code(double w0, double M_m, double D_m, double h, double l, double d_m) {
return w0;
}
d_m = math.fabs(d) D_m = math.fabs(D) M_m = math.fabs(M) def code(w0, M_m, D_m, h, l, d_m): return w0
d_m = abs(d) D_m = abs(D) M_m = abs(M) function code(w0, M_m, D_m, h, l, d_m) return w0 end
d_m = abs(d); D_m = abs(D); M_m = abs(M); function tmp = code(w0, M_m, D_m, h, l, d_m) tmp = w0; end
d_m = N[Abs[d], $MachinePrecision] D_m = N[Abs[D], $MachinePrecision] M_m = N[Abs[M], $MachinePrecision] code[w0_, M$95$m_, D$95$m_, h_, l_, d$95$m_] := w0
\begin{array}{l}
d_m = \left|d\right|
\\
D_m = \left|D\right|
\\
M_m = \left|M\right|
\\
w0
\end{array}
Initial program 84.2%
Taylor expanded in M around 0
Applied rewrites71.0%
*-rgt-identity71.0
Applied rewrites71.0%
herbie shell --seed 2024216
(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))))))