bignum.pmc

/*
Copyright (C) 2004-2008, Parrot Foundation.
$Id$

=head1 NAME

src/pmc/bignum.pmc - BigNum PMC class

=head1 DESCRIPTION

C<BigNum> provides arbitrary precision floating point mathematic
functions, based on the GMP mpf library.

=head1 SYNOPSIS

Make mixing of classes work, like in:

        new $P0 ['BigInt']
        new $P1 ['BigNum']
        set $P0, 10
        set $P1, 2
        div P2, P0, P1  # $P2 = $P0 / $P1; (BigNum) 5.0

Make auto-upgrading/downgrading work.

        set $N1, $P0
        set $N1, $P1
        set $I1, $P0
        set $I1, $P1
        set $P0, $I1
        set $P0, $N1
        set $P1, $I1
        set $P1, $N1

  BigNum
    => BigInt => Integer
    => Number: float (can be long double) and double
    => Integer (unsigned long)

=head2 Functions

=over 4

=item C<static void bignum_set(Interp*, PMC *, PMC *)>

=item C<static void bignum_set_si(Interp*, PMC *, long value)>

=item C<static void bignum_set_double(Interp*, PMC *, double value)>

=item C<static void bignum_set_str(Interp*, PMC *, char *, int base)>

=cut

*/

#include "parrot/parrot.h"

#ifdef S_SPLINT_S
#  undef PARROT_HAS_GMP /* splint barfs on the gmp.h header */
#endif /* S_SPLINT_S */

/* Uncomment to easily disable it */
/*
#ifdef PARROT_HAS_GMP
#  undef PARROT_HAS_GMP
#endif
*/
#undef PARROT_BIGNUM_CAN_BIGINT

#ifdef PARROT_HAS_GMP
#  include "pmc_bigint.h"
#  include <gmp.h>
typedef struct BIGNUM {
    mpf_t b;
} BIGNUM;
#endif

static void
bignum_init(PARROT_INTERP, PMC *self) {
    Parrot_BigNum_attributes *attrs =
        mem_allocate_zeroed_typed(Parrot_BigNum_attributes);
#ifdef PARROT_HAS_GMP
    attrs->bn = mem_allocate_zeroed_typed(BIGNUM);
    mpf_clear(attrs->bn->b);
    mpf_init(attrs->bn->b);
#else
    attrs->bn = NULL;
#endif
    PMC_data(self) = attrs;
}


static void
bignum_clear(PARROT_INTERP, PMC *self) {
#ifdef PARROT_HAS_GMP
    BIGNUM *bn;
    GETATTR_BigNum_bn(interp, self, bn);
    mpf_clear(bn->b);
#endif
}


#ifdef PARROT_HAS_GMP

static void
bignum_set(PARROT_INTERP, PMC *dest, PMC *src) {
    BIGNUM *bn_dest, *bn_src;
    GETATTR_BigNum_bn(interp, dest, bn_dest);
    GETATTR_BigNum_bn(interp, src,  bn_src);
    mpf_set(bn_dest->b, bn_src->b);
}

static void
bignum_set_si(PARROT_INTERP, PMC *self, long value) {
    BIGNUM *bn;
    GETATTR_BigNum_bn(interp, self, bn);
    mpf_set_si(bn->b, value);
}

static void
bignum_set_ui(PARROT_INTERP, PMC *self, unsigned long value) {
    BIGNUM *bn;
    GETATTR_BigNum_bn(interp, self, bn);
    mpf_set_ui(bn->b, value);
}

static void
bignum_set_float(PARROT_INTERP, PMC *self, FLOATVAL value) {
    BIGNUM *bn;
    GETATTR_BigNum_bn(interp, self, bn);
    mpf_set_d(bn->b, (double)value);
}

static void
bignum_set_double(PARROT_INTERP, PMC *self, double value) {
    BIGNUM *bn;
    GETATTR_BigNum_bn(interp, self, bn);
    mpf_set_d(bn->b, value);
}

static void
bignum_set_str(PARROT_INTERP, PMC *self, char *value, int base) {
    BIGNUM *bn;
    GETATTR_BigNum_bn(interp, self, bn);
    mpf_set_str(bn->b, value, base);
}

#  ifdef PARROT_BIGNUM_CAN_BIGINT
static void
bignum_set_bigint(PARROT_INTERP, PMC *self, struct BIGINT *value) {
    BIGNUM *bn;
    struct BIGINT *bi;
    GETATTR_BigNum_bn(interp, self, bn);
    bi->b = PARROT_BIGINT(value);
    mpf_set(bn->b, (mpf_srcptr)bi->b);
}
#  endif

static BIGNUM*
bignum_get_self(PARROT_INTERP, PMC *self) {
    BIGNUM *bn;
    GETATTR_BigNum_bn(interp, self, bn);
    return bn;
}

static void
bignum_set_self(PARROT_INTERP, PMC *self, BIGNUM *value) {
    BIGNUM *bn;
    GETATTR_BigNum_bn(interp, self, bn);
    mpf_set(bn->b, (mpf_srcptr)((BIGNUM*)value)->b);
}

static long
bignum_get_si(PARROT_INTERP, PMC *self) {
    BIGNUM *bn;
    GETATTR_BigNum_bn(interp, self, bn);
    if (mpf_fits_slong_p(bn->b))
        return mpf_get_si(bn->b);

    Parrot_ex_throw_from_c_args(interp, NULL, 1, "bignum_get_si: number too big");
}

static unsigned long
bignum_get_ui(PARROT_INTERP, PMC *self) {
    BIGNUM *bn;
    GETATTR_BigNum_bn(interp, self, bn);
    if (mpf_fits_slong_p(bn->b))
        return mpf_get_ui(bn->b);

    Parrot_ex_throw_from_c_args(interp, NULL, 1, "bignum_get_ui: number too big");
}

