
(FPCore (d h l M D) :precision binary64 (* (* (pow (/ d h) (/ 1.0 2.0)) (pow (/ d l) (/ 1.0 2.0))) (- 1.0 (* (* (/ 1.0 2.0) (pow (/ (* M D) (* 2.0 d)) 2.0)) (/ h l)))))
double code(double d, double h, double l, double M, double D) {
return (pow((d / h), (1.0 / 2.0)) * pow((d / l), (1.0 / 2.0))) * (1.0 - (((1.0 / 2.0) * pow(((M * D) / (2.0 * d)), 2.0)) * (h / l)));
}
real(8) function code(d, h, l, m, d_1)
real(8), intent (in) :: d
real(8), intent (in) :: h
real(8), intent (in) :: l
real(8), intent (in) :: m
real(8), intent (in) :: d_1
code = (((d / h) ** (1.0d0 / 2.0d0)) * ((d / l) ** (1.0d0 / 2.0d0))) * (1.0d0 - (((1.0d0 / 2.0d0) * (((m * d_1) / (2.0d0 * d)) ** 2.0d0)) * (h / l)))
end function
public static double code(double d, double h, double l, double M, double D) {
return (Math.pow((d / h), (1.0 / 2.0)) * Math.pow((d / l), (1.0 / 2.0))) * (1.0 - (((1.0 / 2.0) * Math.pow(((M * D) / (2.0 * d)), 2.0)) * (h / l)));
}
def code(d, h, l, M, D): return (math.pow((d / h), (1.0 / 2.0)) * math.pow((d / l), (1.0 / 2.0))) * (1.0 - (((1.0 / 2.0) * math.pow(((M * D) / (2.0 * d)), 2.0)) * (h / l)))
function code(d, h, l, M, D) return Float64(Float64((Float64(d / h) ^ Float64(1.0 / 2.0)) * (Float64(d / l) ^ Float64(1.0 / 2.0))) * Float64(1.0 - Float64(Float64(Float64(1.0 / 2.0) * (Float64(Float64(M * D) / Float64(2.0 * d)) ^ 2.0)) * Float64(h / l)))) end
function tmp = code(d, h, l, M, D) tmp = (((d / h) ^ (1.0 / 2.0)) * ((d / l) ^ (1.0 / 2.0))) * (1.0 - (((1.0 / 2.0) * (((M * D) / (2.0 * d)) ^ 2.0)) * (h / l))); end
code[d_, h_, l_, M_, D_] := N[(N[(N[Power[N[(d / h), $MachinePrecision], N[(1.0 / 2.0), $MachinePrecision]], $MachinePrecision] * N[Power[N[(d / l), $MachinePrecision], N[(1.0 / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(1.0 - N[(N[(N[(1.0 / 2.0), $MachinePrecision] * N[Power[N[(N[(M * D), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(h / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left({\left(\frac{d}{h}\right)}^{\left(\frac{1}{2}\right)} \cdot {\left(\frac{d}{\ell}\right)}^{\left(\frac{1}{2}\right)}\right) \cdot \left(1 - \left(\frac{1}{2} \cdot {\left(\frac{M \cdot D}{2 \cdot d}\right)}^{2}\right) \cdot \frac{h}{\ell}\right)
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 26 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (d h l M D) :precision binary64 (* (* (pow (/ d h) (/ 1.0 2.0)) (pow (/ d l) (/ 1.0 2.0))) (- 1.0 (* (* (/ 1.0 2.0) (pow (/ (* M D) (* 2.0 d)) 2.0)) (/ h l)))))
double code(double d, double h, double l, double M, double D) {
return (pow((d / h), (1.0 / 2.0)) * pow((d / l), (1.0 / 2.0))) * (1.0 - (((1.0 / 2.0) * pow(((M * D) / (2.0 * d)), 2.0)) * (h / l)));
}
real(8) function code(d, h, l, m, d_1)
real(8), intent (in) :: d
real(8), intent (in) :: h
real(8), intent (in) :: l
real(8), intent (in) :: m
real(8), intent (in) :: d_1
code = (((d / h) ** (1.0d0 / 2.0d0)) * ((d / l) ** (1.0d0 / 2.0d0))) * (1.0d0 - (((1.0d0 / 2.0d0) * (((m * d_1) / (2.0d0 * d)) ** 2.0d0)) * (h / l)))
end function
public static double code(double d, double h, double l, double M, double D) {
return (Math.pow((d / h), (1.0 / 2.0)) * Math.pow((d / l), (1.0 / 2.0))) * (1.0 - (((1.0 / 2.0) * Math.pow(((M * D) / (2.0 * d)), 2.0)) * (h / l)));
}
def code(d, h, l, M, D): return (math.pow((d / h), (1.0 / 2.0)) * math.pow((d / l), (1.0 / 2.0))) * (1.0 - (((1.0 / 2.0) * math.pow(((M * D) / (2.0 * d)), 2.0)) * (h / l)))
function code(d, h, l, M, D) return Float64(Float64((Float64(d / h) ^ Float64(1.0 / 2.0)) * (Float64(d / l) ^ Float64(1.0 / 2.0))) * Float64(1.0 - Float64(Float64(Float64(1.0 / 2.0) * (Float64(Float64(M * D) / Float64(2.0 * d)) ^ 2.0)) * Float64(h / l)))) end
function tmp = code(d, h, l, M, D) tmp = (((d / h) ^ (1.0 / 2.0)) * ((d / l) ^ (1.0 / 2.0))) * (1.0 - (((1.0 / 2.0) * (((M * D) / (2.0 * d)) ^ 2.0)) * (h / l))); end
code[d_, h_, l_, M_, D_] := N[(N[(N[Power[N[(d / h), $MachinePrecision], N[(1.0 / 2.0), $MachinePrecision]], $MachinePrecision] * N[Power[N[(d / l), $MachinePrecision], N[(1.0 / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(1.0 - N[(N[(N[(1.0 / 2.0), $MachinePrecision] * N[Power[N[(N[(M * D), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[(h / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left({\left(\frac{d}{h}\right)}^{\left(\frac{1}{2}\right)} \cdot {\left(\frac{d}{\ell}\right)}^{\left(\frac{1}{2}\right)}\right) \cdot \left(1 - \left(\frac{1}{2} \cdot {\left(\frac{M \cdot D}{2 \cdot d}\right)}^{2}\right) \cdot \frac{h}{\ell}\right)
\end{array}
M_m = (fabs.f64 M)
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
(FPCore (d h l M_m D)
:precision binary64
(let* ((t_0 (* M_m (* D 0.25))) (t_1 (* (* (/ 0.5 d) D) M_m)))
(if (<= d -5e-310)
(*
(- 1.0 (* (/ t_1 (/ 1.0 h)) (/ (/ t_0 d) l)))
(* (/ (sqrt (- d)) (sqrt (- l))) (pow (/ d h) (/ 1.0 2.0))))
(/ (* (fma (* t_1 (/ t_0 (* (- l) d))) h 1.0) d) (* (sqrt h) (sqrt l))))))M_m = fabs(M);
assert(d < h && h < l && l < M_m && M_m < D);
double code(double d, double h, double l, double M_m, double D) {
double t_0 = M_m * (D * 0.25);
double t_1 = ((0.5 / d) * D) * M_m;
double tmp;
if (d <= -5e-310) {
tmp = (1.0 - ((t_1 / (1.0 / h)) * ((t_0 / d) / l))) * ((sqrt(-d) / sqrt(-l)) * pow((d / h), (1.0 / 2.0)));
} else {
tmp = (fma((t_1 * (t_0 / (-l * d))), h, 1.0) * d) / (sqrt(h) * sqrt(l));
}
return tmp;
}
M_m = abs(M) d, h, l, M_m, D = sort([d, h, l, M_m, D]) function code(d, h, l, M_m, D) t_0 = Float64(M_m * Float64(D * 0.25)) t_1 = Float64(Float64(Float64(0.5 / d) * D) * M_m) tmp = 0.0 if (d <= -5e-310) tmp = Float64(Float64(1.0 - Float64(Float64(t_1 / Float64(1.0 / h)) * Float64(Float64(t_0 / d) / l))) * Float64(Float64(sqrt(Float64(-d)) / sqrt(Float64(-l))) * (Float64(d / h) ^ Float64(1.0 / 2.0)))); else tmp = Float64(Float64(fma(Float64(t_1 * Float64(t_0 / Float64(Float64(-l) * d))), h, 1.0) * d) / Float64(sqrt(h) * sqrt(l))); end return tmp end
M_m = N[Abs[M], $MachinePrecision]
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
code[d_, h_, l_, M$95$m_, D_] := Block[{t$95$0 = N[(M$95$m * N[(D * 0.25), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(N[(0.5 / d), $MachinePrecision] * D), $MachinePrecision] * M$95$m), $MachinePrecision]}, If[LessEqual[d, -5e-310], N[(N[(1.0 - N[(N[(t$95$1 / N[(1.0 / h), $MachinePrecision]), $MachinePrecision] * N[(N[(t$95$0 / d), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(N[Sqrt[(-d)], $MachinePrecision] / N[Sqrt[(-l)], $MachinePrecision]), $MachinePrecision] * N[Power[N[(d / h), $MachinePrecision], N[(1.0 / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[(t$95$1 * N[(t$95$0 / N[((-l) * d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * h + 1.0), $MachinePrecision] * d), $MachinePrecision] / N[(N[Sqrt[h], $MachinePrecision] * N[Sqrt[l], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
M_m = \left|M\right|
\\
[d, h, l, M_m, D] = \mathsf{sort}([d, h, l, M_m, D])\\
\\
\begin{array}{l}
t_0 := M\_m \cdot \left(D \cdot 0.25\right)\\
t_1 := \left(\frac{0.5}{d} \cdot D\right) \cdot M\_m\\
\mathbf{if}\;d \leq -5 \cdot 10^{-310}:\\
\;\;\;\;\left(1 - \frac{t\_1}{\frac{1}{h}} \cdot \frac{\frac{t\_0}{d}}{\ell}\right) \cdot \left(\frac{\sqrt{-d}}{\sqrt{-\ell}} \cdot {\left(\frac{d}{h}\right)}^{\left(\frac{1}{2}\right)}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\mathsf{fma}\left(t\_1 \cdot \frac{t\_0}{\left(-\ell\right) \cdot d}, h, 1\right) \cdot d}{\sqrt{h} \cdot \sqrt{\ell}}\\
\end{array}
\end{array}
if d < -4.999999999999985e-310Initial program 72.4%
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
un-div-invN/A
lift-*.f64N/A
lift-pow.f64N/A
unpow2N/A
associate-*r*N/A
div-invN/A
times-fracN/A
lower-*.f64N/A
Applied rewrites76.2%
lift-/.f64N/A
metadata-eval76.2
lift-pow.f64N/A
unpow1/2N/A
lower-sqrt.f6476.2
Applied rewrites76.2%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
metadata-evalN/A
lift-*.f64N/A
lift-*.f64N/A
lower-/.f6476.8
Applied rewrites76.8%
lift-sqrt.f64N/A
lift-/.f64N/A
frac-2negN/A
lift-neg.f64N/A
lift-neg.f64N/A
sqrt-divN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
lower-/.f6486.0
Applied rewrites86.0%
if -4.999999999999985e-310 < d Initial program 73.0%
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
un-div-invN/A
lift-*.f64N/A
lift-pow.f64N/A
unpow2N/A
associate-*r*N/A
div-invN/A
times-fracN/A
lower-*.f64N/A
Applied rewrites71.3%
Applied rewrites62.4%
lift-sqrt.f64N/A
lift-*.f64N/A
sqrt-prodN/A
pow1/2N/A
lower-*.f64N/A
pow1/2N/A
lower-sqrt.f64N/A
lower-sqrt.f6481.1
Applied rewrites81.1%
Final simplification83.8%
M_m = (fabs.f64 M)
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
(FPCore (d h l M_m D)
:precision binary64
(let* ((t_0
(*
(- 1.0 (* (/ h l) (* (pow (/ (* M_m D) (* 2.0 d)) 2.0) (/ 1.0 2.0))))
(* (pow (/ d l) (/ 1.0 2.0)) (pow (/ d h) (/ 1.0 2.0)))))
(t_1 (sqrt (/ d h)))
(t_2 (sqrt (/ d l)))
(t_3 (fabs (/ d (sqrt (* l h))))))
(if (<= t_0 -1e-167)
(*
(*
(fma (/ (* -0.25 (* M_m D)) (* l d)) (* (* (* (/ 0.5 d) D) M_m) h) 1.0)
t_1)
t_2)
(if (<= t_0 0.0) t_3 (if (<= t_0 2e+264) (* t_2 t_1) t_3)))))M_m = fabs(M);
assert(d < h && h < l && l < M_m && M_m < D);
double code(double d, double h, double l, double M_m, double D) {
double t_0 = (1.0 - ((h / l) * (pow(((M_m * D) / (2.0 * d)), 2.0) * (1.0 / 2.0)))) * (pow((d / l), (1.0 / 2.0)) * pow((d / h), (1.0 / 2.0)));
double t_1 = sqrt((d / h));
double t_2 = sqrt((d / l));
double t_3 = fabs((d / sqrt((l * h))));
double tmp;
if (t_0 <= -1e-167) {
tmp = (fma(((-0.25 * (M_m * D)) / (l * d)), ((((0.5 / d) * D) * M_m) * h), 1.0) * t_1) * t_2;
} else if (t_0 <= 0.0) {
tmp = t_3;
} else if (t_0 <= 2e+264) {
tmp = t_2 * t_1;
} else {
tmp = t_3;
}
return tmp;
}
M_m = abs(M) d, h, l, M_m, D = sort([d, h, l, M_m, D]) function code(d, h, l, M_m, D) t_0 = Float64(Float64(1.0 - Float64(Float64(h / l) * Float64((Float64(Float64(M_m * D) / Float64(2.0 * d)) ^ 2.0) * Float64(1.0 / 2.0)))) * Float64((Float64(d / l) ^ Float64(1.0 / 2.0)) * (Float64(d / h) ^ Float64(1.0 / 2.0)))) t_1 = sqrt(Float64(d / h)) t_2 = sqrt(Float64(d / l)) t_3 = abs(Float64(d / sqrt(Float64(l * h)))) tmp = 0.0 if (t_0 <= -1e-167) tmp = Float64(Float64(fma(Float64(Float64(-0.25 * Float64(M_m * D)) / Float64(l * d)), Float64(Float64(Float64(Float64(0.5 / d) * D) * M_m) * h), 1.0) * t_1) * t_2); elseif (t_0 <= 0.0) tmp = t_3; elseif (t_0 <= 2e+264) tmp = Float64(t_2 * t_1); else tmp = t_3; end return tmp end
M_m = N[Abs[M], $MachinePrecision]
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
code[d_, h_, l_, M$95$m_, D_] := Block[{t$95$0 = N[(N[(1.0 - N[(N[(h / l), $MachinePrecision] * N[(N[Power[N[(N[(M$95$m * D), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] * N[(1.0 / 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[Power[N[(d / l), $MachinePrecision], N[(1.0 / 2.0), $MachinePrecision]], $MachinePrecision] * N[Power[N[(d / h), $MachinePrecision], N[(1.0 / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[Sqrt[N[(d / h), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[Sqrt[N[(d / l), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$3 = N[Abs[N[(d / N[Sqrt[N[(l * h), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[t$95$0, -1e-167], N[(N[(N[(N[(N[(-0.25 * N[(M$95$m * D), $MachinePrecision]), $MachinePrecision] / N[(l * d), $MachinePrecision]), $MachinePrecision] * N[(N[(N[(N[(0.5 / d), $MachinePrecision] * D), $MachinePrecision] * M$95$m), $MachinePrecision] * h), $MachinePrecision] + 1.0), $MachinePrecision] * t$95$1), $MachinePrecision] * t$95$2), $MachinePrecision], If[LessEqual[t$95$0, 0.0], t$95$3, If[LessEqual[t$95$0, 2e+264], N[(t$95$2 * t$95$1), $MachinePrecision], t$95$3]]]]]]]
\begin{array}{l}
M_m = \left|M\right|
\\
[d, h, l, M_m, D] = \mathsf{sort}([d, h, l, M_m, D])\\
\\
\begin{array}{l}
t_0 := \left(1 - \frac{h}{\ell} \cdot \left({\left(\frac{M\_m \cdot D}{2 \cdot d}\right)}^{2} \cdot \frac{1}{2}\right)\right) \cdot \left({\left(\frac{d}{\ell}\right)}^{\left(\frac{1}{2}\right)} \cdot {\left(\frac{d}{h}\right)}^{\left(\frac{1}{2}\right)}\right)\\
t_1 := \sqrt{\frac{d}{h}}\\
t_2 := \sqrt{\frac{d}{\ell}}\\
t_3 := \left|\frac{d}{\sqrt{\ell \cdot h}}\right|\\
\mathbf{if}\;t\_0 \leq -1 \cdot 10^{-167}:\\
\;\;\;\;\left(\mathsf{fma}\left(\frac{-0.25 \cdot \left(M\_m \cdot D\right)}{\ell \cdot d}, \left(\left(\frac{0.5}{d} \cdot D\right) \cdot M\_m\right) \cdot h, 1\right) \cdot t\_1\right) \cdot t\_2\\
\mathbf{elif}\;t\_0 \leq 0:\\
\;\;\;\;t\_3\\
\mathbf{elif}\;t\_0 \leq 2 \cdot 10^{+264}:\\
\;\;\;\;t\_2 \cdot t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_3\\
\end{array}
\end{array}
if (*.f64 (*.f64 (pow.f64 (/.f64 d h) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64))) (pow.f64 (/.f64 d l) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)))) (-.f64 #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)) (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64))) (/.f64 h l)))) < -1e-167Initial program 88.7%
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
un-div-invN/A
lift-*.f64N/A
lift-pow.f64N/A
unpow2N/A
associate-*r*N/A
div-invN/A
times-fracN/A
lower-*.f64N/A
Applied rewrites89.5%
Applied rewrites30.8%
Applied rewrites84.6%
if -1e-167 < (*.f64 (*.f64 (pow.f64 (/.f64 d h) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64))) (pow.f64 (/.f64 d l) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)))) (-.f64 #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)) (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64))) (/.f64 h l)))) < 0.0 or 2.00000000000000009e264 < (*.f64 (*.f64 (pow.f64 (/.f64 d h) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64))) (pow.f64 (/.f64 d l) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)))) (-.f64 #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)) (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64))) (/.f64 h l)))) Initial program 27.7%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6427.0
Applied rewrites27.0%
Applied rewrites57.1%
if 0.0 < (*.f64 (*.f64 (pow.f64 (/.f64 d h) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64))) (pow.f64 (/.f64 d l) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)))) (-.f64 #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)) (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64))) (/.f64 h l)))) < 2.00000000000000009e264Initial program 99.3%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6431.0
Applied rewrites31.0%
Applied rewrites99.0%
Final simplification80.6%
M_m = (fabs.f64 M)
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
(FPCore (d h l M_m D)
:precision binary64
(let* ((t_0
(*
(- 1.0 (* (/ h l) (* (pow (/ (* M_m D) (* 2.0 d)) 2.0) (/ 1.0 2.0))))
(* (pow (/ d l) (/ 1.0 2.0)) (pow (/ d h) (/ 1.0 2.0)))))
(t_1 (sqrt (/ d h)))
(t_2 (sqrt (/ d l)))
(t_3 (fabs (/ d (sqrt (* l h))))))
(if (<= t_0 -1e-167)
(*
(*
(fma (* (/ (* -0.25 (* M_m D)) (* l d)) (* (* (/ 0.5 d) D) M_m)) h 1.0)
t_1)
t_2)
(if (<= t_0 0.0) t_3 (if (<= t_0 2e+264) (* t_2 t_1) t_3)))))M_m = fabs(M);
assert(d < h && h < l && l < M_m && M_m < D);
double code(double d, double h, double l, double M_m, double D) {
double t_0 = (1.0 - ((h / l) * (pow(((M_m * D) / (2.0 * d)), 2.0) * (1.0 / 2.0)))) * (pow((d / l), (1.0 / 2.0)) * pow((d / h), (1.0 / 2.0)));
double t_1 = sqrt((d / h));
double t_2 = sqrt((d / l));
double t_3 = fabs((d / sqrt((l * h))));
double tmp;
if (t_0 <= -1e-167) {
tmp = (fma((((-0.25 * (M_m * D)) / (l * d)) * (((0.5 / d) * D) * M_m)), h, 1.0) * t_1) * t_2;
} else if (t_0 <= 0.0) {
tmp = t_3;
} else if (t_0 <= 2e+264) {
tmp = t_2 * t_1;
} else {
tmp = t_3;
}
return tmp;
}
M_m = abs(M) d, h, l, M_m, D = sort([d, h, l, M_m, D]) function code(d, h, l, M_m, D) t_0 = Float64(Float64(1.0 - Float64(Float64(h / l) * Float64((Float64(Float64(M_m * D) / Float64(2.0 * d)) ^ 2.0) * Float64(1.0 / 2.0)))) * Float64((Float64(d / l) ^ Float64(1.0 / 2.0)) * (Float64(d / h) ^ Float64(1.0 / 2.0)))) t_1 = sqrt(Float64(d / h)) t_2 = sqrt(Float64(d / l)) t_3 = abs(Float64(d / sqrt(Float64(l * h)))) tmp = 0.0 if (t_0 <= -1e-167) tmp = Float64(Float64(fma(Float64(Float64(Float64(-0.25 * Float64(M_m * D)) / Float64(l * d)) * Float64(Float64(Float64(0.5 / d) * D) * M_m)), h, 1.0) * t_1) * t_2); elseif (t_0 <= 0.0) tmp = t_3; elseif (t_0 <= 2e+264) tmp = Float64(t_2 * t_1); else tmp = t_3; end return tmp end
M_m = N[Abs[M], $MachinePrecision]
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
code[d_, h_, l_, M$95$m_, D_] := Block[{t$95$0 = N[(N[(1.0 - N[(N[(h / l), $MachinePrecision] * N[(N[Power[N[(N[(M$95$m * D), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] * N[(1.0 / 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[Power[N[(d / l), $MachinePrecision], N[(1.0 / 2.0), $MachinePrecision]], $MachinePrecision] * N[Power[N[(d / h), $MachinePrecision], N[(1.0 / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[Sqrt[N[(d / h), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[Sqrt[N[(d / l), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$3 = N[Abs[N[(d / N[Sqrt[N[(l * h), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[t$95$0, -1e-167], N[(N[(N[(N[(N[(N[(-0.25 * N[(M$95$m * D), $MachinePrecision]), $MachinePrecision] / N[(l * d), $MachinePrecision]), $MachinePrecision] * N[(N[(N[(0.5 / d), $MachinePrecision] * D), $MachinePrecision] * M$95$m), $MachinePrecision]), $MachinePrecision] * h + 1.0), $MachinePrecision] * t$95$1), $MachinePrecision] * t$95$2), $MachinePrecision], If[LessEqual[t$95$0, 0.0], t$95$3, If[LessEqual[t$95$0, 2e+264], N[(t$95$2 * t$95$1), $MachinePrecision], t$95$3]]]]]]]
\begin{array}{l}
M_m = \left|M\right|
\\
[d, h, l, M_m, D] = \mathsf{sort}([d, h, l, M_m, D])\\
\\
\begin{array}{l}
t_0 := \left(1 - \frac{h}{\ell} \cdot \left({\left(\frac{M\_m \cdot D}{2 \cdot d}\right)}^{2} \cdot \frac{1}{2}\right)\right) \cdot \left({\left(\frac{d}{\ell}\right)}^{\left(\frac{1}{2}\right)} \cdot {\left(\frac{d}{h}\right)}^{\left(\frac{1}{2}\right)}\right)\\
t_1 := \sqrt{\frac{d}{h}}\\
t_2 := \sqrt{\frac{d}{\ell}}\\
t_3 := \left|\frac{d}{\sqrt{\ell \cdot h}}\right|\\
\mathbf{if}\;t\_0 \leq -1 \cdot 10^{-167}:\\
\;\;\;\;\left(\mathsf{fma}\left(\frac{-0.25 \cdot \left(M\_m \cdot D\right)}{\ell \cdot d} \cdot \left(\left(\frac{0.5}{d} \cdot D\right) \cdot M\_m\right), h, 1\right) \cdot t\_1\right) \cdot t\_2\\
\mathbf{elif}\;t\_0 \leq 0:\\
\;\;\;\;t\_3\\
\mathbf{elif}\;t\_0 \leq 2 \cdot 10^{+264}:\\
\;\;\;\;t\_2 \cdot t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_3\\
\end{array}
\end{array}
if (*.f64 (*.f64 (pow.f64 (/.f64 d h) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64))) (pow.f64 (/.f64 d l) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)))) (-.f64 #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)) (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64))) (/.f64 h l)))) < -1e-167Initial program 88.7%
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
un-div-invN/A
lift-*.f64N/A
lift-pow.f64N/A
unpow2N/A
associate-*r*N/A
div-invN/A
times-fracN/A
lower-*.f64N/A
Applied rewrites89.5%
lift-/.f64N/A
metadata-eval89.5
lift-pow.f64N/A
unpow1/2N/A
lower-sqrt.f6489.5
Applied rewrites89.5%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
metadata-evalN/A
lift-*.f64N/A
lift-*.f64N/A
lower-/.f6490.6
Applied rewrites90.6%
Applied rewrites83.5%
if -1e-167 < (*.f64 (*.f64 (pow.f64 (/.f64 d h) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64))) (pow.f64 (/.f64 d l) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)))) (-.f64 #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)) (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64))) (/.f64 h l)))) < 0.0 or 2.00000000000000009e264 < (*.f64 (*.f64 (pow.f64 (/.f64 d h) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64))) (pow.f64 (/.f64 d l) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)))) (-.f64 #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)) (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64))) (/.f64 h l)))) Initial program 27.7%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6427.0
Applied rewrites27.0%
Applied rewrites57.1%
if 0.0 < (*.f64 (*.f64 (pow.f64 (/.f64 d h) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64))) (pow.f64 (/.f64 d l) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)))) (-.f64 #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)) (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64))) (/.f64 h l)))) < 2.00000000000000009e264Initial program 99.3%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6431.0
Applied rewrites31.0%
Applied rewrites99.0%
Final simplification80.2%
M_m = (fabs.f64 M)
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
(FPCore (d h l M_m D)
:precision binary64
(let* ((t_0
(*
(- 1.0 (* (/ h l) (* (pow (/ (* M_m D) (* 2.0 d)) 2.0) (/ 1.0 2.0))))
(* (pow (/ d l) (/ 1.0 2.0)) (pow (/ d h) (/ 1.0 2.0)))))
(t_1 (fabs (/ d (sqrt (* l h))))))
(if (<= t_0 -1e+93)
(* (* (/ (* M_m M_m) d) (* 0.125 (* D D))) (sqrt (/ h (* (* l l) l))))
(if (<= t_0 0.0)
t_1
(if (<= t_0 2e+264) (* (sqrt (/ d l)) (sqrt (/ d h))) t_1)))))M_m = fabs(M);
assert(d < h && h < l && l < M_m && M_m < D);
double code(double d, double h, double l, double M_m, double D) {
double t_0 = (1.0 - ((h / l) * (pow(((M_m * D) / (2.0 * d)), 2.0) * (1.0 / 2.0)))) * (pow((d / l), (1.0 / 2.0)) * pow((d / h), (1.0 / 2.0)));
double t_1 = fabs((d / sqrt((l * h))));
double tmp;
if (t_0 <= -1e+93) {
tmp = (((M_m * M_m) / d) * (0.125 * (D * D))) * sqrt((h / ((l * l) * l)));
} else if (t_0 <= 0.0) {
tmp = t_1;
} else if (t_0 <= 2e+264) {
tmp = sqrt((d / l)) * sqrt((d / h));
} else {
tmp = t_1;
}
return tmp;
}
M_m = abs(m)
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
real(8) function code(d, h, l, m_m, d_1)
real(8), intent (in) :: d
real(8), intent (in) :: h
real(8), intent (in) :: l
real(8), intent (in) :: m_m
real(8), intent (in) :: d_1
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = (1.0d0 - ((h / l) * ((((m_m * d_1) / (2.0d0 * d)) ** 2.0d0) * (1.0d0 / 2.0d0)))) * (((d / l) ** (1.0d0 / 2.0d0)) * ((d / h) ** (1.0d0 / 2.0d0)))
t_1 = abs((d / sqrt((l * h))))
if (t_0 <= (-1d+93)) then
tmp = (((m_m * m_m) / d) * (0.125d0 * (d_1 * d_1))) * sqrt((h / ((l * l) * l)))
else if (t_0 <= 0.0d0) then
tmp = t_1
else if (t_0 <= 2d+264) then
tmp = sqrt((d / l)) * sqrt((d / h))
else
tmp = t_1
end if
code = tmp
end function
M_m = Math.abs(M);
assert d < h && h < l && l < M_m && M_m < D;
public static double code(double d, double h, double l, double M_m, double D) {
double t_0 = (1.0 - ((h / l) * (Math.pow(((M_m * D) / (2.0 * d)), 2.0) * (1.0 / 2.0)))) * (Math.pow((d / l), (1.0 / 2.0)) * Math.pow((d / h), (1.0 / 2.0)));
double t_1 = Math.abs((d / Math.sqrt((l * h))));
double tmp;
if (t_0 <= -1e+93) {
tmp = (((M_m * M_m) / d) * (0.125 * (D * D))) * Math.sqrt((h / ((l * l) * l)));
} else if (t_0 <= 0.0) {
tmp = t_1;
} else if (t_0 <= 2e+264) {
tmp = Math.sqrt((d / l)) * Math.sqrt((d / h));
} else {
tmp = t_1;
}
return tmp;
}
M_m = math.fabs(M) [d, h, l, M_m, D] = sort([d, h, l, M_m, D]) def code(d, h, l, M_m, D): t_0 = (1.0 - ((h / l) * (math.pow(((M_m * D) / (2.0 * d)), 2.0) * (1.0 / 2.0)))) * (math.pow((d / l), (1.0 / 2.0)) * math.pow((d / h), (1.0 / 2.0))) t_1 = math.fabs((d / math.sqrt((l * h)))) tmp = 0 if t_0 <= -1e+93: tmp = (((M_m * M_m) / d) * (0.125 * (D * D))) * math.sqrt((h / ((l * l) * l))) elif t_0 <= 0.0: tmp = t_1 elif t_0 <= 2e+264: tmp = math.sqrt((d / l)) * math.sqrt((d / h)) else: tmp = t_1 return tmp
M_m = abs(M) d, h, l, M_m, D = sort([d, h, l, M_m, D]) function code(d, h, l, M_m, D) t_0 = Float64(Float64(1.0 - Float64(Float64(h / l) * Float64((Float64(Float64(M_m * D) / Float64(2.0 * d)) ^ 2.0) * Float64(1.0 / 2.0)))) * Float64((Float64(d / l) ^ Float64(1.0 / 2.0)) * (Float64(d / h) ^ Float64(1.0 / 2.0)))) t_1 = abs(Float64(d / sqrt(Float64(l * h)))) tmp = 0.0 if (t_0 <= -1e+93) tmp = Float64(Float64(Float64(Float64(M_m * M_m) / d) * Float64(0.125 * Float64(D * D))) * sqrt(Float64(h / Float64(Float64(l * l) * l)))); elseif (t_0 <= 0.0) tmp = t_1; elseif (t_0 <= 2e+264) tmp = Float64(sqrt(Float64(d / l)) * sqrt(Float64(d / h))); else tmp = t_1; end return tmp end
M_m = abs(M);
d, h, l, M_m, D = num2cell(sort([d, h, l, M_m, D])){:}
function tmp_2 = code(d, h, l, M_m, D)
t_0 = (1.0 - ((h / l) * ((((M_m * D) / (2.0 * d)) ^ 2.0) * (1.0 / 2.0)))) * (((d / l) ^ (1.0 / 2.0)) * ((d / h) ^ (1.0 / 2.0)));
t_1 = abs((d / sqrt((l * h))));
tmp = 0.0;
if (t_0 <= -1e+93)
tmp = (((M_m * M_m) / d) * (0.125 * (D * D))) * sqrt((h / ((l * l) * l)));
elseif (t_0 <= 0.0)
tmp = t_1;
elseif (t_0 <= 2e+264)
tmp = sqrt((d / l)) * sqrt((d / h));
else
tmp = t_1;
end
tmp_2 = tmp;
end
M_m = N[Abs[M], $MachinePrecision]
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
code[d_, h_, l_, M$95$m_, D_] := Block[{t$95$0 = N[(N[(1.0 - N[(N[(h / l), $MachinePrecision] * N[(N[Power[N[(N[(M$95$m * D), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] * N[(1.0 / 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[Power[N[(d / l), $MachinePrecision], N[(1.0 / 2.0), $MachinePrecision]], $MachinePrecision] * N[Power[N[(d / h), $MachinePrecision], N[(1.0 / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[Abs[N[(d / N[Sqrt[N[(l * h), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[t$95$0, -1e+93], N[(N[(N[(N[(M$95$m * M$95$m), $MachinePrecision] / d), $MachinePrecision] * N[(0.125 * N[(D * D), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(h / N[(N[(l * l), $MachinePrecision] * l), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, 0.0], t$95$1, If[LessEqual[t$95$0, 2e+264], N[(N[Sqrt[N[(d / l), $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[(d / h), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
M_m = \left|M\right|
\\
[d, h, l, M_m, D] = \mathsf{sort}([d, h, l, M_m, D])\\
\\
\begin{array}{l}
t_0 := \left(1 - \frac{h}{\ell} \cdot \left({\left(\frac{M\_m \cdot D}{2 \cdot d}\right)}^{2} \cdot \frac{1}{2}\right)\right) \cdot \left({\left(\frac{d}{\ell}\right)}^{\left(\frac{1}{2}\right)} \cdot {\left(\frac{d}{h}\right)}^{\left(\frac{1}{2}\right)}\right)\\
t_1 := \left|\frac{d}{\sqrt{\ell \cdot h}}\right|\\
\mathbf{if}\;t\_0 \leq -1 \cdot 10^{+93}:\\
\;\;\;\;\left(\frac{M\_m \cdot M\_m}{d} \cdot \left(0.125 \cdot \left(D \cdot D\right)\right)\right) \cdot \sqrt{\frac{h}{\left(\ell \cdot \ell\right) \cdot \ell}}\\
\mathbf{elif}\;t\_0 \leq 0:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_0 \leq 2 \cdot 10^{+264}:\\
\;\;\;\;\sqrt{\frac{d}{\ell}} \cdot \sqrt{\frac{d}{h}}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 (*.f64 (pow.f64 (/.f64 d h) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64))) (pow.f64 (/.f64 d l) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)))) (-.f64 #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)) (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64))) (/.f64 h l)))) < -1.00000000000000004e93Initial program 88.9%
Taylor expanded in h around -inf
associate-*r*N/A
lower-*.f64N/A
Applied rewrites39.3%
if -1.00000000000000004e93 < (*.f64 (*.f64 (pow.f64 (/.f64 d h) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64))) (pow.f64 (/.f64 d l) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)))) (-.f64 #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)) (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64))) (/.f64 h l)))) < 0.0 or 2.00000000000000009e264 < (*.f64 (*.f64 (pow.f64 (/.f64 d h) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64))) (pow.f64 (/.f64 d l) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)))) (-.f64 #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)) (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64))) (/.f64 h l)))) Initial program 30.3%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6425.9
Applied rewrites25.9%
Applied rewrites54.6%
if 0.0 < (*.f64 (*.f64 (pow.f64 (/.f64 d h) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64))) (pow.f64 (/.f64 d l) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)))) (-.f64 #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)) (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64))) (/.f64 h l)))) < 2.00000000000000009e264Initial program 99.3%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6431.0
Applied rewrites31.0%
Applied rewrites99.0%
Final simplification64.3%
M_m = (fabs.f64 M)
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
(FPCore (d h l M_m D)
:precision binary64
(let* ((t_0
(*
(- 1.0 (* (/ h l) (* (pow (/ (* M_m D) (* 2.0 d)) 2.0) (/ 1.0 2.0))))
(* (pow (/ d l) (/ 1.0 2.0)) (pow (/ d h) (/ 1.0 2.0)))))
(t_1 (fabs (/ d (sqrt (* l h))))))
(if (<= t_0 -1e+202)
(* (* (/ (* D D) d) (sqrt (/ h (* (* l l) l)))) (* -0.125 (* M_m M_m)))
(if (<= t_0 0.0)
t_1
(if (<= t_0 2e+264) (* (sqrt (/ d l)) (sqrt (/ d h))) t_1)))))M_m = fabs(M);
assert(d < h && h < l && l < M_m && M_m < D);
double code(double d, double h, double l, double M_m, double D) {
double t_0 = (1.0 - ((h / l) * (pow(((M_m * D) / (2.0 * d)), 2.0) * (1.0 / 2.0)))) * (pow((d / l), (1.0 / 2.0)) * pow((d / h), (1.0 / 2.0)));
double t_1 = fabs((d / sqrt((l * h))));
double tmp;
if (t_0 <= -1e+202) {
tmp = (((D * D) / d) * sqrt((h / ((l * l) * l)))) * (-0.125 * (M_m * M_m));
} else if (t_0 <= 0.0) {
tmp = t_1;
} else if (t_0 <= 2e+264) {
tmp = sqrt((d / l)) * sqrt((d / h));
} else {
tmp = t_1;
}
return tmp;
}
M_m = abs(m)
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
real(8) function code(d, h, l, m_m, d_1)
real(8), intent (in) :: d
real(8), intent (in) :: h
real(8), intent (in) :: l
real(8), intent (in) :: m_m
real(8), intent (in) :: d_1
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = (1.0d0 - ((h / l) * ((((m_m * d_1) / (2.0d0 * d)) ** 2.0d0) * (1.0d0 / 2.0d0)))) * (((d / l) ** (1.0d0 / 2.0d0)) * ((d / h) ** (1.0d0 / 2.0d0)))
t_1 = abs((d / sqrt((l * h))))
if (t_0 <= (-1d+202)) then
tmp = (((d_1 * d_1) / d) * sqrt((h / ((l * l) * l)))) * ((-0.125d0) * (m_m * m_m))
else if (t_0 <= 0.0d0) then
tmp = t_1
else if (t_0 <= 2d+264) then
tmp = sqrt((d / l)) * sqrt((d / h))
else
tmp = t_1
end if
code = tmp
end function
M_m = Math.abs(M);
assert d < h && h < l && l < M_m && M_m < D;
public static double code(double d, double h, double l, double M_m, double D) {
double t_0 = (1.0 - ((h / l) * (Math.pow(((M_m * D) / (2.0 * d)), 2.0) * (1.0 / 2.0)))) * (Math.pow((d / l), (1.0 / 2.0)) * Math.pow((d / h), (1.0 / 2.0)));
double t_1 = Math.abs((d / Math.sqrt((l * h))));
double tmp;
if (t_0 <= -1e+202) {
tmp = (((D * D) / d) * Math.sqrt((h / ((l * l) * l)))) * (-0.125 * (M_m * M_m));
} else if (t_0 <= 0.0) {
tmp = t_1;
} else if (t_0 <= 2e+264) {
tmp = Math.sqrt((d / l)) * Math.sqrt((d / h));
} else {
tmp = t_1;
}
return tmp;
}
M_m = math.fabs(M) [d, h, l, M_m, D] = sort([d, h, l, M_m, D]) def code(d, h, l, M_m, D): t_0 = (1.0 - ((h / l) * (math.pow(((M_m * D) / (2.0 * d)), 2.0) * (1.0 / 2.0)))) * (math.pow((d / l), (1.0 / 2.0)) * math.pow((d / h), (1.0 / 2.0))) t_1 = math.fabs((d / math.sqrt((l * h)))) tmp = 0 if t_0 <= -1e+202: tmp = (((D * D) / d) * math.sqrt((h / ((l * l) * l)))) * (-0.125 * (M_m * M_m)) elif t_0 <= 0.0: tmp = t_1 elif t_0 <= 2e+264: tmp = math.sqrt((d / l)) * math.sqrt((d / h)) else: tmp = t_1 return tmp
M_m = abs(M) d, h, l, M_m, D = sort([d, h, l, M_m, D]) function code(d, h, l, M_m, D) t_0 = Float64(Float64(1.0 - Float64(Float64(h / l) * Float64((Float64(Float64(M_m * D) / Float64(2.0 * d)) ^ 2.0) * Float64(1.0 / 2.0)))) * Float64((Float64(d / l) ^ Float64(1.0 / 2.0)) * (Float64(d / h) ^ Float64(1.0 / 2.0)))) t_1 = abs(Float64(d / sqrt(Float64(l * h)))) tmp = 0.0 if (t_0 <= -1e+202) tmp = Float64(Float64(Float64(Float64(D * D) / d) * sqrt(Float64(h / Float64(Float64(l * l) * l)))) * Float64(-0.125 * Float64(M_m * M_m))); elseif (t_0 <= 0.0) tmp = t_1; elseif (t_0 <= 2e+264) tmp = Float64(sqrt(Float64(d / l)) * sqrt(Float64(d / h))); else tmp = t_1; end return tmp end
M_m = abs(M);
d, h, l, M_m, D = num2cell(sort([d, h, l, M_m, D])){:}
function tmp_2 = code(d, h, l, M_m, D)
t_0 = (1.0 - ((h / l) * ((((M_m * D) / (2.0 * d)) ^ 2.0) * (1.0 / 2.0)))) * (((d / l) ^ (1.0 / 2.0)) * ((d / h) ^ (1.0 / 2.0)));
t_1 = abs((d / sqrt((l * h))));
tmp = 0.0;
if (t_0 <= -1e+202)
tmp = (((D * D) / d) * sqrt((h / ((l * l) * l)))) * (-0.125 * (M_m * M_m));
elseif (t_0 <= 0.0)
tmp = t_1;
elseif (t_0 <= 2e+264)
tmp = sqrt((d / l)) * sqrt((d / h));
else
tmp = t_1;
end
tmp_2 = tmp;
end
M_m = N[Abs[M], $MachinePrecision]
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
code[d_, h_, l_, M$95$m_, D_] := Block[{t$95$0 = N[(N[(1.0 - N[(N[(h / l), $MachinePrecision] * N[(N[Power[N[(N[(M$95$m * D), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] * N[(1.0 / 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[Power[N[(d / l), $MachinePrecision], N[(1.0 / 2.0), $MachinePrecision]], $MachinePrecision] * N[Power[N[(d / h), $MachinePrecision], N[(1.0 / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[Abs[N[(d / N[Sqrt[N[(l * h), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[t$95$0, -1e+202], N[(N[(N[(N[(D * D), $MachinePrecision] / d), $MachinePrecision] * N[Sqrt[N[(h / N[(N[(l * l), $MachinePrecision] * l), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(-0.125 * N[(M$95$m * M$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, 0.0], t$95$1, If[LessEqual[t$95$0, 2e+264], N[(N[Sqrt[N[(d / l), $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[(d / h), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
M_m = \left|M\right|
\\
[d, h, l, M_m, D] = \mathsf{sort}([d, h, l, M_m, D])\\
\\
\begin{array}{l}
t_0 := \left(1 - \frac{h}{\ell} \cdot \left({\left(\frac{M\_m \cdot D}{2 \cdot d}\right)}^{2} \cdot \frac{1}{2}\right)\right) \cdot \left({\left(\frac{d}{\ell}\right)}^{\left(\frac{1}{2}\right)} \cdot {\left(\frac{d}{h}\right)}^{\left(\frac{1}{2}\right)}\right)\\
t_1 := \left|\frac{d}{\sqrt{\ell \cdot h}}\right|\\
\mathbf{if}\;t\_0 \leq -1 \cdot 10^{+202}:\\
\;\;\;\;\left(\frac{D \cdot D}{d} \cdot \sqrt{\frac{h}{\left(\ell \cdot \ell\right) \cdot \ell}}\right) \cdot \left(-0.125 \cdot \left(M\_m \cdot M\_m\right)\right)\\
\mathbf{elif}\;t\_0 \leq 0:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_0 \leq 2 \cdot 10^{+264}:\\
\;\;\;\;\sqrt{\frac{d}{\ell}} \cdot \sqrt{\frac{d}{h}}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 (*.f64 (pow.f64 (/.f64 d h) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64))) (pow.f64 (/.f64 d l) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)))) (-.f64 #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)) (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64))) (/.f64 h l)))) < -9.999999999999999e201Initial program 88.6%
Taylor expanded in d around 0
associate-*l/N/A
*-commutativeN/A
associate-*r*N/A
associate-*l/N/A
associate-*r/N/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower-*.f64N/A
Applied rewrites29.5%
if -9.999999999999999e201 < (*.f64 (*.f64 (pow.f64 (/.f64 d h) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64))) (pow.f64 (/.f64 d l) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)))) (-.f64 #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)) (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64))) (/.f64 h l)))) < 0.0 or 2.00000000000000009e264 < (*.f64 (*.f64 (pow.f64 (/.f64 d h) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64))) (pow.f64 (/.f64 d l) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)))) (-.f64 #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)) (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64))) (/.f64 h l)))) Initial program 32.6%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6425.2
Applied rewrites25.2%
Applied rewrites52.8%
if 0.0 < (*.f64 (*.f64 (pow.f64 (/.f64 d h) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64))) (pow.f64 (/.f64 d l) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)))) (-.f64 #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)) (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64))) (/.f64 h l)))) < 2.00000000000000009e264Initial program 99.3%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6431.0
Applied rewrites31.0%
Applied rewrites99.0%
Final simplification60.7%
M_m = (fabs.f64 M)
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
(FPCore (d h l M_m D)
:precision binary64
(let* ((t_0 (/ -1.0 (* l h)))
(t_1
(*
(- 1.0 (* (/ h l) (* (pow (/ (* M_m D) (* 2.0 d)) 2.0) (/ 1.0 2.0))))
(* (pow (/ d l) (/ 1.0 2.0)) (pow (/ d h) (/ 1.0 2.0)))))
(t_2 (fabs (/ d (sqrt (* l h))))))
(if (<= t_1 -1e-167)
(* (sqrt (sqrt (* t_0 t_0))) d)
(if (<= t_1 0.0)
t_2
(if (<= t_1 2e+264) (* (sqrt (/ d l)) (sqrt (/ d h))) t_2)))))M_m = fabs(M);
assert(d < h && h < l && l < M_m && M_m < D);
double code(double d, double h, double l, double M_m, double D) {
double t_0 = -1.0 / (l * h);
double t_1 = (1.0 - ((h / l) * (pow(((M_m * D) / (2.0 * d)), 2.0) * (1.0 / 2.0)))) * (pow((d / l), (1.0 / 2.0)) * pow((d / h), (1.0 / 2.0)));
double t_2 = fabs((d / sqrt((l * h))));
double tmp;
if (t_1 <= -1e-167) {
tmp = sqrt(sqrt((t_0 * t_0))) * d;
} else if (t_1 <= 0.0) {
tmp = t_2;
} else if (t_1 <= 2e+264) {
tmp = sqrt((d / l)) * sqrt((d / h));
} else {
tmp = t_2;
}
return tmp;
}
M_m = abs(m)
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
real(8) function code(d, h, l, m_m, d_1)
real(8), intent (in) :: d
real(8), intent (in) :: h
real(8), intent (in) :: l
real(8), intent (in) :: m_m
real(8), intent (in) :: d_1
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_0 = (-1.0d0) / (l * h)
t_1 = (1.0d0 - ((h / l) * ((((m_m * d_1) / (2.0d0 * d)) ** 2.0d0) * (1.0d0 / 2.0d0)))) * (((d / l) ** (1.0d0 / 2.0d0)) * ((d / h) ** (1.0d0 / 2.0d0)))
t_2 = abs((d / sqrt((l * h))))
if (t_1 <= (-1d-167)) then
tmp = sqrt(sqrt((t_0 * t_0))) * d
else if (t_1 <= 0.0d0) then
tmp = t_2
else if (t_1 <= 2d+264) then
tmp = sqrt((d / l)) * sqrt((d / h))
else
tmp = t_2
end if
code = tmp
end function
M_m = Math.abs(M);
assert d < h && h < l && l < M_m && M_m < D;
public static double code(double d, double h, double l, double M_m, double D) {
double t_0 = -1.0 / (l * h);
double t_1 = (1.0 - ((h / l) * (Math.pow(((M_m * D) / (2.0 * d)), 2.0) * (1.0 / 2.0)))) * (Math.pow((d / l), (1.0 / 2.0)) * Math.pow((d / h), (1.0 / 2.0)));
double t_2 = Math.abs((d / Math.sqrt((l * h))));
double tmp;
if (t_1 <= -1e-167) {
tmp = Math.sqrt(Math.sqrt((t_0 * t_0))) * d;
} else if (t_1 <= 0.0) {
tmp = t_2;
} else if (t_1 <= 2e+264) {
tmp = Math.sqrt((d / l)) * Math.sqrt((d / h));
} else {
tmp = t_2;
}
return tmp;
}
M_m = math.fabs(M) [d, h, l, M_m, D] = sort([d, h, l, M_m, D]) def code(d, h, l, M_m, D): t_0 = -1.0 / (l * h) t_1 = (1.0 - ((h / l) * (math.pow(((M_m * D) / (2.0 * d)), 2.0) * (1.0 / 2.0)))) * (math.pow((d / l), (1.0 / 2.0)) * math.pow((d / h), (1.0 / 2.0))) t_2 = math.fabs((d / math.sqrt((l * h)))) tmp = 0 if t_1 <= -1e-167: tmp = math.sqrt(math.sqrt((t_0 * t_0))) * d elif t_1 <= 0.0: tmp = t_2 elif t_1 <= 2e+264: tmp = math.sqrt((d / l)) * math.sqrt((d / h)) else: tmp = t_2 return tmp
M_m = abs(M) d, h, l, M_m, D = sort([d, h, l, M_m, D]) function code(d, h, l, M_m, D) t_0 = Float64(-1.0 / Float64(l * h)) t_1 = Float64(Float64(1.0 - Float64(Float64(h / l) * Float64((Float64(Float64(M_m * D) / Float64(2.0 * d)) ^ 2.0) * Float64(1.0 / 2.0)))) * Float64((Float64(d / l) ^ Float64(1.0 / 2.0)) * (Float64(d / h) ^ Float64(1.0 / 2.0)))) t_2 = abs(Float64(d / sqrt(Float64(l * h)))) tmp = 0.0 if (t_1 <= -1e-167) tmp = Float64(sqrt(sqrt(Float64(t_0 * t_0))) * d); elseif (t_1 <= 0.0) tmp = t_2; elseif (t_1 <= 2e+264) tmp = Float64(sqrt(Float64(d / l)) * sqrt(Float64(d / h))); else tmp = t_2; end return tmp end
M_m = abs(M);
d, h, l, M_m, D = num2cell(sort([d, h, l, M_m, D])){:}
function tmp_2 = code(d, h, l, M_m, D)
t_0 = -1.0 / (l * h);
t_1 = (1.0 - ((h / l) * ((((M_m * D) / (2.0 * d)) ^ 2.0) * (1.0 / 2.0)))) * (((d / l) ^ (1.0 / 2.0)) * ((d / h) ^ (1.0 / 2.0)));
t_2 = abs((d / sqrt((l * h))));
tmp = 0.0;
if (t_1 <= -1e-167)
tmp = sqrt(sqrt((t_0 * t_0))) * d;
elseif (t_1 <= 0.0)
tmp = t_2;
elseif (t_1 <= 2e+264)
tmp = sqrt((d / l)) * sqrt((d / h));
else
tmp = t_2;
end
tmp_2 = tmp;
end
M_m = N[Abs[M], $MachinePrecision]
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
code[d_, h_, l_, M$95$m_, D_] := Block[{t$95$0 = N[(-1.0 / N[(l * h), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(1.0 - N[(N[(h / l), $MachinePrecision] * N[(N[Power[N[(N[(M$95$m * D), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] * N[(1.0 / 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[Power[N[(d / l), $MachinePrecision], N[(1.0 / 2.0), $MachinePrecision]], $MachinePrecision] * N[Power[N[(d / h), $MachinePrecision], N[(1.0 / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Abs[N[(d / N[Sqrt[N[(l * h), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[t$95$1, -1e-167], N[(N[Sqrt[N[Sqrt[N[(t$95$0 * t$95$0), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] * d), $MachinePrecision], If[LessEqual[t$95$1, 0.0], t$95$2, If[LessEqual[t$95$1, 2e+264], N[(N[Sqrt[N[(d / l), $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[(d / h), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]
\begin{array}{l}
M_m = \left|M\right|
\\
[d, h, l, M_m, D] = \mathsf{sort}([d, h, l, M_m, D])\\
\\
\begin{array}{l}
t_0 := \frac{-1}{\ell \cdot h}\\
t_1 := \left(1 - \frac{h}{\ell} \cdot \left({\left(\frac{M\_m \cdot D}{2 \cdot d}\right)}^{2} \cdot \frac{1}{2}\right)\right) \cdot \left({\left(\frac{d}{\ell}\right)}^{\left(\frac{1}{2}\right)} \cdot {\left(\frac{d}{h}\right)}^{\left(\frac{1}{2}\right)}\right)\\
t_2 := \left|\frac{d}{\sqrt{\ell \cdot h}}\right|\\
\mathbf{if}\;t\_1 \leq -1 \cdot 10^{-167}:\\
\;\;\;\;\sqrt{\sqrt{t\_0 \cdot t\_0}} \cdot d\\
\mathbf{elif}\;t\_1 \leq 0:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+264}:\\
\;\;\;\;\sqrt{\frac{d}{\ell}} \cdot \sqrt{\frac{d}{h}}\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if (*.f64 (*.f64 (pow.f64 (/.f64 d h) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64))) (pow.f64 (/.f64 d l) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)))) (-.f64 #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)) (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64))) (/.f64 h l)))) < -1e-167Initial program 88.7%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6415.4
Applied rewrites15.4%
Applied rewrites23.0%
if -1e-167 < (*.f64 (*.f64 (pow.f64 (/.f64 d h) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64))) (pow.f64 (/.f64 d l) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)))) (-.f64 #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)) (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64))) (/.f64 h l)))) < 0.0 or 2.00000000000000009e264 < (*.f64 (*.f64 (pow.f64 (/.f64 d h) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64))) (pow.f64 (/.f64 d l) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)))) (-.f64 #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)) (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64))) (/.f64 h l)))) Initial program 27.7%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6427.0
Applied rewrites27.0%
Applied rewrites57.1%
if 0.0 < (*.f64 (*.f64 (pow.f64 (/.f64 d h) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64))) (pow.f64 (/.f64 d l) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)))) (-.f64 #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)) (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64))) (/.f64 h l)))) < 2.00000000000000009e264Initial program 99.3%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6431.0
Applied rewrites31.0%
Applied rewrites99.0%
Final simplification59.2%
M_m = (fabs.f64 M)
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
(FPCore (d h l M_m D)
:precision binary64
(let* ((t_0 (sqrt (* l h)))
(t_1
(*
(- 1.0 (* (/ h l) (* (pow (/ (* M_m D) (* 2.0 d)) 2.0) (/ 1.0 2.0))))
(* (pow (/ d l) (/ 1.0 2.0)) (pow (/ d h) (/ 1.0 2.0)))))
(t_2 (* M_m (* D 0.25)))
(t_3 (* (* M_m D) 0.5)))
(if (<= t_1 2e+264)
(*
(* (sqrt (/ d l)) (sqrt (/ d h)))
(- 1.0 (* (/ (* (* (/ 0.5 d) D) M_m) (/ 1.0 h)) (/ (/ t_2 d) l))))
(if (<= t_1 INFINITY)
(fabs (/ d t_0))
(/
(*
(fma (* (pow (/ (* t_3 t_3) (* d d)) 0.5) (/ t_2 (* (- l) d))) h 1.0)
d)
t_0)))))M_m = fabs(M);
assert(d < h && h < l && l < M_m && M_m < D);
double code(double d, double h, double l, double M_m, double D) {
double t_0 = sqrt((l * h));
double t_1 = (1.0 - ((h / l) * (pow(((M_m * D) / (2.0 * d)), 2.0) * (1.0 / 2.0)))) * (pow((d / l), (1.0 / 2.0)) * pow((d / h), (1.0 / 2.0)));
double t_2 = M_m * (D * 0.25);
double t_3 = (M_m * D) * 0.5;
double tmp;
if (t_1 <= 2e+264) {
tmp = (sqrt((d / l)) * sqrt((d / h))) * (1.0 - (((((0.5 / d) * D) * M_m) / (1.0 / h)) * ((t_2 / d) / l)));
} else if (t_1 <= ((double) INFINITY)) {
tmp = fabs((d / t_0));
} else {
tmp = (fma((pow(((t_3 * t_3) / (d * d)), 0.5) * (t_2 / (-l * d))), h, 1.0) * d) / t_0;
}
return tmp;
}
M_m = abs(M) d, h, l, M_m, D = sort([d, h, l, M_m, D]) function code(d, h, l, M_m, D) t_0 = sqrt(Float64(l * h)) t_1 = Float64(Float64(1.0 - Float64(Float64(h / l) * Float64((Float64(Float64(M_m * D) / Float64(2.0 * d)) ^ 2.0) * Float64(1.0 / 2.0)))) * Float64((Float64(d / l) ^ Float64(1.0 / 2.0)) * (Float64(d / h) ^ Float64(1.0 / 2.0)))) t_2 = Float64(M_m * Float64(D * 0.25)) t_3 = Float64(Float64(M_m * D) * 0.5) tmp = 0.0 if (t_1 <= 2e+264) tmp = Float64(Float64(sqrt(Float64(d / l)) * sqrt(Float64(d / h))) * Float64(1.0 - Float64(Float64(Float64(Float64(Float64(0.5 / d) * D) * M_m) / Float64(1.0 / h)) * Float64(Float64(t_2 / d) / l)))); elseif (t_1 <= Inf) tmp = abs(Float64(d / t_0)); else tmp = Float64(Float64(fma(Float64((Float64(Float64(t_3 * t_3) / Float64(d * d)) ^ 0.5) * Float64(t_2 / Float64(Float64(-l) * d))), h, 1.0) * d) / t_0); end return tmp end
M_m = N[Abs[M], $MachinePrecision]
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
code[d_, h_, l_, M$95$m_, D_] := Block[{t$95$0 = N[Sqrt[N[(l * h), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$1 = N[(N[(1.0 - N[(N[(h / l), $MachinePrecision] * N[(N[Power[N[(N[(M$95$m * D), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] * N[(1.0 / 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[Power[N[(d / l), $MachinePrecision], N[(1.0 / 2.0), $MachinePrecision]], $MachinePrecision] * N[Power[N[(d / h), $MachinePrecision], N[(1.0 / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(M$95$m * N[(D * 0.25), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(M$95$m * D), $MachinePrecision] * 0.5), $MachinePrecision]}, If[LessEqual[t$95$1, 2e+264], N[(N[(N[Sqrt[N[(d / l), $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[(d / h), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(1.0 - N[(N[(N[(N[(N[(0.5 / d), $MachinePrecision] * D), $MachinePrecision] * M$95$m), $MachinePrecision] / N[(1.0 / h), $MachinePrecision]), $MachinePrecision] * N[(N[(t$95$2 / d), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, Infinity], N[Abs[N[(d / t$95$0), $MachinePrecision]], $MachinePrecision], N[(N[(N[(N[(N[Power[N[(N[(t$95$3 * t$95$3), $MachinePrecision] / N[(d * d), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision] * N[(t$95$2 / N[((-l) * d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * h + 1.0), $MachinePrecision] * d), $MachinePrecision] / t$95$0), $MachinePrecision]]]]]]]
\begin{array}{l}
M_m = \left|M\right|
\\
[d, h, l, M_m, D] = \mathsf{sort}([d, h, l, M_m, D])\\
\\
\begin{array}{l}
t_0 := \sqrt{\ell \cdot h}\\
t_1 := \left(1 - \frac{h}{\ell} \cdot \left({\left(\frac{M\_m \cdot D}{2 \cdot d}\right)}^{2} \cdot \frac{1}{2}\right)\right) \cdot \left({\left(\frac{d}{\ell}\right)}^{\left(\frac{1}{2}\right)} \cdot {\left(\frac{d}{h}\right)}^{\left(\frac{1}{2}\right)}\right)\\
t_2 := M\_m \cdot \left(D \cdot 0.25\right)\\
t_3 := \left(M\_m \cdot D\right) \cdot 0.5\\
\mathbf{if}\;t\_1 \leq 2 \cdot 10^{+264}:\\
\;\;\;\;\left(\sqrt{\frac{d}{\ell}} \cdot \sqrt{\frac{d}{h}}\right) \cdot \left(1 - \frac{\left(\frac{0.5}{d} \cdot D\right) \cdot M\_m}{\frac{1}{h}} \cdot \frac{\frac{t\_2}{d}}{\ell}\right)\\
\mathbf{elif}\;t\_1 \leq \infty:\\
\;\;\;\;\left|\frac{d}{t\_0}\right|\\
\mathbf{else}:\\
\;\;\;\;\frac{\mathsf{fma}\left({\left(\frac{t\_3 \cdot t\_3}{d \cdot d}\right)}^{0.5} \cdot \frac{t\_2}{\left(-\ell\right) \cdot d}, h, 1\right) \cdot d}{t\_0}\\
\end{array}
\end{array}
if (*.f64 (*.f64 (pow.f64 (/.f64 d h) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64))) (pow.f64 (/.f64 d l) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)))) (-.f64 #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)) (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64))) (/.f64 h l)))) < 2.00000000000000009e264Initial program 90.5%
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
un-div-invN/A
lift-*.f64N/A
lift-pow.f64N/A
unpow2N/A
associate-*r*N/A
div-invN/A
times-fracN/A
lower-*.f64N/A
Applied rewrites90.2%
lift-/.f64N/A
metadata-eval90.2
lift-pow.f64N/A
unpow1/2N/A
lower-sqrt.f6490.2
Applied rewrites90.2%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
metadata-evalN/A
lift-*.f64N/A
lift-*.f64N/A
lower-/.f6490.7
Applied rewrites90.7%
lift-/.f64N/A
lift-/.f64N/A
metadata-evalN/A
lift-pow.f64N/A
pow1/2N/A
lower-sqrt.f64N/A
lift-/.f6490.7
Applied rewrites90.7%
if 2.00000000000000009e264 < (*.f64 (*.f64 (pow.f64 (/.f64 d h) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64))) (pow.f64 (/.f64 d l) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)))) (-.f64 #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)) (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64))) (/.f64 h l)))) < +inf.0Initial program 60.2%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6442.9
Applied rewrites42.9%
Applied rewrites96.7%
if +inf.0 < (*.f64 (*.f64 (pow.f64 (/.f64 d h) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64))) (pow.f64 (/.f64 d l) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)))) (-.f64 #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)) (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64))) (/.f64 h l)))) Initial program 0.0%
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
un-div-invN/A
lift-*.f64N/A
lift-pow.f64N/A
unpow2N/A
associate-*r*N/A
div-invN/A
times-fracN/A
lower-*.f64N/A
Applied rewrites9.4%
Applied rewrites15.5%
lift-*.f64N/A
*-commutativeN/A
lift-*.f6415.5
lower-*.f64N/A
*-commutativeN/A
lift-*.f6415.5
unpow1N/A
metadata-evalN/A
pow-prod-upN/A
pow-prod-downN/A
pow2N/A
lift-*.f64N/A
*-commutativeN/A
unpow-prod-downN/A
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
metadata-evalN/A
associate-/r*N/A
div-invN/A
unpow-prod-downN/A
associate-/l*N/A
lower-pow.f64N/A
Applied rewrites12.7%
Final simplification78.9%
M_m = (fabs.f64 M)
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
(FPCore (d h l M_m D)
:precision binary64
(let* ((t_0 (sqrt (* l h)))
(t_1
(*
(- 1.0 (* (/ h l) (* (pow (/ (* M_m D) (* 2.0 d)) 2.0) (/ 1.0 2.0))))
(* (pow (/ d l) (/ 1.0 2.0)) (pow (/ d h) (/ 1.0 2.0))))))
(if (<= t_1 0.0)
(/ 1.0 (/ t_0 (- d)))
(if (<= t_1 2e+264) (* (sqrt (/ d l)) (sqrt (/ d h))) (fabs (/ d t_0))))))M_m = fabs(M);
assert(d < h && h < l && l < M_m && M_m < D);
double code(double d, double h, double l, double M_m, double D) {
double t_0 = sqrt((l * h));
double t_1 = (1.0 - ((h / l) * (pow(((M_m * D) / (2.0 * d)), 2.0) * (1.0 / 2.0)))) * (pow((d / l), (1.0 / 2.0)) * pow((d / h), (1.0 / 2.0)));
double tmp;
if (t_1 <= 0.0) {
tmp = 1.0 / (t_0 / -d);
} else if (t_1 <= 2e+264) {
tmp = sqrt((d / l)) * sqrt((d / h));
} else {
tmp = fabs((d / t_0));
}
return tmp;
}
M_m = abs(m)
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
real(8) function code(d, h, l, m_m, d_1)
real(8), intent (in) :: d
real(8), intent (in) :: h
real(8), intent (in) :: l
real(8), intent (in) :: m_m
real(8), intent (in) :: d_1
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = sqrt((l * h))
t_1 = (1.0d0 - ((h / l) * ((((m_m * d_1) / (2.0d0 * d)) ** 2.0d0) * (1.0d0 / 2.0d0)))) * (((d / l) ** (1.0d0 / 2.0d0)) * ((d / h) ** (1.0d0 / 2.0d0)))
if (t_1 <= 0.0d0) then
tmp = 1.0d0 / (t_0 / -d)
else if (t_1 <= 2d+264) then
tmp = sqrt((d / l)) * sqrt((d / h))
else
tmp = abs((d / t_0))
end if
code = tmp
end function
M_m = Math.abs(M);
assert d < h && h < l && l < M_m && M_m < D;
public static double code(double d, double h, double l, double M_m, double D) {
double t_0 = Math.sqrt((l * h));
double t_1 = (1.0 - ((h / l) * (Math.pow(((M_m * D) / (2.0 * d)), 2.0) * (1.0 / 2.0)))) * (Math.pow((d / l), (1.0 / 2.0)) * Math.pow((d / h), (1.0 / 2.0)));
double tmp;
if (t_1 <= 0.0) {
tmp = 1.0 / (t_0 / -d);
} else if (t_1 <= 2e+264) {
tmp = Math.sqrt((d / l)) * Math.sqrt((d / h));
} else {
tmp = Math.abs((d / t_0));
}
return tmp;
}
M_m = math.fabs(M) [d, h, l, M_m, D] = sort([d, h, l, M_m, D]) def code(d, h, l, M_m, D): t_0 = math.sqrt((l * h)) t_1 = (1.0 - ((h / l) * (math.pow(((M_m * D) / (2.0 * d)), 2.0) * (1.0 / 2.0)))) * (math.pow((d / l), (1.0 / 2.0)) * math.pow((d / h), (1.0 / 2.0))) tmp = 0 if t_1 <= 0.0: tmp = 1.0 / (t_0 / -d) elif t_1 <= 2e+264: tmp = math.sqrt((d / l)) * math.sqrt((d / h)) else: tmp = math.fabs((d / t_0)) return tmp
M_m = abs(M) d, h, l, M_m, D = sort([d, h, l, M_m, D]) function code(d, h, l, M_m, D) t_0 = sqrt(Float64(l * h)) t_1 = Float64(Float64(1.0 - Float64(Float64(h / l) * Float64((Float64(Float64(M_m * D) / Float64(2.0 * d)) ^ 2.0) * Float64(1.0 / 2.0)))) * Float64((Float64(d / l) ^ Float64(1.0 / 2.0)) * (Float64(d / h) ^ Float64(1.0 / 2.0)))) tmp = 0.0 if (t_1 <= 0.0) tmp = Float64(1.0 / Float64(t_0 / Float64(-d))); elseif (t_1 <= 2e+264) tmp = Float64(sqrt(Float64(d / l)) * sqrt(Float64(d / h))); else tmp = abs(Float64(d / t_0)); end return tmp end
M_m = abs(M);
d, h, l, M_m, D = num2cell(sort([d, h, l, M_m, D])){:}
function tmp_2 = code(d, h, l, M_m, D)
t_0 = sqrt((l * h));
t_1 = (1.0 - ((h / l) * ((((M_m * D) / (2.0 * d)) ^ 2.0) * (1.0 / 2.0)))) * (((d / l) ^ (1.0 / 2.0)) * ((d / h) ^ (1.0 / 2.0)));
tmp = 0.0;
if (t_1 <= 0.0)
tmp = 1.0 / (t_0 / -d);
elseif (t_1 <= 2e+264)
tmp = sqrt((d / l)) * sqrt((d / h));
else
tmp = abs((d / t_0));
end
tmp_2 = tmp;
end
M_m = N[Abs[M], $MachinePrecision]
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
code[d_, h_, l_, M$95$m_, D_] := Block[{t$95$0 = N[Sqrt[N[(l * h), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$1 = N[(N[(1.0 - N[(N[(h / l), $MachinePrecision] * N[(N[Power[N[(N[(M$95$m * D), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] * N[(1.0 / 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[Power[N[(d / l), $MachinePrecision], N[(1.0 / 2.0), $MachinePrecision]], $MachinePrecision] * N[Power[N[(d / h), $MachinePrecision], N[(1.0 / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, 0.0], N[(1.0 / N[(t$95$0 / (-d)), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 2e+264], N[(N[Sqrt[N[(d / l), $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[(d / h), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[Abs[N[(d / t$95$0), $MachinePrecision]], $MachinePrecision]]]]]
\begin{array}{l}
M_m = \left|M\right|
\\
[d, h, l, M_m, D] = \mathsf{sort}([d, h, l, M_m, D])\\
\\
\begin{array}{l}
t_0 := \sqrt{\ell \cdot h}\\
t_1 := \left(1 - \frac{h}{\ell} \cdot \left({\left(\frac{M\_m \cdot D}{2 \cdot d}\right)}^{2} \cdot \frac{1}{2}\right)\right) \cdot \left({\left(\frac{d}{\ell}\right)}^{\left(\frac{1}{2}\right)} \cdot {\left(\frac{d}{h}\right)}^{\left(\frac{1}{2}\right)}\right)\\
\mathbf{if}\;t\_1 \leq 0:\\
\;\;\;\;\frac{1}{\frac{t\_0}{-d}}\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+264}:\\
\;\;\;\;\sqrt{\frac{d}{\ell}} \cdot \sqrt{\frac{d}{h}}\\
\mathbf{else}:\\
\;\;\;\;\left|\frac{d}{t\_0}\right|\\
\end{array}
\end{array}
if (*.f64 (*.f64 (pow.f64 (/.f64 d h) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64))) (pow.f64 (/.f64 d l) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)))) (-.f64 #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)) (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64))) (/.f64 h l)))) < 0.0Initial program 83.1%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6420.6
Applied rewrites20.6%
Applied rewrites7.5%
Taylor expanded in d around -inf
Applied rewrites21.7%
if 0.0 < (*.f64 (*.f64 (pow.f64 (/.f64 d h) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64))) (pow.f64 (/.f64 d l) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)))) (-.f64 #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)) (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64))) (/.f64 h l)))) < 2.00000000000000009e264Initial program 99.3%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6431.0
Applied rewrites31.0%
Applied rewrites99.0%
if 2.00000000000000009e264 < (*.f64 (*.f64 (pow.f64 (/.f64 d h) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64))) (pow.f64 (/.f64 d l) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)))) (-.f64 #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)) (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64))) (/.f64 h l)))) Initial program 24.4%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6421.6
Applied rewrites21.6%
Applied rewrites53.2%
Final simplification55.8%
M_m = (fabs.f64 M)
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
(FPCore (d h l M_m D)
:precision binary64
(if (<=
(*
(- 1.0 (* (/ h l) (* (pow (/ (* M_m D) (* 2.0 d)) 2.0) (/ 1.0 2.0))))
(* (pow (/ d l) (/ 1.0 2.0)) (pow (/ d h) (/ 1.0 2.0))))
2e+264)
(*
(* (sqrt (/ d l)) (sqrt (/ d h)))
(-
1.0
(* (/ (* (* (/ 0.5 d) D) M_m) (/ 1.0 h)) (/ (/ (* M_m (* D 0.25)) d) l))))
(fabs (/ d (sqrt (* l h))))))M_m = fabs(M);
assert(d < h && h < l && l < M_m && M_m < D);
double code(double d, double h, double l, double M_m, double D) {
double tmp;
if (((1.0 - ((h / l) * (pow(((M_m * D) / (2.0 * d)), 2.0) * (1.0 / 2.0)))) * (pow((d / l), (1.0 / 2.0)) * pow((d / h), (1.0 / 2.0)))) <= 2e+264) {
tmp = (sqrt((d / l)) * sqrt((d / h))) * (1.0 - (((((0.5 / d) * D) * M_m) / (1.0 / h)) * (((M_m * (D * 0.25)) / d) / l)));
} else {
tmp = fabs((d / sqrt((l * h))));
}
return tmp;
}
M_m = abs(m)
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
real(8) function code(d, h, l, m_m, d_1)
real(8), intent (in) :: d
real(8), intent (in) :: h
real(8), intent (in) :: l
real(8), intent (in) :: m_m
real(8), intent (in) :: d_1
real(8) :: tmp
if (((1.0d0 - ((h / l) * ((((m_m * d_1) / (2.0d0 * d)) ** 2.0d0) * (1.0d0 / 2.0d0)))) * (((d / l) ** (1.0d0 / 2.0d0)) * ((d / h) ** (1.0d0 / 2.0d0)))) <= 2d+264) then
tmp = (sqrt((d / l)) * sqrt((d / h))) * (1.0d0 - (((((0.5d0 / d) * d_1) * m_m) / (1.0d0 / h)) * (((m_m * (d_1 * 0.25d0)) / d) / l)))
else
tmp = abs((d / sqrt((l * h))))
end if
code = tmp
end function
M_m = Math.abs(M);
assert d < h && h < l && l < M_m && M_m < D;
public static double code(double d, double h, double l, double M_m, double D) {
double tmp;
if (((1.0 - ((h / l) * (Math.pow(((M_m * D) / (2.0 * d)), 2.0) * (1.0 / 2.0)))) * (Math.pow((d / l), (1.0 / 2.0)) * Math.pow((d / h), (1.0 / 2.0)))) <= 2e+264) {
tmp = (Math.sqrt((d / l)) * Math.sqrt((d / h))) * (1.0 - (((((0.5 / d) * D) * M_m) / (1.0 / h)) * (((M_m * (D * 0.25)) / d) / l)));
} else {
tmp = Math.abs((d / Math.sqrt((l * h))));
}
return tmp;
}
M_m = math.fabs(M) [d, h, l, M_m, D] = sort([d, h, l, M_m, D]) def code(d, h, l, M_m, D): tmp = 0 if ((1.0 - ((h / l) * (math.pow(((M_m * D) / (2.0 * d)), 2.0) * (1.0 / 2.0)))) * (math.pow((d / l), (1.0 / 2.0)) * math.pow((d / h), (1.0 / 2.0)))) <= 2e+264: tmp = (math.sqrt((d / l)) * math.sqrt((d / h))) * (1.0 - (((((0.5 / d) * D) * M_m) / (1.0 / h)) * (((M_m * (D * 0.25)) / d) / l))) else: tmp = math.fabs((d / math.sqrt((l * h)))) return tmp
M_m = abs(M) d, h, l, M_m, D = sort([d, h, l, M_m, D]) function code(d, h, l, M_m, D) tmp = 0.0 if (Float64(Float64(1.0 - Float64(Float64(h / l) * Float64((Float64(Float64(M_m * D) / Float64(2.0 * d)) ^ 2.0) * Float64(1.0 / 2.0)))) * Float64((Float64(d / l) ^ Float64(1.0 / 2.0)) * (Float64(d / h) ^ Float64(1.0 / 2.0)))) <= 2e+264) tmp = Float64(Float64(sqrt(Float64(d / l)) * sqrt(Float64(d / h))) * Float64(1.0 - Float64(Float64(Float64(Float64(Float64(0.5 / d) * D) * M_m) / Float64(1.0 / h)) * Float64(Float64(Float64(M_m * Float64(D * 0.25)) / d) / l)))); else tmp = abs(Float64(d / sqrt(Float64(l * h)))); end return tmp end
M_m = abs(M);
d, h, l, M_m, D = num2cell(sort([d, h, l, M_m, D])){:}
function tmp_2 = code(d, h, l, M_m, D)
tmp = 0.0;
if (((1.0 - ((h / l) * ((((M_m * D) / (2.0 * d)) ^ 2.0) * (1.0 / 2.0)))) * (((d / l) ^ (1.0 / 2.0)) * ((d / h) ^ (1.0 / 2.0)))) <= 2e+264)
tmp = (sqrt((d / l)) * sqrt((d / h))) * (1.0 - (((((0.5 / d) * D) * M_m) / (1.0 / h)) * (((M_m * (D * 0.25)) / d) / l)));
else
tmp = abs((d / sqrt((l * h))));
end
tmp_2 = tmp;
end
M_m = N[Abs[M], $MachinePrecision] NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function. code[d_, h_, l_, M$95$m_, D_] := If[LessEqual[N[(N[(1.0 - N[(N[(h / l), $MachinePrecision] * N[(N[Power[N[(N[(M$95$m * D), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] * N[(1.0 / 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[Power[N[(d / l), $MachinePrecision], N[(1.0 / 2.0), $MachinePrecision]], $MachinePrecision] * N[Power[N[(d / h), $MachinePrecision], N[(1.0 / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2e+264], N[(N[(N[Sqrt[N[(d / l), $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[(d / h), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(1.0 - N[(N[(N[(N[(N[(0.5 / d), $MachinePrecision] * D), $MachinePrecision] * M$95$m), $MachinePrecision] / N[(1.0 / h), $MachinePrecision]), $MachinePrecision] * N[(N[(N[(M$95$m * N[(D * 0.25), $MachinePrecision]), $MachinePrecision] / d), $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[Abs[N[(d / N[Sqrt[N[(l * h), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
M_m = \left|M\right|
\\
[d, h, l, M_m, D] = \mathsf{sort}([d, h, l, M_m, D])\\
\\
\begin{array}{l}
\mathbf{if}\;\left(1 - \frac{h}{\ell} \cdot \left({\left(\frac{M\_m \cdot D}{2 \cdot d}\right)}^{2} \cdot \frac{1}{2}\right)\right) \cdot \left({\left(\frac{d}{\ell}\right)}^{\left(\frac{1}{2}\right)} \cdot {\left(\frac{d}{h}\right)}^{\left(\frac{1}{2}\right)}\right) \leq 2 \cdot 10^{+264}:\\
\;\;\;\;\left(\sqrt{\frac{d}{\ell}} \cdot \sqrt{\frac{d}{h}}\right) \cdot \left(1 - \frac{\left(\frac{0.5}{d} \cdot D\right) \cdot M\_m}{\frac{1}{h}} \cdot \frac{\frac{M\_m \cdot \left(D \cdot 0.25\right)}{d}}{\ell}\right)\\
\mathbf{else}:\\
\;\;\;\;\left|\frac{d}{\sqrt{\ell \cdot h}}\right|\\
\end{array}
\end{array}
if (*.f64 (*.f64 (pow.f64 (/.f64 d h) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64))) (pow.f64 (/.f64 d l) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)))) (-.f64 #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)) (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64))) (/.f64 h l)))) < 2.00000000000000009e264Initial program 90.5%
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
un-div-invN/A
lift-*.f64N/A
lift-pow.f64N/A
unpow2N/A
associate-*r*N/A
div-invN/A
times-fracN/A
lower-*.f64N/A
Applied rewrites90.2%
lift-/.f64N/A
metadata-eval90.2
lift-pow.f64N/A
unpow1/2N/A
lower-sqrt.f6490.2
Applied rewrites90.2%
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
metadata-evalN/A
lift-*.f64N/A
lift-*.f64N/A
lower-/.f6490.7
Applied rewrites90.7%
lift-/.f64N/A
lift-/.f64N/A
metadata-evalN/A
lift-pow.f64N/A
pow1/2N/A
lower-sqrt.f64N/A
lift-/.f6490.7
Applied rewrites90.7%
if 2.00000000000000009e264 < (*.f64 (*.f64 (pow.f64 (/.f64 d h) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64))) (pow.f64 (/.f64 d l) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)))) (-.f64 #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)) (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64))) (/.f64 h l)))) Initial program 24.4%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6421.6
Applied rewrites21.6%
Applied rewrites53.2%
Final simplification80.6%
M_m = (fabs.f64 M)
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
(FPCore (d h l M_m D)
:precision binary64
(if (<=
(*
(- 1.0 (* (/ h l) (* (pow (/ (* M_m D) (* 2.0 d)) 2.0) (/ 1.0 2.0))))
(* (pow (/ d l) (/ 1.0 2.0)) (pow (/ d h) (/ 1.0 2.0))))
-1e+42)
(* (sqrt (/ 1.0 (* l h))) d)
(fabs (/ d (sqrt (* l h))))))M_m = fabs(M);
assert(d < h && h < l && l < M_m && M_m < D);
double code(double d, double h, double l, double M_m, double D) {
double tmp;
if (((1.0 - ((h / l) * (pow(((M_m * D) / (2.0 * d)), 2.0) * (1.0 / 2.0)))) * (pow((d / l), (1.0 / 2.0)) * pow((d / h), (1.0 / 2.0)))) <= -1e+42) {
tmp = sqrt((1.0 / (l * h))) * d;
} else {
tmp = fabs((d / sqrt((l * h))));
}
return tmp;
}
M_m = abs(m)
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
real(8) function code(d, h, l, m_m, d_1)
real(8), intent (in) :: d
real(8), intent (in) :: h
real(8), intent (in) :: l
real(8), intent (in) :: m_m
real(8), intent (in) :: d_1
real(8) :: tmp
if (((1.0d0 - ((h / l) * ((((m_m * d_1) / (2.0d0 * d)) ** 2.0d0) * (1.0d0 / 2.0d0)))) * (((d / l) ** (1.0d0 / 2.0d0)) * ((d / h) ** (1.0d0 / 2.0d0)))) <= (-1d+42)) then
tmp = sqrt((1.0d0 / (l * h))) * d
else
tmp = abs((d / sqrt((l * h))))
end if
code = tmp
end function
M_m = Math.abs(M);
assert d < h && h < l && l < M_m && M_m < D;
public static double code(double d, double h, double l, double M_m, double D) {
double tmp;
if (((1.0 - ((h / l) * (Math.pow(((M_m * D) / (2.0 * d)), 2.0) * (1.0 / 2.0)))) * (Math.pow((d / l), (1.0 / 2.0)) * Math.pow((d / h), (1.0 / 2.0)))) <= -1e+42) {
tmp = Math.sqrt((1.0 / (l * h))) * d;
} else {
tmp = Math.abs((d / Math.sqrt((l * h))));
}
return tmp;
}
M_m = math.fabs(M) [d, h, l, M_m, D] = sort([d, h, l, M_m, D]) def code(d, h, l, M_m, D): tmp = 0 if ((1.0 - ((h / l) * (math.pow(((M_m * D) / (2.0 * d)), 2.0) * (1.0 / 2.0)))) * (math.pow((d / l), (1.0 / 2.0)) * math.pow((d / h), (1.0 / 2.0)))) <= -1e+42: tmp = math.sqrt((1.0 / (l * h))) * d else: tmp = math.fabs((d / math.sqrt((l * h)))) return tmp
M_m = abs(M) d, h, l, M_m, D = sort([d, h, l, M_m, D]) function code(d, h, l, M_m, D) tmp = 0.0 if (Float64(Float64(1.0 - Float64(Float64(h / l) * Float64((Float64(Float64(M_m * D) / Float64(2.0 * d)) ^ 2.0) * Float64(1.0 / 2.0)))) * Float64((Float64(d / l) ^ Float64(1.0 / 2.0)) * (Float64(d / h) ^ Float64(1.0 / 2.0)))) <= -1e+42) tmp = Float64(sqrt(Float64(1.0 / Float64(l * h))) * d); else tmp = abs(Float64(d / sqrt(Float64(l * h)))); end return tmp end
M_m = abs(M);
d, h, l, M_m, D = num2cell(sort([d, h, l, M_m, D])){:}
function tmp_2 = code(d, h, l, M_m, D)
tmp = 0.0;
if (((1.0 - ((h / l) * ((((M_m * D) / (2.0 * d)) ^ 2.0) * (1.0 / 2.0)))) * (((d / l) ^ (1.0 / 2.0)) * ((d / h) ^ (1.0 / 2.0)))) <= -1e+42)
tmp = sqrt((1.0 / (l * h))) * d;
else
tmp = abs((d / sqrt((l * h))));
end
tmp_2 = tmp;
end
M_m = N[Abs[M], $MachinePrecision] NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function. code[d_, h_, l_, M$95$m_, D_] := If[LessEqual[N[(N[(1.0 - N[(N[(h / l), $MachinePrecision] * N[(N[Power[N[(N[(M$95$m * D), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] * N[(1.0 / 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[Power[N[(d / l), $MachinePrecision], N[(1.0 / 2.0), $MachinePrecision]], $MachinePrecision] * N[Power[N[(d / h), $MachinePrecision], N[(1.0 / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], -1e+42], N[(N[Sqrt[N[(1.0 / N[(l * h), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * d), $MachinePrecision], N[Abs[N[(d / N[Sqrt[N[(l * h), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
M_m = \left|M\right|
\\
[d, h, l, M_m, D] = \mathsf{sort}([d, h, l, M_m, D])\\
\\
\begin{array}{l}
\mathbf{if}\;\left(1 - \frac{h}{\ell} \cdot \left({\left(\frac{M\_m \cdot D}{2 \cdot d}\right)}^{2} \cdot \frac{1}{2}\right)\right) \cdot \left({\left(\frac{d}{\ell}\right)}^{\left(\frac{1}{2}\right)} \cdot {\left(\frac{d}{h}\right)}^{\left(\frac{1}{2}\right)}\right) \leq -1 \cdot 10^{+42}:\\
\;\;\;\;\sqrt{\frac{1}{\ell \cdot h}} \cdot d\\
\mathbf{else}:\\
\;\;\;\;\left|\frac{d}{\sqrt{\ell \cdot h}}\right|\\
\end{array}
\end{array}
if (*.f64 (*.f64 (pow.f64 (/.f64 d h) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64))) (pow.f64 (/.f64 d l) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)))) (-.f64 #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)) (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64))) (/.f64 h l)))) < -1.00000000000000004e42Initial program 89.1%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6415.8
Applied rewrites15.8%
if -1.00000000000000004e42 < (*.f64 (*.f64 (pow.f64 (/.f64 d h) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64))) (pow.f64 (/.f64 d l) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)))) (-.f64 #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)) (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64))) (/.f64 h l)))) Initial program 64.4%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6428.6
Applied rewrites28.6%
Applied rewrites63.0%
Final simplification47.2%
M_m = (fabs.f64 M)
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
(FPCore (d h l M_m D)
:precision binary64
(let* ((t_0 (/ d (sqrt (* l h)))))
(if (<=
(*
(- 1.0 (* (/ h l) (* (pow (/ (* M_m D) (* 2.0 d)) 2.0) (/ 1.0 2.0))))
(* (pow (/ d l) (/ 1.0 2.0)) (pow (/ d h) (/ 1.0 2.0))))
-1e+42)
t_0
(fabs t_0))))M_m = fabs(M);
assert(d < h && h < l && l < M_m && M_m < D);
double code(double d, double h, double l, double M_m, double D) {
double t_0 = d / sqrt((l * h));
double tmp;
if (((1.0 - ((h / l) * (pow(((M_m * D) / (2.0 * d)), 2.0) * (1.0 / 2.0)))) * (pow((d / l), (1.0 / 2.0)) * pow((d / h), (1.0 / 2.0)))) <= -1e+42) {
tmp = t_0;
} else {
tmp = fabs(t_0);
}
return tmp;
}
M_m = abs(m)
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
real(8) function code(d, h, l, m_m, d_1)
real(8), intent (in) :: d
real(8), intent (in) :: h
real(8), intent (in) :: l
real(8), intent (in) :: m_m
real(8), intent (in) :: d_1
real(8) :: t_0
real(8) :: tmp
t_0 = d / sqrt((l * h))
if (((1.0d0 - ((h / l) * ((((m_m * d_1) / (2.0d0 * d)) ** 2.0d0) * (1.0d0 / 2.0d0)))) * (((d / l) ** (1.0d0 / 2.0d0)) * ((d / h) ** (1.0d0 / 2.0d0)))) <= (-1d+42)) then
tmp = t_0
else
tmp = abs(t_0)
end if
code = tmp
end function
M_m = Math.abs(M);
assert d < h && h < l && l < M_m && M_m < D;
public static double code(double d, double h, double l, double M_m, double D) {
double t_0 = d / Math.sqrt((l * h));
double tmp;
if (((1.0 - ((h / l) * (Math.pow(((M_m * D) / (2.0 * d)), 2.0) * (1.0 / 2.0)))) * (Math.pow((d / l), (1.0 / 2.0)) * Math.pow((d / h), (1.0 / 2.0)))) <= -1e+42) {
tmp = t_0;
} else {
tmp = Math.abs(t_0);
}
return tmp;
}
M_m = math.fabs(M) [d, h, l, M_m, D] = sort([d, h, l, M_m, D]) def code(d, h, l, M_m, D): t_0 = d / math.sqrt((l * h)) tmp = 0 if ((1.0 - ((h / l) * (math.pow(((M_m * D) / (2.0 * d)), 2.0) * (1.0 / 2.0)))) * (math.pow((d / l), (1.0 / 2.0)) * math.pow((d / h), (1.0 / 2.0)))) <= -1e+42: tmp = t_0 else: tmp = math.fabs(t_0) return tmp
M_m = abs(M) d, h, l, M_m, D = sort([d, h, l, M_m, D]) function code(d, h, l, M_m, D) t_0 = Float64(d / sqrt(Float64(l * h))) tmp = 0.0 if (Float64(Float64(1.0 - Float64(Float64(h / l) * Float64((Float64(Float64(M_m * D) / Float64(2.0 * d)) ^ 2.0) * Float64(1.0 / 2.0)))) * Float64((Float64(d / l) ^ Float64(1.0 / 2.0)) * (Float64(d / h) ^ Float64(1.0 / 2.0)))) <= -1e+42) tmp = t_0; else tmp = abs(t_0); end return tmp end
M_m = abs(M);
d, h, l, M_m, D = num2cell(sort([d, h, l, M_m, D])){:}
function tmp_2 = code(d, h, l, M_m, D)
t_0 = d / sqrt((l * h));
tmp = 0.0;
if (((1.0 - ((h / l) * ((((M_m * D) / (2.0 * d)) ^ 2.0) * (1.0 / 2.0)))) * (((d / l) ^ (1.0 / 2.0)) * ((d / h) ^ (1.0 / 2.0)))) <= -1e+42)
tmp = t_0;
else
tmp = abs(t_0);
end
tmp_2 = tmp;
end
M_m = N[Abs[M], $MachinePrecision]
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
code[d_, h_, l_, M$95$m_, D_] := Block[{t$95$0 = N[(d / N[Sqrt[N[(l * h), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(N[(1.0 - N[(N[(h / l), $MachinePrecision] * N[(N[Power[N[(N[(M$95$m * D), $MachinePrecision] / N[(2.0 * d), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] * N[(1.0 / 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[Power[N[(d / l), $MachinePrecision], N[(1.0 / 2.0), $MachinePrecision]], $MachinePrecision] * N[Power[N[(d / h), $MachinePrecision], N[(1.0 / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], -1e+42], t$95$0, N[Abs[t$95$0], $MachinePrecision]]]
\begin{array}{l}
M_m = \left|M\right|
\\
[d, h, l, M_m, D] = \mathsf{sort}([d, h, l, M_m, D])\\
\\
\begin{array}{l}
t_0 := \frac{d}{\sqrt{\ell \cdot h}}\\
\mathbf{if}\;\left(1 - \frac{h}{\ell} \cdot \left({\left(\frac{M\_m \cdot D}{2 \cdot d}\right)}^{2} \cdot \frac{1}{2}\right)\right) \cdot \left({\left(\frac{d}{\ell}\right)}^{\left(\frac{1}{2}\right)} \cdot {\left(\frac{d}{h}\right)}^{\left(\frac{1}{2}\right)}\right) \leq -1 \cdot 10^{+42}:\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;\left|t\_0\right|\\
\end{array}
\end{array}
if (*.f64 (*.f64 (pow.f64 (/.f64 d h) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64))) (pow.f64 (/.f64 d l) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)))) (-.f64 #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)) (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64))) (/.f64 h l)))) < -1.00000000000000004e42Initial program 89.1%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6415.8
Applied rewrites15.8%
Applied rewrites11.3%
if -1.00000000000000004e42 < (*.f64 (*.f64 (pow.f64 (/.f64 d h) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64))) (pow.f64 (/.f64 d l) (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)))) (-.f64 #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) #s(literal 2 binary64)) (pow.f64 (/.f64 (*.f64 M D) (*.f64 #s(literal 2 binary64) d)) #s(literal 2 binary64))) (/.f64 h l)))) Initial program 64.4%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6428.6
Applied rewrites28.6%
Applied rewrites63.0%
Final simplification45.6%
M_m = (fabs.f64 M)
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
(FPCore (d h l M_m D)
:precision binary64
(let* ((t_0 (sqrt (- l)))
(t_1 (sqrt (/ d h)))
(t_2 (* -0.5 (/ h l)))
(t_3 (sqrt (- d))))
(if (<= d -1.2e-65)
(/
(*
(* (fma t_2 (* (/ (* (* (* M_m M_m) 0.25) D) d) (/ D d)) 1.0) t_1)
t_3)
t_0)
(if (<= d -5e-310)
(/
(*
(* (fma (/ t_2 d) (* (/ 0.25 d) (* (* (* D D) M_m) M_m)) 1.0) t_1)
t_3)
t_0)
(/
(*
(fma
(* (* (* (/ 0.5 d) D) M_m) (/ (* M_m (* D 0.25)) (* (- l) d)))
h
1.0)
d)
(* (sqrt h) (sqrt l)))))))M_m = fabs(M);
assert(d < h && h < l && l < M_m && M_m < D);
double code(double d, double h, double l, double M_m, double D) {
double t_0 = sqrt(-l);
double t_1 = sqrt((d / h));
double t_2 = -0.5 * (h / l);
double t_3 = sqrt(-d);
double tmp;
if (d <= -1.2e-65) {
tmp = ((fma(t_2, (((((M_m * M_m) * 0.25) * D) / d) * (D / d)), 1.0) * t_1) * t_3) / t_0;
} else if (d <= -5e-310) {
tmp = ((fma((t_2 / d), ((0.25 / d) * (((D * D) * M_m) * M_m)), 1.0) * t_1) * t_3) / t_0;
} else {
tmp = (fma(((((0.5 / d) * D) * M_m) * ((M_m * (D * 0.25)) / (-l * d))), h, 1.0) * d) / (sqrt(h) * sqrt(l));
}
return tmp;
}
M_m = abs(M) d, h, l, M_m, D = sort([d, h, l, M_m, D]) function code(d, h, l, M_m, D) t_0 = sqrt(Float64(-l)) t_1 = sqrt(Float64(d / h)) t_2 = Float64(-0.5 * Float64(h / l)) t_3 = sqrt(Float64(-d)) tmp = 0.0 if (d <= -1.2e-65) tmp = Float64(Float64(Float64(fma(t_2, Float64(Float64(Float64(Float64(Float64(M_m * M_m) * 0.25) * D) / d) * Float64(D / d)), 1.0) * t_1) * t_3) / t_0); elseif (d <= -5e-310) tmp = Float64(Float64(Float64(fma(Float64(t_2 / d), Float64(Float64(0.25 / d) * Float64(Float64(Float64(D * D) * M_m) * M_m)), 1.0) * t_1) * t_3) / t_0); else tmp = Float64(Float64(fma(Float64(Float64(Float64(Float64(0.5 / d) * D) * M_m) * Float64(Float64(M_m * Float64(D * 0.25)) / Float64(Float64(-l) * d))), h, 1.0) * d) / Float64(sqrt(h) * sqrt(l))); end return tmp end
M_m = N[Abs[M], $MachinePrecision]
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
code[d_, h_, l_, M$95$m_, D_] := Block[{t$95$0 = N[Sqrt[(-l)], $MachinePrecision]}, Block[{t$95$1 = N[Sqrt[N[(d / h), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[(-0.5 * N[(h / l), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[Sqrt[(-d)], $MachinePrecision]}, If[LessEqual[d, -1.2e-65], N[(N[(N[(N[(t$95$2 * N[(N[(N[(N[(N[(M$95$m * M$95$m), $MachinePrecision] * 0.25), $MachinePrecision] * D), $MachinePrecision] / d), $MachinePrecision] * N[(D / d), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision] * t$95$1), $MachinePrecision] * t$95$3), $MachinePrecision] / t$95$0), $MachinePrecision], If[LessEqual[d, -5e-310], N[(N[(N[(N[(N[(t$95$2 / d), $MachinePrecision] * N[(N[(0.25 / d), $MachinePrecision] * N[(N[(N[(D * D), $MachinePrecision] * M$95$m), $MachinePrecision] * M$95$m), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision] * t$95$1), $MachinePrecision] * t$95$3), $MachinePrecision] / t$95$0), $MachinePrecision], N[(N[(N[(N[(N[(N[(N[(0.5 / d), $MachinePrecision] * D), $MachinePrecision] * M$95$m), $MachinePrecision] * N[(N[(M$95$m * N[(D * 0.25), $MachinePrecision]), $MachinePrecision] / N[((-l) * d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * h + 1.0), $MachinePrecision] * d), $MachinePrecision] / N[(N[Sqrt[h], $MachinePrecision] * N[Sqrt[l], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
M_m = \left|M\right|
\\
[d, h, l, M_m, D] = \mathsf{sort}([d, h, l, M_m, D])\\
\\
\begin{array}{l}
t_0 := \sqrt{-\ell}\\
t_1 := \sqrt{\frac{d}{h}}\\
t_2 := -0.5 \cdot \frac{h}{\ell}\\
t_3 := \sqrt{-d}\\
\mathbf{if}\;d \leq -1.2 \cdot 10^{-65}:\\
\;\;\;\;\frac{\left(\mathsf{fma}\left(t\_2, \frac{\left(\left(M\_m \cdot M\_m\right) \cdot 0.25\right) \cdot D}{d} \cdot \frac{D}{d}, 1\right) \cdot t\_1\right) \cdot t\_3}{t\_0}\\
\mathbf{elif}\;d \leq -5 \cdot 10^{-310}:\\
\;\;\;\;\frac{\left(\mathsf{fma}\left(\frac{t\_2}{d}, \frac{0.25}{d} \cdot \left(\left(\left(D \cdot D\right) \cdot M\_m\right) \cdot M\_m\right), 1\right) \cdot t\_1\right) \cdot t\_3}{t\_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{\mathsf{fma}\left(\left(\left(\frac{0.5}{d} \cdot D\right) \cdot M\_m\right) \cdot \frac{M\_m \cdot \left(D \cdot 0.25\right)}{\left(-\ell\right) \cdot d}, h, 1\right) \cdot d}{\sqrt{h} \cdot \sqrt{\ell}}\\
\end{array}
\end{array}
if d < -1.2000000000000001e-65Initial program 79.1%
Applied rewrites57.1%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lift-*.f64N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6472.9
Applied rewrites72.9%
if -1.2000000000000001e-65 < d < -4.999999999999985e-310Initial program 63.0%
Applied rewrites49.3%
lift-fma.f64N/A
lift-/.f64N/A
associate-*r/N/A
lift-*.f64N/A
times-fracN/A
lower-fma.f64N/A
Applied rewrites74.4%
if -4.999999999999985e-310 < d Initial program 73.0%
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
un-div-invN/A
lift-*.f64N/A
lift-pow.f64N/A
unpow2N/A
associate-*r*N/A
div-invN/A
times-fracN/A
lower-*.f64N/A
Applied rewrites71.3%
Applied rewrites62.4%
lift-sqrt.f64N/A
lift-*.f64N/A
sqrt-prodN/A
pow1/2N/A
lower-*.f64N/A
pow1/2N/A
lower-sqrt.f64N/A
lower-sqrt.f6481.1
Applied rewrites81.1%
Final simplification76.9%
M_m = (fabs.f64 M)
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
(FPCore (d h l M_m D)
:precision binary64
(let* ((t_0 (sqrt (/ d h))) (t_1 (* (* (/ 0.5 d) D) M_m)))
(if (<= l -4.3e+77)
(/
(*
(*
(fma (* -0.5 (/ h l)) (* (/ (* (* (* M_m M_m) 0.25) D) d) (/ D d)) 1.0)
t_0)
(sqrt (- d)))
(sqrt (- l)))
(if (<= l -5e-310)
(*
(* (fma (/ (* -0.25 (* M_m D)) (* l d)) (* t_1 h) 1.0) t_0)
(sqrt (/ d l)))
(/
(* (fma (* t_1 (/ (* M_m (* D 0.25)) (* (- l) d))) h 1.0) d)
(* (sqrt h) (sqrt l)))))))M_m = fabs(M);
assert(d < h && h < l && l < M_m && M_m < D);
double code(double d, double h, double l, double M_m, double D) {
double t_0 = sqrt((d / h));
double t_1 = ((0.5 / d) * D) * M_m;
double tmp;
if (l <= -4.3e+77) {
tmp = ((fma((-0.5 * (h / l)), (((((M_m * M_m) * 0.25) * D) / d) * (D / d)), 1.0) * t_0) * sqrt(-d)) / sqrt(-l);
} else if (l <= -5e-310) {
tmp = (fma(((-0.25 * (M_m * D)) / (l * d)), (t_1 * h), 1.0) * t_0) * sqrt((d / l));
} else {
tmp = (fma((t_1 * ((M_m * (D * 0.25)) / (-l * d))), h, 1.0) * d) / (sqrt(h) * sqrt(l));
}
return tmp;
}
M_m = abs(M) d, h, l, M_m, D = sort([d, h, l, M_m, D]) function code(d, h, l, M_m, D) t_0 = sqrt(Float64(d / h)) t_1 = Float64(Float64(Float64(0.5 / d) * D) * M_m) tmp = 0.0 if (l <= -4.3e+77) tmp = Float64(Float64(Float64(fma(Float64(-0.5 * Float64(h / l)), Float64(Float64(Float64(Float64(Float64(M_m * M_m) * 0.25) * D) / d) * Float64(D / d)), 1.0) * t_0) * sqrt(Float64(-d))) / sqrt(Float64(-l))); elseif (l <= -5e-310) tmp = Float64(Float64(fma(Float64(Float64(-0.25 * Float64(M_m * D)) / Float64(l * d)), Float64(t_1 * h), 1.0) * t_0) * sqrt(Float64(d / l))); else tmp = Float64(Float64(fma(Float64(t_1 * Float64(Float64(M_m * Float64(D * 0.25)) / Float64(Float64(-l) * d))), h, 1.0) * d) / Float64(sqrt(h) * sqrt(l))); end return tmp end
M_m = N[Abs[M], $MachinePrecision]
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
code[d_, h_, l_, M$95$m_, D_] := Block[{t$95$0 = N[Sqrt[N[(d / h), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$1 = N[(N[(N[(0.5 / d), $MachinePrecision] * D), $MachinePrecision] * M$95$m), $MachinePrecision]}, If[LessEqual[l, -4.3e+77], N[(N[(N[(N[(N[(-0.5 * N[(h / l), $MachinePrecision]), $MachinePrecision] * N[(N[(N[(N[(N[(M$95$m * M$95$m), $MachinePrecision] * 0.25), $MachinePrecision] * D), $MachinePrecision] / d), $MachinePrecision] * N[(D / d), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision] * t$95$0), $MachinePrecision] * N[Sqrt[(-d)], $MachinePrecision]), $MachinePrecision] / N[Sqrt[(-l)], $MachinePrecision]), $MachinePrecision], If[LessEqual[l, -5e-310], N[(N[(N[(N[(N[(-0.25 * N[(M$95$m * D), $MachinePrecision]), $MachinePrecision] / N[(l * d), $MachinePrecision]), $MachinePrecision] * N[(t$95$1 * h), $MachinePrecision] + 1.0), $MachinePrecision] * t$95$0), $MachinePrecision] * N[Sqrt[N[(d / l), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[(t$95$1 * N[(N[(M$95$m * N[(D * 0.25), $MachinePrecision]), $MachinePrecision] / N[((-l) * d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * h + 1.0), $MachinePrecision] * d), $MachinePrecision] / N[(N[Sqrt[h], $MachinePrecision] * N[Sqrt[l], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
M_m = \left|M\right|
\\
[d, h, l, M_m, D] = \mathsf{sort}([d, h, l, M_m, D])\\
\\
\begin{array}{l}
t_0 := \sqrt{\frac{d}{h}}\\
t_1 := \left(\frac{0.5}{d} \cdot D\right) \cdot M\_m\\
\mathbf{if}\;\ell \leq -4.3 \cdot 10^{+77}:\\
\;\;\;\;\frac{\left(\mathsf{fma}\left(-0.5 \cdot \frac{h}{\ell}, \frac{\left(\left(M\_m \cdot M\_m\right) \cdot 0.25\right) \cdot D}{d} \cdot \frac{D}{d}, 1\right) \cdot t\_0\right) \cdot \sqrt{-d}}{\sqrt{-\ell}}\\
\mathbf{elif}\;\ell \leq -5 \cdot 10^{-310}:\\
\;\;\;\;\left(\mathsf{fma}\left(\frac{-0.25 \cdot \left(M\_m \cdot D\right)}{\ell \cdot d}, t\_1 \cdot h, 1\right) \cdot t\_0\right) \cdot \sqrt{\frac{d}{\ell}}\\
\mathbf{else}:\\
\;\;\;\;\frac{\mathsf{fma}\left(t\_1 \cdot \frac{M\_m \cdot \left(D \cdot 0.25\right)}{\left(-\ell\right) \cdot d}, h, 1\right) \cdot d}{\sqrt{h} \cdot \sqrt{\ell}}\\
\end{array}
\end{array}
if l < -4.29999999999999991e77Initial program 65.2%
Applied rewrites57.7%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lift-*.f64N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6468.6
Applied rewrites68.6%
if -4.29999999999999991e77 < l < -4.999999999999985e-310Initial program 77.3%
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
un-div-invN/A
lift-*.f64N/A
lift-pow.f64N/A
unpow2N/A
associate-*r*N/A
div-invN/A
times-fracN/A
lower-*.f64N/A
Applied rewrites82.3%
Applied rewrites0.4%
Applied rewrites80.5%
if -4.999999999999985e-310 < l Initial program 73.0%
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
un-div-invN/A
lift-*.f64N/A
lift-pow.f64N/A
unpow2N/A
associate-*r*N/A
div-invN/A
times-fracN/A
lower-*.f64N/A
Applied rewrites71.3%
Applied rewrites62.4%
lift-sqrt.f64N/A
lift-*.f64N/A
sqrt-prodN/A
pow1/2N/A
lower-*.f64N/A
pow1/2N/A
lower-sqrt.f64N/A
lower-sqrt.f6481.1
Applied rewrites81.1%
Final simplification78.1%
M_m = (fabs.f64 M)
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
(FPCore (d h l M_m D)
:precision binary64
(let* ((t_0 (sqrt (- l))))
(if (<= d -7e+98)
(fabs (/ (/ d t_0) (sqrt (- h))))
(if (<= d -1.85e-132)
(*
(*
(fma
(* -0.5 (/ h l))
(/ (* (* D D) (* (* M_m M_m) 0.25)) (* d d))
1.0)
(sqrt (/ d l)))
(sqrt (/ d h)))
(if (<= d -1.35e-298)
(/
(*
(*
(/ (- D) l)
(* (* (* -0.125 (sqrt (/ h (* (* d d) d)))) (* M_m M_m)) D))
(sqrt (- d)))
t_0)
(/
(*
(fma
(* (* (* (/ 0.5 d) D) M_m) (/ (* M_m (* D 0.25)) (* (- l) d)))
h
1.0)
d)
(* (sqrt h) (sqrt l))))))))M_m = fabs(M);
assert(d < h && h < l && l < M_m && M_m < D);
double code(double d, double h, double l, double M_m, double D) {
double t_0 = sqrt(-l);
double tmp;
if (d <= -7e+98) {
tmp = fabs(((d / t_0) / sqrt(-h)));
} else if (d <= -1.85e-132) {
tmp = (fma((-0.5 * (h / l)), (((D * D) * ((M_m * M_m) * 0.25)) / (d * d)), 1.0) * sqrt((d / l))) * sqrt((d / h));
} else if (d <= -1.35e-298) {
tmp = (((-D / l) * (((-0.125 * sqrt((h / ((d * d) * d)))) * (M_m * M_m)) * D)) * sqrt(-d)) / t_0;
} else {
tmp = (fma(((((0.5 / d) * D) * M_m) * ((M_m * (D * 0.25)) / (-l * d))), h, 1.0) * d) / (sqrt(h) * sqrt(l));
}
return tmp;
}
M_m = abs(M) d, h, l, M_m, D = sort([d, h, l, M_m, D]) function code(d, h, l, M_m, D) t_0 = sqrt(Float64(-l)) tmp = 0.0 if (d <= -7e+98) tmp = abs(Float64(Float64(d / t_0) / sqrt(Float64(-h)))); elseif (d <= -1.85e-132) tmp = Float64(Float64(fma(Float64(-0.5 * Float64(h / l)), Float64(Float64(Float64(D * D) * Float64(Float64(M_m * M_m) * 0.25)) / Float64(d * d)), 1.0) * sqrt(Float64(d / l))) * sqrt(Float64(d / h))); elseif (d <= -1.35e-298) tmp = Float64(Float64(Float64(Float64(Float64(-D) / l) * Float64(Float64(Float64(-0.125 * sqrt(Float64(h / Float64(Float64(d * d) * d)))) * Float64(M_m * M_m)) * D)) * sqrt(Float64(-d))) / t_0); else tmp = Float64(Float64(fma(Float64(Float64(Float64(Float64(0.5 / d) * D) * M_m) * Float64(Float64(M_m * Float64(D * 0.25)) / Float64(Float64(-l) * d))), h, 1.0) * d) / Float64(sqrt(h) * sqrt(l))); end return tmp end
M_m = N[Abs[M], $MachinePrecision]
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
code[d_, h_, l_, M$95$m_, D_] := Block[{t$95$0 = N[Sqrt[(-l)], $MachinePrecision]}, If[LessEqual[d, -7e+98], N[Abs[N[(N[(d / t$95$0), $MachinePrecision] / N[Sqrt[(-h)], $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[d, -1.85e-132], N[(N[(N[(N[(-0.5 * N[(h / l), $MachinePrecision]), $MachinePrecision] * N[(N[(N[(D * D), $MachinePrecision] * N[(N[(M$95$m * M$95$m), $MachinePrecision] * 0.25), $MachinePrecision]), $MachinePrecision] / N[(d * d), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision] * N[Sqrt[N[(d / l), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(d / h), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[d, -1.35e-298], N[(N[(N[(N[((-D) / l), $MachinePrecision] * N[(N[(N[(-0.125 * N[Sqrt[N[(h / N[(N[(d * d), $MachinePrecision] * d), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(M$95$m * M$95$m), $MachinePrecision]), $MachinePrecision] * D), $MachinePrecision]), $MachinePrecision] * N[Sqrt[(-d)], $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision], N[(N[(N[(N[(N[(N[(N[(0.5 / d), $MachinePrecision] * D), $MachinePrecision] * M$95$m), $MachinePrecision] * N[(N[(M$95$m * N[(D * 0.25), $MachinePrecision]), $MachinePrecision] / N[((-l) * d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * h + 1.0), $MachinePrecision] * d), $MachinePrecision] / N[(N[Sqrt[h], $MachinePrecision] * N[Sqrt[l], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
M_m = \left|M\right|
\\
[d, h, l, M_m, D] = \mathsf{sort}([d, h, l, M_m, D])\\
\\
\begin{array}{l}
t_0 := \sqrt{-\ell}\\
\mathbf{if}\;d \leq -7 \cdot 10^{+98}:\\
\;\;\;\;\left|\frac{\frac{d}{t\_0}}{\sqrt{-h}}\right|\\
\mathbf{elif}\;d \leq -1.85 \cdot 10^{-132}:\\
\;\;\;\;\left(\mathsf{fma}\left(-0.5 \cdot \frac{h}{\ell}, \frac{\left(D \cdot D\right) \cdot \left(\left(M\_m \cdot M\_m\right) \cdot 0.25\right)}{d \cdot d}, 1\right) \cdot \sqrt{\frac{d}{\ell}}\right) \cdot \sqrt{\frac{d}{h}}\\
\mathbf{elif}\;d \leq -1.35 \cdot 10^{-298}:\\
\;\;\;\;\frac{\left(\frac{-D}{\ell} \cdot \left(\left(\left(-0.125 \cdot \sqrt{\frac{h}{\left(d \cdot d\right) \cdot d}}\right) \cdot \left(M\_m \cdot M\_m\right)\right) \cdot D\right)\right) \cdot \sqrt{-d}}{t\_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{\mathsf{fma}\left(\left(\left(\frac{0.5}{d} \cdot D\right) \cdot M\_m\right) \cdot \frac{M\_m \cdot \left(D \cdot 0.25\right)}{\left(-\ell\right) \cdot d}, h, 1\right) \cdot d}{\sqrt{h} \cdot \sqrt{\ell}}\\
\end{array}
\end{array}
if d < -7e98Initial program 71.5%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f645.9
Applied rewrites5.9%
Applied rewrites75.2%
Applied rewrites79.2%
if -7e98 < d < -1.8500000000000001e-132Initial program 85.1%
Applied rewrites68.0%
if -1.8500000000000001e-132 < d < -1.3500000000000001e-298Initial program 59.2%
Applied rewrites47.7%
Taylor expanded in h around -inf
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
unpow3N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-*.f64N/A
Applied rewrites59.3%
Applied rewrites59.5%
if -1.3500000000000001e-298 < d Initial program 72.7%
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
un-div-invN/A
lift-*.f64N/A
lift-pow.f64N/A
unpow2N/A
associate-*r*N/A
div-invN/A
times-fracN/A
lower-*.f64N/A
Applied rewrites70.9%
Applied rewrites61.4%
lift-sqrt.f64N/A
lift-*.f64N/A
sqrt-prodN/A
pow1/2N/A
lower-*.f64N/A
pow1/2N/A
lower-sqrt.f64N/A
lower-sqrt.f6479.7
Applied rewrites79.7%
Final simplification73.8%
M_m = (fabs.f64 M)
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
(FPCore (d h l M_m D)
:precision binary64
(let* ((t_0 (sqrt (- l))))
(if (<= d -7e+98)
(fabs (/ (/ d t_0) (sqrt (- h))))
(if (<= d -1.85e-132)
(*
(*
(fma
(/ (* (* (* (* D D) 0.25) (* M_m M_m)) h) (* (* d d) l))
-0.5
1.0)
(sqrt (/ d h)))
(sqrt (/ d l)))
(if (<= d -1.35e-298)
(/
(*
(*
(/ (- D) l)
(* (* (* -0.125 (sqrt (/ h (* (* d d) d)))) (* M_m M_m)) D))
(sqrt (- d)))
t_0)
(/
(*
(fma
(* (* (* (/ 0.5 d) D) M_m) (/ (* M_m (* D 0.25)) (* (- l) d)))
h
1.0)
d)
(* (sqrt h) (sqrt l))))))))M_m = fabs(M);
assert(d < h && h < l && l < M_m && M_m < D);
double code(double d, double h, double l, double M_m, double D) {
double t_0 = sqrt(-l);
double tmp;
if (d <= -7e+98) {
tmp = fabs(((d / t_0) / sqrt(-h)));
} else if (d <= -1.85e-132) {
tmp = (fma((((((D * D) * 0.25) * (M_m * M_m)) * h) / ((d * d) * l)), -0.5, 1.0) * sqrt((d / h))) * sqrt((d / l));
} else if (d <= -1.35e-298) {
tmp = (((-D / l) * (((-0.125 * sqrt((h / ((d * d) * d)))) * (M_m * M_m)) * D)) * sqrt(-d)) / t_0;
} else {
tmp = (fma(((((0.5 / d) * D) * M_m) * ((M_m * (D * 0.25)) / (-l * d))), h, 1.0) * d) / (sqrt(h) * sqrt(l));
}
return tmp;
}
M_m = abs(M) d, h, l, M_m, D = sort([d, h, l, M_m, D]) function code(d, h, l, M_m, D) t_0 = sqrt(Float64(-l)) tmp = 0.0 if (d <= -7e+98) tmp = abs(Float64(Float64(d / t_0) / sqrt(Float64(-h)))); elseif (d <= -1.85e-132) tmp = Float64(Float64(fma(Float64(Float64(Float64(Float64(Float64(D * D) * 0.25) * Float64(M_m * M_m)) * h) / Float64(Float64(d * d) * l)), -0.5, 1.0) * sqrt(Float64(d / h))) * sqrt(Float64(d / l))); elseif (d <= -1.35e-298) tmp = Float64(Float64(Float64(Float64(Float64(-D) / l) * Float64(Float64(Float64(-0.125 * sqrt(Float64(h / Float64(Float64(d * d) * d)))) * Float64(M_m * M_m)) * D)) * sqrt(Float64(-d))) / t_0); else tmp = Float64(Float64(fma(Float64(Float64(Float64(Float64(0.5 / d) * D) * M_m) * Float64(Float64(M_m * Float64(D * 0.25)) / Float64(Float64(-l) * d))), h, 1.0) * d) / Float64(sqrt(h) * sqrt(l))); end return tmp end
M_m = N[Abs[M], $MachinePrecision]
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
code[d_, h_, l_, M$95$m_, D_] := Block[{t$95$0 = N[Sqrt[(-l)], $MachinePrecision]}, If[LessEqual[d, -7e+98], N[Abs[N[(N[(d / t$95$0), $MachinePrecision] / N[Sqrt[(-h)], $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[d, -1.85e-132], N[(N[(N[(N[(N[(N[(N[(N[(D * D), $MachinePrecision] * 0.25), $MachinePrecision] * N[(M$95$m * M$95$m), $MachinePrecision]), $MachinePrecision] * h), $MachinePrecision] / N[(N[(d * d), $MachinePrecision] * l), $MachinePrecision]), $MachinePrecision] * -0.5 + 1.0), $MachinePrecision] * N[Sqrt[N[(d / h), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(d / l), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[d, -1.35e-298], N[(N[(N[(N[((-D) / l), $MachinePrecision] * N[(N[(N[(-0.125 * N[Sqrt[N[(h / N[(N[(d * d), $MachinePrecision] * d), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(M$95$m * M$95$m), $MachinePrecision]), $MachinePrecision] * D), $MachinePrecision]), $MachinePrecision] * N[Sqrt[(-d)], $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision], N[(N[(N[(N[(N[(N[(N[(0.5 / d), $MachinePrecision] * D), $MachinePrecision] * M$95$m), $MachinePrecision] * N[(N[(M$95$m * N[(D * 0.25), $MachinePrecision]), $MachinePrecision] / N[((-l) * d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * h + 1.0), $MachinePrecision] * d), $MachinePrecision] / N[(N[Sqrt[h], $MachinePrecision] * N[Sqrt[l], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
M_m = \left|M\right|
\\
[d, h, l, M_m, D] = \mathsf{sort}([d, h, l, M_m, D])\\
\\
\begin{array}{l}
t_0 := \sqrt{-\ell}\\
\mathbf{if}\;d \leq -7 \cdot 10^{+98}:\\
\;\;\;\;\left|\frac{\frac{d}{t\_0}}{\sqrt{-h}}\right|\\
\mathbf{elif}\;d \leq -1.85 \cdot 10^{-132}:\\
\;\;\;\;\left(\mathsf{fma}\left(\frac{\left(\left(\left(D \cdot D\right) \cdot 0.25\right) \cdot \left(M\_m \cdot M\_m\right)\right) \cdot h}{\left(d \cdot d\right) \cdot \ell}, -0.5, 1\right) \cdot \sqrt{\frac{d}{h}}\right) \cdot \sqrt{\frac{d}{\ell}}\\
\mathbf{elif}\;d \leq -1.35 \cdot 10^{-298}:\\
\;\;\;\;\frac{\left(\frac{-D}{\ell} \cdot \left(\left(\left(-0.125 \cdot \sqrt{\frac{h}{\left(d \cdot d\right) \cdot d}}\right) \cdot \left(M\_m \cdot M\_m\right)\right) \cdot D\right)\right) \cdot \sqrt{-d}}{t\_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{\mathsf{fma}\left(\left(\left(\frac{0.5}{d} \cdot D\right) \cdot M\_m\right) \cdot \frac{M\_m \cdot \left(D \cdot 0.25\right)}{\left(-\ell\right) \cdot d}, h, 1\right) \cdot d}{\sqrt{h} \cdot \sqrt{\ell}}\\
\end{array}
\end{array}
if d < -7e98Initial program 71.5%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f645.9
Applied rewrites5.9%
Applied rewrites75.2%
Applied rewrites79.2%
if -7e98 < d < -1.8500000000000001e-132Initial program 85.1%
Applied rewrites69.9%
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
sqrt-divN/A
lift-neg.f64N/A
lift-neg.f64N/A
frac-2negN/A
lift-/.f64N/A
pow1/2N/A
lift-/.f64N/A
Applied rewrites65.7%
if -1.8500000000000001e-132 < d < -1.3500000000000001e-298Initial program 59.2%
Applied rewrites47.7%
Taylor expanded in h around -inf
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
unpow3N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-*.f64N/A
Applied rewrites59.3%
Applied rewrites59.5%
if -1.3500000000000001e-298 < d Initial program 72.7%
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
un-div-invN/A
lift-*.f64N/A
lift-pow.f64N/A
unpow2N/A
associate-*r*N/A
div-invN/A
times-fracN/A
lower-*.f64N/A
Applied rewrites70.9%
Applied rewrites61.4%
lift-sqrt.f64N/A
lift-*.f64N/A
sqrt-prodN/A
pow1/2N/A
lower-*.f64N/A
pow1/2N/A
lower-sqrt.f64N/A
lower-sqrt.f6479.7
Applied rewrites79.7%
Final simplification73.3%
M_m = (fabs.f64 M)
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
(FPCore (d h l M_m D)
:precision binary64
(let* ((t_0 (sqrt (- l))))
(if (<= d -7e+98)
(fabs (/ (/ d t_0) (sqrt (- h))))
(if (<= d -4.1e-123)
(*
(*
(fma
(/ (* (* (* (* D D) 0.25) (* M_m M_m)) h) (* (* d d) l))
-0.5
1.0)
(sqrt (/ d h)))
(sqrt (/ d l)))
(if (<= d -1.35e-298)
(/
(*
(*
(* (- -0.125) (sqrt (/ h (* (* d d) d))))
(* (/ (* D D) l) (* M_m M_m)))
(sqrt (- d)))
t_0)
(/
(*
(fma
(* (* (* (/ 0.5 d) D) M_m) (/ (* M_m (* D 0.25)) (* (- l) d)))
h
1.0)
d)
(* (sqrt h) (sqrt l))))))))M_m = fabs(M);
assert(d < h && h < l && l < M_m && M_m < D);
double code(double d, double h, double l, double M_m, double D) {
double t_0 = sqrt(-l);
double tmp;
if (d <= -7e+98) {
tmp = fabs(((d / t_0) / sqrt(-h)));
} else if (d <= -4.1e-123) {
tmp = (fma((((((D * D) * 0.25) * (M_m * M_m)) * h) / ((d * d) * l)), -0.5, 1.0) * sqrt((d / h))) * sqrt((d / l));
} else if (d <= -1.35e-298) {
tmp = (((-(-0.125) * sqrt((h / ((d * d) * d)))) * (((D * D) / l) * (M_m * M_m))) * sqrt(-d)) / t_0;
} else {
tmp = (fma(((((0.5 / d) * D) * M_m) * ((M_m * (D * 0.25)) / (-l * d))), h, 1.0) * d) / (sqrt(h) * sqrt(l));
}
return tmp;
}
M_m = abs(M) d, h, l, M_m, D = sort([d, h, l, M_m, D]) function code(d, h, l, M_m, D) t_0 = sqrt(Float64(-l)) tmp = 0.0 if (d <= -7e+98) tmp = abs(Float64(Float64(d / t_0) / sqrt(Float64(-h)))); elseif (d <= -4.1e-123) tmp = Float64(Float64(fma(Float64(Float64(Float64(Float64(Float64(D * D) * 0.25) * Float64(M_m * M_m)) * h) / Float64(Float64(d * d) * l)), -0.5, 1.0) * sqrt(Float64(d / h))) * sqrt(Float64(d / l))); elseif (d <= -1.35e-298) tmp = Float64(Float64(Float64(Float64(Float64(-(-0.125)) * sqrt(Float64(h / Float64(Float64(d * d) * d)))) * Float64(Float64(Float64(D * D) / l) * Float64(M_m * M_m))) * sqrt(Float64(-d))) / t_0); else tmp = Float64(Float64(fma(Float64(Float64(Float64(Float64(0.5 / d) * D) * M_m) * Float64(Float64(M_m * Float64(D * 0.25)) / Float64(Float64(-l) * d))), h, 1.0) * d) / Float64(sqrt(h) * sqrt(l))); end return tmp end
M_m = N[Abs[M], $MachinePrecision]
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
code[d_, h_, l_, M$95$m_, D_] := Block[{t$95$0 = N[Sqrt[(-l)], $MachinePrecision]}, If[LessEqual[d, -7e+98], N[Abs[N[(N[(d / t$95$0), $MachinePrecision] / N[Sqrt[(-h)], $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[d, -4.1e-123], N[(N[(N[(N[(N[(N[(N[(N[(D * D), $MachinePrecision] * 0.25), $MachinePrecision] * N[(M$95$m * M$95$m), $MachinePrecision]), $MachinePrecision] * h), $MachinePrecision] / N[(N[(d * d), $MachinePrecision] * l), $MachinePrecision]), $MachinePrecision] * -0.5 + 1.0), $MachinePrecision] * N[Sqrt[N[(d / h), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(d / l), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[d, -1.35e-298], N[(N[(N[(N[((--0.125) * N[Sqrt[N[(h / N[(N[(d * d), $MachinePrecision] * d), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(N[(N[(D * D), $MachinePrecision] / l), $MachinePrecision] * N[(M$95$m * M$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sqrt[(-d)], $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision], N[(N[(N[(N[(N[(N[(N[(0.5 / d), $MachinePrecision] * D), $MachinePrecision] * M$95$m), $MachinePrecision] * N[(N[(M$95$m * N[(D * 0.25), $MachinePrecision]), $MachinePrecision] / N[((-l) * d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * h + 1.0), $MachinePrecision] * d), $MachinePrecision] / N[(N[Sqrt[h], $MachinePrecision] * N[Sqrt[l], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
M_m = \left|M\right|
\\
[d, h, l, M_m, D] = \mathsf{sort}([d, h, l, M_m, D])\\
\\
\begin{array}{l}
t_0 := \sqrt{-\ell}\\
\mathbf{if}\;d \leq -7 \cdot 10^{+98}:\\
\;\;\;\;\left|\frac{\frac{d}{t\_0}}{\sqrt{-h}}\right|\\
\mathbf{elif}\;d \leq -4.1 \cdot 10^{-123}:\\
\;\;\;\;\left(\mathsf{fma}\left(\frac{\left(\left(\left(D \cdot D\right) \cdot 0.25\right) \cdot \left(M\_m \cdot M\_m\right)\right) \cdot h}{\left(d \cdot d\right) \cdot \ell}, -0.5, 1\right) \cdot \sqrt{\frac{d}{h}}\right) \cdot \sqrt{\frac{d}{\ell}}\\
\mathbf{elif}\;d \leq -1.35 \cdot 10^{-298}:\\
\;\;\;\;\frac{\left(\left(\left(--0.125\right) \cdot \sqrt{\frac{h}{\left(d \cdot d\right) \cdot d}}\right) \cdot \left(\frac{D \cdot D}{\ell} \cdot \left(M\_m \cdot M\_m\right)\right)\right) \cdot \sqrt{-d}}{t\_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{\mathsf{fma}\left(\left(\left(\frac{0.5}{d} \cdot D\right) \cdot M\_m\right) \cdot \frac{M\_m \cdot \left(D \cdot 0.25\right)}{\left(-\ell\right) \cdot d}, h, 1\right) \cdot d}{\sqrt{h} \cdot \sqrt{\ell}}\\
\end{array}
\end{array}
if d < -7e98Initial program 71.5%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f645.9
Applied rewrites5.9%
Applied rewrites75.2%
Applied rewrites79.2%
if -7e98 < d < -4.1e-123Initial program 86.6%
Applied rewrites71.1%
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
sqrt-divN/A
lift-neg.f64N/A
lift-neg.f64N/A
frac-2negN/A
lift-/.f64N/A
pow1/2N/A
lift-/.f64N/A
Applied rewrites66.9%
if -4.1e-123 < d < -1.3500000000000001e-298Initial program 58.0%
Applied rewrites46.8%
Taylor expanded in h around -inf
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
unpow3N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-*.f64N/A
Applied rewrites58.2%
if -1.3500000000000001e-298 < d Initial program 72.7%
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
un-div-invN/A
lift-*.f64N/A
lift-pow.f64N/A
unpow2N/A
associate-*r*N/A
div-invN/A
times-fracN/A
lower-*.f64N/A
Applied rewrites70.9%
Applied rewrites61.4%
lift-sqrt.f64N/A
lift-*.f64N/A
sqrt-prodN/A
pow1/2N/A
lower-*.f64N/A
pow1/2N/A
lower-sqrt.f64N/A
lower-sqrt.f6479.7
Applied rewrites79.7%
Final simplification73.3%
M_m = (fabs.f64 M)
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
(FPCore (d h l M_m D)
:precision binary64
(let* ((t_0 (sqrt (- l))))
(if (<= d -7e+98)
(fabs (/ (/ d t_0) (sqrt (- h))))
(if (<= d -4.1e-123)
(*
(*
(fma
(/ (* (* (* (* D D) 0.25) (* M_m M_m)) h) (* (* d d) l))
-0.5
1.0)
(sqrt (/ d h)))
(sqrt (/ d l)))
(if (<= d -1.35e-298)
(/
(*
(*
(* (/ (* M_m M_m) l) (* 0.125 (* D D)))
(sqrt (/ h (* (* d d) d))))
(sqrt (- d)))
t_0)
(/
(*
(fma
(* (* (* (/ 0.5 d) D) M_m) (/ (* M_m (* D 0.25)) (* (- l) d)))
h
1.0)
d)
(* (sqrt h) (sqrt l))))))))M_m = fabs(M);
assert(d < h && h < l && l < M_m && M_m < D);
double code(double d, double h, double l, double M_m, double D) {
double t_0 = sqrt(-l);
double tmp;
if (d <= -7e+98) {
tmp = fabs(((d / t_0) / sqrt(-h)));
} else if (d <= -4.1e-123) {
tmp = (fma((((((D * D) * 0.25) * (M_m * M_m)) * h) / ((d * d) * l)), -0.5, 1.0) * sqrt((d / h))) * sqrt((d / l));
} else if (d <= -1.35e-298) {
tmp = (((((M_m * M_m) / l) * (0.125 * (D * D))) * sqrt((h / ((d * d) * d)))) * sqrt(-d)) / t_0;
} else {
tmp = (fma(((((0.5 / d) * D) * M_m) * ((M_m * (D * 0.25)) / (-l * d))), h, 1.0) * d) / (sqrt(h) * sqrt(l));
}
return tmp;
}
M_m = abs(M) d, h, l, M_m, D = sort([d, h, l, M_m, D]) function code(d, h, l, M_m, D) t_0 = sqrt(Float64(-l)) tmp = 0.0 if (d <= -7e+98) tmp = abs(Float64(Float64(d / t_0) / sqrt(Float64(-h)))); elseif (d <= -4.1e-123) tmp = Float64(Float64(fma(Float64(Float64(Float64(Float64(Float64(D * D) * 0.25) * Float64(M_m * M_m)) * h) / Float64(Float64(d * d) * l)), -0.5, 1.0) * sqrt(Float64(d / h))) * sqrt(Float64(d / l))); elseif (d <= -1.35e-298) tmp = Float64(Float64(Float64(Float64(Float64(Float64(M_m * M_m) / l) * Float64(0.125 * Float64(D * D))) * sqrt(Float64(h / Float64(Float64(d * d) * d)))) * sqrt(Float64(-d))) / t_0); else tmp = Float64(Float64(fma(Float64(Float64(Float64(Float64(0.5 / d) * D) * M_m) * Float64(Float64(M_m * Float64(D * 0.25)) / Float64(Float64(-l) * d))), h, 1.0) * d) / Float64(sqrt(h) * sqrt(l))); end return tmp end
M_m = N[Abs[M], $MachinePrecision]
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
code[d_, h_, l_, M$95$m_, D_] := Block[{t$95$0 = N[Sqrt[(-l)], $MachinePrecision]}, If[LessEqual[d, -7e+98], N[Abs[N[(N[(d / t$95$0), $MachinePrecision] / N[Sqrt[(-h)], $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[d, -4.1e-123], N[(N[(N[(N[(N[(N[(N[(N[(D * D), $MachinePrecision] * 0.25), $MachinePrecision] * N[(M$95$m * M$95$m), $MachinePrecision]), $MachinePrecision] * h), $MachinePrecision] / N[(N[(d * d), $MachinePrecision] * l), $MachinePrecision]), $MachinePrecision] * -0.5 + 1.0), $MachinePrecision] * N[Sqrt[N[(d / h), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(d / l), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[d, -1.35e-298], N[(N[(N[(N[(N[(N[(M$95$m * M$95$m), $MachinePrecision] / l), $MachinePrecision] * N[(0.125 * N[(D * D), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(h / N[(N[(d * d), $MachinePrecision] * d), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Sqrt[(-d)], $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision], N[(N[(N[(N[(N[(N[(N[(0.5 / d), $MachinePrecision] * D), $MachinePrecision] * M$95$m), $MachinePrecision] * N[(N[(M$95$m * N[(D * 0.25), $MachinePrecision]), $MachinePrecision] / N[((-l) * d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * h + 1.0), $MachinePrecision] * d), $MachinePrecision] / N[(N[Sqrt[h], $MachinePrecision] * N[Sqrt[l], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
M_m = \left|M\right|
\\
[d, h, l, M_m, D] = \mathsf{sort}([d, h, l, M_m, D])\\
\\
\begin{array}{l}
t_0 := \sqrt{-\ell}\\
\mathbf{if}\;d \leq -7 \cdot 10^{+98}:\\
\;\;\;\;\left|\frac{\frac{d}{t\_0}}{\sqrt{-h}}\right|\\
\mathbf{elif}\;d \leq -4.1 \cdot 10^{-123}:\\
\;\;\;\;\left(\mathsf{fma}\left(\frac{\left(\left(\left(D \cdot D\right) \cdot 0.25\right) \cdot \left(M\_m \cdot M\_m\right)\right) \cdot h}{\left(d \cdot d\right) \cdot \ell}, -0.5, 1\right) \cdot \sqrt{\frac{d}{h}}\right) \cdot \sqrt{\frac{d}{\ell}}\\
\mathbf{elif}\;d \leq -1.35 \cdot 10^{-298}:\\
\;\;\;\;\frac{\left(\left(\frac{M\_m \cdot M\_m}{\ell} \cdot \left(0.125 \cdot \left(D \cdot D\right)\right)\right) \cdot \sqrt{\frac{h}{\left(d \cdot d\right) \cdot d}}\right) \cdot \sqrt{-d}}{t\_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{\mathsf{fma}\left(\left(\left(\frac{0.5}{d} \cdot D\right) \cdot M\_m\right) \cdot \frac{M\_m \cdot \left(D \cdot 0.25\right)}{\left(-\ell\right) \cdot d}, h, 1\right) \cdot d}{\sqrt{h} \cdot \sqrt{\ell}}\\
\end{array}
\end{array}
if d < -7e98Initial program 71.5%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f645.9
Applied rewrites5.9%
Applied rewrites75.2%
Applied rewrites79.2%
if -7e98 < d < -4.1e-123Initial program 86.6%
Applied rewrites71.1%
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
sqrt-divN/A
lift-neg.f64N/A
lift-neg.f64N/A
frac-2negN/A
lift-/.f64N/A
pow1/2N/A
lift-/.f64N/A
Applied rewrites66.9%
if -4.1e-123 < d < -1.3500000000000001e-298Initial program 58.0%
Applied rewrites46.8%
Taylor expanded in h around -inf
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
unpow3N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-*.f64N/A
Applied rewrites58.2%
Taylor expanded in h around 0
Applied rewrites58.2%
if -1.3500000000000001e-298 < d Initial program 72.7%
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
un-div-invN/A
lift-*.f64N/A
lift-pow.f64N/A
unpow2N/A
associate-*r*N/A
div-invN/A
times-fracN/A
lower-*.f64N/A
Applied rewrites70.9%
Applied rewrites61.4%
lift-sqrt.f64N/A
lift-*.f64N/A
sqrt-prodN/A
pow1/2N/A
lower-*.f64N/A
pow1/2N/A
lower-sqrt.f64N/A
lower-sqrt.f6479.7
Applied rewrites79.7%
Final simplification73.3%
M_m = (fabs.f64 M)
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
(FPCore (d h l M_m D)
:precision binary64
(if (<= d -7e+98)
(fabs (/ (/ d (sqrt (- l))) (sqrt (- h))))
(if (<= d -3.2e-138)
(*
(*
(fma (/ (* (* (* (* D D) 0.25) (* M_m M_m)) h) (* (* d d) l)) -0.5 1.0)
(sqrt (/ d h)))
(sqrt (/ d l)))
(if (<= d -5e-310)
(fma
(* (* (* (- D) D) (sqrt (/ h (* (* l l) l)))) (* (/ M_m d) M_m))
-0.125
(* (sqrt (/ 1.0 (* l h))) (- d)))
(/
(*
(fma
(* (* (* (/ 0.5 d) D) M_m) (/ (* M_m (* D 0.25)) (* (- l) d)))
h
1.0)
d)
(* (sqrt h) (sqrt l)))))))M_m = fabs(M);
assert(d < h && h < l && l < M_m && M_m < D);
double code(double d, double h, double l, double M_m, double D) {
double tmp;
if (d <= -7e+98) {
tmp = fabs(((d / sqrt(-l)) / sqrt(-h)));
} else if (d <= -3.2e-138) {
tmp = (fma((((((D * D) * 0.25) * (M_m * M_m)) * h) / ((d * d) * l)), -0.5, 1.0) * sqrt((d / h))) * sqrt((d / l));
} else if (d <= -5e-310) {
tmp = fma((((-D * D) * sqrt((h / ((l * l) * l)))) * ((M_m / d) * M_m)), -0.125, (sqrt((1.0 / (l * h))) * -d));
} else {
tmp = (fma(((((0.5 / d) * D) * M_m) * ((M_m * (D * 0.25)) / (-l * d))), h, 1.0) * d) / (sqrt(h) * sqrt(l));
}
return tmp;
}
M_m = abs(M) d, h, l, M_m, D = sort([d, h, l, M_m, D]) function code(d, h, l, M_m, D) tmp = 0.0 if (d <= -7e+98) tmp = abs(Float64(Float64(d / sqrt(Float64(-l))) / sqrt(Float64(-h)))); elseif (d <= -3.2e-138) tmp = Float64(Float64(fma(Float64(Float64(Float64(Float64(Float64(D * D) * 0.25) * Float64(M_m * M_m)) * h) / Float64(Float64(d * d) * l)), -0.5, 1.0) * sqrt(Float64(d / h))) * sqrt(Float64(d / l))); elseif (d <= -5e-310) tmp = fma(Float64(Float64(Float64(Float64(-D) * D) * sqrt(Float64(h / Float64(Float64(l * l) * l)))) * Float64(Float64(M_m / d) * M_m)), -0.125, Float64(sqrt(Float64(1.0 / Float64(l * h))) * Float64(-d))); else tmp = Float64(Float64(fma(Float64(Float64(Float64(Float64(0.5 / d) * D) * M_m) * Float64(Float64(M_m * Float64(D * 0.25)) / Float64(Float64(-l) * d))), h, 1.0) * d) / Float64(sqrt(h) * sqrt(l))); end return tmp end
M_m = N[Abs[M], $MachinePrecision] NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function. code[d_, h_, l_, M$95$m_, D_] := If[LessEqual[d, -7e+98], N[Abs[N[(N[(d / N[Sqrt[(-l)], $MachinePrecision]), $MachinePrecision] / N[Sqrt[(-h)], $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[d, -3.2e-138], N[(N[(N[(N[(N[(N[(N[(N[(D * D), $MachinePrecision] * 0.25), $MachinePrecision] * N[(M$95$m * M$95$m), $MachinePrecision]), $MachinePrecision] * h), $MachinePrecision] / N[(N[(d * d), $MachinePrecision] * l), $MachinePrecision]), $MachinePrecision] * -0.5 + 1.0), $MachinePrecision] * N[Sqrt[N[(d / h), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(d / l), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[d, -5e-310], N[(N[(N[(N[((-D) * D), $MachinePrecision] * N[Sqrt[N[(h / N[(N[(l * l), $MachinePrecision] * l), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(N[(M$95$m / d), $MachinePrecision] * M$95$m), $MachinePrecision]), $MachinePrecision] * -0.125 + N[(N[Sqrt[N[(1.0 / N[(l * h), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * (-d)), $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[(N[(N[(N[(0.5 / d), $MachinePrecision] * D), $MachinePrecision] * M$95$m), $MachinePrecision] * N[(N[(M$95$m * N[(D * 0.25), $MachinePrecision]), $MachinePrecision] / N[((-l) * d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * h + 1.0), $MachinePrecision] * d), $MachinePrecision] / N[(N[Sqrt[h], $MachinePrecision] * N[Sqrt[l], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
M_m = \left|M\right|
\\
[d, h, l, M_m, D] = \mathsf{sort}([d, h, l, M_m, D])\\
\\
\begin{array}{l}
\mathbf{if}\;d \leq -7 \cdot 10^{+98}:\\
\;\;\;\;\left|\frac{\frac{d}{\sqrt{-\ell}}}{\sqrt{-h}}\right|\\
\mathbf{elif}\;d \leq -3.2 \cdot 10^{-138}:\\
\;\;\;\;\left(\mathsf{fma}\left(\frac{\left(\left(\left(D \cdot D\right) \cdot 0.25\right) \cdot \left(M\_m \cdot M\_m\right)\right) \cdot h}{\left(d \cdot d\right) \cdot \ell}, -0.5, 1\right) \cdot \sqrt{\frac{d}{h}}\right) \cdot \sqrt{\frac{d}{\ell}}\\
\mathbf{elif}\;d \leq -5 \cdot 10^{-310}:\\
\;\;\;\;\mathsf{fma}\left(\left(\left(\left(-D\right) \cdot D\right) \cdot \sqrt{\frac{h}{\left(\ell \cdot \ell\right) \cdot \ell}}\right) \cdot \left(\frac{M\_m}{d} \cdot M\_m\right), -0.125, \sqrt{\frac{1}{\ell \cdot h}} \cdot \left(-d\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\mathsf{fma}\left(\left(\left(\frac{0.5}{d} \cdot D\right) \cdot M\_m\right) \cdot \frac{M\_m \cdot \left(D \cdot 0.25\right)}{\left(-\ell\right) \cdot d}, h, 1\right) \cdot d}{\sqrt{h} \cdot \sqrt{\ell}}\\
\end{array}
\end{array}
if d < -7e98Initial program 71.5%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f645.9
Applied rewrites5.9%
Applied rewrites75.2%
Applied rewrites79.2%
if -7e98 < d < -3.2000000000000001e-138Initial program 84.3%
Applied rewrites68.5%
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
sqrt-divN/A
lift-neg.f64N/A
lift-neg.f64N/A
frac-2negN/A
lift-/.f64N/A
pow1/2N/A
lift-/.f64N/A
Applied rewrites64.6%
if -3.2000000000000001e-138 < d < -4.999999999999985e-310Initial program 57.4%
Applied rewrites45.2%
Taylor expanded in h around -inf
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
unpow3N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-*.f64N/A
Applied rewrites55.0%
Taylor expanded in l around -inf
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites50.1%
if -4.999999999999985e-310 < d Initial program 73.0%
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
un-div-invN/A
lift-*.f64N/A
lift-pow.f64N/A
unpow2N/A
associate-*r*N/A
div-invN/A
times-fracN/A
lower-*.f64N/A
Applied rewrites71.3%
Applied rewrites62.4%
lift-sqrt.f64N/A
lift-*.f64N/A
sqrt-prodN/A
pow1/2N/A
lower-*.f64N/A
pow1/2N/A
lower-sqrt.f64N/A
lower-sqrt.f6481.1
Applied rewrites81.1%
Final simplification72.1%
M_m = (fabs.f64 M)
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
(FPCore (d h l M_m D)
:precision binary64
(if (<= d -2.05e-77)
(fabs (/ d (* (sqrt (- h)) (sqrt (- l)))))
(if (<= d -5e-310)
(fma
(* (* (* (- D) D) (sqrt (/ h (* (* l l) l)))) (* (/ M_m d) M_m))
-0.125
(* (sqrt (/ 1.0 (* l h))) (- d)))
(/
(*
(fma
(* (* (* (/ 0.5 d) D) M_m) (/ (* M_m (* D 0.25)) (* (- l) d)))
h
1.0)
d)
(* (sqrt h) (sqrt l))))))M_m = fabs(M);
assert(d < h && h < l && l < M_m && M_m < D);
double code(double d, double h, double l, double M_m, double D) {
double tmp;
if (d <= -2.05e-77) {
tmp = fabs((d / (sqrt(-h) * sqrt(-l))));
} else if (d <= -5e-310) {
tmp = fma((((-D * D) * sqrt((h / ((l * l) * l)))) * ((M_m / d) * M_m)), -0.125, (sqrt((1.0 / (l * h))) * -d));
} else {
tmp = (fma(((((0.5 / d) * D) * M_m) * ((M_m * (D * 0.25)) / (-l * d))), h, 1.0) * d) / (sqrt(h) * sqrt(l));
}
return tmp;
}
M_m = abs(M) d, h, l, M_m, D = sort([d, h, l, M_m, D]) function code(d, h, l, M_m, D) tmp = 0.0 if (d <= -2.05e-77) tmp = abs(Float64(d / Float64(sqrt(Float64(-h)) * sqrt(Float64(-l))))); elseif (d <= -5e-310) tmp = fma(Float64(Float64(Float64(Float64(-D) * D) * sqrt(Float64(h / Float64(Float64(l * l) * l)))) * Float64(Float64(M_m / d) * M_m)), -0.125, Float64(sqrt(Float64(1.0 / Float64(l * h))) * Float64(-d))); else tmp = Float64(Float64(fma(Float64(Float64(Float64(Float64(0.5 / d) * D) * M_m) * Float64(Float64(M_m * Float64(D * 0.25)) / Float64(Float64(-l) * d))), h, 1.0) * d) / Float64(sqrt(h) * sqrt(l))); end return tmp end
M_m = N[Abs[M], $MachinePrecision] NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function. code[d_, h_, l_, M$95$m_, D_] := If[LessEqual[d, -2.05e-77], N[Abs[N[(d / N[(N[Sqrt[(-h)], $MachinePrecision] * N[Sqrt[(-l)], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[d, -5e-310], N[(N[(N[(N[((-D) * D), $MachinePrecision] * N[Sqrt[N[(h / N[(N[(l * l), $MachinePrecision] * l), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(N[(M$95$m / d), $MachinePrecision] * M$95$m), $MachinePrecision]), $MachinePrecision] * -0.125 + N[(N[Sqrt[N[(1.0 / N[(l * h), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * (-d)), $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[(N[(N[(N[(0.5 / d), $MachinePrecision] * D), $MachinePrecision] * M$95$m), $MachinePrecision] * N[(N[(M$95$m * N[(D * 0.25), $MachinePrecision]), $MachinePrecision] / N[((-l) * d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * h + 1.0), $MachinePrecision] * d), $MachinePrecision] / N[(N[Sqrt[h], $MachinePrecision] * N[Sqrt[l], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
M_m = \left|M\right|
\\
[d, h, l, M_m, D] = \mathsf{sort}([d, h, l, M_m, D])\\
\\
\begin{array}{l}
\mathbf{if}\;d \leq -2.05 \cdot 10^{-77}:\\
\;\;\;\;\left|\frac{d}{\sqrt{-h} \cdot \sqrt{-\ell}}\right|\\
\mathbf{elif}\;d \leq -5 \cdot 10^{-310}:\\
\;\;\;\;\mathsf{fma}\left(\left(\left(\left(-D\right) \cdot D\right) \cdot \sqrt{\frac{h}{\left(\ell \cdot \ell\right) \cdot \ell}}\right) \cdot \left(\frac{M\_m}{d} \cdot M\_m\right), -0.125, \sqrt{\frac{1}{\ell \cdot h}} \cdot \left(-d\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\mathsf{fma}\left(\left(\left(\frac{0.5}{d} \cdot D\right) \cdot M\_m\right) \cdot \frac{M\_m \cdot \left(D \cdot 0.25\right)}{\left(-\ell\right) \cdot d}, h, 1\right) \cdot d}{\sqrt{h} \cdot \sqrt{\ell}}\\
\end{array}
\end{array}
if d < -2.04999999999999981e-77Initial program 78.8%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f646.9
Applied rewrites6.9%
Applied rewrites55.9%
Applied rewrites67.6%
if -2.04999999999999981e-77 < d < -4.999999999999985e-310Initial program 62.2%
Applied rewrites47.4%
Taylor expanded in h around -inf
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
unpow3N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-*.f64N/A
Applied rewrites49.7%
Taylor expanded in l around -inf
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites45.8%
if -4.999999999999985e-310 < d Initial program 73.0%
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
un-div-invN/A
lift-*.f64N/A
lift-pow.f64N/A
unpow2N/A
associate-*r*N/A
div-invN/A
times-fracN/A
lower-*.f64N/A
Applied rewrites71.3%
Applied rewrites62.4%
lift-sqrt.f64N/A
lift-*.f64N/A
sqrt-prodN/A
pow1/2N/A
lower-*.f64N/A
pow1/2N/A
lower-sqrt.f64N/A
lower-sqrt.f6481.1
Applied rewrites81.1%
Final simplification68.9%
M_m = (fabs.f64 M)
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
(FPCore (d h l M_m D)
:precision binary64
(let* ((t_0 (/ -1.0 (* l h))))
(if (<= l -7.8e-169)
(fabs (/ d (* (sqrt (- h)) (sqrt (- l)))))
(if (<= l -4.1e-297)
(* (sqrt (sqrt (* t_0 t_0))) d)
(if (<= l 7.6e+69)
(/
(*
(fma
(* (/ (/ (* -0.25 (* M_m D)) l) d) (* (* (/ 0.5 d) D) M_m))
h
1.0)
d)
(sqrt (* l h)))
(/ d (* (sqrt h) (sqrt l))))))))M_m = fabs(M);
assert(d < h && h < l && l < M_m && M_m < D);
double code(double d, double h, double l, double M_m, double D) {
double t_0 = -1.0 / (l * h);
double tmp;
if (l <= -7.8e-169) {
tmp = fabs((d / (sqrt(-h) * sqrt(-l))));
} else if (l <= -4.1e-297) {
tmp = sqrt(sqrt((t_0 * t_0))) * d;
} else if (l <= 7.6e+69) {
tmp = (fma(((((-0.25 * (M_m * D)) / l) / d) * (((0.5 / d) * D) * M_m)), h, 1.0) * d) / sqrt((l * h));
} else {
tmp = d / (sqrt(h) * sqrt(l));
}
return tmp;
}
M_m = abs(M) d, h, l, M_m, D = sort([d, h, l, M_m, D]) function code(d, h, l, M_m, D) t_0 = Float64(-1.0 / Float64(l * h)) tmp = 0.0 if (l <= -7.8e-169) tmp = abs(Float64(d / Float64(sqrt(Float64(-h)) * sqrt(Float64(-l))))); elseif (l <= -4.1e-297) tmp = Float64(sqrt(sqrt(Float64(t_0 * t_0))) * d); elseif (l <= 7.6e+69) tmp = Float64(Float64(fma(Float64(Float64(Float64(Float64(-0.25 * Float64(M_m * D)) / l) / d) * Float64(Float64(Float64(0.5 / d) * D) * M_m)), h, 1.0) * d) / sqrt(Float64(l * h))); else tmp = Float64(d / Float64(sqrt(h) * sqrt(l))); end return tmp end
M_m = N[Abs[M], $MachinePrecision]
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
code[d_, h_, l_, M$95$m_, D_] := Block[{t$95$0 = N[(-1.0 / N[(l * h), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[l, -7.8e-169], N[Abs[N[(d / N[(N[Sqrt[(-h)], $MachinePrecision] * N[Sqrt[(-l)], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[l, -4.1e-297], N[(N[Sqrt[N[Sqrt[N[(t$95$0 * t$95$0), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] * d), $MachinePrecision], If[LessEqual[l, 7.6e+69], N[(N[(N[(N[(N[(N[(N[(-0.25 * N[(M$95$m * D), $MachinePrecision]), $MachinePrecision] / l), $MachinePrecision] / d), $MachinePrecision] * N[(N[(N[(0.5 / d), $MachinePrecision] * D), $MachinePrecision] * M$95$m), $MachinePrecision]), $MachinePrecision] * h + 1.0), $MachinePrecision] * d), $MachinePrecision] / N[Sqrt[N[(l * h), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(d / N[(N[Sqrt[h], $MachinePrecision] * N[Sqrt[l], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
M_m = \left|M\right|
\\
[d, h, l, M_m, D] = \mathsf{sort}([d, h, l, M_m, D])\\
\\
\begin{array}{l}
t_0 := \frac{-1}{\ell \cdot h}\\
\mathbf{if}\;\ell \leq -7.8 \cdot 10^{-169}:\\
\;\;\;\;\left|\frac{d}{\sqrt{-h} \cdot \sqrt{-\ell}}\right|\\
\mathbf{elif}\;\ell \leq -4.1 \cdot 10^{-297}:\\
\;\;\;\;\sqrt{\sqrt{t\_0 \cdot t\_0}} \cdot d\\
\mathbf{elif}\;\ell \leq 7.6 \cdot 10^{+69}:\\
\;\;\;\;\frac{\mathsf{fma}\left(\frac{\frac{-0.25 \cdot \left(M\_m \cdot D\right)}{\ell}}{d} \cdot \left(\left(\frac{0.5}{d} \cdot D\right) \cdot M\_m\right), h, 1\right) \cdot d}{\sqrt{\ell \cdot h}}\\
\mathbf{else}:\\
\;\;\;\;\frac{d}{\sqrt{h} \cdot \sqrt{\ell}}\\
\end{array}
\end{array}
if l < -7.79999999999999954e-169Initial program 69.0%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f646.9
Applied rewrites6.9%
Applied rewrites49.6%
Applied rewrites58.1%
if -7.79999999999999954e-169 < l < -4.1000000000000002e-297Initial program 88.8%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6436.1
Applied rewrites36.1%
Applied rewrites54.8%
if -4.1000000000000002e-297 < l < 7.60000000000000055e69Initial program 81.3%
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
un-div-invN/A
lift-*.f64N/A
lift-pow.f64N/A
unpow2N/A
associate-*r*N/A
div-invN/A
times-fracN/A
lower-*.f64N/A
Applied rewrites79.9%
Applied rewrites75.9%
lift-neg.f64N/A
lift-/.f64N/A
distribute-neg-fracN/A
lift-*.f64N/A
associate-/r*N/A
lower-/.f64N/A
lower-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
metadata-evalN/A
lower-*.f6480.3
Applied rewrites80.3%
if 7.60000000000000055e69 < l Initial program 60.5%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6445.4
Applied rewrites45.4%
Applied rewrites45.4%
Applied rewrites69.1%
Final simplification65.7%
M_m = (fabs.f64 M)
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
(FPCore (d h l M_m D)
:precision binary64
(if (<= d -4e-121)
(fabs (/ (/ d (sqrt (- l))) (sqrt (- h))))
(if (<= d -5e-310)
(* (* (/ (* M_m M_m) d) (* 0.125 (* D D))) (sqrt (/ h (* (* l l) l))))
(/
(*
(fma
(* (* (* (/ 0.5 d) D) M_m) (/ (* M_m (* D 0.25)) (* (- l) d)))
h
1.0)
d)
(* (sqrt h) (sqrt l))))))M_m = fabs(M);
assert(d < h && h < l && l < M_m && M_m < D);
double code(double d, double h, double l, double M_m, double D) {
double tmp;
if (d <= -4e-121) {
tmp = fabs(((d / sqrt(-l)) / sqrt(-h)));
} else if (d <= -5e-310) {
tmp = (((M_m * M_m) / d) * (0.125 * (D * D))) * sqrt((h / ((l * l) * l)));
} else {
tmp = (fma(((((0.5 / d) * D) * M_m) * ((M_m * (D * 0.25)) / (-l * d))), h, 1.0) * d) / (sqrt(h) * sqrt(l));
}
return tmp;
}
M_m = abs(M) d, h, l, M_m, D = sort([d, h, l, M_m, D]) function code(d, h, l, M_m, D) tmp = 0.0 if (d <= -4e-121) tmp = abs(Float64(Float64(d / sqrt(Float64(-l))) / sqrt(Float64(-h)))); elseif (d <= -5e-310) tmp = Float64(Float64(Float64(Float64(M_m * M_m) / d) * Float64(0.125 * Float64(D * D))) * sqrt(Float64(h / Float64(Float64(l * l) * l)))); else tmp = Float64(Float64(fma(Float64(Float64(Float64(Float64(0.5 / d) * D) * M_m) * Float64(Float64(M_m * Float64(D * 0.25)) / Float64(Float64(-l) * d))), h, 1.0) * d) / Float64(sqrt(h) * sqrt(l))); end return tmp end
M_m = N[Abs[M], $MachinePrecision] NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function. code[d_, h_, l_, M$95$m_, D_] := If[LessEqual[d, -4e-121], N[Abs[N[(N[(d / N[Sqrt[(-l)], $MachinePrecision]), $MachinePrecision] / N[Sqrt[(-h)], $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[d, -5e-310], N[(N[(N[(N[(M$95$m * M$95$m), $MachinePrecision] / d), $MachinePrecision] * N[(0.125 * N[(D * D), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(h / N[(N[(l * l), $MachinePrecision] * l), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[(N[(N[(N[(0.5 / d), $MachinePrecision] * D), $MachinePrecision] * M$95$m), $MachinePrecision] * N[(N[(M$95$m * N[(D * 0.25), $MachinePrecision]), $MachinePrecision] / N[((-l) * d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * h + 1.0), $MachinePrecision] * d), $MachinePrecision] / N[(N[Sqrt[h], $MachinePrecision] * N[Sqrt[l], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
M_m = \left|M\right|
\\
[d, h, l, M_m, D] = \mathsf{sort}([d, h, l, M_m, D])\\
\\
\begin{array}{l}
\mathbf{if}\;d \leq -4 \cdot 10^{-121}:\\
\;\;\;\;\left|\frac{\frac{d}{\sqrt{-\ell}}}{\sqrt{-h}}\right|\\
\mathbf{elif}\;d \leq -5 \cdot 10^{-310}:\\
\;\;\;\;\left(\frac{M\_m \cdot M\_m}{d} \cdot \left(0.125 \cdot \left(D \cdot D\right)\right)\right) \cdot \sqrt{\frac{h}{\left(\ell \cdot \ell\right) \cdot \ell}}\\
\mathbf{else}:\\
\;\;\;\;\frac{\mathsf{fma}\left(\left(\left(\frac{0.5}{d} \cdot D\right) \cdot M\_m\right) \cdot \frac{M\_m \cdot \left(D \cdot 0.25\right)}{\left(-\ell\right) \cdot d}, h, 1\right) \cdot d}{\sqrt{h} \cdot \sqrt{\ell}}\\
\end{array}
\end{array}
if d < -3.9999999999999999e-121Initial program 79.6%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f646.5
Applied rewrites6.5%
Applied rewrites55.0%
Applied rewrites66.2%
if -3.9999999999999999e-121 < d < -4.999999999999985e-310Initial program 57.8%
Taylor expanded in h around -inf
associate-*r*N/A
lower-*.f64N/A
Applied rewrites43.5%
if -4.999999999999985e-310 < d Initial program 73.0%
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
un-div-invN/A
lift-*.f64N/A
lift-pow.f64N/A
unpow2N/A
associate-*r*N/A
div-invN/A
times-fracN/A
lower-*.f64N/A
Applied rewrites71.3%
Applied rewrites62.4%
lift-sqrt.f64N/A
lift-*.f64N/A
sqrt-prodN/A
pow1/2N/A
lower-*.f64N/A
pow1/2N/A
lower-sqrt.f64N/A
lower-sqrt.f6481.1
Applied rewrites81.1%
Final simplification68.7%
M_m = (fabs.f64 M)
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
(FPCore (d h l M_m D)
:precision binary64
(let* ((t_0 (/ -1.0 (* l h))))
(if (<= l -7.8e-169)
(fabs (/ d (* (sqrt (- h)) (sqrt (- l)))))
(if (<= l -5e-310)
(* (sqrt (sqrt (* t_0 t_0))) d)
(if (<= l 7.6e+69)
(*
(/
(fma
(/ (* -0.25 (* M_m D)) (* l d))
(* (* (* (/ 0.5 d) D) M_m) h)
1.0)
(sqrt (* l h)))
d)
(/ d (* (sqrt h) (sqrt l))))))))M_m = fabs(M);
assert(d < h && h < l && l < M_m && M_m < D);
double code(double d, double h, double l, double M_m, double D) {
double t_0 = -1.0 / (l * h);
double tmp;
if (l <= -7.8e-169) {
tmp = fabs((d / (sqrt(-h) * sqrt(-l))));
} else if (l <= -5e-310) {
tmp = sqrt(sqrt((t_0 * t_0))) * d;
} else if (l <= 7.6e+69) {
tmp = (fma(((-0.25 * (M_m * D)) / (l * d)), ((((0.5 / d) * D) * M_m) * h), 1.0) / sqrt((l * h))) * d;
} else {
tmp = d / (sqrt(h) * sqrt(l));
}
return tmp;
}
M_m = abs(M) d, h, l, M_m, D = sort([d, h, l, M_m, D]) function code(d, h, l, M_m, D) t_0 = Float64(-1.0 / Float64(l * h)) tmp = 0.0 if (l <= -7.8e-169) tmp = abs(Float64(d / Float64(sqrt(Float64(-h)) * sqrt(Float64(-l))))); elseif (l <= -5e-310) tmp = Float64(sqrt(sqrt(Float64(t_0 * t_0))) * d); elseif (l <= 7.6e+69) tmp = Float64(Float64(fma(Float64(Float64(-0.25 * Float64(M_m * D)) / Float64(l * d)), Float64(Float64(Float64(Float64(0.5 / d) * D) * M_m) * h), 1.0) / sqrt(Float64(l * h))) * d); else tmp = Float64(d / Float64(sqrt(h) * sqrt(l))); end return tmp end
M_m = N[Abs[M], $MachinePrecision]
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
code[d_, h_, l_, M$95$m_, D_] := Block[{t$95$0 = N[(-1.0 / N[(l * h), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[l, -7.8e-169], N[Abs[N[(d / N[(N[Sqrt[(-h)], $MachinePrecision] * N[Sqrt[(-l)], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[l, -5e-310], N[(N[Sqrt[N[Sqrt[N[(t$95$0 * t$95$0), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] * d), $MachinePrecision], If[LessEqual[l, 7.6e+69], N[(N[(N[(N[(N[(-0.25 * N[(M$95$m * D), $MachinePrecision]), $MachinePrecision] / N[(l * d), $MachinePrecision]), $MachinePrecision] * N[(N[(N[(N[(0.5 / d), $MachinePrecision] * D), $MachinePrecision] * M$95$m), $MachinePrecision] * h), $MachinePrecision] + 1.0), $MachinePrecision] / N[Sqrt[N[(l * h), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * d), $MachinePrecision], N[(d / N[(N[Sqrt[h], $MachinePrecision] * N[Sqrt[l], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
M_m = \left|M\right|
\\
[d, h, l, M_m, D] = \mathsf{sort}([d, h, l, M_m, D])\\
\\
\begin{array}{l}
t_0 := \frac{-1}{\ell \cdot h}\\
\mathbf{if}\;\ell \leq -7.8 \cdot 10^{-169}:\\
\;\;\;\;\left|\frac{d}{\sqrt{-h} \cdot \sqrt{-\ell}}\right|\\
\mathbf{elif}\;\ell \leq -5 \cdot 10^{-310}:\\
\;\;\;\;\sqrt{\sqrt{t\_0 \cdot t\_0}} \cdot d\\
\mathbf{elif}\;\ell \leq 7.6 \cdot 10^{+69}:\\
\;\;\;\;\frac{\mathsf{fma}\left(\frac{-0.25 \cdot \left(M\_m \cdot D\right)}{\ell \cdot d}, \left(\left(\frac{0.5}{d} \cdot D\right) \cdot M\_m\right) \cdot h, 1\right)}{\sqrt{\ell \cdot h}} \cdot d\\
\mathbf{else}:\\
\;\;\;\;\frac{d}{\sqrt{h} \cdot \sqrt{\ell}}\\
\end{array}
\end{array}
if l < -7.79999999999999954e-169Initial program 69.0%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f646.9
Applied rewrites6.9%
Applied rewrites49.6%
Applied rewrites58.1%
if -7.79999999999999954e-169 < l < -4.999999999999985e-310Initial program 86.4%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6433.5
Applied rewrites33.5%
Applied rewrites50.9%
if -4.999999999999985e-310 < l < 7.60000000000000055e69Initial program 82.1%
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
un-div-invN/A
lift-*.f64N/A
lift-pow.f64N/A
unpow2N/A
associate-*r*N/A
div-invN/A
times-fracN/A
lower-*.f64N/A
Applied rewrites80.6%
Applied rewrites78.2%
Applied rewrites79.6%
if 7.60000000000000055e69 < l Initial program 60.5%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6445.4
Applied rewrites45.4%
Applied rewrites45.4%
Applied rewrites69.1%
Final simplification64.9%
M_m = (fabs.f64 M)
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
(FPCore (d h l M_m D)
:precision binary64
(if (<= l -5e-310)
(fabs (/ d (* (sqrt (- h)) (sqrt (- l)))))
(if (<= l 4.7e-228)
(* (sqrt (/ 1.0 (* l h))) (- d))
(/ d (* (sqrt h) (sqrt l))))))M_m = fabs(M);
assert(d < h && h < l && l < M_m && M_m < D);
double code(double d, double h, double l, double M_m, double D) {
double tmp;
if (l <= -5e-310) {
tmp = fabs((d / (sqrt(-h) * sqrt(-l))));
} else if (l <= 4.7e-228) {
tmp = sqrt((1.0 / (l * h))) * -d;
} else {
tmp = d / (sqrt(h) * sqrt(l));
}
return tmp;
}
M_m = abs(m)
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
real(8) function code(d, h, l, m_m, d_1)
real(8), intent (in) :: d
real(8), intent (in) :: h
real(8), intent (in) :: l
real(8), intent (in) :: m_m
real(8), intent (in) :: d_1
real(8) :: tmp
if (l <= (-5d-310)) then
tmp = abs((d / (sqrt(-h) * sqrt(-l))))
else if (l <= 4.7d-228) then
tmp = sqrt((1.0d0 / (l * h))) * -d
else
tmp = d / (sqrt(h) * sqrt(l))
end if
code = tmp
end function
M_m = Math.abs(M);
assert d < h && h < l && l < M_m && M_m < D;
public static double code(double d, double h, double l, double M_m, double D) {
double tmp;
if (l <= -5e-310) {
tmp = Math.abs((d / (Math.sqrt(-h) * Math.sqrt(-l))));
} else if (l <= 4.7e-228) {
tmp = Math.sqrt((1.0 / (l * h))) * -d;
} else {
tmp = d / (Math.sqrt(h) * Math.sqrt(l));
}
return tmp;
}
M_m = math.fabs(M) [d, h, l, M_m, D] = sort([d, h, l, M_m, D]) def code(d, h, l, M_m, D): tmp = 0 if l <= -5e-310: tmp = math.fabs((d / (math.sqrt(-h) * math.sqrt(-l)))) elif l <= 4.7e-228: tmp = math.sqrt((1.0 / (l * h))) * -d else: tmp = d / (math.sqrt(h) * math.sqrt(l)) return tmp
M_m = abs(M) d, h, l, M_m, D = sort([d, h, l, M_m, D]) function code(d, h, l, M_m, D) tmp = 0.0 if (l <= -5e-310) tmp = abs(Float64(d / Float64(sqrt(Float64(-h)) * sqrt(Float64(-l))))); elseif (l <= 4.7e-228) tmp = Float64(sqrt(Float64(1.0 / Float64(l * h))) * Float64(-d)); else tmp = Float64(d / Float64(sqrt(h) * sqrt(l))); end return tmp end
M_m = abs(M);
d, h, l, M_m, D = num2cell(sort([d, h, l, M_m, D])){:}
function tmp_2 = code(d, h, l, M_m, D)
tmp = 0.0;
if (l <= -5e-310)
tmp = abs((d / (sqrt(-h) * sqrt(-l))));
elseif (l <= 4.7e-228)
tmp = sqrt((1.0 / (l * h))) * -d;
else
tmp = d / (sqrt(h) * sqrt(l));
end
tmp_2 = tmp;
end
M_m = N[Abs[M], $MachinePrecision] NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function. code[d_, h_, l_, M$95$m_, D_] := If[LessEqual[l, -5e-310], N[Abs[N[(d / N[(N[Sqrt[(-h)], $MachinePrecision] * N[Sqrt[(-l)], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[l, 4.7e-228], N[(N[Sqrt[N[(1.0 / N[(l * h), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * (-d)), $MachinePrecision], N[(d / N[(N[Sqrt[h], $MachinePrecision] * N[Sqrt[l], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
M_m = \left|M\right|
\\
[d, h, l, M_m, D] = \mathsf{sort}([d, h, l, M_m, D])\\
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq -5 \cdot 10^{-310}:\\
\;\;\;\;\left|\frac{d}{\sqrt{-h} \cdot \sqrt{-\ell}}\right|\\
\mathbf{elif}\;\ell \leq 4.7 \cdot 10^{-228}:\\
\;\;\;\;\sqrt{\frac{1}{\ell \cdot h}} \cdot \left(-d\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{d}{\sqrt{h} \cdot \sqrt{\ell}}\\
\end{array}
\end{array}
if l < -4.999999999999985e-310Initial program 72.4%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6412.1
Applied rewrites12.1%
Applied rewrites44.2%
Applied rewrites51.6%
if -4.999999999999985e-310 < l < 4.7000000000000002e-228Initial program 83.3%
Taylor expanded in l around -inf
*-commutativeN/A
unpow2N/A
rem-square-sqrtN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6458.7
Applied rewrites58.7%
if 4.7000000000000002e-228 < l Initial program 71.8%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6442.0
Applied rewrites42.0%
Applied rewrites42.0%
Applied rewrites56.0%
Final simplification53.7%
M_m = (fabs.f64 M) NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function. (FPCore (d h l M_m D) :precision binary64 (if (<= l 4.7e-228) (/ 1.0 (/ (sqrt (* l h)) (- d))) (/ d (* (sqrt h) (sqrt l)))))
M_m = fabs(M);
assert(d < h && h < l && l < M_m && M_m < D);
double code(double d, double h, double l, double M_m, double D) {
double tmp;
if (l <= 4.7e-228) {
tmp = 1.0 / (sqrt((l * h)) / -d);
} else {
tmp = d / (sqrt(h) * sqrt(l));
}
return tmp;
}
M_m = abs(m)
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
real(8) function code(d, h, l, m_m, d_1)
real(8), intent (in) :: d
real(8), intent (in) :: h
real(8), intent (in) :: l
real(8), intent (in) :: m_m
real(8), intent (in) :: d_1
real(8) :: tmp
if (l <= 4.7d-228) then
tmp = 1.0d0 / (sqrt((l * h)) / -d)
else
tmp = d / (sqrt(h) * sqrt(l))
end if
code = tmp
end function
M_m = Math.abs(M);
assert d < h && h < l && l < M_m && M_m < D;
public static double code(double d, double h, double l, double M_m, double D) {
double tmp;
if (l <= 4.7e-228) {
tmp = 1.0 / (Math.sqrt((l * h)) / -d);
} else {
tmp = d / (Math.sqrt(h) * Math.sqrt(l));
}
return tmp;
}
M_m = math.fabs(M) [d, h, l, M_m, D] = sort([d, h, l, M_m, D]) def code(d, h, l, M_m, D): tmp = 0 if l <= 4.7e-228: tmp = 1.0 / (math.sqrt((l * h)) / -d) else: tmp = d / (math.sqrt(h) * math.sqrt(l)) return tmp
M_m = abs(M) d, h, l, M_m, D = sort([d, h, l, M_m, D]) function code(d, h, l, M_m, D) tmp = 0.0 if (l <= 4.7e-228) tmp = Float64(1.0 / Float64(sqrt(Float64(l * h)) / Float64(-d))); else tmp = Float64(d / Float64(sqrt(h) * sqrt(l))); end return tmp end
M_m = abs(M);
d, h, l, M_m, D = num2cell(sort([d, h, l, M_m, D])){:}
function tmp_2 = code(d, h, l, M_m, D)
tmp = 0.0;
if (l <= 4.7e-228)
tmp = 1.0 / (sqrt((l * h)) / -d);
else
tmp = d / (sqrt(h) * sqrt(l));
end
tmp_2 = tmp;
end
M_m = N[Abs[M], $MachinePrecision] NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function. code[d_, h_, l_, M$95$m_, D_] := If[LessEqual[l, 4.7e-228], N[(1.0 / N[(N[Sqrt[N[(l * h), $MachinePrecision]], $MachinePrecision] / (-d)), $MachinePrecision]), $MachinePrecision], N[(d / N[(N[Sqrt[h], $MachinePrecision] * N[Sqrt[l], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
M_m = \left|M\right|
\\
[d, h, l, M_m, D] = \mathsf{sort}([d, h, l, M_m, D])\\
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq 4.7 \cdot 10^{-228}:\\
\;\;\;\;\frac{1}{\frac{\sqrt{\ell \cdot h}}{-d}}\\
\mathbf{else}:\\
\;\;\;\;\frac{d}{\sqrt{h} \cdot \sqrt{\ell}}\\
\end{array}
\end{array}
if l < 4.7000000000000002e-228Initial program 73.2%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6412.5
Applied rewrites12.5%
Applied rewrites29.8%
Taylor expanded in d around -inf
Applied rewrites45.3%
if 4.7000000000000002e-228 < l Initial program 71.8%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6442.0
Applied rewrites42.0%
Applied rewrites42.0%
Applied rewrites56.0%
Final simplification49.6%
M_m = (fabs.f64 M) NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function. (FPCore (d h l M_m D) :precision binary64 (if (<= l 4.7e-228) (* (sqrt (/ 1.0 (* l h))) (- d)) (/ d (* (sqrt h) (sqrt l)))))
M_m = fabs(M);
assert(d < h && h < l && l < M_m && M_m < D);
double code(double d, double h, double l, double M_m, double D) {
double tmp;
if (l <= 4.7e-228) {
tmp = sqrt((1.0 / (l * h))) * -d;
} else {
tmp = d / (sqrt(h) * sqrt(l));
}
return tmp;
}
M_m = abs(m)
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
real(8) function code(d, h, l, m_m, d_1)
real(8), intent (in) :: d
real(8), intent (in) :: h
real(8), intent (in) :: l
real(8), intent (in) :: m_m
real(8), intent (in) :: d_1
real(8) :: tmp
if (l <= 4.7d-228) then
tmp = sqrt((1.0d0 / (l * h))) * -d
else
tmp = d / (sqrt(h) * sqrt(l))
end if
code = tmp
end function
M_m = Math.abs(M);
assert d < h && h < l && l < M_m && M_m < D;
public static double code(double d, double h, double l, double M_m, double D) {
double tmp;
if (l <= 4.7e-228) {
tmp = Math.sqrt((1.0 / (l * h))) * -d;
} else {
tmp = d / (Math.sqrt(h) * Math.sqrt(l));
}
return tmp;
}
M_m = math.fabs(M) [d, h, l, M_m, D] = sort([d, h, l, M_m, D]) def code(d, h, l, M_m, D): tmp = 0 if l <= 4.7e-228: tmp = math.sqrt((1.0 / (l * h))) * -d else: tmp = d / (math.sqrt(h) * math.sqrt(l)) return tmp
M_m = abs(M) d, h, l, M_m, D = sort([d, h, l, M_m, D]) function code(d, h, l, M_m, D) tmp = 0.0 if (l <= 4.7e-228) tmp = Float64(sqrt(Float64(1.0 / Float64(l * h))) * Float64(-d)); else tmp = Float64(d / Float64(sqrt(h) * sqrt(l))); end return tmp end
M_m = abs(M);
d, h, l, M_m, D = num2cell(sort([d, h, l, M_m, D])){:}
function tmp_2 = code(d, h, l, M_m, D)
tmp = 0.0;
if (l <= 4.7e-228)
tmp = sqrt((1.0 / (l * h))) * -d;
else
tmp = d / (sqrt(h) * sqrt(l));
end
tmp_2 = tmp;
end
M_m = N[Abs[M], $MachinePrecision] NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function. code[d_, h_, l_, M$95$m_, D_] := If[LessEqual[l, 4.7e-228], N[(N[Sqrt[N[(1.0 / N[(l * h), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * (-d)), $MachinePrecision], N[(d / N[(N[Sqrt[h], $MachinePrecision] * N[Sqrt[l], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
M_m = \left|M\right|
\\
[d, h, l, M_m, D] = \mathsf{sort}([d, h, l, M_m, D])\\
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq 4.7 \cdot 10^{-228}:\\
\;\;\;\;\sqrt{\frac{1}{\ell \cdot h}} \cdot \left(-d\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{d}{\sqrt{h} \cdot \sqrt{\ell}}\\
\end{array}
\end{array}
if l < 4.7000000000000002e-228Initial program 73.2%
Taylor expanded in l around -inf
*-commutativeN/A
unpow2N/A
rem-square-sqrtN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6444.9
Applied rewrites44.9%
if 4.7000000000000002e-228 < l Initial program 71.8%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6442.0
Applied rewrites42.0%
Applied rewrites42.0%
Applied rewrites56.0%
Final simplification49.3%
M_m = (fabs.f64 M) NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function. (FPCore (d h l M_m D) :precision binary64 (/ d (sqrt (* l h))))
M_m = fabs(M);
assert(d < h && h < l && l < M_m && M_m < D);
double code(double d, double h, double l, double M_m, double D) {
return d / sqrt((l * h));
}
M_m = abs(m)
NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function.
real(8) function code(d, h, l, m_m, d_1)
real(8), intent (in) :: d
real(8), intent (in) :: h
real(8), intent (in) :: l
real(8), intent (in) :: m_m
real(8), intent (in) :: d_1
code = d / sqrt((l * h))
end function
M_m = Math.abs(M);
assert d < h && h < l && l < M_m && M_m < D;
public static double code(double d, double h, double l, double M_m, double D) {
return d / Math.sqrt((l * h));
}
M_m = math.fabs(M) [d, h, l, M_m, D] = sort([d, h, l, M_m, D]) def code(d, h, l, M_m, D): return d / math.sqrt((l * h))
M_m = abs(M) d, h, l, M_m, D = sort([d, h, l, M_m, D]) function code(d, h, l, M_m, D) return Float64(d / sqrt(Float64(l * h))) end
M_m = abs(M);
d, h, l, M_m, D = num2cell(sort([d, h, l, M_m, D])){:}
function tmp = code(d, h, l, M_m, D)
tmp = d / sqrt((l * h));
end
M_m = N[Abs[M], $MachinePrecision] NOTE: d, h, l, M_m, and D should be sorted in increasing order before calling this function. code[d_, h_, l_, M$95$m_, D_] := N[(d / N[Sqrt[N[(l * h), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
M_m = \left|M\right|
\\
[d, h, l, M_m, D] = \mathsf{sort}([d, h, l, M_m, D])\\
\\
\frac{d}{\sqrt{\ell \cdot h}}
\end{array}
Initial program 72.7%
Taylor expanded in d around inf
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6424.3
Applied rewrites24.3%
Applied rewrites22.8%
herbie shell --seed 2024235
(FPCore (d h l M D)
:name "Henrywood and Agarwal, Equation (12)"
:precision binary64
(* (* (pow (/ d h) (/ 1.0 2.0)) (pow (/ d l) (/ 1.0 2.0))) (- 1.0 (* (* (/ 1.0 2.0) (pow (/ (* M D) (* 2.0 d)) 2.0)) (/ h l)))))