malachite_float/float/arithmetic/

cos.rs

// Copyright © 2026 Mikhail Hogrefe
//
// Uses code adopted from the GNU MPFR Library.
//
//      Copyright © 2001-2025 Free Software Foundation, Inc.
//
//      Contributed by the Pascaline and Caramba projects, INRIA.
//
// This file is part of Malachite.
//
// Malachite is free software: you can redistribute it and/or modify it under the terms of the GNU
// Lesser General Public License (LGPL) as published by the Free Software Foundation; either version
// 3 of the License, or (at your option) any later version. See <https://www.gnu.org/licenses/>.

// Port of MPFR's cosine. `mpfr_cos` (`cos.c`) reduces an argument with |x| >= 4 modulo 2 pi using
// `mpfr_remainder`, halves the (squared) reduced argument K times, sums the Taylor series of cos in
// integer arithmetic (`mpfr_cos2_aux`), and undoes the halvings with cos(2x) = 2cos^2(x) - 1, all
// inside a Ziv loop. For precisions at or above `SINCOS_THRESHOLD`, the binary-splitting tier
// `sin_cos_fast` in sin_cos.rs (MPFR's `mpfr_cos_fast`, built on `mpfr_sincos_fast`) is used
// instead.

use crate::InnerFloat::{Finite, Infinity, NaN, Zero};
use crate::float::arithmetic::exp::{get_z_2exp, one_neighbor};
use crate::float::arithmetic::round_near_x::float_round_near_x;
use crate::float::arithmetic::sin_cos::{SINCOS_THRESHOLD, sin_cos_fast};
use crate::{ComparableFloatRef, Float, emulate_float_to_float_fn, emulate_rational_to_float_fn};
use core::cmp::Ordering::{self, Equal, Greater, Less};
use core::cmp::{max, min};
use malachite_base::fail_on_untested_path;
use malachite_base::num::arithmetic::traits::{
    Abs, CeilingLogBase2, Cos, CosAssign, DivRoundAssign, FloorLogBase2, FloorSqrt, Mod,
    ModPowerOf2, NegAssign, Parity, PowerOf2, Square, SubMul, UnsignedAbs,
};
use malachite_base::num::basic::floats::PrimitiveFloat;
use malachite_base::num::basic::integers::PrimitiveInt;
use malachite_base::num::basic::traits::{NaN as NaNTrait, One, Zero as ZeroTrait};
use malachite_base::num::comparison::traits::PartialOrdAbs;
use malachite_base::num::conversion::traits::{ExactFrom, RoundingFrom};
use malachite_base::num::logic::traits::SignificantBits;
use malachite_base::rounding_modes::RoundingMode::{self, *};
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
use malachite_nz::natural::arithmetic::float::round::float_can_round;
use malachite_nz::platform::Limb;
use malachite_q::Rational;

// f <- 1 - r/2! + r^2/4! + ... + (-1)^l r^l/(2l)! + ...
//
// Assumes |r| < 1/2, and f, r have the same precision. Returns e such that the error on f is
// bounded by 2^e ulps.
//
// The smallest i such that i*(i+1) might not fit in a u64. Reaching it would take 2^32 terms, so
// the two-step division below is never exercised in practice.
const MAXI: u64 = 1 << (u64::WIDTH >> 1);

// This is mpfr_cos2_aux from cos.c, MPFR 4.2.2.
fn cos2_aux(r: &Float, p: u64) -> (Float, u64) {
    let exp_r = i64::from(r.get_exponent().unwrap());
    assert!(exp_r <= -1);
    let (mut x, mut ex) = get_z_2exp(r.clone()); // r = x*2^ex
    // Remove trailing zeroes. Since x comes from a regular MPFR number, due to the constraints on
    // the exponent and the precision, there can be no integer overflow below.
    let l = x.trailing_zeros().unwrap();
    ex += i64::exact_from(l);
    x >>= l;
    // since |r| < 1, r = x*2^ex, and x is an integer, necessarily ex < 0 bound for number of
    // iterations
    let mut imax = p / u64::exact_from(-exp_r);
    imax += u64::from(imax == 0);
    let q = (imax.ceiling_log_base_2() << 1) + 4; // bound for (3l)^2
    let mut s = Integer::power_of_2(p + q); // initialize sum with 1, scaled by 2^(p+q)
    let mut t = s.clone(); // invariant: t is previous term
    let mut i: u64 = 1;
    loop {
        let m = t.significant_bits();
        if m < q {
            break;
        }
        // adjust precision of x to that of t
        let mut l = x.significant_bits();
        if l > m {
            l -= m;
            x >>= l;
            ex += i64::exact_from(l);
        }
        // multiply t by r
        t *= &x;
        t >>= u64::exact_from(-ex);
        // divide t by i*(i+1)
        if i < MAXI {
            t.div_round_assign(Integer::from(i * (i + 1)), Floor);
        } else {
            t.div_round_assign(Integer::from(i), Floor);
            t.div_round_assign(Integer::from(i + 1), Floor);
        }
        // if m is the (current) number of bits of t, we can consider that all operations on t so
        // far had precision >= m, so we can prove by induction that the relative error on t is of
        // the form (1+u)^(3l)-1, where |u| <= 2^(-m), and l=(i+1)/2 is the # of loops. Since
        // |(1+x^2)^(1/x) - 1| <= 4x/3 for |x| <= 1/2, for |u| <= 1/(3l)^2, the absolute error is
        // bounded by 4/3*(3l)*2^(-m)*t <= 4*l since |t| < 2^m. Therefore the error on s is bounded
        // by 2*l*(l+1).
        //
        // add or subtract to s
        if i % 4 == 1 {
            s -= &t;
        } else {
            s += &t;
        }
        i += 2;
    }
    let f = Float::from_integer_prec(s, p).0 >> (p + q);
    let l = (i - 1) >> 1; // number of iterations
    (f, ((l + 1).ceiling_log_base_2() << 1) + 1) // bound is 2l(l+1)
}

// Returns a partial sum S_k = t - t^3/3! + ... of the sine series for a `Rational` t with |t| < 1,
// which is an upper bound on sin(t) if `upper` is true and a lower bound otherwise, and is within
// |t| 2^-(w + 2) of sin(t). The bound thus tightens with the working precision w, unlike a fixed
// bound such as t - t^3/6 <= sin(t) <= t, which for |t| near 2^-64 leaves a relative gap of about
// 2^-128 that no amount of pi precision can close.
//
// The series alternates with decreasing terms, so |sin(t) - S_k| <= |t|^(2k + 1) / (2k + 1)!, and
// S_k is above sin(t) exactly when the omitted term t^(2k + 1) / (2k + 1)! is negative, i.e. when k
// is odd and t > 0, or k is even and t < 0. The number of terms is chosen from the bit length of t
// alone, so when the first term suffices (as in underflow cases, where |t| is tiny) t itself, or t
// shifted by the error margin, is the bound, and no product is formed.
pub(crate) fn sin_bound(t: &Rational, w: u64, upper: bool) -> Rational {
    if *t == 0u32 {
        return Rational::ZERO;
    }
    // |t| < 2^(log + 1), with log < 0
    let log = t.floor_log_base_2_abs();
    assert!(log < 0);
    // |t|^(2k) / (2k + 1)! < 2^(2k (log + 1) - log_factorial), where log_factorial <= log2((2k +
    // 1)!)
    let mut k = 1u64;
    let mut log_factorial = 2u64; // floor(log2(2)) + floor(log2(3))
    let target = -i128::from(w) - 4;
    while i128::from(k << 1) * i128::from(log + 1) - i128::from(log_factorial) > target {
        k += 1;
        let two_k = k << 1;
        log_factorial += two_k.floor_log_base_2() + (two_k + 1).floor_log_base_2();
    }
    let mut s = t.clone();
    if k > 1 {
        let t_squared = t.square();
        let mut term = t.clone();
        for j in 1..k {
            term *= &t_squared;
            term /= Rational::from((j << 1) * ((j << 1) + 1));
            term.neg_assign();
            s += &term;
        }
    }
    // S_k is within |t| 2^-(w + 4) of sin(t). If it bounds sin(t) on the wrong side, moving it by
    // |S_k| 2^-(w + 3) >= |t| 2^-(w + 4) (since |S_k| >= |t| / 2) gives a bound on the right side,
    // within |t| 2^-(w + 2). The move is done as a multiplication by 2^(w + 3) ± 1 followed by a
    // shift, which only reduces a small integer against the denominator; adding a shifted copy
    // would instead take a GCD of two denominators, ruinous when t has a 2^30-bit one. (Taking one
    // more series term would be worse still, squaring t.)
    if upper != ((*t > 0u32) == k.odd()) {
        let shift = w + 3;
        let mut factor = Natural::power_of_2(shift);
        if upper == (s > 0u32) {
            factor += Natural::ONE;
        } else {
            factor -= Natural::ONE;
        }
        s *= Rational::from(factor);
        s >>= shift;
    }
    s
}

// Rounds both ends of an open bracket (lo, hi) known to contain a transcendental value; if the two
// ends round to the same `Float` on the same side of it, that settles the result. The value is
// strictly inside the bracket, so an end that is exactly representable is not itself a candidate:
// values just inside round either to that end (with the `Ordering` of that side) or, when the mode
// rounds them away from it, to its neighbor. (A partial sum of a series can be exactly the input,
// as t is for sin(t); merging the end's own `Equal` with the other side's `Ordering` would then
// never let a directed rounding resolve, however narrow the bracket.) The comparison is
// sign-sensitive, so a bracket straddling or touching zero is never accepted.
pub(crate) fn round_bracket(
    lo: &Rational,
    hi: &Rational,
    prec: u64,
    rm: RoundingMode,
) -> Option<(Float, Ordering)> {
    let (mut f_lo, mut o_lo) = Float::from_rational_prec_round_ref(lo, prec, rm);
    let (mut f_hi, mut o_hi) = Float::from_rational_prec_round_ref(hi, prec, rm);
    if o_lo == Equal {
        if f_lo == 0u32 {
            return None;
        }
        // values just above lo
        let up = match rm {
            Ceiling => true,
            Up => f_lo > 0u32,
            Down => f_lo < 0u32,
            _ => false,
        };
        o_lo = if up {
            f_lo.increment();
            Greater
        } else {
            Less
        };
    }
    if o_hi == Equal {
        if f_hi == 0u32 {
            return None;
        }
        // values just below hi
        let down = match rm {
            Floor => true,
            Down => f_hi > 0u32,
            Up => f_hi < 0u32,
            _ => false,
        };
        o_hi = if down {
            f_hi.decrement();
            Less
        } else {
            Greater
        };
    }
    (o_lo == o_hi && ComparableFloatRef(&f_lo) == ComparableFloatRef(&f_hi)).then_some((f_lo, o_lo))
}

// `round_bracket` for the open bracket (2^k lo, 2^k hi) of nonzero Floats of the same sign, scaled
// by a power of 2 so large that its ends would not fit in `Rational`s of reasonable size: each end
// is shifted with the rounding mode, which performs any underflow or overflow rounding. As in
// `round_bracket`, an end that is exactly representable after the shift is not itself a candidate,
// since the value is strictly inside the bracket.
pub(crate) fn round_scaled_bracket(
    lo: &Float,
    hi: &Float,
    k: i64,
    prec: u64,
    rm: RoundingMode,
) -> Option<(Float, Ordering)> {
    let (mut f_lo, mut o_lo) = lo.shl_prec_round_ref(k, prec, rm);
    let (mut f_hi, mut o_hi) = hi.shl_prec_round_ref(k, prec, rm);
    if o_lo == Equal {
        // an end with all-zero bits below the output precision values just above lo
        let up = match rm {
            Ceiling => true,
            Up => f_lo > 0u32,
            Down => f_lo < 0u32,
            _ => false,
        };
        o_lo = if up {
            f_lo.increment();
            Greater
        } else {
            Less
        };
    }
    if o_hi == Equal {
        // an end with all-zero bits below the output precision; not reached by any test
        fail_on_untested_path("round_scaled_bracket, exact upper end");
        // values just below hi
        let down = match rm {
            Floor => true,
            Down => f_hi > 0u32,
            Up => f_hi < 0u32,
            _ => false,
        };
        o_hi = if down {
            f_hi.decrement();
            Less
        } else {
            Greater
        };
    }
    (o_lo == o_hi && ComparableFloatRef(&f_lo) == ComparableFloatRef(&f_hi)).then_some((f_lo, o_lo))
}

// cos(x) for a nonzero x so small that 1 - x^2/2 <= cos(x) < 1 lies within half an ulp of 1 at
// precision `prec`: the result is 1, or its predecessor for rounding toward zero.
pub(crate) fn cos_rational_tiny(prec: u64, rm: RoundingMode) -> (Float, Ordering) {
    match rm {
        Floor | Down => (one_neighbor(prec, false), Less),
        _ => (Float::one_prec(prec), Greater),
    }
}

// Sums the cosine series 1 - x^2/2! + x^4/4! - ... in `Rational` arithmetic for a nonzero |x| < 1
// too small to be a `Float`. The terms alternate in sign with decreasing magnitude, so cos(x) lies
// between consecutive partial sums, and the bracket is tightened until both ends round the same
// way. Only reachable for a precision beyond 2^31 bits: any smaller precision takes the tiny path.
fn cos_rational_series(x: &Rational, prec: u64, rm: RoundingMode) -> (Float, Ordering) {
    fail_on_untested_path("cos_rational_series");
    let x_squared = x.square();
    let mut s = Rational::ONE;
    let mut term = Rational::ONE;
    let mut k = 1u64;
    loop {
        term *= &x_squared;
        term /= Rational::from((k << 1) * ((k << 1) - 1));
        term.neg_assign();
        let s_next = &s + &term;
        let (lo, hi) = if s < s_next {
            (&s, &s_next)
        } else {
            (&s_next, &s)
        };
        if let Some(result) = round_bracket(lo, hi, prec, rm) {
            return result;
        }
        s = s_next;
        k += 1;
    }
}

// Reduces a `Rational` too large to be a `Float` modulo 2 pi, using pi to exp_x + w bits, so that
// the reduced value y satisfies |x - 2 pi k - y| <= 2^(2 - w): |k| < 2^exp_x, and 2 pi is known to
// within 2^(2 - exp_x - w).
pub(crate) fn reduce_huge(x: &Rational, exp_x: i64, w: u64) -> Rational {
    let two_pi = Rational::exact_from(&(Float::pi_prec(u64::exact_from(exp_x) + w).0 << 1u32));
    let k = Integer::rounding_from(x / &two_pi, Nearest).0;
    x.sub_mul(&two_pi, &Rational::from(k))
}

// cos(y) (if `cos` is true) or sin(y) for a `Rational` y within about 2^-cancel of a zero of the
// function, an odd multiple of pi/2 for cos or a multiple of pi for sin (cancel >= 64 and cancel >=
// prec / 16), where the general bracket would need its working precision raised by `cancel` bits to
// resolve the result. As in `trig_near_zero`, write y = n pi/2 + delta with n odd, so that cos(y) =
// -sin(delta) if n = 1 mod 4 and sin(delta) if n = 3 mod 4, or y = n pi + delta, so that sin(y) =
// (-1)^n sin(delta); here delta is a `Rational` known up to the error in pi, and sin(delta) is
// bracketed by partial sums of its series. `extra`, if present, is the exponent of an additional
// error in y itself (from a reduction modulo 2 pi), and `w` is the working precision the caller
// reached, which is raised until the bracket rounds unambiguously. The bracket of
// `trig_rational_near_zero`, computed with the working precision raised, as there, until the
// bracket is narrower than 2^-(target + 4) relative to the value: for a consumer that combines the
// tiny value with others before rounding (the tangent).
pub(crate) fn trig_rational_near_zero_bracket(
    y: &Rational,
    exp_y: i64,
    extra: Option<i64>,
    mut w: u64,
    target: u64,
    cos: bool,
) -> (Rational, Rational) {
    let mut increment = Limb::WIDTH;
    let w_hint = y.denominator_ref().significant_bits() + target + 64;
    loop {
        let (lo, hi) = trig_rational_near_zero_step(y, exp_y, extra, w, cos);
        if (&hi - &lo) << (target + 4) <= (&lo).abs() {
            return (lo, hi);
        }
        w = max(w + increment, min(w_hint, w << 3));
        increment = w >> 1;
    }
}

// One bracket of `trig_rational_near_zero` at working precision w.
fn trig_rational_near_zero_step(
    y: &Rational,
    exp_y: i64,
    extra: Option<i64>,
    w: u64,
    cos: bool,
) -> (Rational, Rational) {
    let pi = Rational::exact_from(&Float::pi_prec(u64::exact_from(max(exp_y, 1)) + w).0);
    let (n, negate, multiple) = if cos {
        let n = Integer::rounding_from((y / &pi) << 1u32, Nearest).0;
        assert!(n.odd());
        let negate = (&n).mod_power_of_2(2) == 1u32;
        (n, negate, pi >> 1u32)
    } else {
        let n = Integer::rounding_from(y / &pi, Nearest).0;
        let negate = n.odd();
        (n, negate, pi)
    };
    let delta = y.sub_mul(&multiple, &Rational::from(&n));
    let mut e = Rational::power_of_2(1 - i64::exact_from(w));
    if let Some(extra) = extra {
        e += Rational::power_of_2(extra);
    }
    let d_lo = &delta - &e;
    let d_hi = delta + e;
    // |delta| is tiny, so sin is increasing on [d_lo, d_hi] and sin(delta) lies between sin(d_lo)
    // and sin(d_hi)
    let sin_lo = sin_bound(&d_lo, w, false);
    let sin_hi = sin_bound(&d_hi, w, true);
    if negate {
        (-sin_hi, -sin_lo)
    } else {
        (sin_lo, sin_hi)
    }
}

pub(crate) fn trig_rational_near_zero(
    y: &Rational,
    exp_y: i64,
    prec: u64,
    rm: RoundingMode,
    extra: Option<i64>,
    mut w: u64,
    cos: bool,
) -> (Float, Ordering) {
    let mut increment = Limb::WIDTH;
    // A rational y = a/b is typically no closer to n pi/2 than about 1/b (a dyadic approximation of
    // pi/2 to k bits, for instance, is off by about 2^-k), so a precision that resolves delta at
    // that scale is a good first target: as in `cos_near_zero`, w at least grows by half each time
    // and by up to 8 times to reach the hint, so that the early iterations cost a small fraction of
    // the last one.
    let w_hint = y.denominator_ref().significant_bits() + prec + 64;
    loop {
        let (lo, hi) = trig_rational_near_zero_step(y, exp_y, extra, w, cos);
        if let Some(result) = round_bracket(&lo, &hi, prec, rm) {
            return result;
        }
        w = max(w + increment, min(w_hint, w << 3));
        increment = w >> 1;
    }
}

// Computes cos(x) for a nonzero `Rational` x, rounded to precision `prec` with rounding mode `rm`.
// (cos(0) = 1 is handled by the caller.) The cosine of a nonzero rational is transcendental, so the
// result is never exactly representable and `rm` must not be `Exact`.
//
// The general case rounds x to a `Float` y_f at a working precision w, takes its correctly rounded
// cosine c_f, and brackets cos(x) using |cos(x) - cos(y_f)| <= |x - y_f|, the rounding error of
// c_f, and, for an x too large to be a `Float`, the error of a `Rational` reduction modulo 2 pi.
// The bracket is rounded in `Rational` arithmetic, and w is raised until both ends agree. Unlike
// `exp_rational_helper`'s bracket of x itself, this needs no monotonicity.
pub(crate) fn cos_rational_helper(x: &Rational, prec: u64, rm: RoundingMode) -> (Float, Ordering) {
    assert_ne!(rm, Exact, "Inexact cos");
    let exp_x = x.floor_log_base_2_abs() + 1; // the MPFR-style exponent of x
    // 1 - cos(x) <= x^2/2 < 2^(2 exp_x - 1): when that is at most 2^(-prec - 1), cos(x) rounds to 1
    if 1 - (exp_x << 1) > i64::exact_from(prec) {
        return cos_rational_tiny(prec, rm);
    }
    // x is too small to be a `Float` but `prec` is so large that cos(x) does not round to 1
    if exp_x <= Float::MIN_EXPONENT_I64 {
        return cos_rational_series(x, prec, rm);
    }
    let huge = exp_x >= Float::MAX_EXPONENT_I64;
    let mut w = prec + 10;
    let mut increment = Limb::WIDTH;
    loop {
        let reduced;
        let (y, extra) = if huge {
            reduced = reduce_huge(x, exp_x, w);
            (&reduced, Some(2 - i64::exact_from(w)))
        } else {
            (x, None)
        };
        let (y_f, y_o) = Float::from_rational_prec_ref(y, w);
        if !huge && y_o == Equal {
            // x is exactly representable at w bits, so cos(x) is simply its cosine
            return cos_prec_round_normal_ref(&y_f, prec, rm);
        }
        let c_f = (&y_f).cos();
        // The exponents of y and c_f, as `Float`s would have them (y is nonzero, and c_f is zero
        // only if it underflowed, which counts as complete cancellation).
        let exp_y = y.floor_log_base_2_abs() + 1;
        let exp_c = c_f
            .get_exponent()
            .map_or(Float::MIN_EXPONENT_I64, i64::from);
        // |cos(y)| < 2^exp_c (up to the bracket width): heavy cancellation means y is close to an
        // odd multiple of pi/2, where the bracket below would have to be far narrower than 2^-w.
        if exp_c < 0 {
            let cancel = u64::exact_from(-exp_c);
            if cancel >= max(NEAR_ZERO_MIN_CANCEL, prec >> 4) {
                return trig_rational_near_zero(y, exp_y, prec, rm, extra, w, true);
            }
        }
        // |c_f - cos(y_f)| <= 2^(exp_c - w) (half an ulp, doubled for safety), and |cos(y) -
        // cos(y_f)| <= |y - y_f| <= 2^(exp_y - w)
        let w_i = i64::exact_from(w);
        let mut delta = Rational::power_of_2(exp_c - w_i) + Rational::power_of_2(exp_y - w_i);
        if let Some(extra) = extra {
            delta += Rational::power_of_2(extra);
        }
        let c = Rational::exact_from(&c_f);
        if let Some(result) = round_bracket(&(&c - &delta), &(c + delta), prec, rm) {
            return result;
        }
        w += increment;
        increment = w >> 1;
    }
}

// The least number of bits of cancellation (|cos(x)| < 2^-cancel) that sends an input to
// `cos_near_zero`; the cancellation must also be at least prec / 16, so that the Taylor series
// there needs only a handful of terms.
pub(crate) const NEAR_ZERO_MIN_CANCEL: u64 = 64;

// The core of `trig_near_zero` and `trig_near_zero_bracket`: an approximation m 2^shift of the tiny
// value, with |f(x) - m 2^shift| <= 2^(abs_err + shift), computed at working precision w with pi at
// precision p, which is raised as needed to resolve delta to w bits (and left raised, so that a
// retry starts higher). Returns (m, abs_err, shift).
fn trig_near_zero_approx(
    x: &Float,
    w: u64,
    p: &mut u64,
    p_hint: u64,
    cos: bool,
) -> (Integer, u64, i64) {
    // |x| > 1, so its exponent is positive
    let e = u64::exact_from(x.get_exponent().unwrap());
    // n = round(2x / pi) for cos, or round(x / pi) for sin. Since the quotient is within 2^-62 of
    // an integer (an odd one, for cos), 16 bits after the binary point suffice to identify it.
    let mut x_low = Float::from_float_prec_ref(x, e + 16).0;
    if cos {
        x_low <<= 1u32;
    }
    let q = x_low.div_prec(Float::pi_prec(e + 16).0, e + 16).0;
    let n = Integer::rounding_from(q, Nearest).0;
    // cos(n pi/2 + delta) = -sin(delta) if n = 1 mod 4 and sin(delta) if n = 3 mod 4; sin(n pi +
    // delta) = (-1)^n sin(delta)
    let negate = if cos {
        assert!(n.odd());
        (&n).mod_power_of_2(2) == 1u32
    } else {
        assert_ne!(n, 0u32);
        n.odd()
    };
    // x = x_sig * 2^x_exp exactly
    let x_sig = x.significand_ref().unwrap();
    let x_bits = x_sig.significant_bits();
    let x_exp = i64::from(x.get_exponent().unwrap()) - i64::exact_from(x_bits);
    loop {
        // pi_p = pi_sig * 2^pi_exp, with |pi_p - pi| <= 2^(1 - e - p), so |n pi_p / 2 - n pi / 2| <
        // 2^-p, since |n| < 2^e.
        let (pi_sig, mut pi_exp) = get_z_2exp(Float::pi_prec(e + *p).0);
        if cos {
            pi_exp -= 1; // n pi_p / 2 = n pi_sig * 2^pi_exp
        }
        let d_exp = min(x_exp, pi_exp);
        let a = Integer::from_sign_and_abs_ref(x > &0u32, x_sig) << u64::exact_from(x_exp - d_exp);
        let b = (&n * pi_sig) << u64::exact_from(pi_exp - d_exp);
        let d = a - b;
        let d_neg = d < 0u32;
        let mut d_abs = d.unsigned_abs();
        let d_bits = d_abs.significant_bits();
        let delta_exp = d_exp + i64::exact_from(d_bits);
        if delta_exp + i64::exact_from(*p) <= i64::exact_from(w) {
            let needed = u64::exact_from(i64::exact_from(w) - delta_exp + 2);
            *p = max(
                needed,
                min(max(*p << 1, min(p_hint, *p << 3)), max(p_hint, needed)),
            );
            continue;
        }
        let mut d_exp = d_exp;
        if d_bits > w {
            let shift = d_bits - w;
            d_abs >>= shift;
            d_exp += i64::exact_from(shift);
        }
        let q = Integer::from(
            (&d_abs).square() >> u64::exact_from(-((d_exp << 1) + i64::exact_from(w))),
        );
        let mut r = Integer::power_of_2(w);
        let mut term = Integer::power_of_2(w);
        let mut k = 1u64;
        let mut terms = 0u64;
        loop {
            term *= &q;
            term >>= w;
            term.div_round_assign(Integer::from((k << 1) * ((k << 1) + 1)), Floor);
            term.neg_assign();
            if term == 0u32 {
                break;
            }
            r += &term;
            k += 1;
            terms += 1;
        }
        let mut m = Integer::from(d_abs) * r;
        if d_neg != negate {
            m.neg_assign();
        }
        // the truncations of delta and of the series terms each cost a few units in the last place
        // of m, which has w bits beyond the value's leading bit
        return (
            m,
            w + 2 + (terms + 2).ceiling_log_base_2(),
            d_exp - i64::exact_from(w),
        );
    }
}

// The initial precision of pi for `trig_near_zero_approx`, and the precision that resolves delta
// when x is n pi/2 or n pi rounded to its own precision (see `trig_near_zero`).
fn trig_near_zero_pi_precs(x: &Float, w: u64, cancel: u64) -> (u64, u64) {
    let e = u64::exact_from(x.get_exponent().unwrap());
    let x_bits = x.significand_ref().unwrap().significant_bits();
    (w + cancel + 2, (x_bits + w + 2).saturating_sub(e))
}

// Computes cos(x) (if `cos` is true) or sin(x) for an x within about 2^-cancel of a zero of the
// function, an odd multiple of pi/2 for cos or a nonzero multiple of pi for sin, so that the result
// is below 2^-cancel in magnitude, where cancel >= 64 and cancel >= prec / 16.
//
// The Ziv loops in `cos_prec_round_normal_ref` and `sin_prec_round_normal_ref` would have to raise
// their working precision by `cancel` bits to resolve such a result, and their schemes become
// prohibitively slow long before `cancel` reaches 2^30, where the result underflows. Instead, write
// x = n pi/2 + delta with n odd, so that cos(x) = -sin(delta) if n = 1 mod 4 and sin(delta) if n =
// 3 mod 4, or x = n pi + delta, so that sin(x) = (-1)^n sin(delta). delta is computed exactly in
// integer arithmetic from x and an approximation of pi, and sin(delta)/delta from its Taylor
// series, which converges very quickly since |delta| is tiny. Everything is done in integers scaled
// by explicit powers of 2, so values far below the exponent range are no problem, and only the
// final `shl_prec_round` can underflow.
//
// This has no MPFR counterpart: MPFR's exponent range is so wide that cos and sin never underflow
// there, and `mpfr_cos` and `mpfr_sin` simply keep raising their working precisions.
pub(crate) fn trig_near_zero(
    x: &Float,
    prec: u64,
    rm: RoundingMode,
    cancel: u64,
    cos: bool,
) -> (Float, Ordering) {
    // The working precision: delta and sin(delta) / delta are computed to w bits.
    let w = prec + 64;
    // The precision of pi: since |delta| < 2^(1 - cancel), delta is resolved to w bits once p
    // exceeds w + cancel, unless delta is even smaller than the cancellation suggests. In that
    // case, x is typically n pi/2 rounded to its own precision, so that |delta| is about 2^(e -
    // x_bits), and p_hint is the precision that resolves that. The precision at least doubles each
    // time, and grows by up to 8 times to reach p_hint, so that the cost of the early iterations is
    // a small fraction of that of the last one, without wildly overshooting if x is only stored at
    // a higher precision than the one it agrees with n pi/2 to.
    let (mut p, p_hint) = trig_near_zero_pi_precs(x, w, cancel);
    loop {
        let (m, abs_err, shift) = trig_near_zero_approx(x, w, &mut p, p_hint, cos);
        let m_bits = m.significant_bits();
        assert!(m_bits <= const { Float::MAX_EXPONENT as u64 });
        let err = m_bits - abs_err;
        let s = Float::from_integer_prec(m, m_bits).0;
        if float_can_round(s.significand_ref().unwrap(), err, prec, rm) {
            return s.shl_prec_round(shift, prec, rm);
        }
        p += max(p >> 2, Limb::WIDTH);
    }
}

