
(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 (- INFINITY)) (not (<= t_0 0.0002)))
(/ t_0 2.0)
(/
(+
(* x 2.0)
(+
(* 0.3333333333333333 (pow x 3.0))
(+
(* 0.0003968253968253968 (pow x 7.0))
(* 0.016666666666666666 (pow x 5.0)))))
2.0))))
double code(double x) {
double t_0 = exp(x) - exp(-x);
double tmp;
if ((t_0 <= -((double) INFINITY)) || !(t_0 <= 0.0002)) {
tmp = t_0 / 2.0;
} else {
tmp = ((x * 2.0) + ((0.3333333333333333 * pow(x, 3.0)) + ((0.0003968253968253968 * pow(x, 7.0)) + (0.016666666666666666 * pow(x, 5.0))))) / 2.0;
}
return tmp;
}
public static double code(double x) {
double t_0 = Math.exp(x) - Math.exp(-x);
double tmp;
if ((t_0 <= -Double.POSITIVE_INFINITY) || !(t_0 <= 0.0002)) {
tmp = t_0 / 2.0;
} else {
tmp = ((x * 2.0) + ((0.3333333333333333 * Math.pow(x, 3.0)) + ((0.0003968253968253968 * Math.pow(x, 7.0)) + (0.016666666666666666 * Math.pow(x, 5.0))))) / 2.0;
}
return tmp;
}
def code(x): t_0 = math.exp(x) - math.exp(-x) tmp = 0 if (t_0 <= -math.inf) or not (t_0 <= 0.0002): tmp = t_0 / 2.0 else: tmp = ((x * 2.0) + ((0.3333333333333333 * math.pow(x, 3.0)) + ((0.0003968253968253968 * math.pow(x, 7.0)) + (0.016666666666666666 * math.pow(x, 5.0))))) / 2.0 return tmp
function code(x) t_0 = Float64(exp(x) - exp(Float64(-x))) tmp = 0.0 if ((t_0 <= Float64(-Inf)) || !(t_0 <= 0.0002)) tmp = Float64(t_0 / 2.0); else tmp = Float64(Float64(Float64(x * 2.0) + Float64(Float64(0.3333333333333333 * (x ^ 3.0)) + Float64(Float64(0.0003968253968253968 * (x ^ 7.0)) + Float64(0.016666666666666666 * (x ^ 5.0))))) / 2.0); end return tmp end
function tmp_2 = code(x) t_0 = exp(x) - exp(-x); tmp = 0.0; if ((t_0 <= -Inf) || ~((t_0 <= 0.0002))) tmp = t_0 / 2.0; else tmp = ((x * 2.0) + ((0.3333333333333333 * (x ^ 3.0)) + ((0.0003968253968253968 * (x ^ 7.0)) + (0.016666666666666666 * (x ^ 5.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, (-Infinity)], N[Not[LessEqual[t$95$0, 0.0002]], $MachinePrecision]], N[(t$95$0 / 2.0), $MachinePrecision], N[(N[(N[(x * 2.0), $MachinePrecision] + N[(N[(0.3333333333333333 * N[Power[x, 3.0], $MachinePrecision]), $MachinePrecision] + N[(N[(0.0003968253968253968 * N[Power[x, 7.0], $MachinePrecision]), $MachinePrecision] + N[(0.016666666666666666 * N[Power[x, 5.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := e^{x} - e^{-x}\\
\mathbf{if}\;t_0 \leq -\infty \lor \neg \left(t_0 \leq 0.0002\right):\\
\;\;\;\;\frac{t_0}{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot 2 + \left(0.3333333333333333 \cdot {x}^{3} + \left(0.0003968253968253968 \cdot {x}^{7} + 0.016666666666666666 \cdot {x}^{5}\right)\right)}{2}\\
\end{array}
\end{array}
if (-.f64 (exp.f64 x) (exp.f64 (neg.f64 x))) < -inf.0 or 2.0000000000000001e-4 < (-.f64 (exp.f64 x) (exp.f64 (neg.f64 x))) Initial program 100.0%
if -inf.0 < (-.f64 (exp.f64 x) (exp.f64 (neg.f64 x))) < 2.0000000000000001e-4Initial program 7.7%
Taylor expanded in x around 0 100.0%
Final simplification100.0%
(FPCore (x)
:precision binary64
(let* ((t_0 (- (exp x) (exp (- x)))))
(if (or (<= t_0 -0.02) (not (<= t_0 0.0002)))
(/ t_0 2.0)
(/ (* x (+ 2.0 (* x (* x 0.3333333333333333)))) 2.0))))
double code(double x) {
double t_0 = exp(x) - exp(-x);
double tmp;
if ((t_0 <= -0.02) || !(t_0 <= 0.0002)) {
tmp = t_0 / 2.0;
} else {
tmp = (x * (2.0 + (x * (x * 0.3333333333333333)))) / 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 <= (-0.02d0)) .or. (.not. (t_0 <= 0.0002d0))) then
tmp = t_0 / 2.0d0
else
tmp = (x * (2.0d0 + (x * (x * 0.3333333333333333d0)))) / 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 <= -0.02) || !(t_0 <= 0.0002)) {
tmp = t_0 / 2.0;
} else {
tmp = (x * (2.0 + (x * (x * 0.3333333333333333)))) / 2.0;
}
return tmp;
}
def code(x): t_0 = math.exp(x) - math.exp(-x) tmp = 0 if (t_0 <= -0.02) or not (t_0 <= 0.0002): tmp = t_0 / 2.0 else: tmp = (x * (2.0 + (x * (x * 0.3333333333333333)))) / 2.0 return tmp
function code(x) t_0 = Float64(exp(x) - exp(Float64(-x))) tmp = 0.0 if ((t_0 <= -0.02) || !(t_0 <= 0.0002)) tmp = Float64(t_0 / 2.0); else tmp = Float64(Float64(x * Float64(2.0 + Float64(x * Float64(x * 0.3333333333333333)))) / 2.0); end return tmp end
function tmp_2 = code(x) t_0 = exp(x) - exp(-x); tmp = 0.0; if ((t_0 <= -0.02) || ~((t_0 <= 0.0002))) tmp = t_0 / 2.0; else tmp = (x * (2.0 + (x * (x * 0.3333333333333333)))) / 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, -0.02], N[Not[LessEqual[t$95$0, 0.0002]], $MachinePrecision]], N[(t$95$0 / 2.0), $MachinePrecision], N[(N[(x * N[(2.0 + N[(x * N[(x * 0.3333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := e^{x} - e^{-x}\\
\mathbf{if}\;t_0 \leq -0.02 \lor \neg \left(t_0 \leq 0.0002\right):\\
\;\;\;\;\frac{t_0}{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot \left(2 + x \cdot \left(x \cdot 0.3333333333333333\right)\right)}{2}\\
\end{array}
\end{array}
if (-.f64 (exp.f64 x) (exp.f64 (neg.f64 x))) < -0.0200000000000000004 or 2.0000000000000001e-4 < (-.f64 (exp.f64 x) (exp.f64 (neg.f64 x))) Initial program 99.9%
if -0.0200000000000000004 < (-.f64 (exp.f64 x) (exp.f64 (neg.f64 x))) < 2.0000000000000001e-4Initial program 7.0%
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%
Applied egg-rr100.0%
Final simplification100.0%
(FPCore (x)
:precision binary64
(if (<= x -2e+158)
(* 0.3333333333333333 (* x (* 0.5 (* x x))))
(if (<= x 1e+47)
(/
(*
x
(/
(- 4.0 (* (pow x 4.0) 0.1111111111111111))
(- 2.0 (* 0.3333333333333333 (* x x)))))
2.0)
(sqrt (* (pow x 6.0) 0.027777777777777776)))))
double code(double x) {
double tmp;
if (x <= -2e+158) {
tmp = 0.3333333333333333 * (x * (0.5 * (x * x)));
} else if (x <= 1e+47) {
tmp = (x * ((4.0 - (pow(x, 4.0) * 0.1111111111111111)) / (2.0 - (0.3333333333333333 * (x * x))))) / 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) :: tmp
if (x <= (-2d+158)) then
tmp = 0.3333333333333333d0 * (x * (0.5d0 * (x * x)))
else if (x <= 1d+47) then
tmp = (x * ((4.0d0 - ((x ** 4.0d0) * 0.1111111111111111d0)) / (2.0d0 - (0.3333333333333333d0 * (x * x))))) / 2.0d0
else
tmp = sqrt(((x ** 6.0d0) * 0.027777777777777776d0))
end if
code = tmp
end function
public static double code(double x) {
double tmp;
if (x <= -2e+158) {
tmp = 0.3333333333333333 * (x * (0.5 * (x * x)));
} else if (x <= 1e+47) {
tmp = (x * ((4.0 - (Math.pow(x, 4.0) * 0.1111111111111111)) / (2.0 - (0.3333333333333333 * (x * x))))) / 2.0;
} else {
tmp = Math.sqrt((Math.pow(x, 6.0) * 0.027777777777777776));
}
return tmp;
}
def code(x): tmp = 0 if x <= -2e+158: tmp = 0.3333333333333333 * (x * (0.5 * (x * x))) elif x <= 1e+47: tmp = (x * ((4.0 - (math.pow(x, 4.0) * 0.1111111111111111)) / (2.0 - (0.3333333333333333 * (x * x))))) / 2.0 else: tmp = math.sqrt((math.pow(x, 6.0) * 0.027777777777777776)) return tmp
function code(x) tmp = 0.0 if (x <= -2e+158) tmp = Float64(0.3333333333333333 * Float64(x * Float64(0.5 * Float64(x * x)))); elseif (x <= 1e+47) tmp = Float64(Float64(x * Float64(Float64(4.0 - Float64((x ^ 4.0) * 0.1111111111111111)) / Float64(2.0 - Float64(0.3333333333333333 * Float64(x * x))))) / 2.0); else tmp = sqrt(Float64((x ^ 6.0) * 0.027777777777777776)); end return tmp end
function tmp_2 = code(x) tmp = 0.0; if (x <= -2e+158) tmp = 0.3333333333333333 * (x * (0.5 * (x * x))); elseif (x <= 1e+47) tmp = (x * ((4.0 - ((x ^ 4.0) * 0.1111111111111111)) / (2.0 - (0.3333333333333333 * (x * x))))) / 2.0; else tmp = sqrt(((x ^ 6.0) * 0.027777777777777776)); end tmp_2 = tmp; end
code[x_] := If[LessEqual[x, -2e+158], N[(0.3333333333333333 * N[(x * N[(0.5 * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 1e+47], N[(N[(x * N[(N[(4.0 - N[(N[Power[x, 4.0], $MachinePrecision] * 0.1111111111111111), $MachinePrecision]), $MachinePrecision] / N[(2.0 - N[(0.3333333333333333 * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision], N[Sqrt[N[(N[Power[x, 6.0], $MachinePrecision] * 0.027777777777777776), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -2 \cdot 10^{+158}:\\
\;\;\;\;0.3333333333333333 \cdot \left(x \cdot \left(0.5 \cdot \left(x \cdot x\right)\right)\right)\\
\mathbf{elif}\;x \leq 10^{+47}:\\
\;\;\;\;\frac{x \cdot \frac{4 - {x}^{4} \cdot 0.1111111111111111}{2 - 0.3333333333333333 \cdot \left(x \cdot x\right)}}{2}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{{x}^{6} \cdot 0.027777777777777776}\\
\end{array}
\end{array}
if x < -1.99999999999999991e158Initial program 100.0%
Taylor expanded in x around 0 100.0%
Taylor expanded in x around inf 100.0%
associate-/l*100.0%
div-inv100.0%
Applied egg-rr100.0%
associate-/r/100.0%
unpow3100.0%
associate-*r*100.0%
metadata-eval100.0%
Applied egg-rr100.0%
if -1.99999999999999991e158 < x < 1e47Initial program 31.8%
Taylor expanded in x around 0 79.3%
+-commutative79.3%
unpow379.3%
associate-*r*79.3%
fma-def79.3%
add-log-exp30.6%
*-commutative30.6%
exp-lft-sqr30.5%
log-prod30.5%
add-log-exp39.7%
add-log-exp79.3%
Applied egg-rr79.3%
fma-udef79.3%
*-commutative79.3%
associate-*r*79.3%
count-279.3%
distribute-rgt-in79.3%
fma-udef79.3%
*-commutative79.3%
fma-udef79.3%
associate-*r*79.3%
*-commutative79.3%
fma-def79.3%
Applied egg-rr79.3%
fma-udef79.3%
*-commutative79.3%
associate-*r*79.3%
+-commutative79.3%
flip-+82.3%
metadata-eval82.3%
associate-*r*82.3%
associate-*r*82.3%
swap-sqr82.3%
pow282.3%
pow282.3%
pow-prod-up82.3%
metadata-eval82.3%
metadata-eval82.3%
associate-*r*82.3%
*-commutative82.3%
Applied egg-rr82.3%
if 1e47 < x Initial program 100.0%
Taylor expanded in x around 0 84.1%
Taylor expanded in x around inf 84.1%
add-sqr-sqrt84.1%
sqrt-unprod100.0%
div-inv100.0%
div-inv100.0%
swap-sqr100.0%
*-commutative100.0%
*-commutative100.0%
swap-sqr100.0%
pow-prod-up100.0%
metadata-eval100.0%
metadata-eval100.0%
metadata-eval100.0%
metadata-eval100.0%
metadata-eval100.0%
Applied egg-rr100.0%
Simplified100.0%
Final simplification87.2%
(FPCore (x)
:precision binary64
(if (or (<= x -2e+158) (not (<= x 1e+102)))
(* 0.3333333333333333 (* x (* 0.5 (* x x))))
(/
(*
x
(/
(- 4.0 (* (pow x 4.0) 0.1111111111111111))
(- 2.0 (* 0.3333333333333333 (* x x)))))
2.0)))
double code(double x) {
double tmp;
if ((x <= -2e+158) || !(x <= 1e+102)) {
tmp = 0.3333333333333333 * (x * (0.5 * (x * x)));
} else {
tmp = (x * ((4.0 - (pow(x, 4.0) * 0.1111111111111111)) / (2.0 - (0.3333333333333333 * (x * x))))) / 2.0;
}
return tmp;
}
real(8) function code(x)
real(8), intent (in) :: x
real(8) :: tmp
if ((x <= (-2d+158)) .or. (.not. (x <= 1d+102))) then
tmp = 0.3333333333333333d0 * (x * (0.5d0 * (x * x)))
else
tmp = (x * ((4.0d0 - ((x ** 4.0d0) * 0.1111111111111111d0)) / (2.0d0 - (0.3333333333333333d0 * (x * x))))) / 2.0d0
end if
code = tmp
end function
public static double code(double x) {
double tmp;
if ((x <= -2e+158) || !(x <= 1e+102)) {
tmp = 0.3333333333333333 * (x * (0.5 * (x * x)));
} else {
tmp = (x * ((4.0 - (Math.pow(x, 4.0) * 0.1111111111111111)) / (2.0 - (0.3333333333333333 * (x * x))))) / 2.0;
}
return tmp;
}
def code(x): tmp = 0 if (x <= -2e+158) or not (x <= 1e+102): tmp = 0.3333333333333333 * (x * (0.5 * (x * x))) else: tmp = (x * ((4.0 - (math.pow(x, 4.0) * 0.1111111111111111)) / (2.0 - (0.3333333333333333 * (x * x))))) / 2.0 return tmp
function code(x) tmp = 0.0 if ((x <= -2e+158) || !(x <= 1e+102)) tmp = Float64(0.3333333333333333 * Float64(x * Float64(0.5 * Float64(x * x)))); else tmp = Float64(Float64(x * Float64(Float64(4.0 - Float64((x ^ 4.0) * 0.1111111111111111)) / Float64(2.0 - Float64(0.3333333333333333 * Float64(x * x))))) / 2.0); end return tmp end
function tmp_2 = code(x) tmp = 0.0; if ((x <= -2e+158) || ~((x <= 1e+102))) tmp = 0.3333333333333333 * (x * (0.5 * (x * x))); else tmp = (x * ((4.0 - ((x ^ 4.0) * 0.1111111111111111)) / (2.0 - (0.3333333333333333 * (x * x))))) / 2.0; end tmp_2 = tmp; end
code[x_] := If[Or[LessEqual[x, -2e+158], N[Not[LessEqual[x, 1e+102]], $MachinePrecision]], N[(0.3333333333333333 * N[(x * N[(0.5 * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x * N[(N[(4.0 - N[(N[Power[x, 4.0], $MachinePrecision] * 0.1111111111111111), $MachinePrecision]), $MachinePrecision] / N[(2.0 - N[(0.3333333333333333 * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -2 \cdot 10^{+158} \lor \neg \left(x \leq 10^{+102}\right):\\
\;\;\;\;0.3333333333333333 \cdot \left(x \cdot \left(0.5 \cdot \left(x \cdot x\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot \frac{4 - {x}^{4} \cdot 0.1111111111111111}{2 - 0.3333333333333333 \cdot \left(x \cdot x\right)}}{2}\\
\end{array}
\end{array}
if x < -1.99999999999999991e158 or 9.99999999999999977e101 < x Initial program 100.0%
Taylor expanded in x around 0 100.0%
Taylor expanded in x around inf 100.0%
associate-/l*100.0%
div-inv100.0%
Applied egg-rr100.0%
associate-/r/100.0%
unpow3100.0%
associate-*r*100.0%
metadata-eval100.0%
Applied egg-rr100.0%
if -1.99999999999999991e158 < x < 9.99999999999999977e101Initial program 34.6%
Taylor expanded in x around 0 76.3%
+-commutative76.3%
unpow376.3%
associate-*r*76.3%
fma-def76.3%
add-log-exp33.5%
*-commutative33.5%
exp-lft-sqr33.4%
log-prod33.4%
add-log-exp42.2%
add-log-exp76.3%
Applied egg-rr76.3%
fma-udef76.3%
*-commutative76.3%
associate-*r*76.3%
count-276.3%
distribute-rgt-in76.3%
fma-udef76.3%
*-commutative76.3%
fma-udef76.3%
associate-*r*76.3%
*-commutative76.3%
fma-def76.3%
Applied egg-rr76.3%
fma-udef76.3%
*-commutative76.3%
associate-*r*76.3%
+-commutative76.3%
flip-+80.0%
metadata-eval80.0%
associate-*r*80.0%
associate-*r*80.0%
swap-sqr80.0%
pow280.0%
pow280.0%
pow-prod-up80.0%
metadata-eval80.0%
metadata-eval80.0%
associate-*r*80.0%
*-commutative80.0%
Applied egg-rr80.0%
Final simplification85.0%
(FPCore (x) :precision binary64 (if (or (<= x -2.5) (not (<= x 2.4))) (* 0.3333333333333333 (* x (* 0.5 (* x x)))) (/ (* x 2.0) 2.0)))
double code(double x) {
double tmp;
if ((x <= -2.5) || !(x <= 2.4)) {
tmp = 0.3333333333333333 * (x * (0.5 * (x * x)));
} 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.5d0)) .or. (.not. (x <= 2.4d0))) then
tmp = 0.3333333333333333d0 * (x * (0.5d0 * (x * x)))
else
tmp = (x * 2.0d0) / 2.0d0
end if
code = tmp
end function
public static double code(double x) {
double tmp;
if ((x <= -2.5) || !(x <= 2.4)) {
tmp = 0.3333333333333333 * (x * (0.5 * (x * x)));
} else {
tmp = (x * 2.0) / 2.0;
}
return tmp;
}
def code(x): tmp = 0 if (x <= -2.5) or not (x <= 2.4): tmp = 0.3333333333333333 * (x * (0.5 * (x * x))) else: tmp = (x * 2.0) / 2.0 return tmp
function code(x) tmp = 0.0 if ((x <= -2.5) || !(x <= 2.4)) tmp = Float64(0.3333333333333333 * Float64(x * Float64(0.5 * Float64(x * x)))); else tmp = Float64(Float64(x * 2.0) / 2.0); end return tmp end
function tmp_2 = code(x) tmp = 0.0; if ((x <= -2.5) || ~((x <= 2.4))) tmp = 0.3333333333333333 * (x * (0.5 * (x * x))); else tmp = (x * 2.0) / 2.0; end tmp_2 = tmp; end
code[x_] := If[Or[LessEqual[x, -2.5], N[Not[LessEqual[x, 2.4]], $MachinePrecision]], N[(0.3333333333333333 * N[(x * N[(0.5 * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x * 2.0), $MachinePrecision] / 2.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -2.5 \lor \neg \left(x \leq 2.4\right):\\
\;\;\;\;0.3333333333333333 \cdot \left(x \cdot \left(0.5 \cdot \left(x \cdot x\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot 2}{2}\\
\end{array}
\end{array}
if x < -2.5 or 2.39999999999999991 < x Initial program 100.0%
Taylor expanded in x around 0 62.3%
Taylor expanded in x around inf 62.3%
associate-/l*62.3%
div-inv62.3%
Applied egg-rr62.3%
associate-/r/62.3%
unpow362.3%
associate-*r*62.3%
metadata-eval62.3%
Applied egg-rr62.3%
if -2.5 < x < 2.39999999999999991Initial program 7.7%
Taylor expanded in x around 0 99.3%
Final simplification82.0%
(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 51.0%
Taylor expanded in x around 0 82.2%
unpow382.2%
associate-*r*82.2%
distribute-rgt-out82.2%
*-commutative82.2%
+-commutative82.2%
associate-*l*82.2%
fma-def82.2%
Simplified82.2%
fma-udef82.2%
Applied egg-rr82.2%
Final simplification82.2%
(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 51.0%
Taylor expanded in x around 0 55.3%
Final simplification55.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 51.0%
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 51.0%
Applied egg-rr3.6%
Final simplification3.6%
herbie shell --seed 2023221
(FPCore (x)
:name "Hyperbolic sine"
:precision binary64
(/ (- (exp x) (exp (- x))) 2.0))