/*=============================================================================

    This file is part of FLINT.

    FLINT is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    FLINT is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with FLINT; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA

=============================================================================*/
/******************************************************************************

    Copyright (C) 2011 Fredrik Johansson
    Copyright (C) 2011 Sebastian Pancratz

******************************************************************************/


*******************************************************************************

    Memory management

*******************************************************************************

void fmpq_init(fmpq_t x)

    Initialises the \code{fmpq_t} variable \code{x} for use. Its value
    is set to 0.

void fmpq_clear(fmpq_t x)

    Clears the \code{fmpq_t} variable \code{x}. To use the variable again,
    it must be re-initialised with \code{fmpq_init}.

fmpq * _fmpq_vec_init(slong n)

    Initialises a vector of \code{fmpq} values of length $n$ and sets
    all values to 0. This is equivalent to generating a \code{fmpz} vector
    of length $2n$ with \code{_fmpz_vec_init} and setting all denominators
    to 1.

void _fmpq_vec_clear(fmpq * vec, slong n)

    Frees an \code{fmpq} vector.

*******************************************************************************

    Canonicalisation

*******************************************************************************

void fmpq_canonicalise(fmpq_t res)

    Puts \code{res} in canonical form: the numerator and denominator are
    reduced to lowest terms, and the denominator is made positive.
    If the numerator is zero, the denominator is set to one.

    If the denominator is zero, the outcome of calling this function is
    undefined, regardless of the value of the numerator.

void _fmpq_canonicalise(fmpz_t num, fmpz_t den)

    Does the same thing as \code{fmpq_canonicalise}, but for numerator
    and denominator given explicitly as \code{fmpz_t} variables. Aliasing
    of \code{num} and \code{den} is not allowed.

int fmpq_is_canonical(const fmpq_t x)

    Returns nonzero if \code{fmpq_t} x is in canonical form
    (as produced by \code{fmpq_canonicalise}), and zero otherwise.

int _fmpq_is_canonical(const fmpz_t num, const fmpz_t den)

    Does the same thing as \code{fmpq_is_canonical}, but for numerator
    and denominator given explicitly as \code{fmpz_t} variables.

*******************************************************************************

    Basic assignment

*******************************************************************************

void fmpq_set(fmpq_t dest, const fmpq_t src)

    Sets \code{dest} to a copy of \code{src}. No canonicalisation
    is performed.

void fmpq_swap(fmpq_t op1, fmpq_t op2)

    Swaps the two rational numbers \code{op1} and \code{op2}.

void fmpq_neg(fmpq_t dest, const fmpq_t src)

    Sets \code{dest} to the additive inverse of \code{src}.

void fmpq_abs(fmpq_t dest, const fmpq_t src)

    Sets \code{dest} to the absolute value of \code{src}.

void fmpq_zero(fmpq_t res)

    Sets the value of \code{res} to 0.

void fmpq_one(fmpq_t res)

    Sets the value of \code{res} to $1$.

*******************************************************************************

    Comparison

*******************************************************************************

int fmpq_is_zero(const fmpq_t res)

    Returns nonzero if \code{res} has value 0, and returns zero otherwise.

int fmpq_is_one(const fmpq_t res)

    Returns nonzero if \code{res} has value $1$, and returns zero otherwise.

int fmpq_equal(const fmpq_t x, const fmpq_t y)

    Returns nonzero if \code{x} and \code{y} are equal, and zero otherwise.
    Assumes that \code{x} and \code{y} are both in canonical form.

int fmpq_sgn(const fmpq_t x)

    Returns the sign of the rational number $x$.

int fmpq_cmp(const fmpq_t x, const fmpq_t y)

    Returns negative if $x < y$, zero if $x = y$, and positive if $x > y$.

void fmpq_height(fmpz_t height, const fmpq_t x)

    Sets \code{height} to the height of $x$, defined as the larger of
    the absolute values of the numerator and denominator of $x$.

mp_bitcnt_t fmpq_height_bits(const fmpq_t x)

    Returns the number of bits in the height of $x$.

*******************************************************************************

    Conversion

*******************************************************************************

void fmpq_set_fmpz_frac(fmpq_t res, const fmpz_t p, const fmpz_t q)

    Sets \code{res} to the canonical form of the fraction \code{p / q}.
    This is equivalent to assigning the numerator and denominator
    separately and calling \code{fmpq_canonicalise}.