// A `Rational` bracket [lo, hi] containing cos(x) or sin(x), as for `trig_near_zero`, about 2^-w
// wide relative to the value: for a consumer that combines the tiny value with others before
// rounding (the tangent).
pub(crate) fn trig_near_zero_bracket(
    x: &Float,
    w: u64,
    cancel: u64,
    cos: bool,
) -> (Rational, Rational) {
    let (mut p, p_hint) = trig_near_zero_pi_precs(x, w, cancel);
    let (m, abs_err, shift) = trig_near_zero_approx(x, w, &mut p, p_hint, cos);
    let e = Integer::power_of_2(abs_err);
    (
        Rational::from(&m - &e) << shift,
        Rational::from(m + e) << shift,
    )
}

pub(crate) enum TrigStep {
    // The working precision could not decide the result; retry at a higher one.
    Retry,
    // The result at the working precision, ready for the final rounding.
    Done(Float),
    // The input is within about 2^-cancel of a zero of the function, so the result is below
    // 2^-cancel in magnitude and `trig_near_zero` resolves it directly.
    NearZero(u64),
}

// One iteration of the Ziv loop at working precision `m`, which the cancellation check may raise
// for the next iteration (the caller applies the generic increase on `Retry`). `cancel` tracks the
// exponent of the smallest sum seen so far, so that the precision is only raised once per lost bit.
fn cos_ziv_step(
    x: &Float,
    exp_x: i64,
    prec: u64,
    rm: RoundingMode,
    reduce: bool,
    k0: u64,
    m: &mut u64,
    cancel: &mut i64,
) -> TrigStep {
    // If |x| >= 4, first reduce x cmod (2*Pi) into xr, using mpfr_remainder: let e = EXP(x) >= 3,
    // and m the target precision:
    // ```
    // (1) c <- 2*Pi              [precision e+m-1, nearest]
    // (2) xr <- remainder (x, c) [precision m, nearest]
    // We have |c - 2*Pi| <= 1/2ulp(c) = 2^(3-e-m)
    //         |xr - x - k c| <= 1/2ulp(xr) <= 2^(1-m)
    //         |k| <= |x|/(2*Pi) <= 2^(e-2)
    // Thus |xr - x - 2kPi| <= |k| |c - 2Pi| + 2^(1-m) <= 2^(2-m).
    // It follows |cos(xr) - cos(x)| <= 2^(2-m).
    // ```
    let mut r = if reduce {
        let c = Float::pi_prec(u64::exact_from(exp_x) + *m - 1).0 << 1u32; // 2Pi
        let xr = x.ieee_remainder_prec_ref_val(c, *m).0;
        if xr == 0u32 {
            return TrigStep::Retry;
        }
        // now |xr| <= 4, thus r <= 16 below
        xr.square_round(Ceiling).0 // err <= 1 ulp
    } else {
        x.square_prec_round_ref(*m, Ceiling).0 // err <= 1 ulp
    };
    // now |x| < 4 (or xr if reduce = 1), thus |r| <= 16 we need |r| < 1/2 for mpfr_cos2_aux, i.e.,
    // EXP(r) - 2K <= -1
    let exp_r = i64::from(r.get_exponent().unwrap());
    let k = k0 + 1 + (u64::exact_from(max(0, exp_r)) >> 1);
    // since K0 >= 0, if EXP(r) < 0, then K >= 1, thus EXP(r) - 2K <= -3; otherwise if EXP(r) >= 0,
    // then K >= 1/2 + EXP(r)/2, thus EXP(r) - 2K <= -1
    r >>= k << 1; // Can't overflow!
    // s <- 1 - r/2! + ... + (-1)^l r^l/(2l)!
    let (mut s, err_ulps) = cos2_aux(&r, *m);
    // err_ulps is the error bound in ulps on s
    let one = Float::one_prec(*m);
    for _ in 0..k {
        s.square_prec_round_assign(*m, Ceiling); // err <= 2*olderr
        s <<= 1u32; // Can't overflow
        s.sub_prec_assign_ref(&one, *m); // err <= 4*olderr
        if s == 0u32 {
            fail_on_untested_path("cos_ziv_step, s == 0 after doubling");
            return TrigStep::Retry;
        }
        assert!(s.get_exponent().unwrap() <= 1);
    }
    // The absolute error on s is bounded by (2l+1/3)*2^(2K-m) 2l+1/3 <= 2l+1. If |x| >= 4, we need
    // to add 2^(2-m) for the argument reduction by 2Pi: if K = 0, this amounts to add 4 to 2l+1/3,
    // i.e., to add 2 to l; if K >= 1, this amounts to add 1 to 2*l+1/3. (K >= 1 always holds here,
    // since K0 >= 0, so the K = 0 case in the C code is dead.)
    let mut err_ulps = (err_ulps << 1) + 1;
    if reduce {
        err_ulps += 1;
    }
    let err_bits = err_ulps.ceiling_log_base_2() + (k << 1);
    // now the error is bounded by 2^(err_bits-m) = 2^(EXP(s)-err)
    let exp_s = i64::from(s.get_exponent().unwrap());
    let err = exp_s + i64::exact_from(*m) - i64::exact_from(err_bits);
    if err > 0 && float_can_round(s.significand_ref().unwrap(), u64::exact_from(err), prec, rm) {
        return TrigStep::Done(s);
    }
    if exp_s == 1 && *m > err_bits && *m - err_bits >= prec + u64::from(rm == Nearest) {
        // s = 1 or -1, and except x=0 which was already checked above, cos(x) cannot be 1 or -1, so
        // we can round if the error is less than 2^(-precy) for directed rounding, or 2^(-precy-1)
        // for rounding to nearest.
        //
        // If round to nearest or away, result is s = 1 or -1, otherwise it is round(nexttoward (s,
        // 0)). However, in order to have the inexact flag correctly set below, we set |s| to 1 -
        // 2^(-m) in all cases.
        let neighbor = one_neighbor(*m, false);
        return TrigStep::Done(if s < 0u32 { -neighbor } else { neighbor });
    }
    // |cos(x)| < 2^bound
    let bound = max(exp_s, i64::exact_from(err_bits) - i64::exact_from(*m)) + 1;
    if bound < 0 {
        let c = u64::exact_from(-bound);
        if c >= max(NEAR_ZERO_MIN_CANCEL, prec >> 4) {
            return TrigStep::NearZero(c);
        }
    }
    if exp_s < *cancel {
        *m += u64::exact_from(*cancel - exp_s);
        *cancel = exp_s;
    }
    TrigStep::Retry
}

// This is mpfr_cos from cos.c, MPFR 4.2.2, including the `mpfr_cos_fast` tier for precisions at or
// above `SINCOS_THRESHOLD`.
fn cos_prec_round_normal_ref(x: &Float, prec: u64, rm: RoundingMode) -> (Float, Ordering) {
    assert_ne!(rm, Exact, "Inexact cos");
    // cos(x) = 1-x^2/2 + ..., so error < 2^(2*EXP(x)-1)
    let exp_x = i64::from(x.get_exponent().unwrap());
    // MPFR_SMALL_INPUT_AFTER_SAVE_EXPO (y, __gmpfr_one, -2 * expx, 1, 0, rnd_mode, expo, {});
    let neg_err = -(exp_x << 1);
    if neg_err > 0 {
        let err = u64::exact_from(neg_err) + 1;
        if err > prec + 1 {
            // The reference value 1 has precision 1 < err, so float_round_near_x always succeeds.
            // The error bound only has to clear prec + 1; passing an enormous err (a tiny x has one
            // around 2^31) would make float_round_near_x do work proportional to it.
            return float_round_near_x(&Float::ONE, min(err, prec + 2), false, prec, rm).unwrap();
        }
    }
    // Compute initial precision
    if prec >= SINCOS_THRESHOLD {
        return sin_cos_fast(x, prec, rm, false, true).1.unwrap();
    }
    cos_basic(x, exp_x, prec, rm)
}

// The basic tier of `cos_prec_round_normal_ref`: the Ziv loop of `mpfr_cos`, for a finite nonzero x
// of exponent `exp_x` that the small-input shortcut did not settle.
pub(crate) fn cos_basic(x: &Float, exp_x: i64, prec: u64, rm: RoundingMode) -> (Float, Ordering) {
    let k0 = (prec / 3).floor_sqrt();
    let mut m = prec + (prec.ceiling_log_base_2() << 1) + (k0 << 1) + 4;
    let reduce = exp_x >= 3;
    let mut cancel: i64 = 0;
    let mut increment = Limb::WIDTH;
    let s = loop {
        match cos_ziv_step(x, exp_x, prec, rm, reduce, k0, &mut m, &mut cancel) {
            TrigStep::Done(s) => break s,
            TrigStep::NearZero(c) => return trig_near_zero(x, prec, rm, c, true),
            TrigStep::Retry => {}
        }
        // ziv_next: MPFR_ZIV_NEXT (loop, m);
        m += increment;
        increment = m >> 1;
    };
    Float::from_float_prec_round(s, prec, rm)
}

impl Float {
    /// Computes $\cos x$, the cosine of a [`Float`], rounding the result to the specified precision
    /// and with the specified rounding mode. The [`Float`] is taken by value. An [`Ordering`] is
    /// also returned, indicating whether the rounded cosine is less than, equal to, or greater than
    /// the exact cosine. Although `NaN`s are not comparable to any [`Float`], whenever this
    /// function returns a `NaN` it also returns `Equal`.
    ///
    /// See [`RoundingMode`] for a description of the possible rounding modes.
    ///
    /// $$
    /// f(x,p,m) = \cos x+\varepsilon.
    /// $$
    /// - If $x$ is not finite, $\varepsilon$ may be ignored or assumed to be 0.
    /// - If $x$ is finite and $m$ is not `Nearest`, then $|\varepsilon| < 2^{\lfloor\log_2 |\cos
    ///   x|\rfloor-p+1}$.
    /// - If $x$ is finite and $m$ is `Nearest`, then $|\varepsilon| \leq 2^{\lfloor\log_2 |\cos
    ///   x|\rfloor-p}$.
    ///
    /// If the output has a precision, it is `prec`.
    ///
    /// Special cases:
    /// - $f(\text{NaN},p,m)=\text{NaN}$
    /// - $f(\pm\infty,p,m)=\text{NaN}$
    /// - $f(\pm0.0,p,m)=1.0$
    ///
    /// Overflow and underflow:
    /// - Since $|\cos x|\leq 1$, the result never overflows.
    /// - If $0<f(x,p,m)<2^{-2^{30}}$, and $m$ is `Floor` or `Down`, $0.0$ is returned instead.
    /// - If $0<f(x,p,m)<2^{-2^{30}}$, and $m$ is `Ceiling` or `Up`, $2^{-2^{30}}$ is returned
    ///   instead.
    /// - If $0<f(x,p,m)\leq2^{-2^{30}-1}$, and $m$ is `Nearest`, $0.0$ is returned instead.
    /// - If $2^{-2^{30}-1}<f(x,p,m)<2^{-2^{30}}$, and $m$ is `Nearest`, $2^{-2^{30}}$ is returned
    ///   instead.
    /// - If $-2^{-2^{30}}<f(x,p,m)<0$, and $m$ is `Ceiling` or `Down`, $-0.0$ is returned instead.
    /// - If $-2^{-2^{30}}<f(x,p,m)<0$, and $m$ is `Floor` or `Up`, $-2^{-2^{30}}$ is returned
    ///   instead.
    /// - If $-2^{-2^{30}-1}\leq f(x,p,m)<0$, and $m$ is `Nearest`, $-0.0$ is returned instead.
    /// - If $-2^{-2^{30}}<f(x,p,m)<-2^{-2^{30}-1}$, and $m$ is `Nearest`, $-2^{-2^{30}}$ is
    ///   returned instead.
    ///
    /// Underflow requires an input within $2^{-2^{30}}$ of an odd multiple of $\pi/2$, which takes
    /// more than $2^{30}$ bits of precision.
    ///
    /// If you know you'll be using `Nearest`, consider using [`Float::cos_prec`] instead. If you
    /// know that your target precision is the precision of the input, consider using
    /// [`Float::cos_round`] instead. If both of these things are true, consider using
    /// [`Float::cos`] instead.
    ///
    /// # Worst-case complexity
    /// $T(n, m, e) = O(n (\log n)^3 \log\log n + (n+m+e) (\log (n+m+e))^2 \log\log (n+m+e))$
    ///
    /// $M(n, m, e) = O((n+m+e) \log (n+m+e))$
    ///
    /// where $T$ is time, $M$ is additional memory, $n$ is `prec`, $m$ is
    /// `self.significant_bits()`, and $e$ is the exponent of `self` (0 if `self` has no exponent or
    /// a negative one): the Taylor series at working precision $n$, summed by binary splitting for
    /// large $n$, costs the first term, and for $|x| \geq 4$ the argument is reduced modulo $2\pi$,
    /// which requires $\pi$ to about $n + e$ bits and a remainder of the $m$-bit input. Unlike most
    /// functions, `cos` therefore gets slower as the magnitude of its input grows, not just as the
    /// precision does.
    ///
    /// # Panics
    /// Panics if `rm` is `Exact`, since the cosine of a finite nonzero [`Float`] is never exactly
    /// representable, or if `prec` is zero.
    ///
    /// # Examples
    /// ```
    /// use malachite_base::rounding_modes::RoundingMode::*;
    /// use malachite_float::Float;
    /// use std::cmp::Ordering::*;
    ///
    /// let (c, o) = Float::from_unsigned_prec(1u32, 100)
    ///     .0
    ///     .cos_prec_round(5, Floor);
    /// assert_eq!(c.to_string(), "0.531");
    /// assert_eq!(o, Less);
    ///
    /// let (c, o) = Float::from_unsigned_prec(1u32, 100)
    ///     .0
    ///     .cos_prec_round(5, Ceiling);
    /// assert_eq!(c.to_string(), "0.562");
    /// assert_eq!(o, Greater);
    ///
    /// let (c, o) = Float::from_unsigned_prec(1u32, 100)
    ///     .0
    ///     .cos_prec_round(5, Nearest);
    /// assert_eq!(c.to_string(), "0.531");
    /// assert_eq!(o, Less);
    ///
    /// let (c, o) = Float::from_unsigned_prec(1u32, 100)
    ///     .0
    ///     .cos_prec_round(20, Floor);
    /// assert_eq!(c.to_string(), "0.54030228");
    /// assert_eq!(o, Less);
    ///
    /// let (c, o) = Float::from_unsigned_prec(1u32, 100)
    ///     .0
    ///     .cos_prec_round(20, Ceiling);
    /// assert_eq!(c.to_string(), "0.54030323");
    /// assert_eq!(o, Greater);
    ///
    /// let (c, o) = Float::from_unsigned_prec(1u32, 100)
    ///     .0
    ///     .cos_prec_round(20, Nearest);
    /// assert_eq!(c.to_string(), "0.54030228");
    /// assert_eq!(o, Less);
    /// ```
    #[inline]
    pub fn cos_prec_round(self, prec: u64, rm: RoundingMode) -> (Self, Ordering) {
        self.cos_prec_round_ref(prec, rm)
    }

    /// Computes $\cos x$, the cosine of a [`Float`], rounding the result to the specified precision
    /// and with the specified rounding mode. The [`Float`] is taken by reference. An [`Ordering`]
    /// is also returned, indicating whether the rounded cosine is less than, equal to, or greater
    /// than the exact cosine. Although `NaN`s are not comparable to any [`Float`], whenever this
    /// function returns a `NaN` it also returns `Equal`.
    ///
    /// See [`RoundingMode`] for a description of the possible rounding modes.
    ///
    /// $$
    /// f(x,p,m) = \cos x+\varepsilon.
    /// $$
    /// - If $x$ is not finite, $\varepsilon$ may be ignored or assumed to be 0.
    /// - If $x$ is finite and $m$ is not `Nearest`, then $|\varepsilon| < 2^{\lfloor\log_2 |\cos
    ///   x|\rfloor-p+1}$.
    /// - If $x$ is finite and $m$ is `Nearest`, then $|\varepsilon| \leq 2^{\lfloor\log_2 |\cos
    ///   x|\rfloor-p}$.
    ///
    /// If the output has a precision, it is `prec`.
    ///
    /// Special cases:
    /// - $f(\text{NaN},p,m)=\text{NaN}$
    /// - $f(\pm\infty,p,m)=\text{NaN}$
    /// - $f(\pm0.0,p,m)=1.0$
    ///
    /// Overflow and underflow:
    /// - Since $|\cos x|\leq 1$, the result never overflows.
    /// - If $0<f(x,p,m)<2^{-2^{30}}$, and $m$ is `Floor` or `Down`, $0.0$ is returned instead.
    /// - If $0<f(x,p,m)<2^{-2^{30}}$, and $m$ is `Ceiling` or `Up`, $2^{-2^{30}}$ is returned
    ///   instead.
    /// - If $0<f(x,p,m)\leq2^{-2^{30}-1}$, and $m$ is `Nearest`, $0.0$ is returned instead.
    /// - If $2^{-2^{30}-1}<f(x,p,m)<2^{-2^{30}}$, and $m$ is `Nearest`, $2^{-2^{30}}$ is returned
    ///   instead.
    /// - If $-2^{-2^{30}}<f(x,p,m)<0$, and $m$ is `Ceiling` or `Down`, $-0.0$ is returned instead.
    /// - If $-2^{-2^{30}}<f(x,p,m)<0$, and $m$ is `Floor` or `Up`, $-2^{-2^{30}}$ is returned
    ///   instead.
    /// - If $-2^{-2^{30}-1}\leq f(x,p,m)<0$, and $m$ is `Nearest`, $-0.0$ is returned instead.
    /// - If $-2^{-2^{30}}<f(x,p,m)<-2^{-2^{30}-1}$, and $m$ is `Nearest`, $-2^{-2^{30}}$ is
    ///   returned instead.
    ///
    /// Underflow requires an input within $2^{-2^{30}}$ of an odd multiple of $\pi/2$, which takes
    /// more than $2^{30}$ bits of precision.
    ///
    /// If you know you'll be using `Nearest`, consider using [`Float::cos_prec_ref`] instead. If
    /// you know that your target precision is the precision of the input, consider using
    /// [`Float::cos_round_ref`] instead. If both of these things are true, consider using
    /// `(&Float).cos()` instead.
    ///
    /// # Worst-case complexity
    /// $T(n, m, e) = O(n (\log n)^3 \log\log n + (n+m+e) (\log (n+m+e))^2 \log\log (n+m+e))$
    ///
    /// $M(n, m, e) = O((n+m+e) \log (n+m+e))$
    ///
    /// where $T$ is time, $M$ is additional memory, $n$ is `prec`, $m$ is
    /// `self.significant_bits()`, and $e$ is the exponent of `self` (0 if `self` has no exponent or
    /// a negative one): the Taylor series at working precision $n$, summed by binary splitting for
    /// large $n$, costs the first term, and for $|x| \geq 4$ the argument is reduced modulo $2\pi$,
    /// which requires $\pi$ to about $n + e$ bits and a remainder of the $m$-bit input. Unlike most
    /// functions, `cos` therefore gets slower as the magnitude of its input grows, not just as the
    /// precision does.
    ///
    /// # Panics
    /// Panics if `rm` is `Exact`, since the cosine of a finite nonzero [`Float`] is never exactly
    /// representable, or if `prec` is zero.
    ///
    /// # Examples
    /// ```
    /// use malachite_base::rounding_modes::RoundingMode::*;
    /// use malachite_float::Float;
    /// use std::cmp::Ordering::*;
    ///
    /// let (c, o) = (&Float::from_unsigned_prec(1u32, 100).0).cos_prec_round_ref(5, Floor);
    /// assert_eq!(c.to_string(), "0.531");
    /// assert_eq!(o, Less);
    ///
    /// let (c, o) = (&Float::from_unsigned_prec(1u32, 100).0).cos_prec_round_ref(5, Ceiling);
    /// assert_eq!(c.to_string(), "0.562");
    /// assert_eq!(o, Greater);
    ///
    /// let (c, o) = (&Float::from_unsigned_prec(1u32, 100).0).cos_prec_round_ref(5, Nearest);
    /// assert_eq!(c.to_string(), "0.531");
    /// assert_eq!(o, Less);
    ///
    /// let (c, o) = (&Float::from_unsigned_prec(1u32, 100).0).cos_prec_round_ref(20, Floor);
    /// assert_eq!(c.to_string(), "0.54030228");
    /// assert_eq!(o, Less);
    ///
    /// let (c, o) = (&Float::from_unsigned_prec(1u32, 100).0).cos_prec_round_ref(20, Ceiling);
    /// assert_eq!(c.to_string(), "0.54030323");
    /// assert_eq!(o, Greater);
    ///
    /// let (c, o) = (&Float::from_unsigned_prec(1u32, 100).0).cos_prec_round_ref(20, Nearest);
    /// assert_eq!(c.to_string(), "0.54030228");
    /// assert_eq!(o, Less);
    /// ```
    pub fn cos_prec_round_ref(&self, prec: u64, rm: RoundingMode) -> (Self, Ordering) {
        assert_ne!(prec, 0);
        match &self.0 {
            NaN | Infinity { .. } => (Self::NAN, Equal),
            // cos(+0) = cos(-0) = 1
            Zero { .. } => (Self::one_prec(prec), Equal),
            Finite { .. } => cos_prec_round_normal_ref(self, prec, rm),
        }
    }

    /// Computes $\cos x$, the cosine of a [`Float`], rounding the result to the nearest value of
    /// the specified precision. The [`Float`] is taken by value. An [`Ordering`] is also returned,
    /// indicating whether the rounded cosine is less than, equal to, or greater than the exact
    /// cosine. Although `NaN`s are not comparable to any [`Float`], whenever this function returns
    /// a `NaN` it also returns `Equal`.
    ///
    /// If the cosine is equidistant from two [`Float`]s with the specified precision, the [`Float`]
    /// with fewer 1s in its binary expansion is chosen. See [`RoundingMode`] for a description of
    /// the `Nearest` rounding mode.
    ///
    /// $$
    /// f(x,p) = \cos x+\varepsilon.
    /// $$
    /// - If $x$ is not finite, $\varepsilon$ may be ignored or assumed to be 0.
    /// - If $x$ is finite, then $|\varepsilon| < 2^{\lfloor\log_2 |\cos x|\rfloor-p}$.
    ///
    /// If the output has a precision, it is `prec`.
    ///
    /// Special cases:
    /// - $f(\text{NaN},p)=\text{NaN}$
    /// - $f(\pm\infty,p)=\text{NaN}$
    /// - $f(\pm0.0,p)=1.0$
    ///
    /// Overflow and underflow:
    /// - Since $|\cos x|\leq 1$, the result never overflows.
    /// - If $0<f(x,p)\leq2^{-2^{30}-1}$, $0.0$ is returned instead.
    /// - If $2^{-2^{30}-1}<f(x,p)<2^{-2^{30}}$, $2^{-2^{30}}$ is returned instead.
    /// - If $-2^{-2^{30}-1}\leq f(x,p)<0$, $-0.0$ is returned instead.
    /// - If $-2^{-2^{30}}<f(x,p)<-2^{-2^{30}-1}$, $-2^{-2^{30}}$ is returned instead.
    ///
    /// Underflow requires an input within $2^{-2^{30}}$ of an odd multiple of $\pi/2$, which takes
    /// more than $2^{30}$ bits of precision.
    ///
    /// If you want to use a rounding mode other than `Nearest`, consider using
    /// [`Float::cos_prec_round`] instead. If you know that your target precision is the precision
    /// of the input, consider using [`Float::cos`] instead.
    ///
    /// # Worst-case complexity
    /// $T(n, m, e) = O(n (\log n)^3 \log\log n + (n+m+e) (\log (n+m+e))^2 \log\log (n+m+e))$
    ///
    /// $M(n, m, e) = O((n+m+e) \log (n+m+e))$
    ///
    /// where $T$ is time, $M$ is additional memory, $n$ is `prec`, $m$ is
    /// `self.significant_bits()`, and $e$ is the exponent of `self` (0 if `self` has no exponent or
    /// a negative one): the Taylor series at working precision $n$, summed by binary splitting for
    /// large $n$, costs the first term, and for $|x| \geq 4$ the argument is reduced modulo $2\pi$,
    /// which requires $\pi$ to about $n + e$ bits and a remainder of the $m$-bit input. Unlike most
    /// functions, `cos` therefore gets slower as the magnitude of its input grows, not just as the
    /// precision does.
    ///
    /// # Panics
    /// Panics if `prec` is zero.
    ///
    /// # Examples
    /// ```
    /// use malachite_float::Float;
    /// use std::cmp::Ordering::*;
    ///
    /// let (c, o) = Float::from_unsigned_prec(1u32, 100).0.cos_prec(5);
    /// assert_eq!(c.to_string(), "0.531");
    /// assert_eq!(o, Less);
    ///
    /// let (c, o) = Float::from_unsigned_prec(1u32, 100).0.cos_prec(20);
    /// assert_eq!(c.to_string(), "0.54030228");
    /// assert_eq!(o, Less);
    /// ```
    #[inline]
    pub fn cos_prec(self, prec: u64) -> (Self, Ordering) {
        self.cos_prec_round(prec, Nearest)
    }

    /// Computes $\cos x$, the cosine of a [`Float`], rounding the result to the nearest value of
    /// the specified precision. The [`Float`] is taken by reference. An [`Ordering`] is also
    /// returned, indicating whether the rounded cosine is less than, equal to, or greater than the
    /// exact cosine. Although `NaN`s are not comparable to any [`Float`], whenever this function
    /// returns a `NaN` it also returns `Equal`.
    ///
    /// If the cosine is equidistant from two [`Float`]s with the specified precision, the [`Float`]
    /// with fewer 1s in its binary expansion is chosen. See [`RoundingMode`] for a description of
    /// the `Nearest` rounding mode.
    ///
    /// $$
    /// f(x,p) = \cos x+\varepsilon.
    /// $$
    /// - If $x$ is not finite, $\varepsilon$ may be ignored or assumed to be 0.
    /// - If $x$ is finite, then $|\varepsilon| < 2^{\lfloor\log_2 |\cos x|\rfloor-p}$.
    ///
    /// If the output has a precision, it is `prec`.
    ///
    /// Special cases:
    /// - $f(\text{NaN},p)=\text{NaN}$
    /// - $f(\pm\infty,p)=\text{NaN}$
    /// - $f(\pm0.0,p)=1.0$
    ///
    /// Overflow and underflow:
    /// - Since $|\cos x|\leq 1$, the result never overflows.
    /// - If $0<f(x,p)\leq2^{-2^{30}-1}$, $0.0$ is returned instead.
    /// - If $2^{-2^{30}-1}<f(x,p)<2^{-2^{30}}$, $2^{-2^{30}}$ is returned instead.
    /// - If $-2^{-2^{30}-1}\leq f(x,p)<0$, $-0.0$ is returned instead.
    /// - If $-2^{-2^{30}}<f(x,p)<-2^{-2^{30}-1}$, $-2^{-2^{30}}$ is returned instead.
    ///
    /// Underflow requires an input within $2^{-2^{30}}$ of an odd multiple of $\pi/2$, which takes
    /// more than $2^{30}$ bits of precision.
    ///
    /// If you want to use a rounding mode other than `Nearest`, consider using
    /// [`Float::cos_prec_round_ref`] instead. If you know that your target precision is the
    /// precision of the input, consider using `(&Float).cos()` instead.
    ///
    /// # Worst-case complexity
    /// $T(n, m, e) = O(n (\log n)^3 \log\log n + (n+m+e) (\log (n+m+e))^2 \log\log (n+m+e))$
    ///
    /// $M(n, m, e) = O((n+m+e) \log (n+m+e))$
    ///
    /// where $T$ is time, $M$ is additional memory, $n$ is `prec`, $m$ is
    /// `self.significant_bits()`, and $e$ is the exponent of `self` (0 if `self` has no exponent or
    /// a negative one): the Taylor series at working precision $n$, summed by binary splitting for
    /// large $n$, costs the first term, and for $|x| \geq 4$ the argument is reduced modulo $2\pi$,
    /// which requires $\pi$ to about $n + e$ bits and a remainder of the $m$-bit input. Unlike most
    /// functions, `cos` therefore gets slower as the magnitude of its input grows, not just as the
    /// precision does.
    ///
    /// # Panics
    /// Panics if `prec` is zero.
    ///
    /// # Examples
    /// ```
    /// use malachite_float::Float;
    /// use std::cmp::Ordering::*;
    ///
    /// let (c, o) = (&Float::from_unsigned_prec(1u32, 100).0).cos_prec_ref(5);
    /// assert_eq!(c.to_string(), "0.531");
    /// assert_eq!(o, Less);
    ///
    /// let (c, o) = (&Float::from_unsigned_prec(1u32, 100).0).cos_prec_ref(20);
    /// assert_eq!(c.to_string(), "0.54030228");
    /// assert_eq!(o, Less);
    /// ```
    #[inline]
    pub fn cos_prec_ref(&self, prec: u64) -> (Self, Ordering) {
        self.cos_prec_round_ref(prec, Nearest)
    }