static int
bignum_get_bool(PARROT_INTERP, PMC *self) {
    BIGNUM *bn;
    GETATTR_BigNum_bn(interp, self, bn);
    if (mpf_sgn(bn->b) != 0)
        return 1;
    else
        return 0;
}

static char *
bignum_get_string(PARROT_INTERP, PMC *self, int base) {
    BIGNUM *bn;
    size_t  n;
    char   *s;
    mp_exp_t exponent;

    GETATTR_BigNum_bn(interp, self, bn);
    n = (mpf_get_prec(bn->b)) / log(base) * log(2);
    s = (char *)mem_sys_allocate(n + 5);
    return mpf_get_str(s, &exponent, base, 0, bn->b);
}

static char *
bignum_get_string_size(PARROT_INTERP, PMC *self, int base, int digits) {
    BIGNUM *bn;
    size_t  n;
    char   *s;
    mp_exp_t exponent;

    GETATTR_BigNum_bn(interp, self, bn);
    s = (char *)mem_sys_allocate(digits + 5);
    return mpf_get_str(s, &exponent, base, digits, bn->b);
}

static double
bignum_get_double(PARROT_INTERP, PMC *self) {
    BIGNUM *bn;
    GETATTR_BigNum_bn(interp, self, bn);
    return mpf_get_d(bn->b);
}

static FLOATVAL
bignum_get_float(PARROT_INTERP, PMC *self) {
    BIGNUM *bn;
    GETATTR_BigNum_bn(interp, self, bn);
    return mpf_get_d(bn->b);
}

#  ifdef PARROT_BIGNUM_CAN_BIGINT
static struct BIGINT
bignum_get_bigint(PARROT_INTERP, PMC *self) {
    BIGNUM *bn;
    struct BIGINT *bi_dest;
    GETATTR_BigNum_bn(interp, self, bn);
    mpz_clear(bi_dest->b);
    mpz_init(bi_dest->b);
    if (mpf_fits_slong_p(bn->b)) {
        bi_dest->b = mpf_get_ui(bn->b);
    }
    else {
        Parrot_ex_throw_from_c_args(interp, NULL, 1,
            "bignum_get_bigint: Precision loss");
    }
    return bi_dest;
}
#  endif

static void
bignum_add_bignum(PARROT_INTERP, PMC *self, PMC *value, PMC *dest) {
    BIGNUM *bn_self, *bn_value, *bn_dest;
    GETATTR_BigNum_bn(interp, self, bn_self);
    GETATTR_BigNum_bn(interp, value, bn_value);
    GETATTR_BigNum_bn(interp, dest, bn_dest);
    mpf_add(bn_dest->b, bn_self->b, bn_value->b);
}

static void
bignum_add_bignum_int(PARROT_INTERP, PMC *self, INTVAL value, PMC *dest) {
    BIGNUM *bn_self, *bn_dest;
    GETATTR_BigNum_bn(interp, self, bn_self);
    GETATTR_BigNum_bn(interp, dest, bn_dest);
    if (value < 0)
        mpf_sub_ui(bn_dest->b, bn_self->b, (unsigned long int)-value);
    else
        mpf_add_ui(bn_dest->b, bn_self->b, (unsigned long int)value);
}

static void
bignum_add_bignum_float(PARROT_INTERP, PMC *self, FLOATVAL value, PMC *dest) {
    BIGNUM *bn, *bn_self, *bn_dest;
    GETATTR_BigNum_bn(interp, self, bn_self);
    GETATTR_BigNum_bn(interp, dest, bn_dest);
    mpf_set_d(bn->b, value);
    mpf_add(bn_dest->b, bn_self->b, bn->b);
}

static void
bignum_sub_bignum(PARROT_INTERP, PMC *self, PMC *value, PMC *dest) {
    BIGNUM *bn_self, *bn_value, *bn_dest;
    GETATTR_BigNum_bn(interp, self, bn_self);
    GETATTR_BigNum_bn(interp, value, bn_value);
    GETATTR_BigNum_bn(interp, dest, bn_dest);
    mpf_sub(bn_dest->b, bn_self->b, bn_value->b);
}

static void
bignum_sub_bignum_int(PARROT_INTERP, PMC *self, INTVAL value, PMC *dest) {
    BIGNUM *bn_self, *bn_dest;
    GETATTR_BigNum_bn(interp, self, bn_self);
    GETATTR_BigNum_bn(interp, dest, bn_dest);
    if (value < 0)
        mpf_add_ui(bn_dest->b, bn_self->b, (unsigned long int)-value);
    else
        mpf_sub_ui(bn_dest->b, bn_self->b, (unsigned long int)value);
}

static void
bignum_sub_bignum_float(PARROT_INTERP, PMC *self, FLOATVAL value, PMC *dest) {
    BIGNUM *bn, *bn_self, *bn_dest;
    GETATTR_BigNum_bn(interp, self, bn_self);
    GETATTR_BigNum_bn(interp, dest, bn_dest);
    mpf_set_d(bn->b, value);
    mpf_sub(bn_dest->b, bn_self->b, bn->b);
}

static void
bignum_mul_bignum(PARROT_INTERP, PMC *self, PMC *value, PMC *dest) {
    BIGNUM *bn_self, *bn_value, *bn_dest;
    GETATTR_BigNum_bn(interp, self, bn_self);
    GETATTR_BigNum_bn(interp, value, bn_value);
    GETATTR_BigNum_bn(interp, dest, bn_dest);
    mpf_mul(bn_dest->b, bn_self->b, bn_value->b);
}

