/*
* call-seq:
* GMP::RandState.new()
* GMP::RandState.new(:mt) #=> uses gmp_randinit_mt
* GMP::RandState.new(:lc_2exp, a, c, m2exp) #=> uses gmp_randinit_lc_2exp
* GMP::RandState.new(:lc_2exp_size, size) #=> uses gmp_randinit_lc_2exp_size
*
* Initializes a new Random State object. Multiple GMP::RandState objects can
* be instantiated. They may use different generators and the states
* are kept separate.
*/
VALUE r_gmprandstatesg_new(int argc, VALUE *argv, VALUE klass)
{
MP_RANDSTATE *rs_val;
VALUE rs;
VALUE algorithm, arg2, arg3, arg4;
ID algorithm_id = rb_intern("default");
MP_INT *a_val;
unsigned long c_val, m2exp_val;
unsigned long size_val;
int free_a_val = 0;
ID default_algorithm = rb_intern("default");
ID mt_algorithm = rb_intern("mt");
ID lc_2exp_algorithm = rb_intern("lc_2exp");
ID lc_2exp_size_algorithm = rb_intern("lc_2exp_size");
(void)klass;
mprandstate_make_struct(rs, rs_val);
rb_scan_args(argc, argv, "04", &algorithm, &arg2, &arg3, &arg4);
if (NIL_P(algorithm)) { algorithm_id = rb_intern("default"); } /* default value */
if (SYMBOL_P(algorithm)) { algorithm_id = rb_to_id(algorithm); }
if (algorithm_id == default_algorithm ||
algorithm_id == mt_algorithm) {
if (argc > 1)
rb_raise(rb_eArgError, "wrong # of arguments (%d for 0 or 1)", argc);
gmp_randinit_default(rs_val);
} else if (algorithm_id == lc_2exp_algorithm) {
if (argc != 4)
rb_raise(rb_eArgError, "wrong # of arguments (%d for 4)", argc);
if (GMPZ_P(arg2)) {
mpz_get_struct(arg2, a_val);
} else if (FIXNUM_P(arg2)) {
mpz_temp_alloc(a_val);
mpz_init_set_ui(a_val, FIX2INT(arg2));
free_a_val = 1;
} else if (BIGNUM_P(arg2)) {
mpz_temp_from_bignum(a_val, arg2);
free_a_val = 1;
} else {
typeerror_as(ZXB, "b");
}
c_val = NUM2LONG(arg3);
m2exp_val = NUM2LONG(arg4);
gmp_randinit_lc_2exp(rs_val, a_val, c_val, m2exp_val);
} else if (algorithm_id == lc_2exp_size_algorithm) {
if (argc != 2)
rb_raise(rb_eArgError, "wrong # of arguments (%d for 2)", argc);
size_val = NUM2LONG(arg2);
if (size_val > 128)
rb_raise(rb_eArgError, "size must be within [0..128]");
if (gmp_randinit_lc_2exp_size (rs_val, size_val) == 0)
rb_raise(rb_eArgError, "could not gmp_randinit_lc_2exp_size with %lu", size_val);
}
if (free_a_val) { mpz_temp_free(a_val); }
rb_obj_call_init(rs, argc, argv);
return rs;
}
inline static VALUE
f_div(VALUE x, VALUE y)
{
if (FIXNUM_P(y) && FIX2LONG(y) == 1)
return x;
return rb_funcall(x, '/', 1, y);
}
/*
* call-seq:
* rand_state.urandomm(integer)
*
* From the GMP Manual:
*
* Generate a uniformly distributed random integer in the range 0 to
* _integer-1_, inclusive. _integer_ can be an instance of GMP::Z,
* Fixnum, or Bignum
*/
VALUE r_gmprandstate_urandomm(VALUE self, VALUE arg)
{
MP_RANDSTATE *self_val;
MP_INT *res_val, *arg_val;
int free_arg_val = 0;
VALUE res;
mprandstate_get_struct(self,self_val);
if (GMPZ_P(arg)) {
mpz_get_struct(arg, arg_val);
} else if (FIXNUM_P(arg)) {
mpz_temp_alloc(arg_val);
mpz_init_set_ui(arg_val, FIX2INT(arg));
free_arg_val = 1;
} else if (BIGNUM_P(arg)) {
mpz_temp_from_bignum(arg_val, arg);
free_arg_val = 1;
} else {
typeerror_as(ZXB, "arg");
}
mpz_make_struct_init(res, res_val);
mpz_urandomm(res_val, self_val, arg_val);
if (free_arg_val) { mpz_temp_free(arg_val); }
return res;
}
inline static VALUE
f_zero_p(VALUE x)
{
if (FIXNUM_P(x))
return f_boolcast(FIX2LONG(x) == 0);
return rb_funcall(x, id_equal_p, 1, ZERO);
}
/** call-seq: time = time
Set the timestamp as removal condition.
Parameters:
[time] an integer, for specifying ticks, or a tuple of splat of seconds and nanoseconds
Normally used with the flags +SND_SEQ_REMOVE_TIME_AFTER+ or +SND_SEQ_REMOVE_TIME_BEFORE+.
See RRTS::Driver::AlsaRemoveClass_i#condition=.
*/
static VALUE
wrap_snd_seq_remove_events_set_time(int argc, VALUE *argv, VALUE v_rmp)
{
snd_seq_remove_events_t *rmp;
Data_Get_Struct(v_rmp, snd_seq_remove_events_t, rmp);
VALUE v_sec, v_nsec;
rb_scan_args(argc, argv, "11", &v_sec, &v_nsec);
snd_seq_timestamp_t time;
if (NIL_P(v_nsec))
{
if (FIXNUM_P(v_sec))
time.tick = NUM2UINT(v_sec);
else
{
v_sec = rb_check_array_type(v_sec);
if (!RTEST(v_sec)) RAISE_MIDI_ERROR_FMT0("API call error: bad time format");
time.time.tv_sec = NUM2UINT(rb_ary_entry(v_sec, 0));
time.time.tv_nsec = NUM2UINT(rb_ary_entry(v_sec, 1));
}
}
else
{
time.time.tv_sec = NUM2UINT(v_sec);
time.time.tv_nsec = NUM2UINT(v_nsec);
}
snd_seq_remove_events_set_time(rmp, &time);
return Qnil;
}
inline static VALUE
f_one_p(VALUE x)
{
if (FIXNUM_P(x))
return f_boolcast(FIX2LONG(x) == 1);
return rb_funcall(x, id_equal_p, 1, ONE);
}
inline static VALUE
f_negative_p(VALUE x)
{
if (FIXNUM_P(x))
return f_boolcast(FIX2LONG(x) < 0);
return rb_funcall(x, '<', 1, ZERO);
}
inline static VALUE
f_sub(VALUE x, VALUE y)
{
if (FIXNUM_P(y) && FIX2LONG(y) == 0)
return x;
return rb_funcall(x, '-', 1, y);
}
static VALUE
console_key_pressed_p(VALUE io, VALUE k)
{
int vk = -1;
if (FIXNUM_P(k)) {
vk = NUM2UINT(k);
}
else {
const struct vktable *t;
const char *kn;
if (SYMBOL_P(k)) {
k = rb_sym2str(k);
kn = RSTRING_PTR(k);
}
else {
kn = StringValuePtr(k);
}
t = console_win32_vk(kn, RSTRING_LEN(k));
if (!t || (vk = (short)t->vk) == -1) {
rb_raise(rb_eArgError, "unknown virtual key code: % "PRIsVALUE, k);
}
}
return GetKeyState(vk) & 0x80 ? Qtrue : Qfalse;
}
/*
* call-seq:
* rand_state.mpfr_urandomb()
*
* From the MPFR Manual:
*
* Generate a uniformly distributed random float in the interval 0 <= rop < 1.
*/
VALUE r_gmprandstate_mpfr_urandomb(int argc, VALUE *argv, VALUE self)
{
MP_RANDSTATE *self_val;
MP_FLOAT *res_val;
VALUE res;
unsigned long prec = 0;
if (argc > 1)
rb_raise (rb_eArgError, "wrong # of arguments(%d for 0 or 1)", argc);
mprandstate_get_struct (self,self_val);
if (argc == 1) {
if (FIXNUM_P (argv[0])) {
if (FIX2INT (argv[0]) >= 0)
prec = FIX2INT (argv[0]);
else
rb_raise (rb_eRangeError, "prec must be non-negative");
} else {
rb_raise (rb_eTypeError, "prec must be a Fixnum");
}
}
mpf_make_struct (res, res_val);
if (prec == 0) { mpf_init (res_val); }
else { mpf_init2 (res_val, prec); }
mpfr_urandomb (res_val, self_val);
return res;
}
const char *
rb_builtin_class_name(VALUE x)
{
const char *etype;
if (NIL_P(x)) {
etype = "nil";
}
else if (FIXNUM_P(x)) {
etype = "Fixnum";
}
else if (SYMBOL_P(x)) {
etype = "Symbol";
}
else if (RB_TYPE_P(x, T_TRUE)) {
etype = "true";
}
else if (RB_TYPE_P(x, T_FALSE)) {
etype = "false";
}
else {
etype = rb_obj_classname(x);
}
return etype;
}
VALUE
subIconDrawPoint(int argc,
VALUE *argv,
VALUE self)
{
VALUE data[4] = { Qnil };
rb_scan_args(argc, argv, "22", &data[0], &data[1], &data[2], &data[3]);
/* Check object types */
if(FIXNUM_P(data[0]) && FIXNUM_P(data[1]))
{
SubtlextIcon *i = NULL;
Data_Get_Struct(self, SubtlextIcon, i);
if(i)
{
XGCValues gvals;
/* Create on demand */
if(0 == i->gc)
i->gc = XCreateGC(display, i->pixmap, 0, NULL);
/* Update GC */
gvals.foreground = 1;
gvals.background = 0;
if(i->flags & ICON_PIXMAP)
{
if(!NIL_P(data[2]))
gvals.foreground = subColorPixel(data[2], Qnil, Qnil, NULL);
if(!NIL_P(data[3]))
gvals.background = subColorPixel(data[3], Qnil, Qnil, NULL);
}
XChangeGC(display, i->gc, GCForeground|GCBackground, &gvals);
XDrawPoint(display, i->pixmap, i->gc,
FIX2INT(data[0]), FIX2INT(data[1]));
XFlush(display);
}
}
else rb_raise(rb_eArgError, "Unexpected value-types");
return Qnil;
} /* }}} */
static VALUE
range_each(VALUE range)
{
VALUE beg, end;
RETURN_SIZED_ENUMERATOR(range, 0, 0, range_enum_size);
beg = RANGE_BEG(range);
end = RANGE_END(range);
if (FIXNUM_P(beg) && FIXNUM_P(end)) { /* fixnums are special */
long lim = FIX2LONG(end);
long i;
if (!EXCL(range))
lim += 1;
for (i = FIX2LONG(beg); i < lim; i++) {
rb_yield(LONG2FIX(i));
}
}
else if (SYMBOL_P(beg) && SYMBOL_P(end)) { /* symbols are special */
VALUE args[2];
args[0] = rb_sym_to_s(end);
args[1] = EXCL(range) ? Qtrue : Qfalse;
rb_block_call(rb_sym_to_s(beg), rb_intern("upto"), 2, args, sym_each_i, 0);
}
else {
VALUE tmp = rb_check_string_type(beg);
if (!NIL_P(tmp)) {
VALUE args[2];
args[0] = end;
args[1] = EXCL(range) ? Qtrue : Qfalse;
rb_block_call(tmp, rb_intern("upto"), 2, args, each_i, 0);
}
else {
if (!discrete_object_p(beg)) {
rb_raise(rb_eTypeError, "can't iterate from %s",
rb_obj_classname(beg));
}
range_each_func(range, each_i, 0);
}
}
return range;
}
static VALUE
range_include(VALUE range, VALUE val)
{
VALUE beg = RANGE_BEG(range);
VALUE end = RANGE_END(range);
int nv = FIXNUM_P(beg) || FIXNUM_P(end) ||
rb_obj_is_kind_of(beg, rb_cNumeric) ||
rb_obj_is_kind_of(end, rb_cNumeric);
if (nv ||
!NIL_P(rb_check_to_integer(beg, "to_int")) ||
!NIL_P(rb_check_to_integer(end, "to_int"))) {
if (r_le(beg, val)) {
if (EXCL(range)) {
if (r_lt(val, end))
return Qtrue;
}
else {
if (r_le(val, end))
return Qtrue;
}
}
return Qfalse;
}
else if (TYPE(beg) == T_STRING && TYPE(end) == T_STRING &&
RSTRING_LEN(beg) == 1 && RSTRING_LEN(end) == 1) {
if (NIL_P(val)) return Qfalse;
if (TYPE(val) == T_STRING) {
if (RSTRING_LEN(val) == 0 || RSTRING_LEN(val) > 1)
return Qfalse;
else {
char b = RSTRING_PTR(beg)[0];
char e = RSTRING_PTR(end)[0];
char v = RSTRING_PTR(val)[0];
if (ISASCII(b) && ISASCII(e) && ISASCII(v)) {
if (b <= v && v < e) return Qtrue;
if (!EXCL(range) && v == e) return Qtrue;
return Qfalse;
}
}
}
}
/* TODO: ruby_frame->this_func = rb_intern("include?"); */
return rb_call_super(1, &val);
}
PRIMITIVE VALUE
vm_fast_minus(VALUE left, VALUE right, unsigned char overriden)
{
if (overriden == 0 && NUMERIC_IMM_P(left) && NUMERIC_IMM_P(right)) {
if (FIXNUM_P(left) && FIXNUM_P(right)) {
const long res = FIX2LONG(left) - FIX2LONG(right);
if (FIXABLE(res)) {
return LONG2FIX(res);
}
}
else {
const double res = IMM2DBL(left) - IMM2DBL(right);
return DBL2FIXFLOAT(res);
}
}
return vm_dispatch(0, left, selMINUS, NULL, 0, 1, &right);
}
OBJECT float_coerce(STATE, OBJECT value) {
if(FIXNUM_P(value)) {
return float_new(state, (double)N2I(value));
} else if(BIGNUM_P(value)) {
return float_new(state, bignum_to_double(state, value));
}
return value;
}
static VALUE
backend_initialize(VALUE rb_obj, VALUE mysql_host, VALUE mysql_user, VALUE mysql_passwd, VALUE mysql_db, VALUE mysql_table_name, VALUE mysql_storage_engine, VALUE mysql_port, VALUE mysql_unix_socket, VALUE mysql_client_flag)
{
git_odb *odb;
git_odb_backend *backend;
int error;
char *error_msg;
if (!FIXNUM_P(mysql_port)) {
rb_raise(rb_eArgError, "MySQL port must be a Fixnum");
}
if (!FIXNUM_P(mysql_client_flag)) {
rb_raise(rb_eArgError, "MySQL client flag must be a Fixnum");
}
error =
git_odb_backend_mysql(
&backend,
StringValuePtr(mysql_host),
StringValuePtr(mysql_user),
StringValuePtr(mysql_passwd),
StringValuePtr(mysql_db),
StringValuePtr(mysql_table_name),
StringValuePtr(mysql_storage_engine),
FIX2INT(mysql_port),
StringValuePtr(mysql_unix_socket),
NUM2ULONG(mysql_client_flag),
&error_msg);
if (error != 0) {
if (*error_msg == 0) {
rb_raise(rb_eRuntimeError, "An error occurred when trying to connect to the database");
}
else {
rb_raise(rb_eRuntimeError, "%s", error_msg);
}
}
git_odb_new(&odb);
git_odb_add_backend(odb, backend, 10);
DATA_PTR(rb_obj) = odb;
return rb_obj;
}
static VALUE
printf_test_call(int argc, VALUE *argv, VALUE self)
{
VALUE opt, type, num, result;
char format[sizeof(int) * 6 + 8], *p = format, cnv;
int n;
const char *s;
rb_scan_args(argc, argv, "2:", &type, &num, &opt);
Check_Type(type, T_STRING);
if (RSTRING_LEN(type) != 1) rb_raise(rb_eArgError, "wrong length(%ld)", RSTRING_LEN(type));
switch (cnv = RSTRING_PTR(type)[0]) {
case 'd': case 'x': case 'o': case 'X':
n = NUM2INT(num);
break;
case 's':
s = StringValueCStr(num);
break;
default: rb_raise(rb_eArgError, "wrong conversion(%c)", cnv);
}
*p++ = '%';
if (!NIL_P(opt)) {
VALUE v;
Check_Type(opt, T_HASH);
if (RTEST(rb_hash_aref(opt, ID2SYM(rb_intern("space"))))) {
*p++ = ' ';
}
if (RTEST(rb_hash_aref(opt, ID2SYM(rb_intern("hash"))))) {
*p++ = '#';
}
if (RTEST(rb_hash_aref(opt, ID2SYM(rb_intern("plus"))))) {
*p++ = '+';
}
if (RTEST(rb_hash_aref(opt, ID2SYM(rb_intern("minus"))))) {
*p++ = '-';
}
if (RTEST(rb_hash_aref(opt, ID2SYM(rb_intern("zero"))))) {
*p++ = '0';
}
if (!NIL_P(v = rb_hash_aref(opt, ID2SYM(rb_intern("width"))))) {
p = utoa(p, format + sizeof(format), NUM2UINT(v));
}
if (!NIL_P(v = rb_hash_aref(opt, ID2SYM(rb_intern("prec"))))) {
*p++ = '.';
if (FIXNUM_P(v))
p = utoa(p, format + sizeof(format), NUM2UINT(v));
}
}
*p++ = cnv;
*p++ = '\0';
if (cnv == 's') {
result = rb_enc_sprintf(rb_usascii_encoding(), format, s);
}
else {
result = rb_enc_sprintf(rb_usascii_encoding(), format, n);
}
return rb_assoc_new(result, rb_usascii_str_new_cstr(format));
}
VALUE board_subscript( int argc, VALUE *argv, VALUE self ) {
if( argc == 2 && FIXNUM_P(argv[0]) && FIXNUM_P(argv[1]) ) {
return board_get( self, argv[0], argv[1] );
}
else if( argc == 1 ) {
return board_get_coord( self, argv[0] );
}
else {
VALUE ary = rb_ary_new2( argc );
int i;
for( i = 0; i < argc; i++ ) {
rb_ary_push( ary, board_get_coord( self, argv[i] ) );
}
return ary;
}
return Qnil;
}
/*
* テーブルの _id_ または _key_ に対応するレコードを削除する。
*
* @overload delete(id)
* @overload delete(key)
*/
static VALUE
rb_grn_table_key_support_delete (VALUE self, VALUE rb_id_or_key)
{
if (FIXNUM_P(rb_id_or_key)) {
return rb_grn_table_delete(self, rb_id_or_key);
} else {
return rb_grn_table_key_support_delete_by_key(self, rb_id_or_key);
}
}
inline static VALUE
f_one_p(VALUE x)
{
if (RB_TYPE_P(x, T_FIXNUM)) {
return f_boolcast(FIX2LONG(x) == 1);
}
else if (RB_TYPE_P(x, T_BIGNUM)) {
return Qfalse;
}
else if (RB_TYPE_P(x, T_RATIONAL)) {
VALUE num = RRATIONAL(x)->num;
VALUE den = RRATIONAL(x)->den;
return f_boolcast(FIXNUM_P(num) && FIX2LONG(num) == 1 &&
FIXNUM_P(den) && FIX2LONG(den) == 1);
}
return rb_funcall(x, id_eqeq_p, 1, ONE);
}
inline static VALUE
f_sub(VALUE x, VALUE y)
{
#ifndef PRESERVE_SIGNEDZERO
if (FIXNUM_P(y) && FIX2LONG(y) == 0)
return x;
#endif
return rb_funcall(x, '-', 1, y);
}
void
get_int_ensure(VALUE value, int& i) {
if (FIXNUM_P(value) == 0) {
rb_raise(rb_eRuntimeError, "Bad fixnum value.");
}
Check_Type(value, T_FIXNUM);
i = FIX2INT(value);
}
static VALUE rb_ool_conmin_constraint_set_n(VALUE obj, VALUE n)
{
ool_conmin_constraint *C;
if (!FIXNUM_P(n)) rb_raise(rb_eArgError, "Wrong argument type %s (Fixnum expected)",
rb_class2name(CLASS_OF(n)));
Data_Get_Struct(obj, ool_conmin_constraint, C);
C->n = (size_t) FIX2INT(n);
return n;
}
static VALUE
lazy_take_size(VALUE generator, VALUE args, VALUE lazy)
{
VALUE receiver = lazy_size(lazy);
long len = NUM2LONG(RARRAY_AREF(rb_ivar_get(lazy, id_arguments), 0));
if (NIL_P(receiver) || (FIXNUM_P(receiver) && FIX2LONG(receiver) < len))
return receiver;
return LONG2NUM(len);
}
static VALUE
apply_actions(VALUE field, VALUE actions)
{
long j, actions_len = RARRAY_LEN(actions);
long beg, len;
VALUE num = 0, modi = 0;
for (j = 0; j < actions_len; j++) {
VALUE action = rb_ary_entry(actions, j);
VALUE klass = rb_class_of(action);
if (klass == rb_cRange) {
/* copied from rb_str_aref */
len = rb_str_strlen(field);
if (RTEST(rb_range_beg_len(action, &beg, &len, len, 0)))
field = rb_str_substr(field, beg, len);
} else if (klass == rb_cArray) {
num = rb_str_to_inum(field, 10, 0);
modi = rb_ary_entry(action, 1);
if ( (FIXNUM_P(num) ||
TYPE(num) == T_BIGNUM &&
RBIGNUM_LEN(num) <= (SIZEOF_LONG/SIZEOF_BDIGITS)
) &&
FIXNUM_P(modi) &&
FIX2LONG(modi)) {
long modl = NUM2LONG(modi);
long numl = (NUM2LONG(num) / modl) * modl;
char buf[30];
int wrtn = snprintf(buf, 30,
RSTRING_PTR(rb_ary_entry(action, 0)),
numl);
if (wrtn < 30) {
field = rb_str_new(buf, wrtn);
continue;
}
}
else {
num = rb_funcall2(num, idDiv, 1, &modi);
num = rb_funcall2(num, idMul, 1, &modi);
}
field = rb_str_format(1, &num, rb_ary_entry(action, 0));
}
}
return field;
}
VALUE
shoes_canvas_image(int argc, VALUE *argv, VALUE self)
{
VALUE path, attr, _w, _h, image, block;
if (argc == 0 || (argc == 1 && rb_obj_is_kind_of(argv[0], rb_cHash)))
{
rb_scan_args(argc, argv, "01&", &attr, &block);
if (NIL_P(attr)) attr = rb_hash_new();
_w = ATTR(attr, width);
_h = ATTR(attr, height);
}
else
rb_scan_args(argc, argv, "12&", &_w, &_h, &attr, &block);
if (NIL_P(_w) || FIXNUM_P(_w))
{
path = Qnil;
if (FIXNUM_P(_w)) ATTRSET(attr, width, _w);
if (FIXNUM_P(_h)) ATTRSET(attr, height, _h);
ATTRSET(attr, draw, block);
}
else
{
rb_scan_args(argc, argv, "11&", &path, &attr, &block);
if (!NIL_P(block))
{
if (NIL_P(attr)) attr = rb_hash_new();
rb_hash_aset(attr, ID2SYM(s_click), block);
}
}
if (rb_obj_is_kind_of(self, cImage))
{
shoes_image_image(self, path, attr);
return self;
}
SETUP();
image = shoes_image_new(cImage, path, attr, self, canvas->st);
shoes_add_ele(canvas, image);
return image;
}
static VALUE r_gmpf_to_fr(int argc, VALUE *argv, VALUE self)
{
VALUE ptr_return;
MP_FLOAT *ptr_self;
MPFR *ptr_mpfr;
mp_rnd_t rnd;
mp_prec_t prec;
mpf_get_struct(self, ptr_self);
switch(argc) {
case 2:
switch(TYPE(argv[0])){
case T_SYMBOL:
rnd = r_mpfr_rnd_from_value(argv[0]);
if (FIXNUM_P(argv[1])) {
prec = NUM2INT(argv[1]);
} else {
rb_raise(rb_eArgError, "Invalid arguments for GMP::F#to_fr; argc=%d\n", argc);
}
break;
case T_FIXNUM:
prec = NUM2INT(argv[0]);
if (SYMBOL_P(argv[1])) {
rnd = r_mpfr_rnd_from_value(argv[1]);
} else {
rb_raise(rb_eArgError, "Invalid arguments for GMP::F#to_fr; argc=%d\n", argc);
}
break;
default:
rb_raise(rb_eArgError, "Invalid arguments for GMP::F#to_fr; argc=%d\n", argc);
}
break;
case 1:
switch(TYPE(argv[0])){
case T_SYMBOL:
prec = R_MPF_GET_PREC(ptr_self);
rnd = r_mpfr_rnd_from_value(argv[0]);
break;
case T_FIXNUM:
prec = NUM2INT(argv[0]);
rnd = mpfr_get_default_rounding_mode();
break;
default:
rb_raise(rb_eArgError, "Invalid arguments for GMP::F#to_fr; argc=%d\n", argc);
}
break;
case 0:
prec = R_MPF_GET_PREC(ptr_self);
rnd = mpfr_get_default_rounding_mode();
break;
default:
rb_raise(rb_eArgError, "Invalid number of arguments for GMP::F#to_fr; argc=%d\n", argc);
}
r_mpfr_make_struct_init2(ptr_return, ptr_mpfr, prec);
mpfr_set(ptr_mpfr, ptr_self, rnd);
return ptr_return;
}
PRIMITIVE VALUE
vm_fast_neq(VALUE left, VALUE right, unsigned char overriden)
{
if (overriden == 0) {
if (NUMERIC_IMM_P(left) && NUMERIC_IMM_P(right)) {
if (FIXNUM_P(left) && FIXNUM_P(right)) {
return FIX2LONG(left) != FIX2LONG(right) ? Qtrue : Qfalse;
}
else {
return IMM2DBL(left) != IMM2DBL(right) ? Qtrue : Qfalse;
}
}
if (left == Qtrue || left == Qfalse) {
return left != right ? Qtrue : Qfalse;
}
// TODO: opt for non-immediate types
}
return vm_dispatch(0, left, selNeq, NULL, 0, 1, &right);
}
bool
get_int(VALUE value, int& i) {
if (FIXNUM_P(value) == 0) {
return false;
}
Check_Type(value, T_FIXNUM);
i = FIX2INT(value);
return true;
}