    /// Computes $\cos x$, the cosine of a [`Float`], rounding the result with the specified
    /// rounding mode. The [`Float`] is taken by value. An [`Ordering`] is also returned, indicating
    /// whether the rounded cosine is less than, equal to, or greater than the exact cosine.
    /// Although `NaN`s are not comparable to any [`Float`], whenever this function returns a `NaN`
    /// it also returns `Equal`.
    ///
    /// The precision of the output is the precision of the input. See [`RoundingMode`] for a
    /// description of the possible rounding modes.
    ///
    /// $$
    /// f(x,m) = \cos x+\varepsilon.
    /// $$
    /// - If $x$ is not finite, $\varepsilon$ may be ignored or assumed to be 0.
    /// - If $x$ is finite and $m$ is not `Nearest`, then $|\varepsilon| < 2^{\lfloor\log_2 |\cos
    ///   x|\rfloor-p+1}$, where $p$ is the precision of the input.
    /// - If $x$ is finite and $m$ is `Nearest`, then $|\varepsilon| \leq 2^{\lfloor\log_2 |\cos
    ///   x|\rfloor-p}$, where $p$ is the precision of the input.
    ///
    /// If the output has a precision, it is the precision of the input.
    ///
    /// Special cases:
    /// - $f(\text{NaN},m)=\text{NaN}$
    /// - $f(\pm\infty,m)=\text{NaN}$
    /// - $f(\pm0.0,m)=1.0$
    ///
    /// Overflow and underflow:
    /// - Since $|\cos x|\leq 1$, the result never overflows.
    /// - If $0<f(x,m)<2^{-2^{30}}$, and $m$ is `Floor` or `Down`, $0.0$ is returned instead.
    /// - If $0<f(x,m)<2^{-2^{30}}$, and $m$ is `Ceiling` or `Up`, $2^{-2^{30}}$ is returned
    ///   instead.
    /// - If $0<f(x,m)\leq2^{-2^{30}-1}$, and $m$ is `Nearest`, $0.0$ is returned instead.
    /// - If $2^{-2^{30}-1}<f(x,m)<2^{-2^{30}}$, and $m$ is `Nearest`, $2^{-2^{30}}$ is returned
    ///   instead.
    /// - If $-2^{-2^{30}}<f(x,m)<0$, and $m$ is `Ceiling` or `Down`, $-0.0$ is returned instead.
    /// - If $-2^{-2^{30}}<f(x,m)<0$, and $m$ is `Floor` or `Up`, $-2^{-2^{30}}$ is returned
    ///   instead.
    /// - If $-2^{-2^{30}-1}\leq f(x,m)<0$, and $m$ is `Nearest`, $-0.0$ is returned instead.
    /// - If $-2^{-2^{30}}<f(x,m)<-2^{-2^{30}-1}$, and $m$ is `Nearest`, $-2^{-2^{30}}$ is returned
    ///   instead.
    ///
    /// Underflow requires an input within $2^{-2^{30}}$ of an odd multiple of $\pi/2$, which takes
    /// more than $2^{30}$ bits of precision.
    ///
    /// If you want to specify an output precision, consider using [`Float::cos_prec_round`]
    /// instead. If you know you'll be using the `Nearest` rounding mode, consider using
    /// [`Float::cos`] instead.
    ///
    /// # Worst-case complexity
    /// $T(n, e) = O(n (\log n)^3 \log\log n + (n+e) (\log (n+e))^2 \log\log (n+e))$
    ///
    /// $M(n, e) = O((n+e) \log (n+e))$
    ///
    /// where $T$ is time, $M$ is additional memory, $n$ is `self.significant_bits()`, and $e$ is
    /// the exponent of `self` (0 if `self` has no exponent or a negative one): the Taylor series at
    /// working precision $n$, summed by binary splitting for large $n$, costs the first term, and
    /// for $|x| \geq 4$ the argument is reduced modulo $2\pi$, which requires $\pi$ to about $n +
    /// e$ bits. Unlike most functions, `cos` therefore gets slower as the magnitude of its input
    /// grows, not just as the precision does.
    ///
    /// # Panics
    /// Panics if `rm` is `Exact`, since the cosine of a finite nonzero [`Float`] is never exactly
    /// representable.
    ///
    /// # Examples
    /// ```
    /// use malachite_base::rounding_modes::RoundingMode::*;
    /// use malachite_float::Float;
    /// use std::cmp::Ordering::*;
    ///
    /// let (c, o) = Float::from_unsigned_prec(1u32, 100).0.cos_round(Floor);
    /// assert_eq!(c.to_string(), "0.54030230586813971740093660744256");
    /// assert_eq!(o, Less);
    ///
    /// let (c, o) = Float::from_unsigned_prec(1u32, 100).0.cos_round(Ceiling);
    /// assert_eq!(c.to_string(), "0.54030230586813971740093660744335");
    /// assert_eq!(o, Greater);
    ///
    /// let (c, o) = Float::from_unsigned_prec(1u32, 100).0.cos_round(Nearest);
    /// assert_eq!(c.to_string(), "0.54030230586813971740093660744335");
    /// assert_eq!(o, Greater);
    /// ```
    #[inline]
    pub fn cos_round(self, rm: RoundingMode) -> (Self, Ordering) {
        let prec = self.significant_bits();
        self.cos_prec_round(prec, rm)
    }

    /// Computes $\cos x$, the cosine of a [`Float`], rounding the result with the specified
    /// rounding mode. The [`Float`] is taken by reference. An [`Ordering`] is also returned,
    /// indicating whether the rounded cosine is less than, equal to, or greater than the exact
    /// cosine. Although `NaN`s are not comparable to any [`Float`], whenever this function returns
    /// a `NaN` it also returns `Equal`.
    ///
    /// The precision of the output is the precision of the input. See [`RoundingMode`] for a
    /// description of the possible rounding modes.
    ///
    /// $$
    /// f(x,m) = \cos x+\varepsilon.
    /// $$
    /// - If $x$ is not finite, $\varepsilon$ may be ignored or assumed to be 0.
    /// - If $x$ is finite and $m$ is not `Nearest`, then $|\varepsilon| < 2^{\lfloor\log_2 |\cos
    ///   x|\rfloor-p+1}$, where $p$ is the precision of the input.
    /// - If $x$ is finite and $m$ is `Nearest`, then $|\varepsilon| \leq 2^{\lfloor\log_2 |\cos
    ///   x|\rfloor-p}$, where $p$ is the precision of the input.
    ///
    /// If the output has a precision, it is the precision of the input.
    ///
    /// Special cases:
    /// - $f(\text{NaN},m)=\text{NaN}$
    /// - $f(\pm\infty,m)=\text{NaN}$
    /// - $f(\pm0.0,m)=1.0$
    ///
    /// Overflow and underflow:
    /// - Since $|\cos x|\leq 1$, the result never overflows.
    /// - If $0<f(x,m)<2^{-2^{30}}$, and $m$ is `Floor` or `Down`, $0.0$ is returned instead.
    /// - If $0<f(x,m)<2^{-2^{30}}$, and $m$ is `Ceiling` or `Up`, $2^{-2^{30}}$ is returned
    ///   instead.
    /// - If $0<f(x,m)\leq2^{-2^{30}-1}$, and $m$ is `Nearest`, $0.0$ is returned instead.
    /// - If $2^{-2^{30}-1}<f(x,m)<2^{-2^{30}}$, and $m$ is `Nearest`, $2^{-2^{30}}$ is returned
    ///   instead.
    /// - If $-2^{-2^{30}}<f(x,m)<0$, and $m$ is `Ceiling` or `Down`, $-0.0$ is returned instead.
    /// - If $-2^{-2^{30}}<f(x,m)<0$, and $m$ is `Floor` or `Up`, $-2^{-2^{30}}$ is returned
    ///   instead.
    /// - If $-2^{-2^{30}-1}\leq f(x,m)<0$, and $m$ is `Nearest`, $-0.0$ is returned instead.
    /// - If $-2^{-2^{30}}<f(x,m)<-2^{-2^{30}-1}$, and $m$ is `Nearest`, $-2^{-2^{30}}$ is returned
    ///   instead.
    ///
    /// Underflow requires an input within $2^{-2^{30}}$ of an odd multiple of $\pi/2$, which takes
    /// more than $2^{30}$ bits of precision.
    ///
    /// If you want to specify an output precision, consider using [`Float::cos_prec_round_ref`]
    /// instead. If you know you'll be using the `Nearest` rounding mode, consider using
    /// `(&Float).cos()` instead.
    ///
    /// # Worst-case complexity
    /// $T(n, e) = O(n (\log n)^3 \log\log n + (n+e) (\log (n+e))^2 \log\log (n+e))$
    ///
    /// $M(n, e) = O((n+e) \log (n+e))$
    ///
    /// where $T$ is time, $M$ is additional memory, $n$ is `self.significant_bits()`, and $e$ is
    /// the exponent of `self` (0 if `self` has no exponent or a negative one): the Taylor series at
    /// working precision $n$, summed by binary splitting for large $n$, costs the first term, and
    /// for $|x| \geq 4$ the argument is reduced modulo $2\pi$, which requires $\pi$ to about $n +
    /// e$ bits. Unlike most functions, `cos` therefore gets slower as the magnitude of its input
    /// grows, not just as the precision does.
    ///
    /// # Panics
    /// Panics if `rm` is `Exact`, since the cosine of a finite nonzero [`Float`] is never exactly
    /// representable.
    ///
    /// # Examples
    /// ```
    /// use malachite_base::rounding_modes::RoundingMode::*;
    /// use malachite_float::Float;
    /// use std::cmp::Ordering::*;
    ///
    /// let (c, o) = (&Float::from_unsigned_prec(1u32, 100).0).cos_round_ref(Floor);
    /// assert_eq!(c.to_string(), "0.54030230586813971740093660744256");
    /// assert_eq!(o, Less);
    ///
    /// let (c, o) = (&Float::from_unsigned_prec(1u32, 100).0).cos_round_ref(Ceiling);
    /// assert_eq!(c.to_string(), "0.54030230586813971740093660744335");
    /// assert_eq!(o, Greater);
    ///
    /// let (c, o) = (&Float::from_unsigned_prec(1u32, 100).0).cos_round_ref(Nearest);
    /// assert_eq!(c.to_string(), "0.54030230586813971740093660744335");
    /// assert_eq!(o, Greater);
    /// ```
    #[inline]
    pub fn cos_round_ref(&self, rm: RoundingMode) -> (Self, Ordering) {
        self.cos_prec_round_ref(self.significant_bits(), rm)
    }

    /// Computes $\cos x$, the cosine of a [`Float`], rounding the result to the specified precision
    /// and with the specified rounding mode. The [`Float`] is replaced by the result, and an
    /// [`Ordering`] is returned, indicating whether the rounded cosine is less than, equal to, or
    /// greater than the exact cosine. Although `NaN`s are not comparable to any [`Float`], whenever
    /// this function sets a `NaN` it also returns `Equal`.
    ///
    /// See [`RoundingMode`] for a description of the possible rounding modes.
    ///
    /// $$
    /// x \gets \cos x+\varepsilon.
    /// $$
    /// - If $x$ is not finite, $\varepsilon$ may be ignored or assumed to be 0.
    /// - If $x$ is finite and $m$ is not `Nearest`, then $|\varepsilon| < 2^{\lfloor\log_2 |\cos
    ///   x|\rfloor-p+1}$.
    /// - If $x$ is finite and $m$ is `Nearest`, then $|\varepsilon| \leq 2^{\lfloor\log_2 |\cos
    ///   x|\rfloor-p}$.
    ///
    /// If the output has a precision, it is `prec`.
    ///
    /// See the [`Float::cos_prec_round`] documentation for information on special cases, overflow,
    /// and underflow.
    ///
    /// If you know you'll be using `Nearest`, consider using [`Float::cos_prec_assign`] instead. If
    /// you know that your target precision is the precision of the input, consider using
    /// [`Float::cos_round_assign`] instead. If both of these things are true, consider using
    /// [`Float::cos_assign`] instead.
    ///
    /// # Worst-case complexity
    /// $T(n, m, e) = O(n (\log n)^3 \log\log n + (n+m+e) (\log (n+m+e))^2 \log\log (n+m+e))$
    ///
    /// $M(n, m, e) = O((n+m+e) \log (n+m+e))$
    ///
    /// where $T$ is time, $M$ is additional memory, $n$ is `prec`, $m$ is
    /// `self.significant_bits()`, and $e$ is the exponent of `self` (0 if `self` has no exponent or
    /// a negative one): the Taylor series at working precision $n$, summed by binary splitting for
    /// large $n$, costs the first term, and for $|x| \geq 4$ the argument is reduced modulo $2\pi$,
    /// which requires $\pi$ to about $n + e$ bits and a remainder of the $m$-bit input. Unlike most
    /// functions, `cos` therefore gets slower as the magnitude of its input grows, not just as the
    /// precision does.
    ///
    /// # Panics
    /// Panics if `rm` is `Exact`, since the cosine of a finite nonzero [`Float`] is never exactly
    /// representable, or if `prec` is zero.
    ///
    /// # Examples
    /// ```
    /// use malachite_base::rounding_modes::RoundingMode::*;
    /// use malachite_float::Float;
    /// use std::cmp::Ordering::*;
    ///
    /// let mut x = Float::from_unsigned_prec(1u32, 100).0;
    /// assert_eq!(x.cos_prec_round_assign(5, Floor), Less);
    /// assert_eq!(x.to_string(), "0.531");
    ///
    /// let mut x = Float::from_unsigned_prec(1u32, 100).0;
    /// assert_eq!(x.cos_prec_round_assign(5, Ceiling), Greater);
    /// assert_eq!(x.to_string(), "0.562");
    ///
    /// let mut x = Float::from_unsigned_prec(1u32, 100).0;
    /// assert_eq!(x.cos_prec_round_assign(5, Nearest), Less);
    /// assert_eq!(x.to_string(), "0.531");
    ///
    /// let mut x = Float::from_unsigned_prec(1u32, 100).0;
    /// assert_eq!(x.cos_prec_round_assign(20, Floor), Less);
    /// assert_eq!(x.to_string(), "0.54030228");
    ///
    /// let mut x = Float::from_unsigned_prec(1u32, 100).0;
    /// assert_eq!(x.cos_prec_round_assign(20, Ceiling), Greater);
    /// assert_eq!(x.to_string(), "0.54030323");
    ///
    /// let mut x = Float::from_unsigned_prec(1u32, 100).0;
    /// assert_eq!(x.cos_prec_round_assign(20, Nearest), Less);
    /// assert_eq!(x.to_string(), "0.54030228");
    /// ```
    #[inline]
    pub fn cos_prec_round_assign(&mut self, prec: u64, rm: RoundingMode) -> Ordering {
        let o;
        (*self, o) = self.cos_prec_round_ref(prec, rm);
        o
    }

    /// Computes $\cos x$, the cosine of a [`Float`], rounding the result to the nearest value of
    /// the specified precision. The [`Float`] is replaced by the result, and an [`Ordering`] is
    /// returned, indicating whether the rounded cosine is less than, equal to, or greater than the
    /// exact cosine. Although `NaN`s are not comparable to any [`Float`], whenever this function
    /// sets a `NaN` it also returns `Equal`.
    ///
    /// If the cosine is equidistant from two [`Float`]s with the specified precision, the [`Float`]
    /// with fewer 1s in its binary expansion is chosen. See [`RoundingMode`] for a description of
    /// the `Nearest` rounding mode.
    ///
    /// $$
    /// x \gets \cos x+\varepsilon.
    /// $$
    /// - If $x$ is not finite, $\varepsilon$ may be ignored or assumed to be 0.
    /// - If $x$ is finite, then $|\varepsilon| < 2^{\lfloor\log_2 |\cos x|\rfloor-p}$.
    ///
    /// If the output has a precision, it is `prec`.
    ///
    /// See the [`Float::cos_prec`] documentation for information on special cases, overflow, and
    /// underflow.
    ///
    /// If you want to use a rounding mode other than `Nearest`, consider using
    /// [`Float::cos_prec_round_assign`] instead. If you know that your target precision is the
    /// precision of the input, consider using [`Float::cos_assign`] instead.
    ///
    /// # Worst-case complexity
    /// $T(n, m, e) = O(n (\log n)^3 \log\log n + (n+m+e) (\log (n+m+e))^2 \log\log (n+m+e))$
    ///
    /// $M(n, m, e) = O((n+m+e) \log (n+m+e))$
    ///
    /// where $T$ is time, $M$ is additional memory, $n$ is `prec`, $m$ is
    /// `self.significant_bits()`, and $e$ is the exponent of `self` (0 if `self` has no exponent or
    /// a negative one): the Taylor series at working precision $n$, summed by binary splitting for
    /// large $n$, costs the first term, and for $|x| \geq 4$ the argument is reduced modulo $2\pi$,
    /// which requires $\pi$ to about $n + e$ bits and a remainder of the $m$-bit input. Unlike most
    /// functions, `cos` therefore gets slower as the magnitude of its input grows, not just as the
    /// precision does.
    ///
    /// # Panics
    /// Panics if `prec` is zero.
    ///
    /// # Examples
    /// ```
    /// use malachite_float::Float;
    /// use std::cmp::Ordering::*;
    ///
    /// let mut x = Float::from_unsigned_prec(1u32, 100).0;
    /// assert_eq!(x.cos_prec_assign(5), Less);
    /// assert_eq!(x.to_string(), "0.531");
    ///
    /// let mut x = Float::from_unsigned_prec(1u32, 100).0;
    /// assert_eq!(x.cos_prec_assign(20), Less);
    /// assert_eq!(x.to_string(), "0.54030228");
    /// ```
    #[inline]
    pub fn cos_prec_assign(&mut self, prec: u64) -> Ordering {
        self.cos_prec_round_assign(prec, Nearest)
    }

    /// Computes $\cos x$, the cosine of a [`Float`], rounding the result with the specified
    /// rounding mode. The [`Float`] is replaced by the result, and an [`Ordering`] is returned,
    /// indicating whether the rounded cosine is less than, equal to, or greater than the exact
    /// cosine. Although `NaN`s are not comparable to any [`Float`], whenever this function sets a
    /// `NaN` it also returns `Equal`.
    ///
    /// The precision of the output is the precision of the input. See [`RoundingMode`] for a
    /// description of the possible rounding modes.
    ///
    /// $$
    /// x \gets \cos x+\varepsilon.
    /// $$
    /// - If $x$ is not finite, $\varepsilon$ may be ignored or assumed to be 0.
    /// - If $x$ is finite and $m$ is not `Nearest`, then $|\varepsilon| < 2^{\lfloor\log_2 |\cos
    ///   x|\rfloor-p+1}$, where $p$ is the precision of the input.
    /// - If $x$ is finite and $m$ is `Nearest`, then $|\varepsilon| \leq 2^{\lfloor\log_2 |\cos
    ///   x|\rfloor-p}$, where $p$ is the precision of the input.
    ///
    /// If the output has a precision, it is the precision of the input.
    ///
    /// See the [`Float::cos_round`] documentation for information on special cases, overflow, and
    /// underflow.
    ///
    /// If you want to specify an output precision, consider using [`Float::cos_prec_round_assign`]
    /// instead. If you know you'll be using the `Nearest` rounding mode, consider using
    /// [`Float::cos_assign`] instead.
    ///
    /// # Worst-case complexity
    /// $T(n, e) = O(n (\log n)^3 \log\log n + (n+e) (\log (n+e))^2 \log\log (n+e))$
    ///
    /// $M(n, e) = O((n+e) \log (n+e))$
    ///
    /// where $T$ is time, $M$ is additional memory, $n$ is `self.significant_bits()`, and $e$ is
    /// the exponent of `self` (0 if `self` has no exponent or a negative one): the Taylor series at
    /// working precision $n$, summed by binary splitting for large $n$, costs the first term, and
    /// for $|x| \geq 4$ the argument is reduced modulo $2\pi$, which requires $\pi$ to about $n +
    /// e$ bits. Unlike most functions, `cos` therefore gets slower as the magnitude of its input
    /// grows, not just as the precision does.
    ///
    /// # Panics
    /// Panics if `rm` is `Exact`, since the cosine of a finite nonzero [`Float`] is never exactly
    /// representable.
    ///
    /// # Examples
    /// ```
    /// use malachite_base::rounding_modes::RoundingMode::*;
    /// use malachite_float::Float;
    /// use std::cmp::Ordering::*;
    ///
    /// let mut x = Float::from_unsigned_prec(1u32, 100).0;
    /// assert_eq!(x.cos_round_assign(Floor), Less);
    /// assert_eq!(x.to_string(), "0.54030230586813971740093660744256");
    ///
    /// let mut x = Float::from_unsigned_prec(1u32, 100).0;
    /// assert_eq!(x.cos_round_assign(Ceiling), Greater);
    /// assert_eq!(x.to_string(), "0.54030230586813971740093660744335");
    ///
    /// let mut x = Float::from_unsigned_prec(1u32, 100).0;
    /// assert_eq!(x.cos_round_assign(Nearest), Greater);
    /// assert_eq!(x.to_string(), "0.54030230586813971740093660744335");
    /// ```
    #[inline]
    pub fn cos_round_assign(&mut self, rm: RoundingMode) -> Ordering {
        let prec = self.significant_bits();
        self.cos_prec_round_assign(prec, rm)
    }
}

impl Float {
    /// Computes $\cos x$, the cosine of a [`Rational`], rounding the result to the specified
    /// precision and with the specified rounding mode and returning the result as a [`Float`]. The
    /// [`Rational`] is taken by value. An [`Ordering`] is also returned, indicating whether the
    /// rounded cosine is less than, equal to, or greater than the exact cosine.
    ///
    /// See [`RoundingMode`] for a description of the possible rounding modes.
    ///
    /// $$
    /// f(x,p,m) = \cos x+\varepsilon.
    /// $$
    /// - If $m$ is not `Nearest`, then $|\varepsilon| < 2^{\lfloor\log_2 |\cos x|\rfloor-p+1}$.
    /// - If $m$ is `Nearest`, then $|\varepsilon| \leq 2^{\lfloor\log_2 |\cos x|\rfloor-p}$.
    ///
    /// These bounds do not apply when the result underflows; see below.
    ///
    /// The output has precision `prec`.
    ///
    /// Special cases:
    /// - $f(0,p,m)=1$.
    ///
    /// Overflow and underflow:
    /// - Since $|\cos x|\leq 1$, the result never overflows.
    /// - If $0<f(x,p,m)<2^{-2^{30}}$, and $m$ is `Floor` or `Down`, $0.0$ is returned instead.
    /// - If $0<f(x,p,m)<2^{-2^{30}}$, and $m$ is `Ceiling` or `Up`, $2^{-2^{30}}$ is returned
    ///   instead.
    /// - If $0<f(x,p,m)\leq2^{-2^{30}-1}$, and $m$ is `Nearest`, $0.0$ is returned instead.
    /// - If $2^{-2^{30}-1}<f(x,p,m)<2^{-2^{30}}$, and $m$ is `Nearest`, $2^{-2^{30}}$ is returned
    ///   instead.
    /// - If $-2^{-2^{30}}<f(x,p,m)<0$, and $m$ is `Ceiling` or `Down`, $-0.0$ is returned instead.
    /// - If $-2^{-2^{30}}<f(x,p,m)<0$, and $m$ is `Floor` or `Up`, $-2^{-2^{30}}$ is returned
    ///   instead.
    /// - If $-2^{-2^{30}-1}\leq f(x,p,m)<0$, and $m$ is `Nearest`, $-0.0$ is returned instead.
    /// - If $-2^{-2^{30}}<f(x,p,m)<-2^{-2^{30}-1}$, and $m$ is `Nearest`, $-2^{-2^{30}}$ is
    ///   returned instead.
    ///
    /// Underflow requires an input within $2^{-2^{30}}$ of an odd multiple of $\pi/2$, which takes
    /// more than $2^{30}$ bits.
    ///
    /// If you know you'll be using `Nearest`, consider using [`Float::cos_rational_prec`] instead.
    ///
    /// # Worst-case complexity
    /// $T(n, m, e) = O(n (\log n)^3 \log\log n + (n+m+e) (\log (n+m+e))^2 \log\log (n+m+e))$
    ///
    /// $M(n, m, e) = O((n+m+e) \log (n+m+e))$
    ///
    /// where $T$ is time, $M$ is additional memory, $n$ is `prec`, $m$ is `x.significant_bits()`,
    /// and $e$ is `x.floor_log_base_2_abs()` (taken as 0 when it is negative or $x = 0$): the input
    /// is rounded to a working precision and the [`Float`] cosine taken there, which for $|x| \geq
    /// 4$ reduces the argument modulo $2\pi$ and so needs $\pi$ to about $n + e$ bits.
    ///
    /// # Panics
    /// Panics if `prec` is zero, or if `rm` is `Exact` but the result cannot be represented exactly
    /// with the given precision (which is the case for every nonzero input).
    ///
    /// # Examples
    /// ```
    /// use malachite_base::rounding_modes::RoundingMode::*;
    /// use malachite_float::Float;
    /// use malachite_q::Rational;
    /// use std::cmp::Ordering::*;
    ///
    /// let (c, o) = Float::cos_rational_prec_round(Rational::from_unsigneds(3u8, 5), 5, Floor);
    /// assert_eq!(c.to_string(), "0.812");
    /// assert_eq!(o, Less);
    ///
    /// let (c, o) = Float::cos_rational_prec_round(Rational::from_unsigneds(3u8, 5), 5, Ceiling);
    /// assert_eq!(c.to_string(), "0.844");
    /// assert_eq!(o, Greater);
    ///
    /// let (c, o) = Float::cos_rational_prec_round(Rational::from_unsigneds(3u8, 5), 20, Floor);
    /// assert_eq!(c.to_string(), "0.82533550");
    /// assert_eq!(o, Less);
    ///
    /// let (c, o) = Float::cos_rational_prec_round(Rational::from_unsigneds(3u8, 5), 20, Ceiling);
    /// assert_eq!(c.to_string(), "0.82533646");
    /// assert_eq!(o, Greater);
    /// ```
    #[inline]
    #[allow(clippy::needless_pass_by_value)]
    pub fn cos_rational_prec_round(x: Rational, prec: u64, rm: RoundingMode) -> (Self, Ordering) {
        Self::cos_rational_prec_round_ref(&x, prec, rm)
    }

    /// Computes $\cos x$, the cosine of a [`Rational`], rounding the result to the specified
    /// precision and with the specified rounding mode and returning the result as a [`Float`]. The
    /// [`Rational`] is taken by reference. An [`Ordering`] is also returned, indicating whether the
    /// rounded cosine is less than, equal to, or greater than the exact cosine.
    ///
    /// See [`RoundingMode`] for a description of the possible rounding modes.
    ///
    /// $$
    /// f(x,p,m) = \cos x+\varepsilon.
    /// $$
    /// - If $m$ is not `Nearest`, then $|\varepsilon| < 2^{\lfloor\log_2 |\cos x|\rfloor-p+1}$.
    /// - If $m$ is `Nearest`, then $|\varepsilon| \leq 2^{\lfloor\log_2 |\cos x|\rfloor-p}$.
    ///
    /// These bounds do not apply when the result underflows.
    ///
    /// The output has precision `prec`.
    ///
    /// Special cases:
    /// - $f(0,p,m)=1$.
    ///
    /// See the [`Float::cos_rational_prec_round`] documentation for information on overflow and
    /// underflow.
    ///
    /// If you know you'll be using `Nearest`, consider using [`Float::cos_rational_prec_ref`]
    /// instead.
    ///
    /// # Worst-case complexity
    /// $T(n, m, e) = O(n (\log n)^3 \log\log n + (n+m+e) (\log (n+m+e))^2 \log\log (n+m+e))$
    ///
    /// $M(n, m, e) = O((n+m+e) \log (n+m+e))$
    ///
    /// where $T$ is time, $M$ is additional memory, $n$ is `prec`, $m$ is `x.significant_bits()`,
    /// and $e$ is `x.floor_log_base_2_abs()` (taken as 0 when it is negative or $x = 0$): the input
    /// is rounded to a working precision and the [`Float`] cosine taken there, which for $|x| \geq
    /// 4$ reduces the argument modulo $2\pi$ and so needs $\pi$ to about $n + e$ bits.
    ///
    /// # Panics
    /// Panics if `prec` is zero, or if `rm` is `Exact` but the result cannot be represented exactly
    /// with the given precision (which is the case for every nonzero input).
    ///
    /// # Examples
    /// ```
    /// use malachite_base::rounding_modes::RoundingMode::*;
    /// use malachite_float::Float;
    /// use malachite_q::Rational;
    /// use std::cmp::Ordering::*;
    ///
    /// let (c, o) =
    ///     Float::cos_rational_prec_round_ref(&Rational::from_unsigneds(3u8, 5), 5, Floor);
    /// assert_eq!(c.to_string(), "0.812");
    /// assert_eq!(o, Less);
    ///
    /// let (c, o) =
    ///     Float::cos_rational_prec_round_ref(&Rational::from_unsigneds(3u8, 5), 5, Ceiling);
    /// assert_eq!(c.to_string(), "0.844");
    /// assert_eq!(o, Greater);
    ///
    /// let (c, o) =
    ///     Float::cos_rational_prec_round_ref(&Rational::from_unsigneds(3u8, 5), 20, Floor);
    /// assert_eq!(c.to_string(), "0.82533550");
    /// assert_eq!(o, Less);
    ///
    /// let (c, o) =
    ///     Float::cos_rational_prec_round_ref(&Rational::from_unsigneds(3u8, 5), 20, Ceiling);
    /// assert_eq!(c.to_string(), "0.82533646");
    /// assert_eq!(o, Greater);
    /// ```
    pub fn cos_rational_prec_round_ref(
        x: &Rational,
        prec: u64,
        rm: RoundingMode,
    ) -> (Self, Ordering) {
        assert_ne!(prec, 0);
        if *x == 0u32 {
            // cos(0) = 1, exactly
            return (Self::one_prec(prec), Equal);
        }
        cos_rational_helper(x, prec, rm)
    }