static void
bignum_mul_bignum_int(PARROT_INTERP, PMC *self, INTVAL value, PMC *dest) {
    BIGNUM *bn_self, *bn_dest;
    GETATTR_BigNum_bn(interp, self, bn_self);
    GETATTR_BigNum_bn(interp, dest, bn_dest);
    mpf_mul_ui(bn_dest->b, bn_self->b, (unsigned long)value);
}

static void
bignum_mul_bignum_float(PARROT_INTERP, PMC *self, FLOATVAL value, PMC *dest) {
    BIGNUM *bn, *bn_self, *bn_dest;
    GETATTR_BigNum_bn(interp, self, bn_self);
    GETATTR_BigNum_bn(interp, dest, bn_dest);
    mpf_set_d(bn->b, value);
    mpf_mul(bn_dest->b, bn_self->b, bn->b);
}

static void
bignum_pow_bignum_int(PARROT_INTERP, PMC *self, INTVAL value, PMC *dest) {
    BIGNUM *bn_self, *bn_dest;
    GETATTR_BigNum_bn(interp, self, bn_self);
    GETATTR_BigNum_bn(interp, dest, bn_dest);
    mpf_pow_ui(bn_dest->b, bn_self->b, (unsigned long int)value);
}

static void
int_check_divide_zero(PARROT_INTERP, INTVAL value) {
    if (value == 0)
        Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_DIV_BY_ZERO,
            "Divide by zero");
}

static void
bignum_check_divide_zero(PARROT_INTERP, PMC *value) {
    /* Throw an exception if we are dividing by zero. */
    BIGNUM *bn;
    GETATTR_BigNum_bn(interp, value, bn);
    if (mpf_cmp_si(bn->b, 0) == 0)
        Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_DIV_BY_ZERO,
            "Divide by zero");
}

static void
bignum_div_bignum(PARROT_INTERP, PMC *self, PMC *value, PMC *dest) {
    BIGNUM *bn_self, *bn_value, *bn_dest;
    bignum_check_divide_zero(interp, value);
    GETATTR_BigNum_bn(interp, self, bn_self);
    GETATTR_BigNum_bn(interp, value, bn_value);
    GETATTR_BigNum_bn(interp, dest, bn_dest);
    mpf_div(bn_dest->b, bn_self->b, bn_value->b);
}

static void
bignum_div_bignum_int(PARROT_INTERP, PMC *self, INTVAL value, PMC *dest) {
    BIGNUM *bn_self, *bn_dest;
    GETATTR_BigNum_bn(interp, self, bn_self);
    GETATTR_BigNum_bn(interp, dest, bn_dest);
    int_check_divide_zero(interp, value);

    /* this is mpz_fdiv_q */
    if (value < 0) {
        mpf_div_ui(bn_dest->b, bn_self->b, (unsigned long int)-value);
        mpf_neg(bn_dest->b, bn_dest->b);
    }
    else
        mpf_div_ui(bn_dest->b, bn_self->b, (unsigned long int)value);
}

static void
bignum_div_bignum_float(PARROT_INTERP, PMC *self, FLOATVAL value, PMC *dest) {
    BIGNUM *bn, *bn_self, *bn_dest;
    GETATTR_BigNum_bn(interp, self, bn_self);
    GETATTR_BigNum_bn(interp, dest, bn_dest);
    int_check_divide_zero(interp, value);

    if (value < 0) {
        mpf_set_d(bn->b, -value);
        mpf_div(bn_dest->b, bn_self->b, bn->b);
        mpf_neg(bn_dest->b, bn_dest->b);
    }
    else
        mpf_div(bn_dest->b, bn_self->b, bn->b);
}

/* There's no such mpf_fdiv, only mpz_fdiv and mpf_div */
static void
bignum_fdiv_bignum(PARROT_INTERP, PMC *self, PMC *value, PMC *dest) {
    BIGNUM *bn_self, *bn_value, *bn_dest;
    GETATTR_BigNum_bn(interp, self, bn_self);
    GETATTR_BigNum_bn(interp, value, bn_value);
    GETATTR_BigNum_bn(interp, dest, bn_dest);
    bignum_check_divide_zero(interp, value);
    mpf_div(bn_dest->b, bn_self->b, bn_value->b);
}

static void
bignum_fdiv_bignum_int(PARROT_INTERP, PMC *self, INTVAL value, PMC *dest) {
    BIGNUM *bn_self, *bn_dest;
    GETATTR_BigNum_bn(interp, self, bn_self);
    GETATTR_BigNum_bn(interp, dest, bn_dest);
    int_check_divide_zero(interp, value);

    if (value < 0) {
        mpf_div_ui(bn_dest->b, bn_self->b, (unsigned long int)-value);
        mpf_neg(bn_dest->b, bn_dest->b);
    }
    else
        mpf_div_ui(bn_dest->b, bn_self->b, (unsigned long int)value);
}

static INTVAL
bignum_cmp(PARROT_INTERP, PMC *self, PMC *value) {
    BIGNUM *bn_self, *bn_value;
    GETATTR_BigNum_bn(interp, self,  bn_self);
    GETATTR_BigNum_bn(interp, value, bn_value);
    return mpf_cmp(bn_self->b, bn_value->b);
}

static INTVAL
bignum_cmp_double(PARROT_INTERP, PMC *self, double value) {
    BIGNUM *bn;
    GETATTR_BigNum_bn(interp, self, bn);
    return mpf_cmp_d(bn->b, value);
}

static INTVAL
bignum_cmp_int(PARROT_INTERP, PMC *self, INTVAL value) {
    BIGNUM *bn;
    GETATTR_BigNum_bn(interp, self, bn);
    return mpf_cmp_si(bn->b, value);
}

