class Fixnum - Documentation for Ruby 2.0.0

fix % other → real click to toggle source

Returns fix modulo other. See numeric.divmod for more information.

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

        fixdivmod(FIX2LONG(x), FIX2LONG(y), 0, &mod);
        return LONG2NUM(mod);
    }
    switch (TYPE(y)) {
      case T_BIGNUM:
        x = rb_int2big(FIX2LONG(x));
        return rb_big_modulo(x, y);
      case T_FLOAT:
        return DBL2NUM(ruby_float_mod((double)FIX2LONG(x), RFLOAT_VALUE(y)));
      default:
        return rb_num_coerce_bin(x, y, '%');
    }
}

fix & integer → integer_result click to toggle source

Bitwise AND.

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, TRUE);
    return rb_funcall(x, rb_intern("&"), 1, y);
}

fix * numeric → numeric_result click to toggle source

Performs multiplication: the class of the resulting object depends on the class of numeric and on the magnitude of the result.

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 (FIT_SQRT_LONG(a) && FIT_SQRT_LONG(b))
            return LONG2FIX(a*b);
        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
    }
    switch (TYPE(y)) {
      case T_BIGNUM:
        return rb_big_mul(y, x);
      case T_FLOAT:
        return DBL2NUM((double)FIX2LONG(x) * RFLOAT_VALUE(y));
      default:
        return rb_num_coerce_bin(x, y, '*');
    }
}

**(other) click to toggle source

Exponentiate by other

# File lib/mathn.rb, line 78
def ** (other)
  if self < 0 && other.round != other
    Complex(self, 0.0) ** other
  else
    power!(other)
  end
end

Also aliased as: power!

fix + numeric → numeric_result click to toggle source

Performs addition: the class of the resulting object depends on the class of numeric and on the magnitude of the result.

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;
    }
    switch (TYPE(y)) {
      case T_BIGNUM:
        return rb_big_plus(y, x);
      case T_FLOAT:
        return DBL2NUM((double)FIX2LONG(x) + RFLOAT_VALUE(y));
      default:
        return rb_num_coerce_bin(x, y, '+');
    }
}

fix - numeric → numeric_result click to toggle source

Performs subtraction: the class of the resulting object depends on the class of numeric and on the magnitude of the result.

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;
    }
    switch (TYPE(y)) {
      case T_BIGNUM:
        x = rb_int2big(FIX2LONG(x));
        return rb_big_minus(x, y);
      case T_FLOAT:
        return DBL2NUM((double)FIX2LONG(x) - RFLOAT_VALUE(y));
      default:
        return rb_num_coerce_bin(x, y, '-');
    }
}

-fix → integer click to toggle source

Negates fix (which might return a Bignum).

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

fix / numeric → numeric_result click to toggle source

Performs division: the class of the resulting object depends on the class of numeric and on the magnitude of the result.

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

fix < real → true or false click to toggle source

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

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

fix << count → integer click to toggle source

Shifts fix left count positions (right if count is negative).

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);
}

fix <= real → true or false click to toggle source

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

static VALUE
fix_le(VALUE x, VALUE y)
{
    if (FIXNUM_P(y)) {
        if (FIX2LONG(x) <= FIX2LONG(y)) return Qtrue;
        return Qfalse;
    }
    switch (TYPE(y)) {
      case T_BIGNUM:
        return FIX2INT(rb_big_cmp(rb_int2big(FIX2LONG(x)), y)) <= 0 ? Qtrue : Qfalse;
      case T_FLOAT:
        {
          VALUE rel = rb_integer_float_cmp(x, y);
          return rel == INT2FIX(-1) || rel == INT2FIX(0) ? Qtrue : Qfalse;
        }
      default:
        return rb_num_coerce_relop(x, y, rb_intern("<="));
    }
}

fix <=> numeric → -1, 0, +1 or nil click to toggle source

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 Comparable.

nil is returned if the two values are incomparable.

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);
    }
    switch (TYPE(y)) {
      case T_BIGNUM:
        return rb_big_cmp(rb_int2big(FIX2LONG(x)), y);
      case T_FLOAT:
        return rb_integer_float_cmp(x, y);
      default:
        return rb_num_coerce_cmp(x, y, rb_intern("<=>"));
    }
}

fix == other → true or false click to toggle source

Return true if fix equals other numerically.

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

static VALUE
fix_equal(VALUE x, VALUE y)
{
    if (x == y) return Qtrue;
    if (FIXNUM_P(y)) return Qfalse;
    switch (TYPE(y)) {
      case T_BIGNUM:
        return rb_big_eq(y, x);
      case T_FLOAT:
        return rb_integer_float_eq(x, y);
      default:
        return num_equal(x, y);
    }
}

fix == other → true or false click to toggle source

Return true if fix equals other numerically.

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