    /// Computes $\cos x$, the cosine of a [`Rational`], rounding the result to the nearest value of
    /// the specified precision and returning the result as a [`Float`]. The [`Rational`] is taken
    /// by value. An [`Ordering`] is also returned, indicating whether the rounded cosine is less
    /// than, equal to, or greater than the exact cosine.
    ///
    /// If the cosine is equidistant from two [`Float`]s with the specified precision, the [`Float`]
    /// with fewer 1s in its binary expansion is chosen. See [`RoundingMode`] for a description of
    /// the `Nearest` rounding mode.
    ///
    /// $$
    /// f(x,p) = \cos x+\varepsilon,
    /// $$
    /// where $|\varepsilon| \leq 2^{\lfloor\log_2 |\cos x|\rfloor-p}$ (unless the result
    /// underflows; see below).
    ///
    /// The output has precision `prec`.
    ///
    /// Special cases:
    /// - $f(0,p)=1$.
    ///
    /// Overflow and underflow:
    /// - Since $|\cos x|\leq 1$, the result never overflows.
    /// - If $0<f(x,p)\leq2^{-2^{30}-1}$, $0.0$ is returned instead.
    /// - If $2^{-2^{30}-1}<f(x,p)<2^{-2^{30}}$, $2^{-2^{30}}$ is returned instead.
    /// - If $-2^{-2^{30}-1}\leq f(x,p)<0$, $-0.0$ is returned instead.
    /// - If $-2^{-2^{30}}<f(x,p)<-2^{-2^{30}-1}$, $-2^{-2^{30}}$ is returned instead.
    ///
    /// Underflow requires an input within $2^{-2^{30}}$ of an odd multiple of $\pi/2$, which takes
    /// more than $2^{30}$ bits.
    ///
    /// If you want to use a rounding mode other than `Nearest`, consider using
    /// [`Float::cos_rational_prec_round`] instead.
    ///
    /// # Worst-case complexity
    /// $T(n, m, e) = O(n (\log n)^3 \log\log n + (n+m+e) (\log (n+m+e))^2 \log\log (n+m+e))$
    ///
    /// $M(n, m, e) = O((n+m+e) \log (n+m+e))$
    ///
    /// where $T$ is time, $M$ is additional memory, $n$ is `prec`, $m$ is `x.significant_bits()`,
    /// and $e$ is `x.floor_log_base_2_abs()` (taken as 0 when it is negative or $x = 0$): the input
    /// is rounded to a working precision and the [`Float`] cosine taken there, which for $|x| \geq
    /// 4$ reduces the argument modulo $2\pi$ and so needs $\pi$ to about $n + e$ bits.
    ///
    /// # Panics
    /// Panics if `prec` is zero.
    ///
    /// # Examples
    /// ```
    /// use malachite_float::Float;
    /// use malachite_q::Rational;
    /// use std::cmp::Ordering::*;
    ///
    /// let (c, o) = Float::cos_rational_prec(Rational::from_unsigneds(3u8, 5), 5);
    /// assert_eq!(c.to_string(), "0.812");
    /// assert_eq!(o, Less);
    ///
    /// let (c, o) = Float::cos_rational_prec(Rational::from_unsigneds(3u8, 5), 20);
    /// assert_eq!(c.to_string(), "0.82533550");
    /// assert_eq!(o, Less);
    /// ```
    #[inline]
    #[allow(clippy::needless_pass_by_value)]
    pub fn cos_rational_prec(x: Rational, prec: u64) -> (Self, Ordering) {
        Self::cos_rational_prec_round_ref(&x, prec, Nearest)
    }

    /// Computes $\cos x$, the cosine of a [`Rational`], rounding the result to the nearest value of
    /// the specified precision and returning the result as a [`Float`]. The [`Rational`] is taken
    /// by reference. An [`Ordering`] is also returned, indicating whether the rounded cosine is
    /// less than, equal to, or greater than the exact cosine.
    ///
    /// If the cosine is equidistant from two [`Float`]s with the specified precision, the [`Float`]
    /// with fewer 1s in its binary expansion is chosen. See [`RoundingMode`] for a description of
    /// the `Nearest` rounding mode.
    ///
    /// $$
    /// f(x,p) = \cos x+\varepsilon,
    /// $$
    /// where $|\varepsilon| \leq 2^{\lfloor\log_2 |\cos x|\rfloor-p}$ (unless the result
    /// underflows).
    ///
    /// The output has precision `prec`.
    ///
    /// Special cases:
    /// - $f(0,p)=1$.
    ///
    /// See the [`Float::cos_rational_prec`] documentation for information on overflow and
    /// underflow.
    ///
    /// If you want to use a rounding mode other than `Nearest`, consider using
    /// [`Float::cos_rational_prec_round_ref`] instead.
    ///
    /// # Worst-case complexity
    /// $T(n, m, e) = O(n (\log n)^3 \log\log n + (n+m+e) (\log (n+m+e))^2 \log\log (n+m+e))$
    ///
    /// $M(n, m, e) = O((n+m+e) \log (n+m+e))$
    ///
    /// where $T$ is time, $M$ is additional memory, $n$ is `prec`, $m$ is `x.significant_bits()`,
    /// and $e$ is `x.floor_log_base_2_abs()` (taken as 0 when it is negative or $x = 0$): the input
    /// is rounded to a working precision and the [`Float`] cosine taken there, which for $|x| \geq
    /// 4$ reduces the argument modulo $2\pi$ and so needs $\pi$ to about $n + e$ bits.
    ///
    /// # Panics
    /// Panics if `prec` is zero.
    ///
    /// # Examples
    /// ```
    /// use malachite_float::Float;
    /// use malachite_q::Rational;
    /// use std::cmp::Ordering::*;
    ///
    /// let (c, o) = Float::cos_rational_prec_ref(&Rational::from_unsigneds(3u8, 5), 5);
    /// assert_eq!(c.to_string(), "0.812");
    /// assert_eq!(o, Less);
    ///
    /// let (c, o) = Float::cos_rational_prec_ref(&Rational::from_unsigneds(3u8, 5), 20);
    /// assert_eq!(c.to_string(), "0.82533550");
    /// assert_eq!(o, Less);
    /// ```
    #[inline]
    pub fn cos_rational_prec_ref(x: &Rational, prec: u64) -> (Self, Ordering) {
        Self::cos_rational_prec_round_ref(x, prec, Nearest)
    }
}

// Halves a correctly rounded constant, negating it if `negative`: the shift is exact, and a
// negative result mirrors the rounding mode and reverses the `Ordering`.
pub(crate) fn half_constant<F: Fn(u64, RoundingMode) -> (Float, Ordering)>(
    constant: F,
    negative: bool,
    prec: u64,
    rm: RoundingMode,
) -> (Float, Ordering) {
    let (c, o) = signed_constant(constant, negative, prec, rm);
    (c >> 1u32, o)
}

// `constant` rounded to `prec` with `rm`, negated if `negative`; the negative case reuses the
// positive one with the rounding mode mirrored.
pub(crate) fn signed_constant<F: Fn(u64, RoundingMode) -> (Float, Ordering)>(
    constant: F,
    negative: bool,
    prec: u64,
    rm: RoundingMode,
) -> (Float, Ordering) {
    if negative {
        let (c, o) = constant(prec, -rm);
        (-c, o.reverse())
    } else {
        constant(prec, rm)
    }
}

// phi - 1 = 1/phi, correctly rounded to `prec` bits: phi rounded to `prec + 1` bits, minus 1, has
// exactly `prec` bits, and the rounding carries over since phi - 1 lies in [1/2, 1).
pub(crate) fn phi_minus_1_prec_round(prec: u64, rm: RoundingMode) -> (Float, Ordering) {
    let (phi, o) = Float::phi_prec_round(prec + 1, rm);
    let (r, o_sub) = phi.sub_prec_round(Float::ONE, prec, Exact);
    assert_eq!(o_sub, Equal);
    (r, o)
}

// The closed-form cases of cos(2 pi x / u), keyed by the denominator d of x/u in lowest terms (with
// |x| < u, so the numerator n is the angle in units of 1/d of a turn). MPFR's exact cases are (a) d
// dividing 4, where the cosine is 0 (always +0, following IEEE 754-2019's cosPi), 1, or -1, and (b)
// d = 3 or 6, where it is 1/2 or -1/2. Beyond MPFR, the algebraic cases are dispatched to a single
// correctly rounded constant: d = 8 gives sqrt(2)/2, d = 12 gives sqrt(3)/2, and d = 5 and 10 give
// phi/2 or (phi - 1)/2, up to sign. Those are 15 to 130 times faster than pi plus a cosine at the
// working precision, and are never exact, so they return `None` for `Exact`.
pub(crate) fn cos_turns_special_case(
    q: &Rational,
    prec: u64,
    rm: RoundingMode,
) -> Option<(Float, Ordering)> {
    let d = q.denominator_ref();
    if *d > 12u32 {
        return None;
    }
    let d = u64::exact_from(d);
    // the angle in units of 1/d of a turn
    let n = u64::exact_from(&Integer::from(q.numerator_ref()).mod_op(Integer::from(d)));
    match d {
        1 => Some((Float::one_prec(prec), Equal)),
        2 => Some((-Float::one_prec(prec), Equal)),
        4 => Some((Float::ZERO, Equal)),
        // cos(60°) = cos(300°) = 1/2; cos(120°) = cos(240°) = -1/2
        6 => Some((Float::one_prec(prec) >> 1u32, Equal)),
        3 => Some((-(Float::one_prec(prec) >> 1u32), Equal)),
        _ if rm == Exact => None,
        // cos(45°) = sqrt(2)/2, cos(135°) = -sqrt(2)/2
        8 => Some(half_constant(
            Float::sqrt_2_prec_round,
            n == 3 || n == 5,
            prec,
            rm,
        )),
        // cos(30°) = sqrt(3)/2, cos(150°) = -sqrt(3)/2
        12 => Some(half_constant(
            |prec, rm| const { Float::const_from_unsigned(3) }.sqrt_prec_round(prec, rm),
            n == 5 || n == 7,
            prec,
            rm,
        )),
        // cos(72°) = (phi - 1)/2, cos(144°) = -phi/2
        5 => Some(if n == 1 || n == 4 {
            half_constant(phi_minus_1_prec_round, false, prec, rm)
        } else {
            half_constant(Float::phi_prec_round, true, prec, rm)
        }),
        // cos(36°) = phi/2, cos(108°) = -(phi - 1)/2
        10 => Some(if n == 1 || n == 9 {
            half_constant(Float::phi_prec_round, false, prec, rm)
        } else {
            half_constant(phi_minus_1_prec_round, true, prec, rm)
        }),
        _ => None,
    }
}

// cos(2 pi q) (if `cos` is true) or sin(2 pi q) for a fraction of a turn q within about 2^-64 of a
// zero of the function, an odd multiple of 1/4 for cos or a multiple of 1/2 for sin, where the
// result is tiny. Since q is rational, so is its distance d to the nearest such point, which is
// computed exactly; then cos(2 pi q) = -sin(2 pi d) if the point is m/4 with m = 1 mod 4 and sin(2
// pi d) if m = 3 mod 4, or sin(2 pi q) = (-1)^m sin(2 pi d) for the point m/2, and sin is bracketed
// by partial sums of its series with pi bracketed at w bits. The bracket is rounded in `Rational`
// arithmetic, so the result underflows correctly when it must. Returns `None` if q is not near such
// a point after all.
//
// This has no MPFR counterpart: MPFR's exponent range is so wide that cosu and sinu never underflow
// there, and they simply keep raising their working precision. The distance d from a fraction of a
// turn q to the nearest zero of the function, and whether the value is the negative of sin(2 pi d);
// `None` if q is not near such a zero after all.
fn trig_turns_near_zero_reduce(q: &Rational, cos: bool) -> Option<(bool, Rational)> {
    Some(if cos {
        let m = Integer::rounding_from(q << 2u32, Nearest).0;
        if m.even() {
            fail_on_untested_path("trig_turns_near_zero, not near an odd multiple of 1/4");
            return None;
        }
        (
            (&m).mod_power_of_2(2) == 1u32,
            q - (Rational::from(m) >> 2u32),
        )
    } else {
        let m = Integer::rounding_from(q << 1u32, Nearest).0;
        (m.odd(), q - (Rational::from(m) >> 1u32))
    })
}

// One bracket of `trig_turns_near_zero` at working precision w, with pi bracketed to w bits.
fn trig_turns_near_zero_step(negate: bool, d: &Rational, w: u64) -> Option<(Rational, Rational)> {
    // pi_lo <= pi <= pi_lo + 2^(2 - w)
    let pi_lo = Rational::exact_from(&Float::pi_prec_round(w, Floor).0);
    let pi_hi = &pi_lo + Rational::power_of_2(2 - i64::exact_from(w));
    let two_d = d << 1u32;
    let (t_lo, t_hi) = if two_d >= 0u32 {
        (&two_d * pi_lo, two_d * pi_hi)
    } else {
        (&two_d * pi_hi, two_d * pi_lo)
    };
    if t_hi.ge_abs(&1u32) || t_lo.ge_abs(&1u32) {
        fail_on_untested_path("trig_turns_near_zero, distance not small");
        return None;
    }
    // sin is increasing on [t_lo, t_hi] (a subset of [-1, 1]), so sin(2 pi d) lies between
    // sin(t_lo) and sin(t_hi)
    let sin_lo = sin_bound(&t_lo, w, false);
    let sin_hi = sin_bound(&t_hi, w, true);
    Some(if negate {
        (-sin_hi, -sin_lo)
    } else {
        (sin_lo, sin_hi)
    })
}

pub(crate) fn trig_turns_near_zero(
    q: &Rational,
    prec: u64,
    rm: RoundingMode,
    cos: bool,
) -> Option<(Float, Ordering)> {
    let (negate, d) = trig_turns_near_zero_reduce(q, cos)?;
    let mut w = prec + 64;
    loop {
        let (lo, hi) = trig_turns_near_zero_step(negate, &d, w)?;
        if let Some(result) = round_bracket(&lo, &hi, prec, rm) {
            return Some(result);
        }
        w <<= 1;
    }
}

// The bracket of `trig_turns_near_zero`, tightened until it is narrower than 2^-(target + 4)
// relative to the value: for a consumer that combines the tiny value with others before rounding
// (the tangent).
pub(crate) fn trig_turns_near_zero_bracket(
    q: &Rational,
    target: u64,
    cos: bool,
) -> Option<(Rational, Rational)> {
    let (negate, d) = trig_turns_near_zero_reduce(q, cos)?;
    let mut w = target + 64;
    loop {
        let (lo, hi) = trig_turns_near_zero_step(negate, &d, w)?;
        if (&hi - &lo) << (target + 4) <= (&lo).abs() {
            return Some((lo, hi));
        }
        w <<= 1;
    }
}

// Computes cos(2 pi x / u) for a finite nonzero `Float` x and a nonzero u, rounded to precision
// `prec` with rounding mode `rm`. `rm` may be `Exact` only in the exact cases (see
// `cos_turns_special_case`).
//
// This is mpfr_cosu from cosu.c, MPFR 4.2.2, with the additional near-zero path.
pub(crate) fn cos_with_period_prec_round_normal_ref(
    x: &Float,
    u: u64,
    prec: u64,
    rm: RoundingMode,
) -> (Float, Ordering) {
    // Range reduction. We do not need to reduce the argument if it is already reduced (|x| < u).
    // Note that the case |x| = u is better in the "else" branch as it will give xr = 0.
    let xr;
    let xp = if x.lt_abs(&u) {
        x
    } else {
        // xr = x mod u, with the sign of x, exactly: its precision is the size of u plus the length
        // of the fractional part of x.
        let p = i64::exact_from(x.get_prec().unwrap()) - i64::from(x.get_exponent().unwrap());
        let (r, o) =
            x.rem_unsigned_prec_round_ref(u, u64::WIDTH + u64::exact_from(max(p, 0)), Exact);
        assert_eq!(o, Equal);
        if r == 0u32 {
            return (Float::one_prec(prec), Equal);
        }
        xr = r;
        &xr
    };
    // now |xp/u| < 1; fold it into [-1/2, 1/2], exactly, so that an x just below a multiple of u
    // lands near 0 rather than near 1, where the small-input shortcut below applies (the cosine is
    // even, so the sign is immaterial; otherwise the working precision would have to grow to the
    // whole cancellation in 1 - cos)
    let xf;
    let xp = if (xp << 1u32).gt_abs(&u) {
        let p = i64::exact_from(xp.get_prec().unwrap()) - i64::from(xp.get_exponent().unwrap());
        let step = if *xp > 0u32 {
            -Float::from(u)
        } else {
            Float::from(u)
        };
        let (f, o) = xp.add_prec_ref_val(step, u64::WIDTH + u64::exact_from(max(p, 0)));
        if o != Equal {
            // The precision suffices, so the difference underflowed: x is within 2^(-2^30) of a
            // multiple of u, and the cosine rounds from 1 alone (and is not exact).
            assert_ne!(rm, Exact, "Inexact cos_with_period");
            return float_round_near_x(&Float::ONE, prec + 2, false, prec, rm).unwrap();
        }
        xf = f;
        &xf
    } else {
        xp
    };
    // for x small, we have |cos(2*pi*x/u)-1| < 1/2*(2*pi*x/u)^2 < 2^5*(x/u)^2
    let exp_x = i64::from(xp.get_exponent().unwrap());
    let log2u = if u == 1 {
        0
    } else {
        i64::exact_from(u.ceiling_log_base_2()) - 1
    };
    // u >= 2^log2u thus 1/u <= 2^(-log2u)
    let erra = -(exp_x << 1);
    let errb = 5 - (log2u << 1);
    // MPFR_SMALL_INPUT_AFTER_SAVE_EXPO (y, __gmpfr_one, erra - errb, 0, 0, rnd_mode, expo, ..)
    if erra > errb {
        let err = u64::exact_from(erra - errb);
        if err > prec + 1 {
            // The reference value 1 has precision 1 < err, so float_round_near_x always succeeds.
            // The error bound only has to clear prec + 1; passing an enormous err (a tiny x has one
            // around 2^31) would make float_round_near_x do work proportional to it. Such a tiny x
            // is never a special case, and its cosine is never exact.
            assert_ne!(rm, Exact, "Inexact cos_with_period");
            return float_round_near_x(&Float::ONE, min(err, prec + 2), false, prec, rm).unwrap();
        }
    }
    // The special cases need |x/u| >= 1/12, so the exponent test skips the `Rational` construction
    // for the small x that would make it expensive (a tiny x has a huge power-of-2 denominator).
    if exp_x >= i64::exact_from(u.significant_bits()) - 4
        && let Some(result) =
            cos_turns_special_case(&(Rational::exact_from(xp) / Rational::from(u)), prec, rm)
    {
        return result;
    }
    // Only the exact cases can be rounded exactly
    assert_ne!(rm, Exact, "Inexact cos_with_period");
    // For x large, since argument reduction is expensive, we want to avoid any failure in Ziv's
    // strategy, thus we take into account expx too.
    let mut prec_t =
        prec + u64::exact_from(max(exp_x, i64::exact_from(prec.ceiling_log_base_2()))) + 8;
    let mut increment = Limb::WIDTH;
    let u_float = Float::from(u);
    loop {
        // We first compute an approximation t of 2*pi*x/u, then call cos(t). If t = 2*pi*x/u + s,
        // then |cos(t) - cos(2*pi*x/u)| <= |s|. t = 2*pi * (1 + theta1) where |theta1| <= 2^-prec
        let mut t = Float::pi_prec(prec_t).0 << 1u32;
        // t = 2*pi*x * (1 + theta2)^2 where |theta2| <= 2^-prec
        t.mul_prec_assign_ref(xp, prec_t);
        // t = 2*pi*x/u * (1 + theta3)^3 where |theta3| <= 2^-prec
        t.div_prec_assign_ref(&u_float, prec_t);
        // if t is zero here, it means the division by u underflowed
        if t == 0u32 {
            // Unreachable in practice: such an x is caught by the small-input shortcut above unless
            // `prec` exceeds 2^31 bits.
            fail_on_untested_path(
                "cos_with_period_prec_round_normal_ref, division by u underflowed",
            );
            return match rm {
                Floor | Down => (one_neighbor(prec, false), Less),
                _ => (Float::one_prec(prec), Greater),
            };
        }
        // since prec >= 2, |(1 + theta3)^3 - 1| <= 4*theta3 <= 2^(2-prec)
        let exp_t = i64::from(t.get_exponent().unwrap());
        // we have |s| <= 2^(expt + 2 - prec)
        let prec_t_i = i64::exact_from(prec_t);
        let mut err = exp_t + 2 - prec_t_i;
        t.cos_prec_assign(prec_t);
        // A tiny (or underflowed) cosine means x/u is close to an odd multiple of 1/4, which the
        // near-zero path resolves exactly; the Ziv loop would need its precision raised by the
        // whole cancellation.
        let exp_t = t.get_exponent().map_or(Float::MIN_EXPONENT_I64, i64::from);
        if exp_t < 0 {
            let cancel = u64::exact_from(-exp_t);
            if cancel >= max(NEAR_ZERO_MIN_CANCEL, prec >> 4)
                && let Some(result) = trig_turns_near_zero(
                    &(Rational::exact_from(xp) / Rational::from(u)),
                    prec,
                    rm,
                    true,
                )
            {
                return result;
            }
        }
        // the total error is at most 2^err + ulp(t)/2 = 2^err + 2^(expt-prec-1) thus if err <=
        // expt-prec-1, it is bounded by 2^(expt-prec), otherwise it is bounded by 2^(err+1).
        err = if err < exp_t - prec_t_i {
            exp_t - prec_t_i
        } else {
            err + 1
        };
        // normalize err for mpfr_can_round
        err = exp_t - err;
        if err > 0 && float_can_round(t.significand_ref().unwrap(), u64::exact_from(err), prec, rm)
        {
            return Float::from_float_prec_round(t, prec, rm);
        }
        // (MPFR checks its exact cases here, after the first level of Ziv's strategy; the special
        // cases above cover them before the loop, since the check is cheap.)
        prec_t += increment;
        increment = prec_t >> 1;
    }
}

impl Float {
    /// Computes $\cos(2\pi x/u)$, the cosine of a [`Float`] measured in $u$ths of a turn, rounding
    /// the result to the specified precision and with the specified rounding mode. The [`Float`] is
    /// taken by value. An [`Ordering`] is also returned, indicating whether the rounded cosine is
    /// less than, equal to, or greater than the exact cosine. Although `NaN`s are not comparable to
    /// any [`Float`], whenever this function returns a `NaN` it also returns `Equal`.
    ///
    /// See [`RoundingMode`] for a description of the possible rounding modes.
    ///
    /// $$
    /// f(x,u,p,m) = \cos(2\pi x/u)+\varepsilon.
    /// $$
    /// - If $x$ is not finite or $u=0$, $\varepsilon$ may be ignored or assumed to be 0.
    /// - If $x$ is finite, $u\neq 0$, and $m$ is not `Nearest`, then $|\varepsilon| <
    ///   2^{\lfloor\log_2 |\cos(2\pi x/u)|\rfloor-p+1}$.
    /// - If $x$ is finite, $u\neq 0$, and $m$ is `Nearest`, then $|\varepsilon| \leq
    ///   2^{\lfloor\log_2 |\cos(2\pi x/u)|\rfloor-p}$.
    ///
    /// If the output has a precision, it is `prec`.
    ///
    /// Special cases:
    /// - $f(\text{NaN},u,p,m)=\text{NaN}$
    /// - $f(\pm\infty,u,p,m)=\text{NaN}$
    /// - $f(x,0,p,m)=\text{NaN}$
    /// - $f(\pm0.0,u,p,m)=1.0$
    /// - If $x/u$ is a multiple of $1/2$, the result is exactly $1$ or $-1$; if it is an odd
    ///   multiple of $1/4$, the result is exactly $0.0$ (always positive, following IEEE 754-2019's
    ///   `cosPi`); and if it is an odd multiple of $1/6$ or $1/3$, the result is exactly $1/2$ or
    ///   $-1/2$.
    ///
    /// When $x/u$ in lowest terms has denominator 5, 8, 10, or 12, the result is $\pm\varphi/2$,
    /// $\pm(\varphi-1)/2$, $\pm\sqrt2/2$, or $\pm\sqrt3/2$, and is computed from a single correctly
    /// rounded constant rather than from $\pi$ and a cosine, which is far faster.
    ///
    /// Overflow and underflow:
    /// - Since $|\cos(2\pi x/u)|\leq 1$, the result never overflows.
    /// - If $0<f(x,u,p,m)<2^{-2^{30}}$, and $m$ is `Floor` or `Down`, $0.0$ is returned instead.
    /// - If $0<f(x,u,p,m)<2^{-2^{30}}$, and $m$ is `Ceiling` or `Up`, $2^{-2^{30}}$ is returned
    ///   instead.
    /// - If $0<f(x,u,p,m)\leq2^{-2^{30}-1}$, and $m$ is `Nearest`, $0.0$ is returned instead.
    /// - If $2^{-2^{30}-1}<f(x,u,p,m)<2^{-2^{30}}$, and $m$ is `Nearest`, $2^{-2^{30}}$ is returned
    ///   instead.
    /// - If $-2^{-2^{30}}<f(x,u,p,m)<0$, and $m$ is `Ceiling` or `Down`, $-0.0$ is returned
    ///   instead.
    /// - If $-2^{-2^{30}}<f(x,u,p,m)<0$, and $m$ is `Floor` or `Up`, $-2^{-2^{30}}$ is returned
    ///   instead.
    /// - If $-2^{-2^{30}-1}\leq f(x,u,p,m)<0$, and $m$ is `Nearest`, $-0.0$ is returned instead.
    /// - If $-2^{-2^{30}}<f(x,u,p,m)<-2^{-2^{30}-1}$, and $m$ is `Nearest`, $-2^{-2^{30}}$ is
    ///   returned instead.
    ///
    /// Underflow requires $x/u$ within $2^{-2^{30}}$ of an odd multiple of $1/4$ without being one,
    /// which takes more than $2^{30}$ bits of precision.
    ///
    /// If you know you'll be using `Nearest`, consider using [`Float::cos_with_period_prec`]
    /// instead. If you know that your target precision is the precision of the input, consider
    /// using [`Float::cos_with_period_round`] instead.
    ///
    /// # Worst-case complexity
    /// $T(n, m, e) = O(n (\log n)^3 \log\log n + (n+m+e) (\log (n+m+e))^2 \log\log (n+m+e))$
    ///
    /// $M(n, m, e) = O((n+m+e) \log (n+m+e))$
    ///
    /// where $T$ is time, $M$ is additional memory, $n$ is `prec`, $m$ is
    /// `self.significant_bits()`, and $e$ is the exponent of `self` (0 if `self` has no exponent or
    /// a negative one): the argument is reduced modulo $u$ exactly, and the cosine of $2\pi x/u$ is
    /// then taken at a working precision of about $n + e$ bits, which needs $\pi$ to that many
    /// bits.
    ///
    /// # Panics
    /// Panics if `prec` is zero, or if `rm` is `Exact` but the result cannot be represented exactly
    /// with the given precision (which is the case unless $x/u$ is a multiple of $1/4$ or $1/6$, or
    /// $x$ is zero or not finite, or $u$ is zero).
    ///
    /// # Examples
    /// ```
    /// use malachite_base::num::basic::traits::One;
    /// use malachite_base::rounding_modes::RoundingMode::*;
    /// use malachite_float::Float;
    /// use std::cmp::Ordering::*;
    ///
    /// let (c, o) = Float::ONE.cos_with_period_prec_round(7, 10, Floor);
    /// assert_eq!(c.to_string(), "0.62305");
    /// assert_eq!(o, Less);
    ///
    /// let (c, o) = Float::ONE.cos_with_period_prec_round(7, 10, Ceiling);
    /// assert_eq!(c.to_string(), "0.62402");
    /// assert_eq!(o, Greater);
    ///
    /// let (c, o) = Float::ONE.cos_with_period_prec_round(7, 10, Nearest);
    /// assert_eq!(c.to_string(), "0.62305");
    /// assert_eq!(o, Less);
    ///
    /// // a sixth of a turn is exact
    /// let (c, o) = Float::from(60u32).cos_with_period_prec_round(360, 10, Exact);
    /// assert_eq!(c.to_string(), "0.50000");
    /// assert_eq!(o, Equal);
    ///
    /// // a quarter turn is exactly zero
    /// let (c, o) = Float::from(90u32).cos_with_period_prec_round(360, 10, Nearest);
    /// assert_eq!(c.to_string(), "0.0");
    /// assert_eq!(o, Equal);
    /// ```
    #[inline]
    pub fn cos_with_period_prec_round(
        self,
        u: u64,
        prec: u64,
        rm: RoundingMode,
    ) -> (Self, Ordering) {
        self.cos_with_period_prec_round_ref(u, prec, rm)
    }

