
(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) -0.001) (* 2.0 (log (sqrt (exp (+ -1.0 (/ 2.0 (+ 1.0 (exp (* -2.0 x))))))))) (expm1 x)))
double code(double x, double y) {
double tmp;
if ((-2.0 * x) <= -0.001) {
tmp = 2.0 * log(sqrt(exp((-1.0 + (2.0 / (1.0 + exp((-2.0 * x))))))));
} else {
tmp = expm1(x);
}
return tmp;
}
public static double code(double x, double y) {
double tmp;
if ((-2.0 * x) <= -0.001) {
tmp = 2.0 * Math.log(Math.sqrt(Math.exp((-1.0 + (2.0 / (1.0 + Math.exp((-2.0 * x))))))));
} else {
tmp = Math.expm1(x);
}
return tmp;
}
def code(x, y): tmp = 0 if (-2.0 * x) <= -0.001: tmp = 2.0 * math.log(math.sqrt(math.exp((-1.0 + (2.0 / (1.0 + math.exp((-2.0 * x)))))))) else: tmp = math.expm1(x) return tmp
function code(x, y) tmp = 0.0 if (Float64(-2.0 * x) <= -0.001) tmp = Float64(2.0 * log(sqrt(exp(Float64(-1.0 + Float64(2.0 / Float64(1.0 + exp(Float64(-2.0 * x))))))))); else tmp = expm1(x); end return tmp end
code[x_, y_] := If[LessEqual[N[(-2.0 * x), $MachinePrecision], -0.001], N[(2.0 * N[Log[N[Sqrt[N[Exp[N[(-1.0 + N[(2.0 / N[(1.0 + N[Exp[N[(-2.0 * x), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(Exp[x] - 1), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;-2 \cdot x \leq -0.001:\\
\;\;\;\;2 \cdot \log \left(\sqrt{e^{-1 + \frac{2}{1 + e^{-2 \cdot x}}}}\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{expm1}\left(x\right)\\
\end{array}
\end{array}
if (*.f64 -2 x) < -1e-3Initial program 99.7%
add-log-exp99.7%
*-un-lft-identity99.7%
log-prod99.7%
metadata-eval99.7%
add-log-exp99.7%
add-exp-log99.7%
expm1-def99.7%
log-div99.7%
log1p-udef99.7%
exp-prod99.7%
Applied egg-rr99.7%
+-lft-identity99.7%
Simplified99.7%
add-log-exp99.7%
add-sqr-sqrt99.7%
log-prod99.8%
Applied egg-rr99.8%
count-299.8%
+-commutative99.8%
+-commutative99.8%
Simplified99.8%
Taylor expanded in x around inf 99.8%
if -1e-3 < (*.f64 -2 x) Initial program 42.9%
add-log-exp42.9%
*-un-lft-identity42.9%
log-prod42.9%
metadata-eval42.9%
add-log-exp42.9%
add-exp-log42.9%
expm1-def42.9%
log-div42.9%
log1p-udef42.9%
exp-prod42.9%
Applied egg-rr42.9%
+-lft-identity42.9%
Simplified42.9%
Taylor expanded in x around 0 99.3%
Final simplification99.4%
(FPCore (x y) :precision binary64 (if (<= (* -2.0 x) -0.001) (expm1 (- (log 2.0) (log1p (exp (* -2.0 x))))) (expm1 x)))
double code(double x, double y) {
double tmp;
if ((-2.0 * x) <= -0.001) {
tmp = expm1((log(2.0) - log1p(exp((-2.0 * x)))));
} else {
tmp = expm1(x);
}
return tmp;
}
public static double code(double x, double y) {
double tmp;
if ((-2.0 * x) <= -0.001) {
tmp = Math.expm1((Math.log(2.0) - Math.log1p(Math.exp((-2.0 * x)))));
} else {
tmp = Math.expm1(x);
}
return tmp;
}
def code(x, y): tmp = 0 if (-2.0 * x) <= -0.001: tmp = math.expm1((math.log(2.0) - math.log1p(math.exp((-2.0 * x))))) else: tmp = math.expm1(x) return tmp
function code(x, y) tmp = 0.0 if (Float64(-2.0 * x) <= -0.001) tmp = expm1(Float64(log(2.0) - log1p(exp(Float64(-2.0 * x))))); else tmp = expm1(x); end return tmp end
code[x_, y_] := If[LessEqual[N[(-2.0 * x), $MachinePrecision], -0.001], N[(Exp[N[(N[Log[2.0], $MachinePrecision] - N[Log[1 + N[Exp[N[(-2.0 * x), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]] - 1), $MachinePrecision], N[(Exp[x] - 1), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;-2 \cdot x \leq -0.001:\\
\;\;\;\;\mathsf{expm1}\left(\log 2 - \mathsf{log1p}\left(e^{-2 \cdot x}\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{expm1}\left(x\right)\\
\end{array}
\end{array}
if (*.f64 -2 x) < -1e-3Initial program 99.7%
add-log-exp99.7%
*-un-lft-identity99.7%
log-prod99.7%
metadata-eval99.7%
add-log-exp99.7%
add-exp-log99.7%
expm1-def99.7%
log-div99.7%
log1p-udef99.7%
exp-prod99.7%
Applied egg-rr99.7%
+-lft-identity99.7%
Simplified99.7%
Taylor expanded in x around inf 99.7%
if -1e-3 < (*.f64 -2 x) Initial program 42.9%
add-log-exp42.9%
*-un-lft-identity42.9%
log-prod42.9%
metadata-eval42.9%
add-log-exp42.9%
add-exp-log42.9%
expm1-def42.9%
log-div42.9%
log1p-udef42.9%
exp-prod42.9%
Applied egg-rr42.9%
+-lft-identity42.9%
Simplified42.9%
Taylor expanded in x around 0 99.3%
Final simplification99.4%
(FPCore (x y) :precision binary64 (if (<= (* -2.0 x) -0.001) (+ -1.0 (/ 2.0 (+ 1.0 (exp (* -2.0 x))))) (expm1 x)))
double code(double x, double y) {
double tmp;
if ((-2.0 * x) <= -0.001) {
tmp = -1.0 + (2.0 / (1.0 + exp((-2.0 * x))));
} else {
tmp = expm1(x);
}
return tmp;
}
public static double code(double x, double y) {
double tmp;
if ((-2.0 * x) <= -0.001) {
tmp = -1.0 + (2.0 / (1.0 + Math.exp((-2.0 * x))));
} else {
tmp = Math.expm1(x);
}
return tmp;
}
def code(x, y): tmp = 0 if (-2.0 * x) <= -0.001: tmp = -1.0 + (2.0 / (1.0 + math.exp((-2.0 * x)))) else: tmp = math.expm1(x) return tmp
function code(x, y) tmp = 0.0 if (Float64(-2.0 * x) <= -0.001) tmp = Float64(-1.0 + Float64(2.0 / Float64(1.0 + exp(Float64(-2.0 * x))))); else tmp = expm1(x); end return tmp end
code[x_, y_] := If[LessEqual[N[(-2.0 * x), $MachinePrecision], -0.001], N[(-1.0 + N[(2.0 / N[(1.0 + N[Exp[N[(-2.0 * x), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(Exp[x] - 1), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;-2 \cdot x \leq -0.001:\\
\;\;\;\;-1 + \frac{2}{1 + e^{-2 \cdot x}}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{expm1}\left(x\right)\\
\end{array}
\end{array}
if (*.f64 -2 x) < -1e-3Initial program 99.7%
if -1e-3 < (*.f64 -2 x) Initial program 42.9%
add-log-exp42.9%
*-un-lft-identity42.9%
log-prod42.9%
metadata-eval42.9%
add-log-exp42.9%
add-exp-log42.9%
expm1-def42.9%
log-div42.9%
log1p-udef42.9%
exp-prod42.9%
Applied egg-rr42.9%
+-lft-identity42.9%
Simplified42.9%
Taylor expanded in x around 0 99.3%
Final simplification99.4%
(FPCore (x y) :precision binary64 (if (<= x -4e-14) (expm1 x) (* x (/ 2.0 (+ x 2.0)))))
double code(double x, double y) {
double tmp;
if (x <= -4e-14) {
tmp = expm1(x);
} else {
tmp = x * (2.0 / (x + 2.0));
}
return tmp;
}
public static double code(double x, double y) {
double tmp;
if (x <= -4e-14) {
tmp = Math.expm1(x);
} else {
tmp = x * (2.0 / (x + 2.0));
}
return tmp;
}
def code(x, y): tmp = 0 if x <= -4e-14: tmp = math.expm1(x) else: tmp = x * (2.0 / (x + 2.0)) return tmp
function code(x, y) tmp = 0.0 if (x <= -4e-14) tmp = expm1(x); else tmp = Float64(x * Float64(2.0 / Float64(x + 2.0))); end return tmp end
code[x_, y_] := If[LessEqual[x, -4e-14], N[(Exp[x] - 1), $MachinePrecision], N[(x * N[(2.0 / N[(x + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -4 \cdot 10^{-14}:\\
\;\;\;\;\mathsf{expm1}\left(x\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \frac{2}{x + 2}\\
\end{array}
\end{array}
if x < -4e-14Initial program 98.4%
add-log-exp98.4%
*-un-lft-identity98.4%
log-prod98.4%
metadata-eval98.4%
add-log-exp98.4%
add-exp-log98.4%
expm1-def98.4%
log-div98.4%
log1p-udef98.5%
exp-prod98.5%
Applied egg-rr98.5%
+-lft-identity98.5%
Simplified98.5%
Taylor expanded in x around 0 98.4%
if -4e-14 < x Initial program 41.8%
Taylor expanded in x around 0 6.6%
+-commutative6.6%
Simplified6.6%
flip--6.5%
clear-num6.5%
associate-+l+6.5%
metadata-eval6.5%
metadata-eval6.5%
difference-of-sqr-16.5%
associate-+l+6.5%
metadata-eval6.5%
associate--l+64.4%
metadata-eval64.4%
+-rgt-identity64.4%
Applied egg-rr64.4%
Taylor expanded in x around 0 69.1%
*-commutative69.1%
Simplified69.1%
expm1-log1p-u69.1%
expm1-udef11.3%
associate-/r/11.3%
+-commutative11.3%
*-commutative11.3%
Applied egg-rr11.3%
expm1-def69.3%
expm1-log1p69.3%
associate-*r*69.3%
*-commutative69.3%
associate-*l/69.3%
metadata-eval69.3%
+-commutative69.3%
Simplified69.3%
Final simplification77.7%
(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%
Taylor expanded in x around 0 98.7%
*-commutative98.7%
Simplified98.7%
Taylor expanded in x around inf 100.0%
if -1 < x < 2.5Initial program 9.3%
Taylor expanded in x around 0 98.5%
if 2.5 < x Initial program 100.0%
Taylor expanded in x around 0 5.8%
+-commutative5.8%
Simplified5.8%
flip--5.5%
clear-num5.5%
associate-+l+5.5%
metadata-eval5.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%
Applied egg-rr5.5%
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 simplification78.0%
(FPCore (x y) :precision binary64 (if (<= x -0.68) -1.0 (* x (/ 2.0 (+ x 2.0)))))
double code(double x, double y) {
double tmp;
if (x <= -0.68) {
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.68d0)) 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.68) {
tmp = -1.0;
} else {
tmp = x * (2.0 / (x + 2.0));
}
return tmp;
}
def code(x, y): tmp = 0 if x <= -0.68: tmp = -1.0 else: tmp = x * (2.0 / (x + 2.0)) return tmp
function code(x, y) tmp = 0.0 if (x <= -0.68) 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.68) tmp = -1.0; else tmp = x * (2.0 / (x + 2.0)); end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[x, -0.68], -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.68:\\
\;\;\;\;-1\\
\mathbf{else}:\\
\;\;\;\;x \cdot \frac{2}{x + 2}\\
\end{array}
\end{array}
if x < -0.680000000000000049Initial program 100.0%
Taylor expanded in x around 0 98.7%
*-commutative98.7%
Simplified98.7%
Taylor expanded in x around inf 100.0%
if -0.680000000000000049 < x Initial program 42.1%
Taylor expanded in x around 0 7.2%
+-commutative7.2%
Simplified7.2%
flip--7.1%
clear-num7.1%
associate-+l+7.1%
metadata-eval7.1%
metadata-eval7.1%
difference-of-sqr-17.1%
associate-+l+7.1%
metadata-eval7.1%
associate--l+64.6%
metadata-eval64.6%
+-rgt-identity64.6%
Applied egg-rr64.6%
Taylor expanded in x around 0 68.9%
*-commutative68.9%
Simplified68.9%
expm1-log1p-u68.9%
expm1-udef11.8%
associate-/r/11.8%
+-commutative11.8%
*-commutative11.8%
Applied egg-rr11.8%
expm1-def69.1%
expm1-log1p69.1%
associate-*r*69.1%
*-commutative69.1%
associate-*l/69.1%
metadata-eval69.1%
+-commutative69.1%
Simplified69.1%
Final simplification77.7%
(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%
Taylor expanded in x around 0 98.7%
*-commutative98.7%
Simplified98.7%
Taylor expanded in x around inf 100.0%
if -1 < x < 2Initial program 9.3%
Taylor expanded in x around 0 98.5%
if 2 < x Initial program 100.0%
Taylor expanded in x around 0 5.8%
+-commutative5.8%
Simplified5.8%
flip--5.5%
clear-num5.5%
associate-+l+5.5%
metadata-eval5.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%
Applied egg-rr5.5%
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 60.2%
Taylor expanded in x around 0 58.9%
*-commutative58.9%
Simplified58.9%
Taylor expanded in x around inf 58.2%
if 1.1000000000000001e-308 < x Initial program 56.2%
Taylor expanded in x around 0 6.5%
+-commutative6.5%
Simplified6.5%
flip--6.4%
clear-num6.4%
associate-+l+6.4%
metadata-eval6.4%
metadata-eval6.4%
difference-of-sqr-16.4%
associate-+l+6.4%
metadata-eval6.4%
associate--l+49.9%
metadata-eval49.9%
+-rgt-identity49.9%
Applied egg-rr49.9%
Taylor expanded in x around 0 56.6%
*-commutative56.6%
Simplified56.6%
Taylor expanded in x around inf 12.3%
Final simplification35.1%
(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 58.2%
Taylor expanded in x around 0 31.3%
*-commutative31.3%
Simplified31.3%
Taylor expanded in x around inf 29.9%
Final simplification29.9%
herbie shell --seed 2023187
(FPCore (x y)
:name "Logistic function from Lakshay Garg"
:precision binary64
(- (/ 2.0 (+ 1.0 (exp (* -2.0 x)))) 1.0))