Math-MPFR

 view release on metacpan or  search on metacpan

MPFR.xs  view on Meta::CPAN

	int	sign
	int	max_decimal_prec
	int	sf
CODE:
  RETVAL = _fmt_flt (aTHX_ out, k, sign, max_decimal_prec, sf);
OUTPUT:  RETVAL

void
Rmpfr_set_default_rounding_mode (round)
	SV *	round
        PPCODE:
        Rmpfr_set_default_rounding_mode(aTHX_ round);
        XSRETURN_EMPTY; /* return empty stack */

unsigned long
Rmpfr_get_default_rounding_mode ()


SV *
Rmpfr_prec_round (p, prec, round)
	mpfr_t *	p
	SV *	prec
	SV *	round
CODE:
  RETVAL = Rmpfr_prec_round (aTHX_ p, prec, round);
OUTPUT:  RETVAL

void
DESTROY (p)
	mpfr_t *	p
        PPCODE:
        DESTROY(aTHX_ p);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpfr_clear (p)
	mpfr_t *	p
        PPCODE:
        Rmpfr_clear(aTHX_ p);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpfr_clear_mpfr (p)
	mpfr_t *	p
        PPCODE:
        Rmpfr_clear_mpfr(p);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpfr_clear_ptr (p)
	mpfr_t *	p
        PPCODE:
        Rmpfr_clear_ptr(aTHX_ p);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpfr_clears (p, ...)
	SV *	p
        PPCODE:
        PL_markstack_ptr++;
        Rmpfr_clears(aTHX_ p);
        XSRETURN_EMPTY; /* return empty stack */

SV *
Rmpfr_init ()
CODE:
  RETVAL = Rmpfr_init (aTHX);
OUTPUT:  RETVAL

MPFR.xs  view on Meta::CPAN

Rmpfr_init2_nobless (prec)
	SV *	prec
CODE:
  RETVAL = Rmpfr_init2_nobless (aTHX_ prec);
OUTPUT:  RETVAL

void
Rmpfr_init_set (q, round)
	mpfr_t *	q
	SV *	round
        PPCODE:
        PL_markstack_ptr++;
        Rmpfr_init_set(aTHX_ q, round);
        return;

void
Rmpfr_init_set_ui (q, round)
	SV *	q
	SV *	round
        PPCODE:
        PL_markstack_ptr++;
        Rmpfr_init_set_ui(aTHX_ q, round);
        return;

void
Rmpfr_init_set_si (q, round)
	SV *	q
	SV *	round
        PPCODE:
        PL_markstack_ptr++;
        Rmpfr_init_set_si(aTHX_ q, round);
        return;

void
Rmpfr_init_set_d (q, round)
	SV *	q
	SV *	round
        PPCODE:
        PL_markstack_ptr++;
        Rmpfr_init_set_d(aTHX_ q, round);
        return;

void
Rmpfr_init_set_ld (q, round)
	SV *	q
	SV *	round
        PPCODE:
        PL_markstack_ptr++;
        Rmpfr_init_set_ld(aTHX_ q, round);
        return;

void
Rmpfr_init_set_f (q, round)
	mpf_t *	q
	SV *	round
        PPCODE:
        PL_markstack_ptr++;
        Rmpfr_init_set_f(aTHX_ q, round);
        return;

void
Rmpfr_init_set_z (q, round)
	mpz_t *	q
	SV *	round
        PPCODE:
        PL_markstack_ptr++;
        Rmpfr_init_set_z(aTHX_ q, round);
        return;

void
Rmpfr_init_set_q (q, round)
	mpq_t *	q
	SV *	round
        PPCODE:
        PL_markstack_ptr++;
        Rmpfr_init_set_q(aTHX_ q, round);
        return;

void
Rmpfr_init_set_str (q, base, round)
	SV *	q
	SV *	base
	SV *	round
        PPCODE:
        PL_markstack_ptr++;
        Rmpfr_init_set_str(aTHX_ q, base, round);
        return;

void
Rmpfr_init_set_nobless (q, round)
	mpfr_t *	q
	SV *	round
        PPCODE:
        PL_markstack_ptr++;
        Rmpfr_init_set_nobless(aTHX_ q, round);
        return;

