Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   **** BEGIN LICENSE BLOCK *****
   * Version: EPL 1.0/GPL 2.0/LGPL 2.1
   *
   * The contents of this file are subject to the Eclipse Public
   * License Version 1.0 (the "License"); you may not use this file
   * except in compliance with the License. You may obtain a copy of
   * the License at http://www.eclipse.org/legal/epl-v10.html
   *
  * Software distributed under the License is distributed on an "AS
  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  * implied. See the License for the specific language governing
  * rights and limitations under the License.
  *
  * Copyright (C) 2001 Alan Moore <alan_moore@gmx.net>
  * Copyright (C) 2001-2004 Jan Arne Petersen <jpetersen@uni-bonn.de>
  * Copyright (C) 2002 Anders Bengtsson <ndrsbngtssn@yahoo.se>
  * Copyright (C) 2002 Benoit Cerrina <b.cerrina@wanadoo.fr>
  * Copyright (C) 2002-2004 Thomas E Enebo <enebo@acm.org>
  * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de>
  * Copyright (C) 2005 Charles O Nutter <headius@headius.com>
  * 
  * Alternatively, the contents of this file may be used under the terms of
  * either of the GNU General Public License Version 2 or later (the "GPL"),
  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  * in which case the provisions of the GPL or the LGPL are applicable instead
  * of those above. If you wish to allow use of your version of this file only
  * under the terms of either the GPL or the LGPL, and not to allow others to
  * use your version of this file under the terms of the EPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the EPL, the GPL or the LGPL.
  ***** END LICENSE BLOCK *****/
 package org.jruby;
 
 import static org.jruby.RubyEnumerator.enumeratorize;
 import static org.jruby.util.Numeric.checkInteger;
 import static org.jruby.util.Numeric.f_gcd;
 import static org.jruby.util.Numeric.f_lcm;
 
Implementation of the Integer class.

