Class: Fixnum

Inherits:
Integer show all
Defined in:
numeric.c,
numeric.c

Overview

******************************************************************

Holds Integer values that can be represented in a native machine word
(minus 1 bit).  If any operation on a Fixnum exceeds this range, the value
is automatically converted to a Bignum.

Fixnum objects have immediate value. This means that when they are assigned
or passed as parameters, the actual object is passed, rather than a
reference to that object.

Assignment does not alias Fixnum objects. There is effectively only one
Fixnum object instance for any given integer value, so, for example, you
cannot add a singleton method to a Fixnum. Any attempt to add a singleton
method to a Fixnum object will raise a TypeError.

Instance Method Summary collapse

Methods inherited from Integer

#ceil, #chr, #denominator, #downto, #floor, #gcd, #gcdlcm, #integer?, #lcm, #next, #numerator, #ord, #pred, #rationalize, #round, #times, #to_i, #to_int, #to_r, #truncate, #upto

Methods inherited from Numeric

#+@, #abs2, #angle, #arg, #ceil, #coerce, #conj, #conjugate, #denominator, #eql?, #floor, #i, #imag, #imaginary, #initialize_copy, #integer?, #negative?, #nonzero?, #numerator, #phase, #polar, #positive?, #quo, #real, #real?, #rect, #rectangular, #remainder, #round, #singleton_method_added, #step, #to_c, #to_int, #truncate

Methods included from Comparable

#between?

Instance Method Details

#%(other) ⇒ Object #modulo(other) ⇒ Object

Returns fix modulo other.

See Numeric#divmod for more information.



3179
3180
3181
3182
3183
3184
3185
3186
3187
3188
3189
3190
3191
3192
3193
3194
3195
3196
3197
3198
# File 'numeric.c', line 3179

static VALUE
fix_mod(VALUE x, VALUE y)
{
    if (FIXNUM_P(y)) {
	long mod;

	fixdivmod(FIX2LONG(x), FIX2LONG(y), 0, &mod);
	return LONG2NUM(mod);
    }
    else if (RB_TYPE_P(y, T_BIGNUM)) {
	x = rb_int2big(FIX2LONG(x));
	return rb_big_modulo(x, y);
    }
    else if (RB_TYPE_P(y, T_FLOAT)) {
	return DBL2NUM(ruby_float_mod((double)FIX2LONG(x), RFLOAT_VALUE(y)));
    }
    else {
	return rb_num_coerce_bin(x, y, '%');
    }
}

#&(integer) ⇒ Object

Bitwise AND.



3547
3548
3549
3550
3551
3552
3553
3554
3555
3556
3557
3558
3559
3560
3561
# File 'numeric.c', line 3547

static VALUE
fix_and(VALUE x, VALUE y)
{
    if (FIXNUM_P(y)) {
	long val = FIX2LONG(x) & FIX2LONG(y);
	return LONG2NUM(val);
    }

    if (RB_TYPE_P(y, T_BIGNUM)) {
	return rb_big_and(y, x);
    }

    bit_coerce(&x, &y);
    return rb_funcall(x, '&', 1, y);
}

#*(numeric) ⇒ Object

Performs multiplication: the class of the resulting object depends on the class of numeric and on the magnitude of the result. It may return a Bignum.



3004
3005
3006
3007
3008
3009
3010
3011
3012
3013
3014
3015
3016
3017
3018
3019
3020
3021
3022
3023
3024
3025
3026
3027
3028
3029
3030
3031
3032
3033
3034
3035
3036
3037
3038
3039
3040
3041
3042
3043
3044
3045
3046
3047
3048
# File 'numeric.c', line 3004