void
Rmpfr_init_set_ui_nobless (q, round)
	SV *	q
	SV *	round
        PPCODE:
        PL_markstack_ptr++;
        Rmpfr_init_set_ui_nobless(aTHX_ q, round);
        return;

void
Rmpfr_init_set_si_nobless (q, round)
	SV *	q
	SV *	round
        PPCODE:
        PL_markstack_ptr++;
        Rmpfr_init_set_si_nobless(aTHX_ q, round);
        return;

void
Rmpfr_init_set_d_nobless (q, round)
	SV *	q
	SV *	round
        PPCODE:
        PL_markstack_ptr++;
        Rmpfr_init_set_d_nobless(aTHX_ q, round);
        return;

void
Rmpfr_init_set_ld_nobless (q, round)
	SV *	q
	SV *	round
        PPCODE:
        PL_markstack_ptr++;
        Rmpfr_init_set_ld_nobless(aTHX_ q, round);
        return;

void
Rmpfr_init_set_f_nobless (q, round)
	mpf_t *	q
	SV *	round
        PPCODE:
        PL_markstack_ptr++;
        Rmpfr_init_set_f_nobless(aTHX_ q, round);
        return;

void
Rmpfr_init_set_z_nobless (q, round)
	mpz_t *	q
	SV *	round
        PPCODE:
        PL_markstack_ptr++;
        Rmpfr_init_set_z_nobless(aTHX_ q, round);
        return;

void
Rmpfr_init_set_q_nobless (q, round)
	mpq_t *	q
	SV *	round
        PPCODE:
        PL_markstack_ptr++;
        Rmpfr_init_set_q_nobless(aTHX_ q, round);
        return;

void
Rmpfr_init_set_str_nobless (q, base, round)
	SV *	q
	SV *	base
	SV *	round
        PPCODE:
        PL_markstack_ptr++;
        Rmpfr_init_set_str_nobless(aTHX_ q, base, round);
        return;

void
Rmpfr_deref2 (p, base, n_digits, round)
	mpfr_t *	p
	SV *	base
	SV *	n_digits
	SV *	round
        PPCODE:
        PL_markstack_ptr++;
        Rmpfr_deref2(aTHX_ p, base, n_digits, round);
        return;

void
Rmpfr_set_default_prec (prec)
	SV *	prec
        PPCODE:
        Rmpfr_set_default_prec(aTHX_ prec);
        XSRETURN_EMPTY; /* return empty stack */

SV *
Rmpfr_get_default_prec ()
CODE:
  RETVAL = Rmpfr_get_default_prec (aTHX);
OUTPUT:  RETVAL

MPFR.xs  view on Meta::CPAN

Rmpfr_min_prec (x)
	mpfr_t *	x
CODE:
  RETVAL = Rmpfr_min_prec (aTHX_ x);
OUTPUT:  RETVAL

void
Rmpfr_set_prec (p, prec)
	mpfr_t *	p
	SV *	prec
        PPCODE:
        Rmpfr_set_prec(aTHX_ p, prec);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpfr_set_prec_raw (p, prec)
	mpfr_t *	p
	SV *	prec
        PPCODE:
        Rmpfr_set_prec_raw(aTHX_ p, prec);
        XSRETURN_EMPTY; /* return empty stack */

SV *
Rmpfr_get_prec (p)
	mpfr_t *	p
CODE:
  RETVAL = Rmpfr_get_prec (aTHX_ p);
OUTPUT:  RETVAL

MPFR.xs  view on Meta::CPAN

	SV *	q
	unsigned int	round
CODE:
  RETVAL = Rmpfr_set_NV (aTHX_ p, q, round);
OUTPUT:  RETVAL

void
Rmpfr_init_set_NV (q, round)
	SV *	q
	SV *	round
        PPCODE:
        PL_markstack_ptr++;
        Rmpfr_init_set_NV(aTHX_ q, round);
        return;

void
Rmpfr_init_set_NV_nobless (q, round)
	SV *	q
	SV *	round
        PPCODE:
        PL_markstack_ptr++;
        Rmpfr_init_set_NV_nobless(aTHX_ q, round);
        return;

int
Rmpfr_cmp_float128 (a, b)
	mpfr_t *	a
	SV *	b