Author(s):
jpetersen
 
 @JRubyClass(name="Integer", parent="Numeric", include="Precision")
 public abstract class RubyInteger extends RubyNumeric { 
 
     public static RubyClass createIntegerClass(Ruby runtime) {
         RubyClass integer = runtime.defineClass("Integer"runtime.getNumeric(),
                 .);
         runtime.setInteger(integer);
 
         integer.index = .;
         integer.setReifiedClass(RubyInteger.class);
         
         integer.kindOf = new RubyModule.JavaClassKindOf(RubyInteger.class);
 
         integer.getSingletonClass().undefineMethod("new");
 
         if (!runtime.is1_9()) {
             integer.includeModule(runtime.getPrecision());
         }
 
         integer.defineAnnotatedMethods(RubyInteger.class);
         
         return integer;
     }
 
     public RubyInteger(Ruby runtimeRubyClass rubyClass) {
         super(runtimerubyClass);
     }
 
     public RubyInteger(RubyClass rubyClass) {
         super(rubyClass);
     }
     
     public RubyInteger(Ruby runtimeRubyClass rubyClassboolean useObjectSpace) {
         super(runtimerubyClassuseObjectSpace);
     }     
 
     @Deprecated
     public RubyInteger(Ruby runtimeRubyClass rubyClassboolean useObjectSpaceboolean canBeTainted) {
         super(runtimerubyClassuseObjectSpacecanBeTainted);
    }     
    @Override
    public RubyInteger convertToInteger() {
    	return this;
    }
    // conversion
    protected RubyFloat toFloat() {
        return RubyFloat.newFloat(getRuntime(), getDoubleValue());
    }
    /*  ================
     *  Instance Methods
     *  ================ 
     */

    
int_int_p
    @Override
    @JRubyMethod(name = "integer?")
    public IRubyObject integer_p() {
        return getRuntime().getTrue();
    }

    
int_upto
    public IRubyObject upto(ThreadContext contextIRubyObject toBlock block) {
        if (block.isGiven()) {
            if (this instanceof RubyFixnum && to instanceof RubyFixnum) {
                fixnumUpto(context, ((RubyFixnum)this).getLongValue(), ((RubyFixnum)to).getLongValue(), block);
            } else {
                duckUpto(contextthistoblock);
            }
            return this;
        } else {
            return enumeratorize(context.runtimethis"upto"to);
        }
    }
    private static void fixnumUpto(ThreadContext contextlong fromlong toBlock block) {
        // We must avoid "i++" integer overflow when (to == Long.MAX_VALUE).
        Ruby runtime = context.runtime;
        if (block.getBody().getArgumentType() == .) {
            IRubyObject nil = runtime.getNil();
            long i;
            for (i = fromi < toi++) {
                block.yield(contextnil);
            }
            if (i <= to) {
                block.yield(contextnil);
            }
        } else {
            long i;
            for (i = fromi < toi++) {
                block.yield(context, RubyFixnum.newFixnum(runtimei));
            }
            if (i <= to) {
                block.yield(context, RubyFixnum.newFixnum(runtimei));
            }
        }
    }
    private static void duckUpto(ThreadContext contextIRubyObject fromIRubyObject toBlock block) {
        Ruby runtime = context.runtime;
        IRubyObject i = from;
        RubyFixnum one = RubyFixnum.one(runtime);
        while (true) {
            if (i.callMethod(context">"to).isTrue()) {
                break;
            }
            block.yield(contexti);
            i = i.callMethod(context"+"one);
        }
    }

    
int_downto
    // TODO: Make callCoerced work in block context...then fix downto, step, and upto.
    public IRubyObject downto(ThreadContext contextIRubyObject toBlock block) {
        if (block.isGiven()) {
            if (this instanceof RubyFixnum && to instanceof RubyFixnum) {
                fixnumDownto(context, ((RubyFixnum)this).getLongValue(), ((RubyFixnum)to).getLongValue(), block);
            } else {
                duckDownto(contextthistoblock);
            }
            return this;
        } else {
            return enumeratorize(context.runtimethis"downto"to);
        }
    }
    private static void fixnumDownto(ThreadContext contextlong fromlong toBlock block) {
        // We must avoid "i--" integer overflow when (to == Long.MIN_VALUE).
        Ruby runtime = context.runtime;
        if (block.getBody().getArgumentType() == .) {
            IRubyObject nil = runtime.getNil();
            long i;
            for (i = fromi > toi--) {
                block.yield(contextnil);
            }
            if (i >= to) {
                block.yield(contextnil);
            }
        } else {
            long i;
            for (i = fromi > toi--) {
                block.yield(context, RubyFixnum.newFixnum(runtimei));
            }
            if (i >= to) {
                block.yield(context, RubyFixnum.newFixnum(runtimei));
            }
        }
    }
    private static void duckDownto(ThreadContext contextIRubyObject fromIRubyObject toBlock block) {
        Ruby runtime = context.runtime;
        IRubyObject i = from;
        RubyFixnum one = RubyFixnum.one(runtime);
        while (true) {
            if (i.callMethod(context"<"to).isTrue()) {
                break;
            }
            block.yield(contexti);
            i = i.callMethod(context"-"one);
        }
    }
    public IRubyObject times(ThreadContext contextBlock block) {
        if (block.isGiven()) {
            Ruby runtime = context.runtime;
            IRubyObject i = RubyFixnum.zero(runtime);
            RubyFixnum one = RubyFixnum.one(runtime);
            while (true) {
                if (!i.callMethod(context"<"this).isTrue()) {
                    break;
                }
                block.yield(contexti);
                i = i.callMethod(context"+"one);
            }
            return this;
        } else {
            return enumeratorize(context.runtimethis"times");
        }
    }

    
int_succ
    @JRubyMethod(name = {"succ""next"})
    public IRubyObject succ(ThreadContext context) {
        if (this instanceof RubyFixnum) {
            return ((RubyFixnumthis).op_plus_one(context);
        } else {
            return callMethod(context"+", RubyFixnum.one(context.runtime));
        }
    }
    static final ByteList[] SINGLE_CHAR_BYTELISTS;
    static final ByteList[] SINGLE_CHAR_BYTELISTS19;
    static {
         = new ByteList[256];
         = new ByteList[256];
        for (int i = 0; i < 256; i++) {
            ByteList usascii = new ByteList(new byte[]{(byte)i}, false);
            [i] = usascii;
            [i] = i < 0x80 ?
                new ByteList(new byte[]{(byte)i}, .)
                :
                new ByteList(
                    new byte[]{(byte)i},
                    .);
        }
    }

    
int_chr
    @JRubyMethod(name = "chr", compat = .)
    public RubyString chr(ThreadContext context) {
        Ruby runtime = context.runtime;
        long value = getLongValue();
        if (value < 0 || value > 0xff) throw runtime.newRangeError(this.toString() + " out of char range");
        return RubyString.newStringShared(runtime[(int)value]);
    }
    @JRubyMethod(name = "chr", compat = .)
    public RubyString chr19(ThreadContext context) {
        Ruby runtime = context.runtime;
        int value = (int)getLongValue();
        if (value >= 0 && value <= 0xFF) {
            ByteList bytes = [value];
            return RubyString.newStringShared(runtimebytesbytes.getEncoding());
        } else {
            Encoding enc = runtime.getDefaultInternalEncoding();
            if (value > 0xFF && (enc == null || enc == .)) {
                throw runtime.newRangeError(this.toString() + " out of char range");
            } else {
                if (enc == nullenc = .;
                return RubyString.newStringNoCopy(runtimefromEncodedBytes(runtimeenc, (int)value), enc, 0);
            }
        }
    }
    @JRubyMethod(name = "chr", compat = .)
    public RubyString chr19(ThreadContext contextIRubyObject arg) {
        Ruby runtime = context.runtime;
        long value = getLongValue();
        Encoding enc;
        if (arg instanceof RubyEncoding) {
            enc = ((RubyEncoding)arg).getEncoding();
        } else {
            enc =  arg.convertToString().toEncoding(runtime);
        }
        if (enc == . && value >= 0x80) {
            return chr19(context);
        }
        return RubyString.newStringNoCopy(runtimefromEncodedBytes(runtimeenc, (int)value), enc, 0);
    }
    private ByteList fromEncodedBytes(Ruby runtimeEncoding encint value) {
        int n;
        try {
            n = value < 0 ? 0 : enc.codeToMbcLength(value);
        } catch (EncodingException ee) {
            n = 0;
        }
        if (n <= 0) throw runtime.newRangeError(this.toString() + " out of char range");
        
        ByteList bytes = new ByteList(n);
        
        try {
            enc.codeToMbc(valuebytes.getUnsafeBytes(), 0);
        } catch (EncodingException e) {
            throw runtime.newRangeError("invalid codepoint " + String.format("0x%x in "value) + enc.getCharsetName());
        }
        bytes.setRealSize(n);
        return bytes;
    }

    
int_ord
    @JRubyMethod(name = "ord")
    public IRubyObject ord(ThreadContext context) {
        return this;
    }

    
int_to_i
    @JRubyMethod(name = {"to_i""to_int""floor""ceil""truncate"})
    public IRubyObject to_i() {
        return this;
    }
    @Override
    @JRubyMethod(name = "round", compat = .)
    public IRubyObject round() {
        return this;
    }
    @JRubyMethod(name = "round", compat = .)
    public IRubyObject round19() {
        return this;
    }
    @JRubyMethod(name = "round", compat = .)
    public IRubyObject round19(ThreadContext contextIRubyObject arg) {
        int ndigits = RubyNumeric.num2int(arg);
        if (ndigits > 0) return RubyKernel.new_float(thisthis);
        if (ndigits == 0) return this;
        Ruby runtime = context.runtime;
        
        long bytes = (this instanceof RubyFixnum) ? 8 : RubyFixnum.fix2long(callMethod("size"));
        /* If 10**N/2 > this, return 0 */
        /* We have log_256(10) > 0.415241 and log_256(1/2)=-0.125 */
        if (-0.415241 * ndigits - 0.125 > bytes) {
            return RubyFixnum.zero(runtime);
        }
        
        IRubyObject f = Numeric.int_pow(context, 10, -ndigits);
        if (this instanceof RubyFixnum && f instanceof RubyFixnum) {
            long x = ((RubyFixnum)this).getLongValue();
            long y = ((RubyFixnum)f).getLongValue();
            boolean neg = x < 0;
            if (negx = -x;
            x = (x + y / 2) / y * y;
            if (negx = -x;
            return RubyFixnum.newFixnum(runtimex);
        } else if (f instanceof RubyFloat) {
            return RubyFixnum.zero(runtime);
        } else {
            IRubyObject h = f.callMethod(context"/", RubyFixnum.two(runtime));
            IRubyObject r = callMethod(context"%"f);
            IRubyObject n = callMethod(context"-"r);
            String op = callMethod(context"<", RubyFixnum.zero(runtime)).isTrue() ? "<=" : "<";
            if (!r.callMethod(contextoph).isTrue()) n = n.callMethod(context"+"f);
            return n;
        }
    }

    
integer_to_r
    @JRubyMethod(name = "to_r", compat = .)
    public IRubyObject to_r(ThreadContext context) {
        return RubyRational.newRationalCanonicalize(contextthis);
    }

    
integer_rationalize
    @JRubyMethod(name = "rationalize", optional = 1, compat = .)
    public IRubyObject rationalize(ThreadContext contextIRubyObject[] args) {
        return to_r(context);
    }
    
    @JRubyMethod(name = "odd?")
    public RubyBoolean odd_p(ThreadContext context) {
        Ruby runtime = context.runtime;
        if (callMethod(context"%", RubyFixnum.two(runtime)) != RubyFixnum.zero(runtime)) {
            return runtime.getTrue();
        }
        return runtime.getFalse();
    }
    @JRubyMethod(name = "even?")
    public RubyBoolean even_p(ThreadContext context) {
        Ruby runtime = context.runtime;
        if (callMethod(context"%", RubyFixnum.two(runtime)) == RubyFixnum.zero(runtime)) {
            return runtime.getTrue();
        }
        return runtime.getFalse();
    }
    @JRubyMethod(name = "pred")
    public IRubyObject pred(ThreadContext context) {
        return callMethod(context"-", RubyFixnum.one(context.runtime));
    }

    
rb_gcd
    @JRubyMethod(name = "gcd", compat = .)
    public IRubyObject gcd(ThreadContext contextIRubyObject other) {
        checkInteger(contextother);
        return f_gcd(contextthis, RubyRational.intValue(contextother));
    }    

    
rb_lcm
    @JRubyMethod(name = "lcm", compat = .)
    public IRubyObject lcm(ThreadContext contextIRubyObject other) {
        checkInteger(contextother);
        return f_lcm(contextthis, RubyRational.intValue(contextother));
    }    

    
rb_gcdlcm
    @JRubyMethod(name = "gcdlcm", compat = .)
    public IRubyObject gcdlcm(ThreadContext contextIRubyObject other) {
        checkInteger(contextother);
        other = RubyRational.intValue(contextother);
        return context.runtime.newArray(f_gcd(contextthisother), f_lcm(contextthisother));
    }
    @Override
    @JRubyMethod(name = "numerator", compat = .)
    public IRubyObject numerator(ThreadContext context) {
        return this;
    }
    @Override
    @JRubyMethod(name = "denominator", compat = .)
    public IRubyObject denominator(ThreadContext context) {
        return RubyFixnum.one(context.runtime);
    }
    /*  ================
     *  Singleton Methods
     *  ================ 
     */

    
rb_int_induced_from
    @JRubyMethod(name = "induced_from", meta = true, compat = .)
    public static IRubyObject induced_from(ThreadContext contextIRubyObject recvIRubyObject other) {
        if (other instanceof RubyFixnum || other instanceof RubyBignum) {
            return other;
        } else if (other instanceof RubyFloat || other instanceof RubyRational) {
            return other.callMethod(context"to_i");
        } else {
            throw recv.getRuntime().newTypeError(
                    "failed to convert " + other.getMetaClass().getName() + " into Integer");
        }
    }
New to GrepCode? Check out our FAQ X