
(FPCore (x y) :precision binary64 (- (/ 2.0 (+ 1.0 (exp (* -2.0 x)))) 1.0))
double code(double x, double y) {
return (2.0 / (1.0 + exp((-2.0 * x)))) - 1.0;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = (2.0d0 / (1.0d0 + exp(((-2.0d0) * x)))) - 1.0d0
end function
public static double code(double x, double y) {
return (2.0 / (1.0 + Math.exp((-2.0 * x)))) - 1.0;
}
def code(x, y): return (2.0 / (1.0 + math.exp((-2.0 * x)))) - 1.0
function code(x, y) return Float64(Float64(2.0 / Float64(1.0 + exp(Float64(-2.0 * x)))) - 1.0) end
function tmp = code(x, y) tmp = (2.0 / (1.0 + exp((-2.0 * x)))) - 1.0; end
code[x_, y_] := 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 13 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y) :precision binary64 (- (/ 2.0 (+ 1.0 (exp (* -2.0 x)))) 1.0))
double code(double x, double y) {
return (2.0 / (1.0 + exp((-2.0 * x)))) - 1.0;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = (2.0d0 / (1.0d0 + exp(((-2.0d0) * x)))) - 1.0d0
end function
public static double code(double x, double y) {
return (2.0 / (1.0 + Math.exp((-2.0 * x)))) - 1.0;
}
def code(x, y): return (2.0 / (1.0 + math.exp((-2.0 * x)))) - 1.0
function code(x, y) return Float64(Float64(2.0 / Float64(1.0 + exp(Float64(-2.0 * x)))) - 1.0) end
function tmp = code(x, y) tmp = (2.0 / (1.0 + exp((-2.0 * x)))) - 1.0; end
code[x_, y_] := 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 y)
:precision binary64
(let* ((t_0 (+ 2.0 (expm1 (* -2.0 x)))))
(if (<= (* -2.0 x) -0.05)
(/
(- 1.0 (/ 4.0 (pow t_0 2.0)))
(- -1.0 (/ 2.0 (+ 1.0 (pow (exp x) -2.0)))))
(if (<= (* -2.0 x) 5e-7)
(+ x (* -0.3333333333333333 (pow x 3.0)))
(+ -1.0 (/ 2.0 t_0))))))
double code(double x, double y) {
double t_0 = 2.0 + expm1((-2.0 * x));
double tmp;
if ((-2.0 * x) <= -0.05) {
tmp = (1.0 - (4.0 / pow(t_0, 2.0))) / (-1.0 - (2.0 / (1.0 + pow(exp(x), -2.0))));
} else if ((-2.0 * x) <= 5e-7) {
tmp = x + (-0.3333333333333333 * pow(x, 3.0));
} else {
tmp = -1.0 + (2.0 / t_0);
}
return tmp;
}
public static double code(double x, double y) {
double t_0 = 2.0 + Math.expm1((-2.0 * x));
double tmp;
if ((-2.0 * x) <= -0.05) {
tmp = (1.0 - (4.0 / Math.pow(t_0, 2.0))) / (-1.0 - (2.0 / (1.0 + Math.pow(Math.exp(x), -2.0))));
} else if ((-2.0 * x) <= 5e-7) {
tmp = x + (-0.3333333333333333 * Math.pow(x, 3.0));
} else {
tmp = -1.0 + (2.0 / t_0);
}
return tmp;
}
def code(x, y): t_0 = 2.0 + math.expm1((-2.0 * x)) tmp = 0 if (-2.0 * x) <= -0.05: tmp = (1.0 - (4.0 / math.pow(t_0, 2.0))) / (-1.0 - (2.0 / (1.0 + math.pow(math.exp(x), -2.0)))) elif (-2.0 * x) <= 5e-7: tmp = x + (-0.3333333333333333 * math.pow(x, 3.0)) else: tmp = -1.0 + (2.0 / t_0) return tmp
function code(x, y) t_0 = Float64(2.0 + expm1(Float64(-2.0 * x))) tmp = 0.0 if (Float64(-2.0 * x) <= -0.05) tmp = Float64(Float64(1.0 - Float64(4.0 / (t_0 ^ 2.0))) / Float64(-1.0 - Float64(2.0 / Float64(1.0 + (exp(x) ^ -2.0))))); elseif (Float64(-2.0 * x) <= 5e-7) tmp = Float64(x + Float64(-0.3333333333333333 * (x ^ 3.0))); else tmp = Float64(-1.0 + Float64(2.0 / t_0)); end return tmp end
code[x_, y_] := Block[{t$95$0 = N[(2.0 + N[(Exp[N[(-2.0 * x), $MachinePrecision]] - 1), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(-2.0 * x), $MachinePrecision], -0.05], N[(N[(1.0 - N[(4.0 / N[Power[t$95$0, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(-1.0 - N[(2.0 / N[(1.0 + N[Power[N[Exp[x], $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(-2.0 * x), $MachinePrecision], 5e-7], N[(x + N[(-0.3333333333333333 * N[Power[x, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(-1.0 + N[(2.0 / t$95$0), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 2 + \mathsf{expm1}\left(-2 \cdot x\right)\\
\mathbf{if}\;-2 \cdot x \leq -0.05:\\
\;\;\;\;\frac{1 - \frac{4}{{t_0}^{2}}}{-1 - \frac{2}{1 + {\left(e^{x}\right)}^{-2}}}\\
\mathbf{elif}\;-2 \cdot x \leq 5 \cdot 10^{-7}:\\
\;\;\;\;x + -0.3333333333333333 \cdot {x}^{3}\\
\mathbf{else}:\\
\;\;\;\;-1 + \frac{2}{t_0}\\
\end{array}
\end{array}
if (*.f64 -2 x) < -0.050000000000000003Initial program 99.8%
sub-neg99.8%
exp-prod99.8%
metadata-eval99.8%
Simplified99.8%
add-cbrt-cube99.9%
pow399.9%
Applied egg-rr99.9%
pow-exp99.9%
*-commutative99.9%
pow-exp99.9%
associate-*l*99.9%
metadata-eval99.9%
Applied egg-rr99.9%
pow1/399.8%
exp-prod99.8%
pow-pow99.8%
metadata-eval99.8%
exp-prod99.8%
log1p-expm1-u99.8%
log1p-udef99.8%
add-exp-log99.8%
+-commutative99.8%
flip-+99.8%
Applied egg-rr100.0%
Taylor expanded in x around inf 99.9%
*-commutative99.9%
exp-prod100.0%
Simplified100.0%
if -0.050000000000000003 < (*.f64 -2 x) < 4.99999999999999977e-7Initial program 7.1%
sub-neg7.1%
exp-prod7.1%
metadata-eval7.1%
Simplified7.1%
Taylor expanded in x around 0 100.0%
if 4.99999999999999977e-7 < (*.f64 -2 x) Initial program 100.0%
sub-neg100.0%
exp-prod100.0%
metadata-eval100.0%
Simplified100.0%
add-cbrt-cube100.0%
pow3100.0%
Applied egg-rr100.0%
rem-cbrt-cube100.0%
expm1-log1p-u100.0%
expm1-udef100.0%
log1p-udef100.0%
add-exp-log100.0%
Applied egg-rr100.0%
associate--l+100.0%
exp-prod100.0%
expm1-def100.0%
*-commutative100.0%
Simplified100.0%
add-exp-log100.0%
log1p-udef100.0%
log1p-expm1-u100.0%
exp-prod100.0%
metadata-eval100.0%
pow-pow99.9%
exp-prod100.0%
pow1/3100.0%
*-un-lft-identity100.0%
*-commutative100.0%
pow1/3100.0%
exp-prod99.9%
pow-pow100.0%
metadata-eval100.0%
exp-prod100.0%
log1p-expm1-u100.0%
log1p-udef100.0%
add-exp-log100.0%
associate-+r+100.0%
metadata-eval100.0%
Applied egg-rr100.0%
Final simplification100.0%
(FPCore (x y)
:precision binary64
(let* ((t_0 (+ 2.0 (expm1 (* -2.0 x)))) (t_1 (/ 2.0 t_0)))
(if (<= (* -2.0 x) -0.05)
(/ (- 1.0 (/ 4.0 (pow t_0 2.0))) (- -1.0 t_1))
(if (<= (* -2.0 x) 5e-7)
(+ x (* -0.3333333333333333 (pow x 3.0)))
(+ -1.0 t_1)))))
double code(double x, double y) {
double t_0 = 2.0 + expm1((-2.0 * x));
double t_1 = 2.0 / t_0;
double tmp;
if ((-2.0 * x) <= -0.05) {
tmp = (1.0 - (4.0 / pow(t_0, 2.0))) / (-1.0 - t_1);
} else if ((-2.0 * x) <= 5e-7) {
tmp = x + (-0.3333333333333333 * pow(x, 3.0));
} else {
tmp = -1.0 + t_1;
}
return tmp;
}
public static double code(double x, double y) {
double t_0 = 2.0 + Math.expm1((-2.0 * x));
double t_1 = 2.0 / t_0;
double tmp;
if ((-2.0 * x) <= -0.05) {
tmp = (1.0 - (4.0 / Math.pow(t_0, 2.0))) / (-1.0 - t_1);
} else if ((-2.0 * x) <= 5e-7) {
tmp = x + (-0.3333333333333333 * Math.pow(x, 3.0));
} else {
tmp = -1.0 + t_1;
}
return tmp;
}
def code(x, y): t_0 = 2.0 + math.expm1((-2.0 * x)) t_1 = 2.0 / t_0 tmp = 0 if (-2.0 * x) <= -0.05: tmp = (1.0 - (4.0 / math.pow(t_0, 2.0))) / (-1.0 - t_1) elif (-2.0 * x) <= 5e-7: tmp = x + (-0.3333333333333333 * math.pow(x, 3.0)) else: tmp = -1.0 + t_1 return tmp
function code(x, y) t_0 = Float64(2.0 + expm1(Float64(-2.0 * x))) t_1 = Float64(2.0 / t_0) tmp = 0.0 if (Float64(-2.0 * x) <= -0.05) tmp = Float64(Float64(1.0 - Float64(4.0 / (t_0 ^ 2.0))) / Float64(-1.0 - t_1)); elseif (Float64(-2.0 * x) <= 5e-7) tmp = Float64(x + Float64(-0.3333333333333333 * (x ^ 3.0))); else tmp = Float64(-1.0 + t_1); end return tmp end
code[x_, y_] := Block[{t$95$0 = N[(2.0 + N[(Exp[N[(-2.0 * x), $MachinePrecision]] - 1), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(2.0 / t$95$0), $MachinePrecision]}, If[LessEqual[N[(-2.0 * x), $MachinePrecision], -0.05], N[(N[(1.0 - N[(4.0 / N[Power[t$95$0, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(-1.0 - t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(-2.0 * x), $MachinePrecision], 5e-7], N[(x + N[(-0.3333333333333333 * N[Power[x, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(-1.0 + t$95$1), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 2 + \mathsf{expm1}\left(-2 \cdot x\right)\\
t_1 := \frac{2}{t_0}\\
\mathbf{if}\;-2 \cdot x \leq -0.05:\\
\;\;\;\;\frac{1 - \frac{4}{{t_0}^{2}}}{-1 - t_1}\\
\mathbf{elif}\;-2 \cdot x \leq 5 \cdot 10^{-7}:\\
\;\;\;\;x + -0.3333333333333333 \cdot {x}^{3}\\
\mathbf{else}:\\
\;\;\;\;-1 + t_1\\
\end{array}
\end{array}
if (*.f64 -2 x) < -0.050000000000000003Initial program 99.8%
sub-neg99.8%
exp-prod99.8%
metadata-eval99.8%
Simplified99.8%
add-cbrt-cube99.9%
pow399.9%
Applied egg-rr99.9%
pow-exp99.9%
*-commutative99.9%
pow-exp99.9%
associate-*l*99.9%
metadata-eval99.9%
Applied egg-rr99.9%
pow1/399.8%
exp-prod99.8%
pow-pow99.8%
metadata-eval99.8%
exp-prod99.8%
log1p-expm1-u99.8%
log1p-udef99.8%
add-exp-log99.8%
+-commutative99.8%
flip-+99.8%
Applied egg-rr100.0%
if -0.050000000000000003 < (*.f64 -2 x) < 4.99999999999999977e-7Initial program 7.1%
sub-neg7.1%
exp-prod7.1%
metadata-eval7.1%
Simplified7.1%
Taylor expanded in x around 0 100.0%
if 4.99999999999999977e-7 < (*.f64 -2 x) Initial program 100.0%
sub-neg100.0%
exp-prod100.0%
metadata-eval100.0%
Simplified100.0%
add-cbrt-cube100.0%
pow3100.0%
Applied egg-rr100.0%
rem-cbrt-cube100.0%
expm1-log1p-u100.0%
expm1-udef100.0%
log1p-udef100.0%
add-exp-log100.0%
Applied egg-rr100.0%
associate--l+100.0%
exp-prod100.0%
expm1-def100.0%
*-commutative100.0%
Simplified100.0%
add-exp-log100.0%
log1p-udef100.0%
log1p-expm1-u100.0%
exp-prod100.0%
metadata-eval100.0%
pow-pow99.9%
exp-prod100.0%
pow1/3100.0%
*-un-lft-identity100.0%
*-commutative100.0%
pow1/3100.0%
exp-prod99.9%
pow-pow100.0%
metadata-eval100.0%
exp-prod100.0%
log1p-expm1-u100.0%
log1p-udef100.0%
add-exp-log100.0%
associate-+r+100.0%
metadata-eval100.0%
Applied egg-rr100.0%
Final simplification100.0%
(FPCore (x y)
:precision binary64
(let* ((t_0 (+ -1.0 (/ 2.0 (+ 2.0 (expm1 (* -2.0 x)))))))
(if (<= (* -2.0 x) -0.05)
(pow (cbrt t_0) 3.0)
(if (<= (* -2.0 x) 5e-7) (+ x (* -0.3333333333333333 (pow x 3.0))) t_0))))
double code(double x, double y) {
double t_0 = -1.0 + (2.0 / (2.0 + expm1((-2.0 * x))));
double tmp;
if ((-2.0 * x) <= -0.05) {
tmp = pow(cbrt(t_0), 3.0);
} else if ((-2.0 * x) <= 5e-7) {
tmp = x + (-0.3333333333333333 * pow(x, 3.0));
} else {
tmp = t_0;
}
return tmp;
}
public static double code(double x, double y) {
double t_0 = -1.0 + (2.0 / (2.0 + Math.expm1((-2.0 * x))));
double tmp;
if ((-2.0 * x) <= -0.05) {
tmp = Math.pow(Math.cbrt(t_0), 3.0);
} else if ((-2.0 * x) <= 5e-7) {
tmp = x + (-0.3333333333333333 * Math.pow(x, 3.0));
} else {
tmp = t_0;
}
return tmp;
}
function code(x, y) t_0 = Float64(-1.0 + Float64(2.0 / Float64(2.0 + expm1(Float64(-2.0 * x))))) tmp = 0.0 if (Float64(-2.0 * x) <= -0.05) tmp = cbrt(t_0) ^ 3.0; elseif (Float64(-2.0 * x) <= 5e-7) tmp = Float64(x + Float64(-0.3333333333333333 * (x ^ 3.0))); else tmp = t_0; end return tmp end
code[x_, y_] := Block[{t$95$0 = N[(-1.0 + N[(2.0 / N[(2.0 + N[(Exp[N[(-2.0 * x), $MachinePrecision]] - 1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(-2.0 * x), $MachinePrecision], -0.05], N[Power[N[Power[t$95$0, 1/3], $MachinePrecision], 3.0], $MachinePrecision], If[LessEqual[N[(-2.0 * x), $MachinePrecision], 5e-7], N[(x + N[(-0.3333333333333333 * N[Power[x, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := -1 + \frac{2}{2 + \mathsf{expm1}\left(-2 \cdot x\right)}\\
\mathbf{if}\;-2 \cdot x \leq -0.05:\\
\;\;\;\;{\left(\sqrt[3]{t_0}\right)}^{3}\\
\mathbf{elif}\;-2 \cdot x \leq 5 \cdot 10^{-7}:\\
\;\;\;\;x + -0.3333333333333333 \cdot {x}^{3}\\
\mathbf{else}:\\
\;\;\;\;t_0\\
\end{array}
\end{array}
if (*.f64 -2 x) < -0.050000000000000003Initial program 99.8%
sub-neg99.8%
exp-prod99.8%
metadata-eval99.8%
Simplified99.8%
add-cbrt-cube99.9%
pow399.9%
Applied egg-rr99.9%
pow-exp99.9%
*-commutative99.9%
pow-exp99.9%
associate-*l*99.9%
metadata-eval99.9%
Applied egg-rr99.9%
add-cube-cbrt99.9%
pow399.9%
Applied egg-rr99.9%
if -0.050000000000000003 < (*.f64 -2 x) < 4.99999999999999977e-7Initial program 7.1%
sub-neg7.1%
exp-prod7.1%
metadata-eval7.1%
Simplified7.1%
Taylor expanded in x around 0 100.0%
if 4.99999999999999977e-7 < (*.f64 -2 x) Initial program 100.0%
sub-neg100.0%
exp-prod100.0%
metadata-eval100.0%
Simplified100.0%
add-cbrt-cube100.0%
pow3100.0%
Applied egg-rr100.0%
rem-cbrt-cube100.0%
expm1-log1p-u100.0%
expm1-udef100.0%
log1p-udef100.0%
add-exp-log100.0%
Applied egg-rr100.0%
associate--l+100.0%
exp-prod100.0%
expm1-def100.0%
*-commutative100.0%
Simplified100.0%
add-exp-log100.0%
log1p-udef100.0%
log1p-expm1-u100.0%
exp-prod100.0%
metadata-eval100.0%
pow-pow99.9%
exp-prod100.0%
pow1/3100.0%
*-un-lft-identity100.0%
*-commutative100.0%
pow1/3100.0%
exp-prod99.9%
pow-pow100.0%
metadata-eval100.0%
exp-prod100.0%
log1p-expm1-u100.0%
log1p-udef100.0%
add-exp-log100.0%
associate-+r+100.0%
metadata-eval100.0%
Applied egg-rr100.0%
Final simplification100.0%
(FPCore (x y)
:precision binary64
(let* ((t_0 (+ -1.0 (/ 2.0 (+ 2.0 (expm1 (* -2.0 x)))))))
(if (<= (* -2.0 x) -0.05)
(exp (log t_0))
(if (<= (* -2.0 x) 5e-7) (+ x (* -0.3333333333333333 (pow x 3.0))) t_0))))
double code(double x, double y) {
double t_0 = -1.0 + (2.0 / (2.0 + expm1((-2.0 * x))));
double tmp;
if ((-2.0 * x) <= -0.05) {
tmp = exp(log(t_0));
} else if ((-2.0 * x) <= 5e-7) {
tmp = x + (-0.3333333333333333 * pow(x, 3.0));
} else {
tmp = t_0;
}
return tmp;
}
public static double code(double x, double y) {
double t_0 = -1.0 + (2.0 / (2.0 + Math.expm1((-2.0 * x))));
double tmp;
if ((-2.0 * x) <= -0.05) {
tmp = Math.exp(Math.log(t_0));
} else if ((-2.0 * x) <= 5e-7) {
tmp = x + (-0.3333333333333333 * Math.pow(x, 3.0));
} else {
tmp = t_0;
}
return tmp;
}
def code(x, y): t_0 = -1.0 + (2.0 / (2.0 + math.expm1((-2.0 * x)))) tmp = 0 if (-2.0 * x) <= -0.05: tmp = math.exp(math.log(t_0)) elif (-2.0 * x) <= 5e-7: tmp = x + (-0.3333333333333333 * math.pow(x, 3.0)) else: tmp = t_0 return tmp
function code(x, y) t_0 = Float64(-1.0 + Float64(2.0 / Float64(2.0 + expm1(Float64(-2.0 * x))))) tmp = 0.0 if (Float64(-2.0 * x) <= -0.05) tmp = exp(log(t_0)); elseif (Float64(-2.0 * x) <= 5e-7) tmp = Float64(x + Float64(-0.3333333333333333 * (x ^ 3.0))); else tmp = t_0; end return tmp end
code[x_, y_] := Block[{t$95$0 = N[(-1.0 + N[(2.0 / N[(2.0 + N[(Exp[N[(-2.0 * x), $MachinePrecision]] - 1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(-2.0 * x), $MachinePrecision], -0.05], N[Exp[N[Log[t$95$0], $MachinePrecision]], $MachinePrecision], If[LessEqual[N[(-2.0 * x), $MachinePrecision], 5e-7], N[(x + N[(-0.3333333333333333 * N[Power[x, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := -1 + \frac{2}{2 + \mathsf{expm1}\left(-2 \cdot x\right)}\\
\mathbf{if}\;-2 \cdot x \leq -0.05:\\
\;\;\;\;e^{\log t_0}\\
\mathbf{elif}\;-2 \cdot x \leq 5 \cdot 10^{-7}:\\
\;\;\;\;x + -0.3333333333333333 \cdot {x}^{3}\\
\mathbf{else}:\\
\;\;\;\;t_0\\
\end{array}
\end{array}
if (*.f64 -2 x) < -0.050000000000000003Initial program 99.8%
sub-neg99.8%
exp-prod99.8%
metadata-eval99.8%
Simplified99.8%
add-cbrt-cube99.9%
pow399.9%
Applied egg-rr99.9%
pow-exp99.9%
*-commutative99.9%
pow-exp99.9%
associate-*l*99.9%
metadata-eval99.9%
Applied egg-rr99.9%
add-exp-log99.9%
pow1/399.8%
exp-prod99.8%
pow-pow99.8%
metadata-eval99.8%
exp-prod99.8%
log1p-expm1-u99.8%
log1p-udef99.8%
add-exp-log99.8%
associate-+r+99.9%
metadata-eval99.9%
Applied egg-rr99.9%
if -0.050000000000000003 < (*.f64 -2 x) < 4.99999999999999977e-7Initial program 7.1%
sub-neg7.1%
exp-prod7.1%
metadata-eval7.1%
Simplified7.1%
Taylor expanded in x around 0 100.0%
if 4.99999999999999977e-7 < (*.f64 -2 x) Initial program 100.0%
sub-neg100.0%
exp-prod100.0%
metadata-eval100.0%
Simplified100.0%
add-cbrt-cube100.0%
pow3100.0%
Applied egg-rr100.0%
rem-cbrt-cube100.0%
expm1-log1p-u100.0%
expm1-udef100.0%
log1p-udef100.0%
add-exp-log100.0%
Applied egg-rr100.0%
associate--l+100.0%
exp-prod100.0%
expm1-def100.0%
*-commutative100.0%
Simplified100.0%
add-exp-log100.0%
log1p-udef100.0%
log1p-expm1-u100.0%
exp-prod100.0%
metadata-eval100.0%
pow-pow99.9%
exp-prod100.0%
pow1/3100.0%
*-un-lft-identity100.0%
*-commutative100.0%
pow1/3100.0%
exp-prod99.9%
pow-pow100.0%
metadata-eval100.0%
exp-prod100.0%
log1p-expm1-u100.0%
log1p-udef100.0%
add-exp-log100.0%
associate-+r+100.0%
metadata-eval100.0%
Applied egg-rr100.0%
Final simplification100.0%
(FPCore (x y)
:precision binary64
(if (<= (* -2.0 x) -0.05)
(fabs (+ -1.0 (/ 2.0 (+ 1.0 (pow (exp 2.0) x)))))
(if (<= (* -2.0 x) 5e-7)
(+ x (* -0.3333333333333333 (pow x 3.0)))
(+ -1.0 (/ 2.0 (+ 2.0 (expm1 (* -2.0 x))))))))
double code(double x, double y) {
double tmp;
if ((-2.0 * x) <= -0.05) {
tmp = fabs((-1.0 + (2.0 / (1.0 + pow(exp(2.0), x)))));
} else if ((-2.0 * x) <= 5e-7) {
tmp = x + (-0.3333333333333333 * pow(x, 3.0));
} else {
tmp = -1.0 + (2.0 / (2.0 + expm1((-2.0 * x))));
}
return tmp;
}
public static double code(double x, double y) {
double tmp;
if ((-2.0 * x) <= -0.05) {
tmp = Math.abs((-1.0 + (2.0 / (1.0 + Math.pow(Math.exp(2.0), x)))));
} else if ((-2.0 * x) <= 5e-7) {
tmp = x + (-0.3333333333333333 * Math.pow(x, 3.0));
} else {
tmp = -1.0 + (2.0 / (2.0 + Math.expm1((-2.0 * x))));
}
return tmp;
}
def code(x, y): tmp = 0 if (-2.0 * x) <= -0.05: tmp = math.fabs((-1.0 + (2.0 / (1.0 + math.pow(math.exp(2.0), x))))) elif (-2.0 * x) <= 5e-7: tmp = x + (-0.3333333333333333 * math.pow(x, 3.0)) else: tmp = -1.0 + (2.0 / (2.0 + math.expm1((-2.0 * x)))) return tmp
function code(x, y) tmp = 0.0 if (Float64(-2.0 * x) <= -0.05) tmp = abs(Float64(-1.0 + Float64(2.0 / Float64(1.0 + (exp(2.0) ^ x))))); elseif (Float64(-2.0 * x) <= 5e-7) tmp = Float64(x + Float64(-0.3333333333333333 * (x ^ 3.0))); else tmp = Float64(-1.0 + Float64(2.0 / Float64(2.0 + expm1(Float64(-2.0 * x))))); end return tmp end
code[x_, y_] := If[LessEqual[N[(-2.0 * x), $MachinePrecision], -0.05], N[Abs[N[(-1.0 + N[(2.0 / N[(1.0 + N[Power[N[Exp[2.0], $MachinePrecision], x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[N[(-2.0 * x), $MachinePrecision], 5e-7], N[(x + N[(-0.3333333333333333 * N[Power[x, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(-1.0 + N[(2.0 / N[(2.0 + N[(Exp[N[(-2.0 * x), $MachinePrecision]] - 1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;-2 \cdot x \leq -0.05:\\
\;\;\;\;\left|-1 + \frac{2}{1 + {\left(e^{2}\right)}^{x}}\right|\\
\mathbf{elif}\;-2 \cdot x \leq 5 \cdot 10^{-7}:\\
\;\;\;\;x + -0.3333333333333333 \cdot {x}^{3}\\
\mathbf{else}:\\
\;\;\;\;-1 + \frac{2}{2 + \mathsf{expm1}\left(-2 \cdot x\right)}\\
\end{array}
\end{array}
if (*.f64 -2 x) < -0.050000000000000003Initial program 99.8%
sub-neg99.8%
exp-prod99.8%
metadata-eval99.8%
Simplified99.8%
add-cbrt-cube99.9%
pow399.9%
Applied egg-rr99.9%
rem-cbrt-cube99.8%
expm1-log1p-u99.8%
expm1-udef99.8%
log1p-udef99.8%
add-exp-log99.8%
Applied egg-rr99.8%
associate--l+99.8%
exp-prod99.8%
expm1-def99.8%
*-commutative99.8%
Simplified99.8%
add-exp-log99.8%
log1p-udef99.8%
log1p-expm1-u99.8%
exp-prod99.8%
metadata-eval99.8%
pow-pow99.8%
exp-prod99.8%
pow1/399.9%
*-un-lft-identity99.9%
*-commutative99.9%
pow1/399.8%
exp-prod99.8%
pow-pow99.8%
metadata-eval99.8%
exp-prod99.8%
log1p-expm1-u99.8%
log1p-udef99.8%
add-exp-log99.8%
associate-+r+99.9%
metadata-eval99.9%
Applied egg-rr99.9%
add-sqr-sqrt99.9%
sqrt-unprod99.9%
pow299.9%
Applied egg-rr99.9%
unpow299.9%
rem-sqrt-square99.9%
sub-neg99.9%
metadata-eval99.9%
+-commutative99.9%
Simplified99.9%
if -0.050000000000000003 < (*.f64 -2 x) < 4.99999999999999977e-7Initial program 7.1%
sub-neg7.1%
exp-prod7.1%
metadata-eval7.1%
Simplified7.1%
Taylor expanded in x around 0 100.0%
if 4.99999999999999977e-7 < (*.f64 -2 x) Initial program 100.0%
sub-neg100.0%
exp-prod100.0%
metadata-eval100.0%
Simplified100.0%
add-cbrt-cube100.0%
pow3100.0%
Applied egg-rr100.0%
rem-cbrt-cube100.0%
expm1-log1p-u100.0%
expm1-udef100.0%
log1p-udef100.0%
add-exp-log100.0%
Applied egg-rr100.0%
associate--l+100.0%
exp-prod100.0%
expm1-def100.0%
*-commutative100.0%
Simplified100.0%
add-exp-log100.0%
log1p-udef100.0%
log1p-expm1-u100.0%
exp-prod100.0%
metadata-eval100.0%
pow-pow99.9%
exp-prod100.0%
pow1/3100.0%
*-un-lft-identity100.0%
*-commutative100.0%
pow1/3100.0%
exp-prod99.9%
pow-pow100.0%
metadata-eval100.0%
exp-prod100.0%
log1p-expm1-u100.0%
log1p-udef100.0%
add-exp-log100.0%
associate-+r+100.0%
metadata-eval100.0%
Applied egg-rr100.0%
Final simplification100.0%
(FPCore (x y) :precision binary64 (if (or (<= (* -2.0 x) -0.05) (not (<= (* -2.0 x) 5e-7))) (+ -1.0 (/ 2.0 (+ 1.0 (exp (* -2.0 x))))) (+ x (* -0.3333333333333333 (pow x 3.0)))))
double code(double x, double y) {
double tmp;
if (((-2.0 * x) <= -0.05) || !((-2.0 * x) <= 5e-7)) {
tmp = -1.0 + (2.0 / (1.0 + exp((-2.0 * x))));
} else {
tmp = x + (-0.3333333333333333 * pow(x, 3.0));
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if ((((-2.0d0) * x) <= (-0.05d0)) .or. (.not. (((-2.0d0) * x) <= 5d-7))) then
tmp = (-1.0d0) + (2.0d0 / (1.0d0 + exp(((-2.0d0) * x))))
else
tmp = x + ((-0.3333333333333333d0) * (x ** 3.0d0))
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (((-2.0 * x) <= -0.05) || !((-2.0 * x) <= 5e-7)) {
tmp = -1.0 + (2.0 / (1.0 + Math.exp((-2.0 * x))));
} else {
tmp = x + (-0.3333333333333333 * Math.pow(x, 3.0));
}
return tmp;
}
def code(x, y): tmp = 0 if ((-2.0 * x) <= -0.05) or not ((-2.0 * x) <= 5e-7): tmp = -1.0 + (2.0 / (1.0 + math.exp((-2.0 * x)))) else: tmp = x + (-0.3333333333333333 * math.pow(x, 3.0)) return tmp
function code(x, y) tmp = 0.0 if ((Float64(-2.0 * x) <= -0.05) || !(Float64(-2.0 * x) <= 5e-7)) tmp = Float64(-1.0 + Float64(2.0 / Float64(1.0 + exp(Float64(-2.0 * x))))); else tmp = Float64(x + Float64(-0.3333333333333333 * (x ^ 3.0))); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (((-2.0 * x) <= -0.05) || ~(((-2.0 * x) <= 5e-7))) tmp = -1.0 + (2.0 / (1.0 + exp((-2.0 * x)))); else tmp = x + (-0.3333333333333333 * (x ^ 3.0)); end tmp_2 = tmp; end
code[x_, y_] := If[Or[LessEqual[N[(-2.0 * x), $MachinePrecision], -0.05], N[Not[LessEqual[N[(-2.0 * x), $MachinePrecision], 5e-7]], $MachinePrecision]], N[(-1.0 + N[(2.0 / N[(1.0 + N[Exp[N[(-2.0 * x), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(-0.3333333333333333 * N[Power[x, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;-2 \cdot x \leq -0.05 \lor \neg \left(-2 \cdot x \leq 5 \cdot 10^{-7}\right):\\
\;\;\;\;-1 + \frac{2}{1 + e^{-2 \cdot x}}\\
\mathbf{else}:\\
\;\;\;\;x + -0.3333333333333333 \cdot {x}^{3}\\
\end{array}
\end{array}
if (*.f64 -2 x) < -0.050000000000000003 or 4.99999999999999977e-7 < (*.f64 -2 x) Initial program 99.9%
if -0.050000000000000003 < (*.f64 -2 x) < 4.99999999999999977e-7Initial program 7.1%
sub-neg7.1%
exp-prod7.1%
metadata-eval7.1%
Simplified7.1%
Taylor expanded in x around 0 100.0%
Final simplification100.0%
(FPCore (x y) :precision binary64 (if (or (<= (* -2.0 x) -0.05) (not (<= (* -2.0 x) 5e-7))) (+ -1.0 (/ 2.0 (+ 2.0 (expm1 (* -2.0 x))))) (+ x (* -0.3333333333333333 (pow x 3.0)))))
double code(double x, double y) {
double tmp;
if (((-2.0 * x) <= -0.05) || !((-2.0 * x) <= 5e-7)) {
tmp = -1.0 + (2.0 / (2.0 + expm1((-2.0 * x))));
} else {
tmp = x + (-0.3333333333333333 * pow(x, 3.0));
}
return tmp;
}
public static double code(double x, double y) {
double tmp;
if (((-2.0 * x) <= -0.05) || !((-2.0 * x) <= 5e-7)) {
tmp = -1.0 + (2.0 / (2.0 + Math.expm1((-2.0 * x))));
} else {
tmp = x + (-0.3333333333333333 * Math.pow(x, 3.0));
}
return tmp;
}
def code(x, y): tmp = 0 if ((-2.0 * x) <= -0.05) or not ((-2.0 * x) <= 5e-7): tmp = -1.0 + (2.0 / (2.0 + math.expm1((-2.0 * x)))) else: tmp = x + (-0.3333333333333333 * math.pow(x, 3.0)) return tmp
function code(x, y) tmp = 0.0 if ((Float64(-2.0 * x) <= -0.05) || !(Float64(-2.0 * x) <= 5e-7)) tmp = Float64(-1.0 + Float64(2.0 / Float64(2.0 + expm1(Float64(-2.0 * x))))); else tmp = Float64(x + Float64(-0.3333333333333333 * (x ^ 3.0))); end return tmp end
code[x_, y_] := If[Or[LessEqual[N[(-2.0 * x), $MachinePrecision], -0.05], N[Not[LessEqual[N[(-2.0 * x), $MachinePrecision], 5e-7]], $MachinePrecision]], N[(-1.0 + N[(2.0 / N[(2.0 + N[(Exp[N[(-2.0 * x), $MachinePrecision]] - 1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(-0.3333333333333333 * N[Power[x, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;-2 \cdot x \leq -0.05 \lor \neg \left(-2 \cdot x \leq 5 \cdot 10^{-7}\right):\\
\;\;\;\;-1 + \frac{2}{2 + \mathsf{expm1}\left(-2 \cdot x\right)}\\
\mathbf{else}:\\
\;\;\;\;x + -0.3333333333333333 \cdot {x}^{3}\\
\end{array}
\end{array}
if (*.f64 -2 x) < -0.050000000000000003 or 4.99999999999999977e-7 < (*.f64 -2 x) Initial program 99.9%
sub-neg99.9%
exp-prod99.9%
metadata-eval99.9%
Simplified99.9%
add-cbrt-cube99.9%
pow399.9%
Applied egg-rr99.9%
rem-cbrt-cube99.9%
expm1-log1p-u99.9%
expm1-udef99.9%
log1p-udef99.9%
add-exp-log99.9%
Applied egg-rr99.9%
associate--l+99.9%
exp-prod99.9%
expm1-def99.9%
*-commutative99.9%
Simplified99.9%
add-exp-log99.9%
log1p-udef99.9%
log1p-expm1-u99.9%
exp-prod99.9%
metadata-eval99.9%
pow-pow99.9%
exp-prod99.9%
pow1/399.9%
*-un-lft-identity99.9%
*-commutative99.9%
pow1/399.9%
exp-prod99.9%
pow-pow99.9%
metadata-eval99.9%
exp-prod99.9%
log1p-expm1-u99.9%
log1p-udef99.9%
add-exp-log99.9%
associate-+r+99.9%
metadata-eval99.9%
Applied egg-rr99.9%
if -0.050000000000000003 < (*.f64 -2 x) < 4.99999999999999977e-7Initial program 7.1%
sub-neg7.1%
exp-prod7.1%
metadata-eval7.1%
Simplified7.1%
Taylor expanded in x around 0 100.0%
Final simplification100.0%
(FPCore (x y) :precision binary64 (if (<= x -0.58) (+ -1.0 (/ 2.0 (+ 2.0 (* -2.0 x)))) (/ (* x 2.0) (+ x 2.0))))
double code(double x, double y) {
double tmp;
if (x <= -0.58) {
tmp = -1.0 + (2.0 / (2.0 + (-2.0 * x)));
} else {
tmp = (x * 2.0) / (x + 2.0);
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (x <= (-0.58d0)) then
tmp = (-1.0d0) + (2.0d0 / (2.0d0 + ((-2.0d0) * x)))
else
tmp = (x * 2.0d0) / (x + 2.0d0)
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (x <= -0.58) {
tmp = -1.0 + (2.0 / (2.0 + (-2.0 * x)));
} else {
tmp = (x * 2.0) / (x + 2.0);
}
return tmp;
}
def code(x, y): tmp = 0 if x <= -0.58: tmp = -1.0 + (2.0 / (2.0 + (-2.0 * x))) else: tmp = (x * 2.0) / (x + 2.0) return tmp
function code(x, y) tmp = 0.0 if (x <= -0.58) tmp = Float64(-1.0 + Float64(2.0 / Float64(2.0 + Float64(-2.0 * x)))); else tmp = Float64(Float64(x * 2.0) / Float64(x + 2.0)); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (x <= -0.58) tmp = -1.0 + (2.0 / (2.0 + (-2.0 * x))); else tmp = (x * 2.0) / (x + 2.0); end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[x, -0.58], N[(-1.0 + N[(2.0 / N[(2.0 + N[(-2.0 * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x * 2.0), $MachinePrecision] / N[(x + 2.0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -0.58:\\
\;\;\;\;-1 + \frac{2}{2 + -2 \cdot x}\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot 2}{x + 2}\\
\end{array}
\end{array}
if x < -0.57999999999999996Initial program 100.0%
sub-neg100.0%
exp-prod100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in x around 0 98.7%
*-commutative98.7%
Simplified98.7%
if -0.57999999999999996 < x Initial program 39.6%
sub-neg39.6%
exp-prod39.6%
metadata-eval39.6%
Simplified39.6%
Taylor expanded in x around 0 6.8%
+-commutative6.8%
Simplified6.8%
flip-+6.7%
metadata-eval6.7%
difference-of-sqr-16.7%
metadata-eval6.7%
sub-neg6.7%
associate--l+6.7%
metadata-eval6.7%
add-exp-log6.7%
+-commutative6.7%
log1p-udef6.7%
expm1-udef66.8%
expm1-log1p-u66.8%
associate--l+66.8%
metadata-eval66.8%
Applied egg-rr66.8%
Taylor expanded in x around 0 70.9%
*-commutative70.9%
Simplified70.9%
Final simplification77.6%
(FPCore (x y) :precision binary64 (if (<= x -0.66) -1.0 (/ 2.0 (+ 1.0 (/ 2.0 x)))))
double code(double x, double y) {
double tmp;
if (x <= -0.66) {
tmp = -1.0;
} else {
tmp = 2.0 / (1.0 + (2.0 / x));
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (x <= (-0.66d0)) then
tmp = -1.0d0
else
tmp = 2.0d0 / (1.0d0 + (2.0d0 / x))
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (x <= -0.66) {
tmp = -1.0;
} else {
tmp = 2.0 / (1.0 + (2.0 / x));
}
return tmp;
}
def code(x, y): tmp = 0 if x <= -0.66: tmp = -1.0 else: tmp = 2.0 / (1.0 + (2.0 / x)) return tmp
function code(x, y) tmp = 0.0 if (x <= -0.66) tmp = -1.0; else tmp = Float64(2.0 / Float64(1.0 + Float64(2.0 / x))); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (x <= -0.66) tmp = -1.0; else tmp = 2.0 / (1.0 + (2.0 / x)); end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[x, -0.66], -1.0, N[(2.0 / N[(1.0 + N[(2.0 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -0.66:\\
\;\;\;\;-1\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{1 + \frac{2}{x}}\\
\end{array}
\end{array}
if x < -0.660000000000000031Initial program 100.0%
sub-neg100.0%
exp-prod100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in x around 0 98.7%
*-commutative98.7%
Simplified98.7%
Taylor expanded in x around inf 98.7%
if -0.660000000000000031 < x Initial program 39.6%
sub-neg39.6%
exp-prod39.6%
metadata-eval39.6%
Simplified39.6%
Taylor expanded in x around 0 6.8%
+-commutative6.8%
Simplified6.8%
flip-+6.7%
div-inv6.7%
metadata-eval6.7%
difference-of-sqr-16.7%
metadata-eval6.7%
sub-neg6.7%
associate--l+6.7%
metadata-eval6.7%
add-exp-log6.7%
+-commutative6.7%
log1p-udef6.7%
expm1-udef66.8%
expm1-log1p-u66.8%
associate--l+66.8%
metadata-eval66.8%
Applied egg-rr66.8%
Taylor expanded in x around 0 70.9%
*-commutative70.9%
Simplified70.9%
expm1-log1p-u70.9%
expm1-udef11.1%
*-commutative11.1%
associate-*l*11.1%
+-commutative11.1%
div-inv11.1%
Applied egg-rr11.1%
expm1-def70.9%
expm1-log1p70.9%
associate-*r/70.9%
/-rgt-identity70.9%
associate-/l*70.7%
associate-/r*70.7%
+-commutative70.7%
distribute-rgt-in70.7%
rgt-mult-inverse70.7%
associate-*r/70.7%
metadata-eval70.7%
Simplified70.7%
Final simplification77.5%
(FPCore (x y) :precision binary64 (if (<= x -0.66) -1.0 (/ (* x 2.0) (+ x 2.0))))
double code(double x, double y) {
double tmp;
if (x <= -0.66) {
tmp = -1.0;
} else {
tmp = (x * 2.0) / (x + 2.0);
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (x <= (-0.66d0)) then
tmp = -1.0d0
else
tmp = (x * 2.0d0) / (x + 2.0d0)
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (x <= -0.66) {
tmp = -1.0;
} else {
tmp = (x * 2.0) / (x + 2.0);
}
return tmp;
}
def code(x, y): tmp = 0 if x <= -0.66: tmp = -1.0 else: tmp = (x * 2.0) / (x + 2.0) return tmp
function code(x, y) tmp = 0.0 if (x <= -0.66) tmp = -1.0; else tmp = Float64(Float64(x * 2.0) / Float64(x + 2.0)); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (x <= -0.66) tmp = -1.0; else tmp = (x * 2.0) / (x + 2.0); end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[x, -0.66], -1.0, N[(N[(x * 2.0), $MachinePrecision] / N[(x + 2.0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -0.66:\\
\;\;\;\;-1\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot 2}{x + 2}\\
\end{array}
\end{array}
if x < -0.660000000000000031Initial program 100.0%
sub-neg100.0%
exp-prod100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in x around 0 98.7%
*-commutative98.7%
Simplified98.7%
Taylor expanded in x around inf 98.7%
if -0.660000000000000031 < x Initial program 39.6%
sub-neg39.6%
exp-prod39.6%
metadata-eval39.6%
Simplified39.6%
Taylor expanded in x around 0 6.8%
+-commutative6.8%
Simplified6.8%
flip-+6.7%
metadata-eval6.7%
difference-of-sqr-16.7%
metadata-eval6.7%
sub-neg6.7%
associate--l+6.7%
metadata-eval6.7%
add-exp-log6.7%
+-commutative6.7%
log1p-udef6.7%
expm1-udef66.8%
expm1-log1p-u66.8%
associate--l+66.8%
metadata-eval66.8%
Applied egg-rr66.8%
Taylor expanded in x around 0 70.9%
*-commutative70.9%
Simplified70.9%
Final simplification77.6%
(FPCore (x y) :precision binary64 (if (<= x -1.0) -1.0 (if (<= x 2.0) x 2.0)))
double code(double x, double y) {
double tmp;
if (x <= -1.0) {
tmp = -1.0;
} else if (x <= 2.0) {
tmp = x;
} else {
tmp = 2.0;
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (x <= (-1.0d0)) then
tmp = -1.0d0
else if (x <= 2.0d0) then
tmp = x
else
tmp = 2.0d0
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (x <= -1.0) {
tmp = -1.0;
} else if (x <= 2.0) {
tmp = x;
} else {
tmp = 2.0;
}
return tmp;
}
def code(x, y): tmp = 0 if x <= -1.0: tmp = -1.0 elif x <= 2.0: tmp = x else: tmp = 2.0 return tmp
function code(x, y) tmp = 0.0 if (x <= -1.0) tmp = -1.0; elseif (x <= 2.0) tmp = x; else tmp = 2.0; end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (x <= -1.0) tmp = -1.0; elseif (x <= 2.0) tmp = x; else tmp = 2.0; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[x, -1.0], -1.0, If[LessEqual[x, 2.0], x, 2.0]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1:\\
\;\;\;\;-1\\
\mathbf{elif}\;x \leq 2:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;2\\
\end{array}
\end{array}
if x < -1Initial program 100.0%
sub-neg100.0%
exp-prod100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in x around 0 100.0%
*-commutative100.0%
Simplified100.0%
Taylor expanded in x around inf 100.0%
if -1 < x < 2Initial program 9.2%
sub-neg9.2%
exp-prod9.2%
metadata-eval9.2%
Simplified9.2%
Taylor expanded in x around 0 98.0%
if 2 < x Initial program 100.0%
sub-neg100.0%
exp-prod100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in x around 0 5.5%
+-commutative5.5%
Simplified5.5%
flip-+5.2%
div-inv5.2%
metadata-eval5.2%
difference-of-sqr-15.2%
metadata-eval5.2%
sub-neg5.2%
associate--l+5.2%
metadata-eval5.2%
add-exp-log5.2%
+-commutative5.2%
log1p-udef5.2%
expm1-udef5.2%
expm1-log1p-u5.2%
associate--l+5.2%
metadata-eval5.2%
Applied egg-rr5.2%
Taylor expanded in x around 0 18.8%
*-commutative18.8%
Simplified18.8%
Taylor expanded in x around inf 18.7%
Final simplification78.0%
(FPCore (x y) :precision binary64 (if (<= x 1.1e-308) -1.0 2.0))
double code(double x, double y) {
double tmp;
if (x <= 1.1e-308) {
tmp = -1.0;
} else {
tmp = 2.0;
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (x <= 1.1d-308) then
tmp = -1.0d0
else
tmp = 2.0d0
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (x <= 1.1e-308) {
tmp = -1.0;
} else {
tmp = 2.0;
}
return tmp;
}
def code(x, y): tmp = 0 if x <= 1.1e-308: tmp = -1.0 else: tmp = 2.0 return tmp
function code(x, y) tmp = 0.0 if (x <= 1.1e-308) tmp = -1.0; else tmp = 2.0; end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (x <= 1.1e-308) tmp = -1.0; else tmp = 2.0; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[x, 1.1e-308], -1.0, 2.0]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 1.1 \cdot 10^{-308}:\\
\;\;\;\;-1\\
\mathbf{else}:\\
\;\;\;\;2\\
\end{array}
\end{array}
if x < 1.1000000000000001e-308Initial program 48.5%
sub-neg48.5%
exp-prod48.5%
metadata-eval48.5%
Simplified48.5%
Taylor expanded in x around 0 47.3%
*-commutative47.3%
Simplified47.3%
Taylor expanded in x around inf 46.2%
if 1.1000000000000001e-308 < x Initial program 61.2%
sub-neg61.2%
exp-prod61.2%
metadata-eval61.2%
Simplified61.2%
Taylor expanded in x around 0 6.5%
+-commutative6.5%
Simplified6.5%
flip-+6.3%
div-inv6.3%
metadata-eval6.3%
difference-of-sqr-16.3%
metadata-eval6.3%
sub-neg6.3%
associate--l+6.3%
metadata-eval6.3%
add-exp-log6.3%
+-commutative6.3%
log1p-udef6.3%
expm1-udef44.8%
expm1-log1p-u44.8%
associate--l+44.8%
metadata-eval44.8%
Applied egg-rr44.8%
Taylor expanded in x around 0 52.1%
*-commutative52.1%
Simplified52.1%
Taylor expanded in x around inf 13.2%
Final simplification31.4%
(FPCore (x y) :precision binary64 -1.0)
double code(double x, double y) {
return -1.0;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = -1.0d0
end function
public static double code(double x, double y) {
return -1.0;
}
def code(x, y): return -1.0
function code(x, y) return -1.0 end
function tmp = code(x, y) tmp = -1.0; end
code[x_, y_] := -1.0
\begin{array}{l}
\\
-1
\end{array}
Initial program 54.2%
sub-neg54.2%
exp-prod54.2%
metadata-eval54.2%
Simplified54.2%
Taylor expanded in x around 0 27.8%
*-commutative27.8%
Simplified27.8%
Taylor expanded in x around inf 26.3%
Final simplification26.3%
herbie shell --seed 2023320
(FPCore (x y)
:name "Logistic function from Lakshay Garg"
:precision binary64
(- (/ 2.0 (+ 1.0 (exp (* -2.0 x)))) 1.0))