CODE:
  RETVAL = Rmpfr_cmp_float128 (aTHX_ a, b);

MPFR.xs  view on Meta::CPAN

	SV *	base
	SV *	round
CODE:
  RETVAL = Rmpfr_set_str (aTHX_ p, num, base, round);
OUTPUT:  RETVAL

void
Rmpfr_set_inf (p, sign)
	mpfr_t *	p
	int	sign
        PPCODE:
        Rmpfr_set_inf(p, sign);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpfr_set_nan (p)
	mpfr_t *	p
        PPCODE:
        Rmpfr_set_nan(p);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpfr_swap (p, q)
	mpfr_t *	p
	mpfr_t *	q
        PPCODE:
        Rmpfr_swap(p, q);
        XSRETURN_EMPTY; /* return empty stack */

SV *
Rmpfr_get_d (p, round)
	mpfr_t *	p
	SV *	round
CODE:
  RETVAL = Rmpfr_get_d (aTHX_ p, round);
OUTPUT:  RETVAL

MPFR.xs  view on Meta::CPAN

	mpz_t *	c
	SV *	round
CODE:
  RETVAL = Rmpfr_add_z (aTHX_ a, b, c, round);
OUTPUT:  RETVAL

void
Rmpfr_get_q (a, b)
	mpq_t *	a
	mpfr_t *	b
        PPCODE:
        Rmpfr_get_q(a, b);
        XSRETURN_EMPTY; /* return empty stack */

SV *
Rmpfr_add_q (a, b, c, round)
	mpfr_t *	a
	mpfr_t *	b
	mpq_t *	c
	SV *	round
CODE:
  RETVAL = Rmpfr_add_q (aTHX_ a, b, c, round);
OUTPUT:  RETVAL

void
q_add_fr (a, b, c)
	mpq_t *	a
	mpq_t *	b
	mpfr_t *	c
        PPCODE:
        q_add_fr(a, b, c);
        XSRETURN_EMPTY; /* return empty stack */

SV *
Rmpfr_sub (a, b, c, round)
	mpfr_t *	a
	mpfr_t *	b
	mpfr_t *	c
	SV *	round
CODE:

MPFR.xs  view on Meta::CPAN

	SV *	round
CODE:
  RETVAL = Rmpfr_sub_q (aTHX_ a, b, c, round);
OUTPUT:  RETVAL

void
q_sub_fr (a, b, c)
	mpq_t *	a
	mpq_t *	b
	mpfr_t *	c
        PPCODE:
        q_sub_fr(a, b, c);
        XSRETURN_EMPTY; /* return empty stack */

SV *
Rmpfr_ui_sub (a, b, c, round)
	mpfr_t *	a
	SV *	b
	mpfr_t *	c
	SV *	round
CODE:

MPFR.xs  view on Meta::CPAN

	SV *	round
CODE:
  RETVAL = Rmpfr_mul_q (aTHX_ a, b, c, round);
OUTPUT:  RETVAL

void
q_mul_fr (a, b, c)
	mpq_t *	a
	mpq_t *	b
	mpfr_t *	c
        PPCODE:
        q_mul_fr(a, b, c);
        XSRETURN_EMPTY; /* return empty stack */

SV *
Rmpfr_dim (rop, op1, op2, round)
	mpfr_t *	rop
	mpfr_t *	op1
	mpfr_t *	op2
	SV *	round
CODE:

MPFR.xs  view on Meta::CPAN

	SV *	round
CODE:
  RETVAL = Rmpfr_div_q (aTHX_ a, b, c, round);
OUTPUT:  RETVAL

void
q_div_fr (a, b, c)
	mpq_t *	a
	mpq_t *	b
	mpfr_t *	c
        PPCODE:
        q_div_fr(a, b, c);
        XSRETURN_EMPTY; /* return empty stack */

void
q_fmod_fr (a, b, c)
	mpq_t *	a
	mpq_t *	b
	mpfr_t *	c
        PPCODE:
        q_fmod_fr(a, b, c);
        XSRETURN_EMPTY; /* return empty stack */

SV *
Rmpfr_ui_div (a, b, c, round)
	mpfr_t *	a
	SV *	b
	mpfr_t *	c
	SV *	round
CODE:

MPFR.xs  view on Meta::CPAN

