
(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 18 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)
NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function.
(FPCore (w0 M D_m h l d_m)
:precision binary64
(let* ((t_0 (- 1.0 (* (pow (/ (* M D_m) (* 2.0 d_m)) 2.0) (/ h l)))))
(if (<= t_0 5e+278)
(* w0 (sqrt t_0))
(*
w0
(hypot
1.0
(*
(pow d_m -0.5)
(pow (/ l (/ (* M (/ (* M D_m) d_m)) (/ -4.0 (* D_m h)))) -0.5)))))))D_m = fabs(D);
d_m = fabs(d);
assert(w0 < M && M < D_m && D_m < h && h < l && l < d_m);
double code(double w0, double M, double D_m, double h, double l, double d_m) {
double t_0 = 1.0 - (pow(((M * D_m) / (2.0 * d_m)), 2.0) * (h / l));
double tmp;
if (t_0 <= 5e+278) {
tmp = w0 * sqrt(t_0);
} else {
tmp = w0 * hypot(1.0, (pow(d_m, -0.5) * pow((l / ((M * ((M * D_m) / d_m)) / (-4.0 / (D_m * h)))), -0.5)));
}
return tmp;
}
D_m = Math.abs(D);
d_m = Math.abs(d);
assert w0 < M && M < D_m && D_m < h && h < l && l < d_m;
public static double code(double w0, double M, double D_m, double h, double l, double d_m) {
double t_0 = 1.0 - (Math.pow(((M * D_m) / (2.0 * d_m)), 2.0) * (h / l));
double tmp;
if (t_0 <= 5e+278) {
tmp = w0 * Math.sqrt(t_0);
} else {
tmp = w0 * Math.hypot(1.0, (Math.pow(d_m, -0.5) * Math.pow((l / ((M * ((M * D_m) / d_m)) / (-4.0 / (D_m * h)))), -0.5)));
}
return tmp;
}
D_m = math.fabs(D) d_m = math.fabs(d) [w0, M, D_m, h, l, d_m] = sort([w0, M, D_m, h, l, d_m]) def code(w0, M, D_m, h, l, d_m): t_0 = 1.0 - (math.pow(((M * D_m) / (2.0 * d_m)), 2.0) * (h / l)) tmp = 0 if t_0 <= 5e+278: tmp = w0 * math.sqrt(t_0) else: tmp = w0 * math.hypot(1.0, (math.pow(d_m, -0.5) * math.pow((l / ((M * ((M * D_m) / d_m)) / (-4.0 / (D_m * h)))), -0.5))) return tmp
D_m = abs(D) d_m = abs(d) w0, M, D_m, h, l, d_m = sort([w0, M, D_m, h, l, d_m]) function code(w0, M, D_m, h, l, d_m) t_0 = Float64(1.0 - Float64((Float64(Float64(M * D_m) / Float64(2.0 * d_m)) ^ 2.0) * Float64(h / l))) tmp = 0.0 if (t_0 <= 5e+278) tmp = Float64(w0 * sqrt(t_0)); else tmp = Float64(w0 * hypot(1.0, Float64((d_m ^ -0.5) * (Float64(l / Float64(Float64(M * Float64(Float64(M * D_m) / d_m)) / Float64(-4.0 / Float64(D_m * h)))) ^ -0.5)))); end return tmp end
D_m = abs(D);
d_m = abs(d);
w0, M, D_m, h, l, d_m = num2cell(sort([w0, M, D_m, h, l, d_m])){:}
function tmp_2 = code(w0, M, D_m, h, l, d_m)
t_0 = 1.0 - ((((M * D_m) / (2.0 * d_m)) ^ 2.0) * (h / l));
tmp = 0.0;
if (t_0 <= 5e+278)
tmp = w0 * sqrt(t_0);
else
tmp = w0 * hypot(1.0, ((d_m ^ -0.5) * ((l / ((M * ((M * D_m) / d_m)) / (-4.0 / (D_m * h)))) ^ -0.5)));
end
tmp_2 = tmp;
end
D_m = N[Abs[D], $MachinePrecision]
d_m = N[Abs[d], $MachinePrecision]
NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function.
code[w0_, M_, D$95$m_, h_, l_, d$95$m_] := Block[{t$95$0 = N[(1.0 - N[(N[Power[N[(N[(M * D$95$m), $MachinePrecision] / N[(2.0 * d$95$m), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] * N[(h / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, 5e+278], N[(w0 * N[Sqrt[t$95$0], $MachinePrecision]), $MachinePrecision], N[(w0 * N[Sqrt[1.0 ^ 2 + N[(N[Power[d$95$m, -0.5], $MachinePrecision] * N[Power[N[(l / N[(N[(M * N[(N[(M * D$95$m), $MachinePrecision] / d$95$m), $MachinePrecision]), $MachinePrecision] / N[(-4.0 / N[(D$95$m * h), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], -0.5], $MachinePrecision]), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
D_m = \left|D\right|
\\
d_m = \left|d\right|
\\
[w0, M, D_m, h, l, d_m] = \mathsf{sort}([w0, M, D_m, h, l, d_m])\\
\\
\begin{array}{l}
t_0 := 1 - {\left(\frac{M \cdot D\_m}{2 \cdot d\_m}\right)}^{2} \cdot \frac{h}{\ell}\\
\mathbf{if}\;t\_0 \leq 5 \cdot 10^{+278}:\\
\;\;\;\;w0 \cdot \sqrt{t\_0}\\
\mathbf{else}:\\
\;\;\;\;w0 \cdot \mathsf{hypot}\left(1, {d\_m}^{-0.5} \cdot {\left(\frac{\ell}{\frac{M \cdot \frac{M \cdot D\_m}{d\_m}}{\frac{-4}{D\_m \cdot h}}}\right)}^{-0.5}\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))) < 5.00000000000000029e278Initial program 99.9%
if 5.00000000000000029e278 < (-.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 46.4%
Simplified66.0%
associate-/l/N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f6464.3%
Applied egg-rr64.3%
frac-timesN/A
*-commutativeN/A
associate-*l*N/A
clear-numN/A
associate-/r/N/A
clear-numN/A
clear-numN/A
inv-powN/A
sqr-powN/A
hypot-1-defN/A
hypot-lowering-hypot.f64N/A
Applied egg-rr64.0%
frac-timesN/A
associate-/l*N/A
unpow-prod-downN/A
*-lowering-*.f64N/A
pow-lowering-pow.f64N/A
pow-lowering-pow.f64N/A
Applied egg-rr35.4%
Final simplification79.0%
D_m = (fabs.f64 D)
d_m = (fabs.f64 d)
NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function.
(FPCore (w0 M D_m h l d_m)
:precision binary64
(let* ((t_0 (- 1.0 (* (pow (/ (* M D_m) (* 2.0 d_m)) 2.0) (/ h l)))))
(if (<= t_0 2e+258)
(* w0 (sqrt t_0))
(*
w0
(sqrt
(+
1.0
(/ (/ (* (* h (* M D_m)) (/ (* M D_m) (* d_m -4.0))) d_m) l)))))))D_m = fabs(D);
d_m = fabs(d);
assert(w0 < M && M < D_m && D_m < h && h < l && l < d_m);
double code(double w0, double M, double D_m, double h, double l, double d_m) {
double t_0 = 1.0 - (pow(((M * D_m) / (2.0 * d_m)), 2.0) * (h / l));
double tmp;
if (t_0 <= 2e+258) {
tmp = w0 * sqrt(t_0);
} else {
tmp = w0 * sqrt((1.0 + ((((h * (M * D_m)) * ((M * D_m) / (d_m * -4.0))) / d_m) / l)));
}
return tmp;
}
D_m = abs(d)
d_m = abs(d)
NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function.
real(8) function code(w0, m, d_m, h, l, d_m_1)
real(8), intent (in) :: w0
real(8), intent (in) :: 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) :: t_0
real(8) :: tmp
t_0 = 1.0d0 - ((((m * d_m) / (2.0d0 * d_m_1)) ** 2.0d0) * (h / l))
if (t_0 <= 2d+258) then
tmp = w0 * sqrt(t_0)
else
tmp = w0 * sqrt((1.0d0 + ((((h * (m * d_m)) * ((m * d_m) / (d_m_1 * (-4.0d0)))) / d_m_1) / l)))
end if
code = tmp
end function
D_m = Math.abs(D);
d_m = Math.abs(d);
assert w0 < M && M < D_m && D_m < h && h < l && l < d_m;
public static double code(double w0, double M, double D_m, double h, double l, double d_m) {
double t_0 = 1.0 - (Math.pow(((M * D_m) / (2.0 * d_m)), 2.0) * (h / l));
double tmp;
if (t_0 <= 2e+258) {
tmp = w0 * Math.sqrt(t_0);
} else {
tmp = w0 * Math.sqrt((1.0 + ((((h * (M * D_m)) * ((M * D_m) / (d_m * -4.0))) / d_m) / l)));
}
return tmp;
}
D_m = math.fabs(D) d_m = math.fabs(d) [w0, M, D_m, h, l, d_m] = sort([w0, M, D_m, h, l, d_m]) def code(w0, M, D_m, h, l, d_m): t_0 = 1.0 - (math.pow(((M * D_m) / (2.0 * d_m)), 2.0) * (h / l)) tmp = 0 if t_0 <= 2e+258: tmp = w0 * math.sqrt(t_0) else: tmp = w0 * math.sqrt((1.0 + ((((h * (M * D_m)) * ((M * D_m) / (d_m * -4.0))) / d_m) / l))) return tmp
D_m = abs(D) d_m = abs(d) w0, M, D_m, h, l, d_m = sort([w0, M, D_m, h, l, d_m]) function code(w0, M, D_m, h, l, d_m) t_0 = Float64(1.0 - Float64((Float64(Float64(M * D_m) / Float64(2.0 * d_m)) ^ 2.0) * Float64(h / l))) tmp = 0.0 if (t_0 <= 2e+258) tmp = Float64(w0 * sqrt(t_0)); else tmp = Float64(w0 * sqrt(Float64(1.0 + Float64(Float64(Float64(Float64(h * Float64(M * D_m)) * Float64(Float64(M * D_m) / Float64(d_m * -4.0))) / d_m) / l)))); end return tmp end
D_m = abs(D);
d_m = abs(d);
w0, M, D_m, h, l, d_m = num2cell(sort([w0, M, D_m, h, l, d_m])){:}
function tmp_2 = code(w0, M, D_m, h, l, d_m)
t_0 = 1.0 - ((((M * D_m) / (2.0 * d_m)) ^ 2.0) * (h / l));
tmp = 0.0;
if (t_0 <= 2e+258)
tmp = w0 * sqrt(t_0);
else
tmp = w0 * sqrt((1.0 + ((((h * (M * D_m)) * ((M * D_m) / (d_m * -4.0))) / d_m) / l)));
end
tmp_2 = tmp;
end
D_m = N[Abs[D], $MachinePrecision]
d_m = N[Abs[d], $MachinePrecision]
NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function.
code[w0_, M_, D$95$m_, h_, l_, d$95$m_] := Block[{t$95$0 = N[(1.0 - N[(N[Power[N[(N[(M * D$95$m), $MachinePrecision] / N[(2.0 * d$95$m), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] * N[(h / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, 2e+258], N[(w0 * N[Sqrt[t$95$0], $MachinePrecision]), $MachinePrecision], N[(w0 * N[Sqrt[N[(1.0 + N[(N[(N[(N[(h * N[(M * D$95$m), $MachinePrecision]), $MachinePrecision] * N[(N[(M * D$95$m), $MachinePrecision] / N[(d$95$m * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / d$95$m), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
D_m = \left|D\right|
\\
d_m = \left|d\right|
\\
[w0, M, D_m, h, l, d_m] = \mathsf{sort}([w0, M, D_m, h, l, d_m])\\
\\
\begin{array}{l}
t_0 := 1 - {\left(\frac{M \cdot D\_m}{2 \cdot d\_m}\right)}^{2} \cdot \frac{h}{\ell}\\
\mathbf{if}\;t\_0 \leq 2 \cdot 10^{+258}:\\
\;\;\;\;w0 \cdot \sqrt{t\_0}\\
\mathbf{else}:\\
\;\;\;\;w0 \cdot \sqrt{1 + \frac{\frac{\left(h \cdot \left(M \cdot D\_m\right)\right) \cdot \frac{M \cdot D\_m}{d\_m \cdot -4}}{d\_m}}{\ell}}\\
\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))) < 2.00000000000000011e258Initial program 99.9%
if 2.00000000000000011e258 < (-.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 47.6%
Simplified65.7%
associate-*r*N/A
associate-/l*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6469.9%
Applied egg-rr69.9%
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6472.2%
Applied egg-rr72.2%
Final simplification90.7%
D_m = (fabs.f64 D)
d_m = (fabs.f64 d)
NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function.
(FPCore (w0 M D_m h l d_m)
:precision binary64
(if (<= l -4e-63)
(*
w0
(sqrt
(+ 1.0 (* (/ (* h (/ (/ M (/ d_m (* M D_m))) -4.0)) d_m) (/ D_m l)))))
(*
w0
(sqrt
(+ 1.0 (/ (/ (* (* h (* M D_m)) (/ (* M D_m) (* d_m -4.0))) d_m) l))))))D_m = fabs(D);
d_m = fabs(d);
assert(w0 < M && M < D_m && D_m < h && h < l && l < d_m);
double code(double w0, double M, double D_m, double h, double l, double d_m) {
double tmp;
if (l <= -4e-63) {
tmp = w0 * sqrt((1.0 + (((h * ((M / (d_m / (M * D_m))) / -4.0)) / d_m) * (D_m / l))));
} else {
tmp = w0 * sqrt((1.0 + ((((h * (M * D_m)) * ((M * D_m) / (d_m * -4.0))) / d_m) / l)));
}
return tmp;
}
D_m = abs(d)
d_m = abs(d)
NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function.
real(8) function code(w0, m, d_m, h, l, d_m_1)
real(8), intent (in) :: w0
real(8), intent (in) :: 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 (l <= (-4d-63)) then
tmp = w0 * sqrt((1.0d0 + (((h * ((m / (d_m_1 / (m * d_m))) / (-4.0d0))) / d_m_1) * (d_m / l))))
else
tmp = w0 * sqrt((1.0d0 + ((((h * (m * d_m)) * ((m * d_m) / (d_m_1 * (-4.0d0)))) / d_m_1) / l)))
end if
code = tmp
end function
D_m = Math.abs(D);
d_m = Math.abs(d);
assert w0 < M && M < D_m && D_m < h && h < l && l < d_m;
public static double code(double w0, double M, double D_m, double h, double l, double d_m) {
double tmp;
if (l <= -4e-63) {
tmp = w0 * Math.sqrt((1.0 + (((h * ((M / (d_m / (M * D_m))) / -4.0)) / d_m) * (D_m / l))));
} else {
tmp = w0 * Math.sqrt((1.0 + ((((h * (M * D_m)) * ((M * D_m) / (d_m * -4.0))) / d_m) / l)));
}
return tmp;
}
D_m = math.fabs(D) d_m = math.fabs(d) [w0, M, D_m, h, l, d_m] = sort([w0, M, D_m, h, l, d_m]) def code(w0, M, D_m, h, l, d_m): tmp = 0 if l <= -4e-63: tmp = w0 * math.sqrt((1.0 + (((h * ((M / (d_m / (M * D_m))) / -4.0)) / d_m) * (D_m / l)))) else: tmp = w0 * math.sqrt((1.0 + ((((h * (M * D_m)) * ((M * D_m) / (d_m * -4.0))) / d_m) / l))) return tmp
D_m = abs(D) d_m = abs(d) w0, M, D_m, h, l, d_m = sort([w0, M, D_m, h, l, d_m]) function code(w0, M, D_m, h, l, d_m) tmp = 0.0 if (l <= -4e-63) tmp = Float64(w0 * sqrt(Float64(1.0 + Float64(Float64(Float64(h * Float64(Float64(M / Float64(d_m / Float64(M * D_m))) / -4.0)) / d_m) * Float64(D_m / l))))); else tmp = Float64(w0 * sqrt(Float64(1.0 + Float64(Float64(Float64(Float64(h * Float64(M * D_m)) * Float64(Float64(M * D_m) / Float64(d_m * -4.0))) / d_m) / l)))); end return tmp end
D_m = abs(D);
d_m = abs(d);
w0, M, D_m, h, l, d_m = num2cell(sort([w0, M, D_m, h, l, d_m])){:}
function tmp_2 = code(w0, M, D_m, h, l, d_m)
tmp = 0.0;
if (l <= -4e-63)
tmp = w0 * sqrt((1.0 + (((h * ((M / (d_m / (M * D_m))) / -4.0)) / d_m) * (D_m / l))));
else
tmp = w0 * sqrt((1.0 + ((((h * (M * D_m)) * ((M * D_m) / (d_m * -4.0))) / d_m) / l)));
end
tmp_2 = tmp;
end
D_m = N[Abs[D], $MachinePrecision] d_m = N[Abs[d], $MachinePrecision] NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function. code[w0_, M_, D$95$m_, h_, l_, d$95$m_] := If[LessEqual[l, -4e-63], N[(w0 * N[Sqrt[N[(1.0 + N[(N[(N[(h * N[(N[(M / N[(d$95$m / N[(M * D$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / -4.0), $MachinePrecision]), $MachinePrecision] / d$95$m), $MachinePrecision] * N[(D$95$m / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(w0 * N[Sqrt[N[(1.0 + N[(N[(N[(N[(h * N[(M * D$95$m), $MachinePrecision]), $MachinePrecision] * N[(N[(M * D$95$m), $MachinePrecision] / N[(d$95$m * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / d$95$m), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
D_m = \left|D\right|
\\
d_m = \left|d\right|
\\
[w0, M, D_m, h, l, d_m] = \mathsf{sort}([w0, M, D_m, h, l, d_m])\\
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq -4 \cdot 10^{-63}:\\
\;\;\;\;w0 \cdot \sqrt{1 + \frac{h \cdot \frac{\frac{M}{\frac{d\_m}{M \cdot D\_m}}}{-4}}{d\_m} \cdot \frac{D\_m}{\ell}}\\
\mathbf{else}:\\
\;\;\;\;w0 \cdot \sqrt{1 + \frac{\frac{\left(h \cdot \left(M \cdot D\_m\right)\right) \cdot \frac{M \cdot D\_m}{d\_m \cdot -4}}{d\_m}}{\ell}}\\
\end{array}
\end{array}
if l < -4.00000000000000027e-63Initial program 89.5%
Simplified87.1%
associate-/l/N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f6486.9%
Applied egg-rr86.9%
if -4.00000000000000027e-63 < l Initial program 79.4%
Simplified83.8%
associate-*r*N/A
associate-/l*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6485.9%
Applied egg-rr85.9%
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6489.1%
Applied egg-rr89.1%
Final simplification88.4%
D_m = (fabs.f64 D)
d_m = (fabs.f64 d)
NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function.
(FPCore (w0 M D_m h l d_m)
:precision binary64
(if (<= l -3.6e-90)
(*
w0
(sqrt
(+ 1.0 (* (/ (* h (/ (/ M (/ d_m (* M D_m))) -4.0)) d_m) (/ D_m l)))))
(*
w0
(sqrt
(+ 1.0 (/ (/ (* h (* D_m (/ (* M (/ (* M D_m) d_m)) -4.0))) d_m) l))))))D_m = fabs(D);
d_m = fabs(d);
assert(w0 < M && M < D_m && D_m < h && h < l && l < d_m);
double code(double w0, double M, double D_m, double h, double l, double d_m) {
double tmp;
if (l <= -3.6e-90) {
tmp = w0 * sqrt((1.0 + (((h * ((M / (d_m / (M * D_m))) / -4.0)) / d_m) * (D_m / l))));
} else {
tmp = w0 * sqrt((1.0 + (((h * (D_m * ((M * ((M * D_m) / d_m)) / -4.0))) / d_m) / l)));
}
return tmp;
}
D_m = abs(d)
d_m = abs(d)
NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function.
real(8) function code(w0, m, d_m, h, l, d_m_1)
real(8), intent (in) :: w0
real(8), intent (in) :: 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 (l <= (-3.6d-90)) then
tmp = w0 * sqrt((1.0d0 + (((h * ((m / (d_m_1 / (m * d_m))) / (-4.0d0))) / d_m_1) * (d_m / l))))
else
tmp = w0 * sqrt((1.0d0 + (((h * (d_m * ((m * ((m * d_m) / d_m_1)) / (-4.0d0)))) / d_m_1) / l)))
end if
code = tmp
end function
D_m = Math.abs(D);
d_m = Math.abs(d);
assert w0 < M && M < D_m && D_m < h && h < l && l < d_m;
public static double code(double w0, double M, double D_m, double h, double l, double d_m) {
double tmp;
if (l <= -3.6e-90) {
tmp = w0 * Math.sqrt((1.0 + (((h * ((M / (d_m / (M * D_m))) / -4.0)) / d_m) * (D_m / l))));
} else {
tmp = w0 * Math.sqrt((1.0 + (((h * (D_m * ((M * ((M * D_m) / d_m)) / -4.0))) / d_m) / l)));
}
return tmp;
}
D_m = math.fabs(D) d_m = math.fabs(d) [w0, M, D_m, h, l, d_m] = sort([w0, M, D_m, h, l, d_m]) def code(w0, M, D_m, h, l, d_m): tmp = 0 if l <= -3.6e-90: tmp = w0 * math.sqrt((1.0 + (((h * ((M / (d_m / (M * D_m))) / -4.0)) / d_m) * (D_m / l)))) else: tmp = w0 * math.sqrt((1.0 + (((h * (D_m * ((M * ((M * D_m) / d_m)) / -4.0))) / d_m) / l))) return tmp
D_m = abs(D) d_m = abs(d) w0, M, D_m, h, l, d_m = sort([w0, M, D_m, h, l, d_m]) function code(w0, M, D_m, h, l, d_m) tmp = 0.0 if (l <= -3.6e-90) tmp = Float64(w0 * sqrt(Float64(1.0 + Float64(Float64(Float64(h * Float64(Float64(M / Float64(d_m / Float64(M * D_m))) / -4.0)) / d_m) * Float64(D_m / l))))); else tmp = Float64(w0 * sqrt(Float64(1.0 + Float64(Float64(Float64(h * Float64(D_m * Float64(Float64(M * Float64(Float64(M * D_m) / d_m)) / -4.0))) / d_m) / l)))); end return tmp end
D_m = abs(D);
d_m = abs(d);
w0, M, D_m, h, l, d_m = num2cell(sort([w0, M, D_m, h, l, d_m])){:}
function tmp_2 = code(w0, M, D_m, h, l, d_m)
tmp = 0.0;
if (l <= -3.6e-90)
tmp = w0 * sqrt((1.0 + (((h * ((M / (d_m / (M * D_m))) / -4.0)) / d_m) * (D_m / l))));
else
tmp = w0 * sqrt((1.0 + (((h * (D_m * ((M * ((M * D_m) / d_m)) / -4.0))) / d_m) / l)));
end
tmp_2 = tmp;
end
D_m = N[Abs[D], $MachinePrecision] d_m = N[Abs[d], $MachinePrecision] NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function. code[w0_, M_, D$95$m_, h_, l_, d$95$m_] := If[LessEqual[l, -3.6e-90], N[(w0 * N[Sqrt[N[(1.0 + N[(N[(N[(h * N[(N[(M / N[(d$95$m / N[(M * D$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / -4.0), $MachinePrecision]), $MachinePrecision] / d$95$m), $MachinePrecision] * N[(D$95$m / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(w0 * N[Sqrt[N[(1.0 + N[(N[(N[(h * N[(D$95$m * N[(N[(M * N[(N[(M * D$95$m), $MachinePrecision] / d$95$m), $MachinePrecision]), $MachinePrecision] / -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / d$95$m), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
D_m = \left|D\right|
\\
d_m = \left|d\right|
\\
[w0, M, D_m, h, l, d_m] = \mathsf{sort}([w0, M, D_m, h, l, d_m])\\
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq -3.6 \cdot 10^{-90}:\\
\;\;\;\;w0 \cdot \sqrt{1 + \frac{h \cdot \frac{\frac{M}{\frac{d\_m}{M \cdot D\_m}}}{-4}}{d\_m} \cdot \frac{D\_m}{\ell}}\\
\mathbf{else}:\\
\;\;\;\;w0 \cdot \sqrt{1 + \frac{\frac{h \cdot \left(D\_m \cdot \frac{M \cdot \frac{M \cdot D\_m}{d\_m}}{-4}\right)}{d\_m}}{\ell}}\\
\end{array}
\end{array}
if l < -3.59999999999999981e-90Initial program 87.8%
Simplified85.4%
associate-/l/N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f6485.3%
Applied egg-rr85.3%
if -3.59999999999999981e-90 < l Initial program 80.0%
Simplified84.5%
Final simplification84.8%
D_m = (fabs.f64 D)
d_m = (fabs.f64 d)
NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function.
(FPCore (w0 M D_m h l d_m)
:precision binary64
(if (<= d_m 1e+60)
(*
w0
(sqrt
(+ 1.0 (* (/ (* h (/ (/ M (/ d_m (* M D_m))) -4.0)) d_m) (/ D_m l)))))
(+
w0
(* (* D_m -0.125) (* D_m (/ (* w0 (* h (* M M))) (* d_m (* d_m l))))))))D_m = fabs(D);
d_m = fabs(d);
assert(w0 < M && M < D_m && D_m < h && h < l && l < d_m);
double code(double w0, double M, double D_m, double h, double l, double d_m) {
double tmp;
if (d_m <= 1e+60) {
tmp = w0 * sqrt((1.0 + (((h * ((M / (d_m / (M * D_m))) / -4.0)) / d_m) * (D_m / l))));
} else {
tmp = w0 + ((D_m * -0.125) * (D_m * ((w0 * (h * (M * M))) / (d_m * (d_m * l)))));
}
return tmp;
}
D_m = abs(d)
d_m = abs(d)
NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function.
real(8) function code(w0, m, d_m, h, l, d_m_1)
real(8), intent (in) :: w0
real(8), intent (in) :: 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 (d_m_1 <= 1d+60) then
tmp = w0 * sqrt((1.0d0 + (((h * ((m / (d_m_1 / (m * d_m))) / (-4.0d0))) / d_m_1) * (d_m / l))))
else
tmp = w0 + ((d_m * (-0.125d0)) * (d_m * ((w0 * (h * (m * m))) / (d_m_1 * (d_m_1 * l)))))
end if
code = tmp
end function
D_m = Math.abs(D);
d_m = Math.abs(d);
assert w0 < M && M < D_m && D_m < h && h < l && l < d_m;
public static double code(double w0, double M, double D_m, double h, double l, double d_m) {
double tmp;
if (d_m <= 1e+60) {
tmp = w0 * Math.sqrt((1.0 + (((h * ((M / (d_m / (M * D_m))) / -4.0)) / d_m) * (D_m / l))));
} else {
tmp = w0 + ((D_m * -0.125) * (D_m * ((w0 * (h * (M * M))) / (d_m * (d_m * l)))));
}
return tmp;
}
D_m = math.fabs(D) d_m = math.fabs(d) [w0, M, D_m, h, l, d_m] = sort([w0, M, D_m, h, l, d_m]) def code(w0, M, D_m, h, l, d_m): tmp = 0 if d_m <= 1e+60: tmp = w0 * math.sqrt((1.0 + (((h * ((M / (d_m / (M * D_m))) / -4.0)) / d_m) * (D_m / l)))) else: tmp = w0 + ((D_m * -0.125) * (D_m * ((w0 * (h * (M * M))) / (d_m * (d_m * l))))) return tmp
D_m = abs(D) d_m = abs(d) w0, M, D_m, h, l, d_m = sort([w0, M, D_m, h, l, d_m]) function code(w0, M, D_m, h, l, d_m) tmp = 0.0 if (d_m <= 1e+60) tmp = Float64(w0 * sqrt(Float64(1.0 + Float64(Float64(Float64(h * Float64(Float64(M / Float64(d_m / Float64(M * D_m))) / -4.0)) / d_m) * Float64(D_m / l))))); else tmp = Float64(w0 + Float64(Float64(D_m * -0.125) * Float64(D_m * Float64(Float64(w0 * Float64(h * Float64(M * M))) / Float64(d_m * Float64(d_m * l)))))); end return tmp end
D_m = abs(D);
d_m = abs(d);
w0, M, D_m, h, l, d_m = num2cell(sort([w0, M, D_m, h, l, d_m])){:}
function tmp_2 = code(w0, M, D_m, h, l, d_m)
tmp = 0.0;
if (d_m <= 1e+60)
tmp = w0 * sqrt((1.0 + (((h * ((M / (d_m / (M * D_m))) / -4.0)) / d_m) * (D_m / l))));
else
tmp = w0 + ((D_m * -0.125) * (D_m * ((w0 * (h * (M * M))) / (d_m * (d_m * l)))));
end
tmp_2 = tmp;
end
D_m = N[Abs[D], $MachinePrecision] d_m = N[Abs[d], $MachinePrecision] NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function. code[w0_, M_, D$95$m_, h_, l_, d$95$m_] := If[LessEqual[d$95$m, 1e+60], N[(w0 * N[Sqrt[N[(1.0 + N[(N[(N[(h * N[(N[(M / N[(d$95$m / N[(M * D$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / -4.0), $MachinePrecision]), $MachinePrecision] / d$95$m), $MachinePrecision] * N[(D$95$m / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(w0 + N[(N[(D$95$m * -0.125), $MachinePrecision] * N[(D$95$m * N[(N[(w0 * N[(h * N[(M * M), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(d$95$m * N[(d$95$m * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
D_m = \left|D\right|
\\
d_m = \left|d\right|
\\
[w0, M, D_m, h, l, d_m] = \mathsf{sort}([w0, M, D_m, h, l, d_m])\\
\\
\begin{array}{l}
\mathbf{if}\;d\_m \leq 10^{+60}:\\
\;\;\;\;w0 \cdot \sqrt{1 + \frac{h \cdot \frac{\frac{M}{\frac{d\_m}{M \cdot D\_m}}}{-4}}{d\_m} \cdot \frac{D\_m}{\ell}}\\
\mathbf{else}:\\
\;\;\;\;w0 + \left(D\_m \cdot -0.125\right) \cdot \left(D\_m \cdot \frac{w0 \cdot \left(h \cdot \left(M \cdot M\right)\right)}{d\_m \cdot \left(d\_m \cdot \ell\right)}\right)\\
\end{array}
\end{array}
if d < 9.9999999999999995e59Initial program 82.6%
Simplified82.9%
associate-/l/N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f6481.2%
Applied egg-rr81.2%
if 9.9999999999999995e59 < d Initial program 82.6%
Simplified91.5%
Taylor expanded in h around 0
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6456.3%
Simplified56.3%
associate-/l*N/A
associate-*r*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f6472.4%
Applied egg-rr72.4%
Taylor expanded in M around 0
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6463.7%
Simplified63.7%
Final simplification77.3%
D_m = (fabs.f64 D)
d_m = (fabs.f64 d)
NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function.
(FPCore (w0 M D_m h l d_m)
:precision binary64
(let* ((t_0 (/ -0.125 (* d_m d_m))))
(if (<= M 5.9e-130)
w0
(if (<= M 2.2e-21)
(* w0 (+ 1.0 (* t_0 (/ (* D_m (* h (* D_m (* M M)))) l))))
(if (<= M 1.6e+36)
w0
(* w0 (+ 1.0 (* t_0 (/ (* D_m (* D_m (* h (* M M)))) l)))))))))D_m = fabs(D);
d_m = fabs(d);
assert(w0 < M && M < D_m && D_m < h && h < l && l < d_m);
double code(double w0, double M, double D_m, double h, double l, double d_m) {
double t_0 = -0.125 / (d_m * d_m);
double tmp;
if (M <= 5.9e-130) {
tmp = w0;
} else if (M <= 2.2e-21) {
tmp = w0 * (1.0 + (t_0 * ((D_m * (h * (D_m * (M * M)))) / l)));
} else if (M <= 1.6e+36) {
tmp = w0;
} else {
tmp = w0 * (1.0 + (t_0 * ((D_m * (D_m * (h * (M * M)))) / l)));
}
return tmp;
}
D_m = abs(d)
d_m = abs(d)
NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function.
real(8) function code(w0, m, d_m, h, l, d_m_1)
real(8), intent (in) :: w0
real(8), intent (in) :: 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) :: t_0
real(8) :: tmp
t_0 = (-0.125d0) / (d_m_1 * d_m_1)
if (m <= 5.9d-130) then
tmp = w0
else if (m <= 2.2d-21) then
tmp = w0 * (1.0d0 + (t_0 * ((d_m * (h * (d_m * (m * m)))) / l)))
else if (m <= 1.6d+36) then
tmp = w0
else
tmp = w0 * (1.0d0 + (t_0 * ((d_m * (d_m * (h * (m * m)))) / l)))
end if
code = tmp
end function
D_m = Math.abs(D);
d_m = Math.abs(d);
assert w0 < M && M < D_m && D_m < h && h < l && l < d_m;
public static double code(double w0, double M, double D_m, double h, double l, double d_m) {
double t_0 = -0.125 / (d_m * d_m);
double tmp;
if (M <= 5.9e-130) {
tmp = w0;
} else if (M <= 2.2e-21) {
tmp = w0 * (1.0 + (t_0 * ((D_m * (h * (D_m * (M * M)))) / l)));
} else if (M <= 1.6e+36) {
tmp = w0;
} else {
tmp = w0 * (1.0 + (t_0 * ((D_m * (D_m * (h * (M * M)))) / l)));
}
return tmp;
}
D_m = math.fabs(D) d_m = math.fabs(d) [w0, M, D_m, h, l, d_m] = sort([w0, M, D_m, h, l, d_m]) def code(w0, M, D_m, h, l, d_m): t_0 = -0.125 / (d_m * d_m) tmp = 0 if M <= 5.9e-130: tmp = w0 elif M <= 2.2e-21: tmp = w0 * (1.0 + (t_0 * ((D_m * (h * (D_m * (M * M)))) / l))) elif M <= 1.6e+36: tmp = w0 else: tmp = w0 * (1.0 + (t_0 * ((D_m * (D_m * (h * (M * M)))) / l))) return tmp
D_m = abs(D) d_m = abs(d) w0, M, D_m, h, l, d_m = sort([w0, M, D_m, h, l, d_m]) function code(w0, M, D_m, h, l, d_m) t_0 = Float64(-0.125 / Float64(d_m * d_m)) tmp = 0.0 if (M <= 5.9e-130) tmp = w0; elseif (M <= 2.2e-21) tmp = Float64(w0 * Float64(1.0 + Float64(t_0 * Float64(Float64(D_m * Float64(h * Float64(D_m * Float64(M * M)))) / l)))); elseif (M <= 1.6e+36) tmp = w0; else tmp = Float64(w0 * Float64(1.0 + Float64(t_0 * Float64(Float64(D_m * Float64(D_m * Float64(h * Float64(M * M)))) / l)))); end return tmp end
D_m = abs(D);
d_m = abs(d);
w0, M, D_m, h, l, d_m = num2cell(sort([w0, M, D_m, h, l, d_m])){:}
function tmp_2 = code(w0, M, D_m, h, l, d_m)
t_0 = -0.125 / (d_m * d_m);
tmp = 0.0;
if (M <= 5.9e-130)
tmp = w0;
elseif (M <= 2.2e-21)
tmp = w0 * (1.0 + (t_0 * ((D_m * (h * (D_m * (M * M)))) / l)));
elseif (M <= 1.6e+36)
tmp = w0;
else
tmp = w0 * (1.0 + (t_0 * ((D_m * (D_m * (h * (M * M)))) / l)));
end
tmp_2 = tmp;
end
D_m = N[Abs[D], $MachinePrecision]
d_m = N[Abs[d], $MachinePrecision]
NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function.
code[w0_, M_, D$95$m_, h_, l_, d$95$m_] := Block[{t$95$0 = N[(-0.125 / N[(d$95$m * d$95$m), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[M, 5.9e-130], w0, If[LessEqual[M, 2.2e-21], N[(w0 * N[(1.0 + N[(t$95$0 * N[(N[(D$95$m * N[(h * N[(D$95$m * N[(M * M), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[M, 1.6e+36], w0, N[(w0 * N[(1.0 + N[(t$95$0 * N[(N[(D$95$m * N[(D$95$m * N[(h * N[(M * M), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
D_m = \left|D\right|
\\
d_m = \left|d\right|
\\
[w0, M, D_m, h, l, d_m] = \mathsf{sort}([w0, M, D_m, h, l, d_m])\\
\\
\begin{array}{l}
t_0 := \frac{-0.125}{d\_m \cdot d\_m}\\
\mathbf{if}\;M \leq 5.9 \cdot 10^{-130}:\\
\;\;\;\;w0\\
\mathbf{elif}\;M \leq 2.2 \cdot 10^{-21}:\\
\;\;\;\;w0 \cdot \left(1 + t\_0 \cdot \frac{D\_m \cdot \left(h \cdot \left(D\_m \cdot \left(M \cdot M\right)\right)\right)}{\ell}\right)\\
\mathbf{elif}\;M \leq 1.6 \cdot 10^{+36}:\\
\;\;\;\;w0\\
\mathbf{else}:\\
\;\;\;\;w0 \cdot \left(1 + t\_0 \cdot \frac{D\_m \cdot \left(D\_m \cdot \left(h \cdot \left(M \cdot M\right)\right)\right)}{\ell}\right)\\
\end{array}
\end{array}
if M < 5.9000000000000003e-130 or 2.2000000000000001e-21 < M < 1.5999999999999999e36Initial program 82.1%
Simplified85.7%
Taylor expanded in h around 0
Simplified70.8%
if 5.9000000000000003e-130 < M < 2.2000000000000001e-21Initial program 80.4%
Simplified93.2%
associate-/l/N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f6499.9%
Applied egg-rr99.9%
Taylor expanded in h around 0
*-lft-identityN/A
associate-*r/N/A
associate-*r*N/A
associate-*r*N/A
associate-*r*N/A
associate-*r*N/A
associate-*l/N/A
associate-*r/N/A
distribute-rgt-inN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
associate-*r/N/A
Simplified86.1%
if 1.5999999999999999e36 < M Initial program 84.6%
Simplified79.9%
Taylor expanded in h around 0
+-lowering-+.f64N/A
associate-*r/N/A
times-fracN/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
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6443.5%
Simplified43.5%
Final simplification65.6%
D_m = (fabs.f64 D)
d_m = (fabs.f64 d)
NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function.
(FPCore (w0 M D_m h l d_m)
:precision binary64
(let* ((t_0
(*
w0
(+
1.0
(* (/ -0.125 (* d_m d_m)) (/ (* D_m (* D_m (* h (* M M)))) l))))))
(if (<= M 5.2e-154) w0 (if (<= M 2.6e-23) t_0 (if (<= M 2.2e+36) w0 t_0)))))D_m = fabs(D);
d_m = fabs(d);
assert(w0 < M && M < D_m && D_m < h && h < l && l < d_m);
double code(double w0, double M, double D_m, double h, double l, double d_m) {
double t_0 = w0 * (1.0 + ((-0.125 / (d_m * d_m)) * ((D_m * (D_m * (h * (M * M)))) / l)));
double tmp;
if (M <= 5.2e-154) {
tmp = w0;
} else if (M <= 2.6e-23) {
tmp = t_0;
} else if (M <= 2.2e+36) {
tmp = w0;
} else {
tmp = t_0;
}
return tmp;
}
D_m = abs(d)
d_m = abs(d)
NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function.
real(8) function code(w0, m, d_m, h, l, d_m_1)
real(8), intent (in) :: w0
real(8), intent (in) :: 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) :: t_0
real(8) :: tmp
t_0 = w0 * (1.0d0 + (((-0.125d0) / (d_m_1 * d_m_1)) * ((d_m * (d_m * (h * (m * m)))) / l)))
if (m <= 5.2d-154) then
tmp = w0
else if (m <= 2.6d-23) then
tmp = t_0
else if (m <= 2.2d+36) then
tmp = w0
else
tmp = t_0
end if
code = tmp
end function
D_m = Math.abs(D);
d_m = Math.abs(d);
assert w0 < M && M < D_m && D_m < h && h < l && l < d_m;
public static double code(double w0, double M, double D_m, double h, double l, double d_m) {
double t_0 = w0 * (1.0 + ((-0.125 / (d_m * d_m)) * ((D_m * (D_m * (h * (M * M)))) / l)));
double tmp;
if (M <= 5.2e-154) {
tmp = w0;
} else if (M <= 2.6e-23) {
tmp = t_0;
} else if (M <= 2.2e+36) {
tmp = w0;
} else {
tmp = t_0;
}
return tmp;
}
D_m = math.fabs(D) d_m = math.fabs(d) [w0, M, D_m, h, l, d_m] = sort([w0, M, D_m, h, l, d_m]) def code(w0, M, D_m, h, l, d_m): t_0 = w0 * (1.0 + ((-0.125 / (d_m * d_m)) * ((D_m * (D_m * (h * (M * M)))) / l))) tmp = 0 if M <= 5.2e-154: tmp = w0 elif M <= 2.6e-23: tmp = t_0 elif M <= 2.2e+36: tmp = w0 else: tmp = t_0 return tmp
D_m = abs(D) d_m = abs(d) w0, M, D_m, h, l, d_m = sort([w0, M, D_m, h, l, d_m]) function code(w0, M, D_m, h, l, d_m) t_0 = Float64(w0 * Float64(1.0 + Float64(Float64(-0.125 / Float64(d_m * d_m)) * Float64(Float64(D_m * Float64(D_m * Float64(h * Float64(M * M)))) / l)))) tmp = 0.0 if (M <= 5.2e-154) tmp = w0; elseif (M <= 2.6e-23) tmp = t_0; elseif (M <= 2.2e+36) tmp = w0; else tmp = t_0; end return tmp end
D_m = abs(D);
d_m = abs(d);
w0, M, D_m, h, l, d_m = num2cell(sort([w0, M, D_m, h, l, d_m])){:}
function tmp_2 = code(w0, M, D_m, h, l, d_m)
t_0 = w0 * (1.0 + ((-0.125 / (d_m * d_m)) * ((D_m * (D_m * (h * (M * M)))) / l)));
tmp = 0.0;
if (M <= 5.2e-154)
tmp = w0;
elseif (M <= 2.6e-23)
tmp = t_0;
elseif (M <= 2.2e+36)
tmp = w0;
else
tmp = t_0;
end
tmp_2 = tmp;
end
D_m = N[Abs[D], $MachinePrecision]
d_m = N[Abs[d], $MachinePrecision]
NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function.
code[w0_, M_, D$95$m_, h_, l_, d$95$m_] := Block[{t$95$0 = N[(w0 * N[(1.0 + N[(N[(-0.125 / N[(d$95$m * d$95$m), $MachinePrecision]), $MachinePrecision] * N[(N[(D$95$m * N[(D$95$m * N[(h * N[(M * M), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[M, 5.2e-154], w0, If[LessEqual[M, 2.6e-23], t$95$0, If[LessEqual[M, 2.2e+36], w0, t$95$0]]]]
\begin{array}{l}
D_m = \left|D\right|
\\
d_m = \left|d\right|
\\
[w0, M, D_m, h, l, d_m] = \mathsf{sort}([w0, M, D_m, h, l, d_m])\\
\\
\begin{array}{l}
t_0 := w0 \cdot \left(1 + \frac{-0.125}{d\_m \cdot d\_m} \cdot \frac{D\_m \cdot \left(D\_m \cdot \left(h \cdot \left(M \cdot M\right)\right)\right)}{\ell}\right)\\
\mathbf{if}\;M \leq 5.2 \cdot 10^{-154}:\\
\;\;\;\;w0\\
\mathbf{elif}\;M \leq 2.6 \cdot 10^{-23}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;M \leq 2.2 \cdot 10^{+36}:\\
\;\;\;\;w0\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if M < 5.2e-154 or 2.6e-23 < M < 2.2e36Initial program 82.2%
Simplified85.5%
Taylor expanded in h around 0
Simplified70.8%
if 5.2e-154 < M < 2.6e-23 or 2.2e36 < M Initial program 83.5%
Simplified83.2%
Taylor expanded in h around 0
+-lowering-+.f64N/A
associate-*r/N/A
times-fracN/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
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6452.9%
Simplified52.9%
Final simplification65.4%
D_m = (fabs.f64 D)
d_m = (fabs.f64 d)
NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function.
(FPCore (w0 M D_m h l d_m)
:precision binary64
(if (<= d_m 1.6e-6)
(+ w0 (* (* D_m -0.125) (/ (/ (* (* M (/ (* M D_m) d_m)) (* h w0)) l) d_m)))
(*
w0
(-
(* (* 0.125 (* D_m (* M (* M h)))) (/ D_m (* (* d_m l) (- 0.0 d_m))))
-1.0))))D_m = fabs(D);
d_m = fabs(d);
assert(w0 < M && M < D_m && D_m < h && h < l && l < d_m);
double code(double w0, double M, double D_m, double h, double l, double d_m) {
double tmp;
if (d_m <= 1.6e-6) {
tmp = w0 + ((D_m * -0.125) * ((((M * ((M * D_m) / d_m)) * (h * w0)) / l) / d_m));
} else {
tmp = w0 * (((0.125 * (D_m * (M * (M * h)))) * (D_m / ((d_m * l) * (0.0 - d_m)))) - -1.0);
}
return tmp;
}
D_m = abs(d)
d_m = abs(d)
NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function.
real(8) function code(w0, m, d_m, h, l, d_m_1)
real(8), intent (in) :: w0
real(8), intent (in) :: 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 (d_m_1 <= 1.6d-6) then
tmp = w0 + ((d_m * (-0.125d0)) * ((((m * ((m * d_m) / d_m_1)) * (h * w0)) / l) / d_m_1))
else
tmp = w0 * (((0.125d0 * (d_m * (m * (m * h)))) * (d_m / ((d_m_1 * l) * (0.0d0 - d_m_1)))) - (-1.0d0))
end if
code = tmp
end function
D_m = Math.abs(D);
d_m = Math.abs(d);
assert w0 < M && M < D_m && D_m < h && h < l && l < d_m;
public static double code(double w0, double M, double D_m, double h, double l, double d_m) {
double tmp;
if (d_m <= 1.6e-6) {
tmp = w0 + ((D_m * -0.125) * ((((M * ((M * D_m) / d_m)) * (h * w0)) / l) / d_m));
} else {
tmp = w0 * (((0.125 * (D_m * (M * (M * h)))) * (D_m / ((d_m * l) * (0.0 - d_m)))) - -1.0);
}
return tmp;
}
D_m = math.fabs(D) d_m = math.fabs(d) [w0, M, D_m, h, l, d_m] = sort([w0, M, D_m, h, l, d_m]) def code(w0, M, D_m, h, l, d_m): tmp = 0 if d_m <= 1.6e-6: tmp = w0 + ((D_m * -0.125) * ((((M * ((M * D_m) / d_m)) * (h * w0)) / l) / d_m)) else: tmp = w0 * (((0.125 * (D_m * (M * (M * h)))) * (D_m / ((d_m * l) * (0.0 - d_m)))) - -1.0) return tmp
D_m = abs(D) d_m = abs(d) w0, M, D_m, h, l, d_m = sort([w0, M, D_m, h, l, d_m]) function code(w0, M, D_m, h, l, d_m) tmp = 0.0 if (d_m <= 1.6e-6) tmp = Float64(w0 + Float64(Float64(D_m * -0.125) * Float64(Float64(Float64(Float64(M * Float64(Float64(M * D_m) / d_m)) * Float64(h * w0)) / l) / d_m))); else tmp = Float64(w0 * Float64(Float64(Float64(0.125 * Float64(D_m * Float64(M * Float64(M * h)))) * Float64(D_m / Float64(Float64(d_m * l) * Float64(0.0 - d_m)))) - -1.0)); end return tmp end
D_m = abs(D);
d_m = abs(d);
w0, M, D_m, h, l, d_m = num2cell(sort([w0, M, D_m, h, l, d_m])){:}
function tmp_2 = code(w0, M, D_m, h, l, d_m)
tmp = 0.0;
if (d_m <= 1.6e-6)
tmp = w0 + ((D_m * -0.125) * ((((M * ((M * D_m) / d_m)) * (h * w0)) / l) / d_m));
else
tmp = w0 * (((0.125 * (D_m * (M * (M * h)))) * (D_m / ((d_m * l) * (0.0 - d_m)))) - -1.0);
end
tmp_2 = tmp;
end
D_m = N[Abs[D], $MachinePrecision] d_m = N[Abs[d], $MachinePrecision] NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function. code[w0_, M_, D$95$m_, h_, l_, d$95$m_] := If[LessEqual[d$95$m, 1.6e-6], N[(w0 + N[(N[(D$95$m * -0.125), $MachinePrecision] * N[(N[(N[(N[(M * N[(N[(M * D$95$m), $MachinePrecision] / d$95$m), $MachinePrecision]), $MachinePrecision] * N[(h * w0), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision] / d$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(w0 * N[(N[(N[(0.125 * N[(D$95$m * N[(M * N[(M * h), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(D$95$m / N[(N[(d$95$m * l), $MachinePrecision] * N[(0.0 - d$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - -1.0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
D_m = \left|D\right|
\\
d_m = \left|d\right|
\\
[w0, M, D_m, h, l, d_m] = \mathsf{sort}([w0, M, D_m, h, l, d_m])\\
\\
\begin{array}{l}
\mathbf{if}\;d\_m \leq 1.6 \cdot 10^{-6}:\\
\;\;\;\;w0 + \left(D\_m \cdot -0.125\right) \cdot \frac{\frac{\left(M \cdot \frac{M \cdot D\_m}{d\_m}\right) \cdot \left(h \cdot w0\right)}{\ell}}{d\_m}\\
\mathbf{else}:\\
\;\;\;\;w0 \cdot \left(\left(0.125 \cdot \left(D\_m \cdot \left(M \cdot \left(M \cdot h\right)\right)\right)\right) \cdot \frac{D\_m}{\left(d\_m \cdot \ell\right) \cdot \left(0 - d\_m\right)} - -1\right)\\
\end{array}
\end{array}
if d < 1.5999999999999999e-6Initial program 81.9%
Simplified82.7%
Taylor expanded in h around 0
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6447.0%
Simplified47.0%
associate-/l*N/A
associate-*r*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f6461.7%
Applied egg-rr61.7%
times-fracN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6467.7%
Applied egg-rr67.7%
associate-*r/N/A
*-commutativeN/A
associate-/r*N/A
/-lowering-/.f64N/A
Applied egg-rr74.6%
if 1.5999999999999999e-6 < d Initial program 84.7%
Simplified91.2%
Taylor expanded in h around 0
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6452.2%
Simplified52.2%
Taylor expanded in w0 around -inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
Simplified64.5%
associate-*r*N/A
associate-/l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6466.2%
Applied egg-rr66.2%
Final simplification72.4%
D_m = (fabs.f64 D)
d_m = (fabs.f64 d)
NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function.
(FPCore (w0 M D_m h l d_m)
:precision binary64
(if (<= D_m 3.6e+58)
w0
(+
w0
(* (* D_m -0.125) (* (* D_m (/ M d_m)) (* (/ h l) (/ (* M w0) d_m)))))))D_m = fabs(D);
d_m = fabs(d);
assert(w0 < M && M < D_m && D_m < h && h < l && l < d_m);
double code(double w0, double M, double D_m, double h, double l, double d_m) {
double tmp;
if (D_m <= 3.6e+58) {
tmp = w0;
} else {
tmp = w0 + ((D_m * -0.125) * ((D_m * (M / d_m)) * ((h / l) * ((M * w0) / d_m))));
}
return tmp;
}
D_m = abs(d)
d_m = abs(d)
NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function.
real(8) function code(w0, m, d_m, h, l, d_m_1)
real(8), intent (in) :: w0
real(8), intent (in) :: 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 (d_m <= 3.6d+58) then
tmp = w0
else
tmp = w0 + ((d_m * (-0.125d0)) * ((d_m * (m / d_m_1)) * ((h / l) * ((m * w0) / d_m_1))))
end if
code = tmp
end function
D_m = Math.abs(D);
d_m = Math.abs(d);
assert w0 < M && M < D_m && D_m < h && h < l && l < d_m;
public static double code(double w0, double M, double D_m, double h, double l, double d_m) {
double tmp;
if (D_m <= 3.6e+58) {
tmp = w0;
} else {
tmp = w0 + ((D_m * -0.125) * ((D_m * (M / d_m)) * ((h / l) * ((M * w0) / d_m))));
}
return tmp;
}
D_m = math.fabs(D) d_m = math.fabs(d) [w0, M, D_m, h, l, d_m] = sort([w0, M, D_m, h, l, d_m]) def code(w0, M, D_m, h, l, d_m): tmp = 0 if D_m <= 3.6e+58: tmp = w0 else: tmp = w0 + ((D_m * -0.125) * ((D_m * (M / d_m)) * ((h / l) * ((M * w0) / d_m)))) return tmp
D_m = abs(D) d_m = abs(d) w0, M, D_m, h, l, d_m = sort([w0, M, D_m, h, l, d_m]) function code(w0, M, D_m, h, l, d_m) tmp = 0.0 if (D_m <= 3.6e+58) tmp = w0; else tmp = Float64(w0 + Float64(Float64(D_m * -0.125) * Float64(Float64(D_m * Float64(M / d_m)) * Float64(Float64(h / l) * Float64(Float64(M * w0) / d_m))))); end return tmp end
D_m = abs(D);
d_m = abs(d);
w0, M, D_m, h, l, d_m = num2cell(sort([w0, M, D_m, h, l, d_m])){:}
function tmp_2 = code(w0, M, D_m, h, l, d_m)
tmp = 0.0;
if (D_m <= 3.6e+58)
tmp = w0;
else
tmp = w0 + ((D_m * -0.125) * ((D_m * (M / d_m)) * ((h / l) * ((M * w0) / d_m))));
end
tmp_2 = tmp;
end
D_m = N[Abs[D], $MachinePrecision] d_m = N[Abs[d], $MachinePrecision] NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function. code[w0_, M_, D$95$m_, h_, l_, d$95$m_] := If[LessEqual[D$95$m, 3.6e+58], w0, N[(w0 + N[(N[(D$95$m * -0.125), $MachinePrecision] * N[(N[(D$95$m * N[(M / d$95$m), $MachinePrecision]), $MachinePrecision] * N[(N[(h / l), $MachinePrecision] * N[(N[(M * w0), $MachinePrecision] / d$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
D_m = \left|D\right|
\\
d_m = \left|d\right|
\\
[w0, M, D_m, h, l, d_m] = \mathsf{sort}([w0, M, D_m, h, l, d_m])\\
\\
\begin{array}{l}
\mathbf{if}\;D\_m \leq 3.6 \cdot 10^{+58}:\\
\;\;\;\;w0\\
\mathbf{else}:\\
\;\;\;\;w0 + \left(D\_m \cdot -0.125\right) \cdot \left(\left(D\_m \cdot \frac{M}{d\_m}\right) \cdot \left(\frac{h}{\ell} \cdot \frac{M \cdot w0}{d\_m}\right)\right)\\
\end{array}
\end{array}
if D < 3.59999999999999996e58Initial program 81.0%
Simplified84.7%
Taylor expanded in h around 0
Simplified73.3%
if 3.59999999999999996e58 < D Initial program 90.6%
Simplified85.8%
Taylor expanded in h around 0
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6443.3%
Simplified43.3%
associate-/l*N/A
associate-*r*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f6470.9%
Applied egg-rr70.9%
times-fracN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6471.0%
Applied egg-rr71.0%
associate-*r*N/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f6478.2%
Applied egg-rr78.2%
Final simplification74.1%
D_m = (fabs.f64 D)
d_m = (fabs.f64 d)
NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function.
(FPCore (w0 M D_m h l d_m)
:precision binary64
(if (<= D_m 1.65e+89)
w0
(+
w0
(* (* D_m -0.125) (* D_m (/ (* M (* w0 (* M h))) (* d_m (* d_m l))))))))D_m = fabs(D);
d_m = fabs(d);
assert(w0 < M && M < D_m && D_m < h && h < l && l < d_m);
double code(double w0, double M, double D_m, double h, double l, double d_m) {
double tmp;
if (D_m <= 1.65e+89) {
tmp = w0;
} else {
tmp = w0 + ((D_m * -0.125) * (D_m * ((M * (w0 * (M * h))) / (d_m * (d_m * l)))));
}
return tmp;
}
D_m = abs(d)
d_m = abs(d)
NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function.
real(8) function code(w0, m, d_m, h, l, d_m_1)
real(8), intent (in) :: w0
real(8), intent (in) :: 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 (d_m <= 1.65d+89) then
tmp = w0
else
tmp = w0 + ((d_m * (-0.125d0)) * (d_m * ((m * (w0 * (m * h))) / (d_m_1 * (d_m_1 * l)))))
end if
code = tmp
end function
D_m = Math.abs(D);
d_m = Math.abs(d);
assert w0 < M && M < D_m && D_m < h && h < l && l < d_m;
public static double code(double w0, double M, double D_m, double h, double l, double d_m) {
double tmp;
if (D_m <= 1.65e+89) {
tmp = w0;
} else {
tmp = w0 + ((D_m * -0.125) * (D_m * ((M * (w0 * (M * h))) / (d_m * (d_m * l)))));
}
return tmp;
}
D_m = math.fabs(D) d_m = math.fabs(d) [w0, M, D_m, h, l, d_m] = sort([w0, M, D_m, h, l, d_m]) def code(w0, M, D_m, h, l, d_m): tmp = 0 if D_m <= 1.65e+89: tmp = w0 else: tmp = w0 + ((D_m * -0.125) * (D_m * ((M * (w0 * (M * h))) / (d_m * (d_m * l))))) return tmp
D_m = abs(D) d_m = abs(d) w0, M, D_m, h, l, d_m = sort([w0, M, D_m, h, l, d_m]) function code(w0, M, D_m, h, l, d_m) tmp = 0.0 if (D_m <= 1.65e+89) tmp = w0; else tmp = Float64(w0 + Float64(Float64(D_m * -0.125) * Float64(D_m * Float64(Float64(M * Float64(w0 * Float64(M * h))) / Float64(d_m * Float64(d_m * l)))))); end return tmp end
D_m = abs(D);
d_m = abs(d);
w0, M, D_m, h, l, d_m = num2cell(sort([w0, M, D_m, h, l, d_m])){:}
function tmp_2 = code(w0, M, D_m, h, l, d_m)
tmp = 0.0;
if (D_m <= 1.65e+89)
tmp = w0;
else
tmp = w0 + ((D_m * -0.125) * (D_m * ((M * (w0 * (M * h))) / (d_m * (d_m * l)))));
end
tmp_2 = tmp;
end
D_m = N[Abs[D], $MachinePrecision] d_m = N[Abs[d], $MachinePrecision] NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function. code[w0_, M_, D$95$m_, h_, l_, d$95$m_] := If[LessEqual[D$95$m, 1.65e+89], w0, N[(w0 + N[(N[(D$95$m * -0.125), $MachinePrecision] * N[(D$95$m * N[(N[(M * N[(w0 * N[(M * h), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(d$95$m * N[(d$95$m * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
D_m = \left|D\right|
\\
d_m = \left|d\right|
\\
[w0, M, D_m, h, l, d_m] = \mathsf{sort}([w0, M, D_m, h, l, d_m])\\
\\
\begin{array}{l}
\mathbf{if}\;D\_m \leq 1.65 \cdot 10^{+89}:\\
\;\;\;\;w0\\
\mathbf{else}:\\
\;\;\;\;w0 + \left(D\_m \cdot -0.125\right) \cdot \left(D\_m \cdot \frac{M \cdot \left(w0 \cdot \left(M \cdot h\right)\right)}{d\_m \cdot \left(d\_m \cdot \ell\right)}\right)\\
\end{array}
\end{array}
if D < 1.64999999999999987e89Initial program 81.6%
Simplified85.1%
Taylor expanded in h around 0
Simplified73.3%
if 1.64999999999999987e89 < D Initial program 88.7%
Simplified82.9%
Taylor expanded in h around 0
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6437.5%
Simplified37.5%
associate-/l*N/A
associate-*r*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f6467.8%
Applied egg-rr67.8%
Final simplification72.6%
D_m = (fabs.f64 D) d_m = (fabs.f64 d) NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function. (FPCore (w0 M D_m h l d_m) :precision binary64 (if (<= M 1.1e+36) w0 (* (/ (/ (* M (* M (* h w0))) d_m) l) (* D_m (/ (* D_m -0.125) d_m)))))
D_m = fabs(D);
d_m = fabs(d);
assert(w0 < M && M < D_m && D_m < h && h < l && l < d_m);
double code(double w0, double M, double D_m, double h, double l, double d_m) {
double tmp;
if (M <= 1.1e+36) {
tmp = w0;
} else {
tmp = (((M * (M * (h * w0))) / d_m) / l) * (D_m * ((D_m * -0.125) / d_m));
}
return tmp;
}
D_m = abs(d)
d_m = abs(d)
NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function.
real(8) function code(w0, m, d_m, h, l, d_m_1)
real(8), intent (in) :: w0
real(8), intent (in) :: 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 <= 1.1d+36) then
tmp = w0
else
tmp = (((m * (m * (h * w0))) / d_m_1) / l) * (d_m * ((d_m * (-0.125d0)) / d_m_1))
end if
code = tmp
end function
D_m = Math.abs(D);
d_m = Math.abs(d);
assert w0 < M && M < D_m && D_m < h && h < l && l < d_m;
public static double code(double w0, double M, double D_m, double h, double l, double d_m) {
double tmp;
if (M <= 1.1e+36) {
tmp = w0;
} else {
tmp = (((M * (M * (h * w0))) / d_m) / l) * (D_m * ((D_m * -0.125) / d_m));
}
return tmp;
}
D_m = math.fabs(D) d_m = math.fabs(d) [w0, M, D_m, h, l, d_m] = sort([w0, M, D_m, h, l, d_m]) def code(w0, M, D_m, h, l, d_m): tmp = 0 if M <= 1.1e+36: tmp = w0 else: tmp = (((M * (M * (h * w0))) / d_m) / l) * (D_m * ((D_m * -0.125) / d_m)) return tmp
D_m = abs(D) d_m = abs(d) w0, M, D_m, h, l, d_m = sort([w0, M, D_m, h, l, d_m]) function code(w0, M, D_m, h, l, d_m) tmp = 0.0 if (M <= 1.1e+36) tmp = w0; else tmp = Float64(Float64(Float64(Float64(M * Float64(M * Float64(h * w0))) / d_m) / l) * Float64(D_m * Float64(Float64(D_m * -0.125) / d_m))); end return tmp end
D_m = abs(D);
d_m = abs(d);
w0, M, D_m, h, l, d_m = num2cell(sort([w0, M, D_m, h, l, d_m])){:}
function tmp_2 = code(w0, M, D_m, h, l, d_m)
tmp = 0.0;
if (M <= 1.1e+36)
tmp = w0;
else
tmp = (((M * (M * (h * w0))) / d_m) / l) * (D_m * ((D_m * -0.125) / d_m));
end
tmp_2 = tmp;
end
D_m = N[Abs[D], $MachinePrecision] d_m = N[Abs[d], $MachinePrecision] NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function. code[w0_, M_, D$95$m_, h_, l_, d$95$m_] := If[LessEqual[M, 1.1e+36], w0, N[(N[(N[(N[(M * N[(M * N[(h * w0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / d$95$m), $MachinePrecision] / l), $MachinePrecision] * N[(D$95$m * N[(N[(D$95$m * -0.125), $MachinePrecision] / d$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
D_m = \left|D\right|
\\
d_m = \left|d\right|
\\
[w0, M, D_m, h, l, d_m] = \mathsf{sort}([w0, M, D_m, h, l, d_m])\\
\\
\begin{array}{l}
\mathbf{if}\;M \leq 1.1 \cdot 10^{+36}:\\
\;\;\;\;w0\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{M \cdot \left(M \cdot \left(h \cdot w0\right)\right)}{d\_m}}{\ell} \cdot \left(D\_m \cdot \frac{D\_m \cdot -0.125}{d\_m}\right)\\
\end{array}
\end{array}
if M < 1.1e36Initial program 82.0%
Simplified86.2%
Taylor expanded in h around 0
Simplified71.1%
if 1.1e36 < M Initial program 84.6%
Simplified79.9%
Taylor expanded in h around 0
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6437.9%
Simplified37.9%
Taylor expanded in D around inf
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6419.2%
Simplified19.2%
associate-*r/N/A
associate-*r*N/A
associate-/r*N/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
associate-*l/N/A
*-commutativeN/A
times-fracN/A
*-lowering-*.f64N/A
Applied egg-rr25.7%
Final simplification61.0%
D_m = (fabs.f64 D) d_m = (fabs.f64 d) NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function. (FPCore (w0 M D_m h l d_m) :precision binary64 (if (<= M 3.7e+36) w0 (* D_m (/ (* -0.125 (* (* M (/ (* M D_m) d_m)) (* h w0))) (* d_m l)))))
D_m = fabs(D);
d_m = fabs(d);
assert(w0 < M && M < D_m && D_m < h && h < l && l < d_m);
double code(double w0, double M, double D_m, double h, double l, double d_m) {
double tmp;
if (M <= 3.7e+36) {
tmp = w0;
} else {
tmp = D_m * ((-0.125 * ((M * ((M * D_m) / d_m)) * (h * w0))) / (d_m * l));
}
return tmp;
}
D_m = abs(d)
d_m = abs(d)
NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function.
real(8) function code(w0, m, d_m, h, l, d_m_1)
real(8), intent (in) :: w0
real(8), intent (in) :: 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 <= 3.7d+36) then
tmp = w0
else
tmp = d_m * (((-0.125d0) * ((m * ((m * d_m) / d_m_1)) * (h * w0))) / (d_m_1 * l))
end if
code = tmp
end function
D_m = Math.abs(D);
d_m = Math.abs(d);
assert w0 < M && M < D_m && D_m < h && h < l && l < d_m;
public static double code(double w0, double M, double D_m, double h, double l, double d_m) {
double tmp;
if (M <= 3.7e+36) {
tmp = w0;
} else {
tmp = D_m * ((-0.125 * ((M * ((M * D_m) / d_m)) * (h * w0))) / (d_m * l));
}
return tmp;
}
D_m = math.fabs(D) d_m = math.fabs(d) [w0, M, D_m, h, l, d_m] = sort([w0, M, D_m, h, l, d_m]) def code(w0, M, D_m, h, l, d_m): tmp = 0 if M <= 3.7e+36: tmp = w0 else: tmp = D_m * ((-0.125 * ((M * ((M * D_m) / d_m)) * (h * w0))) / (d_m * l)) return tmp
D_m = abs(D) d_m = abs(d) w0, M, D_m, h, l, d_m = sort([w0, M, D_m, h, l, d_m]) function code(w0, M, D_m, h, l, d_m) tmp = 0.0 if (M <= 3.7e+36) tmp = w0; else tmp = Float64(D_m * Float64(Float64(-0.125 * Float64(Float64(M * Float64(Float64(M * D_m) / d_m)) * Float64(h * w0))) / Float64(d_m * l))); end return tmp end
D_m = abs(D);
d_m = abs(d);
w0, M, D_m, h, l, d_m = num2cell(sort([w0, M, D_m, h, l, d_m])){:}
function tmp_2 = code(w0, M, D_m, h, l, d_m)
tmp = 0.0;
if (M <= 3.7e+36)
tmp = w0;
else
tmp = D_m * ((-0.125 * ((M * ((M * D_m) / d_m)) * (h * w0))) / (d_m * l));
end
tmp_2 = tmp;
end
D_m = N[Abs[D], $MachinePrecision] d_m = N[Abs[d], $MachinePrecision] NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function. code[w0_, M_, D$95$m_, h_, l_, d$95$m_] := If[LessEqual[M, 3.7e+36], w0, N[(D$95$m * N[(N[(-0.125 * N[(N[(M * N[(N[(M * D$95$m), $MachinePrecision] / d$95$m), $MachinePrecision]), $MachinePrecision] * N[(h * w0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(d$95$m * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
D_m = \left|D\right|
\\
d_m = \left|d\right|
\\
[w0, M, D_m, h, l, d_m] = \mathsf{sort}([w0, M, D_m, h, l, d_m])\\
\\
\begin{array}{l}
\mathbf{if}\;M \leq 3.7 \cdot 10^{+36}:\\
\;\;\;\;w0\\
\mathbf{else}:\\
\;\;\;\;D\_m \cdot \frac{-0.125 \cdot \left(\left(M \cdot \frac{M \cdot D\_m}{d\_m}\right) \cdot \left(h \cdot w0\right)\right)}{d\_m \cdot \ell}\\
\end{array}
\end{array}
if M < 3.70000000000000029e36Initial program 82.0%
Simplified86.2%
Taylor expanded in h around 0
Simplified71.1%
if 3.70000000000000029e36 < M Initial program 84.6%
Simplified79.9%
Taylor expanded in h around 0
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6437.9%
Simplified37.9%
Taylor expanded in D around inf
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6419.2%
Simplified19.2%
associate-*r/N/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*r*N/A
associate-*r/N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
Applied egg-rr25.9%
*-commutativeN/A
*-commutativeN/A
associate-*r*N/A
times-fracN/A
associate-*l*N/A
associate-*r/N/A
associate-*r/N/A
/-lowering-/.f64N/A
Applied egg-rr27.7%
Final simplification61.4%
D_m = (fabs.f64 D) d_m = (fabs.f64 d) NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function. (FPCore (w0 M D_m h l d_m) :precision binary64 (if (<= M 4.2e+36) w0 (* D_m (* (/ (* M (* M (* h w0))) d_m) (/ (/ (* D_m -0.125) l) d_m)))))
D_m = fabs(D);
d_m = fabs(d);
assert(w0 < M && M < D_m && D_m < h && h < l && l < d_m);
double code(double w0, double M, double D_m, double h, double l, double d_m) {
double tmp;
if (M <= 4.2e+36) {
tmp = w0;
} else {
tmp = D_m * (((M * (M * (h * w0))) / d_m) * (((D_m * -0.125) / l) / d_m));
}
return tmp;
}
D_m = abs(d)
d_m = abs(d)
NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function.
real(8) function code(w0, m, d_m, h, l, d_m_1)
real(8), intent (in) :: w0
real(8), intent (in) :: 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 <= 4.2d+36) then
tmp = w0
else
tmp = d_m * (((m * (m * (h * w0))) / d_m_1) * (((d_m * (-0.125d0)) / l) / d_m_1))
end if
code = tmp
end function
D_m = Math.abs(D);
d_m = Math.abs(d);
assert w0 < M && M < D_m && D_m < h && h < l && l < d_m;
public static double code(double w0, double M, double D_m, double h, double l, double d_m) {
double tmp;
if (M <= 4.2e+36) {
tmp = w0;
} else {
tmp = D_m * (((M * (M * (h * w0))) / d_m) * (((D_m * -0.125) / l) / d_m));
}
return tmp;
}
D_m = math.fabs(D) d_m = math.fabs(d) [w0, M, D_m, h, l, d_m] = sort([w0, M, D_m, h, l, d_m]) def code(w0, M, D_m, h, l, d_m): tmp = 0 if M <= 4.2e+36: tmp = w0 else: tmp = D_m * (((M * (M * (h * w0))) / d_m) * (((D_m * -0.125) / l) / d_m)) return tmp
D_m = abs(D) d_m = abs(d) w0, M, D_m, h, l, d_m = sort([w0, M, D_m, h, l, d_m]) function code(w0, M, D_m, h, l, d_m) tmp = 0.0 if (M <= 4.2e+36) tmp = w0; else tmp = Float64(D_m * Float64(Float64(Float64(M * Float64(M * Float64(h * w0))) / d_m) * Float64(Float64(Float64(D_m * -0.125) / l) / d_m))); end return tmp end
D_m = abs(D);
d_m = abs(d);
w0, M, D_m, h, l, d_m = num2cell(sort([w0, M, D_m, h, l, d_m])){:}
function tmp_2 = code(w0, M, D_m, h, l, d_m)
tmp = 0.0;
if (M <= 4.2e+36)
tmp = w0;
else
tmp = D_m * (((M * (M * (h * w0))) / d_m) * (((D_m * -0.125) / l) / d_m));
end
tmp_2 = tmp;
end
D_m = N[Abs[D], $MachinePrecision] d_m = N[Abs[d], $MachinePrecision] NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function. code[w0_, M_, D$95$m_, h_, l_, d$95$m_] := If[LessEqual[M, 4.2e+36], w0, N[(D$95$m * N[(N[(N[(M * N[(M * N[(h * w0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / d$95$m), $MachinePrecision] * N[(N[(N[(D$95$m * -0.125), $MachinePrecision] / l), $MachinePrecision] / d$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
D_m = \left|D\right|
\\
d_m = \left|d\right|
\\
[w0, M, D_m, h, l, d_m] = \mathsf{sort}([w0, M, D_m, h, l, d_m])\\
\\
\begin{array}{l}
\mathbf{if}\;M \leq 4.2 \cdot 10^{+36}:\\
\;\;\;\;w0\\
\mathbf{else}:\\
\;\;\;\;D\_m \cdot \left(\frac{M \cdot \left(M \cdot \left(h \cdot w0\right)\right)}{d\_m} \cdot \frac{\frac{D\_m \cdot -0.125}{\ell}}{d\_m}\right)\\
\end{array}
\end{array}
if M < 4.20000000000000009e36Initial program 82.0%
Simplified86.2%
Taylor expanded in h around 0
Simplified71.1%
if 4.20000000000000009e36 < M Initial program 84.6%
Simplified79.9%
Taylor expanded in h around 0
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6437.9%
Simplified37.9%
Taylor expanded in D around inf
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6419.2%
Simplified19.2%
associate-*r/N/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
frac-timesN/A
associate-/l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Applied egg-rr25.7%
Final simplification61.0%
D_m = (fabs.f64 D) d_m = (fabs.f64 d) NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function. (FPCore (w0 M D_m h l d_m) :precision binary64 (if (<= M 2.9e+36) w0 (* D_m (* (* D_m -0.125) (/ (* (/ M d_m) (/ (* M (* h w0)) d_m)) l)))))
D_m = fabs(D);
d_m = fabs(d);
assert(w0 < M && M < D_m && D_m < h && h < l && l < d_m);
double code(double w0, double M, double D_m, double h, double l, double d_m) {
double tmp;
if (M <= 2.9e+36) {
tmp = w0;
} else {
tmp = D_m * ((D_m * -0.125) * (((M / d_m) * ((M * (h * w0)) / d_m)) / l));
}
return tmp;
}
D_m = abs(d)
d_m = abs(d)
NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function.
real(8) function code(w0, m, d_m, h, l, d_m_1)
real(8), intent (in) :: w0
real(8), intent (in) :: 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 <= 2.9d+36) then
tmp = w0
else
tmp = d_m * ((d_m * (-0.125d0)) * (((m / d_m_1) * ((m * (h * w0)) / d_m_1)) / l))
end if
code = tmp
end function
D_m = Math.abs(D);
d_m = Math.abs(d);
assert w0 < M && M < D_m && D_m < h && h < l && l < d_m;
public static double code(double w0, double M, double D_m, double h, double l, double d_m) {
double tmp;
if (M <= 2.9e+36) {
tmp = w0;
} else {
tmp = D_m * ((D_m * -0.125) * (((M / d_m) * ((M * (h * w0)) / d_m)) / l));
}
return tmp;
}
D_m = math.fabs(D) d_m = math.fabs(d) [w0, M, D_m, h, l, d_m] = sort([w0, M, D_m, h, l, d_m]) def code(w0, M, D_m, h, l, d_m): tmp = 0 if M <= 2.9e+36: tmp = w0 else: tmp = D_m * ((D_m * -0.125) * (((M / d_m) * ((M * (h * w0)) / d_m)) / l)) return tmp
D_m = abs(D) d_m = abs(d) w0, M, D_m, h, l, d_m = sort([w0, M, D_m, h, l, d_m]) function code(w0, M, D_m, h, l, d_m) tmp = 0.0 if (M <= 2.9e+36) tmp = w0; else tmp = Float64(D_m * Float64(Float64(D_m * -0.125) * Float64(Float64(Float64(M / d_m) * Float64(Float64(M * Float64(h * w0)) / d_m)) / l))); end return tmp end
D_m = abs(D);
d_m = abs(d);
w0, M, D_m, h, l, d_m = num2cell(sort([w0, M, D_m, h, l, d_m])){:}
function tmp_2 = code(w0, M, D_m, h, l, d_m)
tmp = 0.0;
if (M <= 2.9e+36)
tmp = w0;
else
tmp = D_m * ((D_m * -0.125) * (((M / d_m) * ((M * (h * w0)) / d_m)) / l));
end
tmp_2 = tmp;
end
D_m = N[Abs[D], $MachinePrecision] d_m = N[Abs[d], $MachinePrecision] NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function. code[w0_, M_, D$95$m_, h_, l_, d$95$m_] := If[LessEqual[M, 2.9e+36], w0, N[(D$95$m * N[(N[(D$95$m * -0.125), $MachinePrecision] * N[(N[(N[(M / d$95$m), $MachinePrecision] * N[(N[(M * N[(h * w0), $MachinePrecision]), $MachinePrecision] / d$95$m), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
D_m = \left|D\right|
\\
d_m = \left|d\right|
\\
[w0, M, D_m, h, l, d_m] = \mathsf{sort}([w0, M, D_m, h, l, d_m])\\
\\
\begin{array}{l}
\mathbf{if}\;M \leq 2.9 \cdot 10^{+36}:\\
\;\;\;\;w0\\
\mathbf{else}:\\
\;\;\;\;D\_m \cdot \left(\left(D\_m \cdot -0.125\right) \cdot \frac{\frac{M}{d\_m} \cdot \frac{M \cdot \left(h \cdot w0\right)}{d\_m}}{\ell}\right)\\
\end{array}
\end{array}
if M < 2.9e36Initial program 82.0%
Simplified86.2%
Taylor expanded in h around 0
Simplified71.1%
if 2.9e36 < M Initial program 84.6%
Simplified79.9%
Taylor expanded in h around 0
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6437.9%
Simplified37.9%
Taylor expanded in D around inf
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6419.2%
Simplified19.2%
associate-*r/N/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*r*N/A
associate-*r/N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
Applied egg-rr25.9%
times-fracN/A
associate-/r*N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6428.1%
Applied egg-rr28.1%
Final simplification61.5%
D_m = (fabs.f64 D) d_m = (fabs.f64 d) NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function. (FPCore (w0 M D_m h l d_m) :precision binary64 (if (<= M 3.5e+36) w0 (* D_m (* (* D_m -0.125) (/ (* (* M w0) (* M h)) (* d_m (* d_m l)))))))
D_m = fabs(D);
d_m = fabs(d);
assert(w0 < M && M < D_m && D_m < h && h < l && l < d_m);
double code(double w0, double M, double D_m, double h, double l, double d_m) {
double tmp;
if (M <= 3.5e+36) {
tmp = w0;
} else {
tmp = D_m * ((D_m * -0.125) * (((M * w0) * (M * h)) / (d_m * (d_m * l))));
}
return tmp;
}
D_m = abs(d)
d_m = abs(d)
NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function.
real(8) function code(w0, m, d_m, h, l, d_m_1)
real(8), intent (in) :: w0
real(8), intent (in) :: 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 <= 3.5d+36) then
tmp = w0
else
tmp = d_m * ((d_m * (-0.125d0)) * (((m * w0) * (m * h)) / (d_m_1 * (d_m_1 * l))))
end if
code = tmp
end function
D_m = Math.abs(D);
d_m = Math.abs(d);
assert w0 < M && M < D_m && D_m < h && h < l && l < d_m;
public static double code(double w0, double M, double D_m, double h, double l, double d_m) {
double tmp;
if (M <= 3.5e+36) {
tmp = w0;
} else {
tmp = D_m * ((D_m * -0.125) * (((M * w0) * (M * h)) / (d_m * (d_m * l))));
}
return tmp;
}
D_m = math.fabs(D) d_m = math.fabs(d) [w0, M, D_m, h, l, d_m] = sort([w0, M, D_m, h, l, d_m]) def code(w0, M, D_m, h, l, d_m): tmp = 0 if M <= 3.5e+36: tmp = w0 else: tmp = D_m * ((D_m * -0.125) * (((M * w0) * (M * h)) / (d_m * (d_m * l)))) return tmp
D_m = abs(D) d_m = abs(d) w0, M, D_m, h, l, d_m = sort([w0, M, D_m, h, l, d_m]) function code(w0, M, D_m, h, l, d_m) tmp = 0.0 if (M <= 3.5e+36) tmp = w0; else tmp = Float64(D_m * Float64(Float64(D_m * -0.125) * Float64(Float64(Float64(M * w0) * Float64(M * h)) / Float64(d_m * Float64(d_m * l))))); end return tmp end
D_m = abs(D);
d_m = abs(d);
w0, M, D_m, h, l, d_m = num2cell(sort([w0, M, D_m, h, l, d_m])){:}
function tmp_2 = code(w0, M, D_m, h, l, d_m)
tmp = 0.0;
if (M <= 3.5e+36)
tmp = w0;
else
tmp = D_m * ((D_m * -0.125) * (((M * w0) * (M * h)) / (d_m * (d_m * l))));
end
tmp_2 = tmp;
end
D_m = N[Abs[D], $MachinePrecision] d_m = N[Abs[d], $MachinePrecision] NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function. code[w0_, M_, D$95$m_, h_, l_, d$95$m_] := If[LessEqual[M, 3.5e+36], w0, N[(D$95$m * N[(N[(D$95$m * -0.125), $MachinePrecision] * N[(N[(N[(M * w0), $MachinePrecision] * N[(M * h), $MachinePrecision]), $MachinePrecision] / N[(d$95$m * N[(d$95$m * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
D_m = \left|D\right|
\\
d_m = \left|d\right|
\\
[w0, M, D_m, h, l, d_m] = \mathsf{sort}([w0, M, D_m, h, l, d_m])\\
\\
\begin{array}{l}
\mathbf{if}\;M \leq 3.5 \cdot 10^{+36}:\\
\;\;\;\;w0\\
\mathbf{else}:\\
\;\;\;\;D\_m \cdot \left(\left(D\_m \cdot -0.125\right) \cdot \frac{\left(M \cdot w0\right) \cdot \left(M \cdot h\right)}{d\_m \cdot \left(d\_m \cdot \ell\right)}\right)\\
\end{array}
\end{array}
if M < 3.4999999999999998e36Initial program 82.0%
Simplified86.2%
Taylor expanded in h around 0
Simplified71.1%
if 3.4999999999999998e36 < M Initial program 84.6%
Simplified79.9%
Taylor expanded in h around 0
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6437.9%
Simplified37.9%
Taylor expanded in D around inf
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6419.2%
Simplified19.2%
associate-*r/N/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*r*N/A
associate-*r/N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
Applied egg-rr25.9%
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6425.7%
Applied egg-rr25.7%
Final simplification61.0%
D_m = (fabs.f64 D) d_m = (fabs.f64 d) NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function. (FPCore (w0 M D_m h l d_m) :precision binary64 (if (<= M 4.2e+36) w0 (* D_m (* (* D_m -0.125) (/ (* M (* M (* h w0))) (* d_m (* d_m l)))))))
D_m = fabs(D);
d_m = fabs(d);
assert(w0 < M && M < D_m && D_m < h && h < l && l < d_m);
double code(double w0, double M, double D_m, double h, double l, double d_m) {
double tmp;
if (M <= 4.2e+36) {
tmp = w0;
} else {
tmp = D_m * ((D_m * -0.125) * ((M * (M * (h * w0))) / (d_m * (d_m * l))));
}
return tmp;
}
D_m = abs(d)
d_m = abs(d)
NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function.
real(8) function code(w0, m, d_m, h, l, d_m_1)
real(8), intent (in) :: w0
real(8), intent (in) :: 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 <= 4.2d+36) then
tmp = w0
else
tmp = d_m * ((d_m * (-0.125d0)) * ((m * (m * (h * w0))) / (d_m_1 * (d_m_1 * l))))
end if
code = tmp
end function
D_m = Math.abs(D);
d_m = Math.abs(d);
assert w0 < M && M < D_m && D_m < h && h < l && l < d_m;
public static double code(double w0, double M, double D_m, double h, double l, double d_m) {
double tmp;
if (M <= 4.2e+36) {
tmp = w0;
} else {
tmp = D_m * ((D_m * -0.125) * ((M * (M * (h * w0))) / (d_m * (d_m * l))));
}
return tmp;
}
D_m = math.fabs(D) d_m = math.fabs(d) [w0, M, D_m, h, l, d_m] = sort([w0, M, D_m, h, l, d_m]) def code(w0, M, D_m, h, l, d_m): tmp = 0 if M <= 4.2e+36: tmp = w0 else: tmp = D_m * ((D_m * -0.125) * ((M * (M * (h * w0))) / (d_m * (d_m * l)))) return tmp
D_m = abs(D) d_m = abs(d) w0, M, D_m, h, l, d_m = sort([w0, M, D_m, h, l, d_m]) function code(w0, M, D_m, h, l, d_m) tmp = 0.0 if (M <= 4.2e+36) tmp = w0; else tmp = Float64(D_m * Float64(Float64(D_m * -0.125) * Float64(Float64(M * Float64(M * Float64(h * w0))) / Float64(d_m * Float64(d_m * l))))); end return tmp end
D_m = abs(D);
d_m = abs(d);
w0, M, D_m, h, l, d_m = num2cell(sort([w0, M, D_m, h, l, d_m])){:}
function tmp_2 = code(w0, M, D_m, h, l, d_m)
tmp = 0.0;
if (M <= 4.2e+36)
tmp = w0;
else
tmp = D_m * ((D_m * -0.125) * ((M * (M * (h * w0))) / (d_m * (d_m * l))));
end
tmp_2 = tmp;
end
D_m = N[Abs[D], $MachinePrecision] d_m = N[Abs[d], $MachinePrecision] NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function. code[w0_, M_, D$95$m_, h_, l_, d$95$m_] := If[LessEqual[M, 4.2e+36], w0, N[(D$95$m * N[(N[(D$95$m * -0.125), $MachinePrecision] * N[(N[(M * N[(M * N[(h * w0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(d$95$m * N[(d$95$m * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
D_m = \left|D\right|
\\
d_m = \left|d\right|
\\
[w0, M, D_m, h, l, d_m] = \mathsf{sort}([w0, M, D_m, h, l, d_m])\\
\\
\begin{array}{l}
\mathbf{if}\;M \leq 4.2 \cdot 10^{+36}:\\
\;\;\;\;w0\\
\mathbf{else}:\\
\;\;\;\;D\_m \cdot \left(\left(D\_m \cdot -0.125\right) \cdot \frac{M \cdot \left(M \cdot \left(h \cdot w0\right)\right)}{d\_m \cdot \left(d\_m \cdot \ell\right)}\right)\\
\end{array}
\end{array}
if M < 4.20000000000000009e36Initial program 82.0%
Simplified86.2%
Taylor expanded in h around 0
Simplified71.1%
if 4.20000000000000009e36 < M Initial program 84.6%
Simplified79.9%
Taylor expanded in h around 0
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6437.9%
Simplified37.9%
Taylor expanded in D around inf
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6419.2%
Simplified19.2%
associate-*r/N/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*r*N/A
associate-*r/N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
Applied egg-rr25.9%
Final simplification61.0%
D_m = (fabs.f64 D) d_m = (fabs.f64 d) NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function. (FPCore (w0 M D_m h l d_m) :precision binary64 (if (<= M 3.8e+36) w0 (* D_m (* (* D_m -0.125) (* (* (/ M d_m) (/ M d_m)) (/ (* h w0) l))))))
D_m = fabs(D);
d_m = fabs(d);
assert(w0 < M && M < D_m && D_m < h && h < l && l < d_m);
double code(double w0, double M, double D_m, double h, double l, double d_m) {
double tmp;
if (M <= 3.8e+36) {
tmp = w0;
} else {
tmp = D_m * ((D_m * -0.125) * (((M / d_m) * (M / d_m)) * ((h * w0) / l)));
}
return tmp;
}
D_m = abs(d)
d_m = abs(d)
NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function.
real(8) function code(w0, m, d_m, h, l, d_m_1)
real(8), intent (in) :: w0
real(8), intent (in) :: 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 <= 3.8d+36) then
tmp = w0
else
tmp = d_m * ((d_m * (-0.125d0)) * (((m / d_m_1) * (m / d_m_1)) * ((h * w0) / l)))
end if
code = tmp
end function
D_m = Math.abs(D);
d_m = Math.abs(d);
assert w0 < M && M < D_m && D_m < h && h < l && l < d_m;
public static double code(double w0, double M, double D_m, double h, double l, double d_m) {
double tmp;
if (M <= 3.8e+36) {
tmp = w0;
} else {
tmp = D_m * ((D_m * -0.125) * (((M / d_m) * (M / d_m)) * ((h * w0) / l)));
}
return tmp;
}
D_m = math.fabs(D) d_m = math.fabs(d) [w0, M, D_m, h, l, d_m] = sort([w0, M, D_m, h, l, d_m]) def code(w0, M, D_m, h, l, d_m): tmp = 0 if M <= 3.8e+36: tmp = w0 else: tmp = D_m * ((D_m * -0.125) * (((M / d_m) * (M / d_m)) * ((h * w0) / l))) return tmp
D_m = abs(D) d_m = abs(d) w0, M, D_m, h, l, d_m = sort([w0, M, D_m, h, l, d_m]) function code(w0, M, D_m, h, l, d_m) tmp = 0.0 if (M <= 3.8e+36) tmp = w0; else tmp = Float64(D_m * Float64(Float64(D_m * -0.125) * Float64(Float64(Float64(M / d_m) * Float64(M / d_m)) * Float64(Float64(h * w0) / l)))); end return tmp end
D_m = abs(D);
d_m = abs(d);
w0, M, D_m, h, l, d_m = num2cell(sort([w0, M, D_m, h, l, d_m])){:}
function tmp_2 = code(w0, M, D_m, h, l, d_m)
tmp = 0.0;
if (M <= 3.8e+36)
tmp = w0;
else
tmp = D_m * ((D_m * -0.125) * (((M / d_m) * (M / d_m)) * ((h * w0) / l)));
end
tmp_2 = tmp;
end
D_m = N[Abs[D], $MachinePrecision] d_m = N[Abs[d], $MachinePrecision] NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function. code[w0_, M_, D$95$m_, h_, l_, d$95$m_] := If[LessEqual[M, 3.8e+36], w0, N[(D$95$m * N[(N[(D$95$m * -0.125), $MachinePrecision] * N[(N[(N[(M / d$95$m), $MachinePrecision] * N[(M / d$95$m), $MachinePrecision]), $MachinePrecision] * N[(N[(h * w0), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
D_m = \left|D\right|
\\
d_m = \left|d\right|
\\
[w0, M, D_m, h, l, d_m] = \mathsf{sort}([w0, M, D_m, h, l, d_m])\\
\\
\begin{array}{l}
\mathbf{if}\;M \leq 3.8 \cdot 10^{+36}:\\
\;\;\;\;w0\\
\mathbf{else}:\\
\;\;\;\;D\_m \cdot \left(\left(D\_m \cdot -0.125\right) \cdot \left(\left(\frac{M}{d\_m} \cdot \frac{M}{d\_m}\right) \cdot \frac{h \cdot w0}{\ell}\right)\right)\\
\end{array}
\end{array}
if M < 3.80000000000000025e36Initial program 82.0%
Simplified86.2%
Taylor expanded in h around 0
Simplified71.1%
if 3.80000000000000025e36 < M Initial program 84.6%
Simplified79.9%
Taylor expanded in h around 0
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6437.9%
Simplified37.9%
Taylor expanded in D around inf
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6419.2%
Simplified19.2%
associate-*r/N/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*r*N/A
associate-*r/N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
Applied egg-rr25.9%
times-fracN/A
times-fracN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6427.6%
Applied egg-rr27.6%
Final simplification61.4%
D_m = (fabs.f64 D) d_m = (fabs.f64 d) NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function. (FPCore (w0 M D_m h l d_m) :precision binary64 w0)
D_m = fabs(D);
d_m = fabs(d);
assert(w0 < M && M < D_m && D_m < h && h < l && l < d_m);
double code(double w0, double M, double D_m, double h, double l, double d_m) {
return w0;
}
D_m = abs(d)
d_m = abs(d)
NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function.
real(8) function code(w0, m, d_m, h, l, d_m_1)
real(8), intent (in) :: w0
real(8), intent (in) :: 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);
assert w0 < M && M < D_m && D_m < h && h < l && l < d_m;
public static double code(double w0, double M, double D_m, double h, double l, double d_m) {
return w0;
}
D_m = math.fabs(D) d_m = math.fabs(d) [w0, M, D_m, h, l, d_m] = sort([w0, M, D_m, h, l, d_m]) def code(w0, M, D_m, h, l, d_m): return w0
D_m = abs(D) d_m = abs(d) w0, M, D_m, h, l, d_m = sort([w0, M, D_m, h, l, d_m]) function code(w0, M, D_m, h, l, d_m) return w0 end
D_m = abs(D);
d_m = abs(d);
w0, M, D_m, h, l, d_m = num2cell(sort([w0, M, D_m, h, l, d_m])){:}
function tmp = code(w0, M, D_m, h, l, d_m)
tmp = w0;
end
D_m = N[Abs[D], $MachinePrecision] d_m = N[Abs[d], $MachinePrecision] NOTE: w0, M, D_m, h, l, and d_m should be sorted in increasing order before calling this function. code[w0_, M_, D$95$m_, h_, l_, d$95$m_] := w0
\begin{array}{l}
D_m = \left|D\right|
\\
d_m = \left|d\right|
\\
[w0, M, D_m, h, l, d_m] = \mathsf{sort}([w0, M, D_m, h, l, d_m])\\
\\
w0
\end{array}
Initial program 82.6%
Simplified84.8%
Taylor expanded in h around 0
Simplified68.4%
herbie shell --seed 2024145
(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))))))