static VALUE
fix_mul(VALUE x, VALUE y)
{
    if (FIXNUM_P(y)) {
#ifdef __HP_cc
/* avoids an optimization bug of HP aC++/ANSI C B3910B A.06.05 [Jul 25 2005] */
	volatile
#endif
	long a, b;
#if SIZEOF_LONG * 2 <= SIZEOF_LONG_LONG
	LONG_LONG d;
#else
	VALUE r;
#endif

	a = FIX2LONG(x);
	b = FIX2LONG(y);

#if SIZEOF_LONG * 2 <= SIZEOF_LONG_LONG
	d = (LONG_LONG)a * b;
	if (FIXABLE(d)) return LONG2FIX(d);
	return rb_ll2inum(d);
#else
	if (a == 0) return x;
        if (MUL_OVERFLOW_FIXNUM_P(a, b))
	    r = rb_big_mul(rb_int2big(a), rb_int2big(b));
        else
            r = LONG2FIX(a * b);
	return r;
#endif
    }
    else if (RB_TYPE_P(y, T_BIGNUM)) {
	return rb_big_mul(y, x);
    }
    else if (RB_TYPE_P(y, T_FLOAT)) {
	return DBL2NUM((double)FIX2LONG(x) * RFLOAT_VALUE(y));
    }
    else if (RB_TYPE_P(y, T_COMPLEX)) {
	VALUE rb_nucomp_mul(VALUE, VALUE);
	return rb_nucomp_mul(y, x);
    }
    else {
	return rb_num_coerce_bin(x, y, '*');
    }
}

#**(numeric) ⇒ Object

Raises fix to the power of numeric, which may be negative or fractional.

2 ** 3      #=> 8
2 ** -1     #=> (1/2)
2 ** 0.5    #=> 1.4142135623731


3289
3290
3291
3292
3293
3294
3295
3296
3297
3298
3299
3300
3301
3302
3303
3304
3305
3306
3307
3308
3309
3310
3311
3312
3313
3314
3315
3316
3317
3318
3319
3320
3321
3322
3323
3324
3325
3326
3327
3328
3329
3330
3331
3332
3333
3334
3335
3336
3337
3338
3339
3340
3341
3342
3343
# File 'numeric.c', line 3289

static VALUE
fix_pow(VALUE x, VALUE y)
{
    long a = FIX2LONG(x);

    if (FIXNUM_P(y)) {
	long b = FIX2LONG(y);

	if (a == 1) return INT2FIX(1);
	if (a == -1) {
	    if (b % 2 == 0)
		return INT2FIX(1);
	    else
		return INT2FIX(-1);
	}
	if (b < 0)
	    return rb_funcall(rb_rational_raw1(x), idPow, 1, y);

	if (b == 0) return INT2FIX(1);
	if (b == 1) return x;
	if (a == 0) {
	    if (b > 0) return INT2FIX(0);
	    return DBL2NUM(INFINITY);
	}
	return int_pow(a, b);
    }
    else if (RB_TYPE_P(y, T_BIGNUM)) {
	if (a == 1) return INT2FIX(1);
	if (a == -1) {
	    if (int_even_p(y)) return INT2FIX(1);
	    else return INT2FIX(-1);
	}
	if (negative_int_p(y))
	    return rb_funcall(rb_rational_raw1(x), idPow, 1, y);
	if (a == 0) return INT2FIX(0);
	x = rb_int2big(FIX2LONG(x));
	return rb_big_pow(x, y);
    }
    else if (RB_TYPE_P(y, T_FLOAT)) {
	if (RFLOAT_VALUE(y) == 0.0) return DBL2NUM(1.0);
	if (a == 0) {
	    return DBL2NUM(RFLOAT_VALUE(y) < 0 ? INFINITY : 0.0);
	}
	if (a == 1) return DBL2NUM(1.0);
	{
	    double dy = RFLOAT_VALUE(y);
	    if (a < 0 && dy != round(dy))
		return rb_funcall(rb_complex_raw1(x), idPow, 1, y);
	    return DBL2NUM(pow((double)a, dy));
	}
    }
    else {
	return rb_num_coerce_bin(x, y, idPow);
    }
}

#+(numeric) ⇒ Object

Performs addition: the class of the resulting object depends on the class of numeric and on the magnitude of the result. It may return a Bignum.



2928
2929
2930
2931
2932
2933
2934
2935
2936
2937
2938
2939
2940
2941
2942
2943
2944
2945
2946
2947
2948
2949
2950
2951
2952
2953
2954
2955
# File 'numeric.c', line 2928

static VALUE
fix_plus(VALUE x, VALUE y)
{
    if (FIXNUM_P(y)) {
	long a, b, c;
	VALUE r;

	a = FIX2LONG(x);
	b = FIX2LONG(y);
	c = a + b;
	r = LONG2NUM(c);

	return r;
    }
    else if (RB_TYPE_P(y, T_BIGNUM)) {
	return rb_big_plus(y, x);
    }
    else if (RB_TYPE_P(y, T_FLOAT)) {
	return DBL2NUM((double)FIX2LONG(x) + RFLOAT_VALUE(y));
    }
    else if (RB_TYPE_P(y, T_COMPLEX)) {
	VALUE rb_nucomp_add(VALUE, VALUE);
	return rb_nucomp_add(y, x);
    }
    else {
	return rb_num_coerce_bin(x, y, '+');
    }
}