int
Rmpfr_number_p (p)
	mpfr_t *	p

void
Rmpfr_reldiff (a, b, c, round)
	mpfr_t *	a
	mpfr_t *	b
	mpfr_t *	c
	SV *	round
        PPCODE:
        Rmpfr_reldiff(aTHX_ a, b, c, round);
        XSRETURN_EMPTY; /* return empty stack */

int
Rmpfr_sgn (p)
	mpfr_t *	p

int
Rmpfr_greater_p (a, b)
	mpfr_t *	a

MPFR.xs  view on Meta::CPAN

	mpfr_t *	p
	SV *	t
	SV *	round
CODE:
  RETVAL = Rmpfr_check_range (aTHX_ p, t, round);
OUTPUT:  RETVAL

void
Rmpfr_clear_underflow ()

        PPCODE:
        Rmpfr_clear_underflow();
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpfr_clear_overflow ()

        PPCODE:
        Rmpfr_clear_overflow();
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpfr_clear_nanflag ()

        PPCODE:
        Rmpfr_clear_nanflag();
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpfr_clear_inexflag ()

        PPCODE:
        Rmpfr_clear_inexflag();
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpfr_clear_flags ()

        PPCODE:
        Rmpfr_clear_flags();
        XSRETURN_EMPTY; /* return empty stack */

int
Rmpfr_underflow_p ()


int
Rmpfr_overflow_p ()

MPFR.xs  view on Meta::CPAN

	mpfr_t *	a
	mpfr_t *	b
	SV *	round
CODE:
  RETVAL = Rmpfr_exp10 (aTHX_ a, b, round);
OUTPUT:  RETVAL

void
Rmpfr_urandomb (x, ...)
	SV *	x
        PPCODE:
        PL_markstack_ptr++;
        Rmpfr_urandomb(aTHX_ x);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpfr_random2 (p, s, exp)
	mpfr_t *	p
	SV *	s
	SV *	exp
        PPCODE:
        Rmpfr_random2(aTHX_ p, s, exp);
        XSRETURN_EMPTY; /* return empty stack */

SV *
_TRmpfr_out_str (stream, base, dig, p, round)
	FILE *	stream
	SV *	base
	SV *	dig
	mpfr_t *	p
	SV *	round

MPFR.xs  view on Meta::CPAN

CODE:
  RETVAL = Rmpfr_fmod_ui (aTHX_ a, b, c, round);
OUTPUT:  RETVAL

void
Rmpfr_remquo (a, b, c, round)
	mpfr_t *	a
	mpfr_t *	b
	mpfr_t *	c
	SV *	round
        PPCODE:
        PL_markstack_ptr++;
        Rmpfr_remquo(aTHX_ a, b, c, round);
        return;

int
Rmpfr_integer_p (p)
	mpfr_t *	p

void
Rmpfr_nexttoward (a, b)
	mpfr_t *	a
	mpfr_t *	b
        PPCODE:
        Rmpfr_nexttoward(a, b);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpfr_nextabove (p)
	mpfr_t *	p
        PPCODE:
        Rmpfr_nextabove(p);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpfr_nextbelow (p)
	mpfr_t *	p
        PPCODE:
        Rmpfr_nextbelow(p);
        XSRETURN_EMPTY; /* return empty stack */

SV *
Rmpfr_min (a, b, c, round)
	mpfr_t *	a
	mpfr_t *	b
	mpfr_t *	c
	SV *	round
CODE:

MPFR.xs  view on Meta::CPAN

SV *
get_package_name (x)
	SV *	x
CODE:
  RETVAL = get_package_name (aTHX_ x);
OUTPUT:  RETVAL

void
Rmpfr_dump (a)
	mpfr_t *	a
        PPCODE:
        Rmpfr_dump(a);
        XSRETURN_EMPTY; /* return empty stack */

SV *
gmp_v ()
CODE:
  RETVAL = gmp_v (aTHX);
OUTPUT:  RETVAL

MPFR.xs  view on Meta::CPAN

	mpfr_t *	a
	mpf_t *	b

int
Rmpfr_zero_p (a)
	mpfr_t *	a

