
(FPCore (x) :precision binary64 (exp (- (- 1.0 (* x x)))))
double code(double x) {
return exp(-(1.0 - (x * x)));
}
real(8) function code(x)
real(8), intent (in) :: x
code = exp(-(1.0d0 - (x * x)))
end function
public static double code(double x) {
return Math.exp(-(1.0 - (x * x)));
}
def code(x): return math.exp(-(1.0 - (x * x)))
function code(x) return exp(Float64(-Float64(1.0 - Float64(x * x)))) end
function tmp = code(x) tmp = exp(-(1.0 - (x * x))); end
code[x_] := N[Exp[(-N[(1.0 - N[(x * x), $MachinePrecision]), $MachinePrecision])], $MachinePrecision]
\begin{array}{l}
\\
e^{-\left(1 - x \cdot x\right)}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 5 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x) :precision binary64 (exp (- (- 1.0 (* x x)))))
double code(double x) {
return exp(-(1.0 - (x * x)));
}
real(8) function code(x)
real(8), intent (in) :: x
code = exp(-(1.0d0 - (x * x)))
end function
public static double code(double x) {
return Math.exp(-(1.0 - (x * x)));
}
def code(x): return math.exp(-(1.0 - (x * x)))
function code(x) return exp(Float64(-Float64(1.0 - Float64(x * x)))) end
function tmp = code(x) tmp = exp(-(1.0 - (x * x))); end
code[x_] := N[Exp[(-N[(1.0 - N[(x * x), $MachinePrecision]), $MachinePrecision])], $MachinePrecision]
\begin{array}{l}
\\
e^{-\left(1 - x \cdot x\right)}
\end{array}
x_m = (fabs.f64 x) (FPCore (x_m) :precision binary64 (let* ((t_0 (exp (+ -1.0 x_m)))) (* (pow t_0 (+ x_m 0.5)) (sqrt t_0))))
x_m = fabs(x);
double code(double x_m) {
double t_0 = exp((-1.0 + x_m));
return pow(t_0, (x_m + 0.5)) * sqrt(t_0);
}
x_m = abs(x)
real(8) function code(x_m)
real(8), intent (in) :: x_m
real(8) :: t_0
t_0 = exp(((-1.0d0) + x_m))
code = (t_0 ** (x_m + 0.5d0)) * sqrt(t_0)
end function
x_m = Math.abs(x);
public static double code(double x_m) {
double t_0 = Math.exp((-1.0 + x_m));
return Math.pow(t_0, (x_m + 0.5)) * Math.sqrt(t_0);
}
x_m = math.fabs(x) def code(x_m): t_0 = math.exp((-1.0 + x_m)) return math.pow(t_0, (x_m + 0.5)) * math.sqrt(t_0)
x_m = abs(x) function code(x_m) t_0 = exp(Float64(-1.0 + x_m)) return Float64((t_0 ^ Float64(x_m + 0.5)) * sqrt(t_0)) end
x_m = abs(x); function tmp = code(x_m) t_0 = exp((-1.0 + x_m)); tmp = (t_0 ^ (x_m + 0.5)) * sqrt(t_0); end
x_m = N[Abs[x], $MachinePrecision]
code[x$95$m_] := Block[{t$95$0 = N[Exp[N[(-1.0 + x$95$m), $MachinePrecision]], $MachinePrecision]}, N[(N[Power[t$95$0, N[(x$95$m + 0.5), $MachinePrecision]], $MachinePrecision] * N[Sqrt[t$95$0], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
x_m = \left|x\right|
\\
\begin{array}{l}
t_0 := e^{-1 + x\_m}\\
{t\_0}^{\left(x\_m + 0.5\right)} \cdot \sqrt{t\_0}
\end{array}
\end{array}
Initial program 100.0%
neg-sub0100.0%
sqr-neg100.0%
associate--r-100.0%
metadata-eval100.0%
+-commutative100.0%
sqr-neg100.0%
Simplified100.0%
*-un-lft-identity100.0%
exp-prod99.9%
expm1-log1p-u99.9%
expm1-undefine99.9%
pow-sub99.9%
fma-define99.9%
metadata-eval99.9%
fma-neg99.9%
pow199.9%
pow-to-exp99.9%
expm1-define99.9%
log1p-expm1-u99.9%
pow-to-exp99.9%
pow199.9%
exp-prod99.9%
*-un-lft-identity99.9%
pow299.9%
pow199.9%
exp-1-e99.9%
Applied egg-rr99.9%
e-exp-199.9%
div-exp100.0%
unpow2100.0%
difference-of-sqr-199.9%
sub-neg99.9%
metadata-eval99.9%
add-log-exp99.9%
log-pow99.9%
add-exp-log100.0%
pow-plus76.9%
add-sqr-sqrt76.9%
associate-*r*76.9%
+-commutative76.9%
+-commutative76.9%
+-commutative76.9%
Applied egg-rr76.9%
add-log-exp76.5%
*-un-lft-identity76.5%
log-prod76.5%
metadata-eval76.5%
add-log-exp76.9%
pow1/276.9%
pow-prod-up76.9%
Applied egg-rr76.9%
+-lft-identity76.9%
Simplified76.9%
x_m = (fabs.f64 x) (FPCore (x_m) :precision binary64 (* (pow (exp (+ -1.0 x_m)) (+ x_m 0.5)) (exp (* (+ -1.0 x_m) 0.5))))
x_m = fabs(x);
double code(double x_m) {
return pow(exp((-1.0 + x_m)), (x_m + 0.5)) * exp(((-1.0 + x_m) * 0.5));
}
x_m = abs(x)
real(8) function code(x_m)
real(8), intent (in) :: x_m
code = (exp(((-1.0d0) + x_m)) ** (x_m + 0.5d0)) * exp((((-1.0d0) + x_m) * 0.5d0))
end function
x_m = Math.abs(x);
public static double code(double x_m) {
return Math.pow(Math.exp((-1.0 + x_m)), (x_m + 0.5)) * Math.exp(((-1.0 + x_m) * 0.5));
}
x_m = math.fabs(x) def code(x_m): return math.pow(math.exp((-1.0 + x_m)), (x_m + 0.5)) * math.exp(((-1.0 + x_m) * 0.5))
x_m = abs(x) function code(x_m) return Float64((exp(Float64(-1.0 + x_m)) ^ Float64(x_m + 0.5)) * exp(Float64(Float64(-1.0 + x_m) * 0.5))) end
x_m = abs(x); function tmp = code(x_m) tmp = (exp((-1.0 + x_m)) ^ (x_m + 0.5)) * exp(((-1.0 + x_m) * 0.5)); end
x_m = N[Abs[x], $MachinePrecision] code[x$95$m_] := N[(N[Power[N[Exp[N[(-1.0 + x$95$m), $MachinePrecision]], $MachinePrecision], N[(x$95$m + 0.5), $MachinePrecision]], $MachinePrecision] * N[Exp[N[(N[(-1.0 + x$95$m), $MachinePrecision] * 0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
x_m = \left|x\right|
\\
{\left(e^{-1 + x\_m}\right)}^{\left(x\_m + 0.5\right)} \cdot e^{\left(-1 + x\_m\right) \cdot 0.5}
\end{array}
Initial program 100.0%
neg-sub0100.0%
sqr-neg100.0%
associate--r-100.0%
metadata-eval100.0%
+-commutative100.0%
sqr-neg100.0%
Simplified100.0%
*-un-lft-identity100.0%
exp-prod99.9%
expm1-log1p-u99.9%
expm1-undefine99.9%
pow-sub99.9%
fma-define99.9%
metadata-eval99.9%
fma-neg99.9%
pow199.9%
pow-to-exp99.9%
expm1-define99.9%
log1p-expm1-u99.9%
pow-to-exp99.9%
pow199.9%
exp-prod99.9%
*-un-lft-identity99.9%
pow299.9%
pow199.9%
exp-1-e99.9%
Applied egg-rr99.9%
e-exp-199.9%
div-exp100.0%
unpow2100.0%
difference-of-sqr-199.9%
sub-neg99.9%
metadata-eval99.9%
add-log-exp99.9%
log-pow99.9%
add-exp-log100.0%
pow-plus76.9%
add-sqr-sqrt76.9%
associate-*r*76.9%
+-commutative76.9%
+-commutative76.9%
+-commutative76.9%
Applied egg-rr76.9%
add-log-exp76.5%
*-un-lft-identity76.5%
log-prod76.5%
metadata-eval76.5%
add-log-exp76.9%
pow1/276.9%
pow-prod-up76.9%
Applied egg-rr76.9%
+-lft-identity76.9%
Simplified76.9%
pow1/276.9%
pow-exp76.9%
Applied egg-rr76.9%
x_m = (fabs.f64 x) (FPCore (x_m) :precision binary64 (/ (pow (exp x_m) x_m) E))
x_m = fabs(x);
double code(double x_m) {
return pow(exp(x_m), x_m) / ((double) M_E);
}
x_m = Math.abs(x);
public static double code(double x_m) {
return Math.pow(Math.exp(x_m), x_m) / Math.E;
}
x_m = math.fabs(x) def code(x_m): return math.pow(math.exp(x_m), x_m) / math.e
x_m = abs(x) function code(x_m) return Float64((exp(x_m) ^ x_m) / exp(1)) end
x_m = abs(x); function tmp = code(x_m) tmp = (exp(x_m) ^ x_m) / 2.71828182845904523536; end
x_m = N[Abs[x], $MachinePrecision] code[x$95$m_] := N[(N[Power[N[Exp[x$95$m], $MachinePrecision], x$95$m], $MachinePrecision] / E), $MachinePrecision]
\begin{array}{l}
x_m = \left|x\right|
\\
\frac{{\left(e^{x\_m}\right)}^{x\_m}}{e}
\end{array}
Initial program 100.0%
neg-sub0100.0%
sqr-neg100.0%
associate--r-100.0%
metadata-eval100.0%
+-commutative100.0%
sqr-neg100.0%
Simplified100.0%
*-un-lft-identity100.0%
exp-prod99.9%
expm1-log1p-u99.9%
expm1-undefine99.9%
pow-sub99.9%
fma-define99.9%
metadata-eval99.9%
fma-neg99.9%
pow199.9%
pow-to-exp99.9%
expm1-define99.9%
log1p-expm1-u99.9%
pow-to-exp99.9%
pow199.9%
exp-prod99.9%
*-un-lft-identity99.9%
pow299.9%
pow199.9%
exp-1-e99.9%
Applied egg-rr99.9%
unpow299.9%
exp-prod100.0%
Applied egg-rr100.0%
x_m = (fabs.f64 x) (FPCore (x_m) :precision binary64 (exp (+ -1.0 (* x_m x_m))))
x_m = fabs(x);
double code(double x_m) {
return exp((-1.0 + (x_m * x_m)));
}
x_m = abs(x)
real(8) function code(x_m)
real(8), intent (in) :: x_m
code = exp(((-1.0d0) + (x_m * x_m)))
end function
x_m = Math.abs(x);
public static double code(double x_m) {
return Math.exp((-1.0 + (x_m * x_m)));
}
x_m = math.fabs(x) def code(x_m): return math.exp((-1.0 + (x_m * x_m)))
x_m = abs(x) function code(x_m) return exp(Float64(-1.0 + Float64(x_m * x_m))) end
x_m = abs(x); function tmp = code(x_m) tmp = exp((-1.0 + (x_m * x_m))); end
x_m = N[Abs[x], $MachinePrecision] code[x$95$m_] := N[Exp[N[(-1.0 + N[(x$95$m * x$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
x_m = \left|x\right|
\\
e^{-1 + x\_m \cdot x\_m}
\end{array}
Initial program 100.0%
neg-sub0100.0%
sqr-neg100.0%
associate--r-100.0%
metadata-eval100.0%
+-commutative100.0%
sqr-neg100.0%
Simplified100.0%
Final simplification100.0%
x_m = (fabs.f64 x) (FPCore (x_m) :precision binary64 (/ 1.0 E))
x_m = fabs(x);
double code(double x_m) {
return 1.0 / ((double) M_E);
}
x_m = Math.abs(x);
public static double code(double x_m) {
return 1.0 / Math.E;
}
x_m = math.fabs(x) def code(x_m): return 1.0 / math.e
x_m = abs(x) function code(x_m) return Float64(1.0 / exp(1)) end
x_m = abs(x); function tmp = code(x_m) tmp = 1.0 / 2.71828182845904523536; end
x_m = N[Abs[x], $MachinePrecision] code[x$95$m_] := N[(1.0 / E), $MachinePrecision]
\begin{array}{l}
x_m = \left|x\right|
\\
\frac{1}{e}
\end{array}
Initial program 100.0%
neg-sub0100.0%
sqr-neg100.0%
associate--r-100.0%
metadata-eval100.0%
+-commutative100.0%
sqr-neg100.0%
Simplified100.0%
*-un-lft-identity100.0%
exp-prod99.9%
expm1-log1p-u99.9%
expm1-undefine99.9%
pow-sub99.9%
fma-define99.9%
metadata-eval99.9%
fma-neg99.9%
pow199.9%
pow-to-exp99.9%
expm1-define99.9%
log1p-expm1-u99.9%
pow-to-exp99.9%
pow199.9%
exp-prod99.9%
*-un-lft-identity99.9%
pow299.9%
pow199.9%
exp-1-e99.9%
Applied egg-rr99.9%
Taylor expanded in x around 0 54.5%
herbie shell --seed 2024128
(FPCore (x)
:name "exp neg sub"
:precision binary64
(exp (- (- 1.0 (* x x)))))