#-(numeric) ⇒ Object

Performs subtraction: the class of the resulting object depends on the class of numeric and on the magnitude of the result. It may return a Bignum.



2965
2966
2967
2968
2969
2970
2971
2972
2973
2974
2975
2976
2977
2978
2979
2980
2981
2982
2983
2984
2985
2986
2987
2988
2989
# File 'numeric.c', line 2965

static VALUE
fix_minus(VALUE x, VALUE y)
{
    if (FIXNUM_P(y)) {
	long a, b, c;
	VALUE r;

	a = FIX2LONG(x);
	b = FIX2LONG(y);
	c = a - b;
	r = LONG2NUM(c);

	return r;
    }
    else if (RB_TYPE_P(y, T_BIGNUM)) {
	x = rb_int2big(FIX2LONG(x));
	return rb_big_minus(x, y);
    }
    else if (RB_TYPE_P(y, T_FLOAT)) {
	return DBL2NUM((double)FIX2LONG(x) - RFLOAT_VALUE(y));
    }
    else {
	return rb_num_coerce_bin(x, y, '-');
    }
}

#-Integer

Negates fix, which may return a Bignum.

Returns:



2855
2856
2857
2858
2859
# File 'numeric.c', line 2855

static VALUE
fix_uminus(VALUE num)
{
    return LONG2NUM(-FIX2LONG(num));
}

#/(numeric) ⇒ Object

Performs division: the class of the resulting object depends on the class of numeric and on the magnitude of the result. It may return a Bignum.



3149
3150
3151
3152
3153
# File 'numeric.c', line 3149

static VALUE
fix_div(VALUE x, VALUE y)
{
    return fix_divide(x, y, '/');
}

#<(real) ⇒ Boolean

Returns true if the value of fix is less than that of real.

Returns:

  • (Boolean)


3461
3462
3463
3464
3465
3466
3467
3468
3469
3470
3471
3472
3473
3474
3475
3476
3477
# File 'numeric.c', line 3461

static VALUE
fix_lt(VALUE x, VALUE y)
{
    if (FIXNUM_P(y)) {
	if (FIX2LONG(x) < FIX2LONG(y)) return Qtrue;
	return Qfalse;
    }
    else if (RB_TYPE_P(y, T_BIGNUM)) {
	return FIX2INT(rb_big_cmp(rb_int2big(FIX2LONG(x)), y)) < 0 ? Qtrue : Qfalse;
    }
    else if (RB_TYPE_P(y, T_FLOAT)) {
        return rb_integer_float_cmp(x, y) == INT2FIX(-1) ? Qtrue : Qfalse;
    }
    else {
	return rb_num_coerce_relop(x, y, '<');
    }
}

#<<(count) ⇒ Integer

Shifts fix left count positions, or right if count is negative.

Returns:



3619
3620
3621
3622
3623
3624
3625
3626
3627
3628
3629
3630
3631
# File 'numeric.c', line 3619

static VALUE
rb_fix_lshift(VALUE x, VALUE y)
{
    long val, width;

    val = NUM2LONG(x);
    if (!FIXNUM_P(y))
	return rb_big_lshift(rb_int2big(val), y);
    width = FIX2LONG(y);
    if (width < 0)
	return fix_rshift(val, (unsigned long)-width);
    return fix_lshift(val, width);
}

#<=(real) ⇒ Boolean

Returns true if the value of fix is less than or equal to that of real.

Returns:

  • (Boolean)


3487
3488
3489
3490
3491
3492
3493
3494
3495
3496
3497
3498
3499
3500
3501
3502
3503
3504
# File 'numeric.c', line 3487

static VALUE
fix_le(VALUE x, VALUE y)
{
    if (FIXNUM_P(y)) {
	if (FIX2LONG(x) <= FIX2LONG(y)) return Qtrue;
	return Qfalse;
    }
    else if (RB_TYPE_P(y, T_BIGNUM)) {
	return FIX2INT(rb_big_cmp(rb_int2big(FIX2LONG(x)), y)) <= 0 ? Qtrue : Qfalse;
    }
    else if (RB_TYPE_P(y, T_FLOAT)) {
	VALUE rel = rb_integer_float_cmp(x, y);
	return rel == INT2FIX(-1) || rel == INT2FIX(0) ? Qtrue : Qfalse;
    }
    else {
	return rb_num_coerce_relop(x, y, idLE);
    }
}