void
Rmpfr_free_cache ()

        PPCODE:
        Rmpfr_free_cache();
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpfr_free_cache2 (way)
	unsigned int	way
        PPCODE:
        Rmpfr_free_cache2(way);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpfr_free_pool ()

        PPCODE:
        Rmpfr_free_pool();
        XSRETURN_EMPTY; /* return empty stack */

SV *
Rmpfr_get_version ()
CODE:
  RETVAL = Rmpfr_get_version (aTHX);
OUTPUT:  RETVAL

MPFR.xs  view on Meta::CPAN

SV *
Rmpfr_get_emax_max ()
CODE:
  RETVAL = Rmpfr_get_emax_max (aTHX);
OUTPUT:  RETVAL


void
Rmpfr_clear_erangeflag ()

        PPCODE:
        Rmpfr_clear_erangeflag();
        XSRETURN_EMPTY; /* return empty stack */

int
Rmpfr_erangeflag_p ()


SV *
Rmpfr_rint_round (a, b, round)
	mpfr_t *	a

MPFR.xs  view on Meta::CPAN

	SV *	sv
	unsigned int	rnd
CODE:
  RETVAL = Rmpfr_set_IV (aTHX_ x, sv, rnd);
OUTPUT:  RETVAL

void
Rmpfr_init_set_IV (q, round)
	SV *	q
	SV *	round
        PPCODE:
        PL_markstack_ptr++;
        Rmpfr_init_set_IV(aTHX_ q, round);
        return;

void
Rmpfr_init_set_IV_nobless (q, round)
	SV *	q
	SV *	round
        PPCODE:
        PL_markstack_ptr++;
        Rmpfr_init_set_IV_nobless(aTHX_ q, round);
        return;

SV *
Rmpfr_get_NV (x, round)
	mpfr_t *	x
	SV *	round
CODE:
  RETVAL = Rmpfr_get_NV (aTHX_ x, round);

MPFR.xs  view on Meta::CPAN

	SV *	str
	SV *	base
	SV *	round
CODE:
  RETVAL = Rmpfr_strtofr (aTHX_ a, str, base, round);
OUTPUT:  RETVAL

void
Rmpfr_set_erangeflag ()

        PPCODE:
        Rmpfr_set_erangeflag();
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpfr_set_underflow ()

        PPCODE:
        Rmpfr_set_underflow();
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpfr_set_overflow ()

        PPCODE:
        Rmpfr_set_overflow();
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpfr_set_nanflag ()

        PPCODE:
        Rmpfr_set_nanflag();
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpfr_set_inexflag ()

        PPCODE:
        Rmpfr_set_inexflag();
        XSRETURN_EMPTY; /* return empty stack */

SV *
Rmpfr_erfc (a, b, round)
	mpfr_t *	a
	mpfr_t *	b
	SV *	round
CODE:
  RETVAL = Rmpfr_erfc (aTHX_ a, b, round);

MPFR.xs  view on Meta::CPAN

	SV *	round
CODE:
  RETVAL = Rmpfr_lngamma (aTHX_ a, b, round);
OUTPUT:  RETVAL

void
Rmpfr_lgamma (a, b, round)
	mpfr_t *	a
	mpfr_t *	b
	SV *	round
        PPCODE:
        PL_markstack_ptr++;
        Rmpfr_lgamma(aTHX_ a, b, round);
        return;

SV *
_MPFR_VERSION ()
CODE:
  RETVAL = _MPFR_VERSION (aTHX);
OUTPUT:  RETVAL

MPFR.xs  view on Meta::CPAN

	SV *	len
	SV *	round
CODE:
  RETVAL = Rmpfr_sum (aTHX_ rop, avref, len, round);
OUTPUT:  RETVAL

void
_fr_to_q (q, fr)
	mpq_t *	q
	mpfr_t *	fr
        PPCODE:
        _fr_to_q(q, fr);
        XSRETURN_EMPTY; /* return empty stack */

int
Rmpfr_q_div (rop, q, fr, round)
	mpfr_t *	rop
	mpq_t *	q
	mpfr_t *	fr
	int	round

MPFR.xs  view on Meta::CPAN

SV *
Rmpfr_randinit_lc_2exp_size_nobless (size)
	SV *	size
CODE:
  RETVAL = Rmpfr_randinit_lc_2exp_size_nobless (aTHX_ size);