static INTVAL
bignum_cmp_ulong(PARROT_INTERP, PMC *self, unsigned long value) {
    BIGNUM *bn;
    GETATTR_BigNum_bn(interp, self, bn);
    return mpf_cmp_ui(bn->b, value);
}

static void
bignum_abs(PARROT_INTERP, PMC *self, PMC *dest) {
    BIGNUM *bn_self, *bn_dest;
    pmc_reuse(interp, dest, enum_class_BigNum, 0);
    GETATTR_BigNum_bn(interp, self, bn_self);
    GETATTR_BigNum_bn(interp, dest, bn_dest);
    mpf_abs(bn_dest->b, bn_self->b);
}

static void
bignum_neg(PARROT_INTERP, PMC *self, PMC *dest) {
    BIGNUM *bn_self, *bn_dest;
    pmc_reuse(interp, dest, enum_class_BigNum, 0);
    GETATTR_BigNum_bn(interp, self, bn_self);
    GETATTR_BigNum_bn(interp, dest, bn_dest);
    mpf_neg(bn_dest->b, bn_self->b);
}

static INTVAL
bignum_get_default_prec(PARROT_INTERP, PMC *self) {
    return mpf_get_default_prec();
}

static void
bignum_set_default_prec(PARROT_INTERP, PMC *self, INTVAL prec) {
    mpf_set_default_prec(prec);
}

#else /* ifdef PARROT_HAS_GMP */

typedef struct BIGNUM {
    FLOATVAL b; /* bogus definition for users without libgmp*/
} BIGNUM;

#  define THROW_NYI Parrot_ex_throw_from_c_args(interp, NULL, \
                        EXCEPTION_LIBRARY_ERROR, "no bignum lib loaded")

#  if 0
static void
bignum_init(PARROT_INTERP, PMC *self) {
    THROW_NYI;
}

static void
bignum_clear(PARROT_INTERP, PMC *self) {
    THROW_NYI;
}
#  endif

static void
bignum_set(PARROT_INTERP, PMC *dest, PMC *src) {
    THROW_NYI;
}

static void
bignum_set_si(PARROT_INTERP, PMC *self, long value) {
    THROW_NYI;
}

static void
bignum_set_double(PARROT_INTERP, PMC *self, double value) {
    THROW_NYI;
}

static void
bignum_set_str(PARROT_INTERP, PMC *self, char *value, int base) {
    THROW_NYI;
}

static void
bignum_set_self(PARROT_INTERP, PMC *self, BIGNUM *value) {
    THROW_NYI;
}

static BIGNUM*
bignum_get_self(PARROT_INTERP, PMC *self) {
    THROW_NYI;
}

static char *
bignum_get_string(PARROT_INTERP, PMC *self, int base) {
    THROW_NYI;
}

static char *
bignum_get_string_size(PARROT_INTERP, PMC *self, int base, int digits) {
    THROW_NYI;
}

static unsigned long
bignum_get_ui(PARROT_INTERP, PMC *self) {
    THROW_NYI;
}

static long
bignum_get_si(PARROT_INTERP, PMC *self) {
    THROW_NYI;
}

static long
bignum_get_bool(PARROT_INTERP, PMC *self) {
    THROW_NYI;
}

static double
bignum_get_double(PARROT_INTERP, PMC *self) {
    THROW_NYI;
}

static void
bignum_add_bignum(PARROT_INTERP, PMC *self, PMC *value, PMC *dest) {
    THROW_NYI;
}

static void
bignum_add_bignum_int(PARROT_INTERP, PMC *self, INTVAL value, PMC *dest) {
    THROW_NYI;
}

static void
bignum_add_bignum_float(PARROT_INTERP, PMC *self, FLOATVAL value, PMC *dest) {
    THROW_NYI;
}

static void
bignum_sub_bignum(PARROT_INTERP, PMC *self, PMC *value, PMC *dest) {
    THROW_NYI;
}

static void
bignum_sub_bignum_int(PARROT_INTERP, PMC *self, INTVAL value, PMC *dest) {
    THROW_NYI;
}

static void
bignum_sub_bignum_float(PARROT_INTERP, PMC *self, FLOATVAL value, PMC *dest) {
    THROW_NYI;
}

static void
bignum_mul_bignum(PARROT_INTERP, PMC *self, PMC *value, PMC *dest) {
    THROW_NYI;
}

static void
bignum_mul_bignum_int(PARROT_INTERP, PMC *self, INTVAL value, PMC *dest) {
    THROW_NYI;
}

static void
bignum_mul_bignum_float(PARROT_INTERP, PMC *self, FLOATVAL value, PMC *dest) {
    THROW_NYI;
}

static void
bignum_pow_bignum_int(PARROT_INTERP, PMC *self, INTVAL value, PMC *dest) {
    THROW_NYI;
}

static void
bignum_pow_bignum_float(PARROT_INTERP, PMC *self, FLOATVAL value, PMC *dest) {
    THROW_NYI;
}

static void
bignum_div_bignum(PARROT_INTERP, PMC *self, PMC *value, PMC *dest) {
    THROW_NYI;
}

static void
bignum_div_bignum_int(PARROT_INTERP, PMC *self, INTVAL value, PMC *dest) {
    THROW_NYI;
}

static void
bignum_div_bignum_float(PARROT_INTERP, PMC *self, FLOATVAL value, PMC *dest) {
    THROW_NYI;
}

static void
bignum_fdiv_bignum(PARROT_INTERP, PMC *self, PMC *value, PMC *dest) {
    THROW_NYI;
}

static void
bignum_fdiv_bignum_int(PARROT_INTERP, PMC *self, INTVAL value, PMC *dest) {
    THROW_NYI;
}

