
(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}
M_m = (fabs.f64 M)
D_m = (fabs.f64 D)
NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function.
(FPCore (w0 M_m D_m h l d)
:precision binary64
(let* ((t_0 (/ (* M_m D_m) (* 2.0 d))))
(if (<= (* M_m D_m) 5e+159)
(* w0 (sqrt (+ 1.0 (* (/ t_0 l) (/ t_0 (/ -1.0 h))))))
(if (<= (* M_m D_m) 2e+190)
(* w0 (* D_m (sqrt (* -0.25 (* M_m (* h (/ M_m (* l (* d d)))))))))
(*
w0
(sqrt
(-
1.0
(* (/ D_m d) (* (/ (* M_m (* h (/ D_m d))) l) (* M_m 0.25))))))))))M_m = fabs(M);
D_m = fabs(D);
assert(w0 < M_m && M_m < D_m && D_m < h && h < l && l < d);
double code(double w0, double M_m, double D_m, double h, double l, double d) {
double t_0 = (M_m * D_m) / (2.0 * d);
double tmp;
if ((M_m * D_m) <= 5e+159) {
tmp = w0 * sqrt((1.0 + ((t_0 / l) * (t_0 / (-1.0 / h)))));
} else if ((M_m * D_m) <= 2e+190) {
tmp = w0 * (D_m * sqrt((-0.25 * (M_m * (h * (M_m / (l * (d * d))))))));
} else {
tmp = w0 * sqrt((1.0 - ((D_m / d) * (((M_m * (h * (D_m / d))) / l) * (M_m * 0.25)))));
}
return tmp;
}
M_m = abs(m)
D_m = abs(d)
NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function.
real(8) function code(w0, m_m, d_m, h, l, d)
real(8), intent (in) :: w0
real(8), intent (in) :: m_m
real(8), intent (in) :: d_m
real(8), intent (in) :: h
real(8), intent (in) :: l
real(8), intent (in) :: d
real(8) :: t_0
real(8) :: tmp
t_0 = (m_m * d_m) / (2.0d0 * d)
if ((m_m * d_m) <= 5d+159) then
tmp = w0 * sqrt((1.0d0 + ((t_0 / l) * (t_0 / ((-1.0d0) / h)))))
else if ((m_m * d_m) <= 2d+190) then
tmp = w0 * (d_m * sqrt(((-0.25d0) * (m_m * (h * (m_m / (l * (d * d))))))))
else
tmp = w0 * sqrt((1.0d0 - ((d_m / d) * (((m_m * (h * (d_m / d))) / l) * (m_m * 0.25d0)))))
end if
code = tmp
end function
M_m = Math.abs(M);
D_m = Math.abs(D);
assert w0 < M_m && M_m < D_m && D_m < h && h < l && l < d;
public static double code(double w0, double M_m, double D_m, double h, double l, double d) {
double t_0 = (M_m * D_m) / (2.0 * d);
double tmp;
if ((M_m * D_m) <= 5e+159) {
tmp = w0 * Math.sqrt((1.0 + ((t_0 / l) * (t_0 / (-1.0 / h)))));
} else if ((M_m * D_m) <= 2e+190) {
tmp = w0 * (D_m * Math.sqrt((-0.25 * (M_m * (h * (M_m / (l * (d * d))))))));
} else {
tmp = w0 * Math.sqrt((1.0 - ((D_m / d) * (((M_m * (h * (D_m / d))) / l) * (M_m * 0.25)))));
}
return tmp;
}
M_m = math.fabs(M) D_m = math.fabs(D) [w0, M_m, D_m, h, l, d] = sort([w0, M_m, D_m, h, l, d]) def code(w0, M_m, D_m, h, l, d): t_0 = (M_m * D_m) / (2.0 * d) tmp = 0 if (M_m * D_m) <= 5e+159: tmp = w0 * math.sqrt((1.0 + ((t_0 / l) * (t_0 / (-1.0 / h))))) elif (M_m * D_m) <= 2e+190: tmp = w0 * (D_m * math.sqrt((-0.25 * (M_m * (h * (M_m / (l * (d * d)))))))) else: tmp = w0 * math.sqrt((1.0 - ((D_m / d) * (((M_m * (h * (D_m / d))) / l) * (M_m * 0.25))))) return tmp
M_m = abs(M) D_m = abs(D) w0, M_m, D_m, h, l, d = sort([w0, M_m, D_m, h, l, d]) function code(w0, M_m, D_m, h, l, d) t_0 = Float64(Float64(M_m * D_m) / Float64(2.0 * d)) tmp = 0.0 if (Float64(M_m * D_m) <= 5e+159) tmp = Float64(w0 * sqrt(Float64(1.0 + Float64(Float64(t_0 / l) * Float64(t_0 / Float64(-1.0 / h)))))); elseif (Float64(M_m * D_m) <= 2e+190) tmp = Float64(w0 * Float64(D_m * sqrt(Float64(-0.25 * Float64(M_m * Float64(h * Float64(M_m / Float64(l * Float64(d * d))))))))); else tmp = Float64(w0 * sqrt(Float64(1.0 - Float64(Float64(D_m / d) * Float64(Float64(Float64(M_m * Float64(h * Float64(D_m / d))) / l) * Float64(M_m * 0.25)))))); end return tmp end
M_m = abs(M);
D_m = abs(D);
w0, M_m, D_m, h, l, d = num2cell(sort([w0, M_m, D_m, h, l, d])){:}
function tmp_2 = code(w0, M_m, D_m, h, l, d)
t_0 = (M_m * D_m) / (2.0 * d);
tmp = 0.0;
if ((M_m * D_m) <= 5e+159)
tmp = w0 * sqrt((1.0 + ((t_0 / l) * (t_0 / (-1.0 / h)))));
elseif ((M_m * D_m) <= 2e+190)
tmp = w0 * (D_m * sqrt((-0.25 * (M_m * (h * (M_m / (l * (d * d))))))));
else
tmp = w0 * sqrt((1.0 - ((D_m / d) * (((M_m * (h * (D_m / d))) / l) * (M_m * 0.25)))));
end
tmp_2 = tmp;
end
M_m = N[Abs[M], $MachinePrecision]
D_m = N[Abs[D], $MachinePrecision]
NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function.
code[w0_, M$95$m_, D$95$m_, h_, l_, d_] := Block[{t$95$0 = N[(N[(M$95$m * D$95$m), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(M$95$m * D$95$m), $MachinePrecision], 5e+159], N[(w0 * N[Sqrt[N[(1.0 + N[(N[(t$95$0 / l), $MachinePrecision] * N[(t$95$0 / N[(-1.0 / h), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(M$95$m * D$95$m), $MachinePrecision], 2e+190], N[(w0 * N[(D$95$m * N[Sqrt[N[(-0.25 * N[(M$95$m * N[(h * N[(M$95$m / N[(l * N[(d * d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(w0 * N[Sqrt[N[(1.0 - N[(N[(D$95$m / d), $MachinePrecision] * N[(N[(N[(M$95$m * N[(h * N[(D$95$m / d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision] * N[(M$95$m * 0.25), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
M_m = \left|M\right|
\\
D_m = \left|D\right|
\\
[w0, M_m, D_m, h, l, d] = \mathsf{sort}([w0, M_m, D_m, h, l, d])\\
\\
\begin{array}{l}
t_0 := \frac{M\_m \cdot D\_m}{2 \cdot d}\\
\mathbf{if}\;M\_m \cdot D\_m \leq 5 \cdot 10^{+159}:\\
\;\;\;\;w0 \cdot \sqrt{1 + \frac{t\_0}{\ell} \cdot \frac{t\_0}{\frac{-1}{h}}}\\
\mathbf{elif}\;M\_m \cdot D\_m \leq 2 \cdot 10^{+190}:\\
\;\;\;\;w0 \cdot \left(D\_m \cdot \sqrt{-0.25 \cdot \left(M\_m \cdot \left(h \cdot \frac{M\_m}{\ell \cdot \left(d \cdot d\right)}\right)\right)}\right)\\
\mathbf{else}:\\
\;\;\;\;w0 \cdot \sqrt{1 - \frac{D\_m}{d} \cdot \left(\frac{M\_m \cdot \left(h \cdot \frac{D\_m}{d}\right)}{\ell} \cdot \left(M\_m \cdot 0.25\right)\right)}\\
\end{array}
\end{array}
if (*.f64 M D) < 5.00000000000000003e159Initial program 83.6%
clear-numN/A
un-div-invN/A
unpow2N/A
div-invN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f6491.7
Applied egg-rr91.7%
if 5.00000000000000003e159 < (*.f64 M D) < 2.0000000000000001e190Initial program 28.0%
clear-numN/A
un-div-invN/A
unpow2N/A
div-invN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f6428.0
Applied egg-rr28.0%
Taylor expanded in M around inf
associate-/l*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6428.0
Simplified28.0%
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr26.4%
if 2.0000000000000001e190 < (*.f64 M D) Initial program 75.5%
*-commutativeN/A
unpow2N/A
times-fracN/A
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr65.8%
associate-*r*N/A
associate-*l*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
frac-timesN/A
*-commutativeN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6471.4
Applied egg-rr71.4%
associate-/r*N/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f6476.2
Applied egg-rr76.2%
Final simplification89.5%
M_m = (fabs.f64 M)
D_m = (fabs.f64 D)
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) 4e-169)
(* w0 (fma (* D_m D_m) (/ (/ (* -0.125 (/ (* M_m (* M_m h)) l)) d) d) 1.0))
(if (<= (* M_m D_m) 4e+150)
(*
w0
(sqrt
(fma -0.25 (* (/ (* (* M_m D_m) (* M_m D_m)) (* d l)) (/ h d)) 1.0)))
(*
w0
(sqrt
(-
1.0
(* (* M_m 0.25) (* (/ D_m d) (* (/ M_m (* d l)) (* D_m h))))))))))M_m = fabs(M);
D_m = fabs(D);
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) <= 4e-169) {
tmp = w0 * fma((D_m * D_m), (((-0.125 * ((M_m * (M_m * h)) / l)) / d) / d), 1.0);
} else if ((M_m * D_m) <= 4e+150) {
tmp = w0 * sqrt(fma(-0.25, ((((M_m * D_m) * (M_m * D_m)) / (d * l)) * (h / d)), 1.0));
} else {
tmp = w0 * sqrt((1.0 - ((M_m * 0.25) * ((D_m / d) * ((M_m / (d * l)) * (D_m * h))))));
}
return tmp;
}
M_m = abs(M) D_m = abs(D) 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) <= 4e-169) tmp = Float64(w0 * fma(Float64(D_m * D_m), Float64(Float64(Float64(-0.125 * Float64(Float64(M_m * Float64(M_m * h)) / l)) / d) / d), 1.0)); elseif (Float64(M_m * D_m) <= 4e+150) tmp = Float64(w0 * sqrt(fma(-0.25, Float64(Float64(Float64(Float64(M_m * D_m) * Float64(M_m * D_m)) / Float64(d * l)) * Float64(h / d)), 1.0))); else tmp = Float64(w0 * sqrt(Float64(1.0 - Float64(Float64(M_m * 0.25) * Float64(Float64(D_m / d) * Float64(Float64(M_m / Float64(d * l)) * Float64(D_m * h))))))); end return tmp end
M_m = N[Abs[M], $MachinePrecision] D_m = N[Abs[D], $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], 4e-169], N[(w0 * N[(N[(D$95$m * D$95$m), $MachinePrecision] * N[(N[(N[(-0.125 * N[(N[(M$95$m * N[(M$95$m * h), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision] / d), $MachinePrecision] / d), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(M$95$m * D$95$m), $MachinePrecision], 4e+150], N[(w0 * N[Sqrt[N[(-0.25 * N[(N[(N[(N[(M$95$m * D$95$m), $MachinePrecision] * N[(M$95$m * D$95$m), $MachinePrecision]), $MachinePrecision] / N[(d * l), $MachinePrecision]), $MachinePrecision] * N[(h / d), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(w0 * N[Sqrt[N[(1.0 - N[(N[(M$95$m * 0.25), $MachinePrecision] * N[(N[(D$95$m / d), $MachinePrecision] * N[(N[(M$95$m / N[(d * l), $MachinePrecision]), $MachinePrecision] * N[(D$95$m * h), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
M_m = \left|M\right|
\\
D_m = \left|D\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 4 \cdot 10^{-169}:\\
\;\;\;\;w0 \cdot \mathsf{fma}\left(D\_m \cdot D\_m, \frac{\frac{-0.125 \cdot \frac{M\_m \cdot \left(M\_m \cdot h\right)}{\ell}}{d}}{d}, 1\right)\\
\mathbf{elif}\;M\_m \cdot D\_m \leq 4 \cdot 10^{+150}:\\
\;\;\;\;w0 \cdot \sqrt{\mathsf{fma}\left(-0.25, \frac{\left(M\_m \cdot D\_m\right) \cdot \left(M\_m \cdot D\_m\right)}{d \cdot \ell} \cdot \frac{h}{d}, 1\right)}\\
\mathbf{else}:\\
\;\;\;\;w0 \cdot \sqrt{1 - \left(M\_m \cdot 0.25\right) \cdot \left(\frac{D\_m}{d} \cdot \left(\frac{M\_m}{d \cdot \ell} \cdot \left(D\_m \cdot h\right)\right)\right)}\\
\end{array}
\end{array}
if (*.f64 M D) < 4.00000000000000008e-169Initial program 81.5%
Taylor expanded in w0 around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
unpow2N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6458.8
Simplified58.8%
Taylor expanded in D around 0
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
Simplified49.9%
associate-/r*N/A
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
associate-*l*N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f6463.3
Applied egg-rr63.3%
if 4.00000000000000008e-169 < (*.f64 M D) < 3.99999999999999992e150Initial program 88.9%
Taylor expanded in w0 around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
unpow2N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6464.0
Simplified64.0%
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr63.6%
associate-*r*N/A
*-commutativeN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f6495.4
Applied egg-rr95.4%
if 3.99999999999999992e150 < (*.f64 M D) Initial program 70.1%
*-commutativeN/A
unpow2N/A
times-fracN/A
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr62.6%
associate-*r*N/A
associate-*l*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
frac-timesN/A
*-commutativeN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6466.9
Applied egg-rr66.9%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6477.8
Applied egg-rr77.8%
Final simplification72.5%
M_m = (fabs.f64 M)
D_m = (fabs.f64 D)
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) 4e-169)
(* w0 (fma (* D_m D_m) (/ (/ (* -0.125 (/ (* M_m (* M_m h)) l)) d) d) 1.0))
(if (<= (* M_m D_m) 4e+150)
(*
w0
(sqrt
(fma -0.25 (* (/ (* (* M_m D_m) (* M_m D_m)) (* d l)) (/ h d)) 1.0)))
(*
w0
(sqrt
(-
1.0
(* (/ D_m d) (* (* M_m 0.25) (* M_m (/ (* D_m h) (* d l)))))))))))M_m = fabs(M);
D_m = fabs(D);
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) <= 4e-169) {
tmp = w0 * fma((D_m * D_m), (((-0.125 * ((M_m * (M_m * h)) / l)) / d) / d), 1.0);
} else if ((M_m * D_m) <= 4e+150) {
tmp = w0 * sqrt(fma(-0.25, ((((M_m * D_m) * (M_m * D_m)) / (d * l)) * (h / d)), 1.0));
} else {
tmp = w0 * sqrt((1.0 - ((D_m / d) * ((M_m * 0.25) * (M_m * ((D_m * h) / (d * l)))))));
}
return tmp;
}
M_m = abs(M) D_m = abs(D) 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) <= 4e-169) tmp = Float64(w0 * fma(Float64(D_m * D_m), Float64(Float64(Float64(-0.125 * Float64(Float64(M_m * Float64(M_m * h)) / l)) / d) / d), 1.0)); elseif (Float64(M_m * D_m) <= 4e+150) tmp = Float64(w0 * sqrt(fma(-0.25, Float64(Float64(Float64(Float64(M_m * D_m) * Float64(M_m * D_m)) / Float64(d * l)) * Float64(h / d)), 1.0))); else tmp = Float64(w0 * sqrt(Float64(1.0 - Float64(Float64(D_m / d) * Float64(Float64(M_m * 0.25) * Float64(M_m * Float64(Float64(D_m * h) / Float64(d * l)))))))); end return tmp end
M_m = N[Abs[M], $MachinePrecision] D_m = N[Abs[D], $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], 4e-169], N[(w0 * N[(N[(D$95$m * D$95$m), $MachinePrecision] * N[(N[(N[(-0.125 * N[(N[(M$95$m * N[(M$95$m * h), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision] / d), $MachinePrecision] / d), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(M$95$m * D$95$m), $MachinePrecision], 4e+150], N[(w0 * N[Sqrt[N[(-0.25 * N[(N[(N[(N[(M$95$m * D$95$m), $MachinePrecision] * N[(M$95$m * D$95$m), $MachinePrecision]), $MachinePrecision] / N[(d * l), $MachinePrecision]), $MachinePrecision] * N[(h / d), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(w0 * N[Sqrt[N[(1.0 - N[(N[(D$95$m / d), $MachinePrecision] * N[(N[(M$95$m * 0.25), $MachinePrecision] * N[(M$95$m * N[(N[(D$95$m * h), $MachinePrecision] / N[(d * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
M_m = \left|M\right|
\\
D_m = \left|D\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 4 \cdot 10^{-169}:\\
\;\;\;\;w0 \cdot \mathsf{fma}\left(D\_m \cdot D\_m, \frac{\frac{-0.125 \cdot \frac{M\_m \cdot \left(M\_m \cdot h\right)}{\ell}}{d}}{d}, 1\right)\\
\mathbf{elif}\;M\_m \cdot D\_m \leq 4 \cdot 10^{+150}:\\
\;\;\;\;w0 \cdot \sqrt{\mathsf{fma}\left(-0.25, \frac{\left(M\_m \cdot D\_m\right) \cdot \left(M\_m \cdot D\_m\right)}{d \cdot \ell} \cdot \frac{h}{d}, 1\right)}\\
\mathbf{else}:\\
\;\;\;\;w0 \cdot \sqrt{1 - \frac{D\_m}{d} \cdot \left(\left(M\_m \cdot 0.25\right) \cdot \left(M\_m \cdot \frac{D\_m \cdot h}{d \cdot \ell}\right)\right)}\\
\end{array}
\end{array}
if (*.f64 M D) < 4.00000000000000008e-169Initial program 81.5%
Taylor expanded in w0 around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
unpow2N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6458.8
Simplified58.8%
Taylor expanded in D around 0
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
Simplified49.9%
associate-/r*N/A
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
associate-*l*N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f6463.3
Applied egg-rr63.3%
if 4.00000000000000008e-169 < (*.f64 M D) < 3.99999999999999992e150Initial program 88.9%
Taylor expanded in w0 around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
unpow2N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6464.0
Simplified64.0%
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr63.6%
associate-*r*N/A
*-commutativeN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f6495.4
Applied egg-rr95.4%
if 3.99999999999999992e150 < (*.f64 M D) Initial program 70.1%
*-commutativeN/A
unpow2N/A
times-fracN/A
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr62.6%
associate-*r*N/A
associate-*l*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
frac-timesN/A
*-commutativeN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6466.9
Applied egg-rr66.9%
Final simplification71.4%
M_m = (fabs.f64 M)
D_m = (fabs.f64 D)
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) 4e-169)
(* w0 (fma (* D_m D_m) (/ (/ (* -0.125 (/ (* M_m (* M_m h)) l)) d) d) 1.0))
(if (<= (* M_m D_m) 1e+154)
(*
w0
(sqrt
(fma -0.25 (* (/ (* (* M_m D_m) (* M_m D_m)) (* d l)) (/ h d)) 1.0)))
(if (<= (* M_m D_m) 2e+190)
(* w0 (* D_m (sqrt (* -0.25 (* M_m (* h (/ M_m (* l (* d d)))))))))
(fma
D_m
(* w0 (* (/ h d) (/ (* (* M_m M_m) (* D_m -0.125)) (* d l))))
w0)))))M_m = fabs(M);
D_m = fabs(D);
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) <= 4e-169) {
tmp = w0 * fma((D_m * D_m), (((-0.125 * ((M_m * (M_m * h)) / l)) / d) / d), 1.0);
} else if ((M_m * D_m) <= 1e+154) {
tmp = w0 * sqrt(fma(-0.25, ((((M_m * D_m) * (M_m * D_m)) / (d * l)) * (h / d)), 1.0));
} else if ((M_m * D_m) <= 2e+190) {
tmp = w0 * (D_m * sqrt((-0.25 * (M_m * (h * (M_m / (l * (d * d))))))));
} else {
tmp = fma(D_m, (w0 * ((h / d) * (((M_m * M_m) * (D_m * -0.125)) / (d * l)))), w0);
}
return tmp;
}
M_m = abs(M) D_m = abs(D) 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) <= 4e-169) tmp = Float64(w0 * fma(Float64(D_m * D_m), Float64(Float64(Float64(-0.125 * Float64(Float64(M_m * Float64(M_m * h)) / l)) / d) / d), 1.0)); elseif (Float64(M_m * D_m) <= 1e+154) tmp = Float64(w0 * sqrt(fma(-0.25, Float64(Float64(Float64(Float64(M_m * D_m) * Float64(M_m * D_m)) / Float64(d * l)) * Float64(h / d)), 1.0))); elseif (Float64(M_m * D_m) <= 2e+190) tmp = Float64(w0 * Float64(D_m * sqrt(Float64(-0.25 * Float64(M_m * Float64(h * Float64(M_m / Float64(l * Float64(d * d))))))))); else tmp = fma(D_m, Float64(w0 * Float64(Float64(h / d) * Float64(Float64(Float64(M_m * M_m) * Float64(D_m * -0.125)) / Float64(d * l)))), w0); end return tmp end
M_m = N[Abs[M], $MachinePrecision] D_m = N[Abs[D], $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], 4e-169], N[(w0 * N[(N[(D$95$m * D$95$m), $MachinePrecision] * N[(N[(N[(-0.125 * N[(N[(M$95$m * N[(M$95$m * h), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision] / d), $MachinePrecision] / d), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(M$95$m * D$95$m), $MachinePrecision], 1e+154], N[(w0 * N[Sqrt[N[(-0.25 * N[(N[(N[(N[(M$95$m * D$95$m), $MachinePrecision] * N[(M$95$m * D$95$m), $MachinePrecision]), $MachinePrecision] / N[(d * l), $MachinePrecision]), $MachinePrecision] * N[(h / d), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(M$95$m * D$95$m), $MachinePrecision], 2e+190], N[(w0 * N[(D$95$m * N[Sqrt[N[(-0.25 * N[(M$95$m * N[(h * N[(M$95$m / N[(l * N[(d * d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(D$95$m * N[(w0 * N[(N[(h / d), $MachinePrecision] * N[(N[(N[(M$95$m * M$95$m), $MachinePrecision] * N[(D$95$m * -0.125), $MachinePrecision]), $MachinePrecision] / N[(d * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + w0), $MachinePrecision]]]]
\begin{array}{l}
M_m = \left|M\right|
\\
D_m = \left|D\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 4 \cdot 10^{-169}:\\
\;\;\;\;w0 \cdot \mathsf{fma}\left(D\_m \cdot D\_m, \frac{\frac{-0.125 \cdot \frac{M\_m \cdot \left(M\_m \cdot h\right)}{\ell}}{d}}{d}, 1\right)\\
\mathbf{elif}\;M\_m \cdot D\_m \leq 10^{+154}:\\
\;\;\;\;w0 \cdot \sqrt{\mathsf{fma}\left(-0.25, \frac{\left(M\_m \cdot D\_m\right) \cdot \left(M\_m \cdot D\_m\right)}{d \cdot \ell} \cdot \frac{h}{d}, 1\right)}\\
\mathbf{elif}\;M\_m \cdot D\_m \leq 2 \cdot 10^{+190}:\\
\;\;\;\;w0 \cdot \left(D\_m \cdot \sqrt{-0.25 \cdot \left(M\_m \cdot \left(h \cdot \frac{M\_m}{\ell \cdot \left(d \cdot d\right)}\right)\right)}\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(D\_m, w0 \cdot \left(\frac{h}{d} \cdot \frac{\left(M\_m \cdot M\_m\right) \cdot \left(D\_m \cdot -0.125\right)}{d \cdot \ell}\right), w0\right)\\
\end{array}
\end{array}
if (*.f64 M D) < 4.00000000000000008e-169Initial program 81.5%
Taylor expanded in w0 around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
unpow2N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6458.8
Simplified58.8%
Taylor expanded in D around 0
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
Simplified49.9%
associate-/r*N/A
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
associate-*l*N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f6463.3
Applied egg-rr63.3%
if 4.00000000000000008e-169 < (*.f64 M D) < 1.00000000000000004e154Initial program 89.2%
Taylor expanded in w0 around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
unpow2N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6462.3
Simplified62.3%
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr63.2%
associate-*r*N/A
*-commutativeN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f6495.5
Applied egg-rr95.5%
if 1.00000000000000004e154 < (*.f64 M D) < 2.0000000000000001e190Initial program 28.0%
clear-numN/A
un-div-invN/A
unpow2N/A
div-invN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f6428.0
Applied egg-rr28.0%
Taylor expanded in M around inf
associate-/l*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6428.0
Simplified28.0%
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr26.4%
if 2.0000000000000001e190 < (*.f64 M D) Initial program 75.5%
Taylor expanded in w0 around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
unpow2N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6446.0
Simplified46.0%
Taylor expanded in D around 0
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
Simplified46.0%
distribute-rgt-inN/A
associate-*l*N/A
associate-*l*N/A
*-lft-identityN/A
accelerator-lowering-fma.f64N/A
Applied egg-rr41.0%
associate-*r/N/A
associate-*r*N/A
times-fracN/A
*-lowering-*.f64N/A
*-commutativeN/A
/-lowering-/.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f6465.8
Applied egg-rr65.8%
Final simplification70.9%
M_m = (fabs.f64 M)
D_m = (fabs.f64 D)
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 (* l (* d d))))
(if (<= (* M_m D_m) 2e-147)
(*
w0
(fma (* D_m D_m) (/ (/ (* -0.125 (/ (* M_m (* M_m h)) l)) d) d) 1.0))
(if (<= (* M_m D_m) 1e+154)
(* w0 (sqrt (fma -0.25 (* (* (* M_m D_m) (* M_m D_m)) (/ h t_0)) 1.0)))
(if (<= (* M_m D_m) 2e+190)
(* w0 (* D_m (sqrt (* -0.25 (* M_m (* h (/ M_m t_0)))))))
(fma
D_m
(* w0 (* (/ h d) (/ (* (* M_m M_m) (* D_m -0.125)) (* d l))))
w0))))))M_m = fabs(M);
D_m = fabs(D);
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 = l * (d * d);
double tmp;
if ((M_m * D_m) <= 2e-147) {
tmp = w0 * fma((D_m * D_m), (((-0.125 * ((M_m * (M_m * h)) / l)) / d) / d), 1.0);
} else if ((M_m * D_m) <= 1e+154) {
tmp = w0 * sqrt(fma(-0.25, (((M_m * D_m) * (M_m * D_m)) * (h / t_0)), 1.0));
} else if ((M_m * D_m) <= 2e+190) {
tmp = w0 * (D_m * sqrt((-0.25 * (M_m * (h * (M_m / t_0))))));
} else {
tmp = fma(D_m, (w0 * ((h / d) * (((M_m * M_m) * (D_m * -0.125)) / (d * l)))), w0);
}
return tmp;
}
M_m = abs(M) D_m = abs(D) 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(l * Float64(d * d)) tmp = 0.0 if (Float64(M_m * D_m) <= 2e-147) tmp = Float64(w0 * fma(Float64(D_m * D_m), Float64(Float64(Float64(-0.125 * Float64(Float64(M_m * Float64(M_m * h)) / l)) / d) / d), 1.0)); elseif (Float64(M_m * D_m) <= 1e+154) tmp = Float64(w0 * sqrt(fma(-0.25, Float64(Float64(Float64(M_m * D_m) * Float64(M_m * D_m)) * Float64(h / t_0)), 1.0))); elseif (Float64(M_m * D_m) <= 2e+190) tmp = Float64(w0 * Float64(D_m * sqrt(Float64(-0.25 * Float64(M_m * Float64(h * Float64(M_m / t_0))))))); else tmp = fma(D_m, Float64(w0 * Float64(Float64(h / d) * Float64(Float64(Float64(M_m * M_m) * Float64(D_m * -0.125)) / Float64(d * l)))), w0); end return tmp end
M_m = N[Abs[M], $MachinePrecision]
D_m = N[Abs[D], $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[(l * N[(d * d), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(M$95$m * D$95$m), $MachinePrecision], 2e-147], N[(w0 * N[(N[(D$95$m * D$95$m), $MachinePrecision] * N[(N[(N[(-0.125 * N[(N[(M$95$m * N[(M$95$m * h), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision] / d), $MachinePrecision] / d), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(M$95$m * D$95$m), $MachinePrecision], 1e+154], N[(w0 * N[Sqrt[N[(-0.25 * N[(N[(N[(M$95$m * D$95$m), $MachinePrecision] * N[(M$95$m * D$95$m), $MachinePrecision]), $MachinePrecision] * N[(h / t$95$0), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(M$95$m * D$95$m), $MachinePrecision], 2e+190], N[(w0 * N[(D$95$m * N[Sqrt[N[(-0.25 * N[(M$95$m * N[(h * N[(M$95$m / t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(D$95$m * N[(w0 * N[(N[(h / d), $MachinePrecision] * N[(N[(N[(M$95$m * M$95$m), $MachinePrecision] * N[(D$95$m * -0.125), $MachinePrecision]), $MachinePrecision] / N[(d * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + w0), $MachinePrecision]]]]]
\begin{array}{l}
M_m = \left|M\right|
\\
D_m = \left|D\right|
\\
[w0, M_m, D_m, h, l, d] = \mathsf{sort}([w0, M_m, D_m, h, l, d])\\
\\
\begin{array}{l}
t_0 := \ell \cdot \left(d \cdot d\right)\\
\mathbf{if}\;M\_m \cdot D\_m \leq 2 \cdot 10^{-147}:\\
\;\;\;\;w0 \cdot \mathsf{fma}\left(D\_m \cdot D\_m, \frac{\frac{-0.125 \cdot \frac{M\_m \cdot \left(M\_m \cdot h\right)}{\ell}}{d}}{d}, 1\right)\\
\mathbf{elif}\;M\_m \cdot D\_m \leq 10^{+154}:\\
\;\;\;\;w0 \cdot \sqrt{\mathsf{fma}\left(-0.25, \left(\left(M\_m \cdot D\_m\right) \cdot \left(M\_m \cdot D\_m\right)\right) \cdot \frac{h}{t\_0}, 1\right)}\\
\mathbf{elif}\;M\_m \cdot D\_m \leq 2 \cdot 10^{+190}:\\
\;\;\;\;w0 \cdot \left(D\_m \cdot \sqrt{-0.25 \cdot \left(M\_m \cdot \left(h \cdot \frac{M\_m}{t\_0}\right)\right)}\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(D\_m, w0 \cdot \left(\frac{h}{d} \cdot \frac{\left(M\_m \cdot M\_m\right) \cdot \left(D\_m \cdot -0.125\right)}{d \cdot \ell}\right), w0\right)\\
\end{array}
\end{array}
if (*.f64 M D) < 1.9999999999999999e-147Initial program 81.3%
Taylor expanded in w0 around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
unpow2N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6459.2
Simplified59.2%
Taylor expanded in D around 0
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
Simplified50.5%
associate-/r*N/A
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
associate-*l*N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f6463.6
Applied egg-rr63.6%
if 1.9999999999999999e-147 < (*.f64 M D) < 1.00000000000000004e154Initial program 90.2%
Taylor expanded in w0 around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
unpow2N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6461.4
Simplified61.4%
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr62.5%
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6487.4
Applied egg-rr87.4%
if 1.00000000000000004e154 < (*.f64 M D) < 2.0000000000000001e190Initial program 28.0%
clear-numN/A
un-div-invN/A
unpow2N/A
div-invN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f6428.0
Applied egg-rr28.0%
Taylor expanded in M around inf
associate-/l*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6428.0
Simplified28.0%
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr26.4%
if 2.0000000000000001e190 < (*.f64 M D) Initial program 75.5%
Taylor expanded in w0 around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
unpow2N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6446.0
Simplified46.0%
Taylor expanded in D around 0
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
Simplified46.0%
distribute-rgt-inN/A
associate-*l*N/A
associate-*l*N/A
*-lft-identityN/A
accelerator-lowering-fma.f64N/A
Applied egg-rr41.0%
associate-*r/N/A
associate-*r*N/A
times-fracN/A
*-lowering-*.f64N/A
*-commutativeN/A
/-lowering-/.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f6465.8
Applied egg-rr65.8%
Final simplification68.8%
M_m = (fabs.f64 M)
D_m = (fabs.f64 D)
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 (* l (* d d))))
(if (<= (* M_m D_m) 2e-147)
w0
(if (<= (* M_m D_m) 1e+154)
(* w0 (sqrt (fma -0.25 (* (* (* M_m D_m) (* M_m D_m)) (/ h t_0)) 1.0)))
(if (<= (* M_m D_m) 2e+190)
(* w0 (* D_m (sqrt (* -0.25 (* M_m (* h (/ M_m t_0)))))))
(fma
D_m
(* w0 (* (/ h d) (/ (* (* M_m M_m) (* D_m -0.125)) (* d l))))
w0))))))M_m = fabs(M);
D_m = fabs(D);
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 = l * (d * d);
double tmp;
if ((M_m * D_m) <= 2e-147) {
tmp = w0;
} else if ((M_m * D_m) <= 1e+154) {
tmp = w0 * sqrt(fma(-0.25, (((M_m * D_m) * (M_m * D_m)) * (h / t_0)), 1.0));
} else if ((M_m * D_m) <= 2e+190) {
tmp = w0 * (D_m * sqrt((-0.25 * (M_m * (h * (M_m / t_0))))));
} else {
tmp = fma(D_m, (w0 * ((h / d) * (((M_m * M_m) * (D_m * -0.125)) / (d * l)))), w0);
}
return tmp;
}
M_m = abs(M) D_m = abs(D) 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(l * Float64(d * d)) tmp = 0.0 if (Float64(M_m * D_m) <= 2e-147) tmp = w0; elseif (Float64(M_m * D_m) <= 1e+154) tmp = Float64(w0 * sqrt(fma(-0.25, Float64(Float64(Float64(M_m * D_m) * Float64(M_m * D_m)) * Float64(h / t_0)), 1.0))); elseif (Float64(M_m * D_m) <= 2e+190) tmp = Float64(w0 * Float64(D_m * sqrt(Float64(-0.25 * Float64(M_m * Float64(h * Float64(M_m / t_0))))))); else tmp = fma(D_m, Float64(w0 * Float64(Float64(h / d) * Float64(Float64(Float64(M_m * M_m) * Float64(D_m * -0.125)) / Float64(d * l)))), w0); end return tmp end
M_m = N[Abs[M], $MachinePrecision]
D_m = N[Abs[D], $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[(l * N[(d * d), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(M$95$m * D$95$m), $MachinePrecision], 2e-147], w0, If[LessEqual[N[(M$95$m * D$95$m), $MachinePrecision], 1e+154], N[(w0 * N[Sqrt[N[(-0.25 * N[(N[(N[(M$95$m * D$95$m), $MachinePrecision] * N[(M$95$m * D$95$m), $MachinePrecision]), $MachinePrecision] * N[(h / t$95$0), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(M$95$m * D$95$m), $MachinePrecision], 2e+190], N[(w0 * N[(D$95$m * N[Sqrt[N[(-0.25 * N[(M$95$m * N[(h * N[(M$95$m / t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(D$95$m * N[(w0 * N[(N[(h / d), $MachinePrecision] * N[(N[(N[(M$95$m * M$95$m), $MachinePrecision] * N[(D$95$m * -0.125), $MachinePrecision]), $MachinePrecision] / N[(d * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + w0), $MachinePrecision]]]]]
\begin{array}{l}
M_m = \left|M\right|
\\
D_m = \left|D\right|
\\
[w0, M_m, D_m, h, l, d] = \mathsf{sort}([w0, M_m, D_m, h, l, d])\\
\\
\begin{array}{l}
t_0 := \ell \cdot \left(d \cdot d\right)\\
\mathbf{if}\;M\_m \cdot D\_m \leq 2 \cdot 10^{-147}:\\
\;\;\;\;w0\\
\mathbf{elif}\;M\_m \cdot D\_m \leq 10^{+154}:\\
\;\;\;\;w0 \cdot \sqrt{\mathsf{fma}\left(-0.25, \left(\left(M\_m \cdot D\_m\right) \cdot \left(M\_m \cdot D\_m\right)\right) \cdot \frac{h}{t\_0}, 1\right)}\\
\mathbf{elif}\;M\_m \cdot D\_m \leq 2 \cdot 10^{+190}:\\
\;\;\;\;w0 \cdot \left(D\_m \cdot \sqrt{-0.25 \cdot \left(M\_m \cdot \left(h \cdot \frac{M\_m}{t\_0}\right)\right)}\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(D\_m, w0 \cdot \left(\frac{h}{d} \cdot \frac{\left(M\_m \cdot M\_m\right) \cdot \left(D\_m \cdot -0.125\right)}{d \cdot \ell}\right), w0\right)\\
\end{array}
\end{array}
if (*.f64 M D) < 1.9999999999999999e-147Initial program 81.3%
Taylor expanded in M around 0
Simplified81.0%
if 1.9999999999999999e-147 < (*.f64 M D) < 1.00000000000000004e154Initial program 90.2%
Taylor expanded in w0 around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
unpow2N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6461.4
Simplified61.4%
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr62.5%
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6487.4
Applied egg-rr87.4%
if 1.00000000000000004e154 < (*.f64 M D) < 2.0000000000000001e190Initial program 28.0%
clear-numN/A
un-div-invN/A
unpow2N/A
div-invN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f6428.0
Applied egg-rr28.0%
Taylor expanded in M around inf
associate-/l*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6428.0
Simplified28.0%
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr26.4%
if 2.0000000000000001e190 < (*.f64 M D) Initial program 75.5%
Taylor expanded in w0 around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
unpow2N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6446.0
Simplified46.0%
Taylor expanded in D around 0
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
Simplified46.0%
distribute-rgt-inN/A
associate-*l*N/A
associate-*l*N/A
*-lft-identityN/A
accelerator-lowering-fma.f64N/A
Applied egg-rr41.0%
associate-*r/N/A
associate-*r*N/A
times-fracN/A
*-lowering-*.f64N/A
*-commutativeN/A
/-lowering-/.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f6465.8
Applied egg-rr65.8%
Final simplification80.5%
M_m = (fabs.f64 M)
D_m = (fabs.f64 D)
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) 4e-169)
(* w0 (fma (* D_m D_m) (/ (/ (* -0.125 (/ (* M_m (* M_m h)) l)) d) d) 1.0))
(if (<= (* M_m D_m) 4e+150)
(*
w0
(sqrt
(fma -0.25 (* (/ (* (* M_m D_m) (* M_m D_m)) (* d l)) (/ h d)) 1.0)))
(*
w0
(sqrt
(fma (/ D_m d) (* -0.25 (* M_m (/ (* M_m (* D_m h)) (* d l)))) 1.0))))))M_m = fabs(M);
D_m = fabs(D);
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) <= 4e-169) {
tmp = w0 * fma((D_m * D_m), (((-0.125 * ((M_m * (M_m * h)) / l)) / d) / d), 1.0);
} else if ((M_m * D_m) <= 4e+150) {
tmp = w0 * sqrt(fma(-0.25, ((((M_m * D_m) * (M_m * D_m)) / (d * l)) * (h / d)), 1.0));
} else {
tmp = w0 * sqrt(fma((D_m / d), (-0.25 * (M_m * ((M_m * (D_m * h)) / (d * l)))), 1.0));
}
return tmp;
}
M_m = abs(M) D_m = abs(D) 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) <= 4e-169) tmp = Float64(w0 * fma(Float64(D_m * D_m), Float64(Float64(Float64(-0.125 * Float64(Float64(M_m * Float64(M_m * h)) / l)) / d) / d), 1.0)); elseif (Float64(M_m * D_m) <= 4e+150) tmp = Float64(w0 * sqrt(fma(-0.25, Float64(Float64(Float64(Float64(M_m * D_m) * Float64(M_m * D_m)) / Float64(d * l)) * Float64(h / d)), 1.0))); else tmp = Float64(w0 * sqrt(fma(Float64(D_m / d), Float64(-0.25 * Float64(M_m * Float64(Float64(M_m * Float64(D_m * h)) / Float64(d * l)))), 1.0))); end return tmp end
M_m = N[Abs[M], $MachinePrecision] D_m = N[Abs[D], $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], 4e-169], N[(w0 * N[(N[(D$95$m * D$95$m), $MachinePrecision] * N[(N[(N[(-0.125 * N[(N[(M$95$m * N[(M$95$m * h), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision] / d), $MachinePrecision] / d), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(M$95$m * D$95$m), $MachinePrecision], 4e+150], N[(w0 * N[Sqrt[N[(-0.25 * N[(N[(N[(N[(M$95$m * D$95$m), $MachinePrecision] * N[(M$95$m * D$95$m), $MachinePrecision]), $MachinePrecision] / N[(d * l), $MachinePrecision]), $MachinePrecision] * N[(h / d), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(w0 * N[Sqrt[N[(N[(D$95$m / d), $MachinePrecision] * N[(-0.25 * N[(M$95$m * N[(N[(M$95$m * N[(D$95$m * h), $MachinePrecision]), $MachinePrecision] / N[(d * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
M_m = \left|M\right|
\\
D_m = \left|D\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 4 \cdot 10^{-169}:\\
\;\;\;\;w0 \cdot \mathsf{fma}\left(D\_m \cdot D\_m, \frac{\frac{-0.125 \cdot \frac{M\_m \cdot \left(M\_m \cdot h\right)}{\ell}}{d}}{d}, 1\right)\\
\mathbf{elif}\;M\_m \cdot D\_m \leq 4 \cdot 10^{+150}:\\
\;\;\;\;w0 \cdot \sqrt{\mathsf{fma}\left(-0.25, \frac{\left(M\_m \cdot D\_m\right) \cdot \left(M\_m \cdot D\_m\right)}{d \cdot \ell} \cdot \frac{h}{d}, 1\right)}\\
\mathbf{else}:\\
\;\;\;\;w0 \cdot \sqrt{\mathsf{fma}\left(\frac{D\_m}{d}, -0.25 \cdot \left(M\_m \cdot \frac{M\_m \cdot \left(D\_m \cdot h\right)}{d \cdot \ell}\right), 1\right)}\\
\end{array}
\end{array}
if (*.f64 M D) < 4.00000000000000008e-169Initial program 81.5%
Taylor expanded in w0 around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
unpow2N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6458.8
Simplified58.8%
Taylor expanded in D around 0
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
Simplified49.9%
associate-/r*N/A
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
associate-*l*N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f6463.3
Applied egg-rr63.3%
if 4.00000000000000008e-169 < (*.f64 M D) < 3.99999999999999992e150Initial program 88.9%
Taylor expanded in w0 around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
unpow2N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6464.0
Simplified64.0%
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr63.6%
associate-*r*N/A
*-commutativeN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f6495.4
Applied egg-rr95.4%
if 3.99999999999999992e150 < (*.f64 M D) Initial program 70.1%
*-commutativeN/A
unpow2N/A
times-fracN/A
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr62.6%
associate-*r*N/A
associate-*l*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
frac-timesN/A
*-commutativeN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6466.9
Applied egg-rr66.9%
associate-/r*N/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f6470.6
Applied egg-rr70.6%
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr70.5%
Final simplification71.8%
M_m = (fabs.f64 M)
D_m = (fabs.f64 D)
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) 5e+53)
(*
w0
(sqrt
(fma
(/ (* M_m D_m) (* (* 2.0 d) l))
(/ (* (* M_m D_m) h) (- 0.0 (* 2.0 d)))
1.0)))
(*
w0
(sqrt
(- 1.0 (* (/ D_m d) (* (* M_m 0.25) (* M_m (* (/ D_m d) (/ h l))))))))))M_m = fabs(M);
D_m = fabs(D);
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) <= 5e+53) {
tmp = w0 * sqrt(fma(((M_m * D_m) / ((2.0 * d) * l)), (((M_m * D_m) * h) / (0.0 - (2.0 * d))), 1.0));
} else {
tmp = w0 * sqrt((1.0 - ((D_m / d) * ((M_m * 0.25) * (M_m * ((D_m / d) * (h / l)))))));
}
return tmp;
}
M_m = abs(M) D_m = abs(D) 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) <= 5e+53) tmp = Float64(w0 * sqrt(fma(Float64(Float64(M_m * D_m) / Float64(Float64(2.0 * d) * l)), Float64(Float64(Float64(M_m * D_m) * h) / Float64(0.0 - Float64(2.0 * d))), 1.0))); else tmp = Float64(w0 * sqrt(Float64(1.0 - Float64(Float64(D_m / d) * Float64(Float64(M_m * 0.25) * Float64(M_m * Float64(Float64(D_m / d) * Float64(h / l)))))))); end return tmp end
M_m = N[Abs[M], $MachinePrecision] D_m = N[Abs[D], $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], 5e+53], N[(w0 * N[Sqrt[N[(N[(N[(M$95$m * D$95$m), $MachinePrecision] / N[(N[(2.0 * d), $MachinePrecision] * l), $MachinePrecision]), $MachinePrecision] * N[(N[(N[(M$95$m * D$95$m), $MachinePrecision] * h), $MachinePrecision] / N[(0.0 - N[(2.0 * d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(w0 * N[Sqrt[N[(1.0 - N[(N[(D$95$m / d), $MachinePrecision] * N[(N[(M$95$m * 0.25), $MachinePrecision] * N[(M$95$m * N[(N[(D$95$m / d), $MachinePrecision] * N[(h / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
M_m = \left|M\right|
\\
D_m = \left|D\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 5 \cdot 10^{+53}:\\
\;\;\;\;w0 \cdot \sqrt{\mathsf{fma}\left(\frac{M\_m \cdot D\_m}{\left(2 \cdot d\right) \cdot \ell}, \frac{\left(M\_m \cdot D\_m\right) \cdot h}{0 - 2 \cdot d}, 1\right)}\\
\mathbf{else}:\\
\;\;\;\;w0 \cdot \sqrt{1 - \frac{D\_m}{d} \cdot \left(\left(M\_m \cdot 0.25\right) \cdot \left(M\_m \cdot \left(\frac{D\_m}{d} \cdot \frac{h}{\ell}\right)\right)\right)}\\
\end{array}
\end{array}
if (*.f64 M D) < 5.0000000000000004e53Initial program 82.8%
clear-numN/A
un-div-invN/A
unpow2N/A
div-invN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f6491.5
Applied egg-rr91.5%
sub-negN/A
+-commutativeN/A
distribute-rgt-neg-inN/A
accelerator-lowering-fma.f64N/A
Applied egg-rr87.5%
if 5.0000000000000004e53 < (*.f64 M D) Initial program 78.6%
*-commutativeN/A
unpow2N/A
times-fracN/A
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr62.1%
associate-*r*N/A
associate-*l*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
frac-timesN/A
*-commutativeN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6472.2
Applied egg-rr72.2%
*-commutativeN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f6472.0
Applied egg-rr72.0%
Final simplification85.0%
M_m = (fabs.f64 M)
D_m = (fabs.f64 D)
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 5e-165)
(*
w0
(sqrt
(fma
(/ (* M_m D_m) (* (* 2.0 d) l))
(/ (* (* M_m D_m) h) (- 0.0 (* 2.0 d)))
1.0)))
(*
w0
(sqrt
(- 1.0 (* (/ D_m d) (* (/ (* M_m (* h (/ D_m d))) l) (* M_m 0.25))))))))M_m = fabs(M);
D_m = fabs(D);
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 <= 5e-165) {
tmp = w0 * sqrt(fma(((M_m * D_m) / ((2.0 * d) * l)), (((M_m * D_m) * h) / (0.0 - (2.0 * d))), 1.0));
} else {
tmp = w0 * sqrt((1.0 - ((D_m / d) * (((M_m * (h * (D_m / d))) / l) * (M_m * 0.25)))));
}
return tmp;
}
M_m = abs(M) D_m = abs(D) w0, M_m, D_m, h, l, d = sort([w0, M_m, D_m, h, l, d]) function code(w0, M_m, D_m, h, l, d) tmp = 0.0 if (M_m <= 5e-165) tmp = Float64(w0 * sqrt(fma(Float64(Float64(M_m * D_m) / Float64(Float64(2.0 * d) * l)), Float64(Float64(Float64(M_m * D_m) * h) / Float64(0.0 - Float64(2.0 * d))), 1.0))); else tmp = Float64(w0 * sqrt(Float64(1.0 - Float64(Float64(D_m / d) * Float64(Float64(Float64(M_m * Float64(h * Float64(D_m / d))) / l) * Float64(M_m * 0.25)))))); end return tmp end
M_m = N[Abs[M], $MachinePrecision] D_m = N[Abs[D], $MachinePrecision] NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function. code[w0_, M$95$m_, D$95$m_, h_, l_, d_] := If[LessEqual[M$95$m, 5e-165], N[(w0 * N[Sqrt[N[(N[(N[(M$95$m * D$95$m), $MachinePrecision] / N[(N[(2.0 * d), $MachinePrecision] * l), $MachinePrecision]), $MachinePrecision] * N[(N[(N[(M$95$m * D$95$m), $MachinePrecision] * h), $MachinePrecision] / N[(0.0 - N[(2.0 * d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(w0 * N[Sqrt[N[(1.0 - N[(N[(D$95$m / d), $MachinePrecision] * N[(N[(N[(M$95$m * N[(h * N[(D$95$m / d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision] * N[(M$95$m * 0.25), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
M_m = \left|M\right|
\\
D_m = \left|D\right|
\\
[w0, M_m, D_m, h, l, d] = \mathsf{sort}([w0, M_m, D_m, h, l, d])\\
\\
\begin{array}{l}
\mathbf{if}\;M\_m \leq 5 \cdot 10^{-165}:\\
\;\;\;\;w0 \cdot \sqrt{\mathsf{fma}\left(\frac{M\_m \cdot D\_m}{\left(2 \cdot d\right) \cdot \ell}, \frac{\left(M\_m \cdot D\_m\right) \cdot h}{0 - 2 \cdot d}, 1\right)}\\
\mathbf{else}:\\
\;\;\;\;w0 \cdot \sqrt{1 - \frac{D\_m}{d} \cdot \left(\frac{M\_m \cdot \left(h \cdot \frac{D\_m}{d}\right)}{\ell} \cdot \left(M\_m \cdot 0.25\right)\right)}\\
\end{array}
\end{array}
if M < 4.99999999999999981e-165Initial program 84.0%
clear-numN/A
un-div-invN/A
unpow2N/A
div-invN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f6492.1
Applied egg-rr92.1%
sub-negN/A
+-commutativeN/A
distribute-rgt-neg-inN/A
accelerator-lowering-fma.f64N/A
Applied egg-rr88.2%
if 4.99999999999999981e-165 < M Initial program 78.2%
*-commutativeN/A
unpow2N/A
times-fracN/A
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr67.7%
associate-*r*N/A
associate-*l*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
frac-timesN/A
*-commutativeN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6485.4
Applied egg-rr85.4%
associate-/r*N/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f6489.9
Applied egg-rr89.9%
Final simplification88.7%
M_m = (fabs.f64 M) D_m = (fabs.f64 D) 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 2e+44) (* w0 (fma (* D_m D_m) (* (/ -0.125 d) (/ (* M_m (* M_m h)) (* d l))) 1.0)) (fma D_m (* w0 (* (* M_m (* h (/ M_m (* l (* d d))))) (* D_m -0.125))) w0)))
M_m = fabs(M);
D_m = fabs(D);
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 <= 2e+44) {
tmp = w0 * fma((D_m * D_m), ((-0.125 / d) * ((M_m * (M_m * h)) / (d * l))), 1.0);
} else {
tmp = fma(D_m, (w0 * ((M_m * (h * (M_m / (l * (d * d))))) * (D_m * -0.125))), w0);
}
return tmp;
}
M_m = abs(M) D_m = abs(D) 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 <= 2e+44) tmp = Float64(w0 * fma(Float64(D_m * D_m), Float64(Float64(-0.125 / d) * Float64(Float64(M_m * Float64(M_m * h)) / Float64(d * l))), 1.0)); else tmp = fma(D_m, Float64(w0 * Float64(Float64(M_m * Float64(h * Float64(M_m / Float64(l * Float64(d * d))))) * Float64(D_m * -0.125))), w0); end return tmp end
M_m = N[Abs[M], $MachinePrecision] D_m = N[Abs[D], $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, 2e+44], N[(w0 * N[(N[(D$95$m * D$95$m), $MachinePrecision] * N[(N[(-0.125 / d), $MachinePrecision] * N[(N[(M$95$m * N[(M$95$m * h), $MachinePrecision]), $MachinePrecision] / N[(d * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], N[(D$95$m * N[(w0 * N[(N[(M$95$m * N[(h * N[(M$95$m / N[(l * N[(d * d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(D$95$m * -0.125), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + w0), $MachinePrecision]]
\begin{array}{l}
M_m = \left|M\right|
\\
D_m = \left|D\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 2 \cdot 10^{+44}:\\
\;\;\;\;w0 \cdot \mathsf{fma}\left(D\_m \cdot D\_m, \frac{-0.125}{d} \cdot \frac{M\_m \cdot \left(M\_m \cdot h\right)}{d \cdot \ell}, 1\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(D\_m, w0 \cdot \left(\left(M\_m \cdot \left(h \cdot \frac{M\_m}{\ell \cdot \left(d \cdot d\right)}\right)\right) \cdot \left(D\_m \cdot -0.125\right)\right), w0\right)\\
\end{array}
\end{array}
if D < 2.0000000000000002e44Initial program 83.0%
Taylor expanded in w0 around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
unpow2N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6462.8
Simplified62.8%
Taylor expanded in D around 0
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
Simplified52.5%
associate-*l*N/A
*-commutativeN/A
associate-*r*N/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6466.2
Applied egg-rr66.2%
if 2.0000000000000002e44 < D Initial program 78.7%
Taylor expanded in w0 around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
unpow2N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6439.2
Simplified39.2%
Taylor expanded in D around 0
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
Simplified32.9%
distribute-rgt-inN/A
associate-*l*N/A
associate-*l*N/A
*-lft-identityN/A
accelerator-lowering-fma.f64N/A
Applied egg-rr57.4%
associate-*r*N/A
associate-*l*N/A
associate-/l*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
associate-/l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6468.1
Applied egg-rr68.1%
Final simplification66.6%
M_m = (fabs.f64 M) D_m = (fabs.f64 D) 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.2e+59) w0 (fma D_m (* w0 (* (* M_m (* h (/ M_m (* l (* d d))))) (* D_m -0.125))) w0)))
M_m = fabs(M);
D_m = fabs(D);
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.2e+59) {
tmp = w0;
} else {
tmp = fma(D_m, (w0 * ((M_m * (h * (M_m / (l * (d * d))))) * (D_m * -0.125))), w0);
}
return tmp;
}
M_m = abs(M) D_m = abs(D) 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.2e+59) tmp = w0; else tmp = fma(D_m, Float64(w0 * Float64(Float64(M_m * Float64(h * Float64(M_m / Float64(l * Float64(d * d))))) * Float64(D_m * -0.125))), w0); end return tmp end
M_m = N[Abs[M], $MachinePrecision] D_m = N[Abs[D], $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.2e+59], w0, N[(D$95$m * N[(w0 * N[(N[(M$95$m * N[(h * N[(M$95$m / N[(l * N[(d * d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(D$95$m * -0.125), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + w0), $MachinePrecision]]
\begin{array}{l}
M_m = \left|M\right|
\\
D_m = \left|D\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.2 \cdot 10^{+59}:\\
\;\;\;\;w0\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(D\_m, w0 \cdot \left(\left(M\_m \cdot \left(h \cdot \frac{M\_m}{\ell \cdot \left(d \cdot d\right)}\right)\right) \cdot \left(D\_m \cdot -0.125\right)\right), w0\right)\\
\end{array}
\end{array}
if D < 5.19999999999999999e59Initial program 83.1%
Taylor expanded in M around 0
Simplified75.8%
if 5.19999999999999999e59 < D Initial program 77.8%
Taylor expanded in w0 around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
unpow2N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6438.8
Simplified38.8%
Taylor expanded in D around 0
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
Simplified32.2%
distribute-rgt-inN/A
associate-*l*N/A
associate-*l*N/A
*-lft-identityN/A
accelerator-lowering-fma.f64N/A
Applied egg-rr57.7%
associate-*r*N/A
associate-*l*N/A
associate-/l*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
associate-/l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6468.5
Applied egg-rr68.5%
Final simplification74.5%
M_m = (fabs.f64 M) D_m = (fabs.f64 D) 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 7.3e+74) w0 (* w0 (/ (* (* D_m D_m) (* -0.125 (* h (* M_m M_m)))) (* d (* d l))))))
M_m = fabs(M);
D_m = fabs(D);
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 <= 7.3e+74) {
tmp = w0;
} else {
tmp = w0 * (((D_m * D_m) * (-0.125 * (h * (M_m * M_m)))) / (d * (d * l)));
}
return tmp;
}
M_m = abs(m)
D_m = abs(d)
NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function.
real(8) function code(w0, m_m, d_m, h, l, d)
real(8), intent (in) :: w0
real(8), intent (in) :: m_m
real(8), intent (in) :: d_m
real(8), intent (in) :: h
real(8), intent (in) :: l
real(8), intent (in) :: d
real(8) :: tmp
if (m_m <= 7.3d+74) then
tmp = w0
else
tmp = w0 * (((d_m * d_m) * ((-0.125d0) * (h * (m_m * m_m)))) / (d * (d * l)))
end if
code = tmp
end function
M_m = Math.abs(M);
D_m = Math.abs(D);
assert w0 < M_m && M_m < D_m && D_m < h && h < l && l < d;
public static double code(double w0, double M_m, double D_m, double h, double l, double d) {
double tmp;
if (M_m <= 7.3e+74) {
tmp = w0;
} else {
tmp = w0 * (((D_m * D_m) * (-0.125 * (h * (M_m * M_m)))) / (d * (d * l)));
}
return tmp;
}
M_m = math.fabs(M) D_m = math.fabs(D) [w0, M_m, D_m, h, l, d] = sort([w0, M_m, D_m, h, l, d]) def code(w0, M_m, D_m, h, l, d): tmp = 0 if M_m <= 7.3e+74: tmp = w0 else: tmp = w0 * (((D_m * D_m) * (-0.125 * (h * (M_m * M_m)))) / (d * (d * l))) return tmp
M_m = abs(M) D_m = abs(D) w0, M_m, D_m, h, l, d = sort([w0, M_m, D_m, h, l, d]) function code(w0, M_m, D_m, h, l, d) tmp = 0.0 if (M_m <= 7.3e+74) tmp = w0; else tmp = Float64(w0 * Float64(Float64(Float64(D_m * D_m) * Float64(-0.125 * Float64(h * Float64(M_m * M_m)))) / Float64(d * Float64(d * l)))); end return tmp end
M_m = abs(M);
D_m = abs(D);
w0, M_m, D_m, h, l, d = num2cell(sort([w0, M_m, D_m, h, l, d])){:}
function tmp_2 = code(w0, M_m, D_m, h, l, d)
tmp = 0.0;
if (M_m <= 7.3e+74)
tmp = w0;
else
tmp = w0 * (((D_m * D_m) * (-0.125 * (h * (M_m * M_m)))) / (d * (d * l)));
end
tmp_2 = tmp;
end
M_m = N[Abs[M], $MachinePrecision] D_m = N[Abs[D], $MachinePrecision] NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function. code[w0_, M$95$m_, D$95$m_, h_, l_, d_] := If[LessEqual[M$95$m, 7.3e+74], w0, N[(w0 * N[(N[(N[(D$95$m * D$95$m), $MachinePrecision] * N[(-0.125 * N[(h * N[(M$95$m * M$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(d * N[(d * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
M_m = \left|M\right|
\\
D_m = \left|D\right|
\\
[w0, M_m, D_m, h, l, d] = \mathsf{sort}([w0, M_m, D_m, h, l, d])\\
\\
\begin{array}{l}
\mathbf{if}\;M\_m \leq 7.3 \cdot 10^{+74}:\\
\;\;\;\;w0\\
\mathbf{else}:\\
\;\;\;\;w0 \cdot \frac{\left(D\_m \cdot D\_m\right) \cdot \left(-0.125 \cdot \left(h \cdot \left(M\_m \cdot M\_m\right)\right)\right)}{d \cdot \left(d \cdot \ell\right)}\\
\end{array}
\end{array}
if M < 7.3000000000000005e74Initial program 84.7%
Taylor expanded in M around 0
Simplified72.9%
if 7.3000000000000005e74 < M Initial program 64.2%
Taylor expanded in w0 around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
unpow2N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6438.7
Simplified38.7%
Taylor expanded in D around 0
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
Simplified16.8%
Taylor expanded in D around inf
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6413.7
Simplified13.7%
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6416.8
Applied egg-rr16.8%
Final simplification65.9%
M_m = (fabs.f64 M) D_m = (fabs.f64 D) 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 5e+74) w0 (* w0 (* (* (* M_m M_m) (* D_m (* h -0.125))) (/ D_m (* l (* d d)))))))
M_m = fabs(M);
D_m = fabs(D);
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 <= 5e+74) {
tmp = w0;
} else {
tmp = w0 * (((M_m * M_m) * (D_m * (h * -0.125))) * (D_m / (l * (d * d))));
}
return tmp;
}
M_m = abs(m)
D_m = abs(d)
NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function.
real(8) function code(w0, m_m, d_m, h, l, d)
real(8), intent (in) :: w0
real(8), intent (in) :: m_m
real(8), intent (in) :: d_m
real(8), intent (in) :: h
real(8), intent (in) :: l
real(8), intent (in) :: d
real(8) :: tmp
if (m_m <= 5d+74) then
tmp = w0
else
tmp = w0 * (((m_m * m_m) * (d_m * (h * (-0.125d0)))) * (d_m / (l * (d * d))))
end if
code = tmp
end function
M_m = Math.abs(M);
D_m = Math.abs(D);
assert w0 < M_m && M_m < D_m && D_m < h && h < l && l < d;
public static double code(double w0, double M_m, double D_m, double h, double l, double d) {
double tmp;
if (M_m <= 5e+74) {
tmp = w0;
} else {
tmp = w0 * (((M_m * M_m) * (D_m * (h * -0.125))) * (D_m / (l * (d * d))));
}
return tmp;
}
M_m = math.fabs(M) D_m = math.fabs(D) [w0, M_m, D_m, h, l, d] = sort([w0, M_m, D_m, h, l, d]) def code(w0, M_m, D_m, h, l, d): tmp = 0 if M_m <= 5e+74: tmp = w0 else: tmp = w0 * (((M_m * M_m) * (D_m * (h * -0.125))) * (D_m / (l * (d * d)))) return tmp
M_m = abs(M) D_m = abs(D) w0, M_m, D_m, h, l, d = sort([w0, M_m, D_m, h, l, d]) function code(w0, M_m, D_m, h, l, d) tmp = 0.0 if (M_m <= 5e+74) tmp = w0; else tmp = Float64(w0 * Float64(Float64(Float64(M_m * M_m) * Float64(D_m * Float64(h * -0.125))) * Float64(D_m / Float64(l * Float64(d * d))))); end return tmp end
M_m = abs(M);
D_m = abs(D);
w0, M_m, D_m, h, l, d = num2cell(sort([w0, M_m, D_m, h, l, d])){:}
function tmp_2 = code(w0, M_m, D_m, h, l, d)
tmp = 0.0;
if (M_m <= 5e+74)
tmp = w0;
else
tmp = w0 * (((M_m * M_m) * (D_m * (h * -0.125))) * (D_m / (l * (d * d))));
end
tmp_2 = tmp;
end
M_m = N[Abs[M], $MachinePrecision] D_m = N[Abs[D], $MachinePrecision] NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function. code[w0_, M$95$m_, D$95$m_, h_, l_, d_] := If[LessEqual[M$95$m, 5e+74], w0, N[(w0 * N[(N[(N[(M$95$m * M$95$m), $MachinePrecision] * N[(D$95$m * N[(h * -0.125), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(D$95$m / N[(l * N[(d * d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
M_m = \left|M\right|
\\
D_m = \left|D\right|
\\
[w0, M_m, D_m, h, l, d] = \mathsf{sort}([w0, M_m, D_m, h, l, d])\\
\\
\begin{array}{l}
\mathbf{if}\;M\_m \leq 5 \cdot 10^{+74}:\\
\;\;\;\;w0\\
\mathbf{else}:\\
\;\;\;\;w0 \cdot \left(\left(\left(M\_m \cdot M\_m\right) \cdot \left(D\_m \cdot \left(h \cdot -0.125\right)\right)\right) \cdot \frac{D\_m}{\ell \cdot \left(d \cdot d\right)}\right)\\
\end{array}
\end{array}
if M < 4.99999999999999963e74Initial program 84.7%
Taylor expanded in M around 0
Simplified72.9%
if 4.99999999999999963e74 < M Initial program 64.2%
Taylor expanded in w0 around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
--lowering--.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
unpow2N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6438.7
Simplified38.7%
Taylor expanded in D around 0
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
Simplified16.8%
Taylor expanded in D around inf
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6413.7
Simplified13.7%
associate-*r*N/A
*-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6417.1
Applied egg-rr17.1%
Final simplification65.9%
M_m = (fabs.f64 M) D_m = (fabs.f64 D) NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function. (FPCore (w0 M_m D_m h l d) :precision binary64 w0)
M_m = fabs(M);
D_m = fabs(D);
assert(w0 < M_m && M_m < D_m && D_m < h && h < l && l < d);
double code(double w0, double M_m, double D_m, double h, double l, double d) {
return w0;
}
M_m = abs(m)
D_m = abs(d)
NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function.
real(8) function code(w0, m_m, d_m, h, l, d)
real(8), intent (in) :: w0
real(8), intent (in) :: m_m
real(8), intent (in) :: d_m
real(8), intent (in) :: h
real(8), intent (in) :: l
real(8), intent (in) :: d
code = w0
end function
M_m = Math.abs(M);
D_m = Math.abs(D);
assert w0 < M_m && M_m < D_m && D_m < h && h < l && l < d;
public static double code(double w0, double M_m, double D_m, double h, double l, double d) {
return w0;
}
M_m = math.fabs(M) D_m = math.fabs(D) [w0, M_m, D_m, h, l, d] = sort([w0, M_m, D_m, h, l, d]) def code(w0, M_m, D_m, h, l, d): return w0
M_m = abs(M) D_m = abs(D) w0, M_m, D_m, h, l, d = sort([w0, M_m, D_m, h, l, d]) function code(w0, M_m, D_m, h, l, d) return w0 end
M_m = abs(M);
D_m = abs(D);
w0, M_m, D_m, h, l, d = num2cell(sort([w0, M_m, D_m, h, l, d])){:}
function tmp = code(w0, M_m, D_m, h, l, d)
tmp = w0;
end
M_m = N[Abs[M], $MachinePrecision] D_m = N[Abs[D], $MachinePrecision] NOTE: w0, M_m, D_m, h, l, and d should be sorted in increasing order before calling this function. code[w0_, M$95$m_, D$95$m_, h_, l_, d_] := w0
\begin{array}{l}
M_m = \left|M\right|
\\
D_m = \left|D\right|
\\
[w0, M_m, D_m, h, l, d] = \mathsf{sort}([w0, M_m, D_m, h, l, d])\\
\\
w0
\end{array}
Initial program 82.1%
Taylor expanded in M around 0
Simplified70.7%
herbie shell --seed 2024197
(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))))))