type stringclasses 5
values | content stringlengths 9 163k |
|---|---|
defines | #define Z_LIMB(x) ((mp_limb_t*)&(Field((x),1))) |
defines | #define Z_SIGN(x) (Z_HEAD((x)) & Z_SIGN_MASK) |
defines | #define Z_SIZE(x) (Z_HEAD((x)) & Z_SIZE_MASK) |
defines | #define Z_MAX_INT 0x3fffffffffffffff |
defines | #define Z_MIN_INT (-0x4000000000000000) |
defines | #define Z_MAX_INT 0x3fffffff |
defines | #define Z_MIN_INT (-0x40000000) |
defines | #define Z_FITS_INT(v) ((v) >= Z_MIN_INT && (v) <= Z_MAX_INT) |
defines | #define Z_MAX_INT_FL 0x3ffffffffffff000 |
defines | #define Z_MIN_INT_FL (-Z_MAX_INT_FL) |
defines | #define Z_MAX_INT_FL Z_MAX_INT |
defines | #define Z_MIN_INT_FL Z_MIN_INT |
defines | #define Z_MAX_HINT 0x3fffffff |
defines | #define Z_MAX_HINT 0x3fff |
defines | #define Z_MIN_HINT (-Z_MAX_HINT) |
defines | #define Z_FITS_HINT(v) ((v) >= Z_MIN_HINT && (v) <= Z_MAX_HINT) |
defines | #define Z_HI_INT32 0x80000000 |
defines | #define Z_HI_INT64 0x8000000000000000LL |
defines | #define Z_HI_INTNAT Z_HI_INT64 |
defines | #define Z_HI_INT 0x4000000000000000 |
defines | #define Z_HI_INTNAT Z_HI_INT32 |
defines | #define Z_HI_INT 0x40000000 |
defines |
#define Z_LIMB_BITS (8 * sizeof(mp_limb_t)) |
defines | #define Z_MARK_OP ml_z_ops++ |
defines | #define Z_MARK_SLOW ml_z_slow++ |
defines | #define Z_MARK_OP |
defines | #define Z_MARK_SLOW |
defines | #define Z_CHECK(v) ml_z_check(__FUNCTION__, __LINE__, #v, v) |
defines | #define Z_CHECK(v) |
defines | #define ml_z_alloc(sz) \ |
defines | #define ml_z_alloc(sz) \ |
defines | #define Z_DECL(arg) \ |
defines |
#define Z_ARG(arg) \ |
defines |
#define Z_REFRESH(arg) \ |
defines |
#define ml_z_raise_divide_by_zero() \ |
defines | #define BITS_PER_WORD 64 |
defines | #define BITS_PER_WORD 32 |
defines | #define caml_hash_mix_uint32(h,n) ((h) * 65599 + (n)) |
functions | void ml_z_dump(const char* msg, mp_limb_t* p, mp_size_t sz)
{
mp_size_t i;
printf("%s %i: ",msg,(int)sz);
for (i = 0; i < sz; i++)
#ifdef ARCH_SIXTYFOUR
printf("%08" PRINTF_LIMB "x ",p[i]);
#else
printf("%04" PRINTF_LIMB "x ",p[i]);
#endif
printf("\n");
fflush(stdout);
} |
functions | void ml_z_check(const char* fn, int line, const char* arg, value v)
{
mp_size_t sz;
if (Is_block(v)) {
#if Z_CUSTOM_BLOCK
if (Custom_ops_val(v) != &ml_z_custom_ops) {
printf("ml_z_check: wrong custom block for %s at %s:%i.\n",
arg, fn, line);
exit(1);
} |
functions | value ml_z_alloc(mp_size_t sz)
{
value v;
#if Z_CUSTOM_BLOCK
v = caml_alloc_custom(&ml_z_custom_ops, (1 + sz + 1) * sizeof(value), 0, 1);
#else
v = caml_alloc(1 + sz + 1, Abstract_tag);
#endif
Z_LIMB(v)[sz] = 0xDEADBEEF ^ sz;
return v;
} |
functions | void ml_z_cpy_limb(mp_limb_t* dst, mp_limb_t* src, mp_size_t sz)
{
memcpy(dst, src, sz * sizeof(mp_limb_t));
} |
functions | value ml_z_reduce(value r, mp_size_t sz, intnat sign)
{
while (sz > 0 && !Z_LIMB(r)[sz-1]) sz--;
#if Z_USE_NATINT
if (!sz) return Val_long(0);
if (sz <= 1 && Z_LIMB(r)[0] <= Z_MAX_INT) {
if (sign) return Val_long(-Z_LIMB(r)[0]);
else return Val_long(Z_LIMB(r)[0]);
} |
functions | void ml_z_raise_overflow()
{
caml_raise_constant(*caml_named_value("ml_z_overflow"));
} |
functions | value ml_z_of_int(value v)
{
#if Z_USE_NATINT
Z_MARK_OP;
return v;
#else
intnat x;
value r;
Z_MARK_OP;
Z_MARK_SLOW;
x = Long_val(v);
r = ml_z_alloc(1);
if (x > 0) { Z_HEAD(r) = 1; Z_LIMB(r)[0] = x; } |
functions | else if (x < 0) { Z_HEAD(r) = 1 | Z_SIGN_MASK; Z_LIMB(r)[0] = -x; } |
functions | value ml_z_of_nativeint(value v)
{
intnat x;
value r;
Z_MARK_OP;
x = Nativeint_val(v);
#if Z_USE_NATINT
if (Z_FITS_INT(x)) return Val_long(x);
#endif
Z_MARK_SLOW;
r = ml_z_alloc(1);
if (x > 0) { Z_HEAD(r) = 1; Z_LIMB(r)[0] = x; } |
functions | else if (x < 0) { Z_HEAD(r) = 1 | Z_SIGN_MASK; Z_LIMB(r)[0] = -x; } |
functions | value ml_z_of_int32(value v)
{
int32_t x;
value r;
Z_MARK_OP;
x = Int32_val(v);
#if Z_USE_NATINT
#ifdef ARCH_SIXTYFOUR
return Val_long(x);
#else
if (Z_FITS_INT(x)) return Val_long(x);
#endif
#endif
Z_MARK_SLOW;
r = ml_z_alloc(1);
if (x > 0) { Z_HEAD(r) = 1; Z_LIMB(r)[0] = x; } |
functions | else if (x < 0) { Z_HEAD(r) = 1 | Z_SIGN_MASK; Z_LIMB(r)[0] = -(mp_limb_t)x; } |
functions | value ml_z_of_int64(value v)
{
int64_t x;
value r;
Z_MARK_OP;
x = Int64_val(v);
#if Z_USE_NATINT
if (Z_FITS_INT(x)) return Val_long(x);
#endif
Z_MARK_SLOW;
#ifdef ARCH_SIXTYFOUR
r = ml_z_alloc(1);
if (x > 0) { Z_HEAD(r) = 1; Z_LIMB(r)[0] = x; } |
functions | else if (x < 0) { Z_HEAD(r) = 1 | Z_SIGN_MASK; Z_LIMB(r)[0] = -x; } |
functions | value ml_z_of_float(value v)
{
double x;
int exp;
int64_t y, m;
value r;
Z_MARK_OP;
x = Double_val(v);
#if Z_USE_NATINT
if (x >= Z_MIN_INT_FL && x <= Z_MAX_INT_FL) return Val_long(x);
#endif
Z_MARK_SLOW;
#ifdef ARCH_ALIGN_INT64
memcpy(&y, (void *) v, 8);
#else
y = *((int64_t*)v);
#endif
exp = ((y ... |
functions | value ml_z_of_string_base(value b, value v)
{
CAMLparam1(v);
CAMLlocal1(r);
char *d = String_val(v);
mp_size_t i, sz, sz2;
mp_limb_t sign = 0;
intnat base = Long_val(b);
/* get optional sign */
if (*d == '-') { sign ^= Z_SIGN_MASK; d++; } |
functions | else if (*d == 'x' || *d == 'X') { base = 16; d++; } |
functions | else if (*d == 'b' || *d == 'B') { base = 2; d++; } |
functions | value ml_z_to_int(value v)
{
intnat x;
Z_DECL(v);
Z_MARK_OP;
Z_CHECK(v);
if (Is_long(v)) return v;
Z_MARK_SLOW;
Z_ARG(v);
if (size_v > 1) ml_z_raise_overflow();
if (!size_v) return Val_long(0);
x = *ptr_v;
if (sign_v) {
if ((uintnat)x > Z_HI_INT) ml_z_raise_overflow();
x = -x;
} |
functions | value ml_z_to_nativeint(value v)
{
intnat x;
Z_DECL(v);
Z_MARK_OP;
Z_CHECK(v);
if (Is_long(v)) return caml_copy_nativeint(Long_val(v));
Z_MARK_SLOW;
Z_ARG(v);
if (size_v > 1) ml_z_raise_overflow();
if (!size_v) x = 0;
else {
x = *ptr_v;
if (sign_v) {
if ((uintnat)x > Z_HI_INTNAT) ml_z... |
functions | value ml_z_to_int32(value v)
{
intnat x;
Z_DECL(v);
Z_MARK_OP;
Z_CHECK(v);
if (Is_long(v)) {
x = Long_val(v);
#ifdef ARCH_SIXTYFOUR
if (x >= (intnat)Z_HI_INT32 || x < -(intnat)Z_HI_INT32)
ml_z_raise_overflow();
#endif
return caml_copy_int32(x);
} |
functions | value ml_z_to_int64(value v)
{
int64_t x = 0;
Z_DECL(v);
Z_MARK_OP;
Z_CHECK(v);
if (Is_long(v)) return caml_copy_int64(Long_val(v));
Z_MARK_SLOW;
Z_ARG(v);
switch (size_v) {
case 0: x = 0; break;
case 1: x = ptr_v[0]; break;
#ifndef ARCH_SIXTYFOUR
case 2: x = ptr_v[0] | ((uint64_t)ptr_v[1] << 32... |
functions | value ml_z_to_float(value v)
{
double x, m;
mp_size_t i;
Z_DECL(v);
Z_MARK_OP;
Z_CHECK(v);
if (Is_long(v)) return caml_copy_double(Long_val(v));
Z_MARK_SLOW;
Z_ARG(v);
m = sign_v ? -1. : 1.;
x = 0.;
for (i = 0; i < size_v; i++) {
#ifdef ARCH_SIXTYFOUR
/* split into two 32-bit numbers, as 64-bi... |
functions | value ml_z_format(value f, value v)
{
CAMLparam2(f,v);
Z_DECL(v);
const char tab[2][16] =
{ { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' } |
functions | value ml_z_extract(value arg, value off, value len)
{
intnat o, l, x;
mp_size_t sz, c1, c2, csz, i;
mp_limb_t cr;
value r;
Z_DECL(arg);
Z_MARK_OP;
o = Long_val(off);
l = Long_val(len);
if (o < 0) caml_invalid_argument("Z.extract: negative bit offset");
if (l <= 0) caml_invalid_argument("Z.extract: n... |
functions | value ml_z_to_bits(value arg)
{
CAMLparam1(arg);
CAMLlocal1(r);
Z_DECL(arg);
mp_size_t i;
unsigned char* p;
Z_MARK_OP;
Z_MARK_SLOW;
Z_ARG(arg);
r = caml_alloc_string(size_arg * sizeof(mp_limb_t));
Z_REFRESH(arg);
p = (unsigned char*) String_val(r);
memset(p, 0, size_arg * sizeof(mp_limb_t));
f... |
functions | value ml_z_of_bits(value arg)
{
CAMLparam1(arg);
CAMLlocal1(r);
mp_size_t sz, szw;
mp_size_t i = 0;
mp_limb_t x;
unsigned char* p;
Z_MARK_OP;
Z_MARK_SLOW;
sz = caml_string_length(arg);
szw = (sz + sizeof(mp_limb_t) - 1) / sizeof(mp_limb_t);
r = ml_z_alloc(szw);
p = (unsigned char*) String_val(ar... |
functions | value ml_z_compare(value arg1, value arg2)
{
int r;
Z_DECL(arg1); Z_DECL(arg2);
Z_MARK_OP;
Z_CHECK(arg1); Z_CHECK(arg2);
#if Z_FAST_PATH
if (Is_long(arg1) && Is_long(arg2)) {
/* fast path */
if (arg1 > arg2) return Val_long(1);
else if (arg1 < arg2) return Val_long(-1);
else return Val_long(0)... |
functions | value ml_z_equal(value arg1, value arg2)
{
mp_size_t i;
Z_DECL(arg1); Z_DECL(arg2);
Z_MARK_OP;
Z_CHECK(arg1); Z_CHECK(arg2);
#if Z_FAST_PATH
if (Is_long(arg1) && Is_long(arg2)) {
/* fast path */
return (arg1 == arg2) ? Val_true : Val_false;
} |
functions | int ml_z_sgn(value arg)
{
if (Is_long(arg)) {
if (arg > Val_long(0)) return 1;
else if (arg < Val_long(0)) return -1;
else return 0;
} |
functions | value ml_z_sign(value arg)
{
Z_MARK_OP;
Z_CHECK(arg);
return Val_long(ml_z_sgn(arg));
} |
functions | value ml_z_fits_int(value v)
{
intnat x;
Z_DECL(v);
Z_MARK_OP;
Z_CHECK(v);
if (Is_long(v)) return Val_true;
Z_MARK_SLOW;
Z_ARG(v);
if (size_v > 1) return Val_false;
if (!size_v) return Val_true;
x = *ptr_v;
if (sign_v) {
if ((uintnat)x > Z_HI_INT) return Val_false;
} |
functions | value ml_z_fits_nativeint(value v)
{
intnat x;
Z_DECL(v);
Z_MARK_OP;
Z_CHECK(v);
if (Is_long(v)) return Val_true;
Z_MARK_SLOW;
Z_ARG(v);
if (size_v > 1) return Val_false;
if (!size_v) return Val_true;
x = *ptr_v;
if (sign_v) {
if ((uintnat)x > Z_HI_INTNAT) return Val_false;
} |
functions | value ml_z_fits_int32(value v)
{
intnat x;
Z_MARK_OP;
Z_CHECK(v);
if (Is_long(v)) {
#ifdef ARCH_SIXTYFOUR
x = Long_val(v);
if (x >= (intnat)Z_HI_INT32 || x < -(intnat)Z_HI_INT32)
return Val_false;
#endif
return Val_true;
} |
functions | value ml_z_fits_int64(value v)
{
int64_t x;
Z_DECL(v);
Z_MARK_OP;
Z_CHECK(v);
if (Is_long(v)) return Val_true;
Z_MARK_SLOW;
Z_ARG(v);
switch (size_v) {
case 0: return Val_true;
case 1: x = ptr_v[0]; break;
#ifndef ARCH_SIXTYFOUR
case 2: x = ptr_v[0] | ((uint64_t)ptr_v[1] << 32); break;
#endif
... |
functions | value ml_z_size(value v)
{
Z_MARK_OP;
if (Is_long(v)) return Val_long(1);
else return Val_long(Z_SIZE(v));
} |
functions | value ml_z_neg(value arg)
{
Z_MARK_OP;
Z_CHECK(arg);
#if Z_FAST_PATH && !defined(Z_ASM_neg)
if (Is_long(arg)) {
/* fast path */
if (arg > Val_long(Z_MIN_INT)) return 2 - arg;
} |
functions | value ml_z_abs(value arg)
{
Z_MARK_OP;
Z_CHECK(arg);
#if Z_FAST_PATH && !defined(Z_ASM_abs)
if (Is_long(arg)) {
/* fast path */
if (arg >= Val_long(0)) return arg;
if (arg > Val_long(Z_MIN_INT)) return 2 - arg;
} |
functions | value ml_z_addsub(value arg1, value arg2, intnat sign)
{
CAMLparam2(arg1,arg2);
Z_DECL(arg1); Z_DECL(arg2);
value r;
mp_limb_t c;
Z_ARG(arg1);
Z_ARG(arg2);
sign_arg2 ^= sign;
if (!size_arg2) r = arg1;
else if (!size_arg1) {
if (sign) {
/* negation */
r = ml_z_alloc(size_arg2);
Z_... |
functions | else if (sign_arg1 == sign_arg2) {
/* addition */
if (size_arg1 >= size_arg2) {
r = ml_z_alloc(size_arg1 + 1);
Z_REFRESH(arg1);
Z_REFRESH(arg2);
c = mpn_add(Z_LIMB(r), ptr_arg1, size_arg1, ptr_arg2, size_arg2);
Z_LIMB(r)[size_arg1] = c;
r = ml_z_reduce(r, size_arg1+1, sign_ar... |
functions | else if (size_arg1 < size_arg2) {
r = ml_z_alloc(size_arg2);
Z_REFRESH(arg1);
Z_REFRESH(arg2);
mpn_sub(Z_LIMB(r), ptr_arg2, size_arg2, ptr_arg1, size_arg1);
r = ml_z_reduce(r, size_arg2, sign_arg2);
} |
functions | else if (cmp < 0) {
r = ml_z_alloc(size_arg1);
Z_REFRESH(arg1);
Z_REFRESH(arg2);
mpn_sub_n(Z_LIMB(r), ptr_arg2, ptr_arg1, size_arg1);
r = ml_z_reduce(r, size_arg1, sign_arg2);
} |
functions | value ml_z_add(value arg1, value arg2)
{
Z_MARK_OP;
Z_CHECK(arg1); Z_CHECK(arg2);
#if Z_FAST_PATH && !defined(Z_ASM_add)
if (Is_long(arg1) && Is_long(arg2)) {
/* fast path */
intnat a1 = Long_val(arg1);
intnat a2 = Long_val(arg2);
intnat v = a1 + a2;
if (Z_FITS_INT(v)) return Val_long(v);
} |
functions | value ml_z_sub(value arg1, value arg2)
{
Z_MARK_OP;
Z_CHECK(arg1); Z_CHECK(arg2);
#if Z_FAST_PATH && !defined(Z_ASM_sub)
if (Is_long(arg1) && Is_long(arg2)) {
/* fast path */
intnat a1 = Long_val(arg1);
intnat a2 = Long_val(arg2);
intnat v = a1 - a2;
if (Z_FITS_INT(v)) return Val_long(v);
} |
functions | value ml_z_mul(value arg1, value arg2)
{
Z_DECL(arg1); Z_DECL(arg2);
Z_MARK_OP;
Z_CHECK(arg1); Z_CHECK(arg2);
#if Z_FAST_PATH && !defined(Z_ASM_mul)
if (Is_long(arg1) && Is_long(arg2)) {
/* fast path */
intnat a1 = Long_val(arg1);
intnat a2 = Long_val(arg2);
if (!a1 || !a2) return Val_long(0);
... |
functions | else if (size_arg1 == 1) {
c = mpn_mul_1(Z_LIMB(r), ptr_arg2, size_arg2, *ptr_arg1);
Z_LIMB(r)[size_arg2] = c;
} |
functions | else if (size_arg2 == 2) {
c = mpn_mul_2(Z_LIMB(r), ptr_arg1, size_arg1, ptr_arg2);
Z_LIMB(r)[size_arg1 + 1] = c;
} |
functions | else if (size_arg1 == 2) {
c = mpn_mul_2(Z_LIMB(r), ptr_arg2, size_arg2, ptr_arg1);
Z_LIMB(r)[size_arg2 + 1] = c;
} |
functions | value ml_z_tdiv_qr(value arg1, value arg2)
{
CAMLparam2(arg1, arg2);
CAMLlocal3(q, r, p);
Z_DECL(arg1); Z_DECL(arg2);
Z_ARG(arg1); Z_ARG(arg2);
if (!size_arg2) ml_z_raise_divide_by_zero();
if (size_arg1 >= size_arg2) {
q = ml_z_alloc(size_arg1 - size_arg2 + 1);
r = ml_z_alloc(size_arg2);
Z_REFR... |
functions | value ml_z_div_rem(value arg1, value arg2)
{
Z_MARK_OP;
Z_CHECK(arg1); Z_CHECK(arg2);
#if Z_FAST_PATH
if (Is_long(arg1) && Is_long(arg2)) {
/* fast path */
intnat a1 = Long_val(arg1);
intnat a2 = Long_val(arg2);
intnat q, r;
if (!a2) ml_z_raise_divide_by_zero();
q = a1 / a2;
r = a1 % a... |
functions | value ml_z_div(value arg1, value arg2)
{
Z_MARK_OP;
Z_CHECK(arg1); Z_CHECK(arg2);
#if Z_FAST_PATH && !defined(Z_ASM_div)
if (Is_long(arg1) && Is_long(arg2)) {
/* fast path */
intnat a1 = Long_val(arg1);
intnat a2 = Long_val(arg2);
intnat q;
if (!a2) ml_z_raise_divide_by_zero();
q = a1 / a2... |
functions | value ml_z_rem(value arg1, value arg2)
{
Z_MARK_OP;
Z_CHECK(arg1); Z_CHECK(arg2);
#if Z_FAST_PATH && !defined(Z_ASM_rem)
if (Is_long(arg1) && Is_long(arg2)) {
/* fast path */
intnat a1 = Long_val(arg1);
intnat a2 = Long_val(arg2);
intnat r;
if (!a2) ml_z_raise_divide_by_zero();
r = a1 % a2... |
functions | value ml_z_rdiv(value arg1, value arg2, intnat dir)
{
CAMLparam2(arg1, arg2);
CAMLlocal2(q, r);
Z_DECL(arg1); Z_DECL(arg2);
Z_ARG(arg1); Z_ARG(arg2);
if (!size_arg2) ml_z_raise_divide_by_zero();
if (size_arg1 >= size_arg2) {
mp_limb_t c = 0;
q = ml_z_alloc(size_arg1 - size_arg2 + 2);
r = ml_z_a... |
functions | value ml_z_cdiv(value arg1, value arg2)
{
Z_MARK_OP;
Z_CHECK(arg1); Z_CHECK(arg2);
#if Z_FAST_PATH
if (Is_long(arg1) && Is_long(arg2)) {
/* fast path */
intnat a1 = Long_val(arg1);
intnat a2 = Long_val(arg2);
intnat q;
if (!a2) ml_z_raise_divide_by_zero();
/* adjust to round towards +oo */... |
functions | value ml_z_fdiv(value arg1, value arg2)
{
Z_MARK_OP;
Z_CHECK(arg1); Z_CHECK(arg2);
#if Z_FAST_PATH
if (Is_long(arg1) && Is_long(arg2)) {
/* fast path */
intnat a1 = Long_val(arg1);
intnat a2 = Long_val(arg2);
intnat q;
if (!a2) ml_z_raise_divide_by_zero();
/* adjust to round towards -oo */... |
functions | value ml_z_succpred(value arg, intnat sign)
{
CAMLparam1(arg);
Z_DECL(arg);
value r;
Z_ARG(arg);
r = ml_z_alloc(size_arg + 1);
Z_REFRESH(arg);
if (!size_arg) {
Z_LIMB(r)[0] = 1;
r = ml_z_reduce(r, 1, sign);
} |
functions | else if (sign_arg == sign) {
/* add 1 */
mp_limb_t c = mpn_add_1(Z_LIMB(r), ptr_arg, size_arg, 1);
Z_LIMB(r)[size_arg] = c;
r = ml_z_reduce(r, size_arg + 1, sign_arg);
} |
functions | value ml_z_succ(value arg)
{
Z_MARK_OP;
Z_CHECK(arg);
#if Z_FAST_PATH && !defined(Z_ASM_succ)
if (Is_long(arg)) {
/* fast path */
if (arg < Val_long(Z_MAX_INT)) return arg + 2;
} |
functions | value ml_z_pred(value arg)
{
Z_MARK_OP;
Z_CHECK(arg);
#if Z_FAST_PATH && !defined(Z_ASM_pred)
if (Is_long(arg)) {
/* fast path */
if (arg > Val_long(Z_MIN_INT)) return arg - 2;
} |
functions | value ml_z_sqrt(value arg)
{
/* XXX TODO: fast path */
CAMLparam1(arg);
Z_DECL(arg);
value r;
Z_MARK_OP;
Z_MARK_SLOW;
Z_CHECK(arg);
Z_ARG(arg);
if (sign_arg)
caml_invalid_argument("Z.sqrt: square root of a negative number");
if (size_arg) {
mp_size_t sz = (size_arg + 1) / 2;
r = ml_z_al... |
functions | value ml_z_sqrt_rem(value arg)
{
CAMLparam1(arg);
CAMLlocal3(r, s, p);
Z_DECL(arg);
/* XXX TODO: fast path */
Z_MARK_OP;
Z_MARK_SLOW;
Z_CHECK(arg);
Z_ARG(arg);
if (sign_arg)
caml_invalid_argument("Z.sqrt_rem: square root of a negative number");
if (size_arg) {
mp_size_t sz = (size_arg + 1) ... |
functions | value ml_z_gcd(value arg1, value arg2)
{
Z_MARK_OP;
Z_CHECK(arg1); Z_CHECK(arg2);
#if Z_FAST_PATH
if (Is_long(arg1) && Is_long(arg2)) {
/* fast path */
intnat a1 = Long_val(arg1);
intnat a2 = Long_val(arg2);
if (!a1 || !a2) ml_z_raise_divide_by_zero();
if (a1 < 0) a1 = -a1;
if (a2 < 0) a2 ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.