#<=>(numeric) ⇒ -1, ...

Comparison—Returns -1, 0, +1 or nil depending on whether fix is less than, equal to, or greater than numeric.

This is the basis for the tests in the Comparable module.

nil is returned if the two values are incomparable.

Returns:

  • (-1, 0, +1, nil)


3383
3384
3385
3386
3387
3388
3389
3390
3391
3392
3393
3394
3395
3396
3397
3398
3399
3400
# File 'numeric.c', line 3383

static VALUE
fix_cmp(VALUE x, VALUE y)
{
    if (x == y) return INT2FIX(0);
    if (FIXNUM_P(y)) {
	if (FIX2LONG(x) > FIX2LONG(y)) return INT2FIX(1);
	return INT2FIX(-1);
    }
    else if (RB_TYPE_P(y, T_BIGNUM)) {
	return rb_big_cmp(rb_int2big(FIX2LONG(x)), y);
    }
    else if (RB_TYPE_P(y, T_FLOAT)) {
        return rb_integer_float_cmp(x, y);
    }
    else {
	return rb_num_coerce_cmp(x, y, id_cmp);
    }
}

#==(other) ⇒ Boolean

Return true if fix equals other numerically.

1 == 2      #=> false
1 == 1.0    #=> true

Returns:

  • (Boolean)


3355
3356
3357
3358
3359
3360
3361
3362
3363
3364
3365
3366
3367
3368
3369
# File 'numeric.c', line 3355

static VALUE
fix_equal(VALUE x, VALUE y)
{
    if (x == y) return Qtrue;
    if (FIXNUM_P(y)) return Qfalse;
    else if (RB_TYPE_P(y, T_BIGNUM)) {
	return rb_big_eq(y, x);
    }
    else if (RB_TYPE_P(y, T_FLOAT)) {
        return rb_integer_float_eq(x, y);
    }
    else {
	return num_equal(x, y);
    }
}

#==(other) ⇒ Boolean

Return true if fix equals other numerically.

1 == 2      #=> false
1 == 1.0    #=> true

Returns:

  • (Boolean)


3355
3356
3357
3358
3359
3360
3361
3362
3363
3364
3365
3366
3367
3368
3369
# File 'numeric.c', line 3355

static VALUE
fix_equal(VALUE x, VALUE y)
{
    if (x == y) return Qtrue;
    if (FIXNUM_P(y)) return Qfalse;
    else if (RB_TYPE_P(y, T_BIGNUM)) {
	return rb_big_eq(y, x);
    }
    else if (RB_TYPE_P(y, T_FLOAT)) {
        return rb_integer_float_eq(x, y);
    }
    else {
	return num_equal(x, y);
    }
}

#>(real) ⇒ Boolean

Returns true if the value of fix is greater than that of real.

Returns:

  • (Boolean)


3409
3410
3411
3412
3413
3414
3415
3416
3417
3418
3419
3420
3421
3422
3423
3424
3425
# File 'numeric.c', line 3409

static VALUE
fix_gt(VALUE x, VALUE y)
{
    if (FIXNUM_P(y)) {
	if (FIX2LONG(x) > FIX2LONG(y)) return Qtrue;
	return Qfalse;
    }
    else if (RB_TYPE_P(y, T_BIGNUM)) {
	return FIX2INT(rb_big_cmp(rb_int2big(FIX2LONG(x)), y)) > 0 ? Qtrue : Qfalse;
    }
    else if (RB_TYPE_P(y, T_FLOAT)) {
        return rb_integer_float_cmp(x, y) == INT2FIX(1) ? Qtrue : Qfalse;
    }
    else {
	return rb_num_coerce_relop(x, y, '>');
    }
}

#>=(real) ⇒ Boolean

Returns true if the value of fix is greater than or equal to that of real.

Returns:

  • (Boolean)


3435
3436
3437
3438
3439
3440
3441
3442
3443
3444
3445
3446
3447
3448
3449
3450
3451
3452
# File 'numeric.c', line 3435

