
(FPCore (x c s) :precision binary64 (/ (cos (* 2.0 x)) (* (pow c 2.0) (* (* x (pow s 2.0)) x))))
double code(double x, double c, double s) {
return cos((2.0 * x)) / (pow(c, 2.0) * ((x * pow(s, 2.0)) * x));
}
real(8) function code(x, c, s)
real(8), intent (in) :: x
real(8), intent (in) :: c
real(8), intent (in) :: s
code = cos((2.0d0 * x)) / ((c ** 2.0d0) * ((x * (s ** 2.0d0)) * x))
end function
public static double code(double x, double c, double s) {
return Math.cos((2.0 * x)) / (Math.pow(c, 2.0) * ((x * Math.pow(s, 2.0)) * x));
}
def code(x, c, s): return math.cos((2.0 * x)) / (math.pow(c, 2.0) * ((x * math.pow(s, 2.0)) * x))
function code(x, c, s) return Float64(cos(Float64(2.0 * x)) / Float64((c ^ 2.0) * Float64(Float64(x * (s ^ 2.0)) * x))) end
function tmp = code(x, c, s) tmp = cos((2.0 * x)) / ((c ^ 2.0) * ((x * (s ^ 2.0)) * x)); end
code[x_, c_, s_] := N[(N[Cos[N[(2.0 * x), $MachinePrecision]], $MachinePrecision] / N[(N[Power[c, 2.0], $MachinePrecision] * N[(N[(x * N[Power[s, 2.0], $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\cos \left(2 \cdot x\right)}{{c}^{2} \cdot \left(\left(x \cdot {s}^{2}\right) \cdot x\right)}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 9 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x c s) :precision binary64 (/ (cos (* 2.0 x)) (* (pow c 2.0) (* (* x (pow s 2.0)) x))))
double code(double x, double c, double s) {
return cos((2.0 * x)) / (pow(c, 2.0) * ((x * pow(s, 2.0)) * x));
}
real(8) function code(x, c, s)
real(8), intent (in) :: x
real(8), intent (in) :: c
real(8), intent (in) :: s
code = cos((2.0d0 * x)) / ((c ** 2.0d0) * ((x * (s ** 2.0d0)) * x))
end function
public static double code(double x, double c, double s) {
return Math.cos((2.0 * x)) / (Math.pow(c, 2.0) * ((x * Math.pow(s, 2.0)) * x));
}
def code(x, c, s): return math.cos((2.0 * x)) / (math.pow(c, 2.0) * ((x * math.pow(s, 2.0)) * x))
function code(x, c, s) return Float64(cos(Float64(2.0 * x)) / Float64((c ^ 2.0) * Float64(Float64(x * (s ^ 2.0)) * x))) end
function tmp = code(x, c, s) tmp = cos((2.0 * x)) / ((c ^ 2.0) * ((x * (s ^ 2.0)) * x)); end
code[x_, c_, s_] := N[(N[Cos[N[(2.0 * x), $MachinePrecision]], $MachinePrecision] / N[(N[Power[c, 2.0], $MachinePrecision] * N[(N[(x * N[Power[s, 2.0], $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\cos \left(2 \cdot x\right)}{{c}^{2} \cdot \left(\left(x \cdot {s}^{2}\right) \cdot x\right)}
\end{array}
(FPCore (x c s) :precision binary64 (let* ((t_0 (* x (* c s)))) (/ (/ (cos (* x 2.0)) t_0) t_0)))
double code(double x, double c, double s) {
double t_0 = x * (c * s);
return (cos((x * 2.0)) / t_0) / t_0;
}
real(8) function code(x, c, s)
real(8), intent (in) :: x
real(8), intent (in) :: c
real(8), intent (in) :: s
real(8) :: t_0
t_0 = x * (c * s)
code = (cos((x * 2.0d0)) / t_0) / t_0
end function
public static double code(double x, double c, double s) {
double t_0 = x * (c * s);
return (Math.cos((x * 2.0)) / t_0) / t_0;
}
def code(x, c, s): t_0 = x * (c * s) return (math.cos((x * 2.0)) / t_0) / t_0
function code(x, c, s) t_0 = Float64(x * Float64(c * s)) return Float64(Float64(cos(Float64(x * 2.0)) / t_0) / t_0) end
function tmp = code(x, c, s) t_0 = x * (c * s); tmp = (cos((x * 2.0)) / t_0) / t_0; end
code[x_, c_, s_] := Block[{t$95$0 = N[(x * N[(c * s), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[Cos[N[(x * 2.0), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision] / t$95$0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := x \cdot \left(c \cdot s\right)\\
\frac{\frac{\cos \left(x \cdot 2\right)}{t\_0}}{t\_0}
\end{array}
\end{array}
Initial program 68.0%
*-un-lft-identity68.0%
associate-*r*70.6%
times-frac70.6%
*-commutative70.6%
associate-*r*68.6%
pow-prod-down84.6%
Applied egg-rr84.6%
unpow284.6%
*-commutative84.6%
associate-*r*83.1%
Applied egg-rr83.1%
*-commutative83.1%
frac-times83.1%
*-un-lft-identity83.1%
associate-*l*85.3%
associate-*l*90.2%
associate-*l*91.6%
*-commutative91.6%
associate-*r*88.8%
*-commutative88.8%
associate-*r*91.2%
*-commutative91.2%
associate-*r*94.6%
associate-*r*96.3%
*-commutative96.3%
associate-/l/96.7%
Applied egg-rr97.6%
Final simplification97.6%
(FPCore (x c s) :precision binary64 (/ (/ (cos (* x 2.0)) c) (* (* x s) (* c (* x s)))))
double code(double x, double c, double s) {
return (cos((x * 2.0)) / c) / ((x * s) * (c * (x * s)));
}
real(8) function code(x, c, s)
real(8), intent (in) :: x
real(8), intent (in) :: c
real(8), intent (in) :: s
code = (cos((x * 2.0d0)) / c) / ((x * s) * (c * (x * s)))
end function
public static double code(double x, double c, double s) {
return (Math.cos((x * 2.0)) / c) / ((x * s) * (c * (x * s)));
}
def code(x, c, s): return (math.cos((x * 2.0)) / c) / ((x * s) * (c * (x * s)))
function code(x, c, s) return Float64(Float64(cos(Float64(x * 2.0)) / c) / Float64(Float64(x * s) * Float64(c * Float64(x * s)))) end
function tmp = code(x, c, s) tmp = (cos((x * 2.0)) / c) / ((x * s) * (c * (x * s))); end
code[x_, c_, s_] := N[(N[(N[Cos[N[(x * 2.0), $MachinePrecision]], $MachinePrecision] / c), $MachinePrecision] / N[(N[(x * s), $MachinePrecision] * N[(c * N[(x * s), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\frac{\cos \left(x \cdot 2\right)}{c}}{\left(x \cdot s\right) \cdot \left(c \cdot \left(x \cdot s\right)\right)}
\end{array}
Initial program 68.0%
*-un-lft-identity68.0%
add-sqr-sqrt68.0%
times-frac68.0%
sqrt-prod68.0%
sqrt-pow151.0%
metadata-eval51.0%
pow151.0%
*-commutative51.0%
associate-*r*46.4%
unpow246.4%
pow-prod-down51.0%
sqrt-pow149.1%
metadata-eval49.1%
pow149.1%
*-commutative49.1%
Applied egg-rr96.7%
*-commutative96.7%
associate-/r*96.8%
frac-times94.2%
div-inv94.2%
*-commutative94.2%
Applied egg-rr94.2%
Final simplification94.2%
(FPCore (x c s) :precision binary64 (let* ((t_0 (* c (* x s)))) (/ (/ (cos (* x 2.0)) t_0) t_0)))
double code(double x, double c, double s) {
double t_0 = c * (x * s);
return (cos((x * 2.0)) / t_0) / t_0;
}
real(8) function code(x, c, s)
real(8), intent (in) :: x
real(8), intent (in) :: c
real(8), intent (in) :: s
real(8) :: t_0
t_0 = c * (x * s)
code = (cos((x * 2.0d0)) / t_0) / t_0
end function
public static double code(double x, double c, double s) {
double t_0 = c * (x * s);
return (Math.cos((x * 2.0)) / t_0) / t_0;
}
def code(x, c, s): t_0 = c * (x * s) return (math.cos((x * 2.0)) / t_0) / t_0
function code(x, c, s) t_0 = Float64(c * Float64(x * s)) return Float64(Float64(cos(Float64(x * 2.0)) / t_0) / t_0) end
function tmp = code(x, c, s) t_0 = c * (x * s); tmp = (cos((x * 2.0)) / t_0) / t_0; end
code[x_, c_, s_] := Block[{t$95$0 = N[(c * N[(x * s), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[Cos[N[(x * 2.0), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision] / t$95$0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := c \cdot \left(x \cdot s\right)\\
\frac{\frac{\cos \left(x \cdot 2\right)}{t\_0}}{t\_0}
\end{array}
\end{array}
Initial program 68.0%
*-un-lft-identity68.0%
add-sqr-sqrt68.0%
times-frac68.0%
sqrt-prod68.0%
sqrt-pow151.0%
metadata-eval51.0%
pow151.0%
*-commutative51.0%
associate-*r*46.4%
unpow246.4%
pow-prod-down51.0%
sqrt-pow149.1%
metadata-eval49.1%
pow149.1%
*-commutative49.1%
Applied egg-rr96.7%
*-commutative96.7%
associate-*l/96.7%
div-inv96.7%
*-commutative96.7%
Applied egg-rr96.7%
Final simplification96.7%
(FPCore (x c s)
:precision binary64
(let* ((t_0 (* c (* x s))))
(if (<= s 2e+165)
(/ 1.0 (* (* x c) (* s t_0)))
(/ 1.0 (* (* c s) (* x t_0))))))
double code(double x, double c, double s) {
double t_0 = c * (x * s);
double tmp;
if (s <= 2e+165) {
tmp = 1.0 / ((x * c) * (s * t_0));
} else {
tmp = 1.0 / ((c * s) * (x * t_0));
}
return tmp;
}
real(8) function code(x, c, s)
real(8), intent (in) :: x
real(8), intent (in) :: c
real(8), intent (in) :: s
real(8) :: t_0
real(8) :: tmp
t_0 = c * (x * s)
if (s <= 2d+165) then
tmp = 1.0d0 / ((x * c) * (s * t_0))
else
tmp = 1.0d0 / ((c * s) * (x * t_0))
end if
code = tmp
end function
public static double code(double x, double c, double s) {
double t_0 = c * (x * s);
double tmp;
if (s <= 2e+165) {
tmp = 1.0 / ((x * c) * (s * t_0));
} else {
tmp = 1.0 / ((c * s) * (x * t_0));
}
return tmp;
}
def code(x, c, s): t_0 = c * (x * s) tmp = 0 if s <= 2e+165: tmp = 1.0 / ((x * c) * (s * t_0)) else: tmp = 1.0 / ((c * s) * (x * t_0)) return tmp
function code(x, c, s) t_0 = Float64(c * Float64(x * s)) tmp = 0.0 if (s <= 2e+165) tmp = Float64(1.0 / Float64(Float64(x * c) * Float64(s * t_0))); else tmp = Float64(1.0 / Float64(Float64(c * s) * Float64(x * t_0))); end return tmp end
function tmp_2 = code(x, c, s) t_0 = c * (x * s); tmp = 0.0; if (s <= 2e+165) tmp = 1.0 / ((x * c) * (s * t_0)); else tmp = 1.0 / ((c * s) * (x * t_0)); end tmp_2 = tmp; end
code[x_, c_, s_] := Block[{t$95$0 = N[(c * N[(x * s), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[s, 2e+165], N[(1.0 / N[(N[(x * c), $MachinePrecision] * N[(s * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(N[(c * s), $MachinePrecision] * N[(x * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := c \cdot \left(x \cdot s\right)\\
\mathbf{if}\;s \leq 2 \cdot 10^{+165}:\\
\;\;\;\;\frac{1}{\left(x \cdot c\right) \cdot \left(s \cdot t\_0\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\left(c \cdot s\right) \cdot \left(x \cdot t\_0\right)}\\
\end{array}
\end{array}
if s < 1.9999999999999998e165Initial program 68.0%
Taylor expanded in x around 0 51.1%
associate-/r*51.1%
*-commutative51.1%
unpow251.1%
unpow251.1%
swap-sqr62.8%
unpow262.8%
associate-/r*62.8%
unpow262.8%
unpow262.8%
swap-sqr73.4%
unpow273.4%
*-commutative73.4%
Simplified73.4%
unpow-prod-down62.8%
*-commutative62.8%
unpow-prod-down73.4%
unpow273.4%
associate-*r*73.3%
associate-*l*72.4%
Applied egg-rr72.4%
if 1.9999999999999998e165 < s Initial program 68.1%
Taylor expanded in x around 0 59.3%
associate-/r*59.3%
*-commutative59.3%
unpow259.3%
unpow259.3%
swap-sqr75.4%
unpow275.4%
associate-/r*74.3%
unpow274.3%
unpow274.3%
swap-sqr93.7%
unpow293.7%
*-commutative93.7%
Simplified93.7%
unpow293.7%
associate-*r*93.8%
*-commutative93.8%
associate-*l*90.9%
Applied egg-rr90.9%
Final simplification74.6%
(FPCore (x c s) :precision binary64 (* (/ 1.0 (* c (* x s))) (/ (/ (/ 1.0 x) s) c)))
double code(double x, double c, double s) {
return (1.0 / (c * (x * s))) * (((1.0 / x) / s) / c);
}
real(8) function code(x, c, s)
real(8), intent (in) :: x
real(8), intent (in) :: c
real(8), intent (in) :: s
code = (1.0d0 / (c * (x * s))) * (((1.0d0 / x) / s) / c)
end function
public static double code(double x, double c, double s) {
return (1.0 / (c * (x * s))) * (((1.0 / x) / s) / c);
}
def code(x, c, s): return (1.0 / (c * (x * s))) * (((1.0 / x) / s) / c)
function code(x, c, s) return Float64(Float64(1.0 / Float64(c * Float64(x * s))) * Float64(Float64(Float64(1.0 / x) / s) / c)) end
function tmp = code(x, c, s) tmp = (1.0 / (c * (x * s))) * (((1.0 / x) / s) / c); end
code[x_, c_, s_] := N[(N[(1.0 / N[(c * N[(x * s), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(N[(1.0 / x), $MachinePrecision] / s), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{1}{c \cdot \left(x \cdot s\right)} \cdot \frac{\frac{\frac{1}{x}}{s}}{c}
\end{array}
Initial program 68.0%
*-un-lft-identity68.0%
add-sqr-sqrt68.0%
times-frac68.0%
sqrt-prod68.0%
sqrt-pow151.0%
metadata-eval51.0%
pow151.0%
*-commutative51.0%
associate-*r*46.4%
unpow246.4%
pow-prod-down51.0%
sqrt-pow149.1%
metadata-eval49.1%
pow149.1%
*-commutative49.1%
Applied egg-rr96.7%
Taylor expanded in x around 0 76.2%
associate-/r*76.3%
*-commutative76.3%
*-rgt-identity76.3%
associate-*r/76.2%
associate-*l/76.2%
*-lft-identity76.2%
associate-/r*76.2%
Simplified76.2%
Final simplification76.2%
(FPCore (x c s) :precision binary64 (* (/ (/ 1.0 c) (* x s)) (/ (/ 1.0 (* x s)) c)))
double code(double x, double c, double s) {
return ((1.0 / c) / (x * s)) * ((1.0 / (x * s)) / c);
}
real(8) function code(x, c, s)
real(8), intent (in) :: x
real(8), intent (in) :: c
real(8), intent (in) :: s
code = ((1.0d0 / c) / (x * s)) * ((1.0d0 / (x * s)) / c)
end function
public static double code(double x, double c, double s) {
return ((1.0 / c) / (x * s)) * ((1.0 / (x * s)) / c);
}
def code(x, c, s): return ((1.0 / c) / (x * s)) * ((1.0 / (x * s)) / c)
function code(x, c, s) return Float64(Float64(Float64(1.0 / c) / Float64(x * s)) * Float64(Float64(1.0 / Float64(x * s)) / c)) end
function tmp = code(x, c, s) tmp = ((1.0 / c) / (x * s)) * ((1.0 / (x * s)) / c); end
code[x_, c_, s_] := N[(N[(N[(1.0 / c), $MachinePrecision] / N[(x * s), $MachinePrecision]), $MachinePrecision] * N[(N[(1.0 / N[(x * s), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\frac{1}{c}}{x \cdot s} \cdot \frac{\frac{1}{x \cdot s}}{c}
\end{array}
Initial program 68.0%
Taylor expanded in x around 0 52.1%
associate-/r*52.1%
*-commutative52.1%
unpow252.1%
unpow252.1%
swap-sqr64.3%
unpow264.3%
associate-/r*64.2%
unpow264.2%
unpow264.2%
swap-sqr75.8%
unpow275.8%
*-commutative75.8%
Simplified75.8%
unpow-prod-down64.2%
*-commutative64.2%
unpow-prod-down75.8%
unpow275.8%
associate-*r*75.4%
associate-*l*74.3%
Applied egg-rr74.3%
metadata-eval74.3%
associate-*r*75.4%
*-commutative75.4%
associate-*r*74.7%
associate-*r*75.9%
*-commutative75.9%
associate-*r*76.4%
frac-times76.5%
*-commutative76.5%
associate-*r*74.9%
*-commutative74.9%
associate-/l/75.0%
div-inv75.0%
div-inv75.0%
*-commutative75.0%
*-commutative75.0%
associate-*r*76.2%
times-frac76.3%
Applied egg-rr76.3%
Final simplification76.3%
(FPCore (x c s) :precision binary64 (/ 1.0 (* (* c s) (* x (* c (* x s))))))
double code(double x, double c, double s) {
return 1.0 / ((c * s) * (x * (c * (x * s))));
}
real(8) function code(x, c, s)
real(8), intent (in) :: x
real(8), intent (in) :: c
real(8), intent (in) :: s
code = 1.0d0 / ((c * s) * (x * (c * (x * s))))
end function
public static double code(double x, double c, double s) {
return 1.0 / ((c * s) * (x * (c * (x * s))));
}
def code(x, c, s): return 1.0 / ((c * s) * (x * (c * (x * s))))
function code(x, c, s) return Float64(1.0 / Float64(Float64(c * s) * Float64(x * Float64(c * Float64(x * s))))) end
function tmp = code(x, c, s) tmp = 1.0 / ((c * s) * (x * (c * (x * s)))); end
code[x_, c_, s_] := N[(1.0 / N[(N[(c * s), $MachinePrecision] * N[(x * N[(c * N[(x * s), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{1}{\left(c \cdot s\right) \cdot \left(x \cdot \left(c \cdot \left(x \cdot s\right)\right)\right)}
\end{array}
Initial program 68.0%
Taylor expanded in x around 0 52.1%
associate-/r*52.1%
*-commutative52.1%
unpow252.1%
unpow252.1%
swap-sqr64.3%
unpow264.3%
associate-/r*64.2%
unpow264.2%
unpow264.2%
swap-sqr75.8%
unpow275.8%
*-commutative75.8%
Simplified75.8%
unpow275.8%
associate-*r*74.7%
*-commutative74.7%
associate-*l*72.1%
Applied egg-rr72.1%
Final simplification72.1%
(FPCore (x c s) :precision binary64 (let* ((t_0 (* c (* x s)))) (/ 1.0 (* t_0 t_0))))
double code(double x, double c, double s) {
double t_0 = c * (x * s);
return 1.0 / (t_0 * t_0);
}
real(8) function code(x, c, s)
real(8), intent (in) :: x
real(8), intent (in) :: c
real(8), intent (in) :: s
real(8) :: t_0
t_0 = c * (x * s)
code = 1.0d0 / (t_0 * t_0)
end function
public static double code(double x, double c, double s) {
double t_0 = c * (x * s);
return 1.0 / (t_0 * t_0);
}
def code(x, c, s): t_0 = c * (x * s) return 1.0 / (t_0 * t_0)
function code(x, c, s) t_0 = Float64(c * Float64(x * s)) return Float64(1.0 / Float64(t_0 * t_0)) end
function tmp = code(x, c, s) t_0 = c * (x * s); tmp = 1.0 / (t_0 * t_0); end
code[x_, c_, s_] := Block[{t$95$0 = N[(c * N[(x * s), $MachinePrecision]), $MachinePrecision]}, N[(1.0 / N[(t$95$0 * t$95$0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := c \cdot \left(x \cdot s\right)\\
\frac{1}{t\_0 \cdot t\_0}
\end{array}
\end{array}
Initial program 68.0%
Taylor expanded in x around 0 52.1%
associate-/r*52.1%
*-commutative52.1%
unpow252.1%
unpow252.1%
swap-sqr64.3%
unpow264.3%
associate-/r*64.2%
unpow264.2%
unpow264.2%
swap-sqr75.8%
unpow275.8%
*-commutative75.8%
Simplified75.8%
unpow-prod-down64.2%
*-commutative64.2%
unpow-prod-down75.8%
unpow275.8%
Applied egg-rr75.8%
Final simplification75.8%
(FPCore (x c s) :precision binary64 (let* ((t_0 (* c (* x s)))) (/ (/ 1.0 t_0) t_0)))
double code(double x, double c, double s) {
double t_0 = c * (x * s);
return (1.0 / t_0) / t_0;
}
real(8) function code(x, c, s)
real(8), intent (in) :: x
real(8), intent (in) :: c
real(8), intent (in) :: s
real(8) :: t_0
t_0 = c * (x * s)
code = (1.0d0 / t_0) / t_0
end function
public static double code(double x, double c, double s) {
double t_0 = c * (x * s);
return (1.0 / t_0) / t_0;
}
def code(x, c, s): t_0 = c * (x * s) return (1.0 / t_0) / t_0
function code(x, c, s) t_0 = Float64(c * Float64(x * s)) return Float64(Float64(1.0 / t_0) / t_0) end
function tmp = code(x, c, s) t_0 = c * (x * s); tmp = (1.0 / t_0) / t_0; end
code[x_, c_, s_] := Block[{t$95$0 = N[(c * N[(x * s), $MachinePrecision]), $MachinePrecision]}, N[(N[(1.0 / t$95$0), $MachinePrecision] / t$95$0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := c \cdot \left(x \cdot s\right)\\
\frac{\frac{1}{t\_0}}{t\_0}
\end{array}
\end{array}
Initial program 68.0%
*-un-lft-identity68.0%
add-sqr-sqrt68.0%
times-frac68.0%
sqrt-prod68.0%
sqrt-pow151.0%
metadata-eval51.0%
pow151.0%
*-commutative51.0%
associate-*r*46.4%
unpow246.4%
pow-prod-down51.0%
sqrt-pow149.1%
metadata-eval49.1%
pow149.1%
*-commutative49.1%
Applied egg-rr96.7%
*-commutative96.7%
associate-*l/96.7%
div-inv96.7%
*-commutative96.7%
Applied egg-rr96.7%
Taylor expanded in x around 0 76.2%
Final simplification76.2%
herbie shell --seed 2024059
(FPCore (x c s)
:name "mixedcos"
:precision binary64
(/ (cos (* 2.0 x)) (* (pow c 2.0) (* (* x (pow s 2.0)) x))))