OUTPUT:  RETVAL

void
Rmpfr_randclear (p)
	SV *	p
        PPCODE:
        Rmpfr_randclear(aTHX_ p);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpfr_randseed (state, seed)
	SV *	state
	SV *	seed
        PPCODE:
        Rmpfr_randseed(aTHX_ state, seed);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpfr_randseed_ui (state, seed)
	SV *	state
	SV *	seed
        PPCODE:
        Rmpfr_randseed_ui(aTHX_ state, seed);
        XSRETURN_EMPTY; /* return empty stack */

SV *
overload_pow_eq (a, b, third)
	SV *	a
	SV *	b
	SV *	third
CODE:
  RETVAL = overload_pow_eq (aTHX_ a, b, third);

MPFR.xs  view on Meta::CPAN

Rmpfr_regular_p (a)
	mpfr_t *	a
CODE:
  RETVAL = Rmpfr_regular_p (aTHX_ a);
OUTPUT:  RETVAL

void
Rmpfr_set_zero (a, sign)
	mpfr_t *	a
	SV *	sign
        PPCODE:
        Rmpfr_set_zero(aTHX_ a, sign);
        XSRETURN_EMPTY; /* return empty stack */

SV *
Rmpfr_digamma (rop, op, round)
	mpfr_t *	rop
	mpfr_t *	op
	SV *	round
CODE:
  RETVAL = Rmpfr_digamma (aTHX_ rop, op, round);

MPFR.xs  view on Meta::CPAN

	mpfr_t *	rop2
	gmp_randstate_t *	state
	SV *	round
CODE:
  RETVAL = Rmpfr_grandom (aTHX_ rop1, rop2, state, round);
OUTPUT:  RETVAL

void
Rmpfr_clear_divby0 ()

        PPCODE:
        Rmpfr_clear_divby0(aTHX);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpfr_set_divby0 ()

        PPCODE:
        Rmpfr_set_divby0(aTHX);
        XSRETURN_EMPTY; /* return empty stack */

SV *
Rmpfr_divby0_p ()
CODE:
  RETVAL = Rmpfr_divby0_p (aTHX);
OUTPUT:  RETVAL

MPFR.xs  view on Meta::CPAN

CODE:
  RETVAL = _get_xs_version (aTHX);
OUTPUT:  RETVAL


void
overload_inc (a, b, third)
	SV *	a
	SV *	b
	SV *	third
        PPCODE:
        overload_inc(aTHX_ a, b, third);
        XSRETURN_EMPTY; /* return empty stack */

void
overload_dec (a, b, third)
	SV *	a
	SV *	b
	SV *	third
        PPCODE:
        overload_dec(aTHX_ a, b, third);
        XSRETURN_EMPTY; /* return empty stack */

SV *
_overload_lshift (a, b, third)
	mpfr_t *	a
	SV *	b
	SV *	third
CODE:
  RETVAL = _overload_lshift (aTHX_ a, b, third);

MPFR.xs  view on Meta::CPAN

	SV *	rnd
CODE:
  RETVAL = Rmpfr_set_DECIMAL128 (aTHX_ rop, op, rnd);
OUTPUT:  RETVAL

void
Rmpfr_get_LD (rop, op, rnd)
	SV *	rop
	mpfr_t *	op
	SV *	rnd
        PPCODE:
        Rmpfr_get_LD(aTHX_ rop, op, rnd);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpfr_get_BFLOAT16 (rop, op, rnd)
	SV *	rop
	mpfr_t *	op
	SV *	rnd
        PPCODE:
        Rmpfr_get_BFLOAT16(aTHX_ rop, op, rnd);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpfr_get_FLOAT16 (rop, op, rnd)
	SV *	rop
	mpfr_t *	op
	SV *	rnd
        PPCODE:
        Rmpfr_get_FLOAT16(aTHX_ rop, op, rnd);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpfr_get_FLT (rop, op, rnd)
	SV *	rop
	mpfr_t *	op
	SV *	rnd
        PPCODE:
        Rmpfr_get_FLT(aTHX_ rop, op, rnd);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpfr_get_DECIMAL64 (rop, op, rnd)
	SV *	rop
	mpfr_t *	op
	SV *	rnd
        PPCODE:
        Rmpfr_get_DECIMAL64(aTHX_ rop, op, rnd);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpfr_get_DECIMAL128 (rop, op, rnd)
	SV *	rop
	mpfr_t *	op
	SV *	rnd
        PPCODE:
        Rmpfr_get_DECIMAL128(aTHX_ rop, op, rnd);
        XSRETURN_EMPTY; /* return empty stack */