static VALUE
fix_ge(VALUE x, VALUE y)
{
    if (FIXNUM_P(y)) {
	if (FIX2LONG(x) >= FIX2LONG(y)) return Qtrue;
	return Qfalse;
    }
    else if (RB_TYPE_P(y, T_BIGNUM)) {
	return FIX2INT(rb_big_cmp(rb_int2big(FIX2LONG(x)), y)) >= 0 ? Qtrue : Qfalse;
    }
    else if (RB_TYPE_P(y, T_FLOAT)) {
	VALUE rel = rb_integer_float_cmp(x, y);
	return rel == INT2FIX(1) || rel == INT2FIX(0) ? Qtrue : Qfalse;
    }
    else {
	return rb_num_coerce_relop(x, y, idGE);
    }
}

#>>(count) ⇒ Integer

Shifts fix right count positions, or left if count is negative.

Returns:



3651
3652
3653
3654
3655
3656
3657
3658
3659
3660
3661
3662
3663
3664
# File 'numeric.c', line 3651

static VALUE
rb_fix_rshift(VALUE x, VALUE y)
{
    long i, val;

    val = FIX2LONG(x);
    if (!FIXNUM_P(y))
	return rb_big_rshift(rb_int2big(val), y);
    i = FIX2LONG(y);
    if (i == 0) return x;
    if (i < 0)
	return fix_lshift(val, (unsigned long)-i);
    return fix_rshift(val, i);
}

#[](n) ⇒ 0, 1

Bit Reference—Returns the nth bit in the binary representation of fix, where fix[0] is the least significant bit.

For example:

a = 0b11001100101010
30.downto(0) do |n| print a[n] end
#=> 0000000000000000011001100101010

Returns:

  • (0, 1)


3691
3692
3693
3694
3695
3696
3697
3698
3699
3700
3701
3702
3703
3704
3705
3706
3707
3708
3709
3710
3711
3712
3713
3714
3715
3716
# File 'numeric.c', line 3691

static VALUE
fix_aref(VALUE fix, VALUE idx)
{
    long val = FIX2LONG(fix);
    long i;

    idx = rb_to_int(idx);
    if (!FIXNUM_P(idx)) {
	idx = rb_big_norm(idx);
	if (!FIXNUM_P(idx)) {
	    if (!BIGNUM_SIGN(idx) || val >= 0)
		return INT2FIX(0);
	    return INT2FIX(1);
	}
    }
    i = FIX2LONG(idx);

    if (i < 0) return INT2FIX(0);
    if (SIZEOF_LONG*CHAR_BIT-1 <= i) {
	if (val < 0) return INT2FIX(1);
	return INT2FIX(0);
    }
    if (val & (1L<<i))
	return INT2FIX(1);
    return INT2FIX(0);
}

#^(integer) ⇒ Object

Bitwise EXCLUSIVE OR.



3593
3594
3595
3596
3597
3598
3599
3600
3601
3602
3603
3604
3605
3606
3607
# File 'numeric.c', line 3593

static VALUE
fix_xor(VALUE x, VALUE y)
{
    if (FIXNUM_P(y)) {
	long val = FIX2LONG(x) ^ FIX2LONG(y);
	return LONG2NUM(val);
    }

    if (RB_TYPE_P(y, T_BIGNUM)) {
	return rb_big_xor(y, x);
    }

    bit_coerce(&x, &y);
    return rb_funcall(x, '^', 1, y);
}

#absInteger #magnitudeInteger

Returns the absolute value of fix.

-12345.abs   #=> 12345
12345.abs    #=> 12345

Overloads:



3748
3749
3750
3751
3752
3753
3754
3755
3756
# File 'numeric.c', line 3748

static VALUE
fix_abs(VALUE fix)
{
    long i = FIX2LONG(fix);

    if (i < 0) i = -i;

    return LONG2NUM(i);
}

#bit_lengthInteger

Returns the number of bits of the value of int.

“the number of bits” means that the bit position of the highest bit which is different to the sign bit. (The bit position of the bit 2**n is n+1.) If there is no such bit (zero or minus one), zero is returned.

I.e. This method returns ceil(log2(int < 0 ? -int : int+1)).