void fmpq_set_si(fmpq_t res, slong p, ulong q)

    Sets \code{res} to the canonical form of the fraction \code{p / q}.

void _fmpq_set_si(fmpz_t rnum, fmpz_t rden, slong p, ulong q)

    Sets \code{(rnum, rden)} to the canonical form of the fraction
    \code{p / q}. \code{rnum} and \code{rden} may not be aliased.

void fmpq_set_mpq(fmpq_t dest, const mpq_t src)

    Sets the value of \code{dest} to that of the \code{mpq_t} variable
    \code{src}.

void fmpq_get_mpq(mpq_t dest, const fmpq_t src)

    Sets the value of \code{dest}

int fmpq_get_mpfr(mpfr_t dest, const fmpq_t src, mpfr_rnd_t rnd)

    Sets the MPFR variable \code{dest} to the value of \code{src},
    rounded to the nearest representable binary floating-point value
    in direction \code{rnd}. Returns the sign of the rounding,
    according to MPFR conventions.

char * _fmpq_get_str(char * str, int b, const fmpz_t num, const fmpz_t den)

char * fmpq_get_str(char * str, int b, const fmpq_t x)

    Prints the string representation of $x$ in base $b \in [2, 36]$ 
    to a suitable buffer.

    If \code{str} is not \code{NULL}, this is used as the buffer and 
    also the return value.  If \code{str} is \code{NULL}, allocates 
    sufficient space and returns a pointer to the string.

void flint_mpq_init_set_readonly(mpq_t z, const fmpq_t f)

    Sets the unitialised \code{mpq_t} $z$ to the value of the 
    readonly \code{fmpq_t} $f$.

    Note that it is assumed that $f$ does not change during 
    the lifetime of $z$.

    The rational $z$ has to be cleared by a call to 
    \code{flint_mpq_clear_readonly()}.

    The suggested use of the two functions is as follows:
    \begin{lstlisting}[language=C]
    fmpq_t f;
    ...
    {
        mpq_t z;

        flint_mpq_init_set_readonly(z, f);
        foo(..., z);
        flint_mpq_clear_readonly(z);
    }
    \end{lstlisting}

    This provides a convenient function for user code, only 
    requiring to work with the types \code{fmpq_t} and \code{mpq_t}.

void flint_mpq_clear_readonly(mpq_t z)

    Clears the readonly \code{mpq_t} $z$.

void fmpq_init_set_readonly(fmpq_t f, const mpq_t z)

    Sets the uninitialised \code{fmpq_t} $f$ to a readonly 
    version of the rational $z$.

    Note that the value of $z$ is assumed to remain constant 
    throughout the lifetime of $f$.

    The \code{fmpq_t} $f$ has to be cleared by calling the 
    function \code{fmpq_clear_readonly()}.

    The suggested use of the two functions is as follows:
    \begin{lstlisting}[language=C]
    mpq_t z;
    ...
    {
        fmpq_t f;

        fmpq_init_set_readonly(f, z);
        foo(..., f);
        fmpq_clear_readonly(f);
    }
    \end{lstlisting}

void fmpq_clear_readonly(fmpq_t f)

    Clears the readonly \code{fmpq_t} $f$.

*******************************************************************************

    Input and output

*******************************************************************************

void fmpq_fprint(FILE * file, const fmpq_t x)

    Prints \code{x} as a fraction to the stream \code{file}.   
    The numerator and denominator are printed verbatim as integers, 
    with a forward slash (/) printed in between.

void _fmpq_fprint(FILE * file, const fmpz_t num, const fmpz_t den)

    Does the same thing as \code{fmpq_fprint}, but for numerator
    and denominator given explicitly as \code{fmpz_t} variables. 

void fmpq_print(const fmpq_t x)

    Prints \code{x} as a fraction. The numerator and denominator are
    printed verbatim as integers, with a forward slash (/) printed in
    between.

void _fmpq_print(const fmpz_t num, const fmpz_t den)

    Does the same thing as \code{fmpq_print}, but for numerator
    and denominator given explicitly as \code{fmpz_t} variables. 

*******************************************************************************

    Random number generation

*******************************************************************************

void fmpq_randtest(fmpq_t res, flint_rand_t state, mp_bitcnt_t bits)

    Sets \code{res} to a random value, with numerator and denominator
    having up to \code{bits} bits. The fraction will be in canonical
    form. This function has an increased probability of generating
    special values which are likely to trigger corner cases.

