
(FPCore (z0) :precision binary64 (cos (* z0 (+ PI PI))))
double code(double z0) {
return cos((z0 * (((double) M_PI) + ((double) M_PI))));
}
public static double code(double z0) {
return Math.cos((z0 * (Math.PI + Math.PI)));
}
def code(z0): return math.cos((z0 * (math.pi + math.pi)))
function code(z0) return cos(Float64(z0 * Float64(pi + pi))) end
function tmp = code(z0) tmp = cos((z0 * (pi + pi))); end
code[z0_] := N[Cos[N[(z0 * N[(Pi + Pi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\cos \left(z0 \cdot \left(\pi + \pi\right)\right)
Herbie found 8 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (z0) :precision binary64 (cos (* z0 (+ PI PI))))
double code(double z0) {
return cos((z0 * (((double) M_PI) + ((double) M_PI))));
}
public static double code(double z0) {
return Math.cos((z0 * (Math.PI + Math.PI)));
}
def code(z0): return math.cos((z0 * (math.pi + math.pi)))
function code(z0) return cos(Float64(z0 * Float64(pi + pi))) end
function tmp = code(z0) tmp = cos((z0 * (pi + pi))); end
code[z0_] := N[Cos[N[(z0 * N[(Pi + Pi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\cos \left(z0 \cdot \left(\pi + \pi\right)\right)
(FPCore (z0) :precision binary64 (let* ((t_0 (* (- PI) z0)) (t_1 (- t_0 (* PI -1)))) (+ (/ (- (cos (- t_1 t_0)) (cos (+ t_1 t_0))) 2) (+ 1/2 (* 1/2 (cos (* (+ PI PI) z0)))))))
double code(double z0) {
double t_0 = -((double) M_PI) * z0;
double t_1 = t_0 - (((double) M_PI) * -1.0);
return ((cos((t_1 - t_0)) - cos((t_1 + t_0))) / 2.0) + (0.5 + (0.5 * cos(((((double) M_PI) + ((double) M_PI)) * z0))));
}
public static double code(double z0) {
double t_0 = -Math.PI * z0;
double t_1 = t_0 - (Math.PI * -1.0);
return ((Math.cos((t_1 - t_0)) - Math.cos((t_1 + t_0))) / 2.0) + (0.5 + (0.5 * Math.cos(((Math.PI + Math.PI) * z0))));
}
def code(z0): t_0 = -math.pi * z0 t_1 = t_0 - (math.pi * -1.0) return ((math.cos((t_1 - t_0)) - math.cos((t_1 + t_0))) / 2.0) + (0.5 + (0.5 * math.cos(((math.pi + math.pi) * z0))))
function code(z0) t_0 = Float64(Float64(-pi) * z0) t_1 = Float64(t_0 - Float64(pi * -1.0)) return Float64(Float64(Float64(cos(Float64(t_1 - t_0)) - cos(Float64(t_1 + t_0))) / 2.0) + Float64(0.5 + Float64(0.5 * cos(Float64(Float64(pi + pi) * z0))))) end
function tmp = code(z0) t_0 = -pi * z0; t_1 = t_0 - (pi * -1.0); tmp = ((cos((t_1 - t_0)) - cos((t_1 + t_0))) / 2.0) + (0.5 + (0.5 * cos(((pi + pi) * z0)))); end
code[z0_] := Block[{t$95$0 = N[((-Pi) * z0), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 - N[(Pi * -1), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[(N[Cos[N[(t$95$1 - t$95$0), $MachinePrecision]], $MachinePrecision] - N[Cos[N[(t$95$1 + t$95$0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / 2), $MachinePrecision] + N[(1/2 + N[(1/2 * N[Cos[N[(N[(Pi + Pi), $MachinePrecision] * z0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
t_0 := \left(-\pi\right) \cdot z0\\
t_1 := t\_0 - \pi \cdot -1\\
\frac{\cos \left(t\_1 - t\_0\right) - \cos \left(t\_1 + t\_0\right)}{2} + \left(\frac{1}{2} + \frac{1}{2} \cdot \cos \left(\left(\pi + \pi\right) \cdot z0\right)\right)
\end{array}
Initial program 56.9%
Applied rewrites59.1%
lift-*.f64N/A
*-commutativeN/A
lift-cos.f64N/A
sin-+PI/2-revN/A
lift-sin.f64N/A
sin-multN/A
lower-/.f64N/A
Applied rewrites98.7%
lift--.f64N/A
lift-*.f64N/A
fp-cancel-sub-sign-invN/A
metadata-evalN/A
*-commutativeN/A
lift--.f64N/A
lift-*.f64N/A
fp-cancel-sub-sign-invN/A
lift-neg.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-*.f64N/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
lift-*.f64N/A
metadata-evalN/A
mult-flip-revN/A
Applied rewrites98.6%
lift--.f64N/A
lift-*.f64N/A
fp-cancel-sub-sign-invN/A
metadata-evalN/A
*-commutativeN/A
lift--.f64N/A
lift-*.f64N/A
fp-cancel-sub-sign-invN/A
lift-neg.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-*.f64N/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
lift-*.f64N/A
metadata-evalN/A
mult-flip-revN/A
Applied rewrites98.6%
lift--.f64N/A
lift-*.f64N/A
lift-*.f64N/A
distribute-rgt-out--N/A
lower-*.f64N/A
metadata-eval98.6%
Applied rewrites98.6%
lift--.f64N/A
lift-*.f64N/A
lift-*.f64N/A
distribute-rgt-out--N/A
lower-*.f64N/A
metadata-eval98.6%
Applied rewrites98.6%
(FPCore (z0) :precision binary64 (- (* (+ (cos (* (+ z0 z0) PI)) 1) 1/2) (* (- (cos (* -2 (* (- 1/2 z0) PI))) (cos (+ (* PI (+ (- 1/2 z0) 1/2)) (* PI z0)))) 1/2)))
double code(double z0) {
return ((cos(((z0 + z0) * ((double) M_PI))) + 1.0) * 0.5) - ((cos((-2.0 * ((0.5 - z0) * ((double) M_PI)))) - cos(((((double) M_PI) * ((0.5 - z0) + 0.5)) + (((double) M_PI) * z0)))) * 0.5);
}
public static double code(double z0) {
return ((Math.cos(((z0 + z0) * Math.PI)) + 1.0) * 0.5) - ((Math.cos((-2.0 * ((0.5 - z0) * Math.PI))) - Math.cos(((Math.PI * ((0.5 - z0) + 0.5)) + (Math.PI * z0)))) * 0.5);
}
def code(z0): return ((math.cos(((z0 + z0) * math.pi)) + 1.0) * 0.5) - ((math.cos((-2.0 * ((0.5 - z0) * math.pi))) - math.cos(((math.pi * ((0.5 - z0) + 0.5)) + (math.pi * z0)))) * 0.5)
function code(z0) return Float64(Float64(Float64(cos(Float64(Float64(z0 + z0) * pi)) + 1.0) * 0.5) - Float64(Float64(cos(Float64(-2.0 * Float64(Float64(0.5 - z0) * pi))) - cos(Float64(Float64(pi * Float64(Float64(0.5 - z0) + 0.5)) + Float64(pi * z0)))) * 0.5)) end
function tmp = code(z0) tmp = ((cos(((z0 + z0) * pi)) + 1.0) * 0.5) - ((cos((-2.0 * ((0.5 - z0) * pi))) - cos(((pi * ((0.5 - z0) + 0.5)) + (pi * z0)))) * 0.5); end
code[z0_] := N[(N[(N[(N[Cos[N[(N[(z0 + z0), $MachinePrecision] * Pi), $MachinePrecision]], $MachinePrecision] + 1), $MachinePrecision] * 1/2), $MachinePrecision] - N[(N[(N[Cos[N[(-2 * N[(N[(1/2 - z0), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - N[Cos[N[(N[(Pi * N[(N[(1/2 - z0), $MachinePrecision] + 1/2), $MachinePrecision]), $MachinePrecision] + N[(Pi * z0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * 1/2), $MachinePrecision]), $MachinePrecision]
\left(\cos \left(\left(z0 + z0\right) \cdot \pi\right) + 1\right) \cdot \frac{1}{2} - \left(\cos \left(-2 \cdot \left(\left(\frac{1}{2} - z0\right) \cdot \pi\right)\right) - \cos \left(\pi \cdot \left(\left(\frac{1}{2} - z0\right) + \frac{1}{2}\right) + \pi \cdot z0\right)\right) \cdot \frac{1}{2}
Initial program 56.9%
Applied rewrites59.1%
Applied rewrites59.0%
lift-cos.f64N/A
sin-+PI/2-revN/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-neg.f64N/A
fp-cancel-sub-sign-invN/A
lift-*.f64N/A
lift--.f64N/A
lift-PI.f64N/A
mult-flip-revN/A
metadata-evalN/A
*-commutativeN/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
lift-*.f64N/A
lift--.f64N/A
Applied rewrites60.5%
Applied rewrites98.7%
(FPCore (z0) :precision binary64 (let* ((t_0 (* (- PI) z0))) (+ (* (sin t_0) (sin (+ t_0 PI))) (+ 1/2 (* 1/2 (cos (* (+ PI PI) z0)))))))
double code(double z0) {
double t_0 = -((double) M_PI) * z0;
return (sin(t_0) * sin((t_0 + ((double) M_PI)))) + (0.5 + (0.5 * cos(((((double) M_PI) + ((double) M_PI)) * z0))));
}
public static double code(double z0) {
double t_0 = -Math.PI * z0;
return (Math.sin(t_0) * Math.sin((t_0 + Math.PI))) + (0.5 + (0.5 * Math.cos(((Math.PI + Math.PI) * z0))));
}
def code(z0): t_0 = -math.pi * z0 return (math.sin(t_0) * math.sin((t_0 + math.pi))) + (0.5 + (0.5 * math.cos(((math.pi + math.pi) * z0))))
function code(z0) t_0 = Float64(Float64(-pi) * z0) return Float64(Float64(sin(t_0) * sin(Float64(t_0 + pi))) + Float64(0.5 + Float64(0.5 * cos(Float64(Float64(pi + pi) * z0))))) end
function tmp = code(z0) t_0 = -pi * z0; tmp = (sin(t_0) * sin((t_0 + pi))) + (0.5 + (0.5 * cos(((pi + pi) * z0)))); end
code[z0_] := Block[{t$95$0 = N[((-Pi) * z0), $MachinePrecision]}, N[(N[(N[Sin[t$95$0], $MachinePrecision] * N[Sin[N[(t$95$0 + Pi), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] + N[(1/2 + N[(1/2 * N[Cos[N[(N[(Pi + Pi), $MachinePrecision] * z0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
t_0 := \left(-\pi\right) \cdot z0\\
\sin t\_0 \cdot \sin \left(t\_0 + \pi\right) + \left(\frac{1}{2} + \frac{1}{2} \cdot \cos \left(\left(\pi + \pi\right) \cdot z0\right)\right)
\end{array}
Initial program 56.9%
Applied rewrites59.1%
lift-cos.f64N/A
lift-+.f64N/A
lift-*.f64N/A
*-commutativeN/A
metadata-evalN/A
mult-flipN/A
lift-PI.f64N/A
cos-+PI/2-revN/A
sin-+PI-revN/A
lower-sin.f64N/A
lift-PI.f64N/A
lower-+.f6498.6%
Applied rewrites98.6%
(FPCore (z0)
:precision binary64
(if (<=
(cos (* (fabs z0) (+ PI PI)))
-5764607523034235/288230376151711744)
(- (cos (* 2 (- (* PI (fabs z0)) (* -1/2 PI)))))
(-
1/2
(-
(* -1/2 (cos (* (+ (fabs z0) (fabs z0)) PI)))
(* (cos (* (- 1/2 (fabs z0)) PI)) (sin (* (- PI) (fabs z0))))))))double code(double z0) {
double tmp;
if (cos((fabs(z0) * (((double) M_PI) + ((double) M_PI)))) <= -0.02) {
tmp = -cos((2.0 * ((((double) M_PI) * fabs(z0)) - (-0.5 * ((double) M_PI)))));
} else {
tmp = 0.5 - ((-0.5 * cos(((fabs(z0) + fabs(z0)) * ((double) M_PI)))) - (cos(((0.5 - fabs(z0)) * ((double) M_PI))) * sin((-((double) M_PI) * fabs(z0)))));
}
return tmp;
}
public static double code(double z0) {
double tmp;
if (Math.cos((Math.abs(z0) * (Math.PI + Math.PI))) <= -0.02) {
tmp = -Math.cos((2.0 * ((Math.PI * Math.abs(z0)) - (-0.5 * Math.PI))));
} else {
tmp = 0.5 - ((-0.5 * Math.cos(((Math.abs(z0) + Math.abs(z0)) * Math.PI))) - (Math.cos(((0.5 - Math.abs(z0)) * Math.PI)) * Math.sin((-Math.PI * Math.abs(z0)))));
}
return tmp;
}
def code(z0): tmp = 0 if math.cos((math.fabs(z0) * (math.pi + math.pi))) <= -0.02: tmp = -math.cos((2.0 * ((math.pi * math.fabs(z0)) - (-0.5 * math.pi)))) else: tmp = 0.5 - ((-0.5 * math.cos(((math.fabs(z0) + math.fabs(z0)) * math.pi))) - (math.cos(((0.5 - math.fabs(z0)) * math.pi)) * math.sin((-math.pi * math.fabs(z0))))) return tmp
function code(z0) tmp = 0.0 if (cos(Float64(abs(z0) * Float64(pi + pi))) <= -0.02) tmp = Float64(-cos(Float64(2.0 * Float64(Float64(pi * abs(z0)) - Float64(-0.5 * pi))))); else tmp = Float64(0.5 - Float64(Float64(-0.5 * cos(Float64(Float64(abs(z0) + abs(z0)) * pi))) - Float64(cos(Float64(Float64(0.5 - abs(z0)) * pi)) * sin(Float64(Float64(-pi) * abs(z0)))))); end return tmp end
function tmp_2 = code(z0) tmp = 0.0; if (cos((abs(z0) * (pi + pi))) <= -0.02) tmp = -cos((2.0 * ((pi * abs(z0)) - (-0.5 * pi)))); else tmp = 0.5 - ((-0.5 * cos(((abs(z0) + abs(z0)) * pi))) - (cos(((0.5 - abs(z0)) * pi)) * sin((-pi * abs(z0))))); end tmp_2 = tmp; end
code[z0_] := If[LessEqual[N[Cos[N[(N[Abs[z0], $MachinePrecision] * N[(Pi + Pi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], -5764607523034235/288230376151711744], (-N[Cos[N[(2 * N[(N[(Pi * N[Abs[z0], $MachinePrecision]), $MachinePrecision] - N[(-1/2 * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), N[(1/2 - N[(N[(-1/2 * N[Cos[N[(N[(N[Abs[z0], $MachinePrecision] + N[Abs[z0], $MachinePrecision]), $MachinePrecision] * Pi), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - N[(N[Cos[N[(N[(1/2 - N[Abs[z0], $MachinePrecision]), $MachinePrecision] * Pi), $MachinePrecision]], $MachinePrecision] * N[Sin[N[((-Pi) * N[Abs[z0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\mathbf{if}\;\cos \left(\left|z0\right| \cdot \left(\pi + \pi\right)\right) \leq \frac{-5764607523034235}{288230376151711744}:\\
\;\;\;\;-\cos \left(2 \cdot \left(\pi \cdot \left|z0\right| - \frac{-1}{2} \cdot \pi\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{2} - \left(\frac{-1}{2} \cdot \cos \left(\left(\left|z0\right| + \left|z0\right|\right) \cdot \pi\right) - \cos \left(\left(\frac{1}{2} - \left|z0\right|\right) \cdot \pi\right) \cdot \sin \left(\left(-\pi\right) \cdot \left|z0\right|\right)\right)\\
\end{array}
if (cos.f64 (*.f64 z0 (+.f64 (PI.f64) (PI.f64)))) < -0.02Initial program 56.9%
lift-cos.f64N/A
lift-*.f64N/A
lift-+.f64N/A
distribute-lft-inN/A
cos-sumN/A
difference-of-squaresN/A
lower-*.f64N/A
lower-+.f64N/A
lower-cos.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-sin.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower--.f64N/A
Applied rewrites56.9%
lift-*.f64N/A
lift-+.f64N/A
lift--.f64N/A
difference-of-squares-revN/A
sub-negate-revN/A
sqr-neg-revN/A
lift-sin.f64N/A
cos-+PI/2-revN/A
lift-sin.f64N/A
cos-+PI/2-revN/A
Applied rewrites57.0%
if -0.02 < (cos.f64 (*.f64 z0 (+.f64 (PI.f64) (PI.f64)))) Initial program 56.9%
Applied rewrites59.1%
Applied rewrites59.0%
lift-cos.f64N/A
sin-+PI/2-revN/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-neg.f64N/A
fp-cancel-sub-sign-invN/A
lift-*.f64N/A
lift--.f64N/A
lift-PI.f64N/A
mult-flip-revN/A
metadata-evalN/A
*-commutativeN/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
lift-*.f64N/A
lift--.f64N/A
Applied rewrites60.5%
Applied rewrites59.1%
(FPCore (z0)
:precision binary64
(let* ((t_0 (cos (* (fabs z0) (+ PI PI)))))
(if (<= t_0 -1152921504606847/1152921504606846976)
(- (cos (* 2 (- (* PI (fabs z0)) (* -1/2 PI)))))
t_0)))double code(double z0) {
double t_0 = cos((fabs(z0) * (((double) M_PI) + ((double) M_PI))));
double tmp;
if (t_0 <= -0.001) {
tmp = -cos((2.0 * ((((double) M_PI) * fabs(z0)) - (-0.5 * ((double) M_PI)))));
} else {
tmp = t_0;
}
return tmp;
}
public static double code(double z0) {
double t_0 = Math.cos((Math.abs(z0) * (Math.PI + Math.PI)));
double tmp;
if (t_0 <= -0.001) {
tmp = -Math.cos((2.0 * ((Math.PI * Math.abs(z0)) - (-0.5 * Math.PI))));
} else {
tmp = t_0;
}
return tmp;
}
def code(z0): t_0 = math.cos((math.fabs(z0) * (math.pi + math.pi))) tmp = 0 if t_0 <= -0.001: tmp = -math.cos((2.0 * ((math.pi * math.fabs(z0)) - (-0.5 * math.pi)))) else: tmp = t_0 return tmp
function code(z0) t_0 = cos(Float64(abs(z0) * Float64(pi + pi))) tmp = 0.0 if (t_0 <= -0.001) tmp = Float64(-cos(Float64(2.0 * Float64(Float64(pi * abs(z0)) - Float64(-0.5 * pi))))); else tmp = t_0; end return tmp end
function tmp_2 = code(z0) t_0 = cos((abs(z0) * (pi + pi))); tmp = 0.0; if (t_0 <= -0.001) tmp = -cos((2.0 * ((pi * abs(z0)) - (-0.5 * pi)))); else tmp = t_0; end tmp_2 = tmp; end
code[z0_] := Block[{t$95$0 = N[Cos[N[(N[Abs[z0], $MachinePrecision] * N[(Pi + Pi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[t$95$0, -1152921504606847/1152921504606846976], (-N[Cos[N[(2 * N[(N[(Pi * N[Abs[z0], $MachinePrecision]), $MachinePrecision] - N[(-1/2 * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), t$95$0]]
\begin{array}{l}
t_0 := \cos \left(\left|z0\right| \cdot \left(\pi + \pi\right)\right)\\
\mathbf{if}\;t\_0 \leq \frac{-1152921504606847}{1152921504606846976}:\\
\;\;\;\;-\cos \left(2 \cdot \left(\pi \cdot \left|z0\right| - \frac{-1}{2} \cdot \pi\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
if (cos.f64 (*.f64 z0 (+.f64 (PI.f64) (PI.f64)))) < -1e-3Initial program 56.9%
lift-cos.f64N/A
lift-*.f64N/A
lift-+.f64N/A
distribute-lft-inN/A
cos-sumN/A
difference-of-squaresN/A
lower-*.f64N/A
lower-+.f64N/A
lower-cos.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-sin.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower--.f64N/A
Applied rewrites56.9%
lift-*.f64N/A
lift-+.f64N/A
lift--.f64N/A
difference-of-squares-revN/A
sub-negate-revN/A
sqr-neg-revN/A
lift-sin.f64N/A
cos-+PI/2-revN/A
lift-sin.f64N/A
cos-+PI/2-revN/A
Applied rewrites57.0%
if -1e-3 < (cos.f64 (*.f64 z0 (+.f64 (PI.f64) (PI.f64)))) Initial program 56.9%
(FPCore (z0)
:precision binary64
(let* ((t_0 (cos (* (fabs z0) (+ PI PI)))))
(if (<= t_0 3602879701896397/36028797018963968)
(sin (* (- PI) (+ (+ (fabs z0) (fabs z0)) -1/2)))
t_0)))double code(double z0) {
double t_0 = cos((fabs(z0) * (((double) M_PI) + ((double) M_PI))));
double tmp;
if (t_0 <= 0.1) {
tmp = sin((-((double) M_PI) * ((fabs(z0) + fabs(z0)) + -0.5)));
} else {
tmp = t_0;
}
return tmp;
}
public static double code(double z0) {
double t_0 = Math.cos((Math.abs(z0) * (Math.PI + Math.PI)));
double tmp;
if (t_0 <= 0.1) {
tmp = Math.sin((-Math.PI * ((Math.abs(z0) + Math.abs(z0)) + -0.5)));
} else {
tmp = t_0;
}
return tmp;
}
def code(z0): t_0 = math.cos((math.fabs(z0) * (math.pi + math.pi))) tmp = 0 if t_0 <= 0.1: tmp = math.sin((-math.pi * ((math.fabs(z0) + math.fabs(z0)) + -0.5))) else: tmp = t_0 return tmp
function code(z0) t_0 = cos(Float64(abs(z0) * Float64(pi + pi))) tmp = 0.0 if (t_0 <= 0.1) tmp = sin(Float64(Float64(-pi) * Float64(Float64(abs(z0) + abs(z0)) + -0.5))); else tmp = t_0; end return tmp end
function tmp_2 = code(z0) t_0 = cos((abs(z0) * (pi + pi))); tmp = 0.0; if (t_0 <= 0.1) tmp = sin((-pi * ((abs(z0) + abs(z0)) + -0.5))); else tmp = t_0; end tmp_2 = tmp; end
code[z0_] := Block[{t$95$0 = N[Cos[N[(N[Abs[z0], $MachinePrecision] * N[(Pi + Pi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[t$95$0, 3602879701896397/36028797018963968], N[Sin[N[((-Pi) * N[(N[(N[Abs[z0], $MachinePrecision] + N[Abs[z0], $MachinePrecision]), $MachinePrecision] + -1/2), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], t$95$0]]
\begin{array}{l}
t_0 := \cos \left(\left|z0\right| \cdot \left(\pi + \pi\right)\right)\\
\mathbf{if}\;t\_0 \leq \frac{3602879701896397}{36028797018963968}:\\
\;\;\;\;\sin \left(\left(-\pi\right) \cdot \left(\left(\left|z0\right| + \left|z0\right|\right) + \frac{-1}{2}\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
if (cos.f64 (*.f64 z0 (+.f64 (PI.f64) (PI.f64)))) < 0.10000000000000001Initial program 56.9%
lift-cos.f64N/A
cos-neg-revN/A
sin-+PI/2-revN/A
lower-sin.f64N/A
add-flipN/A
lower--.f64N/A
lift-*.f64N/A
lift-+.f64N/A
count-2N/A
associate-*r*N/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
*-commutativeN/A
count-2N/A
lower-+.f64N/A
lower-neg.f64N/A
lift-PI.f64N/A
mult-flipN/A
distribute-rgt-neg-inN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
Applied rewrites56.9%
lift--.f64N/A
lift-*.f64N/A
*-commutativeN/A
fp-cancel-sub-sign-invN/A
metadata-evalN/A
*-commutativeN/A
metadata-evalN/A
mult-flip-revN/A
lift-PI.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-PI.f64N/A
mult-flip-revN/A
metadata-evalN/A
metadata-evalN/A
distribute-rgt-neg-outN/A
distribute-lft-neg-outN/A
lift-neg.f64N/A
distribute-lft-outN/A
lower-*.f64N/A
lower-+.f6456.9%
Applied rewrites56.9%
if 0.10000000000000001 < (cos.f64 (*.f64 z0 (+.f64 (PI.f64) (PI.f64)))) Initial program 56.9%
(FPCore (z0)
:precision binary64
(let* ((t_0 (cos (* (fabs z0) (+ PI PI)))))
(if (<= t_0 -5764607523034235/288230376151711744)
(sin (* PI (+ 1/2 (+ (fabs z0) (fabs z0)))))
t_0)))double code(double z0) {
double t_0 = cos((fabs(z0) * (((double) M_PI) + ((double) M_PI))));
double tmp;
if (t_0 <= -0.02) {
tmp = sin((((double) M_PI) * (0.5 + (fabs(z0) + fabs(z0)))));
} else {
tmp = t_0;
}
return tmp;
}
public static double code(double z0) {
double t_0 = Math.cos((Math.abs(z0) * (Math.PI + Math.PI)));
double tmp;
if (t_0 <= -0.02) {
tmp = Math.sin((Math.PI * (0.5 + (Math.abs(z0) + Math.abs(z0)))));
} else {
tmp = t_0;
}
return tmp;
}
def code(z0): t_0 = math.cos((math.fabs(z0) * (math.pi + math.pi))) tmp = 0 if t_0 <= -0.02: tmp = math.sin((math.pi * (0.5 + (math.fabs(z0) + math.fabs(z0))))) else: tmp = t_0 return tmp
function code(z0) t_0 = cos(Float64(abs(z0) * Float64(pi + pi))) tmp = 0.0 if (t_0 <= -0.02) tmp = sin(Float64(pi * Float64(0.5 + Float64(abs(z0) + abs(z0))))); else tmp = t_0; end return tmp end
function tmp_2 = code(z0) t_0 = cos((abs(z0) * (pi + pi))); tmp = 0.0; if (t_0 <= -0.02) tmp = sin((pi * (0.5 + (abs(z0) + abs(z0))))); else tmp = t_0; end tmp_2 = tmp; end
code[z0_] := Block[{t$95$0 = N[Cos[N[(N[Abs[z0], $MachinePrecision] * N[(Pi + Pi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[t$95$0, -5764607523034235/288230376151711744], N[Sin[N[(Pi * N[(1/2 + N[(N[Abs[z0], $MachinePrecision] + N[Abs[z0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], t$95$0]]
\begin{array}{l}
t_0 := \cos \left(\left|z0\right| \cdot \left(\pi + \pi\right)\right)\\
\mathbf{if}\;t\_0 \leq \frac{-5764607523034235}{288230376151711744}:\\
\;\;\;\;\sin \left(\pi \cdot \left(\frac{1}{2} + \left(\left|z0\right| + \left|z0\right|\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
if (cos.f64 (*.f64 z0 (+.f64 (PI.f64) (PI.f64)))) < -0.02Initial program 56.9%
lift-cos.f64N/A
sin-+PI/2-revN/A
lower-sin.f64N/A
+-commutativeN/A
lift-PI.f64N/A
mult-flipN/A
lift-*.f64N/A
lift-+.f64N/A
distribute-lft-inN/A
distribute-rgt-outN/A
distribute-lft-outN/A
lower-*.f64N/A
count-2N/A
*-commutativeN/A
lower-+.f64N/A
metadata-evalN/A
*-commutativeN/A
count-2N/A
lower-+.f6456.9%
Applied rewrites56.9%
if -0.02 < (cos.f64 (*.f64 z0 (+.f64 (PI.f64) (PI.f64)))) Initial program 56.9%
herbie shell --seed 2025277 -o generate:taylor -o generate:evaluate
(FPCore (z0)
:name "(cos (* z0 (+ PI PI)))"
:precision binary64
(cos (* z0 (+ PI PI))))