(-2**12-1).bit_length     #=> 13
(-2**12).bit_length       #=> 12
(-2**12+1).bit_length     #=> 12
-0x101.bit_length         #=> 9
-0x100.bit_length         #=> 8
-0xff.bit_length          #=> 8
-2.bit_length             #=> 1
-1.bit_length             #=> 0
0.bit_length              #=> 0
1.bit_length              #=> 1
0xff.bit_length           #=> 8
0x100.bit_length          #=> 9
(2**12-1).bit_length      #=> 12
(2**12).bit_length        #=> 13
(2**12+1).bit_length      #=> 13

This method can be used to detect overflow in Array#pack as follows.

if n.bit_length < 32
  [n].pack("l") # no overflow
else
  raise "overflow"
end

Returns:



3815
3816
3817
3818
3819
3820
3821
3822
# File 'numeric.c', line 3815

static VALUE
rb_fix_bit_length(VALUE fix)
{
    long v = FIX2LONG(fix);
    if (v < 0)
        v = ~v;
    return LONG2FIX(bit_length(v));
}

#div(numeric) ⇒ Integer

Performs integer division: returns integer result of dividing fix by numeric.

Returns:



3163
3164
3165
3166
3167
# File 'numeric.c', line 3163

static VALUE
fix_idiv(VALUE x, VALUE y)
{
    return fix_divide(x, y, id_div);
}

#divmod(numeric) ⇒ Array

See Numeric#divmod.

Returns:



3206
3207
3208
3209
3210
3211
3212
3213
3214
3215
3216
3217
3218
3219
3220
3221
3222
3223
3224
3225
3226
3227
3228
3229
3230
3231
3232
3233
3234
# File 'numeric.c', line 3206

static VALUE
fix_divmod(VALUE x, VALUE y)
{
    if (FIXNUM_P(y)) {
	long div, mod;

	fixdivmod(FIX2LONG(x), FIX2LONG(y), &div, &mod);

	return rb_assoc_new(LONG2NUM(div), LONG2NUM(mod));
    }
    else if (RB_TYPE_P(y, T_BIGNUM)) {
	x = rb_int2big(FIX2LONG(x));
	return rb_big_divmod(x, y);
    }
    else if (RB_TYPE_P(y, T_FLOAT)) {
	{
	    double div, mod;
	    volatile VALUE a, b;

	    flodivmod((double)FIX2LONG(x), RFLOAT_VALUE(y), &div, &mod);
	    a = dbl2ival(div);
	    b = DBL2NUM(mod);
	    return rb_assoc_new(a, b);
	}
    }
    else {
	return rb_num_coerce_bin(x, y, id_divmod);
    }
}

#even?Boolean

Returns true if fix is an even number.

Returns:

  • (Boolean)

Returns:

  • (Boolean)


4040
4041
4042
4043
4044
4045
4046
4047
# File 'numeric.c', line 4040

static VALUE
fix_even_p(VALUE num)
{
    if (num & 2) {
	return Qfalse;
    }
    return Qtrue;
}

#fdiv(numeric) ⇒ Float

Returns the floating point result of dividing fix by numeric.

654321.fdiv(13731)      #=> 47.6528293642124
654321.fdiv(13731.24)   #=> 47.6519964693647

Returns:



3088
3089
3090
3091
3092
3093
3094
3095
3096
3097
3098
3099
3100
3101
3102
3103
# File 'numeric.c', line 3088

static VALUE
fix_fdiv(VALUE x, VALUE y)
{
    if (FIXNUM_P(y)) {
	return DBL2NUM((double)FIX2LONG(x) / (double)FIX2LONG(y));
    }
    else if (RB_TYPE_P(y, T_BIGNUM)) {
	return rb_big_fdiv(rb_int2big(FIX2LONG(x)), y);
    }
    else if (RB_TYPE_P(y, T_FLOAT)) {
	return DBL2NUM((double)FIX2LONG(x) / RFLOAT_VALUE(y));
    }
    else {
	return rb_num_coerce_bin(x, y, rb_intern("fdiv"));
    }
}

#absInteger #magnitudeInteger

Returns the absolute value of fix.

-12345.abs   #=> 12345
12345.abs    #=> 12345

Overloads:



3748
3749
3750
3751
3752
3753
3754
3755
3756
# File 'numeric.c', line 3748

static VALUE
fix_abs(VALUE fix)
{
    long i = FIX2LONG(fix);

    if (i < 0) i = -i;

    return LONG2NUM(i);
}

#%(other) ⇒ Object #modulo(other) ⇒ Object

Returns fix modulo other.

See Numeric#divmod for more information.