void _fmpq_randtest(fmpz_t num, fmpz_t den, flint_rand_t state,
    mp_bitcnt_t bits)

    Does the same thing as \code{fmpq_randtest}, but for numerator
    and denominator given explicitly as \code{fmpz_t} variables. Aliasing
    of \code{num} and \code{den} is not allowed.

void fmpq_randtest_not_zero(fmpq_t res, flint_rand_t state, mp_bitcnt_t bits)

    As per \code{fmpq_randtest}, but the result will not be $0$. 
    If \code{bits} is set to $0$, an exception will result.

void fmpq_randbits(fmpq_t res, flint_rand_t state, mp_bitcnt_t bits)

    Sets \code{res} to a random value, with numerator and denominator
    both having exactly \code{bits} bits before canonicalisation,
    and then puts \code{res} in canonical form. Note that as a result
    of the canonicalisation, the resulting numerator and denominator can
    be slightly smaller than \code{bits} bits.

void _fmpq_randbits(fmpz_t num, fmpz_t den, flint_rand_t state,
        mp_bitcnt_t bits)

    Does the same thing as \code{fmpq_randbits}, but for numerator
    and denominator given explicitly as \code{fmpz_t} variables. Aliasing
    of \code{num} and \code{den} is not allowed.


*******************************************************************************

    Arithmetic

*******************************************************************************


void fmpq_add(fmpq_t res, const fmpq_t op1, const fmpq_t op2)

void fmpq_sub(fmpq_t res, const fmpq_t op1, const fmpq_t op2)

void fmpq_mul(fmpq_t res, const fmpq_t op1, const fmpq_t op2)

void fmpq_div(fmpq_t res, const fmpq_t op1, const fmpq_t op2)

    Sets \code{res} respectively to \code{op1 + op2}, \code{op1 - op2},
    \code{op1 * op2}, or \code{op1 / op2}. Assumes that the inputs
    are in canonical form, and produces output in canonical form.
    Division by zero results in an error.
    Aliasing between any combination of the variables is allowed.

void _fmpq_add(fmpz_t rnum, fmpz_t rden, const fmpz_t op1num,
    const fmpz_t op1den, const fmpz_t op2num, const fmpz_t op2den)

void _fmpq_sub(fmpz_t rnum, fmpz_t rden, const fmpz_t op1num,
    const fmpz_t op1den, const fmpz_t op2num, const fmpz_t op2den)

void _fmpq_mul(fmpz_t rnum, fmpz_t rden, const fmpz_t op1num,
    const fmpz_t op1den, const fmpz_t op2num, const fmpz_t op2den)

void _fmpq_div(fmpz_t rnum, fmpz_t rden, const fmpz_t op1num,
    const fmpz_t op1den, const fmpz_t op2num, const fmpz_t op2den)

    Sets \code{(rnum, rden)} to the canonical form of the sum,
    difference, product or quotient respectively of the fractions
    represented by \code{(op1num, op1den)} and \code{(op2num, op2den)}.
    Aliasing between any combination of the variables is allowed,
    whilst no numerator is aliased with a denominator.

void fmpq_addmul(fmpq_t res, const fmpq_t op1, const fmpq_t op2)

void fmpq_submul(fmpq_t res, const fmpq_t op1, const fmpq_t op2)

    Sets \code{res} to \code{res + op1 * op2} or \code{res - op1 * op2}
    respectively, placing the result in canonical form. Aliasing
    between any combination of the variables is allowed.

void _fmpq_addmul(fmpz_t rnum, fmpz_t rden, const fmpz_t op1num,
    const fmpz_t op1den, const fmpz_t op2num, const fmpz_t op2den)

void _fmpq_submul(fmpz_t rnum, fmpz_t rden, const fmpz_t op1num,
    const fmpz_t op1den, const fmpz_t op2num, const fmpz_t op2den)

    Sets \code{(rnum, rden)} to the canonical form of the fraction
    \code{(rnum, rden)} + \code{(op1num, op1den)} * \code{(op2num, op2den)} or
    \code{(rnum, rden)} - \code{(op1num, op1den)} * \code{(op2num, op2den)}
    respectively. Aliasing between any combination of the variables is allowed,
    whilst no numerator is aliased with a denominator.

void fmpq_inv(fmpq_t dest, const fmpq_t src)

    Sets \code{dest} to \code{1 / src}. The result is placed in canonical
    form, assuming that \code{src} is already in canonical form.

