
(FPCore (x) :precision binary64 (- (/ 2.0 (+ 1.0 (exp (* -2.0 x)))) 1.0))
double code(double x) {
return (2.0 / (1.0 + exp((-2.0 * x)))) - 1.0;
}
real(8) function code(x)
real(8), intent (in) :: x
code = (2.0d0 / (1.0d0 + exp(((-2.0d0) * x)))) - 1.0d0
end function
public static double code(double x) {
return (2.0 / (1.0 + Math.exp((-2.0 * x)))) - 1.0;
}
def code(x): return (2.0 / (1.0 + math.exp((-2.0 * x)))) - 1.0
function code(x) return Float64(Float64(2.0 / Float64(1.0 + exp(Float64(-2.0 * x)))) - 1.0) end
function tmp = code(x) tmp = (2.0 / (1.0 + exp((-2.0 * x)))) - 1.0; end
code[x_] := N[(N[(2.0 / N[(1.0 + N[Exp[N[(-2.0 * x), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - 1.0), $MachinePrecision]
\begin{array}{l}
\\
\frac{2}{1 + e^{-2 \cdot x}} - 1
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 19 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x) :precision binary64 (- (/ 2.0 (+ 1.0 (exp (* -2.0 x)))) 1.0))
double code(double x) {
return (2.0 / (1.0 + exp((-2.0 * x)))) - 1.0;
}
real(8) function code(x)
real(8), intent (in) :: x
code = (2.0d0 / (1.0d0 + exp(((-2.0d0) * x)))) - 1.0d0
end function
public static double code(double x) {
return (2.0 / (1.0 + Math.exp((-2.0 * x)))) - 1.0;
}
def code(x): return (2.0 / (1.0 + math.exp((-2.0 * x)))) - 1.0
function code(x) return Float64(Float64(2.0 / Float64(1.0 + exp(Float64(-2.0 * x)))) - 1.0) end
function tmp = code(x) tmp = (2.0 / (1.0 + exp((-2.0 * x)))) - 1.0; end
code[x_] := N[(N[(2.0 / N[(1.0 + N[Exp[N[(-2.0 * x), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - 1.0), $MachinePrecision]
\begin{array}{l}
\\
\frac{2}{1 + e^{-2 \cdot x}} - 1
\end{array}
(FPCore (x)
:precision binary64
(let* ((t_0 (pow (exp x) -2.0))
(t_1 (- (log 2.0) (log1p t_0)))
(t_2 (/ 2.0 (+ t_0 1.0)))
(t_3 (+ t_2 1.0)))
(if (<= x -0.0076)
(- (/ 2.0 (+ 1.0 (exp (* -2.0 x)))) 1.0)
(if (<= x 0.0074)
(fma
(* (- (* (* x x) 0.13333333333333333) 0.3333333333333333) (* x x))
x
x)
(fma
(sqrt (/ (/ (pow t_2 4.0) t_3) (expm1 (* t_1 2.0))))
(sqrt (expm1 t_1))
(/ -1.0 t_3))))))
double code(double x) {
double t_0 = pow(exp(x), -2.0);
double t_1 = log(2.0) - log1p(t_0);
double t_2 = 2.0 / (t_0 + 1.0);
double t_3 = t_2 + 1.0;
double tmp;
if (x <= -0.0076) {
tmp = (2.0 / (1.0 + exp((-2.0 * x)))) - 1.0;
} else if (x <= 0.0074) {
tmp = fma(((((x * x) * 0.13333333333333333) - 0.3333333333333333) * (x * x)), x, x);
} else {
tmp = fma(sqrt(((pow(t_2, 4.0) / t_3) / expm1((t_1 * 2.0)))), sqrt(expm1(t_1)), (-1.0 / t_3));
}
return tmp;
}
function code(x) t_0 = exp(x) ^ -2.0 t_1 = Float64(log(2.0) - log1p(t_0)) t_2 = Float64(2.0 / Float64(t_0 + 1.0)) t_3 = Float64(t_2 + 1.0) tmp = 0.0 if (x <= -0.0076) tmp = Float64(Float64(2.0 / Float64(1.0 + exp(Float64(-2.0 * x)))) - 1.0); elseif (x <= 0.0074) tmp = fma(Float64(Float64(Float64(Float64(x * x) * 0.13333333333333333) - 0.3333333333333333) * Float64(x * x)), x, x); else tmp = fma(sqrt(Float64(Float64((t_2 ^ 4.0) / t_3) / expm1(Float64(t_1 * 2.0)))), sqrt(expm1(t_1)), Float64(-1.0 / t_3)); end return tmp end
code[x_] := Block[{t$95$0 = N[Power[N[Exp[x], $MachinePrecision], -2.0], $MachinePrecision]}, Block[{t$95$1 = N[(N[Log[2.0], $MachinePrecision] - N[Log[1 + t$95$0], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(2.0 / N[(t$95$0 + 1.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(t$95$2 + 1.0), $MachinePrecision]}, If[LessEqual[x, -0.0076], N[(N[(2.0 / N[(1.0 + N[Exp[N[(-2.0 * x), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - 1.0), $MachinePrecision], If[LessEqual[x, 0.0074], N[(N[(N[(N[(N[(x * x), $MachinePrecision] * 0.13333333333333333), $MachinePrecision] - 0.3333333333333333), $MachinePrecision] * N[(x * x), $MachinePrecision]), $MachinePrecision] * x + x), $MachinePrecision], N[(N[Sqrt[N[(N[(N[Power[t$95$2, 4.0], $MachinePrecision] / t$95$3), $MachinePrecision] / N[(Exp[N[(t$95$1 * 2.0), $MachinePrecision]] - 1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[(Exp[t$95$1] - 1), $MachinePrecision]], $MachinePrecision] + N[(-1.0 / t$95$3), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := {\left(e^{x}\right)}^{-2}\\
t_1 := \log 2 - \mathsf{log1p}\left(t\_0\right)\\
t_2 := \frac{2}{t\_0 + 1}\\
t_3 := t\_2 + 1\\
\mathbf{if}\;x \leq -0.0076:\\
\;\;\;\;\frac{2}{1 + e^{-2 \cdot x}} - 1\\
\mathbf{elif}\;x \leq 0.0074:\\
\;\;\;\;\mathsf{fma}\left(\left(\left(x \cdot x\right) \cdot 0.13333333333333333 - 0.3333333333333333\right) \cdot \left(x \cdot x\right), x, x\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\sqrt{\frac{\frac{{t\_2}^{4}}{t\_3}}{\mathsf{expm1}\left(t\_1 \cdot 2\right)}}, \sqrt{\mathsf{expm1}\left(t\_1\right)}, \frac{-1}{t\_3}\right)\\
\end{array}
\end{array}
if x < -0.00759999999999999998Initial program 100.0%
if -0.00759999999999999998 < x < 0.0074000000000000003Initial program 8.2%
Taylor expanded in x around 0
+-commutativeN/A
distribute-lft-inN/A
associate-*r*N/A
*-rgt-identityN/A
lower-fma.f64N/A
*-commutativeN/A
pow-plusN/A
lower-pow.f64N/A
metadata-evalN/A
lower--.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64100.0
Applied rewrites100.0%
Applied rewrites100.0%
if 0.0074000000000000003 < x Initial program 99.9%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.9
lift-exp.f64N/A
lift-*.f64N/A
*-commutativeN/A
exp-prodN/A
lower-pow.f64N/A
lower-exp.f6499.9
Applied rewrites99.9%
lift--.f64N/A
flip--N/A
Applied rewrites100.0%
Applied rewrites100.0%
(FPCore (x)
:precision binary64
(let* ((t_0 (pow (exp x) -2.0)) (t_1 (+ t_0 1.0)) (t_2 (+ (/ 2.0 t_1) 1.0)))
(if (<= x -0.0076)
(- (/ 2.0 (+ 1.0 (exp (* -2.0 x)))) 1.0)
(if (<= x 0.008)
(fma
(* (- (* (* x x) 0.13333333333333333) 0.3333333333333333) (* x x))
x
x)
(fma
(/ 2.0 (+ 1.0 t_0))
(sqrt (/ (/ 4.0 (pow t_1 2.0)) (pow t_2 2.0)))
(/ -1.0 t_2))))))
double code(double x) {
double t_0 = pow(exp(x), -2.0);
double t_1 = t_0 + 1.0;
double t_2 = (2.0 / t_1) + 1.0;
double tmp;
if (x <= -0.0076) {
tmp = (2.0 / (1.0 + exp((-2.0 * x)))) - 1.0;
} else if (x <= 0.008) {
tmp = fma(((((x * x) * 0.13333333333333333) - 0.3333333333333333) * (x * x)), x, x);
} else {
tmp = fma((2.0 / (1.0 + t_0)), sqrt(((4.0 / pow(t_1, 2.0)) / pow(t_2, 2.0))), (-1.0 / t_2));
}
return tmp;
}
function code(x) t_0 = exp(x) ^ -2.0 t_1 = Float64(t_0 + 1.0) t_2 = Float64(Float64(2.0 / t_1) + 1.0) tmp = 0.0 if (x <= -0.0076) tmp = Float64(Float64(2.0 / Float64(1.0 + exp(Float64(-2.0 * x)))) - 1.0); elseif (x <= 0.008) tmp = fma(Float64(Float64(Float64(Float64(x * x) * 0.13333333333333333) - 0.3333333333333333) * Float64(x * x)), x, x); else tmp = fma(Float64(2.0 / Float64(1.0 + t_0)), sqrt(Float64(Float64(4.0 / (t_1 ^ 2.0)) / (t_2 ^ 2.0))), Float64(-1.0 / t_2)); end return tmp end
code[x_] := Block[{t$95$0 = N[Power[N[Exp[x], $MachinePrecision], -2.0], $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + 1.0), $MachinePrecision]}, Block[{t$95$2 = N[(N[(2.0 / t$95$1), $MachinePrecision] + 1.0), $MachinePrecision]}, If[LessEqual[x, -0.0076], N[(N[(2.0 / N[(1.0 + N[Exp[N[(-2.0 * x), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - 1.0), $MachinePrecision], If[LessEqual[x, 0.008], N[(N[(N[(N[(N[(x * x), $MachinePrecision] * 0.13333333333333333), $MachinePrecision] - 0.3333333333333333), $MachinePrecision] * N[(x * x), $MachinePrecision]), $MachinePrecision] * x + x), $MachinePrecision], N[(N[(2.0 / N[(1.0 + t$95$0), $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(N[(4.0 / N[Power[t$95$1, 2.0], $MachinePrecision]), $MachinePrecision] / N[Power[t$95$2, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + N[(-1.0 / t$95$2), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := {\left(e^{x}\right)}^{-2}\\
t_1 := t\_0 + 1\\
t_2 := \frac{2}{t\_1} + 1\\
\mathbf{if}\;x \leq -0.0076:\\
\;\;\;\;\frac{2}{1 + e^{-2 \cdot x}} - 1\\
\mathbf{elif}\;x \leq 0.008:\\
\;\;\;\;\mathsf{fma}\left(\left(\left(x \cdot x\right) \cdot 0.13333333333333333 - 0.3333333333333333\right) \cdot \left(x \cdot x\right), x, x\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\frac{2}{1 + t\_0}, \sqrt{\frac{\frac{4}{{t\_1}^{2}}}{{t\_2}^{2}}}, \frac{-1}{t\_2}\right)\\
\end{array}
\end{array}
if x < -0.00759999999999999998Initial program 100.0%
if -0.00759999999999999998 < x < 0.0080000000000000002Initial program 8.2%
Taylor expanded in x around 0
+-commutativeN/A
distribute-lft-inN/A
associate-*r*N/A
*-rgt-identityN/A
lower-fma.f64N/A
*-commutativeN/A
pow-plusN/A
lower-pow.f64N/A
metadata-evalN/A
lower--.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64100.0
Applied rewrites100.0%
Applied rewrites100.0%
if 0.0080000000000000002 < x Initial program 99.9%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.9
lift-exp.f64N/A
lift-*.f64N/A
*-commutativeN/A
exp-prodN/A
lower-pow.f64N/A
lower-exp.f6499.9
Applied rewrites99.9%
lift--.f64N/A
flip--N/A
Applied rewrites100.0%
Applied rewrites100.0%
lift-sqrt.f64N/A
lift-/.f64N/A
sqrt-divN/A
metadata-evalN/A
lift-pow.f64N/A
sqrt-pow1N/A
metadata-evalN/A
unpow1N/A
lift-/.f64100.0
lift-+.f64N/A
+-commutativeN/A
lower-+.f64100.0
Applied rewrites100.0%
(FPCore (x)
:precision binary64
(let* ((t_0 (+ (pow (exp x) -2.0) 1.0)) (t_1 (+ (/ 2.0 t_0) 1.0)))
(if (<= x -0.0076)
(- (/ 2.0 (+ 1.0 (exp (* -2.0 x)))) 1.0)
(if (<= x 0.008)
(fma
(* (- (* (* x x) 0.13333333333333333) 0.3333333333333333) (* x x))
x
x)
(+ (/ (/ 4.0 (pow t_0 2.0)) t_1) (/ -1.0 t_1))))))
double code(double x) {
double t_0 = pow(exp(x), -2.0) + 1.0;
double t_1 = (2.0 / t_0) + 1.0;
double tmp;
if (x <= -0.0076) {
tmp = (2.0 / (1.0 + exp((-2.0 * x)))) - 1.0;
} else if (x <= 0.008) {
tmp = fma(((((x * x) * 0.13333333333333333) - 0.3333333333333333) * (x * x)), x, x);
} else {
tmp = ((4.0 / pow(t_0, 2.0)) / t_1) + (-1.0 / t_1);
}
return tmp;
}
function code(x) t_0 = Float64((exp(x) ^ -2.0) + 1.0) t_1 = Float64(Float64(2.0 / t_0) + 1.0) tmp = 0.0 if (x <= -0.0076) tmp = Float64(Float64(2.0 / Float64(1.0 + exp(Float64(-2.0 * x)))) - 1.0); elseif (x <= 0.008) tmp = fma(Float64(Float64(Float64(Float64(x * x) * 0.13333333333333333) - 0.3333333333333333) * Float64(x * x)), x, x); else tmp = Float64(Float64(Float64(4.0 / (t_0 ^ 2.0)) / t_1) + Float64(-1.0 / t_1)); end return tmp end
code[x_] := Block[{t$95$0 = N[(N[Power[N[Exp[x], $MachinePrecision], -2.0], $MachinePrecision] + 1.0), $MachinePrecision]}, Block[{t$95$1 = N[(N[(2.0 / t$95$0), $MachinePrecision] + 1.0), $MachinePrecision]}, If[LessEqual[x, -0.0076], N[(N[(2.0 / N[(1.0 + N[Exp[N[(-2.0 * x), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - 1.0), $MachinePrecision], If[LessEqual[x, 0.008], N[(N[(N[(N[(N[(x * x), $MachinePrecision] * 0.13333333333333333), $MachinePrecision] - 0.3333333333333333), $MachinePrecision] * N[(x * x), $MachinePrecision]), $MachinePrecision] * x + x), $MachinePrecision], N[(N[(N[(4.0 / N[Power[t$95$0, 2.0], $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision] + N[(-1.0 / t$95$1), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := {\left(e^{x}\right)}^{-2} + 1\\
t_1 := \frac{2}{t\_0} + 1\\
\mathbf{if}\;x \leq -0.0076:\\
\;\;\;\;\frac{2}{1 + e^{-2 \cdot x}} - 1\\
\mathbf{elif}\;x \leq 0.008:\\
\;\;\;\;\mathsf{fma}\left(\left(\left(x \cdot x\right) \cdot 0.13333333333333333 - 0.3333333333333333\right) \cdot \left(x \cdot x\right), x, x\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{4}{{t\_0}^{2}}}{t\_1} + \frac{-1}{t\_1}\\
\end{array}
\end{array}
if x < -0.00759999999999999998Initial program 100.0%
if -0.00759999999999999998 < x < 0.0080000000000000002Initial program 8.2%
Taylor expanded in x around 0
+-commutativeN/A
distribute-lft-inN/A
associate-*r*N/A
*-rgt-identityN/A
lower-fma.f64N/A
*-commutativeN/A
pow-plusN/A
lower-pow.f64N/A
metadata-evalN/A
lower--.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64100.0
Applied rewrites100.0%
Applied rewrites100.0%
if 0.0080000000000000002 < x Initial program 99.9%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.9
lift-exp.f64N/A
lift-*.f64N/A
*-commutativeN/A
exp-prodN/A
lower-pow.f64N/A
lower-exp.f6499.9
Applied rewrites99.9%
lift--.f64N/A
flip--N/A
Applied rewrites100.0%
lift--.f64N/A
lift-pow.f64N/A
sqr-powN/A
fp-cancel-sub-sign-invN/A
distribute-lft-neg-inN/A
sqr-powN/A
lift-pow.f64N/A
Applied rewrites100.0%
(FPCore (x)
:precision binary64
(let* ((t_0 (/ 2.0 (+ 1.0 (exp (* -2.0 x)))))
(t_1 (/ 2.0 (+ 1.0 (pow (exp x) -2.0)))))
(if (<= x -0.0076)
(- t_0 1.0)
(if (<= x 0.0075)
(fma
(* (- (* (* x x) 0.13333333333333333) 0.3333333333333333) (* x x))
x
x)
(- (/ (pow t_1 2.0) (+ t_1 1.0)) (pow (+ t_0 1.0) -1.0))))))
double code(double x) {
double t_0 = 2.0 / (1.0 + exp((-2.0 * x)));
double t_1 = 2.0 / (1.0 + pow(exp(x), -2.0));
double tmp;
if (x <= -0.0076) {
tmp = t_0 - 1.0;
} else if (x <= 0.0075) {
tmp = fma(((((x * x) * 0.13333333333333333) - 0.3333333333333333) * (x * x)), x, x);
} else {
tmp = (pow(t_1, 2.0) / (t_1 + 1.0)) - pow((t_0 + 1.0), -1.0);
}
return tmp;
}
function code(x) t_0 = Float64(2.0 / Float64(1.0 + exp(Float64(-2.0 * x)))) t_1 = Float64(2.0 / Float64(1.0 + (exp(x) ^ -2.0))) tmp = 0.0 if (x <= -0.0076) tmp = Float64(t_0 - 1.0); elseif (x <= 0.0075) tmp = fma(Float64(Float64(Float64(Float64(x * x) * 0.13333333333333333) - 0.3333333333333333) * Float64(x * x)), x, x); else tmp = Float64(Float64((t_1 ^ 2.0) / Float64(t_1 + 1.0)) - (Float64(t_0 + 1.0) ^ -1.0)); end return tmp end
code[x_] := Block[{t$95$0 = N[(2.0 / N[(1.0 + N[Exp[N[(-2.0 * x), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(2.0 / N[(1.0 + N[Power[N[Exp[x], $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -0.0076], N[(t$95$0 - 1.0), $MachinePrecision], If[LessEqual[x, 0.0075], N[(N[(N[(N[(N[(x * x), $MachinePrecision] * 0.13333333333333333), $MachinePrecision] - 0.3333333333333333), $MachinePrecision] * N[(x * x), $MachinePrecision]), $MachinePrecision] * x + x), $MachinePrecision], N[(N[(N[Power[t$95$1, 2.0], $MachinePrecision] / N[(t$95$1 + 1.0), $MachinePrecision]), $MachinePrecision] - N[Power[N[(t$95$0 + 1.0), $MachinePrecision], -1.0], $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{2}{1 + e^{-2 \cdot x}}\\
t_1 := \frac{2}{1 + {\left(e^{x}\right)}^{-2}}\\
\mathbf{if}\;x \leq -0.0076:\\
\;\;\;\;t\_0 - 1\\
\mathbf{elif}\;x \leq 0.0075:\\
\;\;\;\;\mathsf{fma}\left(\left(\left(x \cdot x\right) \cdot 0.13333333333333333 - 0.3333333333333333\right) \cdot \left(x \cdot x\right), x, x\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{{t\_1}^{2}}{t\_1 + 1} - {\left(t\_0 + 1\right)}^{-1}\\
\end{array}
\end{array}
if x < -0.00759999999999999998Initial program 100.0%
if -0.00759999999999999998 < x < 0.0074999999999999997Initial program 8.2%
Taylor expanded in x around 0
+-commutativeN/A
distribute-lft-inN/A
associate-*r*N/A
*-rgt-identityN/A
lower-fma.f64N/A
*-commutativeN/A
pow-plusN/A
lower-pow.f64N/A
metadata-evalN/A
lower--.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64100.0
Applied rewrites100.0%
Applied rewrites100.0%
if 0.0074999999999999997 < x Initial program 99.9%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.9
lift-exp.f64N/A
lift-*.f64N/A
*-commutativeN/A
exp-prodN/A
lower-pow.f64N/A
lower-exp.f6499.9
Applied rewrites99.9%
lift--.f64N/A
flip--N/A
Applied rewrites100.0%
lift-pow.f64N/A
lift-exp.f64N/A
pow-expN/A
*-commutativeN/A
lower-exp.f64N/A
lower-*.f6499.9
Applied rewrites99.9%
(FPCore (x)
:precision binary64
(if (<= x -0.0076)
(- (/ 2.0 (+ 1.0 (exp (* -2.0 x)))) 1.0)
(if (<= x 0.0074)
(fma
(* (- (* (* x x) 0.13333333333333333) 0.3333333333333333) (* x x))
x
x)
(- (/ 2.0 (+ (pow (exp x) -2.0) 1.0)) 1.0))))
double code(double x) {
double tmp;
if (x <= -0.0076) {
tmp = (2.0 / (1.0 + exp((-2.0 * x)))) - 1.0;
} else if (x <= 0.0074) {
tmp = fma(((((x * x) * 0.13333333333333333) - 0.3333333333333333) * (x * x)), x, x);
} else {
tmp = (2.0 / (pow(exp(x), -2.0) + 1.0)) - 1.0;
}
return tmp;
}
function code(x) tmp = 0.0 if (x <= -0.0076) tmp = Float64(Float64(2.0 / Float64(1.0 + exp(Float64(-2.0 * x)))) - 1.0); elseif (x <= 0.0074) tmp = fma(Float64(Float64(Float64(Float64(x * x) * 0.13333333333333333) - 0.3333333333333333) * Float64(x * x)), x, x); else tmp = Float64(Float64(2.0 / Float64((exp(x) ^ -2.0) + 1.0)) - 1.0); end return tmp end
code[x_] := If[LessEqual[x, -0.0076], N[(N[(2.0 / N[(1.0 + N[Exp[N[(-2.0 * x), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - 1.0), $MachinePrecision], If[LessEqual[x, 0.0074], N[(N[(N[(N[(N[(x * x), $MachinePrecision] * 0.13333333333333333), $MachinePrecision] - 0.3333333333333333), $MachinePrecision] * N[(x * x), $MachinePrecision]), $MachinePrecision] * x + x), $MachinePrecision], N[(N[(2.0 / N[(N[Power[N[Exp[x], $MachinePrecision], -2.0], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] - 1.0), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -0.0076:\\
\;\;\;\;\frac{2}{1 + e^{-2 \cdot x}} - 1\\
\mathbf{elif}\;x \leq 0.0074:\\
\;\;\;\;\mathsf{fma}\left(\left(\left(x \cdot x\right) \cdot 0.13333333333333333 - 0.3333333333333333\right) \cdot \left(x \cdot x\right), x, x\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{{\left(e^{x}\right)}^{-2} + 1} - 1\\
\end{array}
\end{array}
if x < -0.00759999999999999998Initial program 100.0%
if -0.00759999999999999998 < x < 0.0074000000000000003Initial program 8.2%
Taylor expanded in x around 0
+-commutativeN/A
distribute-lft-inN/A
associate-*r*N/A
*-rgt-identityN/A
lower-fma.f64N/A
*-commutativeN/A
pow-plusN/A
lower-pow.f64N/A
metadata-evalN/A
lower--.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64100.0
Applied rewrites100.0%
Applied rewrites100.0%
if 0.0074000000000000003 < x Initial program 99.9%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.9
lift-exp.f64N/A
lift-*.f64N/A
*-commutativeN/A
exp-prodN/A
lower-pow.f64N/A
lower-exp.f6499.9
Applied rewrites99.9%
(FPCore (x)
:precision binary64
(if (or (<= x -0.0076) (not (<= x 0.0074)))
(- (/ 2.0 (+ 1.0 (exp (* -2.0 x)))) 1.0)
(fma
(* (- (* (* x x) 0.13333333333333333) 0.3333333333333333) (* x x))
x
x)))
double code(double x) {
double tmp;
if ((x <= -0.0076) || !(x <= 0.0074)) {
tmp = (2.0 / (1.0 + exp((-2.0 * x)))) - 1.0;
} else {
tmp = fma(((((x * x) * 0.13333333333333333) - 0.3333333333333333) * (x * x)), x, x);
}
return tmp;
}
function code(x) tmp = 0.0 if ((x <= -0.0076) || !(x <= 0.0074)) tmp = Float64(Float64(2.0 / Float64(1.0 + exp(Float64(-2.0 * x)))) - 1.0); else tmp = fma(Float64(Float64(Float64(Float64(x * x) * 0.13333333333333333) - 0.3333333333333333) * Float64(x * x)), x, x); end return tmp end
code[x_] := If[Or[LessEqual[x, -0.0076], N[Not[LessEqual[x, 0.0074]], $MachinePrecision]], N[(N[(2.0 / N[(1.0 + N[Exp[N[(-2.0 * x), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - 1.0), $MachinePrecision], N[(N[(N[(N[(N[(x * x), $MachinePrecision] * 0.13333333333333333), $MachinePrecision] - 0.3333333333333333), $MachinePrecision] * N[(x * x), $MachinePrecision]), $MachinePrecision] * x + x), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -0.0076 \lor \neg \left(x \leq 0.0074\right):\\
\;\;\;\;\frac{2}{1 + e^{-2 \cdot x}} - 1\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\left(\left(x \cdot x\right) \cdot 0.13333333333333333 - 0.3333333333333333\right) \cdot \left(x \cdot x\right), x, x\right)\\
\end{array}
\end{array}
if x < -0.00759999999999999998 or 0.0074000000000000003 < x Initial program 100.0%
if -0.00759999999999999998 < x < 0.0074000000000000003Initial program 8.2%
Taylor expanded in x around 0
+-commutativeN/A
distribute-lft-inN/A
associate-*r*N/A
*-rgt-identityN/A
lower-fma.f64N/A
*-commutativeN/A
pow-plusN/A
lower-pow.f64N/A
metadata-evalN/A
lower--.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64100.0
Applied rewrites100.0%
Applied rewrites100.0%
Final simplification100.0%
(FPCore (x)
:precision binary64
(if (<= x -0.98)
(- (/ 2.0 (fma (- (* (fma -1.3333333333333333 x 2.0) x) 2.0) x 2.0)) 1.0)
(fma
(* (- (* (* x x) 0.13333333333333333) 0.3333333333333333) (* x x))
x
x)))
double code(double x) {
double tmp;
if (x <= -0.98) {
tmp = (2.0 / fma(((fma(-1.3333333333333333, x, 2.0) * x) - 2.0), x, 2.0)) - 1.0;
} else {
tmp = fma(((((x * x) * 0.13333333333333333) - 0.3333333333333333) * (x * x)), x, x);
}
return tmp;
}
function code(x) tmp = 0.0 if (x <= -0.98) tmp = Float64(Float64(2.0 / fma(Float64(Float64(fma(-1.3333333333333333, x, 2.0) * x) - 2.0), x, 2.0)) - 1.0); else tmp = fma(Float64(Float64(Float64(Float64(x * x) * 0.13333333333333333) - 0.3333333333333333) * Float64(x * x)), x, x); end return tmp end
code[x_] := If[LessEqual[x, -0.98], N[(N[(2.0 / N[(N[(N[(N[(-1.3333333333333333 * x + 2.0), $MachinePrecision] * x), $MachinePrecision] - 2.0), $MachinePrecision] * x + 2.0), $MachinePrecision]), $MachinePrecision] - 1.0), $MachinePrecision], N[(N[(N[(N[(N[(x * x), $MachinePrecision] * 0.13333333333333333), $MachinePrecision] - 0.3333333333333333), $MachinePrecision] * N[(x * x), $MachinePrecision]), $MachinePrecision] * x + x), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -0.98:\\
\;\;\;\;\frac{2}{\mathsf{fma}\left(\mathsf{fma}\left(-1.3333333333333333, x, 2\right) \cdot x - 2, x, 2\right)} - 1\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\left(\left(x \cdot x\right) \cdot 0.13333333333333333 - 0.3333333333333333\right) \cdot \left(x \cdot x\right), x, x\right)\\
\end{array}
\end{array}
if x < -0.97999999999999998Initial program 100.0%
Taylor expanded in x around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6498.0
Applied rewrites98.0%
if -0.97999999999999998 < x Initial program 41.3%
Taylor expanded in x around 0
+-commutativeN/A
distribute-lft-inN/A
associate-*r*N/A
*-rgt-identityN/A
lower-fma.f64N/A
*-commutativeN/A
pow-plusN/A
lower-pow.f64N/A
metadata-evalN/A
lower--.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6465.5
Applied rewrites65.5%
Applied rewrites65.5%
(FPCore (x)
:precision binary64
(if (<= x -1.15)
(- (/ 2.0 (* (- (* (fma -1.3333333333333333 x 2.0) x) 2.0) x)) 1.0)
(fma
(* (- (* (* x x) 0.13333333333333333) 0.3333333333333333) (* x x))
x
x)))
double code(double x) {
double tmp;
if (x <= -1.15) {
tmp = (2.0 / (((fma(-1.3333333333333333, x, 2.0) * x) - 2.0) * x)) - 1.0;
} else {
tmp = fma(((((x * x) * 0.13333333333333333) - 0.3333333333333333) * (x * x)), x, x);
}
return tmp;
}
function code(x) tmp = 0.0 if (x <= -1.15) tmp = Float64(Float64(2.0 / Float64(Float64(Float64(fma(-1.3333333333333333, x, 2.0) * x) - 2.0) * x)) - 1.0); else tmp = fma(Float64(Float64(Float64(Float64(x * x) * 0.13333333333333333) - 0.3333333333333333) * Float64(x * x)), x, x); end return tmp end
code[x_] := If[LessEqual[x, -1.15], N[(N[(2.0 / N[(N[(N[(N[(-1.3333333333333333 * x + 2.0), $MachinePrecision] * x), $MachinePrecision] - 2.0), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision] - 1.0), $MachinePrecision], N[(N[(N[(N[(N[(x * x), $MachinePrecision] * 0.13333333333333333), $MachinePrecision] - 0.3333333333333333), $MachinePrecision] * N[(x * x), $MachinePrecision]), $MachinePrecision] * x + x), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.15:\\
\;\;\;\;\frac{2}{\left(\mathsf{fma}\left(-1.3333333333333333, x, 2\right) \cdot x - 2\right) \cdot x} - 1\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\left(\left(x \cdot x\right) \cdot 0.13333333333333333 - 0.3333333333333333\right) \cdot \left(x \cdot x\right), x, x\right)\\
\end{array}
\end{array}
if x < -1.1499999999999999Initial program 100.0%
Taylor expanded in x around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6498.0
Applied rewrites98.0%
Taylor expanded in x around inf
Applied rewrites98.0%
if -1.1499999999999999 < x Initial program 41.3%
Taylor expanded in x around 0
+-commutativeN/A
distribute-lft-inN/A
associate-*r*N/A
*-rgt-identityN/A
lower-fma.f64N/A
*-commutativeN/A
pow-plusN/A
lower-pow.f64N/A
metadata-evalN/A
lower--.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6465.5
Applied rewrites65.5%
Applied rewrites65.5%
(FPCore (x)
:precision binary64
(if (<= x -1.3)
(- (/ 2.0 (* (* (fma -1.3333333333333333 x 2.0) x) x)) 1.0)
(fma
(* (- (* (* x x) 0.13333333333333333) 0.3333333333333333) (* x x))
x
x)))
double code(double x) {
double tmp;
if (x <= -1.3) {
tmp = (2.0 / ((fma(-1.3333333333333333, x, 2.0) * x) * x)) - 1.0;
} else {
tmp = fma(((((x * x) * 0.13333333333333333) - 0.3333333333333333) * (x * x)), x, x);
}
return tmp;
}
function code(x) tmp = 0.0 if (x <= -1.3) tmp = Float64(Float64(2.0 / Float64(Float64(fma(-1.3333333333333333, x, 2.0) * x) * x)) - 1.0); else tmp = fma(Float64(Float64(Float64(Float64(x * x) * 0.13333333333333333) - 0.3333333333333333) * Float64(x * x)), x, x); end return tmp end
code[x_] := If[LessEqual[x, -1.3], N[(N[(2.0 / N[(N[(N[(-1.3333333333333333 * x + 2.0), $MachinePrecision] * x), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision] - 1.0), $MachinePrecision], N[(N[(N[(N[(N[(x * x), $MachinePrecision] * 0.13333333333333333), $MachinePrecision] - 0.3333333333333333), $MachinePrecision] * N[(x * x), $MachinePrecision]), $MachinePrecision] * x + x), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.3:\\
\;\;\;\;\frac{2}{\left(\mathsf{fma}\left(-1.3333333333333333, x, 2\right) \cdot x\right) \cdot x} - 1\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\left(\left(x \cdot x\right) \cdot 0.13333333333333333 - 0.3333333333333333\right) \cdot \left(x \cdot x\right), x, x\right)\\
\end{array}
\end{array}
if x < -1.30000000000000004Initial program 100.0%
Taylor expanded in x around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6498.0
Applied rewrites98.0%
Taylor expanded in x around -inf
Applied rewrites98.0%
if -1.30000000000000004 < x Initial program 41.3%
Taylor expanded in x around 0
+-commutativeN/A
distribute-lft-inN/A
associate-*r*N/A
*-rgt-identityN/A
lower-fma.f64N/A
*-commutativeN/A
pow-plusN/A
lower-pow.f64N/A
metadata-evalN/A
lower--.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6465.5
Applied rewrites65.5%
Applied rewrites65.5%
(FPCore (x)
:precision binary64
(if (<= x -1.55)
(- (/ 2.0 (* (* (* -1.3333333333333333 x) x) x)) 1.0)
(fma
(* (- (* (* x x) 0.13333333333333333) 0.3333333333333333) (* x x))
x
x)))
double code(double x) {
double tmp;
if (x <= -1.55) {
tmp = (2.0 / (((-1.3333333333333333 * x) * x) * x)) - 1.0;
} else {
tmp = fma(((((x * x) * 0.13333333333333333) - 0.3333333333333333) * (x * x)), x, x);
}
return tmp;
}
function code(x) tmp = 0.0 if (x <= -1.55) tmp = Float64(Float64(2.0 / Float64(Float64(Float64(-1.3333333333333333 * x) * x) * x)) - 1.0); else tmp = fma(Float64(Float64(Float64(Float64(x * x) * 0.13333333333333333) - 0.3333333333333333) * Float64(x * x)), x, x); end return tmp end
code[x_] := If[LessEqual[x, -1.55], N[(N[(2.0 / N[(N[(N[(-1.3333333333333333 * x), $MachinePrecision] * x), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision] - 1.0), $MachinePrecision], N[(N[(N[(N[(N[(x * x), $MachinePrecision] * 0.13333333333333333), $MachinePrecision] - 0.3333333333333333), $MachinePrecision] * N[(x * x), $MachinePrecision]), $MachinePrecision] * x + x), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.55:\\
\;\;\;\;\frac{2}{\left(\left(-1.3333333333333333 \cdot x\right) \cdot x\right) \cdot x} - 1\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\left(\left(x \cdot x\right) \cdot 0.13333333333333333 - 0.3333333333333333\right) \cdot \left(x \cdot x\right), x, x\right)\\
\end{array}
\end{array}
if x < -1.55000000000000004Initial program 100.0%
Taylor expanded in x around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6498.0
Applied rewrites98.0%
Taylor expanded in x around -inf
Applied rewrites98.0%
Taylor expanded in x around inf
Applied rewrites98.0%
if -1.55000000000000004 < x Initial program 41.3%
Taylor expanded in x around 0
+-commutativeN/A
distribute-lft-inN/A
associate-*r*N/A
*-rgt-identityN/A
lower-fma.f64N/A
*-commutativeN/A
pow-plusN/A
lower-pow.f64N/A
metadata-evalN/A
lower--.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6465.5
Applied rewrites65.5%
Applied rewrites65.5%
(FPCore (x)
:precision binary64
(if (<= x -1.15)
(- (/ 2.0 (fma (fma 2.0 x -2.0) x 2.0)) 1.0)
(fma
(* (- (* (* x x) 0.13333333333333333) 0.3333333333333333) (* x x))
x
x)))
double code(double x) {
double tmp;
if (x <= -1.15) {
tmp = (2.0 / fma(fma(2.0, x, -2.0), x, 2.0)) - 1.0;
} else {
tmp = fma(((((x * x) * 0.13333333333333333) - 0.3333333333333333) * (x * x)), x, x);
}
return tmp;
}
function code(x) tmp = 0.0 if (x <= -1.15) tmp = Float64(Float64(2.0 / fma(fma(2.0, x, -2.0), x, 2.0)) - 1.0); else tmp = fma(Float64(Float64(Float64(Float64(x * x) * 0.13333333333333333) - 0.3333333333333333) * Float64(x * x)), x, x); end return tmp end
code[x_] := If[LessEqual[x, -1.15], N[(N[(2.0 / N[(N[(2.0 * x + -2.0), $MachinePrecision] * x + 2.0), $MachinePrecision]), $MachinePrecision] - 1.0), $MachinePrecision], N[(N[(N[(N[(N[(x * x), $MachinePrecision] * 0.13333333333333333), $MachinePrecision] - 0.3333333333333333), $MachinePrecision] * N[(x * x), $MachinePrecision]), $MachinePrecision] * x + x), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.15:\\
\;\;\;\;\frac{2}{\mathsf{fma}\left(\mathsf{fma}\left(2, x, -2\right), x, 2\right)} - 1\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\left(\left(x \cdot x\right) \cdot 0.13333333333333333 - 0.3333333333333333\right) \cdot \left(x \cdot x\right), x, x\right)\\
\end{array}
\end{array}
if x < -1.1499999999999999Initial program 100.0%
lift-+.f64N/A
+-commutativeN/A
lower-+.f64100.0
lift-exp.f64N/A
lift-*.f64N/A
*-commutativeN/A
exp-prodN/A
lower-pow.f64N/A
lower-exp.f64100.0
Applied rewrites100.0%
Taylor expanded in x around 0
Applied rewrites97.9%
if -1.1499999999999999 < x Initial program 41.3%
Taylor expanded in x around 0
+-commutativeN/A
distribute-lft-inN/A
associate-*r*N/A
*-rgt-identityN/A
lower-fma.f64N/A
*-commutativeN/A
pow-plusN/A
lower-pow.f64N/A
metadata-evalN/A
lower--.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6465.5
Applied rewrites65.5%
Applied rewrites65.5%
Final simplification73.7%
(FPCore (x)
:precision binary64
(if (<= x -1.15)
(- (/ 2.0 (fma (fma 2.0 x -2.0) x 2.0)) 1.0)
(*
(fma (- (* 0.13333333333333333 (* x x)) 0.3333333333333333) (* x x) 1.0)
x)))
double code(double x) {
double tmp;
if (x <= -1.15) {
tmp = (2.0 / fma(fma(2.0, x, -2.0), x, 2.0)) - 1.0;
} else {
tmp = fma(((0.13333333333333333 * (x * x)) - 0.3333333333333333), (x * x), 1.0) * x;
}
return tmp;
}
function code(x) tmp = 0.0 if (x <= -1.15) tmp = Float64(Float64(2.0 / fma(fma(2.0, x, -2.0), x, 2.0)) - 1.0); else tmp = Float64(fma(Float64(Float64(0.13333333333333333 * Float64(x * x)) - 0.3333333333333333), Float64(x * x), 1.0) * x); end return tmp end
code[x_] := If[LessEqual[x, -1.15], N[(N[(2.0 / N[(N[(2.0 * x + -2.0), $MachinePrecision] * x + 2.0), $MachinePrecision]), $MachinePrecision] - 1.0), $MachinePrecision], N[(N[(N[(N[(0.13333333333333333 * N[(x * x), $MachinePrecision]), $MachinePrecision] - 0.3333333333333333), $MachinePrecision] * N[(x * x), $MachinePrecision] + 1.0), $MachinePrecision] * x), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.15:\\
\;\;\;\;\frac{2}{\mathsf{fma}\left(\mathsf{fma}\left(2, x, -2\right), x, 2\right)} - 1\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(0.13333333333333333 \cdot \left(x \cdot x\right) - 0.3333333333333333, x \cdot x, 1\right) \cdot x\\
\end{array}
\end{array}
if x < -1.1499999999999999Initial program 100.0%
lift-+.f64N/A
+-commutativeN/A
lower-+.f64100.0
lift-exp.f64N/A
lift-*.f64N/A
*-commutativeN/A
exp-prodN/A
lower-pow.f64N/A
lower-exp.f64100.0
Applied rewrites100.0%
Taylor expanded in x around 0
Applied rewrites97.9%
if -1.1499999999999999 < x Initial program 41.3%
Taylor expanded in x around 0
+-commutativeN/A
distribute-lft-inN/A
associate-*r*N/A
*-rgt-identityN/A
lower-fma.f64N/A
*-commutativeN/A
pow-plusN/A
lower-pow.f64N/A
metadata-evalN/A
lower--.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6465.5
Applied rewrites65.5%
Applied rewrites65.5%
Applied rewrites65.5%
Final simplification73.7%
(FPCore (x) :precision binary64 (if (<= x -1.0) (- (/ 2.0 (fma (fma 2.0 x -2.0) x 2.0)) 1.0) (fma (* -0.3333333333333333 (* x x)) x x)))
double code(double x) {
double tmp;
if (x <= -1.0) {
tmp = (2.0 / fma(fma(2.0, x, -2.0), x, 2.0)) - 1.0;
} else {
tmp = fma((-0.3333333333333333 * (x * x)), x, x);
}
return tmp;
}
function code(x) tmp = 0.0 if (x <= -1.0) tmp = Float64(Float64(2.0 / fma(fma(2.0, x, -2.0), x, 2.0)) - 1.0); else tmp = fma(Float64(-0.3333333333333333 * Float64(x * x)), x, x); end return tmp end
code[x_] := If[LessEqual[x, -1.0], N[(N[(2.0 / N[(N[(2.0 * x + -2.0), $MachinePrecision] * x + 2.0), $MachinePrecision]), $MachinePrecision] - 1.0), $MachinePrecision], N[(N[(-0.3333333333333333 * N[(x * x), $MachinePrecision]), $MachinePrecision] * x + x), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1:\\
\;\;\;\;\frac{2}{\mathsf{fma}\left(\mathsf{fma}\left(2, x, -2\right), x, 2\right)} - 1\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-0.3333333333333333 \cdot \left(x \cdot x\right), x, x\right)\\
\end{array}
\end{array}
if x < -1Initial program 100.0%
lift-+.f64N/A
+-commutativeN/A
lower-+.f64100.0
lift-exp.f64N/A
lift-*.f64N/A
*-commutativeN/A
exp-prodN/A
lower-pow.f64N/A
lower-exp.f64100.0
Applied rewrites100.0%
Taylor expanded in x around 0
Applied rewrites97.9%
if -1 < x Initial program 41.3%
Taylor expanded in x around 0
+-commutativeN/A
distribute-lft-inN/A
associate-*r*N/A
*-rgt-identityN/A
lower-fma.f64N/A
*-commutativeN/A
pow-plusN/A
lower-pow.f64N/A
metadata-evalN/A
lower--.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6465.5
Applied rewrites65.5%
Applied rewrites65.5%
Taylor expanded in x around 0
Applied rewrites64.3%
Final simplification72.8%
(FPCore (x) :precision binary64 (if (<= x -1.25) (- (/ 2.0 (fma (* 2.0 x) x 2.0)) 1.0) (fma (* -0.3333333333333333 (* x x)) x x)))
double code(double x) {
double tmp;
if (x <= -1.25) {
tmp = (2.0 / fma((2.0 * x), x, 2.0)) - 1.0;
} else {
tmp = fma((-0.3333333333333333 * (x * x)), x, x);
}
return tmp;
}
function code(x) tmp = 0.0 if (x <= -1.25) tmp = Float64(Float64(2.0 / fma(Float64(2.0 * x), x, 2.0)) - 1.0); else tmp = fma(Float64(-0.3333333333333333 * Float64(x * x)), x, x); end return tmp end
code[x_] := If[LessEqual[x, -1.25], N[(N[(2.0 / N[(N[(2.0 * x), $MachinePrecision] * x + 2.0), $MachinePrecision]), $MachinePrecision] - 1.0), $MachinePrecision], N[(N[(-0.3333333333333333 * N[(x * x), $MachinePrecision]), $MachinePrecision] * x + x), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.25:\\
\;\;\;\;\frac{2}{\mathsf{fma}\left(2 \cdot x, x, 2\right)} - 1\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-0.3333333333333333 \cdot \left(x \cdot x\right), x, x\right)\\
\end{array}
\end{array}
if x < -1.25Initial program 100.0%
lift-+.f64N/A
+-commutativeN/A
lower-+.f64100.0
lift-exp.f64N/A
lift-*.f64N/A
*-commutativeN/A
exp-prodN/A
lower-pow.f64N/A
lower-exp.f64100.0
Applied rewrites100.0%
Taylor expanded in x around 0
Applied rewrites97.9%
Taylor expanded in x around inf
Applied rewrites97.9%
if -1.25 < x Initial program 41.3%
Taylor expanded in x around 0
+-commutativeN/A
distribute-lft-inN/A
associate-*r*N/A
*-rgt-identityN/A
lower-fma.f64N/A
*-commutativeN/A
pow-plusN/A
lower-pow.f64N/A
metadata-evalN/A
lower--.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6465.5
Applied rewrites65.5%
Applied rewrites65.5%
Taylor expanded in x around 0
Applied rewrites64.3%
Final simplification72.8%
(FPCore (x) :precision binary64 (if (<= x -1.4) (- (/ 2.0 (* (* 2.0 x) x)) 1.0) (fma (* -0.3333333333333333 (* x x)) x x)))
double code(double x) {
double tmp;
if (x <= -1.4) {
tmp = (2.0 / ((2.0 * x) * x)) - 1.0;
} else {
tmp = fma((-0.3333333333333333 * (x * x)), x, x);
}
return tmp;
}
function code(x) tmp = 0.0 if (x <= -1.4) tmp = Float64(Float64(2.0 / Float64(Float64(2.0 * x) * x)) - 1.0); else tmp = fma(Float64(-0.3333333333333333 * Float64(x * x)), x, x); end return tmp end
code[x_] := If[LessEqual[x, -1.4], N[(N[(2.0 / N[(N[(2.0 * x), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision] - 1.0), $MachinePrecision], N[(N[(-0.3333333333333333 * N[(x * x), $MachinePrecision]), $MachinePrecision] * x + x), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.4:\\
\;\;\;\;\frac{2}{\left(2 \cdot x\right) \cdot x} - 1\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-0.3333333333333333 \cdot \left(x \cdot x\right), x, x\right)\\
\end{array}
\end{array}
if x < -1.3999999999999999Initial program 100.0%
lift-+.f64N/A
+-commutativeN/A
lower-+.f64100.0
lift-exp.f64N/A
lift-*.f64N/A
*-commutativeN/A
exp-prodN/A
lower-pow.f64N/A
lower-exp.f64100.0
Applied rewrites100.0%
Taylor expanded in x around 0
Applied rewrites97.9%
Taylor expanded in x around inf
Applied rewrites97.9%
if -1.3999999999999999 < x Initial program 41.3%
Taylor expanded in x around 0
+-commutativeN/A
distribute-lft-inN/A
associate-*r*N/A
*-rgt-identityN/A
lower-fma.f64N/A
*-commutativeN/A
pow-plusN/A
lower-pow.f64N/A
metadata-evalN/A
lower--.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6465.5
Applied rewrites65.5%
Applied rewrites65.5%
Taylor expanded in x around 0
Applied rewrites64.3%
Final simplification72.8%
(FPCore (x) :precision binary64 (if (<= x -1.3) (- (/ -1.0 (- x 1.0)) 1.0) (fma (* -0.3333333333333333 (* x x)) x x)))
double code(double x) {
double tmp;
if (x <= -1.3) {
tmp = (-1.0 / (x - 1.0)) - 1.0;
} else {
tmp = fma((-0.3333333333333333 * (x * x)), x, x);
}
return tmp;
}
function code(x) tmp = 0.0 if (x <= -1.3) tmp = Float64(Float64(-1.0 / Float64(x - 1.0)) - 1.0); else tmp = fma(Float64(-0.3333333333333333 * Float64(x * x)), x, x); end return tmp end
code[x_] := If[LessEqual[x, -1.3], N[(N[(-1.0 / N[(x - 1.0), $MachinePrecision]), $MachinePrecision] - 1.0), $MachinePrecision], N[(N[(-0.3333333333333333 * N[(x * x), $MachinePrecision]), $MachinePrecision] * x + x), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.3:\\
\;\;\;\;\frac{-1}{x - 1} - 1\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-0.3333333333333333 \cdot \left(x \cdot x\right), x, x\right)\\
\end{array}
\end{array}
if x < -1.30000000000000004Initial program 100.0%
lift-+.f64N/A
+-commutativeN/A
lower-+.f64100.0
lift-exp.f64N/A
lift-*.f64N/A
*-commutativeN/A
exp-prodN/A
lower-pow.f64N/A
lower-exp.f64100.0
Applied rewrites100.0%
Taylor expanded in x around 0
lower-+.f645.1
Applied rewrites5.1%
Applied rewrites4.7%
Taylor expanded in x around 0
Applied rewrites97.5%
if -1.30000000000000004 < x Initial program 41.3%
Taylor expanded in x around 0
+-commutativeN/A
distribute-lft-inN/A
associate-*r*N/A
*-rgt-identityN/A
lower-fma.f64N/A
*-commutativeN/A
pow-plusN/A
lower-pow.f64N/A
metadata-evalN/A
lower--.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6465.5
Applied rewrites65.5%
Applied rewrites65.5%
Taylor expanded in x around 0
Applied rewrites64.3%
(FPCore (x) :precision binary64 (fma (* -0.3333333333333333 (* x x)) x x))
double code(double x) {
return fma((-0.3333333333333333 * (x * x)), x, x);
}
function code(x) return fma(Float64(-0.3333333333333333 * Float64(x * x)), x, x) end
code[x_] := N[(N[(-0.3333333333333333 * N[(x * x), $MachinePrecision]), $MachinePrecision] * x + x), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(-0.3333333333333333 \cdot \left(x \cdot x\right), x, x\right)
\end{array}
Initial program 56.2%
Taylor expanded in x around 0
+-commutativeN/A
distribute-lft-inN/A
associate-*r*N/A
*-rgt-identityN/A
lower-fma.f64N/A
*-commutativeN/A
pow-plusN/A
lower-pow.f64N/A
metadata-evalN/A
lower--.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6449.8
Applied rewrites49.8%
Applied rewrites49.8%
Taylor expanded in x around 0
Applied rewrites48.2%
(FPCore (x) :precision binary64 (- (+ 1.0 x) 1.0))
double code(double x) {
return (1.0 + x) - 1.0;
}
real(8) function code(x)
real(8), intent (in) :: x
code = (1.0d0 + x) - 1.0d0
end function
public static double code(double x) {
return (1.0 + x) - 1.0;
}
def code(x): return (1.0 + x) - 1.0
function code(x) return Float64(Float64(1.0 + x) - 1.0) end
function tmp = code(x) tmp = (1.0 + x) - 1.0; end
code[x_] := N[(N[(1.0 + x), $MachinePrecision] - 1.0), $MachinePrecision]
\begin{array}{l}
\\
\left(1 + x\right) - 1
\end{array}
Initial program 56.2%
Taylor expanded in x around 0
lower-+.f646.6
Applied rewrites6.6%
Final simplification6.6%
(FPCore (x) :precision binary64 (- 1.0 1.0))
double code(double x) {
return 1.0 - 1.0;
}
real(8) function code(x)
real(8), intent (in) :: x
code = 1.0d0 - 1.0d0
end function
public static double code(double x) {
return 1.0 - 1.0;
}
def code(x): return 1.0 - 1.0
function code(x) return Float64(1.0 - 1.0) end
function tmp = code(x) tmp = 1.0 - 1.0; end
code[x_] := N[(1.0 - 1.0), $MachinePrecision]
\begin{array}{l}
\\
1 - 1
\end{array}
Initial program 56.2%
Taylor expanded in x around 0
Applied rewrites4.2%
Final simplification4.2%
herbie shell --seed 2024338
(FPCore (x)
:name "Logistic function from Lakshay Garg"
:precision binary64
(- (/ 2.0 (+ 1.0 (exp (* -2.0 x)))) 1.0))