static void
bignum_fdiv_bignum_float(PARROT_INTERP, PMC *self, FLOATVAL value, PMC *dest) {
    THROW_NYI;
}

static INTVAL
bignum_cmp(PARROT_INTERP, PMC *self, PMC *value) {
    THROW_NYI;
}

static INTVAL
bignum_cmp_int(PARROT_INTERP, PMC *self, INTVAL value) {
    THROW_NYI;
}

static INTVAL
bignum_cmp_float(PARROT_INTERP, PMC *self, FLOATVAL value) {
    THROW_NYI;
}

static void
bignum_abs(PARROT_INTERP, PMC *self, PMC *dest) {
    THROW_NYI;
}

static void
bignum_neg(PARROT_INTERP, PMC *self, PMC *dest) {
    THROW_NYI;
}

static INTVAL
bignum_get_default_prec(PARROT_INTERP, PMC *self) {
    THROW_NYI;
}

static void
bignum_set_default_prec(PARROT_INTERP, PMC *self, INTVAL prec) {
    THROW_NYI;
}

#  undef THROW_NYI

#endif /* ifdef PARROT_HAS_GMP */

pmclass BigNum {
    ATTR struct BIGNUM * bn; /*bignum val*/

/*

=back

=head2 Methods

=over 4

=item C<METHOD version()>

Return GMP version string "x.y.z".

=cut

*/

    METHOD version() {
        STRING *version;
#ifdef PARROT_HAS_GMP
        version = Parrot_str_new(INTERP, gmp_version, 0);
#else
        version = Parrot_str_new(INTERP, "0.0.0", 5);
#endif
        RETURN(STRING *version);
    }

/*

=item C<PMC *instantiate(PMC *sig)>

Object constructor. SELF is a BigNum Class object. Return a new
BigNum object.

=cut

*/
    VTABLE PMC *instantiate(PMC *sig) {
#ifdef PARROT_HAS_GMP
        int argcP = REG_INT(interp, 3);
        int base;
        PMC *res;
        STRING *num;

        res = pmc_new(INTERP, enum_class_BigNum);
        if (!argcP) {
            return res;
        }
        base = 10;
        if (argcP == 2)
            base = VTABLE_get_integer(INTERP, REG_PMC(interp, 6));
        num = VTABLE_get_string(INTERP, REG_PMC(interp, 5));
        VTABLE_set_string_keyed_int(INTERP, res, base, num);
        return res;
#else
        return PMCNULL;
#endif
    }

    VTABLE void init() {
        bignum_init(INTERP, SELF);
        PObj_active_destroy_SET(SELF);
    }

    VTABLE PMC *clone() {
        PMC *res = pmc_new(INTERP, SELF->vtable->base_type);
        bignum_set(INTERP, res, SELF);
        return res;
    }

    VTABLE void destroy() {
        BIGNUM                   *bn;
        Parrot_BigNum_attributes *attrs;

        bignum_clear(INTERP, SELF);

        attrs = (Parrot_BigNum_attributes*)PMC_data(SELF);
#ifdef PARROT_HAS_GMP
        mem_sys_free(attrs->bn);
#endif
        mem_sys_free(attrs);
    }

/*

=item C<void set_integer_native(INTVAL value)>

=cut

*/

    VTABLE void set_integer_native(INTVAL value) {
        bignum_set_si(INTERP, SELF, (long)value);
    }

/*

=item C<void set_number_native(FLOATVAL value)>

Sets the value of the BigNum to C<value>.

=cut

*/

    VTABLE void set_number_native(FLOATVAL value) {
        bignum_set_double(INTERP, SELF, (double)value);
    }

/*

=item C<void set_string_native(STRING *value)>

Sets the value of the BigNum to the result of converting C<*value> to a
number.

=item C<void set_string_keyed_int(INTVAL base, STRING *value)>

Same assume number base C<base>.

=cut

*/

    VTABLE void set_string_native(STRING *value) {
        char * const s = Parrot_str_to_cstring(INTERP, value);
        bignum_set_str(INTERP, SELF, s, 10);
        Parrot_str_free_cstring(s);
    }

    VTABLE void set_string_keyed_int(INTVAL base, STRING *value) {
        char * const s = Parrot_str_to_cstring(INTERP, value);
        bignum_set_str(INTERP, SELF, s, base);
        Parrot_str_free_cstring(s);
    }
/*

=item C<void set_pmc(PMC *value)>

Sets the value of the BigNum to the BigNum value of C<*value>.

=cut

*/

    VTABLE void set_pmc(PMC *value) {
        bignum_set_self(INTERP, SELF, bignum_get_self(INTERP, value));
    }

/*

=item C<FLOATVAL get_number()>

Down-converts the precise BigNum to an imprecise double.

=cut

*/

    VTABLE FLOATVAL get_number() {
        return bignum_get_double(INTERP, SELF);
    }

/*

=item C<INTVAL get_integer()>

Returns the integer conversion of the BigNum.

=cut

*/

    VTABLE INTVAL get_integer() {
        return bignum_get_si(INTERP, SELF);
    }

/*

=item C<INTVAL get_ulong()>

Returns the unsigned long conversion of the BigNum.

=cut

*/

    VTABLE INTVAL get_ulong() {
        return bignum_get_ui(INTERP, SELF);
    }

/*

=item C<PMC *get_bignum()>

Returns SELF, keeping floating point precision.

=cut

*/

    VTABLE PMC *get_bignum() {
        return SELF;
    }

/*

=item C<FLOATVAL get_bigint()>

Trunc the BigNum to an BigInt.

=cut

*/

    VTABLE BIGINT get_bigint() {
#if PARROT_BIGNUM_CAN_BIGINT
        return bignum_get_bigint(INTERP, SELF);
#else
        Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_LIBRARY_ERROR,
            "no bigint support in bigint");
#endif
    }

