
(FPCore (x eps) :precision binary64 (- (tan (+ x eps)) (tan x)))
double code(double x, double eps) {
return tan((x + eps)) - tan(x);
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
code = tan((x + eps)) - tan(x)
end function
public static double code(double x, double eps) {
return Math.tan((x + eps)) - Math.tan(x);
}
def code(x, eps): return math.tan((x + eps)) - math.tan(x)
function code(x, eps) return Float64(tan(Float64(x + eps)) - tan(x)) end
function tmp = code(x, eps) tmp = tan((x + eps)) - tan(x); end
code[x_, eps_] := N[(N[Tan[N[(x + eps), $MachinePrecision]], $MachinePrecision] - N[Tan[x], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\tan \left(x + \varepsilon\right) - \tan x
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 12 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x eps) :precision binary64 (- (tan (+ x eps)) (tan x)))
double code(double x, double eps) {
return tan((x + eps)) - tan(x);
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
code = tan((x + eps)) - tan(x)
end function
public static double code(double x, double eps) {
return Math.tan((x + eps)) - Math.tan(x);
}
def code(x, eps): return math.tan((x + eps)) - math.tan(x)
function code(x, eps) return Float64(tan(Float64(x + eps)) - tan(x)) end
function tmp = code(x, eps) tmp = tan((x + eps)) - tan(x); end
code[x_, eps_] := N[(N[Tan[N[(x + eps), $MachinePrecision]], $MachinePrecision] - N[Tan[x], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\tan \left(x + \varepsilon\right) - \tan x
\end{array}
(FPCore (x eps)
:precision binary64
(let* ((t_0 (fma eps (tan x) 1.0))
(t_1 (fma -0.3333333333333333 (pow (tan x) 2.0) -0.3333333333333333)))
(*
(fma
(* t_0 (tan x))
(tan x)
(-
t_0
(*
(* eps eps)
(fma
t_1
(* eps (tan x))
(* t_0 (- t_1 (fma (tan x) (tan x) (pow (tan x) 4.0))))))))
eps)))
double code(double x, double eps) {
double t_0 = fma(eps, tan(x), 1.0);
double t_1 = fma(-0.3333333333333333, pow(tan(x), 2.0), -0.3333333333333333);
return fma((t_0 * tan(x)), tan(x), (t_0 - ((eps * eps) * fma(t_1, (eps * tan(x)), (t_0 * (t_1 - fma(tan(x), tan(x), pow(tan(x), 4.0)))))))) * eps;
}
function code(x, eps) t_0 = fma(eps, tan(x), 1.0) t_1 = fma(-0.3333333333333333, (tan(x) ^ 2.0), -0.3333333333333333) return Float64(fma(Float64(t_0 * tan(x)), tan(x), Float64(t_0 - Float64(Float64(eps * eps) * fma(t_1, Float64(eps * tan(x)), Float64(t_0 * Float64(t_1 - fma(tan(x), tan(x), (tan(x) ^ 4.0)))))))) * eps) end
code[x_, eps_] := Block[{t$95$0 = N[(eps * N[Tan[x], $MachinePrecision] + 1.0), $MachinePrecision]}, Block[{t$95$1 = N[(-0.3333333333333333 * N[Power[N[Tan[x], $MachinePrecision], 2.0], $MachinePrecision] + -0.3333333333333333), $MachinePrecision]}, N[(N[(N[(t$95$0 * N[Tan[x], $MachinePrecision]), $MachinePrecision] * N[Tan[x], $MachinePrecision] + N[(t$95$0 - N[(N[(eps * eps), $MachinePrecision] * N[(t$95$1 * N[(eps * N[Tan[x], $MachinePrecision]), $MachinePrecision] + N[(t$95$0 * N[(t$95$1 - N[(N[Tan[x], $MachinePrecision] * N[Tan[x], $MachinePrecision] + N[Power[N[Tan[x], $MachinePrecision], 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * eps), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(\varepsilon, \tan x, 1\right)\\
t_1 := \mathsf{fma}\left(-0.3333333333333333, {\tan x}^{2}, -0.3333333333333333\right)\\
\mathsf{fma}\left(t\_0 \cdot \tan x, \tan x, t\_0 - \left(\varepsilon \cdot \varepsilon\right) \cdot \mathsf{fma}\left(t\_1, \varepsilon \cdot \tan x, t\_0 \cdot \left(t\_1 - \mathsf{fma}\left(\tan x, \tan x, {\tan x}^{4}\right)\right)\right)\right) \cdot \varepsilon
\end{array}
\end{array}
Initial program 60.8%
Taylor expanded in eps around 0
Applied rewrites100.0%
Applied rewrites100.0%
Applied rewrites100.0%
Applied rewrites100.0%
Final simplification100.0%
(FPCore (x eps)
:precision binary64
(let* ((t_0 (fma eps (tan x) 1.0))
(t_1 (fma -0.3333333333333333 (pow (tan x) 2.0) -0.3333333333333333)))
(*
(fma
(fma (tan x) (tan x) 1.0)
t_0
(*
(* (- eps) eps)
(fma
t_1
(* eps (tan x))
(* t_0 (- t_1 (fma (tan x) (tan x) (pow (tan x) 4.0)))))))
eps)))
double code(double x, double eps) {
double t_0 = fma(eps, tan(x), 1.0);
double t_1 = fma(-0.3333333333333333, pow(tan(x), 2.0), -0.3333333333333333);
return fma(fma(tan(x), tan(x), 1.0), t_0, ((-eps * eps) * fma(t_1, (eps * tan(x)), (t_0 * (t_1 - fma(tan(x), tan(x), pow(tan(x), 4.0))))))) * eps;
}
function code(x, eps) t_0 = fma(eps, tan(x), 1.0) t_1 = fma(-0.3333333333333333, (tan(x) ^ 2.0), -0.3333333333333333) return Float64(fma(fma(tan(x), tan(x), 1.0), t_0, Float64(Float64(Float64(-eps) * eps) * fma(t_1, Float64(eps * tan(x)), Float64(t_0 * Float64(t_1 - fma(tan(x), tan(x), (tan(x) ^ 4.0))))))) * eps) end
code[x_, eps_] := Block[{t$95$0 = N[(eps * N[Tan[x], $MachinePrecision] + 1.0), $MachinePrecision]}, Block[{t$95$1 = N[(-0.3333333333333333 * N[Power[N[Tan[x], $MachinePrecision], 2.0], $MachinePrecision] + -0.3333333333333333), $MachinePrecision]}, N[(N[(N[(N[Tan[x], $MachinePrecision] * N[Tan[x], $MachinePrecision] + 1.0), $MachinePrecision] * t$95$0 + N[(N[((-eps) * eps), $MachinePrecision] * N[(t$95$1 * N[(eps * N[Tan[x], $MachinePrecision]), $MachinePrecision] + N[(t$95$0 * N[(t$95$1 - N[(N[Tan[x], $MachinePrecision] * N[Tan[x], $MachinePrecision] + N[Power[N[Tan[x], $MachinePrecision], 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * eps), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(\varepsilon, \tan x, 1\right)\\
t_1 := \mathsf{fma}\left(-0.3333333333333333, {\tan x}^{2}, -0.3333333333333333\right)\\
\mathsf{fma}\left(\mathsf{fma}\left(\tan x, \tan x, 1\right), t\_0, \left(\left(-\varepsilon\right) \cdot \varepsilon\right) \cdot \mathsf{fma}\left(t\_1, \varepsilon \cdot \tan x, t\_0 \cdot \left(t\_1 - \mathsf{fma}\left(\tan x, \tan x, {\tan x}^{4}\right)\right)\right)\right) \cdot \varepsilon
\end{array}
\end{array}
Initial program 60.8%
Taylor expanded in eps around 0
Applied rewrites100.0%
Applied rewrites100.0%
Applied rewrites100.0%
Applied rewrites100.0%
Final simplification100.0%
(FPCore (x eps)
:precision binary64
(let* ((t_0 (* (fma (tan x) (tan x) 1.0) (fma eps (tan x) 1.0)))
(t_1
(*
(fma
(fma 0.6666666666666666 eps (* 1.3333333333333333 x))
x
0.3333333333333333)
(* eps eps))))
(/
(* (+ (pow t_0 3.0) (pow t_1 3.0)) eps)
(fma t_0 (- t_0 t_1) (pow t_1 2.0)))))
double code(double x, double eps) {
double t_0 = fma(tan(x), tan(x), 1.0) * fma(eps, tan(x), 1.0);
double t_1 = fma(fma(0.6666666666666666, eps, (1.3333333333333333 * x)), x, 0.3333333333333333) * (eps * eps);
return ((pow(t_0, 3.0) + pow(t_1, 3.0)) * eps) / fma(t_0, (t_0 - t_1), pow(t_1, 2.0));
}
function code(x, eps) t_0 = Float64(fma(tan(x), tan(x), 1.0) * fma(eps, tan(x), 1.0)) t_1 = Float64(fma(fma(0.6666666666666666, eps, Float64(1.3333333333333333 * x)), x, 0.3333333333333333) * Float64(eps * eps)) return Float64(Float64(Float64((t_0 ^ 3.0) + (t_1 ^ 3.0)) * eps) / fma(t_0, Float64(t_0 - t_1), (t_1 ^ 2.0))) end
code[x_, eps_] := Block[{t$95$0 = N[(N[(N[Tan[x], $MachinePrecision] * N[Tan[x], $MachinePrecision] + 1.0), $MachinePrecision] * N[(eps * N[Tan[x], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(N[(0.6666666666666666 * eps + N[(1.3333333333333333 * x), $MachinePrecision]), $MachinePrecision] * x + 0.3333333333333333), $MachinePrecision] * N[(eps * eps), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[(N[Power[t$95$0, 3.0], $MachinePrecision] + N[Power[t$95$1, 3.0], $MachinePrecision]), $MachinePrecision] * eps), $MachinePrecision] / N[(t$95$0 * N[(t$95$0 - t$95$1), $MachinePrecision] + N[Power[t$95$1, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(\tan x, \tan x, 1\right) \cdot \mathsf{fma}\left(\varepsilon, \tan x, 1\right)\\
t_1 := \mathsf{fma}\left(\mathsf{fma}\left(0.6666666666666666, \varepsilon, 1.3333333333333333 \cdot x\right), x, 0.3333333333333333\right) \cdot \left(\varepsilon \cdot \varepsilon\right)\\
\frac{\left({t\_0}^{3} + {t\_1}^{3}\right) \cdot \varepsilon}{\mathsf{fma}\left(t\_0, t\_0 - t\_1, {t\_1}^{2}\right)}
\end{array}
\end{array}
Initial program 60.8%
Taylor expanded in eps around 0
Applied rewrites100.0%
Taylor expanded in x around 0
Applied rewrites99.8%
Applied rewrites99.8%
Applied rewrites99.8%
(FPCore (x eps)
:precision binary64
(*
(fma
(- (pow (* eps (tan x)) 2.0) 1.0)
(* (pow (fma eps (tan x) -1.0) -1.0) (fma (tan x) (tan x) 1.0))
(*
(fma
(fma 0.6666666666666666 eps (* 1.3333333333333333 x))
x
0.3333333333333333)
(* eps eps)))
eps))
double code(double x, double eps) {
return fma((pow((eps * tan(x)), 2.0) - 1.0), (pow(fma(eps, tan(x), -1.0), -1.0) * fma(tan(x), tan(x), 1.0)), (fma(fma(0.6666666666666666, eps, (1.3333333333333333 * x)), x, 0.3333333333333333) * (eps * eps))) * eps;
}
function code(x, eps) return Float64(fma(Float64((Float64(eps * tan(x)) ^ 2.0) - 1.0), Float64((fma(eps, tan(x), -1.0) ^ -1.0) * fma(tan(x), tan(x), 1.0)), Float64(fma(fma(0.6666666666666666, eps, Float64(1.3333333333333333 * x)), x, 0.3333333333333333) * Float64(eps * eps))) * eps) end
code[x_, eps_] := N[(N[(N[(N[Power[N[(eps * N[Tan[x], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] - 1.0), $MachinePrecision] * N[(N[Power[N[(eps * N[Tan[x], $MachinePrecision] + -1.0), $MachinePrecision], -1.0], $MachinePrecision] * N[(N[Tan[x], $MachinePrecision] * N[Tan[x], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(0.6666666666666666 * eps + N[(1.3333333333333333 * x), $MachinePrecision]), $MachinePrecision] * x + 0.3333333333333333), $MachinePrecision] * N[(eps * eps), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * eps), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left({\left(\varepsilon \cdot \tan x\right)}^{2} - 1, {\left(\mathsf{fma}\left(\varepsilon, \tan x, -1\right)\right)}^{-1} \cdot \mathsf{fma}\left(\tan x, \tan x, 1\right), \mathsf{fma}\left(\mathsf{fma}\left(0.6666666666666666, \varepsilon, 1.3333333333333333 \cdot x\right), x, 0.3333333333333333\right) \cdot \left(\varepsilon \cdot \varepsilon\right)\right) \cdot \varepsilon
\end{array}
Initial program 60.8%
Taylor expanded in eps around 0
Applied rewrites100.0%
Taylor expanded in x around 0
Applied rewrites99.8%
Applied rewrites99.8%
Applied rewrites99.8%
(FPCore (x eps)
:precision binary64
(*
(fma
(*
(fma
(fma 0.6666666666666666 eps (* 1.3333333333333333 x))
x
0.3333333333333333)
eps)
eps
(* (fma (tan x) (tan x) 1.0) (fma eps (tan x) 1.0)))
eps))
double code(double x, double eps) {
return fma((fma(fma(0.6666666666666666, eps, (1.3333333333333333 * x)), x, 0.3333333333333333) * eps), eps, (fma(tan(x), tan(x), 1.0) * fma(eps, tan(x), 1.0))) * eps;
}
function code(x, eps) return Float64(fma(Float64(fma(fma(0.6666666666666666, eps, Float64(1.3333333333333333 * x)), x, 0.3333333333333333) * eps), eps, Float64(fma(tan(x), tan(x), 1.0) * fma(eps, tan(x), 1.0))) * eps) end
code[x_, eps_] := N[(N[(N[(N[(N[(0.6666666666666666 * eps + N[(1.3333333333333333 * x), $MachinePrecision]), $MachinePrecision] * x + 0.3333333333333333), $MachinePrecision] * eps), $MachinePrecision] * eps + N[(N[(N[Tan[x], $MachinePrecision] * N[Tan[x], $MachinePrecision] + 1.0), $MachinePrecision] * N[(eps * N[Tan[x], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * eps), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(\mathsf{fma}\left(\mathsf{fma}\left(0.6666666666666666, \varepsilon, 1.3333333333333333 \cdot x\right), x, 0.3333333333333333\right) \cdot \varepsilon, \varepsilon, \mathsf{fma}\left(\tan x, \tan x, 1\right) \cdot \mathsf{fma}\left(\varepsilon, \tan x, 1\right)\right) \cdot \varepsilon
\end{array}
Initial program 60.8%
Taylor expanded in eps around 0
Applied rewrites100.0%
Taylor expanded in x around 0
Applied rewrites99.8%
Applied rewrites99.8%
(FPCore (x eps) :precision binary64 (* (fma (* eps eps) 0.3333333333333333 (* (fma eps (tan x) 1.0) (fma (tan x) (tan x) 1.0))) eps))
double code(double x, double eps) {
return fma((eps * eps), 0.3333333333333333, (fma(eps, tan(x), 1.0) * fma(tan(x), tan(x), 1.0))) * eps;
}
function code(x, eps) return Float64(fma(Float64(eps * eps), 0.3333333333333333, Float64(fma(eps, tan(x), 1.0) * fma(tan(x), tan(x), 1.0))) * eps) end
code[x_, eps_] := N[(N[(N[(eps * eps), $MachinePrecision] * 0.3333333333333333 + N[(N[(eps * N[Tan[x], $MachinePrecision] + 1.0), $MachinePrecision] * N[(N[Tan[x], $MachinePrecision] * N[Tan[x], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * eps), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(\varepsilon \cdot \varepsilon, 0.3333333333333333, \mathsf{fma}\left(\varepsilon, \tan x, 1\right) \cdot \mathsf{fma}\left(\tan x, \tan x, 1\right)\right) \cdot \varepsilon
\end{array}
Initial program 60.8%
Taylor expanded in eps around 0
Applied rewrites100.0%
Applied rewrites100.0%
Taylor expanded in x around 0
Applied rewrites99.8%
(FPCore (x eps)
:precision binary64
(fma
(*
eps
(fma
(fma (* eps eps) 1.3333333333333333 1.0)
x
(fma (pow eps 3.0) 0.6666666666666666 eps)))
x
(* (fma (* eps eps) 0.3333333333333333 1.0) eps)))
double code(double x, double eps) {
return fma((eps * fma(fma((eps * eps), 1.3333333333333333, 1.0), x, fma(pow(eps, 3.0), 0.6666666666666666, eps))), x, (fma((eps * eps), 0.3333333333333333, 1.0) * eps));
}
function code(x, eps) return fma(Float64(eps * fma(fma(Float64(eps * eps), 1.3333333333333333, 1.0), x, fma((eps ^ 3.0), 0.6666666666666666, eps))), x, Float64(fma(Float64(eps * eps), 0.3333333333333333, 1.0) * eps)) end
code[x_, eps_] := N[(N[(eps * N[(N[(N[(eps * eps), $MachinePrecision] * 1.3333333333333333 + 1.0), $MachinePrecision] * x + N[(N[Power[eps, 3.0], $MachinePrecision] * 0.6666666666666666 + eps), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * x + N[(N[(N[(eps * eps), $MachinePrecision] * 0.3333333333333333 + 1.0), $MachinePrecision] * eps), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(\varepsilon \cdot \mathsf{fma}\left(\mathsf{fma}\left(\varepsilon \cdot \varepsilon, 1.3333333333333333, 1\right), x, \mathsf{fma}\left({\varepsilon}^{3}, 0.6666666666666666, \varepsilon\right)\right), x, \mathsf{fma}\left(\varepsilon \cdot \varepsilon, 0.3333333333333333, 1\right) \cdot \varepsilon\right)
\end{array}
Initial program 60.8%
Taylor expanded in eps around 0
Applied rewrites100.0%
Taylor expanded in x around 0
Applied rewrites99.8%
Taylor expanded in x around 0
Applied rewrites99.2%
Taylor expanded in x around 0
Applied rewrites99.2%
(FPCore (x eps)
:precision binary64
(*
(fma
(fma
(fma
(* 0.6666666666666666 eps)
x
(fma (* x x) 1.3333333333333333 0.3333333333333333))
eps
x)
eps
(fma x x 1.0))
eps))
double code(double x, double eps) {
return fma(fma(fma((0.6666666666666666 * eps), x, fma((x * x), 1.3333333333333333, 0.3333333333333333)), eps, x), eps, fma(x, x, 1.0)) * eps;
}
function code(x, eps) return Float64(fma(fma(fma(Float64(0.6666666666666666 * eps), x, fma(Float64(x * x), 1.3333333333333333, 0.3333333333333333)), eps, x), eps, fma(x, x, 1.0)) * eps) end
code[x_, eps_] := N[(N[(N[(N[(N[(0.6666666666666666 * eps), $MachinePrecision] * x + N[(N[(x * x), $MachinePrecision] * 1.3333333333333333 + 0.3333333333333333), $MachinePrecision]), $MachinePrecision] * eps + x), $MachinePrecision] * eps + N[(x * x + 1.0), $MachinePrecision]), $MachinePrecision] * eps), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(\mathsf{fma}\left(\mathsf{fma}\left(0.6666666666666666 \cdot \varepsilon, x, \mathsf{fma}\left(x \cdot x, 1.3333333333333333, 0.3333333333333333\right)\right), \varepsilon, x\right), \varepsilon, \mathsf{fma}\left(x, x, 1\right)\right) \cdot \varepsilon
\end{array}
Initial program 60.8%
Taylor expanded in eps around 0
Applied rewrites100.0%
Taylor expanded in x around 0
Applied rewrites99.8%
Taylor expanded in x around 0
Applied rewrites99.2%
Taylor expanded in eps around 0
Applied rewrites99.2%
(FPCore (x eps) :precision binary64 (* (fma (fma (fma (* x x) 1.3333333333333333 0.3333333333333333) eps x) eps (fma x x 1.0)) eps))
double code(double x, double eps) {
return fma(fma(fma((x * x), 1.3333333333333333, 0.3333333333333333), eps, x), eps, fma(x, x, 1.0)) * eps;
}
function code(x, eps) return Float64(fma(fma(fma(Float64(x * x), 1.3333333333333333, 0.3333333333333333), eps, x), eps, fma(x, x, 1.0)) * eps) end
code[x_, eps_] := N[(N[(N[(N[(N[(x * x), $MachinePrecision] * 1.3333333333333333 + 0.3333333333333333), $MachinePrecision] * eps + x), $MachinePrecision] * eps + N[(x * x + 1.0), $MachinePrecision]), $MachinePrecision] * eps), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(\mathsf{fma}\left(\mathsf{fma}\left(x \cdot x, 1.3333333333333333, 0.3333333333333333\right), \varepsilon, x\right), \varepsilon, \mathsf{fma}\left(x, x, 1\right)\right) \cdot \varepsilon
\end{array}
Initial program 60.8%
Taylor expanded in eps around 0
Applied rewrites100.0%
Taylor expanded in x around 0
Applied rewrites99.8%
Taylor expanded in x around 0
Applied rewrites99.2%
Taylor expanded in eps around 0
Applied rewrites99.2%
(FPCore (x eps) :precision binary64 (* (fma x (+ eps x) 1.0) eps))
double code(double x, double eps) {
return fma(x, (eps + x), 1.0) * eps;
}
function code(x, eps) return Float64(fma(x, Float64(eps + x), 1.0) * eps) end
code[x_, eps_] := N[(N[(x * N[(eps + x), $MachinePrecision] + 1.0), $MachinePrecision] * eps), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(x, \varepsilon + x, 1\right) \cdot \varepsilon
\end{array}
Initial program 60.8%
Taylor expanded in eps around 0
Applied rewrites100.0%
Taylor expanded in x around 0
Applied rewrites99.8%
Taylor expanded in x around 0
Applied rewrites99.2%
Taylor expanded in eps around 0
Applied rewrites99.1%
(FPCore (x eps) :precision binary64 (* (fma x x 1.0) eps))
double code(double x, double eps) {
return fma(x, x, 1.0) * eps;
}
function code(x, eps) return Float64(fma(x, x, 1.0) * eps) end
code[x_, eps_] := N[(N[(x * x + 1.0), $MachinePrecision] * eps), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(x, x, 1\right) \cdot \varepsilon
\end{array}
Initial program 60.8%
Taylor expanded in eps around 0
sub-negN/A
+-commutativeN/A
distribute-rgt-inN/A
*-lft-identityN/A
lower-fma.f64N/A
mul-1-negN/A
remove-double-negN/A
lower-/.f64N/A
lower-pow.f64N/A
lower-sin.f64N/A
lower-pow.f64N/A
lower-cos.f6499.2
Applied rewrites99.2%
Taylor expanded in x around 0
Applied rewrites98.9%
Applied rewrites98.9%
Taylor expanded in x around 0
Applied rewrites98.9%
(FPCore (x eps) :precision binary64 (* 1.0 eps))
double code(double x, double eps) {
return 1.0 * eps;
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
code = 1.0d0 * eps
end function
public static double code(double x, double eps) {
return 1.0 * eps;
}
def code(x, eps): return 1.0 * eps
function code(x, eps) return Float64(1.0 * eps) end
function tmp = code(x, eps) tmp = 1.0 * eps; end
code[x_, eps_] := N[(1.0 * eps), $MachinePrecision]
\begin{array}{l}
\\
1 \cdot \varepsilon
\end{array}
Initial program 60.8%
Taylor expanded in eps around 0
sub-negN/A
+-commutativeN/A
distribute-rgt-inN/A
*-lft-identityN/A
lower-fma.f64N/A
mul-1-negN/A
remove-double-negN/A
lower-/.f64N/A
lower-pow.f64N/A
lower-sin.f64N/A
lower-pow.f64N/A
lower-cos.f6499.2
Applied rewrites99.2%
Taylor expanded in x around 0
Applied rewrites98.9%
Applied rewrites98.9%
Taylor expanded in x around 0
Applied rewrites98.4%
(FPCore (x eps) :precision binary64 (+ eps (* (* eps (tan x)) (tan x))))
double code(double x, double eps) {
return eps + ((eps * tan(x)) * tan(x));
}
real(8) function code(x, eps)
real(8), intent (in) :: x
real(8), intent (in) :: eps
code = eps + ((eps * tan(x)) * tan(x))
end function
public static double code(double x, double eps) {
return eps + ((eps * Math.tan(x)) * Math.tan(x));
}
def code(x, eps): return eps + ((eps * math.tan(x)) * math.tan(x))
function code(x, eps) return Float64(eps + Float64(Float64(eps * tan(x)) * tan(x))) end
function tmp = code(x, eps) tmp = eps + ((eps * tan(x)) * tan(x)); end
code[x_, eps_] := N[(eps + N[(N[(eps * N[Tan[x], $MachinePrecision]), $MachinePrecision] * N[Tan[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\varepsilon + \left(\varepsilon \cdot \tan x\right) \cdot \tan x
\end{array}
herbie shell --seed 2024318
(FPCore (x eps)
:name "2tan (problem 3.3.2)"
:precision binary64
:pre (and (and (and (<= -10000.0 x) (<= x 10000.0)) (< (* 1e-16 (fabs x)) eps)) (< eps (fabs x)))
:alt
(! :herbie-platform default (+ eps (* eps (tan x) (tan x))))
(- (tan (+ x eps)) (tan x)))