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