int
_MPFR_WANT_DECIMAL_FLOATS ()


int
_MPFR_WANT_DECIMAL64 ()

MPFR.xs  view on Meta::CPAN

SV *
_isobject (x)
	SV *	x
CODE:
  RETVAL = _isobject (aTHX_ x);
OUTPUT:  RETVAL

void
_mp_sizes ()

        PPCODE:
        PL_markstack_ptr++;
        _mp_sizes();
        return;

SV *
_ivsize ()
CODE:
  RETVAL = _ivsize (aTHX);
OUTPUT:  RETVAL

MPFR.xs  view on Meta::CPAN

	SV *	rnd
CODE:
  RETVAL = Rmpfr_get_float128 (aTHX_ op, rnd);
OUTPUT:  RETVAL

void
Rmpfr_get_FLOAT128 (rop, op, rnd)
	SV *	rop
	mpfr_t *	op
	SV *	rnd
        PPCODE:
        Rmpfr_get_FLOAT128(aTHX_ rop, op, rnd);
        XSRETURN_EMPTY; /* return empty stack */

SV *
Rmpfr_set_FLT (rop, op, rnd)
	mpfr_t *	rop
	SV *	op
	SV *	rnd
CODE:
  RETVAL = Rmpfr_set_FLT (aTHX_ rop, op, rnd);

MPFR.xs  view on Meta::CPAN

	SV *	q
	SV *	rnd
CODE:
  RETVAL = Rmpfr_set_float128 (aTHX_ rop, q, rnd);
OUTPUT:  RETVAL

void
Rmpfr_init_set_float128 (q, round)
	SV *	q
	SV *	round
        PPCODE:
        PL_markstack_ptr++;
        Rmpfr_init_set_float128(aTHX_ q, round);
        return;

void
Rmpfr_init_set_float128_nobless (q, round)
	SV *	q
	SV *	round
        PPCODE:
        PL_markstack_ptr++;
        Rmpfr_init_set_float128_nobless(aTHX_ q, round);
        return;

SV *
_is_readonly (sv)
	SV *	sv
CODE:
  RETVAL = _is_readonly (aTHX_ sv);
OUTPUT:  RETVAL

void
_readonly_on (sv)
	SV *	sv
        PPCODE:
        _readonly_on(aTHX_ sv);
        XSRETURN_EMPTY; /* return empty stack */

void
_readonly_off (sv)
	SV *	sv
        PPCODE:
        _readonly_off(aTHX_ sv);
        XSRETURN_EMPTY; /* return empty stack */

int
_can_pass_float128 ()


int
_mpfr_want_float128 ()

MPFR.xs  view on Meta::CPAN

nnumflag ()


int
nok_pokflag ()


void
clear_nnum ()

        PPCODE:
        clear_nnum();
        XSRETURN_EMPTY; /* return empty stack */

void
clear_nok_pok ()

        PPCODE:
        clear_nok_pok();
        XSRETURN_EMPTY; /* return empty stack */

void
set_nnum (x)
	int	x
        PPCODE:
        set_nnum(x);
        XSRETURN_EMPTY; /* return empty stack */

void
set_nok_pok (x)
	int	x
        PPCODE:
        set_nok_pok(x);
        XSRETURN_EMPTY; /* return empty stack */

SV *
_d_bytes (str)
	SV *	str
CODE:
  RETVAL = _d_bytes (aTHX_ str);
OUTPUT:  RETVAL

MPFR.xs  view on Meta::CPAN

  RETVAL = _GMP_NAIL_BITS (aTHX);
OUTPUT:  RETVAL


void
Rmpfr_fmodquo (a, b, c, round)
	mpfr_t *	a
	mpfr_t *	b
	mpfr_t *	c
	SV *	round
        PPCODE:
        PL_markstack_ptr++;
        Rmpfr_fmodquo(aTHX_ a, b, c, round);
        return;