    /// Computes $\cos(2\pi x/u)$, the cosine of a [`Float`] measured in $u$ths of a turn, rounding
    /// the result to the specified precision and with the specified rounding mode. The [`Float`] is
    /// taken by reference. An [`Ordering`] is also returned, indicating whether the rounded cosine
    /// is less than, equal to, or greater than the exact cosine. Although `NaN`s are not comparable
    /// to any [`Float`], whenever this function returns a `NaN` it also returns `Equal`.
    ///
    /// See [`RoundingMode`] for a description of the possible rounding modes.
    ///
    /// $$
    /// f(x,u,p,m) = \cos(2\pi x/u)+\varepsilon.
    /// $$
    /// - If $x$ is not finite or $u=0$, $\varepsilon$ may be ignored or assumed to be 0.
    /// - If $x$ is finite, $u\neq 0$, and $m$ is not `Nearest`, then $|\varepsilon| <
    ///   2^{\lfloor\log_2 |\cos(2\pi x/u)|\rfloor-p+1}$.
    /// - If $x$ is finite, $u\neq 0$, and $m$ is `Nearest`, then $|\varepsilon| \leq
    ///   2^{\lfloor\log_2 |\cos(2\pi x/u)|\rfloor-p}$.
    ///
    /// If the output has a precision, it is `prec`.
    ///
    /// Special cases:
    /// - $f(\text{NaN},u,p,m)=\text{NaN}$
    /// - $f(\pm\infty,u,p,m)=\text{NaN}$
    /// - $f(x,0,p,m)=\text{NaN}$
    /// - $f(\pm0.0,u,p,m)=1.0$
    /// - If $x/u$ is a multiple of $1/2$, the result is exactly $1$ or $-1$; if it is an odd
    ///   multiple of $1/4$, the result is exactly $0.0$ (always positive, following IEEE 754-2019's
    ///   `cosPi`); and if it is an odd multiple of $1/6$ or $1/3$, the result is exactly $1/2$ or
    ///   $-1/2$.
    ///
    /// When $x/u$ in lowest terms has denominator 5, 8, 10, or 12, the result is $\pm\varphi/2$,
    /// $\pm(\varphi-1)/2$, $\pm\sqrt2/2$, or $\pm\sqrt3/2$, and is computed from a single correctly
    /// rounded constant rather than from $\pi$ and a cosine, which is far faster.
    ///
    /// Overflow and underflow:
    /// - Since $|\cos(2\pi x/u)|\leq 1$, the result never overflows.
    /// - If $0<f(x,u,p,m)<2^{-2^{30}}$, and $m$ is `Floor` or `Down`, $0.0$ is returned instead.
    /// - If $0<f(x,u,p,m)<2^{-2^{30}}$, and $m$ is `Ceiling` or `Up`, $2^{-2^{30}}$ is returned
    ///   instead.
    /// - If $0<f(x,u,p,m)\leq2^{-2^{30}-1}$, and $m$ is `Nearest`, $0.0$ is returned instead.
    /// - If $2^{-2^{30}-1}<f(x,u,p,m)<2^{-2^{30}}$, and $m$ is `Nearest`, $2^{-2^{30}}$ is returned
    ///   instead.
    /// - If $-2^{-2^{30}}<f(x,u,p,m)<0$, and $m$ is `Ceiling` or `Down`, $-0.0$ is returned
    ///   instead.
    /// - If $-2^{-2^{30}}<f(x,u,p,m)<0$, and $m$ is `Floor` or `Up`, $-2^{-2^{30}}$ is returned
    ///   instead.
    /// - If $-2^{-2^{30}-1}\leq f(x,u,p,m)<0$, and $m$ is `Nearest`, $-0.0$ is returned instead.
    /// - If $-2^{-2^{30}}<f(x,u,p,m)<-2^{-2^{30}-1}$, and $m$ is `Nearest`, $-2^{-2^{30}}$ is
    ///   returned instead.
    ///
    /// Underflow requires $x/u$ within $2^{-2^{30}}$ of an odd multiple of $1/4$ without being one,
    /// which takes more than $2^{30}$ bits of precision.
    ///
    /// If you know you'll be using `Nearest`, consider using [`Float::cos_with_period_prec_ref`]
    /// instead. If you know that your target precision is the precision of the input, consider
    /// using [`Float::cos_with_period_round_ref`] instead.
    ///
    /// # Worst-case complexity
    /// $T(n, m, e) = O(n (\log n)^3 \log\log n + (n+m+e) (\log (n+m+e))^2 \log\log (n+m+e))$
    ///
    /// $M(n, m, e) = O((n+m+e) \log (n+m+e))$
    ///
    /// where $T$ is time, $M$ is additional memory, $n$ is `prec`, $m$ is
    /// `self.significant_bits()`, and $e$ is the exponent of `self` (0 if `self` has no exponent or
    /// a negative one): the argument is reduced modulo $u$ exactly, and the cosine of $2\pi x/u$ is
    /// then taken at a working precision of about $n + e$ bits, which needs $\pi$ to that many
    /// bits.
    ///
    /// # Panics
    /// Panics if `prec` is zero, or if `rm` is `Exact` but the result cannot be represented exactly
    /// with the given precision (which is the case unless $x/u$ is a multiple of $1/4$ or $1/6$, or
    /// $x$ is zero or not finite, or $u$ is zero).
    ///
    /// # Examples
    /// ```
    /// use malachite_base::num::basic::traits::One;
    /// use malachite_base::rounding_modes::RoundingMode::*;
    /// use malachite_float::Float;
    /// use std::cmp::Ordering::*;
    ///
    /// let (c, o) = (&Float::ONE).cos_with_period_prec_round_ref(7, 10, Floor);
    /// assert_eq!(c.to_string(), "0.62305");
    /// assert_eq!(o, Less);
    ///
    /// let (c, o) = (&Float::ONE).cos_with_period_prec_round_ref(7, 10, Ceiling);
    /// assert_eq!(c.to_string(), "0.62402");
    /// assert_eq!(o, Greater);
    ///
    /// let (c, o) = (&Float::ONE).cos_with_period_prec_round_ref(7, 10, Nearest);
    /// assert_eq!(c.to_string(), "0.62305");
    /// assert_eq!(o, Less);
    ///
    /// // a sixth of a turn is exact
    /// let (c, o) = (&Float::from(60u32)).cos_with_period_prec_round_ref(360, 10, Exact);
    /// assert_eq!(c.to_string(), "0.50000");
    /// assert_eq!(o, Equal);
    ///
    /// // a quarter turn is exactly zero
    /// let (c, o) = (&Float::from(90u32)).cos_with_period_prec_round_ref(360, 10, Nearest);
    /// assert_eq!(c.to_string(), "0.0");
    /// assert_eq!(o, Equal);
    /// ```
    pub fn cos_with_period_prec_round_ref(
        &self,
        u: u64,
        prec: u64,
        rm: RoundingMode,
    ) -> (Self, Ordering) {
        assert_ne!(prec, 0);
        match &self.0 {
            // for u=0, return NaN
            _ if u == 0 => (Self::NAN, Equal),
            NaN | Infinity { .. } => (Self::NAN, Equal),
            // x is zero: cos(0) = 1
            Zero { .. } => (Self::one_prec(prec), Equal),
            Finite { .. } => cos_with_period_prec_round_normal_ref(self, u, prec, rm),
        }
    }

    /// Computes $\cos(2\pi x/u)$, the cosine of a [`Float`] measured in $u$ths of a turn, rounding
    /// the result to the nearest value of the specified precision. The [`Float`] is taken by value.
    /// An [`Ordering`] is also returned, indicating whether the rounded cosine is less than, equal
    /// to, or greater than the exact cosine. Although `NaN`s are not comparable to any [`Float`],
    /// whenever this function returns a `NaN` it also returns `Equal`.
    ///
    /// If the cosine is equidistant from two [`Float`]s with the specified precision, the [`Float`]
    /// with fewer 1s in its binary expansion is chosen. See [`RoundingMode`] for a description of
    /// the `Nearest` rounding mode.
    ///
    /// $$
    /// f(x,u,p) = \cos(2\pi x/u)+\varepsilon.
    /// $$
    /// - If $x$ is not finite or $u=0$, $\varepsilon$ may be ignored or assumed to be 0.
    /// - If $x$ is finite and $u\neq 0$, then $|\varepsilon| < 2^{\lfloor\log_2 |\cos(2\pi
    ///   x/u)|\rfloor-p}$.
    ///
    /// If the output has a precision, it is `prec`.
    ///
    /// Special cases:
    /// - $f(\text{NaN},u,p)=\text{NaN}$
    /// - $f(\pm\infty,u,p)=\text{NaN}$
    /// - $f(x,0,p)=\text{NaN}$
    /// - $f(\pm0.0,u,p)=1.0$
    /// - If $x/u$ is a multiple of $1/2$, the result is exactly $1$ or $-1$; if it is an odd
    ///   multiple of $1/4$, the result is exactly $0.0$ (always positive, following IEEE 754-2019's
    ///   `cosPi`); and if it is an odd multiple of $1/6$ or $1/3$, the result is exactly $1/2$ or
    ///   $-1/2$.
    ///
    /// When $x/u$ in lowest terms has denominator 5, 8, 10, or 12, the result is $\pm\varphi/2$,
    /// $\pm(\varphi-1)/2$, $\pm\sqrt2/2$, or $\pm\sqrt3/2$, and is computed from a single correctly
    /// rounded constant rather than from $\pi$ and a cosine, which is far faster.
    ///
    /// Overflow and underflow:
    /// - Since $|\cos(2\pi x/u)|\leq 1$, the result never overflows.
    /// - If $0<f(x,u,p)\leq2^{-2^{30}-1}$, $0.0$ is returned instead.
    /// - If $2^{-2^{30}-1}<f(x,u,p)<2^{-2^{30}}$, $2^{-2^{30}}$ is returned instead.
    /// - If $-2^{-2^{30}-1}\leq f(x,u,p)<0$, $-0.0$ is returned instead.
    /// - If $-2^{-2^{30}}<f(x,u,p)<-2^{-2^{30}-1}$, $-2^{-2^{30}}$ is returned instead.
    ///
    /// Underflow requires $x/u$ within $2^{-2^{30}}$ of an odd multiple of $1/4$ without being one,
    /// which takes more than $2^{30}$ bits of precision.
    ///
    /// If you want to use a rounding mode other than `Nearest`, consider using
    /// [`Float::cos_with_period_prec_round`] instead. If you know that your target precision is the
    /// precision of the input, consider using [`Float::cos_with_period_round`] with `Nearest`
    /// instead.
    ///
    /// # Worst-case complexity
    /// $T(n, m, e) = O(n (\log n)^3 \log\log n + (n+m+e) (\log (n+m+e))^2 \log\log (n+m+e))$
    ///
    /// $M(n, m, e) = O((n+m+e) \log (n+m+e))$
    ///
    /// where $T$ is time, $M$ is additional memory, $n$ is `prec`, $m$ is
    /// `self.significant_bits()`, and $e$ is the exponent of `self` (0 if `self` has no exponent or
    /// a negative one): the argument is reduced modulo $u$ exactly, and the cosine of $2\pi x/u$ is
    /// then taken at a working precision of about $n + e$ bits, which needs $\pi$ to that many
    /// bits.
    ///
    /// # Panics
    /// Panics if `prec` is zero.
    ///
    /// # Examples
    /// ```
    /// use malachite_base::num::basic::traits::One;
    /// use malachite_float::Float;
    /// use std::cmp::Ordering::*;
    ///
    /// let (c, o) = Float::ONE.cos_with_period_prec(7, 10);
    /// assert_eq!(c.to_string(), "0.62305");
    /// assert_eq!(o, Less);
    ///
    /// let (c, o) = Float::ONE.cos_with_period_prec(360, 53);
    /// assert_eq!(c.to_string(), "0.99984769515639127");
    /// assert_eq!(o, Greater);
    ///
    /// // an eighth of a turn: sqrt(2)/2
    /// let (c, o) = Float::ONE.cos_with_period_prec(8, 10);
    /// assert_eq!(c.to_string(), "0.70703");
    /// assert_eq!(o, Less);
    /// ```
    #[inline]
    pub fn cos_with_period_prec(self, u: u64, prec: u64) -> (Self, Ordering) {
        self.cos_with_period_prec_round(u, prec, Nearest)
    }

    /// Computes $\cos(2\pi x/u)$, the cosine of a [`Float`] measured in $u$ths of a turn, rounding
    /// the result to the nearest value of the specified precision. The [`Float`] is taken by
    /// reference. An [`Ordering`] is also returned, indicating whether the rounded cosine is less
    /// than, equal to, or greater than the exact cosine. Although `NaN`s are not comparable to any
    /// [`Float`], whenever this function returns a `NaN` it also returns `Equal`.
    ///
    /// If the cosine is equidistant from two [`Float`]s with the specified precision, the [`Float`]
    /// with fewer 1s in its binary expansion is chosen. See [`RoundingMode`] for a description of
    /// the `Nearest` rounding mode.
    ///
    /// $$
    /// f(x,u,p) = \cos(2\pi x/u)+\varepsilon.
    /// $$
    /// - If $x$ is not finite or $u=0$, $\varepsilon$ may be ignored or assumed to be 0.
    /// - If $x$ is finite and $u\neq 0$, then $|\varepsilon| < 2^{\lfloor\log_2 |\cos(2\pi
    ///   x/u)|\rfloor-p}$.
    ///
    /// If the output has a precision, it is `prec`.
    ///
    /// Special cases:
    /// - $f(\text{NaN},u,p)=\text{NaN}$
    /// - $f(\pm\infty,u,p)=\text{NaN}$
    /// - $f(x,0,p)=\text{NaN}$
    /// - $f(\pm0.0,u,p)=1.0$
    /// - If $x/u$ is a multiple of $1/2$, the result is exactly $1$ or $-1$; if it is an odd
    ///   multiple of $1/4$, the result is exactly $0.0$ (always positive, following IEEE 754-2019's
    ///   `cosPi`); and if it is an odd multiple of $1/6$ or $1/3$, the result is exactly $1/2$ or
    ///   $-1/2$.
    ///
    /// When $x/u$ in lowest terms has denominator 5, 8, 10, or 12, the result is $\pm\varphi/2$,
    /// $\pm(\varphi-1)/2$, $\pm\sqrt2/2$, or $\pm\sqrt3/2$, and is computed from a single correctly
    /// rounded constant rather than from $\pi$ and a cosine, which is far faster.
    ///
    /// Overflow and underflow:
    /// - Since $|\cos(2\pi x/u)|\leq 1$, the result never overflows.
    /// - If $0<f(x,u,p)\leq2^{-2^{30}-1}$, $0.0$ is returned instead.
    /// - If $2^{-2^{30}-1}<f(x,u,p)<2^{-2^{30}}$, $2^{-2^{30}}$ is returned instead.
    /// - If $-2^{-2^{30}-1}\leq f(x,u,p)<0$, $-0.0$ is returned instead.
    /// - If $-2^{-2^{30}}<f(x,u,p)<-2^{-2^{30}-1}$, $-2^{-2^{30}}$ is returned instead.
    ///
    /// Underflow requires $x/u$ within $2^{-2^{30}}$ of an odd multiple of $1/4$ without being one,
    /// which takes more than $2^{30}$ bits of precision.
    ///
    /// If you want to use a rounding mode other than `Nearest`, consider using
    /// [`Float::cos_with_period_prec_round_ref`] instead. If you know that your target precision is
    /// the precision of the input, consider using [`Float::cos_with_period_round_ref`] with
    /// `Nearest` instead.
    ///
    /// # Worst-case complexity
    /// $T(n, m, e) = O(n (\log n)^3 \log\log n + (n+m+e) (\log (n+m+e))^2 \log\log (n+m+e))$
    ///
    /// $M(n, m, e) = O((n+m+e) \log (n+m+e))$
    ///
    /// where $T$ is time, $M$ is additional memory, $n$ is `prec`, $m$ is
    /// `self.significant_bits()`, and $e$ is the exponent of `self` (0 if `self` has no exponent or
    /// a negative one): the argument is reduced modulo $u$ exactly, and the cosine of $2\pi x/u$ is
    /// then taken at a working precision of about $n + e$ bits, which needs $\pi$ to that many
    /// bits.
    ///
    /// # Panics
    /// Panics if `prec` is zero.
    ///
    /// # Examples
    /// ```
    /// use malachite_base::num::basic::traits::One;
    /// use malachite_float::Float;
    /// use std::cmp::Ordering::*;
    ///
    /// let (c, o) = (&Float::ONE).cos_with_period_prec_ref(7, 10);
    /// assert_eq!(c.to_string(), "0.62305");
    /// assert_eq!(o, Less);
    ///
    /// let (c, o) = (&Float::ONE).cos_with_period_prec_ref(360, 53);
    /// assert_eq!(c.to_string(), "0.99984769515639127");
    /// assert_eq!(o, Greater);
    ///
    /// // an eighth of a turn: sqrt(2)/2
    /// let (c, o) = (&Float::ONE).cos_with_period_prec_ref(8, 10);
    /// assert_eq!(c.to_string(), "0.70703");
    /// assert_eq!(o, Less);
    /// ```
    #[inline]
    pub fn cos_with_period_prec_ref(&self, u: u64, prec: u64) -> (Self, Ordering) {
        self.cos_with_period_prec_round_ref(u, prec, Nearest)
    }

    /// Computes $\cos(2\pi x/u)$, the cosine of a [`Float`] measured in $u$ths of a turn, rounding
    /// the result with the specified rounding mode. The [`Float`] is taken by value. An
    /// [`Ordering`] is also returned, indicating whether the rounded cosine is less than, equal to,
    /// or greater than the exact cosine. Although `NaN`s are not comparable to any [`Float`],
    /// whenever this function returns a `NaN` it also returns `Equal`.
    ///
    /// The precision of the output is the precision of the input. See [`RoundingMode`] for a
    /// description of the possible rounding modes.
    ///
    /// $$
    /// f(x,u,m) = \cos(2\pi x/u)+\varepsilon.
    /// $$
    /// - If $x$ is not finite or $u=0$, $\varepsilon$ may be ignored or assumed to be 0.
    /// - If $x$ is finite, $u\neq 0$, and $m$ is not `Nearest`, then $|\varepsilon| <
    ///   2^{\lfloor\log_2 |\cos(2\pi x/u)|\rfloor-p+1}$, where $p$ is the precision of the input.
    /// - If $x$ is finite, $u\neq 0$, and $m$ is `Nearest`, then $|\varepsilon| \leq
    ///   2^{\lfloor\log_2 |\cos(2\pi x/u)|\rfloor-p}$, where $p$ is the precision of the input.
    ///
    /// If the output has a precision, it is the precision of the input.
    ///
    /// Special cases:
    /// - $f(\text{NaN},u,m)=\text{NaN}$
    /// - $f(\pm\infty,u,m)=\text{NaN}$
    /// - $f(x,0,m)=\text{NaN}$
    /// - $f(\pm0.0,u,m)=1.0$
    /// - If $x/u$ is a multiple of $1/2$, the result is exactly $1$ or $-1$; if it is an odd
    ///   multiple of $1/4$, the result is exactly $0.0$ (always positive, following IEEE 754-2019's
    ///   `cosPi`); and if it is an odd multiple of $1/6$ or $1/3$, the result is exactly $1/2$ or
    ///   $-1/2$.
    ///
    /// When $x/u$ in lowest terms has denominator 5, 8, 10, or 12, the result is $\pm\varphi/2$,
    /// $\pm(\varphi-1)/2$, $\pm\sqrt2/2$, or $\pm\sqrt3/2$, and is computed from a single correctly
    /// rounded constant rather than from $\pi$ and a cosine, which is far faster.
    ///
    /// Overflow and underflow:
    /// - Since $|\cos(2\pi x/u)|\leq 1$, the result never overflows.
    /// - If $0<f(x,u,m)<2^{-2^{30}}$, and $m$ is `Floor` or `Down`, $0.0$ is returned instead.
    /// - If $0<f(x,u,m)<2^{-2^{30}}$, and $m$ is `Ceiling` or `Up`, $2^{-2^{30}}$ is returned
    ///   instead.
    /// - If $0<f(x,u,m)\leq2^{-2^{30}-1}$, and $m$ is `Nearest`, $0.0$ is returned instead.
    /// - If $2^{-2^{30}-1}<f(x,u,m)<2^{-2^{30}}$, and $m$ is `Nearest`, $2^{-2^{30}}$ is returned
    ///   instead.
    /// - If $-2^{-2^{30}}<f(x,u,m)<0$, and $m$ is `Ceiling` or `Down`, $-0.0$ is returned instead.
    /// - If $-2^{-2^{30}}<f(x,u,m)<0$, and $m$ is `Floor` or `Up`, $-2^{-2^{30}}$ is returned
    ///   instead.
    /// - If $-2^{-2^{30}-1}\leq f(x,u,m)<0$, and $m$ is `Nearest`, $-0.0$ is returned instead.
    /// - If $-2^{-2^{30}}<f(x,u,m)<-2^{-2^{30}-1}$, and $m$ is `Nearest`, $-2^{-2^{30}}$ is
    ///   returned instead.
    ///
    /// Underflow requires $x/u$ within $2^{-2^{30}}$ of an odd multiple of $1/4$ without being one,
    /// which takes more than $2^{30}$ bits of precision.
    ///
    /// If you want to specify an output precision, consider using
    /// [`Float::cos_with_period_prec_round`] instead. If you know you'll be using the `Nearest`
    /// rounding mode, consider using [`Float::cos_with_period_prec`] with the input's precision
    /// instead.
    ///
    /// # Worst-case complexity
    /// $T(n, e) = O(n (\log n)^3 \log\log n + (n+e) (\log (n+e))^2 \log\log (n+e))$
    ///
    /// $M(n, e) = O((n+e) \log (n+e))$
    ///
    /// where $T$ is time, $M$ is additional memory, $n$ is `self.significant_bits()`, and $e$ is
    /// the exponent of `self` (0 if `self` has no exponent or a negative one): the argument is
    /// reduced modulo $u$ exactly, and the cosine of $2\pi x/u$ is then taken at a working
    /// precision of about $n + e$ bits, which needs $\pi$ to that many bits.
    ///
    /// # Panics
    /// Panics if `rm` is `Exact` but the result cannot be represented exactly with the input
    /// precision (which is the case unless $x/u$ is a multiple of $1/4$ or $1/6$, or $x$ is zero or
    /// not finite, or $u$ is zero).
    ///
    /// # Examples
    /// ```
    /// use malachite_base::rounding_modes::RoundingMode::*;
    /// use malachite_float::Float;
    /// use std::cmp::Ordering::*;
    ///
    /// let (c, o) = Float::from_unsigned_prec(1u32, 10)
    ///     .0
    ///     .cos_with_period_round(7, Floor);
    /// assert_eq!(c.to_string(), "0.62305");
    /// assert_eq!(o, Less);
    ///
    /// let (c, o) = Float::from_unsigned_prec(1u32, 10)
    ///     .0
    ///     .cos_with_period_round(7, Ceiling);
    /// assert_eq!(c.to_string(), "0.62402");
    /// assert_eq!(o, Greater);
    ///
    /// let (c, o) = Float::from_unsigned_prec(1u32, 10)
    ///     .0
    ///     .cos_with_period_round(7, Nearest);
    /// assert_eq!(c.to_string(), "0.62305");
    /// assert_eq!(o, Less);
    /// ```
    #[inline]
    pub fn cos_with_period_round(self, u: u64, rm: RoundingMode) -> (Self, Ordering) {
        let prec = self.significant_bits();
        self.cos_with_period_prec_round(u, prec, rm)
    }

    /// Computes $\cos(2\pi x/u)$, the cosine of a [`Float`] measured in $u$ths of a turn, rounding
    /// the result with the specified rounding mode. The [`Float`] is taken by reference. An
    /// [`Ordering`] is also returned, indicating whether the rounded cosine is less than, equal to,
    /// or greater than the exact cosine. Although `NaN`s are not comparable to any [`Float`],
    /// whenever this function returns a `NaN` it also returns `Equal`.
    ///
    /// The precision of the output is the precision of the input. See [`RoundingMode`] for a
    /// description of the possible rounding modes.
    ///
    /// $$
    /// f(x,u,m) = \cos(2\pi x/u)+\varepsilon.
    /// $$
    /// - If $x$ is not finite or $u=0$, $\varepsilon$ may be ignored or assumed to be 0.
    /// - If $x$ is finite, $u\neq 0$, and $m$ is not `Nearest`, then $|\varepsilon| <
    ///   2^{\lfloor\log_2 |\cos(2\pi x/u)|\rfloor-p+1}$, where $p$ is the precision of the input.
    /// - If $x$ is finite, $u\neq 0$, and $m$ is `Nearest`, then $|\varepsilon| \leq
    ///   2^{\lfloor\log_2 |\cos(2\pi x/u)|\rfloor-p}$, where $p$ is the precision of the input.
    ///
    /// If the output has a precision, it is the precision of the input.
    ///
    /// Special cases:
    /// - $f(\text{NaN},u,m)=\text{NaN}$
    /// - $f(\pm\infty,u,m)=\text{NaN}$
    /// - $f(x,0,m)=\text{NaN}$
    /// - $f(\pm0.0,u,m)=1.0$
    /// - If $x/u$ is a multiple of $1/2$, the result is exactly $1$ or $-1$; if it is an odd
    ///   multiple of $1/4$, the result is exactly $0.0$ (always positive, following IEEE 754-2019's
    ///   `cosPi`); and if it is an odd multiple of $1/6$ or $1/3$, the result is exactly $1/2$ or
    ///   $-1/2$.
    ///
    /// When $x/u$ in lowest terms has denominator 5, 8, 10, or 12, the result is $\pm\varphi/2$,
    /// $\pm(\varphi-1)/2$, $\pm\sqrt2/2$, or $\pm\sqrt3/2$, and is computed from a single correctly
    /// rounded constant rather than from $\pi$ and a cosine, which is far faster.
    ///
    /// Overflow and underflow:
    /// - Since $|\cos(2\pi x/u)|\leq 1$, the result never overflows.
    /// - If $0<f(x,u,m)<2^{-2^{30}}$, and $m$ is `Floor` or `Down`, $0.0$ is returned instead.
    /// - If $0<f(x,u,m)<2^{-2^{30}}$, and $m$ is `Ceiling` or `Up`, $2^{-2^{30}}$ is returned
    ///   instead.
    /// - If $0<f(x,u,m)\leq2^{-2^{30}-1}$, and $m$ is `Nearest`, $0.0$ is returned instead.
    /// - If $2^{-2^{30}-1}<f(x,u,m)<2^{-2^{30}}$, and $m$ is `Nearest`, $2^{-2^{30}}$ is returned
    ///   instead.
    /// - If $-2^{-2^{30}}<f(x,u,m)<0$, and $m$ is `Ceiling` or `Down`, $-0.0$ is returned instead.
    /// - If $-2^{-2^{30}}<f(x,u,m)<0$, and $m$ is `Floor` or `Up`, $-2^{-2^{30}}$ is returned
    ///   instead.
    /// - If $-2^{-2^{30}-1}\leq f(x,u,m)<0$, and $m$ is `Nearest`, $-0.0$ is returned instead.
    /// - If $-2^{-2^{30}}<f(x,u,m)<-2^{-2^{30}-1}$, and $m$ is `Nearest`, $-2^{-2^{30}}$ is
    ///   returned instead.
    ///
    /// Underflow requires $x/u$ within $2^{-2^{30}}$ of an odd multiple of $1/4$ without being one,
    /// which takes more than $2^{30}$ bits of precision.
    ///
    /// If you want to specify an output precision, consider using
    /// [`Float::cos_with_period_prec_round_ref`] instead. If you know you'll be using the `Nearest`
    /// rounding mode, consider using [`Float::cos_with_period_prec_ref`] with the input's precision
    /// instead.
    ///
    /// # Worst-case complexity
    /// $T(n, e) = O(n (\log n)^3 \log\log n + (n+e) (\log (n+e))^2 \log\log (n+e))$
    ///
    /// $M(n, e) = O((n+e) \log (n+e))$
    ///
    /// where $T$ is time, $M$ is additional memory, $n$ is `self.significant_bits()`, and $e$ is
    /// the exponent of `self` (0 if `self` has no exponent or a negative one): the argument is
    /// reduced modulo $u$ exactly, and the cosine of $2\pi x/u$ is then taken at a working
    /// precision of about $n + e$ bits, which needs $\pi$ to that many bits.
    ///
    /// # Panics
    /// Panics if `rm` is `Exact` but the result cannot be represented exactly with the input
    /// precision (which is the case unless $x/u$ is a multiple of $1/4$ or $1/6$, or $x$ is zero or
    /// not finite, or $u$ is zero).
    ///
    /// # Examples
    /// ```
    /// use malachite_base::rounding_modes::RoundingMode::*;
    /// use malachite_float::Float;
    /// use std::cmp::Ordering::*;
    ///
    /// let (c, o) = (&Float::from_unsigned_prec(1u32, 10).0).cos_with_period_round_ref(7, Floor);
    /// assert_eq!(c.to_string(), "0.62305");
    /// assert_eq!(o, Less);
    ///
    /// let (c, o) = (&Float::from_unsigned_prec(1u32, 10).0).cos_with_period_round_ref(7, Ceiling);
    /// assert_eq!(c.to_string(), "0.62402");
    /// assert_eq!(o, Greater);
    ///
    /// let (c, o) = (&Float::from_unsigned_prec(1u32, 10).0).cos_with_period_round_ref(7, Nearest);
    /// assert_eq!(c.to_string(), "0.62305");
    /// assert_eq!(o, Less);
    /// ```
    #[inline]
    pub fn cos_with_period_round_ref(&self, u: u64, rm: RoundingMode) -> (Self, Ordering) {
        self.cos_with_period_prec_round_ref(u, self.significant_bits(), rm)
    }

    /// Computes $\cos(2\pi x/u)$, the cosine of a [`Float`] measured in $u$ths of a turn (so that
    /// `u = 360` is degrees), rounding the result to the precision of the input and to the nearest
    /// [`Float`]. The [`Float`] is taken by value.
    ///
    /// If the cosine is equidistant from two [`Float`]s with the precision of the input, the
    /// [`Float`] with fewer 1s in its binary expansion is chosen. See [`RoundingMode`] for a
    /// description of the `Nearest` rounding mode.
    ///
    /// See [`Float::cos_with_period_prec_round`] for the error bounds, the special and closed-form
    /// cases, overflow and underflow, and the complexity; this function behaves the same way with
    /// `prec` equal to the precision of the input and `rm` equal to `Nearest`.
    ///
    /// If you want to use a rounding mode other than `Nearest`, consider using
    /// [`Float::cos_with_period_round`] instead. If you want to specify an output precision,
    /// consider using [`Float::cos_with_period_prec`]. If you want both of these things, consider
    /// using [`Float::cos_with_period_prec_round`].
    ///
    /// # Examples
    /// ```
    /// use malachite_float::Float;
    ///
    /// let c = Float::from_unsigned_prec(1u32, 10).0.cos_with_period(7);
    /// assert_eq!(c.to_string(), "0.62305");
    ///
    /// // a half turn is exactly -1
    /// assert_eq!(
    ///     Float::from(180u32).cos_with_period(360).to_string(),
    ///     "-1.00"
    /// );
    /// ```
    #[inline]
    pub fn cos_with_period(self, u: u64) -> Self {
        let prec = self.significant_bits();
        self.cos_with_period_prec(u, prec).0
    }

