
(FPCore (x) :precision binary64 (let* ((t_0 (exp (- x)))) (/ (- (exp x) t_0) (+ (exp x) t_0))))
double code(double x) {
double t_0 = exp(-x);
return (exp(x) - t_0) / (exp(x) + t_0);
}
real(8) function code(x)
real(8), intent (in) :: x
real(8) :: t_0
t_0 = exp(-x)
code = (exp(x) - t_0) / (exp(x) + t_0)
end function
public static double code(double x) {
double t_0 = Math.exp(-x);
return (Math.exp(x) - t_0) / (Math.exp(x) + t_0);
}
def code(x): t_0 = math.exp(-x) return (math.exp(x) - t_0) / (math.exp(x) + t_0)
function code(x) t_0 = exp(Float64(-x)) return Float64(Float64(exp(x) - t_0) / Float64(exp(x) + t_0)) end
function tmp = code(x) t_0 = exp(-x); tmp = (exp(x) - t_0) / (exp(x) + t_0); end
code[x_] := Block[{t$95$0 = N[Exp[(-x)], $MachinePrecision]}, N[(N[(N[Exp[x], $MachinePrecision] - t$95$0), $MachinePrecision] / N[(N[Exp[x], $MachinePrecision] + t$95$0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := e^{-x}\\
\frac{e^{x} - t_0}{e^{x} + t_0}
\end{array}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 5 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x) :precision binary64 (let* ((t_0 (exp (- x)))) (/ (- (exp x) t_0) (+ (exp x) t_0))))
double code(double x) {
double t_0 = exp(-x);
return (exp(x) - t_0) / (exp(x) + t_0);
}
real(8) function code(x)
real(8), intent (in) :: x
real(8) :: t_0
t_0 = exp(-x)
code = (exp(x) - t_0) / (exp(x) + t_0)
end function
public static double code(double x) {
double t_0 = Math.exp(-x);
return (Math.exp(x) - t_0) / (Math.exp(x) + t_0);
}
def code(x): t_0 = math.exp(-x) return (math.exp(x) - t_0) / (math.exp(x) + t_0)
function code(x) t_0 = exp(Float64(-x)) return Float64(Float64(exp(x) - t_0) / Float64(exp(x) + t_0)) end
function tmp = code(x) t_0 = exp(-x); tmp = (exp(x) - t_0) / (exp(x) + t_0); end
code[x_] := Block[{t$95$0 = N[Exp[(-x)], $MachinePrecision]}, N[(N[(N[Exp[x], $MachinePrecision] - t$95$0), $MachinePrecision] / N[(N[Exp[x], $MachinePrecision] + t$95$0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := e^{-x}\\
\frac{e^{x} - t_0}{e^{x} + t_0}
\end{array}
\end{array}
(FPCore (x)
:precision binary64
(if (<= x -1.5)
(+ (exp (+ x (* (pow x 2.0) -0.5))) -1.0)
(/
(+ (* 0.3333333333333333 (pow x 3.0)) (* x 2.0))
(+ 2.0 (+ (pow x 2.0) (* 0.08333333333333333 (pow x 4.0)))))))
double code(double x) {
double tmp;
if (x <= -1.5) {
tmp = exp((x + (pow(x, 2.0) * -0.5))) + -1.0;
} else {
tmp = ((0.3333333333333333 * pow(x, 3.0)) + (x * 2.0)) / (2.0 + (pow(x, 2.0) + (0.08333333333333333 * pow(x, 4.0))));
}
return tmp;
}
real(8) function code(x)
real(8), intent (in) :: x
real(8) :: tmp
if (x <= (-1.5d0)) then
tmp = exp((x + ((x ** 2.0d0) * (-0.5d0)))) + (-1.0d0)
else
tmp = ((0.3333333333333333d0 * (x ** 3.0d0)) + (x * 2.0d0)) / (2.0d0 + ((x ** 2.0d0) + (0.08333333333333333d0 * (x ** 4.0d0))))
end if
code = tmp
end function
public static double code(double x) {
double tmp;
if (x <= -1.5) {
tmp = Math.exp((x + (Math.pow(x, 2.0) * -0.5))) + -1.0;
} else {
tmp = ((0.3333333333333333 * Math.pow(x, 3.0)) + (x * 2.0)) / (2.0 + (Math.pow(x, 2.0) + (0.08333333333333333 * Math.pow(x, 4.0))));
}
return tmp;
}
def code(x): tmp = 0 if x <= -1.5: tmp = math.exp((x + (math.pow(x, 2.0) * -0.5))) + -1.0 else: tmp = ((0.3333333333333333 * math.pow(x, 3.0)) + (x * 2.0)) / (2.0 + (math.pow(x, 2.0) + (0.08333333333333333 * math.pow(x, 4.0)))) return tmp
function code(x) tmp = 0.0 if (x <= -1.5) tmp = Float64(exp(Float64(x + Float64((x ^ 2.0) * -0.5))) + -1.0); else tmp = Float64(Float64(Float64(0.3333333333333333 * (x ^ 3.0)) + Float64(x * 2.0)) / Float64(2.0 + Float64((x ^ 2.0) + Float64(0.08333333333333333 * (x ^ 4.0))))); end return tmp end
function tmp_2 = code(x) tmp = 0.0; if (x <= -1.5) tmp = exp((x + ((x ^ 2.0) * -0.5))) + -1.0; else tmp = ((0.3333333333333333 * (x ^ 3.0)) + (x * 2.0)) / (2.0 + ((x ^ 2.0) + (0.08333333333333333 * (x ^ 4.0)))); end tmp_2 = tmp; end
code[x_] := If[LessEqual[x, -1.5], N[(N[Exp[N[(x + N[(N[Power[x, 2.0], $MachinePrecision] * -0.5), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + -1.0), $MachinePrecision], N[(N[(N[(0.3333333333333333 * N[Power[x, 3.0], $MachinePrecision]), $MachinePrecision] + N[(x * 2.0), $MachinePrecision]), $MachinePrecision] / N[(2.0 + N[(N[Power[x, 2.0], $MachinePrecision] + N[(0.08333333333333333 * N[Power[x, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.5:\\
\;\;\;\;e^{x + {x}^{2} \cdot -0.5} + -1\\
\mathbf{else}:\\
\;\;\;\;\frac{0.3333333333333333 \cdot {x}^{3} + x \cdot 2}{2 + \left({x}^{2} + 0.08333333333333333 \cdot {x}^{4}\right)}\\
\end{array}
\end{array}
if x < -1.5Initial program 16.4%
Taylor expanded in x around 0 5.6%
Taylor expanded in x around 0 13.7%
+-commutative13.7%
associate-+l+13.7%
+-commutative13.7%
fma-def13.7%
+-commutative13.7%
unpow213.7%
fma-def13.7%
Simplified13.7%
expm1-log1p-u13.7%
expm1-udef13.7%
fma-def13.7%
*-commutative13.7%
Applied egg-rr13.7%
Taylor expanded in x around 0 89.5%
*-commutative89.5%
Simplified89.5%
if -1.5 < x Initial program 8.5%
Taylor expanded in x around 0 98.8%
Taylor expanded in x around 0 99.0%
Final simplification98.7%
(FPCore (x) :precision binary64 (if (<= x -0.98) (+ (exp (+ x (* (pow x 2.0) -0.5))) -1.0) (/ (+ (* 0.3333333333333333 (pow x 3.0)) (* x 2.0)) (fma x x 2.0))))
double code(double x) {
double tmp;
if (x <= -0.98) {
tmp = exp((x + (pow(x, 2.0) * -0.5))) + -1.0;
} else {
tmp = ((0.3333333333333333 * pow(x, 3.0)) + (x * 2.0)) / fma(x, x, 2.0);
}
return tmp;
}
function code(x) tmp = 0.0 if (x <= -0.98) tmp = Float64(exp(Float64(x + Float64((x ^ 2.0) * -0.5))) + -1.0); else tmp = Float64(Float64(Float64(0.3333333333333333 * (x ^ 3.0)) + Float64(x * 2.0)) / fma(x, x, 2.0)); end return tmp end
code[x_] := If[LessEqual[x, -0.98], N[(N[Exp[N[(x + N[(N[Power[x, 2.0], $MachinePrecision] * -0.5), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + -1.0), $MachinePrecision], N[(N[(N[(0.3333333333333333 * N[Power[x, 3.0], $MachinePrecision]), $MachinePrecision] + N[(x * 2.0), $MachinePrecision]), $MachinePrecision] / N[(x * x + 2.0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -0.98:\\
\;\;\;\;e^{x + {x}^{2} \cdot -0.5} + -1\\
\mathbf{else}:\\
\;\;\;\;\frac{0.3333333333333333 \cdot {x}^{3} + x \cdot 2}{\mathsf{fma}\left(x, x, 2\right)}\\
\end{array}
\end{array}
if x < -0.97999999999999998Initial program 16.4%
Taylor expanded in x around 0 5.6%
Taylor expanded in x around 0 13.7%
+-commutative13.7%
associate-+l+13.7%
+-commutative13.7%
fma-def13.7%
+-commutative13.7%
unpow213.7%
fma-def13.7%
Simplified13.7%
expm1-log1p-u13.7%
expm1-udef13.7%
fma-def13.7%
*-commutative13.7%
Applied egg-rr13.7%
Taylor expanded in x around 0 89.5%
*-commutative89.5%
Simplified89.5%
if -0.97999999999999998 < x Initial program 8.5%
Taylor expanded in x around 0 98.8%
Taylor expanded in x around 0 99.0%
+-commutative7.7%
unpow27.7%
fma-def7.7%
Simplified99.0%
Final simplification98.7%
(FPCore (x) :precision binary64 (if (<= x -0.395) (+ (exp (+ x (* (pow x 2.0) -0.5))) -1.0) (+ x (* (pow x 3.0) -0.3333333333333333))))
double code(double x) {
double tmp;
if (x <= -0.395) {
tmp = exp((x + (pow(x, 2.0) * -0.5))) + -1.0;
} else {
tmp = x + (pow(x, 3.0) * -0.3333333333333333);
}
return tmp;
}
real(8) function code(x)
real(8), intent (in) :: x
real(8) :: tmp
if (x <= (-0.395d0)) then
tmp = exp((x + ((x ** 2.0d0) * (-0.5d0)))) + (-1.0d0)
else
tmp = x + ((x ** 3.0d0) * (-0.3333333333333333d0))
end if
code = tmp
end function
public static double code(double x) {
double tmp;
if (x <= -0.395) {
tmp = Math.exp((x + (Math.pow(x, 2.0) * -0.5))) + -1.0;
} else {
tmp = x + (Math.pow(x, 3.0) * -0.3333333333333333);
}
return tmp;
}
def code(x): tmp = 0 if x <= -0.395: tmp = math.exp((x + (math.pow(x, 2.0) * -0.5))) + -1.0 else: tmp = x + (math.pow(x, 3.0) * -0.3333333333333333) return tmp
function code(x) tmp = 0.0 if (x <= -0.395) tmp = Float64(exp(Float64(x + Float64((x ^ 2.0) * -0.5))) + -1.0); else tmp = Float64(x + Float64((x ^ 3.0) * -0.3333333333333333)); end return tmp end
function tmp_2 = code(x) tmp = 0.0; if (x <= -0.395) tmp = exp((x + ((x ^ 2.0) * -0.5))) + -1.0; else tmp = x + ((x ^ 3.0) * -0.3333333333333333); end tmp_2 = tmp; end
code[x_] := If[LessEqual[x, -0.395], N[(N[Exp[N[(x + N[(N[Power[x, 2.0], $MachinePrecision] * -0.5), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + -1.0), $MachinePrecision], N[(x + N[(N[Power[x, 3.0], $MachinePrecision] * -0.3333333333333333), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -0.395:\\
\;\;\;\;e^{x + {x}^{2} \cdot -0.5} + -1\\
\mathbf{else}:\\
\;\;\;\;x + {x}^{3} \cdot -0.3333333333333333\\
\end{array}
\end{array}
if x < -0.39500000000000002Initial program 16.4%
Taylor expanded in x around 0 5.6%
Taylor expanded in x around 0 13.7%
+-commutative13.7%
associate-+l+13.7%
+-commutative13.7%
fma-def13.7%
+-commutative13.7%
unpow213.7%
fma-def13.7%
Simplified13.7%
expm1-log1p-u13.7%
expm1-udef13.7%
fma-def13.7%
*-commutative13.7%
Applied egg-rr13.7%
Taylor expanded in x around 0 89.5%
*-commutative89.5%
Simplified89.5%
if -0.39500000000000002 < x Initial program 8.5%
Taylor expanded in x around 0 98.8%
*-commutative98.8%
Simplified98.8%
Final simplification98.6%
(FPCore (x) :precision binary64 (/ (* x 2.0) (fma x x 2.0)))
double code(double x) {
return (x * 2.0) / fma(x, x, 2.0);
}
function code(x) return Float64(Float64(x * 2.0) / fma(x, x, 2.0)) end
code[x_] := N[(N[(x * 2.0), $MachinePrecision] / N[(x * x + 2.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x \cdot 2}{\mathsf{fma}\left(x, x, 2\right)}
\end{array}
Initial program 8.7%
Taylor expanded in x around 0 7.7%
+-commutative7.7%
unpow27.7%
fma-def7.7%
Simplified7.7%
Taylor expanded in x around 0 96.7%
Final simplification96.7%
(FPCore (x) :precision binary64 x)
double code(double x) {
return x;
}
real(8) function code(x)
real(8), intent (in) :: x
code = x
end function
public static double code(double x) {
return x;
}
def code(x): return x
function code(x) return x end
function tmp = code(x) tmp = x; end
code[x_] := x
\begin{array}{l}
\\
x
\end{array}
Initial program 8.7%
Taylor expanded in x around 0 96.7%
Final simplification96.7%
herbie shell --seed 2023333
(FPCore (x)
:name "Hyperbolic tangent"
:precision binary64
(/ (- (exp x) (exp (- x))) (+ (exp x) (exp (- x)))))