view release on metacpan or  search on metacpan

GMP.xs  view on Meta::CPAN

  OUTPUT:
    RETVAL


mpz_t *
bmulf(n,d)
	mpz_t *		n
	double		d

  PREINIT:
    mpf_t nf, df;
    mp_bitcnt_t prec;
  CODE:
    /*
     Multiply (mpz_t) n by (double) d returning an (mpz_t) result.
     Uses GMP floats with maximum needed precision.
    */
    prec = mpf_get_default_prec();
    mpf_set_default_prec(mpz_sizeinbase(*n, 2) + 8 * sizeof(double));

    RETVAL = malloc (sizeof(mpz_t));
    mpz_init(*RETVAL);
    mpf_init(nf);
    mpf_init(df);

    mpf_set_z(nf, *n);
    mpf_set_d(df, d);
    mpf_mul(nf, nf, df);
    mpz_set_f(*RETVAL, nf);
    mpf_clear(nf);
    mpf_clear(df);
    /* restore default */
    mpf_set_default_prec(prec);
  OUTPUT:
    RETVAL


mpz_t *
op_div(m,n,swap)
	mpz_t *		m
	mpz_t *		n
	bool		swap

  CODE:
    SWAP_GMP
    RETVAL = malloc (sizeof(mpz_t));
    mpz_init(*RETVAL);
    mpz_div(*RETVAL, *m, *n);
  OUTPUT:
    RETVAL


void
bdiv(m,n)
	mpz_t *		m
	mpz_t *		n

  PREINIT:
    mpz_t * quo;
    mpz_t * rem;
  PPCODE:
    quo = malloc (sizeof(mpz_t));
    rem = malloc (sizeof(mpz_t));
    mpz_init(*quo);
    mpz_init(*rem);
    mpz_tdiv_qr(*quo, *rem, *m, *n);
  EXTEND(SP, 2);
  PUSHs(sv_setref_pv(sv_newmortal(), "Math::GMP", (void*)quo));
  PUSHs(sv_setref_pv(sv_newmortal(), "Math::GMP", (void*)rem));



mpz_t *
op_mod(m,n,swap)
	mpz_t *		m
	mpz_t *		n
	bool		swap

  CODE:
    SWAP_GMP
    RETVAL = malloc (sizeof(mpz_t));
    mpz_init(*RETVAL);
    mpz_mod(*RETVAL, *m, *n);
  OUTPUT:
    RETVAL

mpz_t *
bmodinv(m,n)
	mpz_t *		m
	mpz_t *		n

  CODE:
    RETVAL = malloc (sizeof(mpz_t));
    mpz_init(*RETVAL);
    mpz_invert(*RETVAL, *m, *n);
  OUTPUT:
    RETVAL


int
op_spaceship(m,n,swap)
	mpz_t *		m
	mpz_t *		n
	bool		swap

  PREINIT:
    int i;
  CODE:
    i = mpz_cmp(*m, *n);
    if (swap) {
        i = -i;
    }
    RETVAL = (i < 0) ? -1 : (i > 0) ? 1 : 0;
  OUTPUT:
    RETVAL

int
op_eq(m,n,swap)
	mpz_t*		m
	mpz_t*		n
	bool		swap

GMP.xs  view on Meta::CPAN

    RETVAL = malloc (sizeof(mpz_t));
    mpz_init(*RETVAL);
    mpz_fac_ui(*RETVAL, n);
  OUTPUT:
    RETVAL


mpz_t *
bnok(n, k)
	long		n
	long		k

  CODE:
    RETVAL = malloc (sizeof(mpz_t));
    mpz_init(*RETVAL);
    mpz_bin_uiui(*RETVAL, n, k);
  OUTPUT:
    RETVAL


mpz_t *
gmp_copy(m)
	mpz_t *		m

  CODE:
    RETVAL = malloc (sizeof(mpz_t));
    mpz_init_set(*RETVAL, *m);
  OUTPUT:
    RETVAL

int
gmp_tstbit(m,n)
	mpz_t *		m
	long		n

  CODE:
    RETVAL = mpz_tstbit(*m,n);
  OUTPUT:
    RETVAL

mpz_t *
broot(m,n)
	mpz_t *		m
	unsigned long	n

  CODE:
    RETVAL = malloc (sizeof(mpz_t));
    mpz_init(*RETVAL);
    mpz_root(*RETVAL, *m, n);
  OUTPUT:
    RETVAL

void
brootrem(m,n)
	mpz_t *		m
	unsigned long	n

  PREINIT:
    mpz_t * root;
    mpz_t * remainder;
  PPCODE:
    root = malloc (sizeof(mpz_t));
    remainder = malloc (sizeof(mpz_t));
    mpz_init(*root);
    mpz_init(*remainder);
    if (need_rootrem_workaround(m, n)) {
        /* Older libgmp have bugs for negative m, but if we need to we can
         * work on abs(m) then negate the results.
         */
        mpz_neg(*root, *m);
        mpz_rootrem(*root, *remainder, *root, n);
        mpz_neg(*root, *root);
        mpz_neg(*remainder, *remainder);
    } else {
        mpz_rootrem(*root, *remainder, *m, n);
    }
  EXTEND(SP, 2);
  PUSHs(sv_setref_pv(sv_newmortal(), "Math::GMP", (void*)root));
  PUSHs(sv_setref_pv(sv_newmortal(), "Math::GMP", (void*)remainder));

mpz_t *
bsqrt(m)
	mpz_t *		m

  CODE:
    RETVAL = malloc (sizeof(mpz_t));
    mpz_init(*RETVAL);
    mpz_sqrt(*RETVAL, *m);
  OUTPUT:
    RETVAL

void
bsqrtrem(m)
	mpz_t *		m

  PREINIT:
    mpz_t * sqrt;
    mpz_t * remainder;
  PPCODE:
    sqrt = malloc (sizeof(mpz_t));
    remainder = malloc (sizeof(mpz_t));
    mpz_init(*sqrt);
    mpz_init(*remainder);
    mpz_sqrtrem(*sqrt, *remainder, *m);
  EXTEND(SP, 2);
  PUSHs(sv_setref_pv(sv_newmortal(), "Math::GMP", (void*)sqrt));
  PUSHs(sv_setref_pv(sv_newmortal(), "Math::GMP", (void*)remainder));

int
is_perfect_power(m)
	mpz_t *		m

  CODE:
    RETVAL = mpz_perfect_power_p(*m) ? 1 : 0;
  OUTPUT:
    RETVAL

int
is_perfect_square(m)
	mpz_t *		m

  CODE:
    RETVAL = mpz_perfect_square_p(*m) ? 1 : 0;
  OUTPUT:
    RETVAL