    /// Computes $\cos(2\pi x/u)$, the cosine of a [`Float`] measured in $u$ths of a turn (so that
    /// `u = 360` is degrees), rounding the result to the precision of the input and to the nearest
    /// [`Float`]. The [`Float`] is taken by reference.
    ///
    /// If the cosine is equidistant from two [`Float`]s with the precision of the input, the
    /// [`Float`] with fewer 1s in its binary expansion is chosen. See [`RoundingMode`] for a
    /// description of the `Nearest` rounding mode.
    ///
    /// See [`Float::cos_with_period_prec_round`] for the error bounds, the special and closed-form
    /// cases, overflow and underflow, and the complexity; this function behaves the same way with
    /// `prec` equal to the precision of the input and `rm` equal to `Nearest`.
    ///
    /// If you want to use a rounding mode other than `Nearest`, consider using
    /// [`Float::cos_with_period_round_ref`] instead. If you want to specify an output precision,
    /// consider using [`Float::cos_with_period_prec_ref`]. If you want both of these things,
    /// consider using [`Float::cos_with_period_prec_round_ref`].
    ///
    /// # Examples
    /// ```
    /// use malachite_float::Float;
    ///
    /// let c = (&Float::from_unsigned_prec(1u32, 10).0).cos_with_period_ref(7);
    /// assert_eq!(c.to_string(), "0.62305");
    /// ```
    #[inline]
    pub fn cos_with_period_ref(&self, u: u64) -> Self {
        self.cos_with_period_prec_ref(u, self.significant_bits()).0
    }

    /// Computes $\cos(2\pi x/u)$, the cosine of a [`Float`] measured in $u$ths of a turn, rounding
    /// the result to the specified precision and with the specified rounding mode. The [`Float`] is
    /// replaced by the result, and an [`Ordering`] is returned, indicating whether the rounded
    /// cosine is less than, equal to, or greater than the exact cosine. Although `NaN`s are not
    /// comparable to any [`Float`], whenever this function sets a `NaN` it also returns `Equal`.
    ///
    /// See [`RoundingMode`] for a description of the possible rounding modes.
    ///
    /// $$
    /// x \gets \cos(2\pi x/u)+\varepsilon.
    /// $$
    /// - If $x$ is not finite or $u=0$, $\varepsilon$ may be ignored or assumed to be 0.
    /// - If $x$ is finite, $u\neq 0$, and $m$ is not `Nearest`, then $|\varepsilon| <
    ///   2^{\lfloor\log_2 |\cos(2\pi x/u)|\rfloor-p+1}$.
    /// - If $x$ is finite, $u\neq 0$, and $m$ is `Nearest`, then $|\varepsilon| \leq
    ///   2^{\lfloor\log_2 |\cos(2\pi x/u)|\rfloor-p}$.
    ///
    /// If the output has a precision, it is `prec`.
    ///
    /// See the [`Float::cos_with_period_prec_round`] documentation for information on special
    /// cases, overflow, and underflow.
    ///
    /// If you know you'll be using `Nearest`, consider using [`Float::cos_with_period_prec_assign`]
    /// instead. If you know that your target precision is the precision of the input, consider
    /// using [`Float::cos_with_period_round_assign`] instead.
    ///
    /// # Worst-case complexity
    /// $T(n, m, e) = O(n (\log n)^3 \log\log n + (n+m+e) (\log (n+m+e))^2 \log\log (n+m+e))$
    ///
    /// $M(n, m, e) = O((n+m+e) \log (n+m+e))$
    ///
    /// where $T$ is time, $M$ is additional memory, $n$ is `prec`, $m$ is
    /// `self.significant_bits()`, and $e$ is the exponent of `self` (0 if `self` has no exponent or
    /// a negative one): the argument is reduced modulo $u$ exactly, and the cosine of $2\pi x/u$ is
    /// then taken at a working precision of about $n + e$ bits, which needs $\pi$ to that many
    /// bits.
    ///
    /// # Panics
    /// Panics if `prec` is zero, or if `rm` is `Exact` but the result cannot be represented exactly
    /// with the given precision (which is the case unless $x/u$ is a multiple of $1/4$ or $1/6$, or
    /// $x$ is zero or not finite, or $u$ is zero).
    ///
    /// # Examples
    /// ```
    /// use malachite_base::rounding_modes::RoundingMode::*;
    /// use malachite_float::Float;
    /// use std::cmp::Ordering::*;
    ///
    /// let mut x = Float::from_unsigned_prec(1u32, 100).0;
    /// assert_eq!(x.cos_with_period_prec_round_assign(7, 10, Floor), Less);
    /// assert_eq!(x.to_string(), "0.62305");
    ///
    /// let mut x = Float::from_unsigned_prec(1u32, 100).0;
    /// assert_eq!(x.cos_with_period_prec_round_assign(7, 10, Ceiling), Greater);
    /// assert_eq!(x.to_string(), "0.62402");
    ///
    /// let mut x = Float::from_unsigned_prec(1u32, 100).0;
    /// assert_eq!(x.cos_with_period_prec_round_assign(7, 10, Nearest), Less);
    /// assert_eq!(x.to_string(), "0.62305");
    /// ```
    #[inline]
    pub fn cos_with_period_prec_round_assign(
        &mut self,
        u: u64,
        prec: u64,
        rm: RoundingMode,
    ) -> Ordering {
        let o;
        (*self, o) = self.cos_with_period_prec_round_ref(u, prec, rm);
        o
    }

    /// Computes $\cos(2\pi x/u)$, the cosine of a [`Float`] measured in $u$ths of a turn, rounding
    /// the result to the nearest value of the specified precision. The [`Float`] is replaced by the
    /// result, and an [`Ordering`] is returned, indicating whether the rounded cosine is less than,
    /// equal to, or greater than the exact cosine. Although `NaN`s are not comparable to any
    /// [`Float`], whenever this function sets a `NaN` it also returns `Equal`.
    ///
    /// If the cosine is equidistant from two [`Float`]s with the specified precision, the [`Float`]
    /// with fewer 1s in its binary expansion is chosen. See [`RoundingMode`] for a description of
    /// the `Nearest` rounding mode.
    ///
    /// $$
    /// x \gets \cos(2\pi x/u)+\varepsilon.
    /// $$
    /// - If $x$ is not finite or $u=0$, $\varepsilon$ may be ignored or assumed to be 0.
    /// - If $x$ is finite and $u\neq 0$, then $|\varepsilon| < 2^{\lfloor\log_2 |\cos(2\pi
    ///   x/u)|\rfloor-p}$.
    ///
    /// If the output has a precision, it is `prec`.
    ///
    /// See the [`Float::cos_with_period_prec`] documentation for information on special cases,
    /// overflow, and underflow.
    ///
    /// If you want to use a rounding mode other than `Nearest`, consider using
    /// [`Float::cos_with_period_prec_round_assign`] instead. If you know that your target precision
    /// is the precision of the input, consider using [`Float::cos_with_period_round_assign`] with
    /// `Nearest` instead.
    ///
    /// # Worst-case complexity
    /// $T(n, m, e) = O(n (\log n)^3 \log\log n + (n+m+e) (\log (n+m+e))^2 \log\log (n+m+e))$
    ///
    /// $M(n, m, e) = O((n+m+e) \log (n+m+e))$
    ///
    /// where $T$ is time, $M$ is additional memory, $n$ is `prec`, $m$ is
    /// `self.significant_bits()`, and $e$ is the exponent of `self` (0 if `self` has no exponent or
    /// a negative one): the argument is reduced modulo $u$ exactly, and the cosine of $2\pi x/u$ is
    /// then taken at a working precision of about $n + e$ bits, which needs $\pi$ to that many
    /// bits.
    ///
    /// # Panics
    /// Panics if `prec` is zero.
    ///
    /// # Examples
    /// ```
    /// use malachite_float::Float;
    /// use std::cmp::Ordering::*;
    ///
    /// let mut x = Float::from_unsigned_prec(1u32, 100).0;
    /// assert_eq!(x.cos_with_period_prec_assign(7, 10), Less);
    /// assert_eq!(x.to_string(), "0.62305");
    ///
    /// let mut x = Float::from_unsigned_prec(1u32, 100).0;
    /// assert_eq!(x.cos_with_period_prec_assign(8, 10), Less);
    /// assert_eq!(x.to_string(), "0.70703");
    /// ```
    #[inline]
    pub fn cos_with_period_prec_assign(&mut self, u: u64, prec: u64) -> Ordering {
        self.cos_with_period_prec_round_assign(u, prec, Nearest)
    }

    /// Computes $\cos(2\pi x/u)$, the cosine of a [`Float`] measured in $u$ths of a turn, rounding
    /// the result with the specified rounding mode. The [`Float`] is replaced by the result, and an
    /// [`Ordering`] is returned, indicating whether the rounded cosine is less than, equal to, or
    /// greater than the exact cosine. Although `NaN`s are not comparable to any [`Float`], whenever
    /// this function sets a `NaN` it also returns `Equal`.
    ///
    /// The precision of the output is the precision of the input. See [`RoundingMode`] for a
    /// description of the possible rounding modes.
    ///
    /// $$
    /// x \gets \cos(2\pi x/u)+\varepsilon.
    /// $$
    /// - If $x$ is not finite or $u=0$, $\varepsilon$ may be ignored or assumed to be 0.
    /// - If $x$ is finite, $u\neq 0$, and $m$ is not `Nearest`, then $|\varepsilon| <
    ///   2^{\lfloor\log_2 |\cos(2\pi x/u)|\rfloor-p+1}$, where $p$ is the precision of the input.
    /// - If $x$ is finite, $u\neq 0$, and $m$ is `Nearest`, then $|\varepsilon| \leq
    ///   2^{\lfloor\log_2 |\cos(2\pi x/u)|\rfloor-p}$, where $p$ is the precision of the input.
    ///
    /// If the output has a precision, it is the precision of the input.
    ///
    /// See the [`Float::cos_with_period_round`] documentation for information on special cases,
    /// overflow, and underflow.
    ///
    /// If you want to specify an output precision, consider using
    /// [`Float::cos_with_period_prec_round_assign`] instead. If you know you'll be using the
    /// `Nearest` rounding mode, consider using [`Float::cos_with_period_prec_assign`] with the
    /// input's precision instead.
    ///
    /// # Worst-case complexity
    /// $T(n, e) = O(n (\log n)^3 \log\log n + (n+e) (\log (n+e))^2 \log\log (n+e))$
    ///
    /// $M(n, e) = O((n+e) \log (n+e))$
    ///
    /// where $T$ is time, $M$ is additional memory, $n$ is `self.significant_bits()`, and $e$ is
    /// the exponent of `self` (0 if `self` has no exponent or a negative one): the argument is
    /// reduced modulo $u$ exactly, and the cosine of $2\pi x/u$ is then taken at a working
    /// precision of about $n + e$ bits, which needs $\pi$ to that many bits.
    ///
    /// # Panics
    /// Panics if `rm` is `Exact` but the result cannot be represented exactly with the input
    /// precision (which is the case unless $x/u$ is a multiple of $1/4$ or $1/6$, or $x$ is zero or
    /// not finite, or $u$ is zero).
    ///
    /// # Examples
    /// ```
    /// use malachite_base::rounding_modes::RoundingMode::*;
    /// use malachite_float::Float;
    /// use std::cmp::Ordering::*;
    ///
    /// let mut x = Float::from_unsigned_prec(1u32, 10).0;
    /// assert_eq!(x.cos_with_period_round_assign(7, Floor), Less);
    /// assert_eq!(x.to_string(), "0.62305");
    ///
    /// let mut x = Float::from_unsigned_prec(1u32, 10).0;
    /// assert_eq!(x.cos_with_period_round_assign(7, Ceiling), Greater);
    /// assert_eq!(x.to_string(), "0.62402");
    ///
    /// let mut x = Float::from_unsigned_prec(1u32, 10).0;
    /// assert_eq!(x.cos_with_period_round_assign(7, Nearest), Less);
    /// assert_eq!(x.to_string(), "0.62305");
    /// ```
    #[inline]
    pub fn cos_with_period_round_assign(&mut self, u: u64, rm: RoundingMode) -> Ordering {
        let prec = self.significant_bits();
        self.cos_with_period_prec_round_assign(u, prec, rm)
    }

    /// Computes $\cos(2\pi x/u)$, the cosine of a [`Float`] measured in $u$ths of a turn (so that
    /// `u = 360` is degrees), rounding the result to the precision of the input and to the nearest
    /// [`Float`]. The [`Float`] is replaced by the result.
    ///
    /// If the cosine is equidistant from two [`Float`]s with the precision of the input, the
    /// [`Float`] with fewer 1s in its binary expansion is chosen. See [`RoundingMode`] for a
    /// description of the `Nearest` rounding mode.
    ///
    /// See [`Float::cos_with_period_prec_round`] for the error bounds, the special and closed-form
    /// cases, overflow and underflow, and the complexity; this function behaves the same way with
    /// `prec` equal to the precision of the input and `rm` equal to `Nearest`.
    ///
    /// If you want to use a rounding mode other than `Nearest`, consider using
    /// [`Float::cos_with_period_round_assign`] instead. If you want to specify an output precision,
    /// consider using [`Float::cos_with_period_prec_assign`]. If you want both of these things,
    /// consider using [`Float::cos_with_period_prec_round_assign`].
    ///
    /// # Examples
    /// ```
    /// use malachite_float::Float;
    ///
    /// let mut x = Float::from_unsigned_prec(1u32, 10).0;
    /// x.cos_with_period_assign(7);
    /// assert_eq!(x.to_string(), "0.62305");
    /// ```
    #[inline]
    pub fn cos_with_period_assign(&mut self, u: u64) {
        let prec = self.significant_bits();
        self.cos_with_period_prec_assign(u, prec);
    }
}

// Computes cos(2 pi q) for a nonzero fraction of a turn q with |q| < 1, rounded to precision `prec`
// with rounding mode `rm`. This is the `Rational` counterpart of
// `cos_with_period_prec_round_normal_ref`, with the same structure: the small-input shortcut, the
// closed-form cases, and a Ziv loop around the cosine of a `Float` approximation of 2 pi q, whose
// three roundings (q, pi, and the product) give the same error bound as MPFR's cosu. `rm` may be
// `Exact` only in the exact cases.
pub(crate) fn cos_turns_helper(q: &Rational, prec: u64, rm: RoundingMode) -> (Float, Ordering) {
    let exp_q = q.floor_log_base_2_abs() + 1;
    // for q small, we have |cos(2*pi*q)-1| < 1/2*(2*pi*q)^2 < 2^5*q^2 < 2^(5 + 2 EXP(q))
    let err = -(exp_q << 1) - 5;
    if err > 0 {
        let err = u64::exact_from(err);
        if err > prec + 1 {
            // As in the `Float` version: the reference value 1 always rounds, the bound need not
            // exceed prec + 2, and such a tiny q is neither a special case nor exact.
            assert_ne!(rm, Exact, "Inexact cos_with_period");
            return float_round_near_x(&Float::ONE, min(err, prec + 2), false, prec, rm).unwrap();
        }
    }
    // The special cases need |q| >= 1/12
    if exp_q >= -4
        && let Some(result) = cos_turns_special_case(q, prec, rm)
    {
        return result;
    }
    // Only the exact cases can be rounded exactly
    assert_ne!(rm, Exact, "Inexact cos_with_period");
    let mut w = prec + prec.ceiling_log_base_2() + 8;
    let mut increment = Limb::WIDTH;
    loop {
        // t = 2*pi*q * (1 + theta)^3 where |theta| <= 2^-w, from rounding q, pi, and the product
        let mut t = Float::pi_prec(w).0 << 1u32;
        t.mul_prec_assign(Float::from_rational_prec_ref(q, w).0, w);
        if t == 0u32 {
            // Unreachable in practice: such a q is caught by the small-input shortcut above unless
            // `prec` exceeds 2^31 bits.
            fail_on_untested_path("cos_turns_helper, 2 pi q underflowed");
            return match rm {
                Floor | Down => (one_neighbor(prec, false), Less),
                _ => (Float::one_prec(prec), Greater),
            };
        }
        // since w >= 2, |(1 + theta)^3 - 1| <= 4*theta <= 2^(2-w), and |cos(t) - cos(2 pi q)| <=
        // |s| <= 2^(EXP(t) + 2 - w)
        let exp_t = i64::from(t.get_exponent().unwrap());
        let w_i = i64::exact_from(w);
        let mut err = exp_t + 2 - w_i;
        t.cos_prec_assign(w);
        let exp_t = t.get_exponent().map_or(Float::MIN_EXPONENT_I64, i64::from);
        if exp_t < 0 {
            let cancel = u64::exact_from(-exp_t);
            if cancel >= max(NEAR_ZERO_MIN_CANCEL, prec >> 4)
                && let Some(result) = trig_turns_near_zero(q, prec, rm, true)
            {
                return result;
            }
        }
        // the total error is at most 2^err + ulp(t)/2, bounded by 2^(EXP(t)-w) if err <= EXP(t)-w-1
        // and by 2^(err+1) otherwise; then normalized for can_round
        err = if err < exp_t - w_i {
            exp_t - w_i
        } else {
            err + 1
        };
        err = exp_t - err;
        if err > 0 && float_can_round(t.significand_ref().unwrap(), u64::exact_from(err), prec, rm)
        {
            return Float::from_float_prec_round(t, prec, rm);
        }
        w += increment;
        increment = w >> 1;
    }
}

impl Float {
    /// Computes $\cos(2\pi x/u)$, the cosine of a [`Rational`] measured in $u$ths of a turn,
    /// rounding the result to the specified precision and with the specified rounding mode, and
    /// returning the result as a [`Float`]. The [`Rational`] is taken by value. An [`Ordering`] is
    /// also returned, indicating whether the rounded cosine is less than, equal to, or greater than
    /// the exact cosine. Although `NaN`s are not comparable to any [`Float`], whenever this
    /// function returns a `NaN` it also returns `Equal`.
    ///
    /// See [`RoundingMode`] for a description of the possible rounding modes.
    ///
    /// $$
    /// f(x,u,p,m) = \cos(2\pi x/u)+\varepsilon.
    /// $$
    /// - If $u=0$, $\varepsilon$ may be ignored or assumed to be 0.
    /// - If $u\neq 0$ and $m$ is not `Nearest`, then $|\varepsilon| < 2^{\lfloor\log_2 |\cos(2\pi
    ///   x/u)|\rfloor-p+1}$.
    /// - If $u\neq 0$ and $m$ is `Nearest`, then $|\varepsilon| \leq 2^{\lfloor\log_2 |\cos(2\pi
    ///   x/u)|\rfloor-p}$.
    ///
    /// If the output has a precision, it is `prec`.
    ///
    /// Special cases:
    /// - $f(x,0,p,m)=\text{NaN}$
    /// - $f(0,u,p,m)=1$
    /// - If $x/u$ is a multiple of $1/2$, the result is exactly $1$ or $-1$; if it is an odd
    ///   multiple of $1/4$, the result is exactly $0.0$ (always positive, following IEEE 754-2019's
    ///   `cosPi`); and if it is an odd multiple of $1/6$ or $1/3$, the result is exactly $1/2$ or
    ///   $-1/2$.
    ///
    /// When $x/u$ in lowest terms has denominator 5, 8, 10, or 12, the result is $\pm\varphi/2$,
    /// $\pm(\varphi-1)/2$, $\pm\sqrt2/2$, or $\pm\sqrt3/2$, and is computed from a single correctly
    /// rounded constant rather than from $\pi$ and a cosine, which is far faster.
    ///
    /// Overflow and underflow:
    /// - Since $|\cos(2\pi x/u)|\leq 1$, the result never overflows.
    /// - If $0<f(x,u,p,m)<2^{-2^{30}}$, and $m$ is `Floor` or `Down`, $0.0$ is returned instead.
    /// - If $0<f(x,u,p,m)<2^{-2^{30}}$, and $m$ is `Ceiling` or `Up`, $2^{-2^{30}}$ is returned
    ///   instead.
    /// - If $0<f(x,u,p,m)\leq2^{-2^{30}-1}$, and $m$ is `Nearest`, $0.0$ is returned instead.
    /// - If $2^{-2^{30}-1}<f(x,u,p,m)<2^{-2^{30}}$, and $m$ is `Nearest`, $2^{-2^{30}}$ is returned
    ///   instead.
    /// - If $-2^{-2^{30}}<f(x,u,p,m)<0$, and $m$ is `Ceiling` or `Down`, $-0.0$ is returned
    ///   instead.
    /// - If $-2^{-2^{30}}<f(x,u,p,m)<0$, and $m$ is `Floor` or `Up`, $-2^{-2^{30}}$ is returned
    ///   instead.
    /// - If $-2^{-2^{30}-1}\leq f(x,u,p,m)<0$, and $m$ is `Nearest`, $-0.0$ is returned instead.
    /// - If $-2^{-2^{30}}<f(x,u,p,m)<-2^{-2^{30}-1}$, and $m$ is `Nearest`, $-2^{-2^{30}}$ is
    ///   returned instead.
    ///
    /// Underflow requires $x/u$ within $2^{-2^{30}}$ of an odd multiple of $1/4$ without being one,
    /// which takes a denominator of more than $2^{30}$ bits.
    ///
    /// If you know you'll be using `Nearest`, consider using
    /// [`Float::cos_with_period_rational_prec`] instead.
    ///
    /// # Worst-case complexity
    /// $T(n, m) = O(n (\log n)^3 \log\log n + (n+m) (\log (n+m))^2 \log\log (n+m))$
    ///
    /// $M(n, m) = O((n+m) \log (n+m))$
    ///
    /// where $T$ is time, $M$ is additional memory, $n$ is `prec`, and $m$ is
    /// `x.significant_bits()`: the fraction of a turn is reduced modulo 1 exactly, so only its size
    /// and the precision drive the cost, not the magnitude of $x$.
    ///
    /// # Panics
    /// Panics if `prec` is zero, or if `rm` is `Exact` but the result cannot be represented exactly
    /// with the given precision (which is the case unless $x/u$ is a multiple of $1/4$ or $1/6$, or
    /// $x$ or $u$ is zero).
    ///
    /// # Examples
    /// ```
    /// use malachite_base::num::basic::traits::One;
    /// use malachite_base::rounding_modes::RoundingMode::*;
    /// use malachite_float::Float;
    /// use malachite_q::Rational;
    /// use std::cmp::Ordering::*;
    ///
    /// let (c, o) = Float::cos_with_period_rational_prec_round(Rational::ONE, 7, 10, Floor);
    /// assert_eq!(c.to_string(), "0.62305");
    /// assert_eq!(o, Less);
    ///
    /// let (c, o) = Float::cos_with_period_rational_prec_round(Rational::ONE, 7, 10, Ceiling);
    /// assert_eq!(c.to_string(), "0.62402");
    /// assert_eq!(o, Greater);
    ///
    /// let (c, o) = Float::cos_with_period_rational_prec_round(Rational::ONE, 7, 10, Nearest);
    /// assert_eq!(c.to_string(), "0.62305");
    /// assert_eq!(o, Less);
    ///
    /// // a third of a turn is exact
    /// let (c, o) = Float::cos_with_period_rational_prec_round(
    ///     Rational::from_unsigneds(1u8, 3),
    ///     1,
    ///     10,
    ///     Exact,
    /// );
    /// assert_eq!(c.to_string(), "-0.50000");
    /// assert_eq!(o, Equal);
    /// ```
    #[inline]
    #[allow(clippy::needless_pass_by_value)]
    pub fn cos_with_period_rational_prec_round(
        x: Rational,
        u: u64,
        prec: u64,
        rm: RoundingMode,
    ) -> (Self, Ordering) {
        Self::cos_with_period_rational_prec_round_ref(&x, u, prec, rm)
    }

    /// Computes $\cos(2\pi x/u)$, the cosine of a [`Rational`] measured in $u$ths of a turn,
    /// rounding the result to the specified precision and with the specified rounding mode, and
    /// returning the result as a [`Float`]. The [`Rational`] is taken by reference. An [`Ordering`]
    /// is also returned, indicating whether the rounded cosine is less than, equal to, or greater
    /// than the exact cosine. Although `NaN`s are not comparable to any [`Float`], whenever this
    /// function returns a `NaN` it also returns `Equal`.
    ///
    /// See [`RoundingMode`] for a description of the possible rounding modes.
    ///
    /// $$
    /// f(x,u,p,m) = \cos(2\pi x/u)+\varepsilon.
    /// $$
    /// - If $u=0$, $\varepsilon$ may be ignored or assumed to be 0.
    /// - If $u\neq 0$ and $m$ is not `Nearest`, then $|\varepsilon| < 2^{\lfloor\log_2 |\cos(2\pi
    ///   x/u)|\rfloor-p+1}$.
    /// - If $u\neq 0$ and $m$ is `Nearest`, then $|\varepsilon| \leq 2^{\lfloor\log_2 |\cos(2\pi
    ///   x/u)|\rfloor-p}$.
    ///
    /// If the output has a precision, it is `prec`.
    ///
    /// Special cases:
    /// - $f(x,0,p,m)=\text{NaN}$
    /// - $f(0,u,p,m)=1$
    /// - If $x/u$ is a multiple of $1/2$, the result is exactly $1$ or $-1$; if it is an odd
    ///   multiple of $1/4$, the result is exactly $0.0$ (always positive, following IEEE 754-2019's
    ///   `cosPi`); and if it is an odd multiple of $1/6$ or $1/3$, the result is exactly $1/2$ or
    ///   $-1/2$.
    ///
    /// When $x/u$ in lowest terms has denominator 5, 8, 10, or 12, the result is $\pm\varphi/2$,
    /// $\pm(\varphi-1)/2$, $\pm\sqrt2/2$, or $\pm\sqrt3/2$, and is computed from a single correctly
    /// rounded constant rather than from $\pi$ and a cosine, which is far faster.
    ///
    /// Overflow and underflow:
    /// - Since $|\cos(2\pi x/u)|\leq 1$, the result never overflows.
    /// - If $0<f(x,u,p,m)<2^{-2^{30}}$, and $m$ is `Floor` or `Down`, $0.0$ is returned instead.
    /// - If $0<f(x,u,p,m)<2^{-2^{30}}$, and $m$ is `Ceiling` or `Up`, $2^{-2^{30}}$ is returned
    ///   instead.
    /// - If $0<f(x,u,p,m)\leq2^{-2^{30}-1}$, and $m$ is `Nearest`, $0.0$ is returned instead.
    /// - If $2^{-2^{30}-1}<f(x,u,p,m)<2^{-2^{30}}$, and $m$ is `Nearest`, $2^{-2^{30}}$ is returned
    ///   instead.
    /// - If $-2^{-2^{30}}<f(x,u,p,m)<0$, and $m$ is `Ceiling` or `Down`, $-0.0$ is returned
    ///   instead.
    /// - If $-2^{-2^{30}}<f(x,u,p,m)<0$, and $m$ is `Floor` or `Up`, $-2^{-2^{30}}$ is returned
    ///   instead.
    /// - If $-2^{-2^{30}-1}\leq f(x,u,p,m)<0$, and $m$ is `Nearest`, $-0.0$ is returned instead.
    /// - If $-2^{-2^{30}}<f(x,u,p,m)<-2^{-2^{30}-1}$, and $m$ is `Nearest`, $-2^{-2^{30}}$ is
    ///   returned instead.
    ///
    /// Underflow requires $x/u$ within $2^{-2^{30}}$ of an odd multiple of $1/4$ without being one,
    /// which takes a denominator of more than $2^{30}$ bits.
    ///
    /// If you know you'll be using `Nearest`, consider using
    /// [`Float::cos_with_period_rational_prec_ref`] instead.
    ///
    /// # Worst-case complexity
    /// $T(n, m) = O(n (\log n)^3 \log\log n + (n+m) (\log (n+m))^2 \log\log (n+m))$
    ///
    /// $M(n, m) = O((n+m) \log (n+m))$
    ///
    /// where $T$ is time, $M$ is additional memory, $n$ is `prec`, and $m$ is
    /// `x.significant_bits()`: the fraction of a turn is reduced modulo 1 exactly, so only its size
    /// and the precision drive the cost, not the magnitude of $x$.
    ///
    /// # Panics
    /// Panics if `prec` is zero, or if `rm` is `Exact` but the result cannot be represented exactly
    /// with the given precision (which is the case unless $x/u$ is a multiple of $1/4$ or $1/6$, or
    /// $x$ or $u$ is zero).
    ///
    /// # Examples
    /// ```
    /// use malachite_base::num::basic::traits::One;
    /// use malachite_base::rounding_modes::RoundingMode::*;
    /// use malachite_float::Float;
    /// use malachite_q::Rational;
    /// use std::cmp::Ordering::*;
    ///
    /// let (c, o) = Float::cos_with_period_rational_prec_round_ref(&Rational::ONE, 7, 10, Floor);
    /// assert_eq!(c.to_string(), "0.62305");
    /// assert_eq!(o, Less);
    ///
    /// let (c, o) = Float::cos_with_period_rational_prec_round_ref(&Rational::ONE, 7, 10, Ceiling);
    /// assert_eq!(c.to_string(), "0.62402");
    /// assert_eq!(o, Greater);
    ///
    /// let (c, o) = Float::cos_with_period_rational_prec_round_ref(&Rational::ONE, 7, 10, Nearest);
    /// assert_eq!(c.to_string(), "0.62305");
    /// assert_eq!(o, Less);
    ///
    /// // a third of a turn is exact
    /// let (c, o) = Float::cos_with_period_rational_prec_round_ref(
    ///     &Rational::from_unsigneds(1u8, 3),
    ///     1,
    ///     10,
    ///     Exact,
    /// );
    /// assert_eq!(c.to_string(), "-0.50000");
    /// assert_eq!(o, Equal);
    /// ```
    pub fn cos_with_period_rational_prec_round_ref(
        x: &Rational,
        u: u64,
        prec: u64,
        rm: RoundingMode,
    ) -> (Self, Ordering) {
        assert_ne!(prec, 0);
        // for u = 0, return NaN
        if u == 0 {
            return (Self::NAN, Equal);
        }
        // cos(0) = 1
        if *x == 0u32 {
            return (Self::one_prec(prec), Equal);
        }
        // q = x/u, reduced to [-1/2, 1/2]: cos(2 pi q) has period 1 in q, and an input just below a
        // multiple of the period must land near 0, not near 1, for the small-input shortcut to
        // apply (otherwise the working precision would have to grow to the whole cancellation in 1
        // - cos)
        let q = x / Rational::from(u);
        let whole = Rational::from(Integer::rounding_from(&q, Nearest).0);
        let q = q - whole;
        if q == 0u32 {
            return (Self::one_prec(prec), Equal);
        }
        cos_turns_helper(&q, prec, rm)
    }