static VALUE
fix_equal(VALUE x, VALUE y)
{
    if (x == y) return Qtrue;
    if (FIXNUM_P(y)) return Qfalse;
    switch (TYPE(y)) {
      case T_BIGNUM:
        return rb_big_eq(y, x);
      case T_FLOAT:
        return rb_integer_float_eq(x, y);
      default:
        return num_equal(x, y);
    }
}

fix > real → true or false click to toggle source

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

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

fix >= real → true or false click to toggle source

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

static VALUE
fix_ge(VALUE x, VALUE y)
{
    if (FIXNUM_P(y)) {
        if (FIX2LONG(x) >= FIX2LONG(y)) return Qtrue;
        return Qfalse;
    }
    switch (TYPE(y)) {
      case T_BIGNUM:
        return FIX2INT(rb_big_cmp(rb_int2big(FIX2LONG(x)), y)) >= 0 ? Qtrue : Qfalse;
      case T_FLOAT:
        {
          VALUE rel = rb_integer_float_cmp(x, y);
          return rel == INT2FIX(1) || rel == INT2FIX(0) ? Qtrue : Qfalse;
        }
      default:
        return rb_num_coerce_relop(x, y, rb_intern(">="));
    }
}

fix >> count → integer click to toggle source

Shifts fix right count positions (left if count is negative).

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);
}

fix[n] → 0, 1 click to toggle source

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

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

produces:

0000000000000000011001100101010

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 (!RBIGNUM_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);
}

fix ^ integer → integer_result click to toggle source

Bitwise EXCLUSIVE OR.

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, TRUE);
    return rb_funcall(x, rb_intern("^"), 1, y);
}

abs → integer click to toggle source

Returns the absolute value of fix.

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

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

    if (i < 0) i = -i;

    return LONG2NUM(i);
}

dclone() click to toggle source

provides a unified clone operation, for REXML::XPathParser to use across multiple Object types

# File lib/rexml/xpath_parser.rb, line 22
def dclone ; self ; end

div(numeric) → integer click to toggle source

Performs integer division: returns integer value.

static VALUE
fix_idiv(VALUE x, VALUE y)
{
    return fix_divide(x, y, rb_intern("div"));
}

divmod(numeric) → array click to toggle source

See Numeric#divmod.

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));
    }
    switch (TYPE(y)) {
      case T_BIGNUM:
        x = rb_int2big(FIX2LONG(x));
        return rb_big_divmod(x, y);
      case 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);
        }
      default:
        return rb_num_coerce_bin(x, y, rb_intern("divmod"));
    }
}

even? → true or false click to toggle source

Returns true if fix is an even number.

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

fdiv(numeric) → float click to toggle source

Returns the floating point result of dividing fix by numeric.

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

static VALUE
fix_fdiv(VALUE x, VALUE y)
{
    if (FIXNUM_P(y)) {
        return DBL2NUM((double)FIX2LONG(x) / (double)FIX2LONG(y));
    }
    switch (TYPE(y)) {
      case T_BIGNUM:
        return rb_big_fdiv(rb_int2big(FIX2LONG(x)), y);
      case T_FLOAT:
        return DBL2NUM((double)FIX2LONG(x) / RFLOAT_VALUE(y));
      default:
        return rb_num_coerce_bin(x, y, rb_intern("fdiv"));
    }
}

inspect(p1 = v1)

Alias for: to_s

magnitude → integer click to toggle source

Returns the absolute value of fix.

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

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

    if (i < 0) i = -i;

    return LONG2NUM(i);
}

modulo(other) → real click to toggle source

Returns fix modulo other. See numeric.divmod for more information.

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

        fixdivmod(FIX2LONG(x), FIX2LONG(y), 0, &mod);
        return LONG2NUM(mod);
    }
    switch (TYPE(y)) {
      case T_BIGNUM:
        x = rb_int2big(FIX2LONG(x));
        return rb_big_modulo(x, y);
      case T_FLOAT:
        return DBL2NUM(ruby_float_mod((double)FIX2LONG(x), RFLOAT_VALUE(y)));
      default:
        return rb_num_coerce_bin(x, y, '%');
    }
}

odd? → true or false click to toggle source

Returns true if fix is an odd number.

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

power!(other)

Alias for: **

size → fixnum click to toggle source

Returns the number of bytes in the machine representation of a Fixnum.

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

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

next → integer click to toggle source

succ → integer

Returns the Integer equal to int + 1.

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

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

to_f → float click to toggle source

Converts fix to a Float.

static VALUE
fix_to_f(VALUE num)
{
    double val;

    val = (double)FIX2LONG(num);

    return DBL2NUM(val);
}

to_s(base=10) → string click to toggle source

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"

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);
}

Also aliased as: inspect

zero? → true or false click to toggle source

Returns true if fix is zero.

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

fix | integer → integer_result click to toggle source

Bitwise OR.

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, TRUE);
    return rb_funcall(x, rb_intern("|"), 1, y);
}

~fix → integer click to toggle source

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

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