/*

=item C<INTVAL get_bool()>

Returns the boolean value of the BigNum.

=cut

*/

    VTABLE INTVAL get_bool() {
        return bignum_get_bool(INTERP, SELF);
    }

/*

=item C<STRING *get_string()>

Returns the string representation of the BigNum.

=item C<STRING *get_string_keyed_int(INTVAL base)>

Returns the string representation of the BigNum in base C<base>.

=item C<STRING *get_string_keyed_int_int(INTVAL base, INTVAL digits)>

Returns the string representation of the BigNum in base C<base> with
C<digits> digits.

=item C<STRING *get_repr()>

Returns the string representation of the BigNum with the letter 'N'
appended.

=cut

*/

    VTABLE STRING *get_string() {
        char   *s  = bignum_get_string(INTERP, SELF, 10);
        STRING *ps = Parrot_str_new(INTERP, s, 0);
        mem_sys_free(s);
        return ps;
    }

    VTABLE STRING *get_string_keyed_int(INTVAL base) {
        char   *s  = bignum_get_string(INTERP, SELF, base);
        STRING *ps = Parrot_str_new(INTERP, s, 0);
        mem_sys_free(s);
        return ps;
    }

    VTABLE STRING *get_string_keyed_int_int(INTVAL base, INTVAL digits) {
        char   *s  = bignum_get_string_size(INTERP, SELF, base, digits);
        STRING *ps = Parrot_str_new(INTERP, s, 0);
        mem_sys_free(s);
        return ps;
    }

    VTABLE STRING *get_repr() {
        STRING *s = SELF.get_string();
        return Parrot_str_append(INTERP, s, Parrot_str_new(interp, "N", 1));
    }
/*

=item C<void increment()>

Increment the BigNum by 1.0.

=cut

*/

    VTABLE void increment() {
        bignum_add_bignum_int(INTERP, SELF, 1, SELF);
    }

/*

=item C<void decrement()>

Decrement the BigNum by 1.0.

=cut

*/

    VTABLE void decrement() {
        bignum_sub_bignum_int(INTERP, SELF, 1, SELF);
    }

/*

=item C<void add()>

=cut

*/

    MULTI PMC *add(BigNum value, PMC *dest) {
        dest = pmc_new(INTERP, SELF->vtable->base_type);

        bignum_add_bignum(INTERP, SELF, value, dest);
        return dest;
    }

    MULTI PMC *add(Integer value, PMC *dest) {
        dest = pmc_new(INTERP, SELF->vtable->base_type);

        bignum_add_bignum_int(INTERP, SELF, VTABLE_get_integer(interp, value), dest);
        return dest;
    }

    MULTI PMC *add(DEFAULT value, PMC *dest) {
        Parrot_ex_throw_from_c_args(INTERP, NULL,
            EXCEPTION_INTERNAL_NOT_IMPLEMENTED,
            "BigNum: no multiple dispatch variant 'add' for %Ss",
            VTABLE_name(interp, value));
    }

    VTABLE PMC *add_int(INTVAL value, PMC *dest) {
        dest = pmc_new(INTERP, SELF->vtable->base_type);

        bignum_add_bignum_int(INTERP, SELF, value, dest);
        return dest;
    }

    MULTI void i_add(BigNum value) {
        bignum_add_bignum(INTERP, SELF, value, SELF);
    }

    MULTI void i_add(FLOATVAL value) {
        bignum_add_bignum_float(INTERP, SELF, value, SELF);
    }

    MULTI void i_add(DEFAULT value) {
        Parrot_ex_throw_from_c_args(INTERP, NULL,
            EXCEPTION_INTERNAL_NOT_IMPLEMENTED,
            "BigNum: no multiple dispatch variant 'i_add' for %Ss",
            VTABLE_name(interp, value));
    }

    VTABLE void i_add_int(INTVAL value) {
        bignum_add_bignum_int(INTERP, SELF, value, SELF);
    }

    VTABLE void i_add_float(FLOATVAL value) {
        Parrot_ex_throw_from_c_args(INTERP, NULL,
            EXCEPTION_INTERNAL_NOT_IMPLEMENTED,
            "BigNum: no multiple dispatch variant 'i_add_float' for FLOATVAL");
    }

/*

=item C<void substract()>

=cut

*/

    MULTI PMC *subtract(BigNum value, PMC *dest) {
        if (dest)
            pmc_reuse(interp, dest, SELF->vtable->base_type, 0);
        else
            dest = pmc_new(INTERP, SELF->vtable->base_type);

        bignum_sub_bignum(INTERP, SELF, value, dest);
        return dest;
    }

    MULTI PMC *subtract(Integer value, PMC *dest) {
        if (dest)
            pmc_reuse(interp, dest, SELF->vtable->base_type, 0);
        else
            dest = pmc_new(INTERP, SELF->vtable->base_type);

        bignum_sub_bignum_int(INTERP, SELF, VTABLE_get_integer(interp, value), dest);
        return dest;
    }

    MULTI PMC *subtract(DEFAULT value, PMC *dest) {
        Parrot_ex_throw_from_c_args(INTERP, NULL,
            EXCEPTION_INTERNAL_NOT_IMPLEMENTED,
            "BigNum: no multiple dispatch variant 'subtract' for %Ss",
            VTABLE_name(interp, value));
    }

    VTABLE PMC *subtract_int(INTVAL value, PMC *dest) {
        if (dest)
            pmc_reuse(interp, dest, SELF->vtable->base_type, 0);
        else
            dest = pmc_new(INTERP, SELF->vtable->base_type);

        bignum_sub_bignum_int(INTERP, SELF, value, dest);
        return dest;
    }

    MULTI void i_subtract(BigNum value) {
        bignum_sub_bignum(INTERP, SELF, value, SELF);
    }

    MULTI void i_subtract(FLOATVAL value) {
        bignum_sub_bignum_float(INTERP, SELF, value, SELF);
    }

    MULTI void i_subtract(DEFAULT value) {
        Parrot_ex_throw_from_c_args(INTERP, NULL,
            EXCEPTION_INTERNAL_NOT_IMPLEMENTED,
            "BigNum: no multiple dispatch variant 'i_subtract' for %Ss",
            VTABLE_name(interp, value));
    }

    VTABLE void i_subtract_int(INTVAL value) {
        bignum_sub_bignum_int(INTERP, SELF, value, SELF);
    }

    VTABLE void i_subtract_float(FLOATVAL value) {
        Parrot_ex_throw_from_c_args(INTERP, NULL,
            EXCEPTION_INTERNAL_NOT_IMPLEMENTED,
            "BigNum: no multiple dispatch variant 'i_subtract_float' for FLOATVAL");
    }