    /// Computes $\cos(2\pi x/u)$, the cosine of a [`Rational`] measured in $u$ths of a turn,
    /// rounding the result to the nearest value of the specified precision, and returning the
    /// result as a [`Float`]. The [`Rational`] is taken by value. An [`Ordering`] is also returned,
    /// indicating whether the rounded cosine is less than, equal to, or greater than the exact
    /// cosine. Although `NaN`s are not comparable to any [`Float`], whenever this function returns
    /// a `NaN` it also returns `Equal`.
    ///
    /// If the cosine is equidistant from two [`Float`]s with the specified precision, the [`Float`]
    /// with fewer 1s in its binary expansion is chosen. See [`RoundingMode`] for a description of
    /// the `Nearest` rounding mode.
    ///
    /// $$
    /// f(x,u,p) = \cos(2\pi x/u)+\varepsilon.
    /// $$
    /// - If $u=0$, $\varepsilon$ may be ignored or assumed to be 0.
    /// - If $u\neq 0$, then $|\varepsilon| < 2^{\lfloor\log_2 |\cos(2\pi x/u)|\rfloor-p}$.
    ///
    /// If the output has a precision, it is `prec`.
    ///
    /// Special cases:
    /// - $f(x,0,p)=\text{NaN}$
    /// - $f(0,u,p)=1$
    /// - If $x/u$ is a multiple of $1/2$, the result is exactly $1$ or $-1$; if it is an odd
    ///   multiple of $1/4$, the result is exactly $0.0$ (always positive, following IEEE 754-2019's
    ///   `cosPi`); and if it is an odd multiple of $1/6$ or $1/3$, the result is exactly $1/2$ or
    ///   $-1/2$.
    ///
    /// When $x/u$ in lowest terms has denominator 5, 8, 10, or 12, the result is $\pm\varphi/2$,
    /// $\pm(\varphi-1)/2$, $\pm\sqrt2/2$, or $\pm\sqrt3/2$, and is computed from a single correctly
    /// rounded constant rather than from $\pi$ and a cosine, which is far faster.
    ///
    /// Overflow and underflow:
    /// - Since $|\cos(2\pi x/u)|\leq 1$, the result never overflows.
    /// - If $0<f(x,u,p)\leq2^{-2^{30}-1}$, $0.0$ is returned instead.
    /// - If $2^{-2^{30}-1}<f(x,u,p)<2^{-2^{30}}$, $2^{-2^{30}}$ is returned instead.
    /// - If $-2^{-2^{30}-1}\leq f(x,u,p)<0$, $-0.0$ is returned instead.
    /// - If $-2^{-2^{30}}<f(x,u,p)<-2^{-2^{30}-1}$, $-2^{-2^{30}}$ is returned instead.
    ///
    /// Underflow requires $x/u$ within $2^{-2^{30}}$ of an odd multiple of $1/4$ without being one,
    /// which takes a denominator of more than $2^{30}$ bits.
    ///
    /// If you want to use a rounding mode other than `Nearest`, consider using
    /// [`Float::cos_with_period_rational_prec_round`] instead.
    ///
    /// # Worst-case complexity
    /// $T(n, m) = O(n (\log n)^3 \log\log n + (n+m) (\log (n+m))^2 \log\log (n+m))$
    ///
    /// $M(n, m) = O((n+m) \log (n+m))$
    ///
    /// where $T$ is time, $M$ is additional memory, $n$ is `prec`, and $m$ is
    /// `x.significant_bits()`: the fraction of a turn is reduced modulo 1 exactly, so only its size
    /// and the precision drive the cost, not the magnitude of $x$.
    ///
    /// # Panics
    /// Panics if `prec` is zero.
    ///
    /// # Examples
    /// ```
    /// use malachite_base::num::basic::traits::One;
    /// use malachite_float::Float;
    /// use malachite_q::Rational;
    /// use std::cmp::Ordering::*;
    ///
    /// let (c, o) = Float::cos_with_period_rational_prec(Rational::ONE, 7, 10);
    /// assert_eq!(c.to_string(), "0.62305");
    /// assert_eq!(o, Less);
    ///
    /// let (c, o) = Float::cos_with_period_rational_prec(Rational::ONE, 7, 53);
    /// assert_eq!(c.to_string(), "0.62348980185873348");
    /// assert_eq!(o, Less);
    ///
    /// // an eighth of a turn: sqrt(2)/2
    /// let (c, o) = Float::cos_with_period_rational_prec(Rational::from_unsigneds(1u8, 8), 1, 53);
    /// assert_eq!(c.to_string(), "0.70710678118654757");
    /// assert_eq!(o, Greater);
    /// ```
    #[inline]
    #[allow(clippy::needless_pass_by_value)]
    pub fn cos_with_period_rational_prec(x: Rational, u: u64, prec: u64) -> (Self, Ordering) {
        Self::cos_with_period_rational_prec_round_ref(&x, u, prec, Nearest)
    }

    /// Computes $\cos(2\pi x/u)$, the cosine of a [`Rational`] measured in $u$ths of a turn,
    /// rounding the result to the nearest value of the specified precision, and returning the
    /// result as a [`Float`]. The [`Rational`] is taken by reference. An [`Ordering`] is also
    /// returned, indicating whether the rounded cosine is less than, equal to, or greater than the
    /// exact cosine. Although `NaN`s are not comparable to any [`Float`], whenever this function
    /// returns a `NaN` it also returns `Equal`.
    ///
    /// If the cosine is equidistant from two [`Float`]s with the specified precision, the [`Float`]
    /// with fewer 1s in its binary expansion is chosen. See [`RoundingMode`] for a description of
    /// the `Nearest` rounding mode.
    ///
    /// $$
    /// f(x,u,p) = \cos(2\pi x/u)+\varepsilon.
    /// $$
    /// - If $u=0$, $\varepsilon$ may be ignored or assumed to be 0.
    /// - If $u\neq 0$, then $|\varepsilon| < 2^{\lfloor\log_2 |\cos(2\pi x/u)|\rfloor-p}$.
    ///
    /// If the output has a precision, it is `prec`.
    ///
    /// Special cases:
    /// - $f(x,0,p)=\text{NaN}$
    /// - $f(0,u,p)=1$
    /// - If $x/u$ is a multiple of $1/2$, the result is exactly $1$ or $-1$; if it is an odd
    ///   multiple of $1/4$, the result is exactly $0.0$ (always positive, following IEEE 754-2019's
    ///   `cosPi`); and if it is an odd multiple of $1/6$ or $1/3$, the result is exactly $1/2$ or
    ///   $-1/2$.
    ///
    /// When $x/u$ in lowest terms has denominator 5, 8, 10, or 12, the result is $\pm\varphi/2$,
    /// $\pm(\varphi-1)/2$, $\pm\sqrt2/2$, or $\pm\sqrt3/2$, and is computed from a single correctly
    /// rounded constant rather than from $\pi$ and a cosine, which is far faster.
    ///
    /// Overflow and underflow:
    /// - Since $|\cos(2\pi x/u)|\leq 1$, the result never overflows.
    /// - If $0<f(x,u,p)\leq2^{-2^{30}-1}$, $0.0$ is returned instead.
    /// - If $2^{-2^{30}-1}<f(x,u,p)<2^{-2^{30}}$, $2^{-2^{30}}$ is returned instead.
    /// - If $-2^{-2^{30}-1}\leq f(x,u,p)<0$, $-0.0$ is returned instead.
    /// - If $-2^{-2^{30}}<f(x,u,p)<-2^{-2^{30}-1}$, $-2^{-2^{30}}$ is returned instead.
    ///
    /// Underflow requires $x/u$ within $2^{-2^{30}}$ of an odd multiple of $1/4$ without being one,
    /// which takes a denominator of more than $2^{30}$ bits.
    ///
    /// If you want to use a rounding mode other than `Nearest`, consider using
    /// [`Float::cos_with_period_rational_prec_round_ref`] instead.
    ///
    /// # Worst-case complexity
    /// $T(n, m) = O(n (\log n)^3 \log\log n + (n+m) (\log (n+m))^2 \log\log (n+m))$
    ///
    /// $M(n, m) = O((n+m) \log (n+m))$
    ///
    /// where $T$ is time, $M$ is additional memory, $n$ is `prec`, and $m$ is
    /// `x.significant_bits()`: the fraction of a turn is reduced modulo 1 exactly, so only its size
    /// and the precision drive the cost, not the magnitude of $x$.
    ///
    /// # Panics
    /// Panics if `prec` is zero.
    ///
    /// # Examples
    /// ```
    /// use malachite_base::num::basic::traits::One;
    /// use malachite_float::Float;
    /// use malachite_q::Rational;
    /// use std::cmp::Ordering::*;
    ///
    /// let (c, o) = Float::cos_with_period_rational_prec_ref(&Rational::ONE, 7, 10);
    /// assert_eq!(c.to_string(), "0.62305");
    /// assert_eq!(o, Less);
    ///
    /// let (c, o) = Float::cos_with_period_rational_prec_ref(&Rational::ONE, 7, 53);
    /// assert_eq!(c.to_string(), "0.62348980185873348");
    /// assert_eq!(o, Less);
    ///
    /// // an eighth of a turn: sqrt(2)/2
    /// let (c, o) =
    ///     Float::cos_with_period_rational_prec_ref(&Rational::from_unsigneds(1u8, 8), 1, 53);
    /// assert_eq!(c.to_string(), "0.70710678118654757");
    /// assert_eq!(o, Greater);
    /// ```
    #[inline]
    pub fn cos_with_period_rational_prec_ref(x: &Rational, u: u64, prec: u64) -> (Self, Ordering) {
        Self::cos_with_period_rational_prec_round_ref(x, u, prec, Nearest)
    }
}

impl Float {
    /// Computes $\cos(\pi x)$, the cosine of a [`Float`] measured in half-turns, rounding the
    /// result to the specified precision and with the specified rounding mode. The [`Float`] is
    /// taken by value. An [`Ordering`] is also returned, indicating whether the rounded cosine is
    /// less than, equal to, or greater than the exact cosine. Although `NaN`s are not comparable to
    /// any [`Float`], whenever this function returns a `NaN` it also returns `Equal`.
    ///
    /// This is `cos_with_period` with a period of 2: see [`Float::cos_with_period_prec_round`] for
    /// the error bounds, the special and closed-form cases (integers give $\pm1$, half-integers
    /// give $+0.0$, and multiples of $1/3$, $1/4$, $1/5$, $1/6$, and $1/10$ have closed forms),
    /// overflow and underflow, and the complexity, with $u = 2$.
    ///
    /// # Panics
    /// Panics if `prec` is zero, or if `rm` is `Exact` but the result cannot be represented exactly
    /// with the given precision.
    ///
    /// # Examples
    /// ```
    /// use malachite_base::num::basic::traits::One;
    /// use malachite_base::rounding_modes::RoundingMode::*;
    /// use malachite_float::Float;
    /// use std::cmp::Ordering::*;
    ///
    /// let (c, o) = Float::from(0.1f64).cos_pi_prec_round(10, Floor);
    /// assert_eq!(c.to_string(), "0.95020");
    /// assert_eq!(o, Less);
    ///
    /// let (c, o) = Float::from(0.1f64).cos_pi_prec_round(10, Ceiling);
    /// assert_eq!(c.to_string(), "0.95117");
    /// assert_eq!(o, Greater);
    ///
    /// // a half-turn is exactly -1
    /// let (c, o) = Float::ONE.cos_pi_prec_round(10, Exact);
    /// assert_eq!(c.to_string(), "-1.0000");
    /// assert_eq!(o, Equal);
    /// ```
    #[inline]
    pub fn cos_pi_prec_round(self, prec: u64, rm: RoundingMode) -> (Self, Ordering) {
        self.cos_with_period_prec_round(2, prec, rm)
    }

    /// Computes $\cos(\pi x)$, the cosine of a [`Float`] measured in half-turns, rounding the
    /// result to the specified precision and with the specified rounding mode. The [`Float`] is
    /// taken by reference. An [`Ordering`] is also returned, indicating whether the rounded cosine
    /// is less than, equal to, or greater than the exact cosine. Although `NaN`s are not comparable
    /// to any [`Float`], whenever this function returns a `NaN` it also returns `Equal`.
    ///
    /// This is `cos_with_period` with a period of 2: see [`Float::cos_with_period_prec_round_ref`]
    /// for the error bounds, the special and closed-form cases (integers give $\pm1$, half-integers
    /// give $+0.0$, and multiples of $1/3$, $1/4$, $1/5$, $1/6$, and $1/10$ have closed forms),
    /// overflow and underflow, and the complexity, with $u = 2$.
    ///
    /// # Panics
    /// Panics if `prec` is zero, or if `rm` is `Exact` but the result cannot be represented exactly
    /// with the given precision.
    ///
    /// # Examples
    /// ```
    /// use malachite_base::num::basic::traits::One;
    /// use malachite_base::rounding_modes::RoundingMode::*;
    /// use malachite_float::Float;
    /// use std::cmp::Ordering::*;
    ///
    /// let (c, o) = (Float::from(0.1f64)).cos_pi_prec_round_ref(10, Floor);
    /// assert_eq!(c.to_string(), "0.95020");
    /// assert_eq!(o, Less);
    ///
    /// let (c, o) = (Float::from(0.1f64)).cos_pi_prec_round_ref(10, Ceiling);
    /// assert_eq!(c.to_string(), "0.95117");
    /// assert_eq!(o, Greater);
    ///
    /// // a half-turn is exactly -1
    /// let (c, o) = (&Float::ONE).cos_pi_prec_round_ref(10, Exact);
    /// assert_eq!(c.to_string(), "-1.0000");
    /// assert_eq!(o, Equal);
    /// ```
    #[inline]
    pub fn cos_pi_prec_round_ref(&self, prec: u64, rm: RoundingMode) -> (Self, Ordering) {
        self.cos_with_period_prec_round_ref(2, prec, rm)
    }

    /// Computes $\cos(\pi x)$, the cosine of a [`Float`] measured in half-turns, rounding the
    /// result to the nearest value of the specified precision. The [`Float`] is taken by value. An
    /// [`Ordering`] is also returned, indicating whether the rounded cosine is less than, equal to,
    /// or greater than the exact cosine. Although `NaN`s are not comparable to any [`Float`],
    /// whenever this function returns a `NaN` it also returns `Equal`.
    ///
    /// This is `cos_with_period` with a period of 2: see [`Float::cos_with_period_prec`] for the
    /// error bounds, the special and closed-form cases (integers give $\pm1$, half-integers give
    /// $+0.0$, and multiples of $1/3$, $1/4$, $1/5$, $1/6$, and $1/10$ have closed forms), overflow
    /// and underflow, and the complexity, with $u = 2$.
    ///
    /// # Panics
    /// Panics if `prec` is zero.
    ///
    /// # Examples
    /// ```
    /// use malachite_float::Float;
    /// use std::cmp::Ordering::*;
    ///
    /// let (c, o) = Float::from(0.1f64).cos_pi_prec(10);
    /// assert_eq!(c.to_string(), "0.95117");
    /// assert_eq!(o, Greater);
    ///
    /// let (c, o) = Float::from(0.1f64).cos_pi_prec(53);
    /// assert_eq!(c.to_string(), "0.95105651629515353");
    /// assert_eq!(o, Less);
    /// ```
    #[inline]
    pub fn cos_pi_prec(self, prec: u64) -> (Self, Ordering) {
        self.cos_with_period_prec(2, prec)
    }

    /// Computes $\cos(\pi x)$, the cosine of a [`Float`] measured in half-turns, rounding the
    /// result to the nearest value of the specified precision. The [`Float`] is taken by reference.
    /// An [`Ordering`] is also returned, indicating whether the rounded cosine is less than, equal
    /// to, or greater than the exact cosine. Although `NaN`s are not comparable to any [`Float`],
    /// whenever this function returns a `NaN` it also returns `Equal`.
    ///
    /// This is `cos_with_period` with a period of 2: see [`Float::cos_with_period_prec_ref`] for
    /// the error bounds, the special and closed-form cases (integers give $\pm1$, half-integers
    /// give $+0.0$, and multiples of $1/3$, $1/4$, $1/5$, $1/6$, and $1/10$ have closed forms),
    /// overflow and underflow, and the complexity, with $u = 2$.
    ///
    /// # Panics
    /// Panics if `prec` is zero.
    ///
    /// # Examples
    /// ```
    /// use malachite_float::Float;
    /// use std::cmp::Ordering::*;
    ///
    /// let (c, o) = (Float::from(0.1f64)).cos_pi_prec_ref(10);
    /// assert_eq!(c.to_string(), "0.95117");
    /// assert_eq!(o, Greater);
    ///
    /// let (c, o) = (Float::from(0.1f64)).cos_pi_prec_ref(53);
    /// assert_eq!(c.to_string(), "0.95105651629515353");
    /// assert_eq!(o, Less);
    /// ```
    #[inline]
    pub fn cos_pi_prec_ref(&self, prec: u64) -> (Self, Ordering) {
        self.cos_with_period_prec_ref(2, prec)
    }

    /// Computes $\cos(\pi x)$, the cosine of a [`Float`] measured in half-turns, rounding the
    /// result with the specified rounding mode. The precision of the output is the precision of the
    /// input. The [`Float`] is taken by value. An [`Ordering`] is also returned, indicating whether
    /// the rounded cosine is less than, equal to, or greater than the exact cosine. Although `NaN`s
    /// are not comparable to any [`Float`], whenever this function returns a `NaN` it also returns
    /// `Equal`.
    ///
    /// This is `cos_with_period` with a period of 2: see [`Float::cos_with_period_round`] for the
    /// error bounds, the special and closed-form cases (integers give $\pm1$, half-integers give
    /// $+0.0$, and multiples of $1/3$, $1/4$, $1/5$, $1/6$, and $1/10$ have closed forms), overflow
    /// and underflow, and the complexity, with $u = 2$.
    ///
    /// # Panics
    /// Panics if `rm` is `Exact` but the result cannot be represented exactly with the input
    /// precision.
    ///
    /// # Examples
    /// ```
    /// use malachite_base::rounding_modes::RoundingMode::*;
    /// use malachite_float::Float;
    /// use std::cmp::Ordering::*;
    ///
    /// let (c, o) = Float::from(0.1f64).cos_pi_round(Floor);
    /// assert_eq!(c.to_string(), "0.95105651629515342");
    /// assert_eq!(o, Less);
    ///
    /// let (c, o) = Float::from(0.1f64).cos_pi_round(Nearest);
    /// assert_eq!(c.to_string(), "0.95105651629515364");
    /// assert_eq!(o, Greater);
    /// ```
    #[inline]
    pub fn cos_pi_round(self, rm: RoundingMode) -> (Self, Ordering) {
        self.cos_with_period_round(2, rm)
    }

    /// Computes $\cos(\pi x)$, the cosine of a [`Float`] measured in half-turns, rounding the
    /// result with the specified rounding mode. The precision of the output is the precision of the
    /// input. The [`Float`] is taken by reference. An [`Ordering`] is also returned, indicating
    /// whether the rounded cosine is less than, equal to, or greater than the exact cosine.
    /// Although `NaN`s are not comparable to any [`Float`], whenever this function returns a `NaN`
    /// it also returns `Equal`.
    ///
    /// This is `cos_with_period` with a period of 2: see [`Float::cos_with_period_round_ref`] for
    /// the error bounds, the special and closed-form cases (integers give $\pm1$, half-integers
    /// give $+0.0$, and multiples of $1/3$, $1/4$, $1/5$, $1/6$, and $1/10$ have closed forms),
    /// overflow and underflow, and the complexity, with $u = 2$.
    ///
    /// # Panics
    /// Panics if `rm` is `Exact` but the result cannot be represented exactly with the input
    /// precision.
    ///
    /// # Examples
    /// ```
    /// use malachite_base::rounding_modes::RoundingMode::*;
    /// use malachite_float::Float;
    /// use std::cmp::Ordering::*;
    ///
    /// let (c, o) = (Float::from(0.1f64)).cos_pi_round_ref(Floor);
    /// assert_eq!(c.to_string(), "0.95105651629515342");
    /// assert_eq!(o, Less);
    ///
    /// let (c, o) = (Float::from(0.1f64)).cos_pi_round_ref(Nearest);
    /// assert_eq!(c.to_string(), "0.95105651629515364");
    /// assert_eq!(o, Greater);
    /// ```
    #[inline]
    pub fn cos_pi_round_ref(&self, rm: RoundingMode) -> (Self, Ordering) {
        self.cos_with_period_round_ref(2, rm)
    }

    /// Computes $\cos(\pi x)$, the cosine of a [`Float`] measured in half-turns, rounding the
    /// result to the precision of the input and to the nearest [`Float`]. The [`Float`] is taken by
    /// value.
    ///
    /// If the cosine is equidistant from two [`Float`]s with the precision of the input, the
    /// [`Float`] with fewer 1s in its binary expansion is chosen. See [`RoundingMode`] for a
    /// description of the `Nearest` rounding mode.
    ///
    /// This is `cos_with_period` with a period of 2: see [`Float::cos_with_period`] for the error
    /// bounds, the special and closed-form cases (integers give $\pm1$, half-integers give $+0.0$,
    /// and multiples of $1/3$, $1/4$, $1/5$, $1/6$, and $1/10$ have closed forms), overflow and
    /// underflow, and the complexity, with $u = 2$.
    ///
    /// If you want to use a rounding mode other than `Nearest`, consider using
    /// [`Float::cos_pi_round`] instead. If you want to specify an output precision, consider using
    /// [`Float::cos_pi_prec`]. If you want both of these things, consider using
    /// [`Float::cos_pi_prec_round`].
    ///
    /// # Examples
    /// ```
    /// use malachite_float::Float;
    ///
    /// let c = Float::from(0.1f64).cos_pi();
    /// assert_eq!(c.to_string(), "0.95105651629515364");
    ///
    /// // an integer is exactly 1 or -1
    /// assert_eq!(Float::from(3u32).cos_pi().to_string(), "-1.0");
    /// ```
    #[inline]
    pub fn cos_pi(self) -> Self {
        let prec = self.significant_bits();
        self.cos_pi_prec(prec).0
    }

    /// Computes $\cos(\pi x)$, the cosine of a [`Float`] measured in half-turns, rounding the
    /// result to the precision of the input and to the nearest [`Float`]. The [`Float`] is taken by
    /// reference.
    ///
    /// If the cosine is equidistant from two [`Float`]s with the precision of the input, the
    /// [`Float`] with fewer 1s in its binary expansion is chosen. See [`RoundingMode`] for a
    /// description of the `Nearest` rounding mode.
    ///
    /// This is `cos_with_period` with a period of 2: see [`Float::cos_with_period`] for the error
    /// bounds, the special and closed-form cases (integers give $\pm1$, half-integers give $+0.0$,
    /// and multiples of $1/3$, $1/4$, $1/5$, $1/6$, and $1/10$ have closed forms), overflow and
    /// underflow, and the complexity, with $u = 2$.
    ///
    /// If you want to use a rounding mode other than `Nearest`, consider using
    /// [`Float::cos_pi_round_ref`] instead. If you want to specify an output precision, consider
    /// using [`Float::cos_pi_prec_ref`]. If you want both of these things, consider using
    /// [`Float::cos_pi_prec_round_ref`].
    ///
    /// # Examples
    /// ```
    /// use malachite_float::Float;
    ///
    /// let c = (&Float::from(0.1f64)).cos_pi_ref();
    /// assert_eq!(c.to_string(), "0.95105651629515364");
    /// ```
    #[inline]
    pub fn cos_pi_ref(&self) -> Self {
        self.cos_pi_prec_ref(self.significant_bits()).0
    }

    /// Computes $\cos(\pi x)$, the cosine of a [`Float`] measured in half-turns, rounding the
    /// result to the specified precision and with the specified rounding mode. The [`Float`] is
    /// replaced by the result, and an [`Ordering`] is returned, indicating whether the rounded
    /// cosine is less than, equal to, or greater than the exact cosine. Although `NaN`s are not
    /// comparable to any [`Float`], whenever this function sets a `NaN` it also returns `Equal`.
    ///
    /// This is `cos_with_period` with a period of 2: see
    /// [`Float::cos_with_period_prec_round_assign`] for the error bounds, the special and
    /// closed-form cases (integers give $\pm1$, half-integers give $+0.0$, and multiples of $1/3$,
    /// $1/4$, $1/5$, $1/6$, and $1/10$ have closed forms), overflow and underflow, and the
    /// complexity, with $u = 2$.
    ///
    /// # Panics
    /// Panics if `prec` is zero, or if `rm` is `Exact` but the result cannot be represented exactly
    /// with the given precision.
    ///
    /// # Examples
    /// ```
    /// use malachite_base::rounding_modes::RoundingMode::*;
    /// use malachite_float::Float;
    /// use std::cmp::Ordering::*;
    ///
    /// let mut x = Float::from(0.1f64);
    /// assert_eq!(x.cos_pi_prec_round_assign(10, Floor), Less);
    /// assert_eq!(x.to_string(), "0.95020");
    ///
    /// let mut x = Float::from(0.1f64);
    /// assert_eq!(x.cos_pi_prec_round_assign(10, Ceiling), Greater);
    /// assert_eq!(x.to_string(), "0.95117");
    /// ```
    #[inline]
    pub fn cos_pi_prec_round_assign(&mut self, prec: u64, rm: RoundingMode) -> Ordering {
        self.cos_with_period_prec_round_assign(2, prec, rm)
    }

    /// Computes $\cos(\pi x)$, the cosine of a [`Float`] measured in half-turns, rounding the
    /// result to the nearest value of the specified precision. The [`Float`] is replaced by the
    /// result, and an [`Ordering`] is returned, indicating whether the rounded cosine is less than,
    /// equal to, or greater than the exact cosine. Although `NaN`s are not comparable to any
    /// [`Float`], whenever this function sets a `NaN` it also returns `Equal`.
    ///
    /// This is `cos_with_period` with a period of 2: see [`Float::cos_with_period_prec_assign`] for
    /// the error bounds, the special and closed-form cases (integers give $\pm1$, half-integers
    /// give $+0.0$, and multiples of $1/3$, $1/4$, $1/5$, $1/6$, and $1/10$ have closed forms),
    /// overflow and underflow, and the complexity, with $u = 2$.
    ///
    /// # Panics
    /// Panics if `prec` is zero.
    ///
    /// # Examples
    /// ```
    /// use malachite_float::Float;
    /// use std::cmp::Ordering::*;
    ///
    /// let mut x = Float::from(0.1f64);
    /// assert_eq!(x.cos_pi_prec_assign(10), Greater);
    /// assert_eq!(x.to_string(), "0.95117");
    /// ```
    #[inline]
    pub fn cos_pi_prec_assign(&mut self, prec: u64) -> Ordering {
        self.cos_with_period_prec_assign(2, prec)
    }

    /// Computes $\cos(\pi x)$, the cosine of a [`Float`] measured in half-turns, rounding the
    /// result with the specified rounding mode. The precision of the output is the precision of the
    /// input. The [`Float`] is replaced by the result, and an [`Ordering`] is returned, indicating
    /// whether the rounded cosine is less than, equal to, or greater than the exact cosine.
    /// Although `NaN`s are not comparable to any [`Float`], whenever this function sets a `NaN` it
    /// also returns `Equal`.
    ///
    /// This is `cos_with_period` with a period of 2: see [`Float::cos_with_period_round_assign`]
    /// for the error bounds, the special and closed-form cases (integers give $\pm1$, half-integers
    /// give $+0.0$, and multiples of $1/3$, $1/4$, $1/5$, $1/6$, and $1/10$ have closed forms),
    /// overflow and underflow, and the complexity, with $u = 2$.
    ///
    /// # Panics
    /// Panics if `rm` is `Exact` but the result cannot be represented exactly with the input
    /// precision.
    ///
    /// # Examples
    /// ```
    /// use malachite_base::rounding_modes::RoundingMode::*;
    /// use malachite_float::Float;
    /// use std::cmp::Ordering::*;
    ///
    /// let mut x = Float::from(0.1f64);
    /// assert_eq!(x.cos_pi_round_assign(Floor), Less);
    /// assert_eq!(x.to_string(), "0.95105651629515342");
    /// ```
    #[inline]
    pub fn cos_pi_round_assign(&mut self, rm: RoundingMode) -> Ordering {
        self.cos_with_period_round_assign(2, rm)
    }

    /// Computes $\cos(\pi x)$, the cosine of a [`Float`] measured in half-turns, rounding the
    /// result to the precision of the input and to the nearest [`Float`]. The [`Float`] is replaced
    /// by the result.
    ///
    /// If the cosine is equidistant from two [`Float`]s with the precision of the input, the
    /// [`Float`] with fewer 1s in its binary expansion is chosen. See [`RoundingMode`] for a
    /// description of the `Nearest` rounding mode.
    ///
    /// This is `cos_with_period` with a period of 2: see [`Float::cos_with_period`] for the error
    /// bounds, the special and closed-form cases (integers give $\pm1$, half-integers give $+0.0$,
    /// and multiples of $1/3$, $1/4$, $1/5$, $1/6$, and $1/10$ have closed forms), overflow and
    /// underflow, and the complexity, with $u = 2$.
    ///
    /// If you want to use a rounding mode other than `Nearest`, consider using
    /// [`Float::cos_pi_round_assign`] instead. If you want to specify an output precision, consider
    /// using [`Float::cos_pi_prec_assign`]. If you want both of these things, consider using
    /// [`Float::cos_pi_prec_round_assign`].
    ///
    /// # Examples
    /// ```
    /// use malachite_float::Float;
    ///
    /// let mut x = Float::from(0.1f64);
    /// x.cos_pi_assign();
    /// assert_eq!(x.to_string(), "0.95105651629515364");
    /// ```
    #[inline]
    pub fn cos_pi_assign(&mut self) {
        let prec = self.significant_bits();
        self.cos_pi_prec_assign(prec);
    }

