
(FPCore (a k m) :precision binary64 (/ (* a (pow k m)) (+ (+ 1.0 (* 10.0 k)) (* k k))))
double code(double a, double k, double m) {
return (a * pow(k, m)) / ((1.0 + (10.0 * k)) + (k * k));
}
real(8) function code(a, k, m)
real(8), intent (in) :: a
real(8), intent (in) :: k
real(8), intent (in) :: m
code = (a * (k ** m)) / ((1.0d0 + (10.0d0 * k)) + (k * k))
end function
public static double code(double a, double k, double m) {
return (a * Math.pow(k, m)) / ((1.0 + (10.0 * k)) + (k * k));
}
def code(a, k, m): return (a * math.pow(k, m)) / ((1.0 + (10.0 * k)) + (k * k))
function code(a, k, m) return Float64(Float64(a * (k ^ m)) / Float64(Float64(1.0 + Float64(10.0 * k)) + Float64(k * k))) end
function tmp = code(a, k, m) tmp = (a * (k ^ m)) / ((1.0 + (10.0 * k)) + (k * k)); end
code[a_, k_, m_] := N[(N[(a * N[Power[k, m], $MachinePrecision]), $MachinePrecision] / N[(N[(1.0 + N[(10.0 * k), $MachinePrecision]), $MachinePrecision] + N[(k * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{a \cdot {k}^{m}}{\left(1 + 10 \cdot k\right) + k \cdot k}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 10 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (a k m) :precision binary64 (/ (* a (pow k m)) (+ (+ 1.0 (* 10.0 k)) (* k k))))
double code(double a, double k, double m) {
return (a * pow(k, m)) / ((1.0 + (10.0 * k)) + (k * k));
}
real(8) function code(a, k, m)
real(8), intent (in) :: a
real(8), intent (in) :: k
real(8), intent (in) :: m
code = (a * (k ** m)) / ((1.0d0 + (10.0d0 * k)) + (k * k))
end function
public static double code(double a, double k, double m) {
return (a * Math.pow(k, m)) / ((1.0 + (10.0 * k)) + (k * k));
}
def code(a, k, m): return (a * math.pow(k, m)) / ((1.0 + (10.0 * k)) + (k * k))
function code(a, k, m) return Float64(Float64(a * (k ^ m)) / Float64(Float64(1.0 + Float64(10.0 * k)) + Float64(k * k))) end
function tmp = code(a, k, m) tmp = (a * (k ^ m)) / ((1.0 + (10.0 * k)) + (k * k)); end
code[a_, k_, m_] := N[(N[(a * N[Power[k, m], $MachinePrecision]), $MachinePrecision] / N[(N[(1.0 + N[(10.0 * k), $MachinePrecision]), $MachinePrecision] + N[(k * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{a \cdot {k}^{m}}{\left(1 + 10 \cdot k\right) + k \cdot k}
\end{array}
(FPCore (a k m) :precision binary64 (let* ((t_0 (* a (pow k m))) (t_1 (/ t_0 (+ (+ 1.0 (* k 10.0)) (* k k))))) (if (<= t_1 4e+226) t_1 t_0)))
double code(double a, double k, double m) {
double t_0 = a * pow(k, m);
double t_1 = t_0 / ((1.0 + (k * 10.0)) + (k * k));
double tmp;
if (t_1 <= 4e+226) {
tmp = t_1;
} else {
tmp = t_0;
}
return tmp;
}
real(8) function code(a, k, m)
real(8), intent (in) :: a
real(8), intent (in) :: k
real(8), intent (in) :: m
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = a * (k ** m)
t_1 = t_0 / ((1.0d0 + (k * 10.0d0)) + (k * k))
if (t_1 <= 4d+226) then
tmp = t_1
else
tmp = t_0
end if
code = tmp
end function
public static double code(double a, double k, double m) {
double t_0 = a * Math.pow(k, m);
double t_1 = t_0 / ((1.0 + (k * 10.0)) + (k * k));
double tmp;
if (t_1 <= 4e+226) {
tmp = t_1;
} else {
tmp = t_0;
}
return tmp;
}
def code(a, k, m): t_0 = a * math.pow(k, m) t_1 = t_0 / ((1.0 + (k * 10.0)) + (k * k)) tmp = 0 if t_1 <= 4e+226: tmp = t_1 else: tmp = t_0 return tmp
function code(a, k, m) t_0 = Float64(a * (k ^ m)) t_1 = Float64(t_0 / Float64(Float64(1.0 + Float64(k * 10.0)) + Float64(k * k))) tmp = 0.0 if (t_1 <= 4e+226) tmp = t_1; else tmp = t_0; end return tmp end
function tmp_2 = code(a, k, m) t_0 = a * (k ^ m); t_1 = t_0 / ((1.0 + (k * 10.0)) + (k * k)); tmp = 0.0; if (t_1 <= 4e+226) tmp = t_1; else tmp = t_0; end tmp_2 = tmp; end
code[a_, k_, m_] := Block[{t$95$0 = N[(a * N[Power[k, m], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 / N[(N[(1.0 + N[(k * 10.0), $MachinePrecision]), $MachinePrecision] + N[(k * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, 4e+226], t$95$1, t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := a \cdot {k}^{m}\\
t_1 := \frac{t\_0}{\left(1 + k \cdot 10\right) + k \cdot k}\\
\mathbf{if}\;t\_1 \leq 4 \cdot 10^{+226}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if (/.f64 (*.f64 a (pow.f64 k m)) (+.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 10 binary64) k)) (*.f64 k k))) < 3.99999999999999985e226Initial program 97.3%
if 3.99999999999999985e226 < (/.f64 (*.f64 a (pow.f64 k m)) (+.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 10 binary64) k)) (*.f64 k k))) Initial program 57.8%
Taylor expanded in k around 0
lower-*.f64N/A
lower-pow.f64100.0
Applied rewrites100.0%
Final simplification97.8%
(FPCore (a k m)
:precision binary64
(let* ((t_0 (/ (* a (pow k m)) (+ (+ 1.0 (* k 10.0)) (* k k)))))
(if (<= t_0 0.0)
(* a (/ 1.0 (fma k (* (- 100.0 (* k k)) 0.1) 1.0)))
(if (<= t_0 2e+305) (/ a (fma k (+ k 10.0) 1.0)) (* a (/ 1.0 (* k k)))))))
double code(double a, double k, double m) {
double t_0 = (a * pow(k, m)) / ((1.0 + (k * 10.0)) + (k * k));
double tmp;
if (t_0 <= 0.0) {
tmp = a * (1.0 / fma(k, ((100.0 - (k * k)) * 0.1), 1.0));
} else if (t_0 <= 2e+305) {
tmp = a / fma(k, (k + 10.0), 1.0);
} else {
tmp = a * (1.0 / (k * k));
}
return tmp;
}
function code(a, k, m) t_0 = Float64(Float64(a * (k ^ m)) / Float64(Float64(1.0 + Float64(k * 10.0)) + Float64(k * k))) tmp = 0.0 if (t_0 <= 0.0) tmp = Float64(a * Float64(1.0 / fma(k, Float64(Float64(100.0 - Float64(k * k)) * 0.1), 1.0))); elseif (t_0 <= 2e+305) tmp = Float64(a / fma(k, Float64(k + 10.0), 1.0)); else tmp = Float64(a * Float64(1.0 / Float64(k * k))); end return tmp end
code[a_, k_, m_] := Block[{t$95$0 = N[(N[(a * N[Power[k, m], $MachinePrecision]), $MachinePrecision] / N[(N[(1.0 + N[(k * 10.0), $MachinePrecision]), $MachinePrecision] + N[(k * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, 0.0], N[(a * N[(1.0 / N[(k * N[(N[(100.0 - N[(k * k), $MachinePrecision]), $MachinePrecision] * 0.1), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, 2e+305], N[(a / N[(k * N[(k + 10.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], N[(a * N[(1.0 / N[(k * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{a \cdot {k}^{m}}{\left(1 + k \cdot 10\right) + k \cdot k}\\
\mathbf{if}\;t\_0 \leq 0:\\
\;\;\;\;a \cdot \frac{1}{\mathsf{fma}\left(k, \left(100 - k \cdot k\right) \cdot 0.1, 1\right)}\\
\mathbf{elif}\;t\_0 \leq 2 \cdot 10^{+305}:\\
\;\;\;\;\frac{a}{\mathsf{fma}\left(k, k + 10, 1\right)}\\
\mathbf{else}:\\
\;\;\;\;a \cdot \frac{1}{k \cdot k}\\
\end{array}
\end{array}
if (/.f64 (*.f64 a (pow.f64 k m)) (+.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 10 binary64) k)) (*.f64 k k))) < 0.0Initial program 96.9%
lift-pow.f64N/A
lift-*.f64N/A
lift-+.f64N/A
lift-*.f64N/A
lift-+.f64N/A
*-commutativeN/A
associate-*l/N/A
lower-*.f64N/A
lower-/.f6496.9
lift-+.f64N/A
lift-+.f64N/A
associate-+l+N/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
distribute-rgt-outN/A
lower-fma.f64N/A
lower-+.f6496.9
Applied rewrites96.9%
Taylor expanded in m around 0
Applied rewrites48.3%
flip-+N/A
lift--.f64N/A
div-invN/A
lower-*.f64N/A
metadata-evalN/A
lift-*.f64N/A
lower--.f64N/A
lower-/.f6448.3
Applied rewrites48.3%
Taylor expanded in k around 0
Applied rewrites46.7%
if 0.0 < (/.f64 (*.f64 a (pow.f64 k m)) (+.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 10 binary64) k)) (*.f64 k k))) < 1.9999999999999999e305Initial program 99.8%
Taylor expanded in m around 0
lower-/.f64N/A
unpow2N/A
distribute-rgt-inN/A
+-commutativeN/A
metadata-evalN/A
lft-mult-inverseN/A
associate-*l*N/A
*-lft-identityN/A
distribute-rgt-inN/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
+-commutativeN/A
distribute-rgt-inN/A
associate-*l*N/A
lft-mult-inverseN/A
metadata-evalN/A
*-lft-identityN/A
lower-+.f6494.1
Applied rewrites94.1%
if 1.9999999999999999e305 < (/.f64 (*.f64 a (pow.f64 k m)) (+.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 10 binary64) k)) (*.f64 k k))) Initial program 55.8%
lift-pow.f64N/A
lift-*.f64N/A
lift-+.f64N/A
lift-*.f64N/A
lift-+.f64N/A
*-commutativeN/A
associate-*l/N/A
lower-*.f64N/A
lower-/.f6455.8
lift-+.f64N/A
lift-+.f64N/A
associate-+l+N/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
distribute-rgt-outN/A
lower-fma.f64N/A
lower-+.f6455.8
Applied rewrites55.8%
Taylor expanded in m around 0
Applied rewrites2.5%
Taylor expanded in k around inf
unpow2N/A
lower-*.f6422.7
Applied rewrites22.7%
Final simplification47.8%
(FPCore (a k m)
:precision binary64
(let* ((t_0 (* a (pow k m))))
(if (<= (/ t_0 (+ (+ 1.0 (* k 10.0)) (* k k))) 4e+226)
(* a (/ (pow k m) (fma k (+ k 10.0) 1.0)))
t_0)))
double code(double a, double k, double m) {
double t_0 = a * pow(k, m);
double tmp;
if ((t_0 / ((1.0 + (k * 10.0)) + (k * k))) <= 4e+226) {
tmp = a * (pow(k, m) / fma(k, (k + 10.0), 1.0));
} else {
tmp = t_0;
}
return tmp;
}
function code(a, k, m) t_0 = Float64(a * (k ^ m)) tmp = 0.0 if (Float64(t_0 / Float64(Float64(1.0 + Float64(k * 10.0)) + Float64(k * k))) <= 4e+226) tmp = Float64(a * Float64((k ^ m) / fma(k, Float64(k + 10.0), 1.0))); else tmp = t_0; end return tmp end
code[a_, k_, m_] := Block[{t$95$0 = N[(a * N[Power[k, m], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(t$95$0 / N[(N[(1.0 + N[(k * 10.0), $MachinePrecision]), $MachinePrecision] + N[(k * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 4e+226], N[(a * N[(N[Power[k, m], $MachinePrecision] / N[(k * N[(k + 10.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := a \cdot {k}^{m}\\
\mathbf{if}\;\frac{t\_0}{\left(1 + k \cdot 10\right) + k \cdot k} \leq 4 \cdot 10^{+226}:\\
\;\;\;\;a \cdot \frac{{k}^{m}}{\mathsf{fma}\left(k, k + 10, 1\right)}\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if (/.f64 (*.f64 a (pow.f64 k m)) (+.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 10 binary64) k)) (*.f64 k k))) < 3.99999999999999985e226Initial program 97.3%
lift-pow.f64N/A
lift-*.f64N/A
lift-+.f64N/A
lift-*.f64N/A
lift-+.f64N/A
*-commutativeN/A
associate-*l/N/A
lower-*.f64N/A
lower-/.f6497.3
lift-+.f64N/A
lift-+.f64N/A
associate-+l+N/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
distribute-rgt-outN/A
lower-fma.f64N/A
lower-+.f6497.3
Applied rewrites97.3%
if 3.99999999999999985e226 < (/.f64 (*.f64 a (pow.f64 k m)) (+.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 10 binary64) k)) (*.f64 k k))) Initial program 57.8%
Taylor expanded in k around 0
lower-*.f64N/A
lower-pow.f64100.0
Applied rewrites100.0%
Final simplification97.8%
(FPCore (a k m) :precision binary64 (if (<= (/ (* a (pow k m)) (+ (+ 1.0 (* k 10.0)) (* k k))) 2e+305) (/ a (fma k (+ k 10.0) 1.0)) (* a (/ 1.0 (* k k)))))
double code(double a, double k, double m) {
double tmp;
if (((a * pow(k, m)) / ((1.0 + (k * 10.0)) + (k * k))) <= 2e+305) {
tmp = a / fma(k, (k + 10.0), 1.0);
} else {
tmp = a * (1.0 / (k * k));
}
return tmp;
}
function code(a, k, m) tmp = 0.0 if (Float64(Float64(a * (k ^ m)) / Float64(Float64(1.0 + Float64(k * 10.0)) + Float64(k * k))) <= 2e+305) tmp = Float64(a / fma(k, Float64(k + 10.0), 1.0)); else tmp = Float64(a * Float64(1.0 / Float64(k * k))); end return tmp end
code[a_, k_, m_] := If[LessEqual[N[(N[(a * N[Power[k, m], $MachinePrecision]), $MachinePrecision] / N[(N[(1.0 + N[(k * 10.0), $MachinePrecision]), $MachinePrecision] + N[(k * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2e+305], N[(a / N[(k * N[(k + 10.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], N[(a * N[(1.0 / N[(k * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{a \cdot {k}^{m}}{\left(1 + k \cdot 10\right) + k \cdot k} \leq 2 \cdot 10^{+305}:\\
\;\;\;\;\frac{a}{\mathsf{fma}\left(k, k + 10, 1\right)}\\
\mathbf{else}:\\
\;\;\;\;a \cdot \frac{1}{k \cdot k}\\
\end{array}
\end{array}
if (/.f64 (*.f64 a (pow.f64 k m)) (+.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 10 binary64) k)) (*.f64 k k))) < 1.9999999999999999e305Initial program 97.3%
Taylor expanded in m around 0
lower-/.f64N/A
unpow2N/A
distribute-rgt-inN/A
+-commutativeN/A
metadata-evalN/A
lft-mult-inverseN/A
associate-*l*N/A
*-lft-identityN/A
distribute-rgt-inN/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
+-commutativeN/A
distribute-rgt-inN/A
associate-*l*N/A
lft-mult-inverseN/A
metadata-evalN/A
*-lft-identityN/A
lower-+.f6454.4
Applied rewrites54.4%
if 1.9999999999999999e305 < (/.f64 (*.f64 a (pow.f64 k m)) (+.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 10 binary64) k)) (*.f64 k k))) Initial program 55.8%
lift-pow.f64N/A
lift-*.f64N/A
lift-+.f64N/A
lift-*.f64N/A
lift-+.f64N/A
*-commutativeN/A
associate-*l/N/A
lower-*.f64N/A
lower-/.f6455.8
lift-+.f64N/A
lift-+.f64N/A
associate-+l+N/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
distribute-rgt-outN/A
lower-fma.f64N/A
lower-+.f6455.8
Applied rewrites55.8%
Taylor expanded in m around 0
Applied rewrites2.5%
Taylor expanded in k around inf
unpow2N/A
lower-*.f6422.7
Applied rewrites22.7%
Final simplification49.0%
(FPCore (a k m) :precision binary64 (let* ((t_0 (* a (pow k m)))) (if (<= m -5e-17) t_0 (if (<= m 2e-19) (/ a (fma k (+ k 10.0) 1.0)) t_0))))
double code(double a, double k, double m) {
double t_0 = a * pow(k, m);
double tmp;
if (m <= -5e-17) {
tmp = t_0;
} else if (m <= 2e-19) {
tmp = a / fma(k, (k + 10.0), 1.0);
} else {
tmp = t_0;
}
return tmp;
}
function code(a, k, m) t_0 = Float64(a * (k ^ m)) tmp = 0.0 if (m <= -5e-17) tmp = t_0; elseif (m <= 2e-19) tmp = Float64(a / fma(k, Float64(k + 10.0), 1.0)); else tmp = t_0; end return tmp end
code[a_, k_, m_] := Block[{t$95$0 = N[(a * N[Power[k, m], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[m, -5e-17], t$95$0, If[LessEqual[m, 2e-19], N[(a / N[(k * N[(k + 10.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := a \cdot {k}^{m}\\
\mathbf{if}\;m \leq -5 \cdot 10^{-17}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;m \leq 2 \cdot 10^{-19}:\\
\;\;\;\;\frac{a}{\mathsf{fma}\left(k, k + 10, 1\right)}\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if m < -4.9999999999999999e-17 or 2e-19 < m Initial program 88.6%
Taylor expanded in k around 0
lower-*.f64N/A
lower-pow.f6499.4
Applied rewrites99.4%
if -4.9999999999999999e-17 < m < 2e-19Initial program 93.7%
Taylor expanded in m around 0
lower-/.f64N/A
unpow2N/A
distribute-rgt-inN/A
+-commutativeN/A
metadata-evalN/A
lft-mult-inverseN/A
associate-*l*N/A
*-lft-identityN/A
distribute-rgt-inN/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
+-commutativeN/A
distribute-rgt-inN/A
associate-*l*N/A
lft-mult-inverseN/A
metadata-evalN/A
*-lft-identityN/A
lower-+.f6493.7
Applied rewrites93.7%
Final simplification97.4%
(FPCore (a k m)
:precision binary64
(let* ((t_0 (fma k (- 10.0 k) 1.0)))
(if (<= m -36000000000000.0)
(/ (* a 1.0) (* (* k k) (* t_0 1.0)))
(if (<= m 1.65)
(/ a (fma k (+ k 10.0) 1.0))
(/ (* a 1.0) (* 1.0 (* t_0 (/ (- -10.0 k) (* k (* k k))))))))))
double code(double a, double k, double m) {
double t_0 = fma(k, (10.0 - k), 1.0);
double tmp;
if (m <= -36000000000000.0) {
tmp = (a * 1.0) / ((k * k) * (t_0 * 1.0));
} else if (m <= 1.65) {
tmp = a / fma(k, (k + 10.0), 1.0);
} else {
tmp = (a * 1.0) / (1.0 * (t_0 * ((-10.0 - k) / (k * (k * k)))));
}
return tmp;
}
function code(a, k, m) t_0 = fma(k, Float64(10.0 - k), 1.0) tmp = 0.0 if (m <= -36000000000000.0) tmp = Float64(Float64(a * 1.0) / Float64(Float64(k * k) * Float64(t_0 * 1.0))); elseif (m <= 1.65) tmp = Float64(a / fma(k, Float64(k + 10.0), 1.0)); else tmp = Float64(Float64(a * 1.0) / Float64(1.0 * Float64(t_0 * Float64(Float64(-10.0 - k) / Float64(k * Float64(k * k)))))); end return tmp end
code[a_, k_, m_] := Block[{t$95$0 = N[(k * N[(10.0 - k), $MachinePrecision] + 1.0), $MachinePrecision]}, If[LessEqual[m, -36000000000000.0], N[(N[(a * 1.0), $MachinePrecision] / N[(N[(k * k), $MachinePrecision] * N[(t$95$0 * 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[m, 1.65], N[(a / N[(k * N[(k + 10.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], N[(N[(a * 1.0), $MachinePrecision] / N[(1.0 * N[(t$95$0 * N[(N[(-10.0 - k), $MachinePrecision] / N[(k * N[(k * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(k, 10 - k, 1\right)\\
\mathbf{if}\;m \leq -36000000000000:\\
\;\;\;\;\frac{a \cdot 1}{\left(k \cdot k\right) \cdot \left(t\_0 \cdot 1\right)}\\
\mathbf{elif}\;m \leq 1.65:\\
\;\;\;\;\frac{a}{\mathsf{fma}\left(k, k + 10, 1\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{a \cdot 1}{1 \cdot \left(t\_0 \cdot \frac{-10 - k}{k \cdot \left(k \cdot k\right)}\right)}\\
\end{array}
\end{array}
if m < -3.6e13Initial program 100.0%
lift-*.f64N/A
lift-+.f64N/A
lift-*.f64N/A
flip-+N/A
div-invN/A
difference-of-squaresN/A
lift-+.f64N/A
associate-*l*N/A
lower-*.f64N/A
Applied rewrites71.4%
Taylor expanded in m around 0
Applied rewrites4.1%
Taylor expanded in k around 0
Applied rewrites46.3%
Taylor expanded in k around inf
unpow2N/A
lower-*.f6471.4
Applied rewrites71.4%
if -3.6e13 < m < 1.6499999999999999Initial program 94.1%
Taylor expanded in m around 0
lower-/.f64N/A
unpow2N/A
distribute-rgt-inN/A
+-commutativeN/A
metadata-evalN/A
lft-mult-inverseN/A
associate-*l*N/A
*-lft-identityN/A
distribute-rgt-inN/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
+-commutativeN/A
distribute-rgt-inN/A
associate-*l*N/A
lft-mult-inverseN/A
metadata-evalN/A
*-lft-identityN/A
lower-+.f6492.0
Applied rewrites92.0%
if 1.6499999999999999 < m Initial program 76.8%
lift-*.f64N/A
lift-+.f64N/A
lift-*.f64N/A
flip-+N/A
div-invN/A
difference-of-squaresN/A
lift-+.f64N/A
associate-*l*N/A
lower-*.f64N/A
Applied rewrites76.8%
Taylor expanded in m around 0
Applied rewrites2.6%
Taylor expanded in k around 0
Applied rewrites3.1%
Taylor expanded in k around inf
mul-1-negN/A
distribute-neg-fracN/A
distribute-neg-inN/A
metadata-evalN/A
unsub-negN/A
metadata-evalN/A
*-inversesN/A
distribute-frac-negN/A
mul-1-negN/A
associate-*r/N/A
metadata-evalN/A
div-subN/A
associate-/r*N/A
unpow2N/A
cube-multN/A
lower-/.f64N/A
sub-negN/A
metadata-evalN/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
cube-multN/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6454.5
Applied rewrites54.5%
Final simplification73.8%
(FPCore (a k m)
:precision binary64
(let* ((t_0 (fma k (- 10.0 k) 1.0)))
(if (<= m -36000000000000.0)
(/ (* a 1.0) (* (* k k) (* t_0 1.0)))
(if (<= m 1.65)
(/ a (fma k (+ k 10.0) 1.0))
(/ (* a 1.0) (* 1.0 (* t_0 (/ -1.0 (* k k)))))))))
double code(double a, double k, double m) {
double t_0 = fma(k, (10.0 - k), 1.0);
double tmp;
if (m <= -36000000000000.0) {
tmp = (a * 1.0) / ((k * k) * (t_0 * 1.0));
} else if (m <= 1.65) {
tmp = a / fma(k, (k + 10.0), 1.0);
} else {
tmp = (a * 1.0) / (1.0 * (t_0 * (-1.0 / (k * k))));
}
return tmp;
}
function code(a, k, m) t_0 = fma(k, Float64(10.0 - k), 1.0) tmp = 0.0 if (m <= -36000000000000.0) tmp = Float64(Float64(a * 1.0) / Float64(Float64(k * k) * Float64(t_0 * 1.0))); elseif (m <= 1.65) tmp = Float64(a / fma(k, Float64(k + 10.0), 1.0)); else tmp = Float64(Float64(a * 1.0) / Float64(1.0 * Float64(t_0 * Float64(-1.0 / Float64(k * k))))); end return tmp end
code[a_, k_, m_] := Block[{t$95$0 = N[(k * N[(10.0 - k), $MachinePrecision] + 1.0), $MachinePrecision]}, If[LessEqual[m, -36000000000000.0], N[(N[(a * 1.0), $MachinePrecision] / N[(N[(k * k), $MachinePrecision] * N[(t$95$0 * 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[m, 1.65], N[(a / N[(k * N[(k + 10.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], N[(N[(a * 1.0), $MachinePrecision] / N[(1.0 * N[(t$95$0 * N[(-1.0 / N[(k * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(k, 10 - k, 1\right)\\
\mathbf{if}\;m \leq -36000000000000:\\
\;\;\;\;\frac{a \cdot 1}{\left(k \cdot k\right) \cdot \left(t\_0 \cdot 1\right)}\\
\mathbf{elif}\;m \leq 1.65:\\
\;\;\;\;\frac{a}{\mathsf{fma}\left(k, k + 10, 1\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{a \cdot 1}{1 \cdot \left(t\_0 \cdot \frac{-1}{k \cdot k}\right)}\\
\end{array}
\end{array}
if m < -3.6e13Initial program 100.0%
lift-*.f64N/A
lift-+.f64N/A
lift-*.f64N/A
flip-+N/A
div-invN/A
difference-of-squaresN/A
lift-+.f64N/A
associate-*l*N/A
lower-*.f64N/A
Applied rewrites71.4%
Taylor expanded in m around 0
Applied rewrites4.1%
Taylor expanded in k around 0
Applied rewrites46.3%
Taylor expanded in k around inf
unpow2N/A
lower-*.f6471.4
Applied rewrites71.4%
if -3.6e13 < m < 1.6499999999999999Initial program 94.1%
Taylor expanded in m around 0
lower-/.f64N/A
unpow2N/A
distribute-rgt-inN/A
+-commutativeN/A
metadata-evalN/A
lft-mult-inverseN/A
associate-*l*N/A
*-lft-identityN/A
distribute-rgt-inN/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
+-commutativeN/A
distribute-rgt-inN/A
associate-*l*N/A
lft-mult-inverseN/A
metadata-evalN/A
*-lft-identityN/A
lower-+.f6492.0
Applied rewrites92.0%
if 1.6499999999999999 < m Initial program 76.8%
lift-*.f64N/A
lift-+.f64N/A
lift-*.f64N/A
flip-+N/A
div-invN/A
difference-of-squaresN/A
lift-+.f64N/A
associate-*l*N/A
lower-*.f64N/A
Applied rewrites76.8%
Taylor expanded in m around 0
Applied rewrites2.6%
Taylor expanded in k around 0
Applied rewrites3.1%
Taylor expanded in k around inf
lower-/.f64N/A
unpow2N/A
lower-*.f6436.1
Applied rewrites36.1%
Final simplification67.9%
(FPCore (a k m) :precision binary64 (if (<= m -36000000000000.0) (/ (* a 1.0) (* (* k k) (* (fma k (- 10.0 k) 1.0) 1.0))) (/ a (fma k (+ k 10.0) 1.0))))
double code(double a, double k, double m) {
double tmp;
if (m <= -36000000000000.0) {
tmp = (a * 1.0) / ((k * k) * (fma(k, (10.0 - k), 1.0) * 1.0));
} else {
tmp = a / fma(k, (k + 10.0), 1.0);
}
return tmp;
}
function code(a, k, m) tmp = 0.0 if (m <= -36000000000000.0) tmp = Float64(Float64(a * 1.0) / Float64(Float64(k * k) * Float64(fma(k, Float64(10.0 - k), 1.0) * 1.0))); else tmp = Float64(a / fma(k, Float64(k + 10.0), 1.0)); end return tmp end
code[a_, k_, m_] := If[LessEqual[m, -36000000000000.0], N[(N[(a * 1.0), $MachinePrecision] / N[(N[(k * k), $MachinePrecision] * N[(N[(k * N[(10.0 - k), $MachinePrecision] + 1.0), $MachinePrecision] * 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(a / N[(k * N[(k + 10.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;m \leq -36000000000000:\\
\;\;\;\;\frac{a \cdot 1}{\left(k \cdot k\right) \cdot \left(\mathsf{fma}\left(k, 10 - k, 1\right) \cdot 1\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{a}{\mathsf{fma}\left(k, k + 10, 1\right)}\\
\end{array}
\end{array}
if m < -3.6e13Initial program 100.0%
lift-*.f64N/A
lift-+.f64N/A
lift-*.f64N/A
flip-+N/A
div-invN/A
difference-of-squaresN/A
lift-+.f64N/A
associate-*l*N/A
lower-*.f64N/A
Applied rewrites71.4%
Taylor expanded in m around 0
Applied rewrites4.1%
Taylor expanded in k around 0
Applied rewrites46.3%
Taylor expanded in k around inf
unpow2N/A
lower-*.f6471.4
Applied rewrites71.4%
if -3.6e13 < m Initial program 86.2%
Taylor expanded in m around 0
lower-/.f64N/A
unpow2N/A
distribute-rgt-inN/A
+-commutativeN/A
metadata-evalN/A
lft-mult-inverseN/A
associate-*l*N/A
*-lft-identityN/A
distribute-rgt-inN/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
+-commutativeN/A
distribute-rgt-inN/A
associate-*l*N/A
lft-mult-inverseN/A
metadata-evalN/A
*-lft-identityN/A
lower-+.f6451.2
Applied rewrites51.2%
Final simplification57.3%
(FPCore (a k m) :precision binary64 (/ a (fma k (+ k 10.0) 1.0)))
double code(double a, double k, double m) {
return a / fma(k, (k + 10.0), 1.0);
}
function code(a, k, m) return Float64(a / fma(k, Float64(k + 10.0), 1.0)) end
code[a_, k_, m_] := N[(a / N[(k * N[(k + 10.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{a}{\mathsf{fma}\left(k, k + 10, 1\right)}
\end{array}
Initial program 90.4%
Taylor expanded in m around 0
lower-/.f64N/A
unpow2N/A
distribute-rgt-inN/A
+-commutativeN/A
metadata-evalN/A
lft-mult-inverseN/A
associate-*l*N/A
*-lft-identityN/A
distribute-rgt-inN/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
+-commutativeN/A
distribute-rgt-inN/A
associate-*l*N/A
lft-mult-inverseN/A
metadata-evalN/A
*-lft-identityN/A
lower-+.f6445.7
Applied rewrites45.7%
Final simplification45.7%
(FPCore (a k m) :precision binary64 (* a 1.0))
double code(double a, double k, double m) {
return a * 1.0;
}
real(8) function code(a, k, m)
real(8), intent (in) :: a
real(8), intent (in) :: k
real(8), intent (in) :: m
code = a * 1.0d0
end function
public static double code(double a, double k, double m) {
return a * 1.0;
}
def code(a, k, m): return a * 1.0
function code(a, k, m) return Float64(a * 1.0) end
function tmp = code(a, k, m) tmp = a * 1.0; end
code[a_, k_, m_] := N[(a * 1.0), $MachinePrecision]
\begin{array}{l}
\\
a \cdot 1
\end{array}
Initial program 90.4%
lift-pow.f64N/A
lift-*.f64N/A
lift-+.f64N/A
lift-*.f64N/A
lift-+.f64N/A
*-commutativeN/A
associate-*l/N/A
lower-*.f64N/A
lower-/.f6490.3
lift-+.f64N/A
lift-+.f64N/A
associate-+l+N/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
distribute-rgt-outN/A
lower-fma.f64N/A
lower-+.f6490.3
Applied rewrites90.3%
Taylor expanded in k around 0
lower-pow.f6479.7
Applied rewrites79.7%
lift-approxN/A
lift-*.f6479.7
Applied rewrites18.5%
Final simplification18.5%
herbie shell --seed 2024212
(FPCore (a k m)
:name "Falkner and Boettcher, Appendix A"
:precision binary64
(/ (* a (pow k m)) (+ (+ 1.0 (* 10.0 k)) (* k k))))