void _fmpq_pow_si(fmpz_t rnum, fmpz_t rden, 
                  const fmpz_t opnum, const fmpz_t opden, slong e);

void fmpq_pow_si(fmpq_t res, const fmpq_t op, slong e);

    Sets \code{res} to \code{op} raised to the power~$e$, where~$e$ 
    is a \code{slong}.  If $e$ is $0$ and \code{op} is $0$, then 
    \code{res} will be set to $1$.

void fmpq_mul_fmpz(fmpq_t res, const fmpq_t op, const fmpz_t x)

    Sets \code{res} to the product of the rational number \code{op} 
    and the integer \code{x}.

void fmpq_div_fmpz(fmpq_t res, const fmpq_t op, const fmpz_t x)

    Sets \code{res} to the quotient of the rational number \code{op} 
    and the integer \code{x}.

void fmpq_mul_2exp(fmpq_t res, const fmpq_t x, mp_bitcnt_t exp)

    Sets \code{res} to \code{x} multiplied by \code{2^exp}.

void fmpq_div_2exp(fmpq_t res, const fmpq_t x, mp_bitcnt_t exp)

    Sets \code{res} to \code{x} divided by \code{2^exp}.

*******************************************************************************

    Modular reduction and rational reconstruction

*******************************************************************************

int _fmpq_mod_fmpz(fmpz_t res,
        const fmpz_t num, const fmpz_t den, const fmpz_t mod)

int fmpq_mod_fmpz(fmpz_t res, const fmpq_t x, const fmpz_t mod)

    Sets the integer \code{res} to the residue $a$ of
    $x = n/d$ = \code{(num, den)} modulo the positive integer $m$ = \code{mod},
    defined as the $0 \le a < m$ satisfying $n \equiv a d \pmod m$.
    If such an $a$ exists, 1 will be returned, otherwise 0 will
    be returned.

int _fmpq_reconstruct_fmpz_2(fmpz_t n, fmpz_t d, const fmpz_t a,
        const fmpz_t m, const fmpz_t N, const fmpz_t D)

int fmpq_reconstruct_fmpz_2(fmpq_t res, const fmpz_t a, const fmpz_t m,
        const fmpz_t N, const fmpz_t D)

    Reconstructs a rational number from its residue $a$ modulo $m$.

    Given a modulus $m > 1$, a residue $0 \le a < m$, and positive $N, D$
    satisfying $2ND < m$, this function attempts to find a fraction $n/d$ with
    $0 \le |n| \le N$ and $0 < d \le D$ such that $\gcd(n,d) = 1$ and
    $n \equiv ad \pmod m$. If a solution exists, then it is also unique.
    The function returns 1 if successful, and 0 to indicate that no solution
    exists.

int _fmpq_reconstruct_fmpz(fmpz_t n, fmpz_t d, const fmpz_t a,
    const fmpz_t m)

int fmpq_reconstruct_fmpz(fmpq_t res, const fmpz_t a, const fmpz_t m)

    Reconstructs a rational number from its residue $a$ modulo $m$,
    returning 1 if successful and 0 if no solution exists.
    Uses the balanced bounds $N = D = \lfloor\sqrt{m/2}\rfloor$.


*******************************************************************************

    Rational enumeration

*******************************************************************************

void _fmpq_next_minimal(fmpz_t rnum, fmpz_t rden,
    const fmpz_t num, const fmpz_t den)

void fmpq_next_minimal(fmpq_t res, const fmpq_t x)

    Given $x$ which is assumed to be nonnegative and in canonical form, sets
    \code{res} to the next rational number in the sequence obtained by
    enumerating all positive denominators $q$, for each $q$ enumerating
    the numerators $1 \le p < q$ in order and generating both $p/q$ and $q/p$,
    but skipping all $\gcd(p,q) \ne 1$. Starting with zero, this generates
    every nonnegative rational number once and only once, with the first
    few entries being:

    $$0, 1, 1/2, 2, 1/3, 3, 2/3, 3/2, 1/4, 4, 3/4, 4/3, 1/5, 5, 2/5, \ldots.$$

    This enumeration produces the rational numbers in order of
    minimal height. It has the disadvantage of being somewhat slower to
    compute than the Calkin-Wilf enumeration.