int
Rmpfr_fpif_export (stream, op)
	FILE *	stream
	mpfr_t *	op
CODE:
  RETVAL = Rmpfr_fpif_export (aTHX_ stream, op);

MPFR.xs  view on Meta::CPAN

	mpfr_t *	op
	unsigned char *	str
	SV *	sizet
CODE:
  RETVAL = Rmpfr_fpif_import_mem (aTHX_ op, str, sizet);
OUTPUT:  RETVAL

void
Rmpfr_flags_clear (mask)
	unsigned int	mask
        PPCODE:
        Rmpfr_flags_clear(mask);
        XSRETURN_EMPTY; /* return empty stack */

void
Rmpfr_flags_set (mask)
	unsigned int	mask
        PPCODE:
        Rmpfr_flags_set(mask);
        XSRETURN_EMPTY; /* return empty stack */

unsigned int
Rmpfr_flags_test (mask)
	unsigned int	mask

unsigned int
Rmpfr_flags_save ()


void
Rmpfr_flags_restore (flags, mask)
	unsigned int	flags
	unsigned int	mask
        PPCODE:
        Rmpfr_flags_restore(flags, mask);
        XSRETURN_EMPTY; /* return empty stack */

int
Rmpfr_rint_roundeven (rop, op, round)
	mpfr_t *	rop
	mpfr_t *	op
	int	round

int

MPFR.xs  view on Meta::CPAN

	SV *	prec
	SV *	emin
	SV *	emax
CODE:
  RETVAL = mpfrtoa_subn (aTHX_ obj, prec, emin, emax);
OUTPUT:  RETVAL

void
set_fallback_flag ()

        PPCODE:
        PL_markstack_ptr++;
        set_fallback_flag(aTHX);
        XSRETURN_EMPTY; /* return empty stack */

SV *
doubletoa (sv, ...)
	SV *	sv
        CODE:
          PL_markstack_ptr++;
          RETVAL = doubletoa(aTHX_ sv);

MPFR.xs  view on Meta::CPAN

SV *
_numtoa (in)
	SV *	in
CODE:
  RETVAL = _numtoa (aTHX_ in);
OUTPUT:  RETVAL

void
decimalize (a, ...)
	SV *	a
        PPCODE:
        PL_markstack_ptr++;
        decimalize(aTHX_ a);
        return;

int
IOK_flag (sv)
	SV *	sv

int
POK_flag (sv)

MPFR.xs  view on Meta::CPAN

int
Rmpfr_buildopt_bfloat16_p ()
CODE:
  RETVAL = Rmpfr_buildopt_bfloat16_p (aTHX);
OUTPUT:  RETVAL


void
_unpack_float32 (f)
	mpfr_t *	f
        PPCODE:
        PL_markstack_ptr++;
        _unpack_float32(aTHX_ f);
        return;

void
_unpack_float16 (f)
	mpfr_t *	f
        PPCODE:
        PL_markstack_ptr++;
        _unpack_float16(aTHX_ f);
        return;

void
_unpack_bfloat16 (f)
	mpfr_t *	f
        PPCODE:
        PL_markstack_ptr++;
        _unpack_bfloat16(aTHX_ f);
        return;

SV *
_subnormalize_pv (val, emin, emax, prec)
	SV *	val
	int	emin
	int	emax
	int	prec

MPFR.xs  view on Meta::CPAN

	SV *	pv

UV
_SvLEN (pv)
	SV *	pv

void
_SvCUR_set (pv, len)
	SV *	pv
	UV	len
        PPCODE:
        _SvCUR_set(pv, len);
        XSRETURN_EMPTY; /* return empty stack */

SV *
Rmpfr_cmp_str (a, str)
	mpfr_t *	a
	SV *	str
CODE:
  RETVAL = Rmpfr_cmp_str (aTHX_ a, str);
OUTPUT:  RETVAL

Prec/Prec.xs  view on Meta::CPAN

  RETVAL = prec_cast (aTHX_ iv);
OUTPUT:  RETVAL

int
_PREC_MIN ()


void
DESTROY (rop)
	SV *	rop
        PPCODE:
        DESTROY(aTHX_ rop);
        XSRETURN_EMPTY; /* return empty stack */