3179
3180
3181
3182
3183
3184
3185
3186
3187
3188
3189
3190
3191
3192
3193
3194
3195
3196
3197
3198
# File 'numeric.c', line 3179

static VALUE
fix_mod(VALUE x, VALUE y)
{
    if (FIXNUM_P(y)) {
	long mod;

	fixdivmod(FIX2LONG(x), FIX2LONG(y), 0, &mod);
	return LONG2NUM(mod);
    }
    else if (RB_TYPE_P(y, T_BIGNUM)) {
	x = rb_int2big(FIX2LONG(x));
	return rb_big_modulo(x, y);
    }
    else if (RB_TYPE_P(y, T_FLOAT)) {
	return DBL2NUM(ruby_float_mod((double)FIX2LONG(x), RFLOAT_VALUE(y)));
    }
    else {
	return rb_num_coerce_bin(x, y, '%');
    }
}

#odd?Boolean

Returns true if fix is an odd number.

Returns:

  • (Boolean)

Returns:

  • (Boolean)


4024
4025
4026
4027
4028
4029
4030
4031
# File 'numeric.c', line 4024

static VALUE
fix_odd_p(VALUE num)
{
    if (num & 2) {
	return Qtrue;
    }
    return Qfalse;
}

#sizeFixnum

Returns the number of bytes in the machine representation of fix.

1.size            #=> 4
-1.size           #=> 4
2147483647.size   #=> 4

Returns:



3771
3772
3773
3774
3775
# File 'numeric.c', line 3771

static VALUE
fix_size(VALUE fix)
{
    return INT2FIX(sizeof(long));
}

#nextInteger #succInteger

Returns the Integer equal to int + 1.

1.next      #=> 2
(-1).next   #=> 0

Overloads:



2673
2674
2675
2676
2677
2678
# File 'numeric.c', line 2673

static VALUE
fix_succ(VALUE num)
{
    long i = FIX2LONG(num) + 1;
    return LONG2NUM(i);
}

#to_fFloat

Converts fix to a Float.

Returns:



3726
3727
3728
3729
3730
3731
3732
3733
3734
# File 'numeric.c', line 3726

static VALUE
fix_to_f(VALUE num)
{
    double val;

    val = (double)FIX2LONG(num);

    return DBL2NUM(val);
}

#to_s(base = 10) ⇒ String Also known as: inspect

Returns a string containing the representation of fix radix base (between 2 and 36).

12345.to_s       #=> "12345"
12345.to_s(2)    #=> "11000000111001"
12345.to_s(8)    #=> "30071"
12345.to_s(10)   #=> "12345"
12345.to_s(16)   #=> "3039"
12345.to_s(36)   #=> "9ix"

Returns:



2904
2905
2906
2907
2908
2909
2910
2911
2912
2913
2914
2915
2916
2917
2918
# File 'numeric.c', line 2904

static VALUE
fix_to_s(int argc, VALUE *argv, VALUE x)
{
    int base;

    if (argc == 0) base = 10;
    else {
	VALUE b;

	rb_scan_args(argc, argv, "01", &b);
	base = NUM2INT(b);
    }

    return rb_fix2str(x, base);
}

#zero?Boolean

Returns true if fix is zero.

Returns:

  • (Boolean)

Returns:

  • (Boolean)


4008
4009
4010
4011
4012
4013
4014
4015
# File 'numeric.c', line 4008

static VALUE
fix_zero_p(VALUE num)
{
    if (FIX2LONG(num) == 0) {
	return Qtrue;
    }
    return Qfalse;
}

#|(integer) ⇒ Object

Bitwise OR.



3570
3571
3572
3573
3574
3575
3576
3577
3578
3579
3580
3581
3582
3583
3584
# File 'numeric.c', line 3570

static VALUE
fix_or(VALUE x, VALUE y)
{
    if (FIXNUM_P(y)) {
	long val = FIX2LONG(x) | FIX2LONG(y);
	return LONG2NUM(val);
    }

    if (RB_TYPE_P(y, T_BIGNUM)) {
	return rb_big_or(y, x);
    }

    bit_coerce(&x, &y);
    return rb_funcall(x, '|', 1, y);
}

#~Integer

One's complement: returns a number where each bit is flipped.

Returns:



3513
3514
3515
3516
3517
# File 'numeric.c', line 3513

static VALUE
fix_rev(VALUE num)
{
    return ~num | FIXNUM_FLAG;
}