
(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 6 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 (<= (* x -2.0) -20.0)
(- (/ 2.0 (+ (exp (* x -2.0)) 1.0)) 1.0)
(if (<= (* x -2.0) 0.0001)
(*
(fma (fma 0.13333333333333333 (* x x) -0.3333333333333333) (* x x) 1.0)
x)
(- (/ 2.0 (* (* -1.3333333333333333 (* x x)) x)) 1.0))))
double code(double x, double y) {
double tmp;
if ((x * -2.0) <= -20.0) {
tmp = (2.0 / (exp((x * -2.0)) + 1.0)) - 1.0;
} else if ((x * -2.0) <= 0.0001) {
tmp = fma(fma(0.13333333333333333, (x * x), -0.3333333333333333), (x * x), 1.0) * x;
} else {
tmp = (2.0 / ((-1.3333333333333333 * (x * x)) * x)) - 1.0;
}
return tmp;
}
function code(x, y) tmp = 0.0 if (Float64(x * -2.0) <= -20.0) tmp = Float64(Float64(2.0 / Float64(exp(Float64(x * -2.0)) + 1.0)) - 1.0); elseif (Float64(x * -2.0) <= 0.0001) tmp = Float64(fma(fma(0.13333333333333333, Float64(x * x), -0.3333333333333333), Float64(x * x), 1.0) * x); else tmp = Float64(Float64(2.0 / Float64(Float64(-1.3333333333333333 * Float64(x * x)) * x)) - 1.0); end return tmp end
code[x_, y_] := If[LessEqual[N[(x * -2.0), $MachinePrecision], -20.0], N[(N[(2.0 / N[(N[Exp[N[(x * -2.0), $MachinePrecision]], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] - 1.0), $MachinePrecision], If[LessEqual[N[(x * -2.0), $MachinePrecision], 0.0001], N[(N[(N[(0.13333333333333333 * N[(x * x), $MachinePrecision] + -0.3333333333333333), $MachinePrecision] * N[(x * x), $MachinePrecision] + 1.0), $MachinePrecision] * x), $MachinePrecision], N[(N[(2.0 / N[(N[(-1.3333333333333333 * N[(x * x), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision] - 1.0), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \cdot -2 \leq -20:\\
\;\;\;\;\frac{2}{e^{x \cdot -2} + 1} - 1\\
\mathbf{elif}\;x \cdot -2 \leq 0.0001:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(0.13333333333333333, x \cdot x, -0.3333333333333333\right), x \cdot x, 1\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\left(-1.3333333333333333 \cdot \left(x \cdot x\right)\right) \cdot x} - 1\\
\end{array}
\end{array}
if (*.f64 #s(literal -2 binary64) x) < -20Initial program 100.0%
if -20 < (*.f64 #s(literal -2 binary64) x) < 1.00000000000000005e-4Initial program 9.5%
Taylor expanded in x around 0
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
sub-negN/A
metadata-evalN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64100.0
Applied rewrites100.0%
if 1.00000000000000005e-4 < (*.f64 #s(literal -2 binary64) x) Initial program 100.0%
Taylor expanded in x around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64100.0
Applied rewrites100.0%
Taylor expanded in x around inf
Applied rewrites100.0%
Final simplification100.0%
(FPCore (x y) :precision binary64 (if (<= (* x -2.0) 2e-7) x (- (/ 2.0 (fma (fma (fma -1.3333333333333333 x 2.0) x -2.0) x 2.0)) 1.0)))
double code(double x, double y) {
double tmp;
if ((x * -2.0) <= 2e-7) {
tmp = x;
} else {
tmp = (2.0 / fma(fma(fma(-1.3333333333333333, x, 2.0), x, -2.0), x, 2.0)) - 1.0;
}
return tmp;
}
function code(x, y) tmp = 0.0 if (Float64(x * -2.0) <= 2e-7) tmp = x; else tmp = Float64(Float64(2.0 / fma(fma(fma(-1.3333333333333333, x, 2.0), x, -2.0), x, 2.0)) - 1.0); end return tmp end
code[x_, y_] := If[LessEqual[N[(x * -2.0), $MachinePrecision], 2e-7], x, N[(N[(2.0 / N[(N[(N[(-1.3333333333333333 * x + 2.0), $MachinePrecision] * x + -2.0), $MachinePrecision] * x + 2.0), $MachinePrecision]), $MachinePrecision] - 1.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \cdot -2 \leq 2 \cdot 10^{-7}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\mathsf{fma}\left(\mathsf{fma}\left(\mathsf{fma}\left(-1.3333333333333333, x, 2\right), x, -2\right), x, 2\right)} - 1\\
\end{array}
\end{array}
if (*.f64 #s(literal -2 binary64) x) < 1.9999999999999999e-7Initial program 43.1%
lift--.f64N/A
sub-negN/A
lift-/.f64N/A
clear-numN/A
inv-powN/A
metadata-evalN/A
sqr-powN/A
lower-fma.f64N/A
Applied rewrites42.5%
Taylor expanded in x around 0
+-commutativeN/A
associate--l+N/A
unpow2N/A
rem-square-sqrtN/A
metadata-evalN/A
*-commutativeN/A
unpow2N/A
rem-square-sqrtN/A
associate-*r*N/A
metadata-evalN/A
*-lft-identityN/A
sub-negN/A
metadata-evalN/A
+-commutativeN/A
associate-+r+N/A
metadata-evalN/A
+-lft-identity64.1
Applied rewrites64.1%
if 1.9999999999999999e-7 < (*.f64 #s(literal -2 binary64) x) Initial program 99.6%
Taylor expanded in x around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f6499.7
Applied rewrites99.7%
Final simplification73.4%
(FPCore (x y) :precision binary64 (if (<= (* x -2.0) 0.0001) x (- (/ 2.0 (* (* -1.3333333333333333 (* x x)) x)) 1.0)))
double code(double x, double y) {
double tmp;
if ((x * -2.0) <= 0.0001) {
tmp = x;
} else {
tmp = (2.0 / ((-1.3333333333333333 * (x * x)) * x)) - 1.0;
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if ((x * (-2.0d0)) <= 0.0001d0) then
tmp = x
else
tmp = (2.0d0 / (((-1.3333333333333333d0) * (x * x)) * x)) - 1.0d0
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if ((x * -2.0) <= 0.0001) {
tmp = x;
} else {
tmp = (2.0 / ((-1.3333333333333333 * (x * x)) * x)) - 1.0;
}
return tmp;
}
def code(x, y): tmp = 0 if (x * -2.0) <= 0.0001: tmp = x else: tmp = (2.0 / ((-1.3333333333333333 * (x * x)) * x)) - 1.0 return tmp
function code(x, y) tmp = 0.0 if (Float64(x * -2.0) <= 0.0001) tmp = x; else tmp = Float64(Float64(2.0 / Float64(Float64(-1.3333333333333333 * Float64(x * x)) * x)) - 1.0); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if ((x * -2.0) <= 0.0001) tmp = x; else tmp = (2.0 / ((-1.3333333333333333 * (x * x)) * x)) - 1.0; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[N[(x * -2.0), $MachinePrecision], 0.0001], x, N[(N[(2.0 / N[(N[(-1.3333333333333333 * N[(x * x), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision] - 1.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \cdot -2 \leq 0.0001:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\left(-1.3333333333333333 \cdot \left(x \cdot x\right)\right) \cdot x} - 1\\
\end{array}
\end{array}
if (*.f64 #s(literal -2 binary64) x) < 1.00000000000000005e-4Initial program 43.3%
lift--.f64N/A
sub-negN/A
lift-/.f64N/A
clear-numN/A
inv-powN/A
metadata-evalN/A
sqr-powN/A
lower-fma.f64N/A
Applied rewrites42.7%
Taylor expanded in x around 0
+-commutativeN/A
associate--l+N/A
unpow2N/A
rem-square-sqrtN/A
metadata-evalN/A
*-commutativeN/A
unpow2N/A
rem-square-sqrtN/A
associate-*r*N/A
metadata-evalN/A
*-lft-identityN/A
sub-negN/A
metadata-evalN/A
+-commutativeN/A
associate-+r+N/A
metadata-evalN/A
+-lft-identity64.1
Applied rewrites64.1%
if 1.00000000000000005e-4 < (*.f64 #s(literal -2 binary64) x) Initial program 100.0%
Taylor expanded in x around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64100.0
Applied rewrites100.0%
Taylor expanded in x around inf
Applied rewrites100.0%
Final simplification73.4%
(FPCore (x y) :precision binary64 (if (<= (* x -2.0) 0.0001) x (- (/ 1.0 (fma (- x 1.0) x 1.0)) 1.0)))
double code(double x, double y) {
double tmp;
if ((x * -2.0) <= 0.0001) {
tmp = x;
} else {
tmp = (1.0 / fma((x - 1.0), x, 1.0)) - 1.0;
}
return tmp;
}
function code(x, y) tmp = 0.0 if (Float64(x * -2.0) <= 0.0001) tmp = x; else tmp = Float64(Float64(1.0 / fma(Float64(x - 1.0), x, 1.0)) - 1.0); end return tmp end
code[x_, y_] := If[LessEqual[N[(x * -2.0), $MachinePrecision], 0.0001], x, N[(N[(1.0 / N[(N[(x - 1.0), $MachinePrecision] * x + 1.0), $MachinePrecision]), $MachinePrecision] - 1.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \cdot -2 \leq 0.0001:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\mathsf{fma}\left(x - 1, x, 1\right)} - 1\\
\end{array}
\end{array}
if (*.f64 #s(literal -2 binary64) x) < 1.00000000000000005e-4Initial program 43.3%
lift--.f64N/A
sub-negN/A
lift-/.f64N/A
clear-numN/A
inv-powN/A
metadata-evalN/A
sqr-powN/A
lower-fma.f64N/A
Applied rewrites42.7%
Taylor expanded in x around 0
+-commutativeN/A
associate--l+N/A
unpow2N/A
rem-square-sqrtN/A
metadata-evalN/A
*-commutativeN/A
unpow2N/A
rem-square-sqrtN/A
associate-*r*N/A
metadata-evalN/A
*-lft-identityN/A
sub-negN/A
metadata-evalN/A
+-commutativeN/A
associate-+r+N/A
metadata-evalN/A
+-lft-identity64.1
Applied rewrites64.1%
if 1.00000000000000005e-4 < (*.f64 #s(literal -2 binary64) x) Initial program 100.0%
Taylor expanded in x around 0
Applied rewrites3.1%
Taylor expanded in x around 0
+-commutativeN/A
metadata-evalN/A
sub-negN/A
lower--.f645.0
Applied rewrites5.0%
Applied rewrites2.5%
Taylor expanded in x around 0
Applied rewrites99.8%
Final simplification73.3%
(FPCore (x y) :precision binary64 (if (<= (* x -2.0) 0.0001) x (- (/ -1.0 (- x 1.0)) 1.0)))
double code(double x, double y) {
double tmp;
if ((x * -2.0) <= 0.0001) {
tmp = x;
} else {
tmp = (-1.0 / (x - 1.0)) - 1.0;
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if ((x * (-2.0d0)) <= 0.0001d0) then
tmp = x
else
tmp = ((-1.0d0) / (x - 1.0d0)) - 1.0d0
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if ((x * -2.0) <= 0.0001) {
tmp = x;
} else {
tmp = (-1.0 / (x - 1.0)) - 1.0;
}
return tmp;
}
def code(x, y): tmp = 0 if (x * -2.0) <= 0.0001: tmp = x else: tmp = (-1.0 / (x - 1.0)) - 1.0 return tmp
function code(x, y) tmp = 0.0 if (Float64(x * -2.0) <= 0.0001) tmp = x; else tmp = Float64(Float64(-1.0 / Float64(x - 1.0)) - 1.0); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if ((x * -2.0) <= 0.0001) tmp = x; else tmp = (-1.0 / (x - 1.0)) - 1.0; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[N[(x * -2.0), $MachinePrecision], 0.0001], x, N[(N[(-1.0 / N[(x - 1.0), $MachinePrecision]), $MachinePrecision] - 1.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \cdot -2 \leq 0.0001:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;\frac{-1}{x - 1} - 1\\
\end{array}
\end{array}
if (*.f64 #s(literal -2 binary64) x) < 1.00000000000000005e-4Initial program 43.3%
lift--.f64N/A
sub-negN/A
lift-/.f64N/A
clear-numN/A
inv-powN/A
metadata-evalN/A
sqr-powN/A
lower-fma.f64N/A
Applied rewrites42.7%
Taylor expanded in x around 0
+-commutativeN/A
associate--l+N/A
unpow2N/A
rem-square-sqrtN/A
metadata-evalN/A
*-commutativeN/A
unpow2N/A
rem-square-sqrtN/A
associate-*r*N/A
metadata-evalN/A
*-lft-identityN/A
sub-negN/A
metadata-evalN/A
+-commutativeN/A
associate-+r+N/A
metadata-evalN/A
+-lft-identity64.1
Applied rewrites64.1%
if 1.00000000000000005e-4 < (*.f64 #s(literal -2 binary64) x) Initial program 100.0%
Taylor expanded in x around 0
Applied rewrites3.1%
Taylor expanded in x around 0
+-commutativeN/A
metadata-evalN/A
sub-negN/A
lower--.f645.0
Applied rewrites5.0%
Applied rewrites4.6%
Taylor expanded in x around 0
Applied rewrites98.7%
Final simplification73.0%
(FPCore (x y) :precision binary64 x)
double code(double x, double y) {
return x;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = x
end function
public static double code(double x, double y) {
return x;
}
def code(x, y): return x
function code(x, y) return x end
function tmp = code(x, y) tmp = x; end
code[x_, y_] := x
\begin{array}{l}
\\
x
\end{array}
Initial program 57.9%
lift--.f64N/A
sub-negN/A
lift-/.f64N/A
clear-numN/A
inv-powN/A
metadata-evalN/A
sqr-powN/A
lower-fma.f64N/A
Applied rewrites57.5%
Taylor expanded in x around 0
+-commutativeN/A
associate--l+N/A
unpow2N/A
rem-square-sqrtN/A
metadata-evalN/A
*-commutativeN/A
unpow2N/A
rem-square-sqrtN/A
associate-*r*N/A
metadata-evalN/A
*-lft-identityN/A
sub-negN/A
metadata-evalN/A
+-commutativeN/A
associate-+r+N/A
metadata-evalN/A
+-lft-identity48.9
Applied rewrites48.9%
herbie shell --seed 2024235
(FPCore (x y)
:name "Logistic function from Lakshay Garg"
:precision binary64
(- (/ 2.0 (+ 1.0 (exp (* -2.0 x)))) 1.0))