void _fmpq_next_signed_minimal(fmpz_t rnum, fmpz_t rden,
    const fmpz_t num, const fmpz_t den)

void fmpq_next_signed_minimal(fmpq_t res, const fmpq_t x)

    Given a signed rational number $x$ assumed to be in canonical form, sets
    \code{res} to the next element in the minimal-height sequence
    generated by \code{fmpq_next_minimal} but with negative numbers
    interleaved:

    $$0, 1, -1, 1/2, -1/2, 2, -2, 1/3, -1/3, \ldots.$$

    Starting with zero, this generates every rational number once
    and only once, in order of minimal height.

void _fmpq_next_calkin_wilf(fmpz_t rnum, fmpz_t rden,
    const fmpz_t num, const fmpz_t den)

void fmpq_next_calkin_wilf(fmpq_t res, const fmpq_t x)

    Given $x$ which is assumed to be nonnegative and in canonical form, sets
    \code{res} to the next number in the breadth-first traversal of the
    Calkin-Wilf tree. Starting with zero, this generates every nonnegative
    rational number once and only once, with the first few entries being:

    $$0, 1, 1/2, 2, 1/3, 3/2, 2/3, 3, 1/4, 4/3, 3/5, 5/2, 2/5, \ldots.$$

    Despite the appearance of the initial entries, the Calkin-Wilf
    enumeration does not produce the rational numbers in order of height:
    some small fractions will appear late in the sequence. This order
    has the advantage of being faster to produce than the minimal-height
    order.

void _fmpq_next_signed_calkin_wilf(fmpz_t rnum, fmpz_t rden,
    const fmpz_t num, const fmpz_t den)

void fmpq_next_signed_calkin_wilf(fmpq_t res, const fmpq_t x)

    Given a signed rational number $x$ assumed to be in canonical form, sets
    \code{res} to the next element in the Calkin-Wilf sequence with
    negative numbers interleaved:

    $$0, 1, -1, 1/2, -1/2, 2, -2, 1/3, -1/3, \ldots.$$

    Starting with zero, this generates every rational number once
    and only once, but not in order of minimal height.

*******************************************************************************

    Continued fractions

*******************************************************************************

slong fmpq_get_cfrac(fmpz * c, fmpq_t rem, const fmpq_t x, slong n)

    Generates up to $n$ terms of the (simple) continued fraction expansion
    of $x$, writing the coefficients to the vector $c$ and the remainder $r$
    to the \code{rem} variable. The return value is the number $k$ of
    generated terms. The output satisfies:

    $$
    x = c_0 + \cfrac{1}{c_1 + \cfrac{1}{c_2 +
        \cfrac{1}{ \ddots + \cfrac{1}{c_{k-1} + r }}}}
    $$

    If $r$ is zero, the continued fraction expansion is complete.
    If $r$ is nonzero, $1/r$ can be passed back as input to generate
    $c_k, c_{k+1}, \ldots$. Calls to \code{fmpq_get_cfrac} can therefore
    be chained to generate the continued fraction incrementally,
    extracting any desired number of coefficients at a time.

    In general, a rational number has exactly two continued fraction
    expansions. By convention, we generate the shorter one. The longer
    expansion can be obtained by replacing the last coefficient
    $a_{k-1}$ by the pair of coefficients $a_{k-1} - 1, 1$.

    As a special case, the continued fraction expansion of zero consists
    of a single zero (and not the empty sequence).

    This function implements a simple algorithm, performing repeated
    divisions. The running time is quadratic.

void fmpq_set_cfrac(fmpq_t x, const fmpz * c, slong n)

    Sets $x$ to the value of the continued fraction

    $$
    x = c_0 + \cfrac{1}{c_1 + \cfrac{1}{c_2 +
        \cfrac{1}{ \ddots + \cfrac{1}{c_{n-1}}}}}
    $$

    where all $c_i$ except $c_0$ should be nonnegative.
    It is assumed that $n > 0$.

    For large $n$, this function implements a subquadratic algorithm.
    The convergents are given by a chain product of 2 by 2 matrices.
    This product is split in half recursively to balance the size
    of the coefficients.

slong fmpq_cfrac_bound(const fmpq_t x)

    Returns an upper bound for the number of terms in the continued
    fraction expansion of $x$. The computed bound is not necessarily sharp.

    We use the fact that the smallest denominator
    that can give a continued fraction of length $n$ is the Fibonacci
    number $F_{n+1}$.