/*

=item C<void multiply()>

=cut

*/

    MULTI PMC *multiply(BigNum value, PMC *dest) {
        dest = pmc_new(INTERP, SELF->vtable->base_type);

        bignum_mul_bignum(INTERP, SELF, value, dest);
        return dest;
    }

    MULTI PMC *multiply(Integer value, PMC *dest) {
        dest = pmc_new(INTERP, SELF->vtable->base_type);

        bignum_mul_bignum_int(INTERP, SELF, VTABLE_get_integer(interp, value), dest);
        return dest;
    }

    MULTI PMC *multiply(DEFAULT value, PMC *dest) {
         Parrot_ex_throw_from_c_args(INTERP, NULL,
            EXCEPTION_INTERNAL_NOT_IMPLEMENTED,
            "BigNum: no multiple dispatch variant 'multiply' for %Ss",
            VTABLE_name(interp, value));
    }

    VTABLE PMC *multiply_int(INTVAL value, PMC *dest) {
        dest = pmc_new(INTERP, SELF->vtable->base_type);

        bignum_mul_bignum_int(INTERP, SELF, value, dest);
        return dest;
    }

    MULTI void i_multiply(BigNum value) {
        bignum_mul_bignum(INTERP, SELF, value, SELF);
    }

    MULTI void i_multiply(FLOATVAL value) {
        bignum_mul_bignum_float(INTERP, SELF, value, SELF);
    }

    MULTI void i_multiply(Integer value) {
        bignum_mul_bignum_int(INTERP, SELF, VTABLE_get_integer(interp, value), SELF);
    }

    MULTI void i_multiply(DEFAULT value) {
        Parrot_ex_throw_from_c_args(INTERP, NULL,
            EXCEPTION_INTERNAL_NOT_IMPLEMENTED,
            "BigNum: no multiple dispatch variant 'i_multiply' for %Ss",
            VTABLE_name(interp, value));
    }

    VTABLE void i_multiply_int(INTVAL value) {
        bignum_mul_bignum_int(INTERP, SELF, value, SELF);
    }

    VTABLE void i_multiply_float(FLOATVAL value) {
        Parrot_ex_throw_from_c_args(INTERP, NULL,
            EXCEPTION_INTERNAL_NOT_IMPLEMENTED,
            "BigNum: no multiple dispatch variant 'i_multiply_float' for FLOATVAL");
    }

/*

=item C<void pow()>

=cut

*/

    VTABLE PMC *pow_int(INTVAL value, PMC *dest) {
        if (dest)
            pmc_reuse(interp, dest, SELF->vtable->base_type, 0);
        else
            dest = pmc_new(INTERP, SELF->vtable->base_type);

        bignum_pow_bignum_int(INTERP, SELF, value, dest);
        return dest;
    }

    MULTI PMC *pow(PMC *value, PMC *dest) {
        /* only Integer RHS currently. TODO: check number and bignum types */
        INTVAL r = VTABLE_get_integer(INTERP, value);
        dest = pmc_new(INTERP, SELF->vtable->base_type);

        bignum_pow_bignum_int(INTERP, SELF, r, dest);
        return dest;
    }

/*

=item C<void divide()>

=cut

*/

    MULTI PMC *divide(BigNum value, PMC *dest) {
        BIGNUM *bn;
        if (dest)
            pmc_reuse(interp, dest, SELF->vtable->base_type, 0);
        else
            dest = pmc_new(INTERP, SELF->vtable->base_type);

        bignum_div_bignum(INTERP, SELF, value, dest);
#if 0
        /* to downgrade or not that's the question */
        GETATTR_BigNum_bn(interp, dest, bn);
        if (mpf_fits_slong_p(bn->b)) {
            long iresult = mpf_get_si(bn->b);
            VTABLE_morph(interp, dest, enum_class_Integer);
            VTABLE_set_integer_native(interp, dest, iresult);
        }
#endif
        return dest;
    }

    MULTI PMC *divide(Integer value, PMC *dest) {
        if (dest)
            pmc_reuse(interp, dest, SELF->vtable->base_type, 0);
        else
            dest = pmc_new(INTERP, SELF->vtable->base_type);

        bignum_div_bignum_int(INTERP, SELF, VTABLE_get_integer(interp, value), dest);
        return dest;
    }

    MULTI PMC *divide(DEFAULT value, PMC *dest) {
        Parrot_ex_throw_from_c_args(INTERP, NULL,
            EXCEPTION_INTERNAL_NOT_IMPLEMENTED,
            "BigNum: no multiple dispatch variant 'divide' for %Ss",
            VTABLE_name(interp, value));
    }

    VTABLE PMC *divide_int(INTVAL value, PMC *dest) {
        if (dest)
            pmc_reuse(interp, dest, SELF->vtable->base_type, 0);
        else
            dest = pmc_new(INTERP, SELF->vtable->base_type);

        bignum_div_bignum_int(INTERP, SELF, value, dest);
        return dest;
    }

    MULTI void i_divide(BigNum value) {
        bignum_div_bignum(INTERP, SELF, value, SELF);
    }
    MULTI void i_divide(Integer value) {
        bignum_div_bignum_int(INTERP, SELF, VTABLE_get_integer(interp, value), SELF);
    }
    MULTI void i_divide(DEFAULT value) {
         Parrot_ex_throw_from_c_args(INTERP, NULL,
            EXCEPTION_INTERNAL_NOT_IMPLEMENTED,
            "BigNum: no multiple dispatch variant 'i_divide' for %Ss",
            VTABLE_name(interp, value));
    }

    VTABLE void i_divide_int(INTVAL value) {
        bignum_div_bignum_int(INTERP, SELF, value, SELF);
    }

