
(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 9 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 (if (<= (* -2.0 x) -2.0) (+ (/ (* 2.0 (expm1 (* -2.0 x))) (expm1 (* x -4.0))) -1.0) (if (<= (* -2.0 x) 1e-8) (+ x (* -0.3333333333333333 (pow x 3.0))) -1.0)))
double code(double x, double y) {
double tmp;
if ((-2.0 * x) <= -2.0) {
tmp = ((2.0 * expm1((-2.0 * x))) / expm1((x * -4.0))) + -1.0;
} else if ((-2.0 * x) <= 1e-8) {
tmp = x + (-0.3333333333333333 * pow(x, 3.0));
} else {
tmp = -1.0;
}
return tmp;
}
public static double code(double x, double y) {
double tmp;
if ((-2.0 * x) <= -2.0) {
tmp = ((2.0 * Math.expm1((-2.0 * x))) / Math.expm1((x * -4.0))) + -1.0;
} else if ((-2.0 * x) <= 1e-8) {
tmp = x + (-0.3333333333333333 * Math.pow(x, 3.0));
} else {
tmp = -1.0;
}
return tmp;
}
def code(x, y): tmp = 0 if (-2.0 * x) <= -2.0: tmp = ((2.0 * math.expm1((-2.0 * x))) / math.expm1((x * -4.0))) + -1.0 elif (-2.0 * x) <= 1e-8: tmp = x + (-0.3333333333333333 * math.pow(x, 3.0)) else: tmp = -1.0 return tmp
function code(x, y) tmp = 0.0 if (Float64(-2.0 * x) <= -2.0) tmp = Float64(Float64(Float64(2.0 * expm1(Float64(-2.0 * x))) / expm1(Float64(x * -4.0))) + -1.0); elseif (Float64(-2.0 * x) <= 1e-8) tmp = Float64(x + Float64(-0.3333333333333333 * (x ^ 3.0))); else tmp = -1.0; end return tmp end
code[x_, y_] := If[LessEqual[N[(-2.0 * x), $MachinePrecision], -2.0], N[(N[(N[(2.0 * N[(Exp[N[(-2.0 * x), $MachinePrecision]] - 1), $MachinePrecision]), $MachinePrecision] / N[(Exp[N[(x * -4.0), $MachinePrecision]] - 1), $MachinePrecision]), $MachinePrecision] + -1.0), $MachinePrecision], If[LessEqual[N[(-2.0 * x), $MachinePrecision], 1e-8], N[(x + N[(-0.3333333333333333 * N[Power[x, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], -1.0]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;-2 \cdot x \leq -2:\\
\;\;\;\;\frac{2 \cdot \mathsf{expm1}\left(-2 \cdot x\right)}{\mathsf{expm1}\left(x \cdot -4\right)} + -1\\
\mathbf{elif}\;-2 \cdot x \leq 10^{-8}:\\
\;\;\;\;x + -0.3333333333333333 \cdot {x}^{3}\\
\mathbf{else}:\\
\;\;\;\;-1\\
\end{array}
\end{array}
if (*.f64 -2 x) < -2Initial program 99.9%
sub-neg99.9%
*-commutative99.9%
exp-prod99.9%
metadata-eval99.9%
Simplified99.9%
+-commutative99.9%
flip-+99.9%
pow-exp99.9%
*-commutative99.9%
expm1-udef99.9%
associate-/r/100.0%
pow-sqr100.0%
metadata-eval100.0%
metadata-eval100.0%
*-commutative100.0%
Applied egg-rr100.0%
associate-*l/100.0%
pow-exp100.0%
*-commutative100.0%
metadata-eval100.0%
associate-*r*100.0%
*-commutative100.0%
expm1-def100.0%
*-commutative100.0%
associate-*r*100.0%
metadata-eval100.0%
*-commutative100.0%
Applied egg-rr100.0%
if -2 < (*.f64 -2 x) < 1e-8Initial program 10.2%
sub-neg10.2%
*-commutative10.2%
exp-prod10.1%
metadata-eval10.1%
Simplified10.1%
Taylor expanded in x around 0 100.0%
if 1e-8 < (*.f64 -2 x) Initial program 100.0%
sub-neg100.0%
*-commutative100.0%
exp-prod100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in x around 0 98.6%
*-commutative98.6%
Simplified98.6%
Taylor expanded in x around inf 100.0%
Final simplification100.0%
(FPCore (x y) :precision binary64 (if (<= (* -2.0 x) -2.0) (+ -1.0 (/ 2.0 (+ 1.0 (exp (* -2.0 x))))) (if (<= (* -2.0 x) 1e-8) (+ x (* -0.3333333333333333 (pow x 3.0))) -1.0)))
double code(double x, double y) {
double tmp;
if ((-2.0 * x) <= -2.0) {
tmp = -1.0 + (2.0 / (1.0 + exp((-2.0 * x))));
} else if ((-2.0 * x) <= 1e-8) {
tmp = x + (-0.3333333333333333 * pow(x, 3.0));
} else {
tmp = -1.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) <= (-2.0d0)) then
tmp = (-1.0d0) + (2.0d0 / (1.0d0 + exp(((-2.0d0) * x))))
else if (((-2.0d0) * x) <= 1d-8) then
tmp = x + ((-0.3333333333333333d0) * (x ** 3.0d0))
else
tmp = -1.0d0
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if ((-2.0 * x) <= -2.0) {
tmp = -1.0 + (2.0 / (1.0 + Math.exp((-2.0 * x))));
} else if ((-2.0 * x) <= 1e-8) {
tmp = x + (-0.3333333333333333 * Math.pow(x, 3.0));
} else {
tmp = -1.0;
}
return tmp;
}
def code(x, y): tmp = 0 if (-2.0 * x) <= -2.0: tmp = -1.0 + (2.0 / (1.0 + math.exp((-2.0 * x)))) elif (-2.0 * x) <= 1e-8: tmp = x + (-0.3333333333333333 * math.pow(x, 3.0)) else: tmp = -1.0 return tmp
function code(x, y) tmp = 0.0 if (Float64(-2.0 * x) <= -2.0) tmp = Float64(-1.0 + Float64(2.0 / Float64(1.0 + exp(Float64(-2.0 * x))))); elseif (Float64(-2.0 * x) <= 1e-8) tmp = Float64(x + Float64(-0.3333333333333333 * (x ^ 3.0))); else tmp = -1.0; end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if ((-2.0 * x) <= -2.0) tmp = -1.0 + (2.0 / (1.0 + exp((-2.0 * x)))); elseif ((-2.0 * x) <= 1e-8) tmp = x + (-0.3333333333333333 * (x ^ 3.0)); else tmp = -1.0; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[N[(-2.0 * x), $MachinePrecision], -2.0], N[(-1.0 + N[(2.0 / N[(1.0 + N[Exp[N[(-2.0 * x), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(-2.0 * x), $MachinePrecision], 1e-8], N[(x + N[(-0.3333333333333333 * N[Power[x, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], -1.0]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;-2 \cdot x \leq -2:\\
\;\;\;\;-1 + \frac{2}{1 + e^{-2 \cdot x}}\\
\mathbf{elif}\;-2 \cdot x \leq 10^{-8}:\\
\;\;\;\;x + -0.3333333333333333 \cdot {x}^{3}\\
\mathbf{else}:\\
\;\;\;\;-1\\
\end{array}
\end{array}
if (*.f64 -2 x) < -2Initial program 99.9%
if -2 < (*.f64 -2 x) < 1e-8Initial program 10.2%
sub-neg10.2%
*-commutative10.2%
exp-prod10.1%
metadata-eval10.1%
Simplified10.1%
Taylor expanded in x around 0 100.0%
if 1e-8 < (*.f64 -2 x) Initial program 100.0%
sub-neg100.0%
*-commutative100.0%
exp-prod100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in x around 0 98.6%
*-commutative98.6%
Simplified98.6%
Taylor expanded in x around inf 100.0%
Final simplification100.0%
(FPCore (x y)
:precision binary64
(if (<= x -1.15)
-1.0
(if (<= x 1.0)
(+ x (* -0.3333333333333333 (pow x 3.0)))
(* x (/ 2.0 (+ x 2.0))))))
double code(double x, double y) {
double tmp;
if (x <= -1.15) {
tmp = -1.0;
} else if (x <= 1.0) {
tmp = x + (-0.3333333333333333 * pow(x, 3.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 <= (-1.15d0)) then
tmp = -1.0d0
else if (x <= 1.0d0) then
tmp = x + ((-0.3333333333333333d0) * (x ** 3.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 <= -1.15) {
tmp = -1.0;
} else if (x <= 1.0) {
tmp = x + (-0.3333333333333333 * Math.pow(x, 3.0));
} else {
tmp = x * (2.0 / (x + 2.0));
}
return tmp;
}
def code(x, y): tmp = 0 if x <= -1.15: tmp = -1.0 elif x <= 1.0: tmp = x + (-0.3333333333333333 * math.pow(x, 3.0)) else: tmp = x * (2.0 / (x + 2.0)) return tmp
function code(x, y) tmp = 0.0 if (x <= -1.15) tmp = -1.0; elseif (x <= 1.0) tmp = Float64(x + Float64(-0.3333333333333333 * (x ^ 3.0))); else tmp = Float64(x * Float64(2.0 / Float64(x + 2.0))); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (x <= -1.15) tmp = -1.0; elseif (x <= 1.0) tmp = x + (-0.3333333333333333 * (x ^ 3.0)); else tmp = x * (2.0 / (x + 2.0)); end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[x, -1.15], -1.0, If[LessEqual[x, 1.0], N[(x + N[(-0.3333333333333333 * N[Power[x, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x * N[(2.0 / N[(x + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.15:\\
\;\;\;\;-1\\
\mathbf{elif}\;x \leq 1:\\
\;\;\;\;x + -0.3333333333333333 \cdot {x}^{3}\\
\mathbf{else}:\\
\;\;\;\;x \cdot \frac{2}{x + 2}\\
\end{array}
\end{array}
if x < -1.1499999999999999Initial program 100.0%
sub-neg100.0%
*-commutative100.0%
exp-prod100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in x around 0 98.6%
*-commutative98.6%
Simplified98.6%
Taylor expanded in x around inf 100.0%
if -1.1499999999999999 < x < 1Initial program 10.2%
sub-neg10.2%
*-commutative10.2%
exp-prod10.1%
metadata-eval10.1%
Simplified10.1%
Taylor expanded in x around 0 100.0%
if 1 < x Initial program 99.9%
sub-neg99.9%
*-commutative99.9%
exp-prod99.9%
metadata-eval99.9%
Simplified99.9%
Taylor expanded in x around 0 5.9%
+-commutative5.9%
Simplified5.9%
flip-+5.5%
metadata-eval5.5%
difference-of-sqr-15.5%
associate-+l+5.5%
metadata-eval5.5%
associate--l+5.5%
metadata-eval5.5%
+-rgt-identity5.5%
associate--l+5.5%
metadata-eval5.5%
Applied egg-rr5.5%
Taylor expanded in x around 0 18.8%
*-commutative18.8%
Simplified18.8%
+-commutative18.8%
*-un-lft-identity18.8%
times-frac18.8%
/-rgt-identity18.8%
+-commutative18.8%
Applied egg-rr18.8%
Final simplification77.8%
(FPCore (x y) :precision binary64 (if (<= x -1.0) -1.0 (if (<= x 2.5) x (- 2.0 (/ 4.0 x)))))
double code(double x, double y) {
double tmp;
if (x <= -1.0) {
tmp = -1.0;
} else if (x <= 2.5) {
tmp = x;
} else {
tmp = 2.0 - (4.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 <= (-1.0d0)) then
tmp = -1.0d0
else if (x <= 2.5d0) then
tmp = x
else
tmp = 2.0d0 - (4.0d0 / x)
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.5) {
tmp = x;
} else {
tmp = 2.0 - (4.0 / x);
}
return tmp;
}
def code(x, y): tmp = 0 if x <= -1.0: tmp = -1.0 elif x <= 2.5: tmp = x else: tmp = 2.0 - (4.0 / x) return tmp
function code(x, y) tmp = 0.0 if (x <= -1.0) tmp = -1.0; elseif (x <= 2.5) tmp = x; else tmp = Float64(2.0 - Float64(4.0 / x)); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (x <= -1.0) tmp = -1.0; elseif (x <= 2.5) tmp = x; else tmp = 2.0 - (4.0 / x); end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[x, -1.0], -1.0, If[LessEqual[x, 2.5], x, N[(2.0 - N[(4.0 / x), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1:\\
\;\;\;\;-1\\
\mathbf{elif}\;x \leq 2.5:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;2 - \frac{4}{x}\\
\end{array}
\end{array}
if x < -1Initial program 100.0%
sub-neg100.0%
*-commutative100.0%
exp-prod100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in x around 0 98.6%
*-commutative98.6%
Simplified98.6%
Taylor expanded in x around inf 100.0%
if -1 < x < 2.5Initial program 10.9%
sub-neg10.9%
*-commutative10.9%
exp-prod10.8%
metadata-eval10.8%
Simplified10.8%
Taylor expanded in x around 0 98.4%
if 2.5 < x Initial program 100.0%
sub-neg100.0%
*-commutative100.0%
exp-prod100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in x around 0 5.7%
+-commutative5.7%
Simplified5.7%
flip-+5.3%
metadata-eval5.3%
difference-of-sqr-15.3%
associate-+l+5.3%
metadata-eval5.3%
associate--l+5.3%
metadata-eval5.3%
+-rgt-identity5.3%
associate--l+5.3%
metadata-eval5.3%
Applied egg-rr5.3%
Taylor expanded in x around 0 18.8%
*-commutative18.8%
Simplified18.8%
Taylor expanded in x around inf 18.8%
associate-*r/18.8%
metadata-eval18.8%
Simplified18.8%
Final simplification77.3%
(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(x * Float64(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[(x * N[(2.0 / N[(x + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -0.66:\\
\;\;\;\;-1\\
\mathbf{else}:\\
\;\;\;\;x \cdot \frac{2}{x + 2}\\
\end{array}
\end{array}
if x < -0.660000000000000031Initial program 100.0%
sub-neg100.0%
*-commutative100.0%
exp-prod100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in x around 0 98.6%
*-commutative98.6%
Simplified98.6%
Taylor expanded in x around inf 100.0%
if -0.660000000000000031 < x Initial program 42.7%
sub-neg42.7%
*-commutative42.7%
exp-prod42.7%
metadata-eval42.7%
Simplified42.7%
Taylor expanded in x around 0 8.4%
+-commutative8.4%
Simplified8.4%
flip-+8.3%
metadata-eval8.3%
difference-of-sqr-18.3%
associate-+l+8.3%
metadata-eval8.3%
associate--l+65.1%
metadata-eval65.1%
+-rgt-identity65.1%
associate--l+65.1%
metadata-eval65.1%
Applied egg-rr65.1%
Taylor expanded in x around 0 68.4%
*-commutative68.4%
Simplified68.4%
+-commutative68.4%
*-un-lft-identity68.4%
times-frac68.4%
/-rgt-identity68.4%
+-commutative68.4%
Applied egg-rr68.4%
Final simplification76.2%
(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%
*-commutative100.0%
exp-prod100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in x around 0 98.6%
*-commutative98.6%
Simplified98.6%
Taylor expanded in x around inf 100.0%
if -0.660000000000000031 < x Initial program 42.7%
sub-neg42.7%
*-commutative42.7%
exp-prod42.7%
metadata-eval42.7%
Simplified42.7%
Taylor expanded in x around 0 8.4%
+-commutative8.4%
Simplified8.4%
flip-+8.3%
metadata-eval8.3%
difference-of-sqr-18.3%
associate-+l+8.3%
metadata-eval8.3%
associate--l+65.1%
metadata-eval65.1%
+-rgt-identity65.1%
associate--l+65.1%
metadata-eval65.1%
Applied egg-rr65.1%
Taylor expanded in x around 0 68.4%
*-commutative68.4%
Simplified68.4%
Final simplification76.2%
(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%
*-commutative100.0%
exp-prod100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in x around 0 98.6%
*-commutative98.6%
Simplified98.6%
Taylor expanded in x around inf 100.0%
if -1 < x < 2Initial program 10.9%
sub-neg10.9%
*-commutative10.9%
exp-prod10.8%
metadata-eval10.8%
Simplified10.8%
Taylor expanded in x around 0 98.4%
if 2 < x Initial program 100.0%
sub-neg100.0%
*-commutative100.0%
exp-prod100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in x around 0 5.7%
+-commutative5.7%
Simplified5.7%
flip-+5.3%
metadata-eval5.3%
difference-of-sqr-15.3%
associate-+l+5.3%
metadata-eval5.3%
associate--l+5.3%
metadata-eval5.3%
+-rgt-identity5.3%
associate--l+5.3%
metadata-eval5.3%
Applied egg-rr5.3%
Taylor expanded in x around 0 18.8%
*-commutative18.8%
Simplified18.8%
Taylor expanded in x around inf 18.7%
Final simplification77.3%
(FPCore (x y) :precision binary64 (if (<= x 1.2e-308) -1.0 2.0))
double code(double x, double y) {
double tmp;
if (x <= 1.2e-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.2d-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.2e-308) {
tmp = -1.0;
} else {
tmp = 2.0;
}
return tmp;
}
def code(x, y): tmp = 0 if x <= 1.2e-308: tmp = -1.0 else: tmp = 2.0 return tmp
function code(x, y) tmp = 0.0 if (x <= 1.2e-308) tmp = -1.0; else tmp = 2.0; end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (x <= 1.2e-308) tmp = -1.0; else tmp = 2.0; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[x, 1.2e-308], -1.0, 2.0]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 1.2 \cdot 10^{-308}:\\
\;\;\;\;-1\\
\mathbf{else}:\\
\;\;\;\;2\\
\end{array}
\end{array}
if x < 1.1999999999999998e-308Initial program 55.4%
sub-neg55.4%
*-commutative55.4%
exp-prod55.4%
metadata-eval55.4%
Simplified55.4%
Taylor expanded in x around 0 54.7%
*-commutative54.7%
Simplified54.7%
Taylor expanded in x around inf 54.3%
if 1.1999999999999998e-308 < x Initial program 58.1%
sub-neg58.1%
*-commutative58.1%
exp-prod58.1%
metadata-eval58.1%
Simplified58.1%
Taylor expanded in x around 0 8.6%
+-commutative8.6%
Simplified8.6%
flip-+8.4%
metadata-eval8.4%
difference-of-sqr-18.4%
associate-+l+8.4%
metadata-eval8.4%
associate--l+49.7%
metadata-eval49.7%
+-rgt-identity49.7%
associate--l+49.7%
metadata-eval49.7%
Applied egg-rr49.7%
Taylor expanded in x around 0 55.2%
*-commutative55.2%
Simplified55.2%
Taylor expanded in x around inf 12.7%
Final simplification32.5%
(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 56.8%
sub-neg56.8%
*-commutative56.8%
exp-prod56.8%
metadata-eval56.8%
Simplified56.8%
Taylor expanded in x around 0 29.0%
*-commutative29.0%
Simplified29.0%
Taylor expanded in x around inf 26.8%
Final simplification26.8%
herbie shell --seed 2023336
(FPCore (x y)
:name "Logistic function from Lakshay Garg"
:precision binary64
(- (/ 2.0 (+ 1.0 (exp (* -2.0 x)))) 1.0))