
(FPCore (x y z t a b) :precision binary64 (* (* x (cos (/ (* (* (+ (* y 2.0) 1.0) z) t) 16.0))) (cos (/ (* (* (+ (* a 2.0) 1.0) b) t) 16.0))))
double code(double x, double y, double z, double t, double a, double b) {
return (x * cos((((((y * 2.0) + 1.0) * z) * t) / 16.0))) * cos((((((a * 2.0) + 1.0) * b) * t) / 16.0));
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = (x * cos((((((y * 2.0d0) + 1.0d0) * z) * t) / 16.0d0))) * cos((((((a * 2.0d0) + 1.0d0) * b) * t) / 16.0d0))
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return (x * Math.cos((((((y * 2.0) + 1.0) * z) * t) / 16.0))) * Math.cos((((((a * 2.0) + 1.0) * b) * t) / 16.0));
}
def code(x, y, z, t, a, b): return (x * math.cos((((((y * 2.0) + 1.0) * z) * t) / 16.0))) * math.cos((((((a * 2.0) + 1.0) * b) * t) / 16.0))
function code(x, y, z, t, a, b) return Float64(Float64(x * cos(Float64(Float64(Float64(Float64(Float64(y * 2.0) + 1.0) * z) * t) / 16.0))) * cos(Float64(Float64(Float64(Float64(Float64(a * 2.0) + 1.0) * b) * t) / 16.0))) end
function tmp = code(x, y, z, t, a, b) tmp = (x * cos((((((y * 2.0) + 1.0) * z) * t) / 16.0))) * cos((((((a * 2.0) + 1.0) * b) * t) / 16.0)); end
code[x_, y_, z_, t_, a_, b_] := N[(N[(x * N[Cos[N[(N[(N[(N[(N[(y * 2.0), $MachinePrecision] + 1.0), $MachinePrecision] * z), $MachinePrecision] * t), $MachinePrecision] / 16.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Cos[N[(N[(N[(N[(N[(a * 2.0), $MachinePrecision] + 1.0), $MachinePrecision] * b), $MachinePrecision] * t), $MachinePrecision] / 16.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x \cdot \cos \left(\frac{\left(\left(y \cdot 2 + 1\right) \cdot z\right) \cdot t}{16}\right)\right) \cdot \cos \left(\frac{\left(\left(a \cdot 2 + 1\right) \cdot b\right) \cdot t}{16}\right)
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 6 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b) :precision binary64 (* (* x (cos (/ (* (* (+ (* y 2.0) 1.0) z) t) 16.0))) (cos (/ (* (* (+ (* a 2.0) 1.0) b) t) 16.0))))
double code(double x, double y, double z, double t, double a, double b) {
return (x * cos((((((y * 2.0) + 1.0) * z) * t) / 16.0))) * cos((((((a * 2.0) + 1.0) * b) * t) / 16.0));
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = (x * cos((((((y * 2.0d0) + 1.0d0) * z) * t) / 16.0d0))) * cos((((((a * 2.0d0) + 1.0d0) * b) * t) / 16.0d0))
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return (x * Math.cos((((((y * 2.0) + 1.0) * z) * t) / 16.0))) * Math.cos((((((a * 2.0) + 1.0) * b) * t) / 16.0));
}
def code(x, y, z, t, a, b): return (x * math.cos((((((y * 2.0) + 1.0) * z) * t) / 16.0))) * math.cos((((((a * 2.0) + 1.0) * b) * t) / 16.0))
function code(x, y, z, t, a, b) return Float64(Float64(x * cos(Float64(Float64(Float64(Float64(Float64(y * 2.0) + 1.0) * z) * t) / 16.0))) * cos(Float64(Float64(Float64(Float64(Float64(a * 2.0) + 1.0) * b) * t) / 16.0))) end
function tmp = code(x, y, z, t, a, b) tmp = (x * cos((((((y * 2.0) + 1.0) * z) * t) / 16.0))) * cos((((((a * 2.0) + 1.0) * b) * t) / 16.0)); end
code[x_, y_, z_, t_, a_, b_] := N[(N[(x * N[Cos[N[(N[(N[(N[(N[(y * 2.0), $MachinePrecision] + 1.0), $MachinePrecision] * z), $MachinePrecision] * t), $MachinePrecision] / 16.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Cos[N[(N[(N[(N[(N[(a * 2.0), $MachinePrecision] + 1.0), $MachinePrecision] * b), $MachinePrecision] * t), $MachinePrecision] / 16.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x \cdot \cos \left(\frac{\left(\left(y \cdot 2 + 1\right) \cdot z\right) \cdot t}{16}\right)\right) \cdot \cos \left(\frac{\left(\left(a \cdot 2 + 1\right) \cdot b\right) \cdot t}{16}\right)
\end{array}
z_m = (fabs.f64 z) (FPCore (x y z_m t a b) :precision binary64 (if (<= z_m 4.7e-6) (* (cos (* (* (* (fma 2.0 y 1.0) z_m) t) -0.0625)) x) (* (cos (* (* b t) -0.0625)) x)))
z_m = fabs(z);
double code(double x, double y, double z_m, double t, double a, double b) {
double tmp;
if (z_m <= 4.7e-6) {
tmp = cos((((fma(2.0, y, 1.0) * z_m) * t) * -0.0625)) * x;
} else {
tmp = cos(((b * t) * -0.0625)) * x;
}
return tmp;
}
z_m = abs(z) function code(x, y, z_m, t, a, b) tmp = 0.0 if (z_m <= 4.7e-6) tmp = Float64(cos(Float64(Float64(Float64(fma(2.0, y, 1.0) * z_m) * t) * -0.0625)) * x); else tmp = Float64(cos(Float64(Float64(b * t) * -0.0625)) * x); end return tmp end
z_m = N[Abs[z], $MachinePrecision] code[x_, y_, z$95$m_, t_, a_, b_] := If[LessEqual[z$95$m, 4.7e-6], N[(N[Cos[N[(N[(N[(N[(2.0 * y + 1.0), $MachinePrecision] * z$95$m), $MachinePrecision] * t), $MachinePrecision] * -0.0625), $MachinePrecision]], $MachinePrecision] * x), $MachinePrecision], N[(N[Cos[N[(N[(b * t), $MachinePrecision] * -0.0625), $MachinePrecision]], $MachinePrecision] * x), $MachinePrecision]]
\begin{array}{l}
z_m = \left|z\right|
\\
\begin{array}{l}
\mathbf{if}\;z\_m \leq 4.7 \cdot 10^{-6}:\\
\;\;\;\;\cos \left(\left(\left(\mathsf{fma}\left(2, y, 1\right) \cdot z\_m\right) \cdot t\right) \cdot -0.0625\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;\cos \left(\left(b \cdot t\right) \cdot -0.0625\right) \cdot x\\
\end{array}
\end{array}
if z < 4.69999999999999989e-6Initial program 32.0%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f6432.9
Applied rewrites32.9%
Taylor expanded in z around 0
*-commutativeN/A
lower-*.f64N/A
cos-neg-revN/A
lower-cos.f64N/A
distribute-lft-neg-inN/A
metadata-evalN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6433.0
Applied rewrites33.0%
Taylor expanded in b around 0
*-commutativeN/A
lower-*.f64N/A
cos-neg-revN/A
lower-cos.f64N/A
distribute-lft-neg-inN/A
metadata-evalN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6434.4
Applied rewrites34.4%
if 4.69999999999999989e-6 < z Initial program 18.3%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f6418.8
Applied rewrites18.8%
Taylor expanded in z around 0
*-commutativeN/A
lower-*.f64N/A
cos-neg-revN/A
lower-cos.f64N/A
distribute-lft-neg-inN/A
metadata-evalN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6424.7
Applied rewrites24.7%
Taylor expanded in a around 0
Applied rewrites25.5%
Final simplification32.1%
z_m = (fabs.f64 z) (FPCore (x y z_m t a b) :precision binary64 (* (cos (* (* (* t 0.0625) (* a 2.0)) b)) (* 1.0 x)))
z_m = fabs(z);
double code(double x, double y, double z_m, double t, double a, double b) {
return cos((((t * 0.0625) * (a * 2.0)) * b)) * (1.0 * x);
}
z_m = abs(z)
real(8) function code(x, y, z_m, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z_m
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = cos((((t * 0.0625d0) * (a * 2.0d0)) * b)) * (1.0d0 * x)
end function
z_m = Math.abs(z);
public static double code(double x, double y, double z_m, double t, double a, double b) {
return Math.cos((((t * 0.0625) * (a * 2.0)) * b)) * (1.0 * x);
}
z_m = math.fabs(z) def code(x, y, z_m, t, a, b): return math.cos((((t * 0.0625) * (a * 2.0)) * b)) * (1.0 * x)
z_m = abs(z) function code(x, y, z_m, t, a, b) return Float64(cos(Float64(Float64(Float64(t * 0.0625) * Float64(a * 2.0)) * b)) * Float64(1.0 * x)) end
z_m = abs(z); function tmp = code(x, y, z_m, t, a, b) tmp = cos((((t * 0.0625) * (a * 2.0)) * b)) * (1.0 * x); end
z_m = N[Abs[z], $MachinePrecision] code[x_, y_, z$95$m_, t_, a_, b_] := N[(N[Cos[N[(N[(N[(t * 0.0625), $MachinePrecision] * N[(a * 2.0), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]], $MachinePrecision] * N[(1.0 * x), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
z_m = \left|z\right|
\\
\cos \left(\left(\left(t \cdot 0.0625\right) \cdot \left(a \cdot 2\right)\right) \cdot b\right) \cdot \left(1 \cdot x\right)
\end{array}
Initial program 28.4%
Applied rewrites28.2%
Taylor expanded in z around 0
cos-PIN/A
metadata-eval30.7
Applied rewrites30.7%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f6431.6
Applied rewrites31.6%
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
div-invN/A
metadata-evalN/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
Applied rewrites31.6%
Final simplification31.6%
z_m = (fabs.f64 z) (FPCore (x y z_m t a b) :precision binary64 (* (cos (* (* b t) -0.0625)) x))
z_m = fabs(z);
double code(double x, double y, double z_m, double t, double a, double b) {
return cos(((b * t) * -0.0625)) * x;
}
z_m = abs(z)
real(8) function code(x, y, z_m, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z_m
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = cos(((b * t) * (-0.0625d0))) * x
end function
z_m = Math.abs(z);
public static double code(double x, double y, double z_m, double t, double a, double b) {
return Math.cos(((b * t) * -0.0625)) * x;
}
z_m = math.fabs(z) def code(x, y, z_m, t, a, b): return math.cos(((b * t) * -0.0625)) * x
z_m = abs(z) function code(x, y, z_m, t, a, b) return Float64(cos(Float64(Float64(b * t) * -0.0625)) * x) end
z_m = abs(z); function tmp = code(x, y, z_m, t, a, b) tmp = cos(((b * t) * -0.0625)) * x; end
z_m = N[Abs[z], $MachinePrecision] code[x_, y_, z$95$m_, t_, a_, b_] := N[(N[Cos[N[(N[(b * t), $MachinePrecision] * -0.0625), $MachinePrecision]], $MachinePrecision] * x), $MachinePrecision]
\begin{array}{l}
z_m = \left|z\right|
\\
\cos \left(\left(b \cdot t\right) \cdot -0.0625\right) \cdot x
\end{array}
Initial program 28.4%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f6429.3
Applied rewrites29.3%
Taylor expanded in z around 0
*-commutativeN/A
lower-*.f64N/A
cos-neg-revN/A
lower-cos.f64N/A
distribute-lft-neg-inN/A
metadata-evalN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6430.8
Applied rewrites30.8%
Taylor expanded in a around 0
Applied rewrites31.3%
Final simplification31.3%
z_m = (fabs.f64 z) (FPCore (x y z_m t a b) :precision binary64 (* (* (* -0.0078125 a) (* (* t x) (* (* b b) t))) a))
z_m = fabs(z);
double code(double x, double y, double z_m, double t, double a, double b) {
return ((-0.0078125 * a) * ((t * x) * ((b * b) * t))) * a;
}
z_m = abs(z)
real(8) function code(x, y, z_m, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z_m
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = (((-0.0078125d0) * a) * ((t * x) * ((b * b) * t))) * a
end function
z_m = Math.abs(z);
public static double code(double x, double y, double z_m, double t, double a, double b) {
return ((-0.0078125 * a) * ((t * x) * ((b * b) * t))) * a;
}
z_m = math.fabs(z) def code(x, y, z_m, t, a, b): return ((-0.0078125 * a) * ((t * x) * ((b * b) * t))) * a
z_m = abs(z) function code(x, y, z_m, t, a, b) return Float64(Float64(Float64(-0.0078125 * a) * Float64(Float64(t * x) * Float64(Float64(b * b) * t))) * a) end
z_m = abs(z); function tmp = code(x, y, z_m, t, a, b) tmp = ((-0.0078125 * a) * ((t * x) * ((b * b) * t))) * a; end
z_m = N[Abs[z], $MachinePrecision] code[x_, y_, z$95$m_, t_, a_, b_] := N[(N[(N[(-0.0078125 * a), $MachinePrecision] * N[(N[(t * x), $MachinePrecision] * N[(N[(b * b), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision]
\begin{array}{l}
z_m = \left|z\right|
\\
\left(\left(-0.0078125 \cdot a\right) \cdot \left(\left(t \cdot x\right) \cdot \left(\left(b \cdot b\right) \cdot t\right)\right)\right) \cdot a
\end{array}
Initial program 28.4%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f6429.3
Applied rewrites29.3%
Taylor expanded in t around 0
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
Applied rewrites13.4%
Taylor expanded in a around inf
Applied rewrites2.0%
Applied rewrites2.9%
Final simplification2.9%
z_m = (fabs.f64 z) (FPCore (x y z_m t a b) :precision binary64 (* (* (* (* (* t t) x) b) (* (* a a) -0.0078125)) b))
z_m = fabs(z);
double code(double x, double y, double z_m, double t, double a, double b) {
return ((((t * t) * x) * b) * ((a * a) * -0.0078125)) * b;
}
z_m = abs(z)
real(8) function code(x, y, z_m, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z_m
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = ((((t * t) * x) * b) * ((a * a) * (-0.0078125d0))) * b
end function
z_m = Math.abs(z);
public static double code(double x, double y, double z_m, double t, double a, double b) {
return ((((t * t) * x) * b) * ((a * a) * -0.0078125)) * b;
}
z_m = math.fabs(z) def code(x, y, z_m, t, a, b): return ((((t * t) * x) * b) * ((a * a) * -0.0078125)) * b
z_m = abs(z) function code(x, y, z_m, t, a, b) return Float64(Float64(Float64(Float64(Float64(t * t) * x) * b) * Float64(Float64(a * a) * -0.0078125)) * b) end
z_m = abs(z); function tmp = code(x, y, z_m, t, a, b) tmp = ((((t * t) * x) * b) * ((a * a) * -0.0078125)) * b; end
z_m = N[Abs[z], $MachinePrecision] code[x_, y_, z$95$m_, t_, a_, b_] := N[(N[(N[(N[(N[(t * t), $MachinePrecision] * x), $MachinePrecision] * b), $MachinePrecision] * N[(N[(a * a), $MachinePrecision] * -0.0078125), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]
\begin{array}{l}
z_m = \left|z\right|
\\
\left(\left(\left(\left(t \cdot t\right) \cdot x\right) \cdot b\right) \cdot \left(\left(a \cdot a\right) \cdot -0.0078125\right)\right) \cdot b
\end{array}
Initial program 28.4%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f6429.3
Applied rewrites29.3%
Taylor expanded in t around 0
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
Applied rewrites13.4%
Taylor expanded in a around inf
Applied rewrites2.0%
Applied rewrites2.6%
Final simplification2.6%
z_m = (fabs.f64 z) (FPCore (x y z_m t a b) :precision binary64 (* (* (* (* (* b b) x) t) t) (* (* a a) -0.0078125)))
z_m = fabs(z);
double code(double x, double y, double z_m, double t, double a, double b) {
return ((((b * b) * x) * t) * t) * ((a * a) * -0.0078125);
}
z_m = abs(z)
real(8) function code(x, y, z_m, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z_m
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = ((((b * b) * x) * t) * t) * ((a * a) * (-0.0078125d0))
end function
z_m = Math.abs(z);
public static double code(double x, double y, double z_m, double t, double a, double b) {
return ((((b * b) * x) * t) * t) * ((a * a) * -0.0078125);
}
z_m = math.fabs(z) def code(x, y, z_m, t, a, b): return ((((b * b) * x) * t) * t) * ((a * a) * -0.0078125)
z_m = abs(z) function code(x, y, z_m, t, a, b) return Float64(Float64(Float64(Float64(Float64(b * b) * x) * t) * t) * Float64(Float64(a * a) * -0.0078125)) end
z_m = abs(z); function tmp = code(x, y, z_m, t, a, b) tmp = ((((b * b) * x) * t) * t) * ((a * a) * -0.0078125); end
z_m = N[Abs[z], $MachinePrecision] code[x_, y_, z$95$m_, t_, a_, b_] := N[(N[(N[(N[(N[(b * b), $MachinePrecision] * x), $MachinePrecision] * t), $MachinePrecision] * t), $MachinePrecision] * N[(N[(a * a), $MachinePrecision] * -0.0078125), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
z_m = \left|z\right|
\\
\left(\left(\left(\left(b \cdot b\right) \cdot x\right) \cdot t\right) \cdot t\right) \cdot \left(\left(a \cdot a\right) \cdot -0.0078125\right)
\end{array}
Initial program 28.4%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f6429.3
Applied rewrites29.3%
Taylor expanded in t around 0
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
Applied rewrites13.4%
Taylor expanded in a around inf
Applied rewrites2.0%
Applied rewrites2.3%
Final simplification2.3%
(FPCore (x y z t a b) :precision binary64 (* x (cos (* (/ b 16.0) (/ t (+ (- 1.0 (* a 2.0)) (pow (* a 2.0) 2.0)))))))
double code(double x, double y, double z, double t, double a, double b) {
return x * cos(((b / 16.0) * (t / ((1.0 - (a * 2.0)) + pow((a * 2.0), 2.0)))));
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = x * cos(((b / 16.0d0) * (t / ((1.0d0 - (a * 2.0d0)) + ((a * 2.0d0) ** 2.0d0)))))
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return x * Math.cos(((b / 16.0) * (t / ((1.0 - (a * 2.0)) + Math.pow((a * 2.0), 2.0)))));
}
def code(x, y, z, t, a, b): return x * math.cos(((b / 16.0) * (t / ((1.0 - (a * 2.0)) + math.pow((a * 2.0), 2.0)))))
function code(x, y, z, t, a, b) return Float64(x * cos(Float64(Float64(b / 16.0) * Float64(t / Float64(Float64(1.0 - Float64(a * 2.0)) + (Float64(a * 2.0) ^ 2.0)))))) end
function tmp = code(x, y, z, t, a, b) tmp = x * cos(((b / 16.0) * (t / ((1.0 - (a * 2.0)) + ((a * 2.0) ^ 2.0))))); end
code[x_, y_, z_, t_, a_, b_] := N[(x * N[Cos[N[(N[(b / 16.0), $MachinePrecision] * N[(t / N[(N[(1.0 - N[(a * 2.0), $MachinePrecision]), $MachinePrecision] + N[Power[N[(a * 2.0), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x \cdot \cos \left(\frac{b}{16} \cdot \frac{t}{\left(1 - a \cdot 2\right) + {\left(a \cdot 2\right)}^{2}}\right)
\end{array}
herbie shell --seed 2024298
(FPCore (x y z t a b)
:name "Codec.Picture.Jpg.FastDct:referenceDct from JuicyPixels-3.2.6.1"
:precision binary64
:alt
(! :herbie-platform default (* x (cos (* (/ b 16) (/ t (+ (- 1 (* a 2)) (pow (* a 2) 2)))))))
(* (* x (cos (/ (* (* (+ (* y 2.0) 1.0) z) t) 16.0))) (cos (/ (* (* (+ (* a 2.0) 1.0) b) t) 16.0))))