    /// Computes $\cos(\pi x)$, the cosine of a [`Rational`] measured in half-turns, rounding the
    /// result to the specified precision and with the specified rounding mode and returning the
    /// result as a [`Float`]. The [`Rational`] is taken by value. An [`Ordering`] is also returned,
    /// indicating whether the rounded cosine is less than, equal to, or greater than the exact
    /// cosine.
    ///
    /// This is `cos_with_period_rational` with a period of 2: see
    /// [`Float::cos_with_period_rational_prec_round`] for the error bounds, the special and
    /// closed-form cases, overflow and underflow, and the complexity, with $u = 2$.
    ///
    /// # Panics
    /// Panics if `prec` is zero, or if `rm` is `Exact` but the result cannot be represented exactly
    /// with the given precision.
    ///
    /// # Examples
    /// ```
    /// use malachite_base::rounding_modes::RoundingMode::*;
    /// use malachite_float::Float;
    /// use malachite_q::Rational;
    /// use std::cmp::Ordering::*;
    ///
    /// let (c, o) = Float::cos_pi_rational_prec_round(Rational::from_unsigneds(1u8, 7), 10, Floor);
    /// assert_eq!(c.to_string(), "0.90039");
    /// assert_eq!(o, Less);
    ///
    /// // a third of a half-turn is exactly 1/2
    /// let (c, o) = Float::cos_pi_rational_prec_round(Rational::from_unsigneds(1u8, 3), 10, Exact);
    /// assert_eq!(c.to_string(), "0.50000");
    /// assert_eq!(o, Equal);
    /// ```
    #[inline]
    #[allow(clippy::needless_pass_by_value)]
    pub fn cos_pi_rational_prec_round(
        x: Rational,
        prec: u64,
        rm: RoundingMode,
    ) -> (Self, Ordering) {
        Self::cos_with_period_rational_prec_round_ref(&x, 2, prec, rm)
    }

    /// Computes $\cos(\pi x)$, the cosine of a [`Rational`] measured in half-turns, rounding the
    /// result to the specified precision and with the specified rounding mode and returning the
    /// result as a [`Float`]. The [`Rational`] is taken by reference. An [`Ordering`] is also
    /// returned, indicating whether the rounded cosine is less than, equal to, or greater than the
    /// exact cosine.
    ///
    /// This is `cos_with_period_rational` with a period of 2: see
    /// [`Float::cos_with_period_rational_prec_round_ref`] for the error bounds, the special and
    /// closed-form cases, overflow and underflow, and the complexity, with $u = 2$.
    ///
    /// # Panics
    /// Panics if `prec` is zero, or if `rm` is `Exact` but the result cannot be represented exactly
    /// with the given precision.
    ///
    /// # Examples
    /// ```
    /// use malachite_base::rounding_modes::RoundingMode::*;
    /// use malachite_float::Float;
    /// use malachite_q::Rational;
    /// use std::cmp::Ordering::*;
    ///
    /// let (c, o) =
    ///     Float::cos_pi_rational_prec_round_ref(&Rational::from_unsigneds(1u8, 7), 10, Ceiling);
    /// assert_eq!(c.to_string(), "0.90137");
    /// assert_eq!(o, Greater);
    /// ```
    #[inline]
    pub fn cos_pi_rational_prec_round_ref(
        x: &Rational,
        prec: u64,
        rm: RoundingMode,
    ) -> (Self, Ordering) {
        Self::cos_with_period_rational_prec_round_ref(x, 2, prec, rm)
    }

    /// Computes $\cos(\pi x)$, the cosine of a [`Rational`] measured in half-turns, rounding the
    /// result to the nearest value of the specified precision and returning the result as a
    /// [`Float`]. The [`Rational`] is taken by value. An [`Ordering`] is also returned, indicating
    /// whether the rounded cosine is less than, equal to, or greater than the exact cosine.
    ///
    /// This is `cos_with_period_rational` with a period of 2: see
    /// [`Float::cos_with_period_rational_prec`] for the error bounds, the special and closed-form
    /// cases, overflow and underflow, and the complexity, with $u = 2$.
    ///
    /// # Panics
    /// Panics if `prec` is zero.
    ///
    /// # Examples
    /// ```
    /// use malachite_float::Float;
    /// use malachite_q::Rational;
    /// use std::cmp::Ordering::*;
    ///
    /// let (c, o) = Float::cos_pi_rational_prec(Rational::from_unsigneds(1u8, 7), 53);
    /// assert_eq!(c.to_string(), "0.90096886790241915");
    /// assert_eq!(o, Greater);
    /// ```
    #[inline]
    #[allow(clippy::needless_pass_by_value)]
    pub fn cos_pi_rational_prec(x: Rational, prec: u64) -> (Self, Ordering) {
        Self::cos_with_period_rational_prec_ref(&x, 2, prec)
    }

    /// Computes $\cos(\pi x)$, the cosine of a [`Rational`] measured in half-turns, rounding the
    /// result to the nearest value of the specified precision and returning the result as a
    /// [`Float`]. The [`Rational`] is taken by reference. An [`Ordering`] is also returned,
    /// indicating whether the rounded cosine is less than, equal to, or greater than the exact
    /// cosine.
    ///
    /// This is `cos_with_period_rational` with a period of 2: see
    /// [`Float::cos_with_period_rational_prec_ref`] for the error bounds, the special and
    /// closed-form cases, overflow and underflow, and the complexity, with $u = 2$.
    ///
    /// # Panics
    /// Panics if `prec` is zero.
    ///
    /// # Examples
    /// ```
    /// use malachite_float::Float;
    /// use malachite_q::Rational;
    /// use std::cmp::Ordering::*;
    ///
    /// let (c, o) = Float::cos_pi_rational_prec_ref(&Rational::from_unsigneds(1u8, 7), 53);
    /// assert_eq!(c.to_string(), "0.90096886790241915");
    /// assert_eq!(o, Greater);
    /// ```
    #[inline]
    pub fn cos_pi_rational_prec_ref(x: &Rational, prec: u64) -> (Self, Ordering) {
        Self::cos_with_period_rational_prec_ref(x, 2, prec)
    }
}

impl Cos for Float {
    type Output = Self;

    /// Computes $\cos x$, the cosine of a [`Float`], taking it by value.
    ///
    /// If the output has a precision, it is the precision of the input. If the cosine is
    /// equidistant from two [`Float`]s with the specified precision, the [`Float`] with fewer 1s in
    /// its binary expansion is chosen. See [`RoundingMode`] for a description of the `Nearest`
    /// rounding mode.
    ///
    /// $$
    /// f(x) = \cos x+\varepsilon.
    /// $$
    /// - If $x$ is not finite, $\varepsilon$ may be ignored or assumed to be 0.
    /// - If $x$ is finite, then $|\varepsilon| < 2^{\lfloor\log_2 |\cos x|\rfloor-p}$, where $p$ is
    ///   the precision of the input.
    ///
    /// Special cases:
    /// - $f(\text{NaN})=\text{NaN}$
    /// - $f(\pm\infty)=\text{NaN}$
    /// - $f(\pm0.0)=1.0$
    ///
    /// See the [`Float::cos_round`] documentation for information on overflow and underflow.
    ///
    /// If you want to use a rounding mode other than `Nearest`, consider using [`Float::cos_round`]
    /// instead. If you want to specify the output precision, consider using [`Float::cos_prec`]. If
    /// you want both of these things, consider using [`Float::cos_prec_round`].
    ///
    /// # Worst-case complexity
    /// $T(n, e) = O(n (\log n)^3 \log\log n + (n+e) (\log (n+e))^2 \log\log (n+e))$
    ///
    /// $M(n, e) = O((n+e) \log (n+e))$
    ///
    /// where $T$ is time, $M$ is additional memory, $n$ is `self.significant_bits()`, and $e$ is
    /// the exponent of `self` (0 if `self` has no exponent or a negative one): the Taylor series at
    /// working precision $n$, summed by binary splitting for large $n$, costs the first term, and
    /// for $|x| \geq 4$ the argument is reduced modulo $2\pi$, which requires $\pi$ to about $n +
    /// e$ bits. Unlike most functions, `cos` therefore gets slower as the magnitude of its input
    /// grows, not just as the precision does.
    ///
    /// # Examples
    /// ```
    /// use malachite_base::num::arithmetic::traits::Cos;
    /// use malachite_base::num::basic::traits::{Infinity, NaN, NegativeInfinity, One, Zero};
    /// use malachite_float::Float;
    ///
    /// assert!(Float::NAN.cos().is_nan());
    /// assert!(Float::INFINITY.cos().is_nan());
    /// assert!(Float::NEGATIVE_INFINITY.cos().is_nan());
    /// assert_eq!(Float::ZERO.cos(), Float::ONE);
    /// assert_eq!(
    ///     Float::from_unsigned_prec(1u32, 100).0.cos().to_string(),
    ///     "0.54030230586813971740093660744335"
    /// );
    /// assert_eq!(
    ///     Float::from_unsigned_prec(100u32, 100).0.cos().to_string(),
    ///     "0.86231887228768393410193851395099"
    /// );
    /// ```
    #[inline]
    fn cos(self) -> Self {
        let prec = self.significant_bits();
        self.cos_prec_round(prec, Nearest).0
    }
}

impl Cos for &Float {
    type Output = Float;

    /// Computes $\cos x$, the cosine of a [`Float`], taking it by reference.
    ///
    /// If the output has a precision, it is the precision of the input. If the cosine is
    /// equidistant from two [`Float`]s with the specified precision, the [`Float`] with fewer 1s in
    /// its binary expansion is chosen. See [`RoundingMode`] for a description of the `Nearest`
    /// rounding mode.
    ///
    /// $$
    /// f(x) = \cos x+\varepsilon.
    /// $$
    /// - If $x$ is not finite, $\varepsilon$ may be ignored or assumed to be 0.
    /// - If $x$ is finite, then $|\varepsilon| < 2^{\lfloor\log_2 |\cos x|\rfloor-p}$, where $p$ is
    ///   the precision of the input.
    ///
    /// Special cases:
    /// - $f(\text{NaN})=\text{NaN}$
    /// - $f(\pm\infty)=\text{NaN}$
    /// - $f(\pm0.0)=1.0$
    ///
    /// See the [`Float::cos_round`] documentation for information on overflow and underflow.
    ///
    /// If you want to use a rounding mode other than `Nearest`, consider using
    /// [`Float::cos_round_ref`] instead. If you want to specify the output precision, consider
    /// using [`Float::cos_prec_ref`]. If you want both of these things, consider using
    /// [`Float::cos_prec_round_ref`].
    ///
    /// # Worst-case complexity
    /// $T(n, e) = O(n (\log n)^3 \log\log n + (n+e) (\log (n+e))^2 \log\log (n+e))$
    ///
    /// $M(n, e) = O((n+e) \log (n+e))$
    ///
    /// where $T$ is time, $M$ is additional memory, $n$ is `self.significant_bits()`, and $e$ is
    /// the exponent of `self` (0 if `self` has no exponent or a negative one): the Taylor series at
    /// working precision $n$, summed by binary splitting for large $n$, costs the first term, and
    /// for $|x| \geq 4$ the argument is reduced modulo $2\pi$, which requires $\pi$ to about $n +
    /// e$ bits. Unlike most functions, `cos` therefore gets slower as the magnitude of its input
    /// grows, not just as the precision does.
    ///
    /// # Examples
    /// ```
    /// use malachite_base::num::arithmetic::traits::Cos;
    /// use malachite_base::num::basic::traits::{Infinity, NaN, NegativeInfinity, One, Zero};
    /// use malachite_float::Float;
    ///
    /// assert!(Float::NAN.cos().is_nan());
    /// assert!(Float::INFINITY.cos().is_nan());
    /// assert!(Float::NEGATIVE_INFINITY.cos().is_nan());
    /// assert_eq!(Float::ZERO.cos(), Float::ONE);
    /// assert_eq!(
    ///     (&Float::from_unsigned_prec(1u32, 100).0).cos().to_string(),
    ///     "0.54030230586813971740093660744335"
    /// );
    /// assert_eq!(
    ///     (&Float::from_unsigned_prec(100u32, 100).0)
    ///         .cos()
    ///         .to_string(),
    ///     "0.86231887228768393410193851395099"
    /// );
    /// ```
    #[inline]
    fn cos(self) -> Float {
        self.cos_prec_round_ref(self.significant_bits(), Nearest).0
    }
}

impl CosAssign for Float {
    /// Computes $\cos x$, the cosine of a [`Float`], in place.
    ///
    /// If the output has a precision, it is the precision of the input. If the cosine is
    /// equidistant from two [`Float`]s with the specified precision, the [`Float`] with fewer 1s in
    /// its binary expansion is chosen. See [`RoundingMode`] for a description of the `Nearest`
    /// rounding mode.
    ///
    /// $$
    /// x \gets \cos x+\varepsilon.
    /// $$
    /// - If $x$ is not finite, $\varepsilon$ may be ignored or assumed to be 0.
    /// - If $x$ is finite, then $|\varepsilon| < 2^{\lfloor\log_2 |\cos x|\rfloor-p}$, where $p$ is
    ///   the precision of the input.
    ///
    /// See the [`Float::cos`] documentation for information on special cases, overflow, and
    /// underflow.
    ///
    /// If you want to use a rounding mode other than `Nearest`, consider using
    /// [`Float::cos_round_assign`] instead. If you want to specify the output precision, consider
    /// using [`Float::cos_prec_assign`]. If you want both of these things, consider using
    /// [`Float::cos_prec_round_assign`].
    ///
    /// # Worst-case complexity
    /// $T(n, e) = O(n (\log n)^3 \log\log n + (n+e) (\log (n+e))^2 \log\log (n+e))$
    ///
    /// $M(n, e) = O((n+e) \log (n+e))$
    ///
    /// where $T$ is time, $M$ is additional memory, $n$ is `self.significant_bits()`, and $e$ is
    /// the exponent of `self` (0 if `self` has no exponent or a negative one): the Taylor series at
    /// working precision $n$, summed by binary splitting for large $n$, costs the first term, and
    /// for $|x| \geq 4$ the argument is reduced modulo $2\pi$, which requires $\pi$ to about $n +
    /// e$ bits. Unlike most functions, `cos` therefore gets slower as the magnitude of its input
    /// grows, not just as the precision does.
    ///
    /// # Examples
    /// ```
    /// use malachite_base::num::arithmetic::traits::CosAssign;
    /// use malachite_base::num::basic::traits::{Infinity, NaN, NegativeInfinity, One, Zero};
    /// use malachite_float::Float;
    ///
    /// let mut x = Float::NAN;
    /// x.cos_assign();
    /// assert!(x.is_nan());
    ///
    /// let mut x = Float::INFINITY;
    /// x.cos_assign();
    /// assert!(x.is_nan());
    ///
    /// let mut x = Float::NEGATIVE_INFINITY;
    /// x.cos_assign();
    /// assert!(x.is_nan());
    ///
    /// let mut x = Float::ZERO;
    /// x.cos_assign();
    /// assert_eq!(x, Float::ONE);
    ///
    /// let mut x = Float::from_unsigned_prec(1u32, 100).0;
    /// x.cos_assign();
    /// assert_eq!(x.to_string(), "0.54030230586813971740093660744335");
    ///
    /// let mut x = Float::from_unsigned_prec(100u32, 100).0;
    /// x.cos_assign();
    /// assert_eq!(x.to_string(), "0.86231887228768393410193851395099");
    /// ```
    #[inline]
    fn cos_assign(&mut self) {
        let prec = self.significant_bits();
        self.cos_prec_round_assign(prec, Nearest);
    }
}

/// Computes $\cos x$, the cosine of a primitive float. Using this function is more accurate than
/// using the default `cos` function or the one provided by `libm`.
///
/// $$
/// f(x) = \cos x+\varepsilon.
/// $$
/// - If $x$ is not finite, $\varepsilon$ may be ignored or assumed to be 0.
/// - If $x$ is finite, then $|\varepsilon| < 2^{\lfloor\log_2 |\cos x|\rfloor-p}$, where $p$ is the
///   precision of the output (24 if `T` is a [`f32`] and 53 if `T` is a [`f64`]).
///
/// Special cases:
/// - $f(\text{NaN})=\text{NaN}$
/// - $f(\pm\infty)=\text{NaN}$
/// - $f(\pm0.0)=1.0$
///
/// Overflow and underflow are not possible: the result lies in $[-1, 1]$, and no [`f32`] or [`f64`]
/// is close enough to an odd multiple of $\pi/2$ for its cosine to be subnormal.
///
/// # Worst-case complexity
/// Constant time and additional memory.
///
/// # Examples
/// ```
/// use malachite_base::num::basic::traits::NegativeInfinity;
/// use malachite_base::num::float::NiceFloat;
/// use malachite_float::float::arithmetic::cos::primitive_float_cos;
///
/// assert!(primitive_float_cos(f32::NAN).is_nan());
/// assert!(primitive_float_cos(f32::INFINITY).is_nan());
/// assert!(primitive_float_cos(f32::NEGATIVE_INFINITY).is_nan());
/// assert_eq!(NiceFloat(primitive_float_cos(0.0f32)), NiceFloat(1.0));
/// assert_eq!(NiceFloat(primitive_float_cos(1.0f32)), NiceFloat(0.5403023));
/// assert_eq!(
///     NiceFloat(primitive_float_cos(1.0f64)),
///     NiceFloat(0.5403023058681398)
/// );
/// ```
#[inline]
#[allow(clippy::type_repetition_in_bounds)]
pub fn primitive_float_cos<T: PrimitiveFloat>(x: T) -> T
where
    Float: From<T> + PartialOrd<T>,
    for<'a> T: ExactFrom<&'a Float> + RoundingFrom<&'a Float>,
{
    emulate_float_to_float_fn(Float::cos_prec, x)
}

/// Computes $\cos x$, the cosine of a [`Rational`], returning the result as a primitive float.
///
/// $$
/// f(x) = \cos x+\varepsilon,
/// $$
/// where $|\varepsilon| < 2^{\lfloor\log_2 |\cos x|\rfloor-p}$, and $p$ is the precision of the
/// output (24 if `T` is a [`f32`] and 53 if `T` is a [`f64`]).
///
/// Special cases:
/// - $f(0)=1$
///
/// Overflow and underflow are not possible: the result lies in $[-1, 1]$, and a [`Rational`] close
/// enough to an odd multiple of $\pi/2$ for its cosine to be subnormal would need a denominator of
/// more than 100 bits, in which case the result is still correctly rounded.
///
/// # Worst-case complexity
/// $T(m, e) = O((m+e) (\log (m+e))^2 \log\log (m+e))$
///
/// $M(m, e) = O((m+e) \log (m+e))$
///
/// where $T$ is time, $M$ is additional memory, $m$ is `x.significant_bits()`, and $e$ is
/// `x.floor_log_base_2_abs()` (taken as 0 when it is negative or $x = 0$): for $|x| \geq 4$ the
/// argument is reduced modulo $2\pi$, which needs $\pi$ to about $e$ bits.
///
/// # Examples
/// ```
/// use malachite_base::num::basic::traits::Zero;
/// use malachite_base::num::float::NiceFloat;
/// use malachite_float::float::arithmetic::cos::primitive_float_cos_rational;
/// use malachite_q::Rational;
///
/// assert_eq!(
///     NiceFloat(primitive_float_cos_rational::<f64>(&Rational::ZERO)),
///     NiceFloat(1.0)
/// );
/// assert_eq!(
///     NiceFloat(primitive_float_cos_rational::<f64>(
///         &Rational::from_unsigneds(1u8, 3)
///     )),
///     NiceFloat(0.9449569463147377)
/// );
/// assert_eq!(
///     NiceFloat(primitive_float_cos_rational::<f32>(
///         &Rational::from_unsigneds(1u8, 3)
///     )),
///     NiceFloat(0.94495696)
/// );
/// assert_eq!(
///     NiceFloat(primitive_float_cos_rational::<f64>(&Rational::from(10000))),
///     NiceFloat(-0.9521553682590148)
/// );
/// ```
#[inline]
#[allow(clippy::type_repetition_in_bounds)]
pub fn primitive_float_cos_rational<T: PrimitiveFloat>(x: &Rational) -> T
where
    Float: PartialOrd<T>,
    for<'a> T: ExactFrom<&'a Float> + RoundingFrom<&'a Float>,
{
    emulate_rational_to_float_fn(Float::cos_rational_prec_ref, x)
}

/// Computes $\cos(2\pi x/u)$, the cosine of a primitive float measured in $u$ths of a turn (so that
/// `u = 360` is degrees).
///
/// $$
/// f(x,u) = \cos(2\pi x/u)+\varepsilon.
/// $$
/// - If $x$ is not finite or $u=0$, $\varepsilon$ may be ignored or assumed to be 0.
/// - If $x$ is finite and $u\neq 0$, then $|\varepsilon| < 2^{\lfloor\log_2 |\cos(2\pi
///   x/u)|\rfloor-p}$, where $p$ is the precision of the output (24 if `T` is a [`f32`] and 53 if
///   `T` is a [`f64`]).
///
/// Special cases:
/// - $f(\text{NaN},u)=\text{NaN}$
/// - $f(\pm\infty,u)=\text{NaN}$
/// - $f(x,0)=\text{NaN}$
/// - $f(\pm0.0,u)=1.0$
/// - If $x/u$ is a multiple of $1/2$, the result is exactly $1$ or $-1$; if it is an odd multiple
///   of $1/4$, the result is exactly $0.0$ (always positive, following IEEE 754-2019's `cosPi`);
///   and if it is an odd multiple of $1/6$ or $1/3$, the result is exactly $1/2$ or $-1/2$.
///
/// Overflow and underflow are not possible: the result lies in $[-1, 1]$, and no [`f32`] or [`f64`]
/// is close enough to an odd quarter turn, without being one, for its cosine to be subnormal.
///
/// # Worst-case complexity
/// Constant time and additional memory.
///
/// # Examples
/// ```
/// use malachite_base::num::float::NiceFloat;
/// use malachite_float::float::arithmetic::cos::primitive_float_cos_with_period;
///
/// assert!(primitive_float_cos_with_period(f32::NAN, 360).is_nan());
/// assert!(primitive_float_cos_with_period(f32::INFINITY, 360).is_nan());
/// assert!(primitive_float_cos_with_period(1.0f32, 0).is_nan());
/// assert_eq!(
///     NiceFloat(primitive_float_cos_with_period(0.0f32, 360)),
///     NiceFloat(1.0)
/// );
/// assert_eq!(
///     NiceFloat(primitive_float_cos_with_period(90.0f32, 360)),
///     NiceFloat(0.0)
/// );
/// assert_eq!(
///     NiceFloat(primitive_float_cos_with_period(60.0f64, 360)),
///     NiceFloat(0.5)
/// );
/// assert_eq!(
///     NiceFloat(primitive_float_cos_with_period(1.0f32, 7)),
///     NiceFloat(0.6234898)
/// );
/// assert_eq!(
///     NiceFloat(primitive_float_cos_with_period(1.0f64, 7)),
///     NiceFloat(0.6234898018587335)
/// );
/// ```
#[inline]
#[allow(clippy::type_repetition_in_bounds)]
pub fn primitive_float_cos_with_period<T: PrimitiveFloat>(x: T, u: u64) -> T
where
    Float: From<T> + PartialOrd<T>,
    for<'a> T: ExactFrom<&'a Float> + RoundingFrom<&'a Float>,
{
    emulate_float_to_float_fn(|x, prec| Float::cos_with_period_prec(x, u, prec), x)
}

/// Computes $\cos(2\pi x/u)$, the cosine of a [`Rational`] measured in $u$ths of a turn (so that `u
/// = 360` is degrees), returning the result as a primitive float.
///
/// $$
/// f(x,u) = \cos(2\pi x/u)+\varepsilon.
/// $$
/// - If $u=0$, $\varepsilon$ may be ignored or assumed to be 0.
/// - If $u\neq 0$, then $|\varepsilon| < 2^{\lfloor\log_2 |\cos(2\pi x/u)|\rfloor-p}$, where $p$ is
///   the precision of the output (24 if `T` is a [`f32`] and 53 if `T` is a [`f64`]).
///
/// Special cases:
/// - $f(x,0)=\text{NaN}$
/// - $f(0,u)=1$
/// - If $x/u$ is a multiple of $1/2$, the result is exactly $1$ or $-1$; if it is an odd multiple
///   of $1/4$, the result is exactly $0.0$ (always positive, following IEEE 754-2019's `cosPi`);
///   and if it is an odd multiple of $1/6$ or $1/3$, the result is exactly $1/2$ or $-1/2$.
///
/// Overflow and underflow are not possible: the result lies in $[-1, 1]$, and a [`Rational`] close
/// enough to an odd quarter turn, without being one, for its cosine to be subnormal would need a
/// denominator of more than 100 bits, in which case the result is still correctly rounded.
///
/// # Worst-case complexity
/// $T(m) = O(m (\log m)^2 \log\log m)$
///
/// $M(m) = O(m \log m)$
///
/// where $T$ is time, $M$ is additional memory, and $m$ is `x.significant_bits()`: the fraction of
/// a turn is reduced modulo 1 exactly, so the magnitude of $x$ does not drive the cost.
///
/// # Examples
/// ```
/// use malachite_base::num::basic::traits::Zero;
/// use malachite_base::num::float::NiceFloat;
/// use malachite_float::float::arithmetic::cos::primitive_float_cos_with_period_rational;
/// use malachite_q::Rational;
///
/// assert!(primitive_float_cos_with_period_rational::<f64>(&Rational::ZERO, 0).is_nan());
/// assert_eq!(
///     NiceFloat(primitive_float_cos_with_period_rational::<f64>(
///         &Rational::ZERO,
///         360
///     )),
///     NiceFloat(1.0)
/// );
/// // a third of a turn is exactly -1/2
/// assert_eq!(
///     NiceFloat(primitive_float_cos_with_period_rational::<f64>(
///         &Rational::from_unsigneds(1u8, 3),
///         1
///     )),
///     NiceFloat(-0.5)
/// );
/// assert_eq!(
///     NiceFloat(primitive_float_cos_with_period_rational::<f32>(
///         &Rational::from_unsigneds(1u8, 7),
///         1
///     )),
///     NiceFloat(0.6234898)
/// );
/// assert_eq!(
///     NiceFloat(primitive_float_cos_with_period_rational::<f64>(
///         &Rational::from_unsigneds(1u8, 7),
///         1
///     )),
///     NiceFloat(0.6234898018587335)
/// );
/// ```
#[inline]
#[allow(clippy::type_repetition_in_bounds)]
pub fn primitive_float_cos_with_period_rational<T: PrimitiveFloat>(x: &Rational, u: u64) -> T
where
    Float: PartialOrd<T>,
    for<'a> T: ExactFrom<&'a Float> + RoundingFrom<&'a Float>,
{
    emulate_rational_to_float_fn(
        |x, prec| Float::cos_with_period_rational_prec_ref(x, u, prec),
        x,
    )
}

/// Computes $\cos(\pi x)$, the cosine of a primitive float measured in half-turns.
///
/// This is `primitive_float_cos_with_period` with a period of 2: see
/// [`primitive_float_cos_with_period`] for the error bound and the special cases, with $u = 2$.
/// Half-integers give exactly $+0.0$ and integers exactly $\pm1$.
///
/// # Worst-case complexity
/// Constant time and additional memory.
///
/// # Examples
/// ```
/// use malachite_base::num::float::NiceFloat;
/// use malachite_float::float::arithmetic::cos::primitive_float_cos_pi;
///
/// assert!(primitive_float_cos_pi(f32::NAN).is_nan());
/// assert_eq!(NiceFloat(primitive_float_cos_pi(0.5f32)), NiceFloat(0.0));
/// assert_eq!(NiceFloat(primitive_float_cos_pi(1.0f64)), NiceFloat(-1.0));
/// assert_eq!(
///     NiceFloat(primitive_float_cos_pi(0.1f32)),
///     NiceFloat(0.95105654)
/// );
/// assert_eq!(
///     NiceFloat(primitive_float_cos_pi(0.1f64)),
///     NiceFloat(0.9510565162951535)
/// );
/// ```
#[inline]
#[allow(clippy::type_repetition_in_bounds)]
pub fn primitive_float_cos_pi<T: PrimitiveFloat>(x: T) -> T
where
    Float: From<T> + PartialOrd<T>,
    for<'a> T: ExactFrom<&'a Float> + RoundingFrom<&'a Float>,
{
    primitive_float_cos_with_period(x, 2)
}

/// Computes $\cos(\pi x)$, the cosine of a [`Rational`] measured in half-turns, returning the
/// result as a primitive float.
///
/// This is `primitive_float_cos_with_period_rational` with a period of 2: see
/// [`primitive_float_cos_with_period_rational`] for the error bound, the special cases, and the
/// complexity, with $u = 2$.
///
/// # Worst-case complexity
/// $T(m) = O(m (\log m)^2 \log\log m)$
///
/// $M(m) = O(m \log m)$
///
/// where $T$ is time, $M$ is additional memory, and $m$ is `x.significant_bits()`.
///
/// # Examples
/// ```
/// use malachite_base::num::float::NiceFloat;
/// use malachite_float::float::arithmetic::cos::primitive_float_cos_pi_rational;
/// use malachite_q::Rational;
///
/// // a third of a half-turn is exactly 1/2
/// assert_eq!(
///     NiceFloat(primitive_float_cos_pi_rational::<f64>(
///         &Rational::from_unsigneds(1u8, 3)
///     )),
///     NiceFloat(0.5)
/// );
/// assert_eq!(
///     NiceFloat(primitive_float_cos_pi_rational::<f64>(
///         &Rational::from_unsigneds(1u8, 7)
///     )),
///     NiceFloat(0.9009688679024191)
/// );
/// ```
#[inline]
#[allow(clippy::type_repetition_in_bounds)]
pub fn primitive_float_cos_pi_rational<T: PrimitiveFloat>(x: &Rational) -> T
where
    Float: PartialOrd<T>,
    for<'a> T: ExactFrom<&'a Float> + RoundingFrom<&'a Float>,
{
    primitive_float_cos_with_period_rational(x, 2)
}