/*

=item C<void floor_divide()>

=cut

*/

    MULTI PMC *floor_divide(BigNum value, PMC *dest) {
        dest = pmc_new(INTERP, SELF->vtable->base_type);

        bignum_fdiv_bignum(INTERP, SELF, value, dest);
        return dest;
    }

    MULTI PMC *floor_divide(Integer value, PMC *dest) {
        dest = pmc_new(INTERP, SELF->vtable->base_type);

        bignum_fdiv_bignum_int(INTERP, SELF, VTABLE_get_integer(interp, value), dest);
        return dest;
    }

    MULTI PMC *floor_divide(DEFAULT value, PMC *dest) {
        Parrot_ex_throw_from_c_args(INTERP, NULL,
            EXCEPTION_INTERNAL_NOT_IMPLEMENTED,
            "BigNum: no multiple dispatch variant 'floor_divide' for %Ss",
            VTABLE_name(interp, value));
    }

    VTABLE PMC *floor_divide_int(INTVAL value, PMC *dest) {
        if (dest)
            pmc_reuse(interp, dest, SELF->vtable->base_type, 0);
        else
            dest = pmc_new(INTERP, SELF->vtable->base_type);

        bignum_fdiv_bignum_int(INTERP, SELF, value, dest);
        return dest;
    }

    MULTI void i_floor_divide(BigNum value) {
        bignum_fdiv_bignum(INTERP, SELF, value, SELF);
    }

    MULTI void i_floor_divide(Integer value) {
        bignum_fdiv_bignum_int(INTERP, SELF, VTABLE_get_integer(interp, value), SELF);
    }

    MULTI void i_floor_divide(DEFAULT value) {
        Parrot_ex_throw_from_c_args(INTERP, NULL,
            EXCEPTION_INTERNAL_NOT_IMPLEMENTED,
            "BigNum: no multiple dispatch variant 'i_floor_divide' for %Ss",
            VTABLE_name(interp, value));
    }

    VTABLE void i_floor_divide_int(INTVAL value) {
        bignum_fdiv_bignum_int(INTERP, SELF, value, SELF);
    }

/*

=item C<void cmp()>

=cut

*/

    MULTI INTVAL cmp(BigNum value) {
        return bignum_cmp(INTERP, SELF, value);
    }

    MULTI INTVAL cmp(Integer value) {
        return bignum_cmp_int(INTERP, SELF, VTABLE_get_integer(interp, value));
    }

    MULTI INTVAL cmp(DEFAULT value) {
        Parrot_ex_throw_from_c_args(INTERP, NULL,
            EXCEPTION_INTERNAL_NOT_IMPLEMENTED,
            "BigNum: no multiple dispatch variant 'cmp' for %Ss",
            VTABLE_name(interp, value));
    }

/*

=item C<void is_equal()>

=cut

*/

    MULTI INTVAL is_equal(BigNum value) {
        return bignum_cmp(INTERP, SELF, value) == 0;
    }

    MULTI INTVAL is_equal(Integer value) {
        return bignum_cmp_int(INTERP, SELF, VTABLE_get_integer(interp, value)) == 0;
    }

    MULTI INTVAL is_equal(DEFAULT value) {
        Parrot_ex_throw_from_c_args(INTERP, NULL,
            EXCEPTION_INTERNAL_NOT_IMPLEMENTED,
            "BigNum: no multiple dispatch variant 'is_equal' for %Ss",
            VTABLE_name(interp, value));
    }

/*

=item C<PMC *absolute(PMC *dest)>

=item C<void i_absolute()>

Sets C<dest> to the absolute value of SELF.

=cut

*/

    VTABLE PMC *absolute(PMC *dest) {
        dest = pmc_new(INTERP, SELF->vtable->base_type);

        bignum_abs(INTERP, SELF, dest);
        return dest;
    }

    VTABLE void i_absolute() {
        bignum_abs(INTERP, SELF, SELF);
    }


/*

=item C<PMC *neg(PMC *dest)>

=item C<void i_neg()>

Set C<dest> to the negated value of C<SELF>.

=cut

*/

    VTABLE PMC *neg(PMC *dest) {
        dest = pmc_new(INTERP, SELF->vtable->base_type);

        bignum_neg(INTERP, SELF, dest);
        return dest;
    }

    VTABLE void i_neg() {
        bignum_neg(INTERP, SELF, SELF);
    }

}

/*

=back

=cut

*/

/*
 * Local variables:
 *   c-file-style: "parrot"
 * End:
 * vim: expandtab shiftwidth=4:
 */