
(FPCore (x) :precision binary64 (/ (- (exp x) (exp (- x))) 2.0))
double code(double x) {
return (exp(x) - exp(-x)) / 2.0;
}
real(8) function code(x)
real(8), intent (in) :: x
code = (exp(x) - exp(-x)) / 2.0d0
end function
public static double code(double x) {
return (Math.exp(x) - Math.exp(-x)) / 2.0;
}
def code(x): return (math.exp(x) - math.exp(-x)) / 2.0
function code(x) return Float64(Float64(exp(x) - exp(Float64(-x))) / 2.0) end
function tmp = code(x) tmp = (exp(x) - exp(-x)) / 2.0; end
code[x_] := N[(N[(N[Exp[x], $MachinePrecision] - N[Exp[(-x)], $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision]
\begin{array}{l}
\\
\frac{e^{x} - e^{-x}}{2}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 9 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x) :precision binary64 (/ (- (exp x) (exp (- x))) 2.0))
double code(double x) {
return (exp(x) - exp(-x)) / 2.0;
}
real(8) function code(x)
real(8), intent (in) :: x
code = (exp(x) - exp(-x)) / 2.0d0
end function
public static double code(double x) {
return (Math.exp(x) - Math.exp(-x)) / 2.0;
}
def code(x): return (math.exp(x) - math.exp(-x)) / 2.0
function code(x) return Float64(Float64(exp(x) - exp(Float64(-x))) / 2.0) end
function tmp = code(x) tmp = (exp(x) - exp(-x)) / 2.0; end
code[x_] := N[(N[(N[Exp[x], $MachinePrecision] - N[Exp[(-x)], $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision]
\begin{array}{l}
\\
\frac{e^{x} - e^{-x}}{2}
\end{array}
(FPCore (x)
:precision binary64
(let* ((t_0 (- (exp x) (exp (- x)))))
(if (or (<= t_0 -10.0) (not (<= t_0 0.0002)))
(/ t_0 2.0)
(/ (+ (* (* x 0.3333333333333333) (* x x)) (* x 2.0)) 2.0))))
double code(double x) {
double t_0 = exp(x) - exp(-x);
double tmp;
if ((t_0 <= -10.0) || !(t_0 <= 0.0002)) {
tmp = t_0 / 2.0;
} else {
tmp = (((x * 0.3333333333333333) * (x * x)) + (x * 2.0)) / 2.0;
}
return tmp;
}
real(8) function code(x)
real(8), intent (in) :: x
real(8) :: t_0
real(8) :: tmp
t_0 = exp(x) - exp(-x)
if ((t_0 <= (-10.0d0)) .or. (.not. (t_0 <= 0.0002d0))) then
tmp = t_0 / 2.0d0
else
tmp = (((x * 0.3333333333333333d0) * (x * x)) + (x * 2.0d0)) / 2.0d0
end if
code = tmp
end function
public static double code(double x) {
double t_0 = Math.exp(x) - Math.exp(-x);
double tmp;
if ((t_0 <= -10.0) || !(t_0 <= 0.0002)) {
tmp = t_0 / 2.0;
} else {
tmp = (((x * 0.3333333333333333) * (x * x)) + (x * 2.0)) / 2.0;
}
return tmp;
}
def code(x): t_0 = math.exp(x) - math.exp(-x) tmp = 0 if (t_0 <= -10.0) or not (t_0 <= 0.0002): tmp = t_0 / 2.0 else: tmp = (((x * 0.3333333333333333) * (x * x)) + (x * 2.0)) / 2.0 return tmp
function code(x) t_0 = Float64(exp(x) - exp(Float64(-x))) tmp = 0.0 if ((t_0 <= -10.0) || !(t_0 <= 0.0002)) tmp = Float64(t_0 / 2.0); else tmp = Float64(Float64(Float64(Float64(x * 0.3333333333333333) * Float64(x * x)) + Float64(x * 2.0)) / 2.0); end return tmp end
function tmp_2 = code(x) t_0 = exp(x) - exp(-x); tmp = 0.0; if ((t_0 <= -10.0) || ~((t_0 <= 0.0002))) tmp = t_0 / 2.0; else tmp = (((x * 0.3333333333333333) * (x * x)) + (x * 2.0)) / 2.0; end tmp_2 = tmp; end
code[x_] := Block[{t$95$0 = N[(N[Exp[x], $MachinePrecision] - N[Exp[(-x)], $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[t$95$0, -10.0], N[Not[LessEqual[t$95$0, 0.0002]], $MachinePrecision]], N[(t$95$0 / 2.0), $MachinePrecision], N[(N[(N[(N[(x * 0.3333333333333333), $MachinePrecision] * N[(x * x), $MachinePrecision]), $MachinePrecision] + N[(x * 2.0), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := e^{x} - e^{-x}\\
\mathbf{if}\;t_0 \leq -10 \lor \neg \left(t_0 \leq 0.0002\right):\\
\;\;\;\;\frac{t_0}{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{\left(x \cdot 0.3333333333333333\right) \cdot \left(x \cdot x\right) + x \cdot 2}{2}\\
\end{array}
\end{array}
if (-.f64 (exp.f64 x) (exp.f64 (neg.f64 x))) < -10 or 2.0000000000000001e-4 < (-.f64 (exp.f64 x) (exp.f64 (neg.f64 x))) Initial program 100.0%
if -10 < (-.f64 (exp.f64 x) (exp.f64 (neg.f64 x))) < 2.0000000000000001e-4Initial program 8.9%
Taylor expanded in x around 0 100.0%
unpow3100.0%
associate-*r*100.0%
distribute-rgt-out100.0%
*-commutative100.0%
+-commutative100.0%
associate-*l*100.0%
fma-def100.0%
Simplified100.0%
fma-udef100.0%
*-commutative100.0%
Applied egg-rr100.0%
distribute-rgt-in100.0%
*-commutative100.0%
associate-*l*100.0%
*-commutative100.0%
Applied egg-rr100.0%
Final simplification100.0%
(FPCore (x)
:precision binary64
(let* ((t_0 (* (* x 0.3333333333333333) (* x x))))
(if (<= x -8.2e+102)
(* x (/ (* x x) 6.0))
(if (<= x -2e+20)
(/ (/ (- (* t_0 t_0) (* (* x 2.0) (* x 2.0))) (- t_0 (* x 2.0))) 2.0)
(if (<= x 500000.0)
(/ (+ t_0 (* x 2.0)) 2.0)
(sqrt (* (pow x 6.0) 0.027777777777777776)))))))
double code(double x) {
double t_0 = (x * 0.3333333333333333) * (x * x);
double tmp;
if (x <= -8.2e+102) {
tmp = x * ((x * x) / 6.0);
} else if (x <= -2e+20) {
tmp = (((t_0 * t_0) - ((x * 2.0) * (x * 2.0))) / (t_0 - (x * 2.0))) / 2.0;
} else if (x <= 500000.0) {
tmp = (t_0 + (x * 2.0)) / 2.0;
} else {
tmp = sqrt((pow(x, 6.0) * 0.027777777777777776));
}
return tmp;
}
real(8) function code(x)
real(8), intent (in) :: x
real(8) :: t_0
real(8) :: tmp
t_0 = (x * 0.3333333333333333d0) * (x * x)
if (x <= (-8.2d+102)) then
tmp = x * ((x * x) / 6.0d0)
else if (x <= (-2d+20)) then
tmp = (((t_0 * t_0) - ((x * 2.0d0) * (x * 2.0d0))) / (t_0 - (x * 2.0d0))) / 2.0d0
else if (x <= 500000.0d0) then
tmp = (t_0 + (x * 2.0d0)) / 2.0d0
else
tmp = sqrt(((x ** 6.0d0) * 0.027777777777777776d0))
end if
code = tmp
end function
public static double code(double x) {
double t_0 = (x * 0.3333333333333333) * (x * x);
double tmp;
if (x <= -8.2e+102) {
tmp = x * ((x * x) / 6.0);
} else if (x <= -2e+20) {
tmp = (((t_0 * t_0) - ((x * 2.0) * (x * 2.0))) / (t_0 - (x * 2.0))) / 2.0;
} else if (x <= 500000.0) {
tmp = (t_0 + (x * 2.0)) / 2.0;
} else {
tmp = Math.sqrt((Math.pow(x, 6.0) * 0.027777777777777776));
}
return tmp;
}
def code(x): t_0 = (x * 0.3333333333333333) * (x * x) tmp = 0 if x <= -8.2e+102: tmp = x * ((x * x) / 6.0) elif x <= -2e+20: tmp = (((t_0 * t_0) - ((x * 2.0) * (x * 2.0))) / (t_0 - (x * 2.0))) / 2.0 elif x <= 500000.0: tmp = (t_0 + (x * 2.0)) / 2.0 else: tmp = math.sqrt((math.pow(x, 6.0) * 0.027777777777777776)) return tmp
function code(x) t_0 = Float64(Float64(x * 0.3333333333333333) * Float64(x * x)) tmp = 0.0 if (x <= -8.2e+102) tmp = Float64(x * Float64(Float64(x * x) / 6.0)); elseif (x <= -2e+20) tmp = Float64(Float64(Float64(Float64(t_0 * t_0) - Float64(Float64(x * 2.0) * Float64(x * 2.0))) / Float64(t_0 - Float64(x * 2.0))) / 2.0); elseif (x <= 500000.0) tmp = Float64(Float64(t_0 + Float64(x * 2.0)) / 2.0); else tmp = sqrt(Float64((x ^ 6.0) * 0.027777777777777776)); end return tmp end
function tmp_2 = code(x) t_0 = (x * 0.3333333333333333) * (x * x); tmp = 0.0; if (x <= -8.2e+102) tmp = x * ((x * x) / 6.0); elseif (x <= -2e+20) tmp = (((t_0 * t_0) - ((x * 2.0) * (x * 2.0))) / (t_0 - (x * 2.0))) / 2.0; elseif (x <= 500000.0) tmp = (t_0 + (x * 2.0)) / 2.0; else tmp = sqrt(((x ^ 6.0) * 0.027777777777777776)); end tmp_2 = tmp; end
code[x_] := Block[{t$95$0 = N[(N[(x * 0.3333333333333333), $MachinePrecision] * N[(x * x), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -8.2e+102], N[(x * N[(N[(x * x), $MachinePrecision] / 6.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -2e+20], N[(N[(N[(N[(t$95$0 * t$95$0), $MachinePrecision] - N[(N[(x * 2.0), $MachinePrecision] * N[(x * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(t$95$0 - N[(x * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision], If[LessEqual[x, 500000.0], N[(N[(t$95$0 + N[(x * 2.0), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision], N[Sqrt[N[(N[Power[x, 6.0], $MachinePrecision] * 0.027777777777777776), $MachinePrecision]], $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(x \cdot 0.3333333333333333\right) \cdot \left(x \cdot x\right)\\
\mathbf{if}\;x \leq -8.2 \cdot 10^{+102}:\\
\;\;\;\;x \cdot \frac{x \cdot x}{6}\\
\mathbf{elif}\;x \leq -2 \cdot 10^{+20}:\\
\;\;\;\;\frac{\frac{t_0 \cdot t_0 - \left(x \cdot 2\right) \cdot \left(x \cdot 2\right)}{t_0 - x \cdot 2}}{2}\\
\mathbf{elif}\;x \leq 500000:\\
\;\;\;\;\frac{t_0 + x \cdot 2}{2}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{{x}^{6} \cdot 0.027777777777777776}\\
\end{array}
\end{array}
if x < -8.1999999999999999e102Initial program 100.0%
Taylor expanded in x around 0 100.0%
Taylor expanded in x around inf 100.0%
Taylor expanded in x around 0 100.0%
Simplified100.0%
metadata-eval100.0%
div-inv100.0%
cube-mult100.0%
associate-/l*100.0%
Applied egg-rr100.0%
associate-/r*100.0%
associate-/l*100.0%
associate-/r/100.0%
Simplified100.0%
if -8.1999999999999999e102 < x < -2e20Initial program 100.0%
Taylor expanded in x around 0 6.4%
unpow36.4%
associate-*r*6.4%
distribute-rgt-out6.4%
*-commutative6.4%
+-commutative6.4%
associate-*l*6.4%
fma-def6.4%
Simplified6.4%
fma-udef6.4%
*-commutative6.4%
Applied egg-rr6.4%
distribute-lft-in6.4%
flip-+76.0%
*-commutative76.0%
*-commutative76.0%
*-commutative76.0%
associate-*l*76.0%
*-commutative76.0%
associate-*l*76.0%
*-commutative76.0%
*-commutative76.0%
associate-*l*76.0%
Applied egg-rr76.0%
if -2e20 < x < 5e5Initial program 14.8%
Taylor expanded in x around 0 94.0%
unpow394.0%
associate-*r*94.0%
distribute-rgt-out94.0%
*-commutative94.0%
+-commutative94.0%
associate-*l*94.0%
fma-def94.0%
Simplified94.0%
fma-udef94.0%
*-commutative94.0%
Applied egg-rr94.0%
distribute-rgt-in94.0%
*-commutative94.0%
associate-*l*94.0%
*-commutative94.0%
Applied egg-rr94.0%
if 5e5 < x Initial program 100.0%
Taylor expanded in x around 0 75.3%
Taylor expanded in x around inf 75.3%
Taylor expanded in x around 0 75.3%
Simplified75.3%
add-sqr-sqrt75.3%
sqrt-unprod89.5%
*-commutative89.5%
*-commutative89.5%
swap-sqr89.5%
metadata-eval89.5%
pow-prod-up89.5%
metadata-eval89.5%
Applied egg-rr89.5%
*-commutative89.5%
Simplified89.5%
Final simplification92.2%
(FPCore (x)
:precision binary64
(let* ((t_0 (* (* x 0.3333333333333333) (* x x)))
(t_1 (* x (/ (* x x) 6.0)))
(t_2
(/
(/ (- (* t_0 t_0) (* (* x 2.0) (* x 2.0))) (- t_0 (* x 2.0)))
2.0)))
(if (<= x -8.2e+102)
t_1
(if (<= x -2e+20)
t_2
(if (<= x 5e+16)
(/ (+ t_0 (* x 2.0)) 2.0)
(if (<= x 8.2e+102) t_2 t_1))))))
double code(double x) {
double t_0 = (x * 0.3333333333333333) * (x * x);
double t_1 = x * ((x * x) / 6.0);
double t_2 = (((t_0 * t_0) - ((x * 2.0) * (x * 2.0))) / (t_0 - (x * 2.0))) / 2.0;
double tmp;
if (x <= -8.2e+102) {
tmp = t_1;
} else if (x <= -2e+20) {
tmp = t_2;
} else if (x <= 5e+16) {
tmp = (t_0 + (x * 2.0)) / 2.0;
} else if (x <= 8.2e+102) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x)
real(8), intent (in) :: x
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_0 = (x * 0.3333333333333333d0) * (x * x)
t_1 = x * ((x * x) / 6.0d0)
t_2 = (((t_0 * t_0) - ((x * 2.0d0) * (x * 2.0d0))) / (t_0 - (x * 2.0d0))) / 2.0d0
if (x <= (-8.2d+102)) then
tmp = t_1
else if (x <= (-2d+20)) then
tmp = t_2
else if (x <= 5d+16) then
tmp = (t_0 + (x * 2.0d0)) / 2.0d0
else if (x <= 8.2d+102) then
tmp = t_2
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x) {
double t_0 = (x * 0.3333333333333333) * (x * x);
double t_1 = x * ((x * x) / 6.0);
double t_2 = (((t_0 * t_0) - ((x * 2.0) * (x * 2.0))) / (t_0 - (x * 2.0))) / 2.0;
double tmp;
if (x <= -8.2e+102) {
tmp = t_1;
} else if (x <= -2e+20) {
tmp = t_2;
} else if (x <= 5e+16) {
tmp = (t_0 + (x * 2.0)) / 2.0;
} else if (x <= 8.2e+102) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
def code(x): t_0 = (x * 0.3333333333333333) * (x * x) t_1 = x * ((x * x) / 6.0) t_2 = (((t_0 * t_0) - ((x * 2.0) * (x * 2.0))) / (t_0 - (x * 2.0))) / 2.0 tmp = 0 if x <= -8.2e+102: tmp = t_1 elif x <= -2e+20: tmp = t_2 elif x <= 5e+16: tmp = (t_0 + (x * 2.0)) / 2.0 elif x <= 8.2e+102: tmp = t_2 else: tmp = t_1 return tmp
function code(x) t_0 = Float64(Float64(x * 0.3333333333333333) * Float64(x * x)) t_1 = Float64(x * Float64(Float64(x * x) / 6.0)) t_2 = Float64(Float64(Float64(Float64(t_0 * t_0) - Float64(Float64(x * 2.0) * Float64(x * 2.0))) / Float64(t_0 - Float64(x * 2.0))) / 2.0) tmp = 0.0 if (x <= -8.2e+102) tmp = t_1; elseif (x <= -2e+20) tmp = t_2; elseif (x <= 5e+16) tmp = Float64(Float64(t_0 + Float64(x * 2.0)) / 2.0); elseif (x <= 8.2e+102) tmp = t_2; else tmp = t_1; end return tmp end
function tmp_2 = code(x) t_0 = (x * 0.3333333333333333) * (x * x); t_1 = x * ((x * x) / 6.0); t_2 = (((t_0 * t_0) - ((x * 2.0) * (x * 2.0))) / (t_0 - (x * 2.0))) / 2.0; tmp = 0.0; if (x <= -8.2e+102) tmp = t_1; elseif (x <= -2e+20) tmp = t_2; elseif (x <= 5e+16) tmp = (t_0 + (x * 2.0)) / 2.0; elseif (x <= 8.2e+102) tmp = t_2; else tmp = t_1; end tmp_2 = tmp; end
code[x_] := Block[{t$95$0 = N[(N[(x * 0.3333333333333333), $MachinePrecision] * N[(x * x), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(x * N[(N[(x * x), $MachinePrecision] / 6.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(N[(t$95$0 * t$95$0), $MachinePrecision] - N[(N[(x * 2.0), $MachinePrecision] * N[(x * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(t$95$0 - N[(x * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision]}, If[LessEqual[x, -8.2e+102], t$95$1, If[LessEqual[x, -2e+20], t$95$2, If[LessEqual[x, 5e+16], N[(N[(t$95$0 + N[(x * 2.0), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision], If[LessEqual[x, 8.2e+102], t$95$2, t$95$1]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(x \cdot 0.3333333333333333\right) \cdot \left(x \cdot x\right)\\
t_1 := x \cdot \frac{x \cdot x}{6}\\
t_2 := \frac{\frac{t_0 \cdot t_0 - \left(x \cdot 2\right) \cdot \left(x \cdot 2\right)}{t_0 - x \cdot 2}}{2}\\
\mathbf{if}\;x \leq -8.2 \cdot 10^{+102}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;x \leq -2 \cdot 10^{+20}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;x \leq 5 \cdot 10^{+16}:\\
\;\;\;\;\frac{t_0 + x \cdot 2}{2}\\
\mathbf{elif}\;x \leq 8.2 \cdot 10^{+102}:\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if x < -8.1999999999999999e102 or 8.1999999999999999e102 < x Initial program 100.0%
Taylor expanded in x around 0 100.0%
Taylor expanded in x around inf 100.0%
Taylor expanded in x around 0 100.0%
Simplified100.0%
metadata-eval100.0%
div-inv100.0%
cube-mult100.0%
associate-/l*100.0%
Applied egg-rr100.0%
associate-/r*100.0%
associate-/l*100.0%
associate-/r/100.0%
Simplified100.0%
if -8.1999999999999999e102 < x < -2e20 or 5e16 < x < 8.1999999999999999e102Initial program 100.0%
Taylor expanded in x around 0 5.9%
unpow35.9%
associate-*r*5.9%
distribute-rgt-out5.9%
*-commutative5.9%
+-commutative5.9%
associate-*l*5.9%
fma-def5.9%
Simplified5.9%
fma-udef5.9%
*-commutative5.9%
Applied egg-rr5.9%
distribute-lft-in5.9%
flip-+75.3%
*-commutative75.3%
*-commutative75.3%
*-commutative75.3%
associate-*l*75.3%
*-commutative75.3%
associate-*l*75.3%
*-commutative75.3%
*-commutative75.3%
associate-*l*75.3%
Applied egg-rr75.3%
if -2e20 < x < 5e16Initial program 17.5%
Taylor expanded in x around 0 91.1%
unpow391.1%
associate-*r*91.1%
distribute-rgt-out91.1%
*-commutative91.1%
+-commutative91.1%
associate-*l*91.1%
fma-def91.1%
Simplified91.1%
fma-udef91.1%
*-commutative91.1%
Applied egg-rr91.1%
distribute-rgt-in91.1%
*-commutative91.1%
associate-*l*91.1%
*-commutative91.1%
Applied egg-rr91.1%
Final simplification92.2%
(FPCore (x) :precision binary64 (/ (+ (* (* x 0.3333333333333333) (* x x)) (* x 2.0)) 2.0))
double code(double x) {
return (((x * 0.3333333333333333) * (x * x)) + (x * 2.0)) / 2.0;
}
real(8) function code(x)
real(8), intent (in) :: x
code = (((x * 0.3333333333333333d0) * (x * x)) + (x * 2.0d0)) / 2.0d0
end function
public static double code(double x) {
return (((x * 0.3333333333333333) * (x * x)) + (x * 2.0)) / 2.0;
}
def code(x): return (((x * 0.3333333333333333) * (x * x)) + (x * 2.0)) / 2.0
function code(x) return Float64(Float64(Float64(Float64(x * 0.3333333333333333) * Float64(x * x)) + Float64(x * 2.0)) / 2.0) end
function tmp = code(x) tmp = (((x * 0.3333333333333333) * (x * x)) + (x * 2.0)) / 2.0; end
code[x_] := N[(N[(N[(N[(x * 0.3333333333333333), $MachinePrecision] * N[(x * x), $MachinePrecision]), $MachinePrecision] + N[(x * 2.0), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision]
\begin{array}{l}
\\
\frac{\left(x \cdot 0.3333333333333333\right) \cdot \left(x \cdot x\right) + x \cdot 2}{2}
\end{array}
Initial program 59.4%
Taylor expanded in x around 0 82.8%
unpow382.8%
associate-*r*82.8%
distribute-rgt-out82.8%
*-commutative82.8%
+-commutative82.8%
associate-*l*82.8%
fma-def82.8%
Simplified82.8%
fma-udef82.8%
*-commutative82.8%
Applied egg-rr82.8%
distribute-rgt-in82.8%
*-commutative82.8%
associate-*l*82.8%
*-commutative82.8%
Applied egg-rr82.8%
Final simplification82.8%
(FPCore (x) :precision binary64 (if (or (<= x -2.4) (not (<= x 2.5))) (* x (/ (* x x) 6.0)) (/ (* x 2.0) 2.0)))
double code(double x) {
double tmp;
if ((x <= -2.4) || !(x <= 2.5)) {
tmp = x * ((x * x) / 6.0);
} else {
tmp = (x * 2.0) / 2.0;
}
return tmp;
}
real(8) function code(x)
real(8), intent (in) :: x
real(8) :: tmp
if ((x <= (-2.4d0)) .or. (.not. (x <= 2.5d0))) then
tmp = x * ((x * x) / 6.0d0)
else
tmp = (x * 2.0d0) / 2.0d0
end if
code = tmp
end function
public static double code(double x) {
double tmp;
if ((x <= -2.4) || !(x <= 2.5)) {
tmp = x * ((x * x) / 6.0);
} else {
tmp = (x * 2.0) / 2.0;
}
return tmp;
}
def code(x): tmp = 0 if (x <= -2.4) or not (x <= 2.5): tmp = x * ((x * x) / 6.0) else: tmp = (x * 2.0) / 2.0 return tmp
function code(x) tmp = 0.0 if ((x <= -2.4) || !(x <= 2.5)) tmp = Float64(x * Float64(Float64(x * x) / 6.0)); else tmp = Float64(Float64(x * 2.0) / 2.0); end return tmp end
function tmp_2 = code(x) tmp = 0.0; if ((x <= -2.4) || ~((x <= 2.5))) tmp = x * ((x * x) / 6.0); else tmp = (x * 2.0) / 2.0; end tmp_2 = tmp; end
code[x_] := If[Or[LessEqual[x, -2.4], N[Not[LessEqual[x, 2.5]], $MachinePrecision]], N[(x * N[(N[(x * x), $MachinePrecision] / 6.0), $MachinePrecision]), $MachinePrecision], N[(N[(x * 2.0), $MachinePrecision] / 2.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -2.4 \lor \neg \left(x \leq 2.5\right):\\
\;\;\;\;x \cdot \frac{x \cdot x}{6}\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot 2}{2}\\
\end{array}
\end{array}
if x < -2.39999999999999991 or 2.5 < x Initial program 100.0%
Taylor expanded in x around 0 68.9%
Taylor expanded in x around inf 68.9%
Taylor expanded in x around 0 68.9%
Simplified68.9%
metadata-eval68.9%
div-inv68.9%
cube-mult68.9%
associate-/l*68.9%
Applied egg-rr68.9%
associate-/r*68.9%
associate-/l*68.9%
associate-/r/68.9%
Simplified68.9%
if -2.39999999999999991 < x < 2.5Initial program 8.9%
Taylor expanded in x around 0 99.3%
Final simplification82.4%
(FPCore (x) :precision binary64 (/ (* x (+ 2.0 (* x (* x 0.3333333333333333)))) 2.0))
double code(double x) {
return (x * (2.0 + (x * (x * 0.3333333333333333)))) / 2.0;
}
real(8) function code(x)
real(8), intent (in) :: x
code = (x * (2.0d0 + (x * (x * 0.3333333333333333d0)))) / 2.0d0
end function
public static double code(double x) {
return (x * (2.0 + (x * (x * 0.3333333333333333)))) / 2.0;
}
def code(x): return (x * (2.0 + (x * (x * 0.3333333333333333)))) / 2.0
function code(x) return Float64(Float64(x * Float64(2.0 + Float64(x * Float64(x * 0.3333333333333333)))) / 2.0) end
function tmp = code(x) tmp = (x * (2.0 + (x * (x * 0.3333333333333333)))) / 2.0; end
code[x_] := N[(N[(x * N[(2.0 + N[(x * N[(x * 0.3333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision]
\begin{array}{l}
\\
\frac{x \cdot \left(2 + x \cdot \left(x \cdot 0.3333333333333333\right)\right)}{2}
\end{array}
Initial program 59.4%
Taylor expanded in x around 0 82.8%
unpow382.8%
associate-*r*82.8%
distribute-rgt-out82.8%
*-commutative82.8%
+-commutative82.8%
associate-*l*82.8%
fma-def82.8%
Simplified82.8%
fma-udef82.8%
*-commutative82.8%
Applied egg-rr82.8%
Final simplification82.8%
(FPCore (x) :precision binary64 (/ (* x 2.0) 2.0))
double code(double x) {
return (x * 2.0) / 2.0;
}
real(8) function code(x)
real(8), intent (in) :: x
code = (x * 2.0d0) / 2.0d0
end function
public static double code(double x) {
return (x * 2.0) / 2.0;
}
def code(x): return (x * 2.0) / 2.0
function code(x) return Float64(Float64(x * 2.0) / 2.0) end
function tmp = code(x) tmp = (x * 2.0) / 2.0; end
code[x_] := N[(N[(x * 2.0), $MachinePrecision] / 2.0), $MachinePrecision]
\begin{array}{l}
\\
\frac{x \cdot 2}{2}
\end{array}
Initial program 59.4%
Taylor expanded in x around 0 47.3%
Final simplification47.3%
(FPCore (x) :precision binary64 -1.0)
double code(double x) {
return -1.0;
}
real(8) function code(x)
real(8), intent (in) :: x
code = -1.0d0
end function
public static double code(double x) {
return -1.0;
}
def code(x): return -1.0
function code(x) return -1.0 end
function tmp = code(x) tmp = -1.0; end
code[x_] := -1.0
\begin{array}{l}
\\
-1
\end{array}
Initial program 59.4%
Applied egg-rr2.8%
Final simplification2.8%
(FPCore (x) :precision binary64 0.0)
double code(double x) {
return 0.0;
}
real(8) function code(x)
real(8), intent (in) :: x
code = 0.0d0
end function
public static double code(double x) {
return 0.0;
}
def code(x): return 0.0
function code(x) return 0.0 end
function tmp = code(x) tmp = 0.0; end
code[x_] := 0.0
\begin{array}{l}
\\
0
\end{array}
Initial program 59.4%
Applied egg-rr3.1%
Final simplification3.1%
herbie shell --seed 2023181
(FPCore (x)
:name "Hyperbolic sine"
:precision binary64
(/ (- (exp x) (exp (- x))) 2.0))