Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /*
    ***** BEGIN LICENSE BLOCK *****
    * Version: CPL 1.0/GPL 2.0/LGPL 2.1
    *
    * The contents of this file are subject to the Common 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/cpl-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 Benoit Cerrina <b.cerrina@wanadoo.fr>
   * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se>
   * Copyright (C) 2002-2006 Thomas E Enebo <enebo@acm.org>
   * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de>
   * Copyright (C) 2005 David Corbin <dcorbin@users.sourceforge.net>
   * Copyright (C) 2006 Antti Karanta <antti.karanta@napa.fi>
   * Copyright (C) 2007 Miguel Covarrubias <mlcovarrubias@gmail.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 CPL, 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 CPL, the GPL or the LGPL.
   ***** END LICENSE BLOCK *****/
  package org.jruby;
  
  import java.util.HashMap;
  import java.util.Map;
  
  import static org.jruby.CompatVersion.*;

Implementation of the Fixnum class.
  
  @JRubyClass(name="Fixnum", parent="Integer", include="Precision")
  public class RubyFixnum extends RubyInteger {
      
      public static RubyClass createFixnumClass(Ruby runtime) {
          RubyClass fixnum = runtime.defineClass("Fixnum"runtime.getInteger(),
                  .);
          runtime.setFixnum(fixnum);
  
          fixnum.index = .;
          fixnum.setReifiedClass(RubyFixnum.class);
          
          fixnum.kindOf = new RubyModule.KindOf() {
              @Override
              public boolean isKindOf(IRubyObject objRubyModule type) {
                  return obj instanceof RubyFixnum;
              }
          };
  
          if (!runtime.is1_9()) {
              fixnum.includeModule(runtime.getPrecision());
          }
  
          fixnum.defineAnnotatedMethods(RubyFixnum.class);
          
          for (int i = 0; i < runtime.fixnumCache.lengthi++) {
              runtime.fixnumCache[i] = new RubyFixnum(fixnumi - );
          }
  
          return fixnum;
      }
      
      private final long value;
      private static final int BIT_SIZE = 64;
      public static final long SIGN_BIT = (1L << ( - 1));
      public static final long MAX = (1L<<( - 1)) - 1;
      public static final long MIN = -1 *  - 1;
      public static final long MAX_MARSHAL_FIXNUM = (1L << 30) - 1; // 0x3fff_ffff
     public static final long MIN_MARSHAL_FIXNUM = - (1L << 30);   // -0x4000_0000
     public static final int CACHE_OFFSET = 256;
 
     private static IRubyObject fixCoerce(IRubyObject x) {
         do {
             x = x.convertToInteger();
         } while (!(x instanceof RubyFixnum) && !(x instanceof RubyBignum));
         return x;
     }
     
     private static IRubyObject bitCoerce(IRubyObject x) {
         do {
             if (x instanceof RubyFloat)
                 throw x.getRuntime().newTypeError("can't convert Float to Integer");
             x = x.convertToInteger("to_int");
         } while (!(x instanceof RubyFixnum) && !(x instanceof RubyBignum));
         return x;
     }
     
     public RubyFixnum(Ruby runtime) {
         this(runtime, 0);
     }
 
     public RubyFixnum(Ruby runtimelong value) {
         super(runtime.getFixnum());
         this. = value;
     }
     
     private RubyFixnum(RubyClass klazzlong value) {
         super(klazz);
         this. = value;
     }
     
     @Override
     public int getNativeTypeIndex() {
         return .;
     }
    
    
short circuit for Fixnum key comparison
 
     @Override
     public final boolean eql(IRubyObject other) {
         return other instanceof RubyFixnum &&  == ((RubyFixnum)other).;
     }
 
     @Override
     public IRubyObject equal_p(ThreadContext contextIRubyObject obj) {
         return equal_p19(contextobj);
     }
 
     @Override
     public IRubyObject equal_p19(ThreadContext contextIRubyObject obj) {
         return context.runtime.newBoolean(this == obj || eql(obj));
     }
     
     @Override
     public boolean isImmediate() {
     	return true;
     }
     
     @Override
     public RubyClass getSingletonClass() {
         throw getRuntime().newTypeError("can't define singleton");
     }
 
     @Override
     public Class<?> getJavaClass() {
         return long.class;
     }
 
     @Override
     public double getDoubleValue() {
         return ;
     }
 
     @Override
     public long getLongValue() {
         return ;
     }
 
     @Override
     public BigInteger getBigIntegerValue() {
         return BigInteger.valueOf();
     }
 
     public static RubyFixnum newFixnum(Ruby runtimelong value) {
         if (isInCacheRange(value)) {
             return runtime.fixnumCache[(intvalue + ];
         }
         return new RubyFixnum(runtimevalue);
     }
     
     private static boolean isInCacheRange(long value) {
         return value <=  - 1 && value >= -;
     }
 
     public RubyFixnum newFixnum(long newValue) {
         return newFixnum(getRuntime(), newValue);
     }
 
     public static RubyFixnum zero(Ruby runtime) {
         return runtime.fixnumCache[];
     }
 
     public static RubyFixnum one(Ruby runtime) {
         return runtime.fixnumCache[ + 1];
     }
     
     public static RubyFixnum two(Ruby runtime) {
         return runtime.fixnumCache[ + 2];
     }
     
     public static RubyFixnum three(Ruby runtime) {
         return runtime.fixnumCache[ + 3];
     }
     
     public static RubyFixnum four(Ruby runtime) {
         return runtime.fixnumCache[ + 4];
     }
     
     public static RubyFixnum five(Ruby runtime) {
         return runtime.fixnumCache[ + 5];
     }
 
     public static RubyFixnum minus_one(Ruby runtime) {
         return runtime.fixnumCache[ - 1];
     }
 
     @Override
     public RubyFixnum hash() {
         return newFixnum(hashCode());
     }
 
     @Override
     public final int hashCode() {
         return (int)( ^  >>> 32);
     }
 
     @Override
     public boolean equals(Object other) {
         if (other == this) {
             return true;
         }
         
         if (other instanceof RubyFixnum) { 
             RubyFixnum num = (RubyFixnum)other;
             
             if (num.value == ) {
                 return true;
             }
         }
         
         return false;
     }
 
     /*  ================
      *  Instance Methods
      *  ================ 
      */
     @Override
     @JRubyMethod
     public IRubyObject times(ThreadContext contextBlock block) {
         if (block.isGiven()) {
             Ruby runtime = context.runtime;
             long lvalue = this.;
             if (block.getBody().getArgumentType() == .) {
                 IRubyObject nil = runtime.getNil();
                 for (long i = 0; i < lvaluei++) {
                     block.yield(contextnil);
                 }
             } else {
                 for (long i = 0; i < lvaluei++) {
                     block.yield(context, RubyFixnum.newFixnum(runtimei));
                 }
             }
             return this;
         } else {
             return RubyEnumerator.enumeratorize(context.runtimethis"times");
         }
     }

    
fix_to_s
 
     public RubyString to_s(IRubyObject[] args) {
         switch (args.length) {
         case 0: return to_s();
         case 1: return to_s(args[0]);
         defaultthrow getRuntime().newArgumentError(args.length, 1);
         }
     }
     
     @JRubyMethod
     @Override
     public RubyString to_s() {
         int base = 10;
         ByteList bl = ConvertBytes.longToByteList(base);
         if (getRuntime().is1_9()) bl.setEncoding(.);
         return getRuntime().newString(bl);
     }
     
     @JRubyMethod
     public RubyString to_s(IRubyObject arg0) {
         int base = num2int(arg0);
         if (base < 2 || base > 36) {
             throw getRuntime().newArgumentError("illegal radix " + base);
         }
         ByteList bl = ConvertBytes.longToByteList(base);
         if (getRuntime().is1_9()) bl.setEncoding(.);
         return getRuntime().newString(bl);
     }

    
fix_id2name
 
     @JRubyMethod
     public IRubyObject id2name() {
         RubySymbol symbol = RubySymbol.getSymbolLong(getRuntime(), );
         
         if (symbol != nullreturn getRuntime().newString(symbol.asJavaString());
 
         return getRuntime().getNil();
     }

    
fix_to_sym
 
     @JRubyMethod(compat = )
     public IRubyObject to_sym() {
         RubySymbol symbol = RubySymbol.getSymbolLong(getRuntime(), );
         
         return symbol != null ? symbol : getRuntime().getNil(); 
     }

    
fix_uminus
 
     @JRubyMethod(name = "-@")
     public IRubyObject op_uminus() {
         if ( == ) { // a gotcha
             return RubyBignum.newBignum(getRuntime(), BigInteger.valueOf().negate());
         }
         return RubyFixnum.newFixnum(getRuntime(), -);
     }

    
fix_plus
 
     @JRubyMethod(name = "+")
     public IRubyObject op_plus(ThreadContext contextIRubyObject other) {
         if (other instanceof RubyFixnum) {
             return addFixnum(context, (RubyFixnum)other);
         }
         return addOther(contextother);
     }
     
     public IRubyObject op_plus(ThreadContext contextlong otherValue) {
         long result =  + otherValue;
         if (additionOverflowed(otherValueresult)) {
             return addAsBignum(contextotherValue);
         }
         return newFixnum(context.runtimeresult);
     }
     
     public IRubyObject op_plus_one(ThreadContext context) {
         long result =  + 1;
         if (result == .) {
             return addAsBignum(context, 1);
         }
         return newFixnum(context.runtimeresult);
     }
     
     public IRubyObject op_plus_two(ThreadContext context) {
         long result =  + 2;
     //- if (result == Long.MIN_VALUE + 1) {     //-code
         if (result < ) {                   //+code+patch; maybe use  if (result <= value) {
             return addAsBignum(context, 2);
         }
         return newFixnum(context.runtimeresult);
     }
     
     private IRubyObject addFixnum(ThreadContext contextRubyFixnum other) {
         long otherValue = other.value;
         long result =  + otherValue;
         if (additionOverflowed(otherValueresult)) {
             return addAsBignum(contextother);
         }
         return newFixnum(context.runtimeresult);
     }
     
     private static boolean additionOverflowed(long originallong otherlong result) {
         return (~(original ^ other) & (original ^ result) & ) != 0;
     }
     
     private static boolean subtractionOverflowed(long originallong otherlong result) {
         return (~(original ^ ~other) & (original ^ result) & ) != 0;
     }
     
     private IRubyObject addAsBignum(ThreadContext contextRubyFixnum other) {
         return RubyBignum.newBignum(context.runtime).op_plus(contextother);
     }
 
     private IRubyObject addAsBignum(ThreadContext contextlong other) {
         return RubyBignum.newBignum(context.runtime).op_plus(contextother);
     }
     
     private IRubyObject addOther(ThreadContext contextIRubyObject other) {
         if (other instanceof RubyBignum) {
             return ((RubyBignumother).op_plus(contextthis);
         }
         if (other instanceof RubyFloat) {
             return context.runtime.newFloat((double + ((RubyFloatother).getDoubleValue());
         }
         return coerceBin(context"+"other);
     }

    
fix_minus
 
     @JRubyMethod(name = "-")
     public IRubyObject op_minus(ThreadContext contextIRubyObject other) {
         if (other instanceof RubyFixnum) {
             return subtractFixnum(context, (RubyFixnum)other);
         }
         return subtractOther(contextother);
     }
 
     public IRubyObject op_minus(ThreadContext contextlong otherValue) {
         long result =  - otherValue;
         if (subtractionOverflowed(otherValueresult)) {
             return subtractAsBignum(contextotherValue);
         }
         return newFixnum(context.runtimeresult);
     }
 
     public IRubyObject op_minus_one(ThreadContext context) {
         long result =  - 1;
         if (result == .) {
             return subtractAsBignum(context, 1);
         }
         return newFixnum(context.runtimeresult);
     }
 
     public IRubyObject op_minus_two(ThreadContext context) {
         long result =  - 2;
     //- if (result == Long.MAX_VALUE - 1) {     //-code
         if ( < result) {                   //+code+patch; maybe use  if (value <= result) {
             return subtractAsBignum(context, 2);
         }
         return newFixnum(context.runtimeresult);
     }
 
     private IRubyObject subtractFixnum(ThreadContext contextRubyFixnum other) {
         long otherValue = other.value;
         long result =  - otherValue;
         if (subtractionOverflowed(otherValueresult)) {
             return subtractAsBignum(contextother);
         }
         return newFixnum(context.runtimeresult);
     }
     
     private IRubyObject subtractAsBignum(ThreadContext contextRubyFixnum other) {
         return RubyBignum.newBignum(context.runtime).op_minus(contextother);
     }
 
     private IRubyObject subtractAsBignum(ThreadContext contextlong other) {
         return RubyBignum.newBignum(context.runtime).op_minus(contextother);
     }
     
     private IRubyObject subtractOther(ThreadContext contextIRubyObject other) {
         if (other instanceof RubyBignum) {
             return RubyBignum.newBignum(context.runtime).op_minus(contextother);
         } else if (other instanceof RubyFloat) {
             return context.runtime.newFloat((double - ((RubyFloatother).getDoubleValue());
         }
         return coerceBin(context"-"other);
     }

    
fix_mul
 
     @JRubyMethod(name = "*")
     public IRubyObject op_mul(ThreadContext contextIRubyObject other) {
         if (other instanceof RubyFixnum) {
             return multiplyFixnum(contextother);
         } else {
             return multiplyOther(contextother);
         }
     }
 
     private IRubyObject multiplyFixnum(ThreadContext contextIRubyObject other) {
         return op_mul(context, ((RubyFixnumother).);
     }
 
     private IRubyObject multiplyOther(ThreadContext contextIRubyObject other) {
         Ruby runtime = context.runtime;
         if (other instanceof RubyBignum) {
             return ((RubyBignumother).op_mul(contextthis);
         } else if (other instanceof RubyFloat) {
             return runtime.newFloat((double * ((RubyFloatother).getDoubleValue());
         }
         return coerceBin(context"*"other);
     }
 
     public IRubyObject op_mul(ThreadContext contextlong otherValue) {
         // See JRUBY-6612 for reasons for these different cases.
         // The problem is that these Java long calculations overflow:
         //   value == -1; otherValue == Long.MIN_VALUE;
         //   result = value * othervalue;  #=> Long.MIN_VALUE (overflow)
         //   result / value  #=>  Long.MIN_VALUE (overflow) == otherValue
         Ruby runtime = context.runtime;
         if ( == 0) {
             return RubyFixnum.zero(runtime);
         }
         if ( == -1) {
             if (otherValue != .) {
                 return newFixnum(runtime, -otherValue);
             }
         } else {
             long result =  * otherValue;
             if (result /  == otherValue) {
                 return newFixnum(runtimeresult);
             }
         }
         // if here (value * otherValue) overflows long, so must return Bignum
         return RubyBignum.newBignum(runtime).op_mul(contextotherValue);
     }

    
fix_div here is terrible MRI gotcha: 1.div 3.0 -> 0 1 / 3.0 -> 0.3333333333333333 MRI is also able to do it in one place by looking at current frame in rb_num_coerce_bin: rb_funcall(x, ruby_frame->orig_func, 1, y); also note that RubyFloat doesn't override Numeric.div
 
     @JRubyMethod(name = "div")
     public IRubyObject div_div(ThreadContext contextIRubyObject other) {
         if (context.is19checkZeroDivisionError(contextother);
         return idiv(contextother"div");
     }
     	
     @JRubyMethod(name = "/")
     public IRubyObject op_div(ThreadContext contextIRubyObject other) {
         return idiv(contextother"/");
     }
 
     public IRubyObject op_div(ThreadContext contextlong other) {
         return idiv(contextother"/");
     }
 
     @JRubyMethod(name = {"odd?"}, compat = )
     public RubyBoolean odd_p(ThreadContext context) {
         if(%2 != 0) {
             return context.runtime.getTrue();
         }
         return context.runtime.getFalse();
     }
 
     @JRubyMethod(name = {"even?"}, compat = )
     public RubyBoolean even_p(ThreadContext context) {
         if(%2 == 0) {
             return context.runtime.getTrue();
         }
         return context.runtime.getFalse();
     }
 
     @JRubyMethod(compat = )
     public IRubyObject pred(ThreadContext context) {
         return context.runtime.newFixnum(-1);
     }
 
     public IRubyObject idiv(ThreadContext contextIRubyObject otherString method) {
         if (other instanceof RubyFixnum) {
             return idivLong(context, ((RubyFixnumother).);
         } 
         return coerceBin(contextmethodother);
     }
 
     public IRubyObject idiv(ThreadContext contextlong yString method) {
         long x = ;
 
         return idivLong(contextxy);
     }
 
     private IRubyObject idivLong(ThreadContext contextlong xlong y) {
         Ruby runtime = context.runtime;
         if (y == 0) {
             throw runtime.newZeroDivisionError();
         }
         long result;
         if (y > 0) {
             if (x >= 0) {
                 result = x / y;          // x >= 0, y > 0;
             } else {
                 result = (x + 1) / y - 1;  // x < 0, y > 0;  // OOPS "=" was omitted
             }
         } else if (x > 0) {
             result = (x - 1) / y - 1;    // x > 0, y < 0;
         } else if (y == -1) {
             if (x == ) {
                 return RubyBignum.newBignum(runtime, BigInteger.valueOf(x).negate());
             }
             result = -x;
         } else {
             result = x / y;  // x <= 0, y < 0;
         }
         return runtime.newFixnum(result);
     }
        
    
fix_mod
 
     @JRubyMethod(name = {"%""modulo"})
     public IRubyObject op_mod(ThreadContext contextIRubyObject other) {
         if (context.runtime.is1_9()) checkZeroDivisionError(contextother);
         if (other instanceof RubyFixnum) {
             return moduloFixnum(context, (RubyFixnum)other);
         }
         return coerceBin(context"%"other);
     }
     
     public IRubyObject op_mod(ThreadContext contextlong other) {
         return moduloFixnum(contextother);
     }
 
     private IRubyObject moduloFixnum(ThreadContext contextRubyFixnum other) {
         return moduloFixnum(contextother.value);
     }
 
     private IRubyObject moduloFixnum(ThreadContext contextlong other) {
         // Java / and % are not the same as ruby
         long x = ;
         long y = other;
         if (y == 0) {
             throw context.runtime.newZeroDivisionError();
         }
         long mod = x % y;
         if (mod < 0 && y > 0 || mod > 0 && y < 0) {
             mod += y;
         }
         return context.runtime.newFixnum(mod);
     }
                
    
fix_divmod
 
     @JRubyMethod(name = "divmod")
     @Override
     public IRubyObject divmod(ThreadContext contextIRubyObject other) {
         if (context.runtime.is1_9()) checkZeroDivisionError(contextother);
         if (other instanceof RubyFixnum) {
             return divmodFixnum(contextother);
         }
         return coerceBin(context"divmod"other);
     }
 
     private IRubyObject divmodFixnum(ThreadContext contextIRubyObject other) {
         long x = ;
         long y = ((RubyFixnumother).;
         final Ruby runtime = context.runtime;
         if (y == 0) {
             throw runtime.newZeroDivisionError();
         }
 
         long mod;
         IRubyObject integerDiv;
         if (y == -1) {
             if (x == ) {
                 integerDiv = RubyBignum.newBignum(runtime, BigInteger.valueOf(x).negate());
             } else {
                 integerDiv = RubyFixnum.newFixnum(runtime, -x);
             }
             mod = 0;
         } else {
             long div = x / y;
             // Next line avoids using the slow: mod = x % y,
             // and I believe there is no possibility of integer overflow.
             mod = x - y * div;
             if (mod < 0 && y > 0 || mod > 0 && y < 0) {
                 div -= 1; // horrible sudden thought: might this overflow? probably not?
                 mod += y;
             }
             integerDiv = RubyFixnum.newFixnum(runtimediv);
         }
         IRubyObject fixMod = RubyFixnum.newFixnum(runtimemod);
         return RubyArray.newArray(runtimeintegerDivfixMod);
     }
    
    
fix_quo
 
     @JRubyMethod(name = "quo", compat = )
     @Override
     public IRubyObject quo(ThreadContext contextIRubyObject other) {
         if (other instanceof RubyFixnum) {
             return RubyFloat.newFloat(context.runtime, (double / (double) ((RubyFixnumother).);
         } else if (other instanceof RubyBignum) {
             return RubyFloat.newFloat(context.runtime, (double / (double) ((RubyBignumother).getDoubleValue());
         }
         return coerceBin(context"quo"other);
     }

    
fix_pow
 
     @JRubyMethod(name = "**")
     public IRubyObject op_pow(ThreadContext contextIRubyObject other) {
         if (context.is19return op_pow_19(contextother);
         if(other instanceof RubyFixnum) {
             return powerFixnum(context, ((RubyFixnum)other).);
         } else {
             return powerOther(contextother);
         }
     }
 
     public IRubyObject op_pow(ThreadContext contextlong other) {
         // FIXME this needs to do the right thing for 1.9 mode before we can use it
         if (context.is19throw context.runtime.newRuntimeError("bug: using direct op_pow(long) in 1.8 mode");
         return powerFixnum(contextother);
     }
 
     private IRubyObject powerFixnum(ThreadContext contextlong other) {
         Ruby runtime = context.runtime;
         if (other == 0) {
             return RubyFixnum.one(runtime);
         }
         if (other == 1) {
             return this;
         }
         if (other > 0) {
             return RubyBignum.newBignum(runtime).op_pow(contextother);
         }
         return RubyFloat.newFloat(runtime, Math.pow(other));
     }
 
     private IRubyObject powerOther(ThreadContext contextIRubyObject other) {
         Ruby runtime = context.runtime;
         if (other instanceof RubyFloat) {
             return RubyFloat.newFloat(runtime, Math.pow(, ((RubyFloatother)
                     .getDoubleValue()));
         }
         return coerceBin(context"**"other);
     }
 
     public IRubyObject op_pow_19(ThreadContext contextIRubyObject other) {
         if (other instanceof RubyNumeric) {
             double d_other = ((RubyNumericother).getDoubleValue();
             if ( < 0 && (d_other != Math.round(d_other))) {
                 return RubyComplex.newComplexRaw(getRuntime(), this).callMethod(context"**"other);
             }
             if (other instanceof RubyFixnum) {
                 return powerFixnum19(contextother);
             }
         }
         return powerOther19(contextother);
     }
 
     private IRubyObject powerOther19(ThreadContext contextIRubyObject other) {
         Ruby runtime = context.runtime;
         long a = ;
         if (other instanceof RubyBignum) {
             if (other.callMethod(context"<", RubyFixnum.zero(runtime)).isTrue()) {
                 return RubyRational.newRationalRaw(runtimethis).callMethod(context"**"other);
             }
             if (a == 0) return RubyFixnum.zero(runtime);
             if (a == 1) return RubyFixnum.one(runtime);
             if (a == -1) {
                 return ((RubyBignum)other).even_p(context).isTrue() ? RubyFixnum.one(runtime) : RubyFixnum.minus_one(runtime);
             }
             RubyBignum.newBignum(runtime, RubyBignum.fix2big(this)).op_pow(contextother);
         } else if (other instanceof RubyFloat) {
             double b = ((RubyFloat)other).getValue();
             if (b == 0.0 || a == 1) return runtime.newFloat(1.0);
             if (a == 0) return runtime.newFloat(b < 0 ? 1.0 / 0.0 : 0.0);
             return RubyFloat.newFloat(runtime, Math.pow(ab));
         }
         return coerceBin(context"**"other);
     }
 
     private IRubyObject powerFixnum19(ThreadContext contextIRubyObject other) {
         Ruby runtime = context.runtime;
         long a = ;
         long b = ((RubyFixnumother).;
         if (b < 0) {
             return RubyRational.newRationalRaw(runtimethis).callMethod(context"**"other);
         }
         if (b == 0) {
             return RubyFixnum.one(runtime);
         }
         if (b == 1) {
             return this;
         }
         if (a == 0) {
             return b > 0 ? RubyFixnum.zero(runtime) : RubyNumeric.dbl2num(runtime, 1.0 / 0.0);
         }
         if (a == 1) {
             return RubyFixnum.one(runtime);
         }
         if (a == -1) {
             return b % 2 == 0 ? RubyFixnum.one(runtime) : RubyFixnum.minus_one(runtime);
         }
         return Numeric.int_pow(contextab);
     }

    
fix_abs
 
     @JRubyMethod
     @Override
     public IRubyObject abs(ThreadContext context) {
         if ( < 0) {
             // A gotcha for Long.MIN_VALUE: value = -value
             if ( == .) {
                 return RubyBignum.newBignum(
                         context.runtime, BigInteger.valueOf().negate());
             }
             return RubyFixnum.newFixnum(context.runtime, -);
         }
         return this;
     }

    
fix_abs/1.9
 
     @JRubyMethod(name = "magnitude", compat = )
     @Override
     public IRubyObject magnitude(ThreadContext context) {
         return abs(context);
     }

    
fix_equal
 
     @JRubyMethod(name = "==")
     @Override
     public IRubyObject op_equal(ThreadContext contextIRubyObject other) {
         if (other instanceof RubyFixnumreturn op_equal(context, ((RubyFixnumother).);
         return context.is19 ?
                 op_equalOther(contextother) :
                 super.op_num_equal(contextother);
     }
 
     public IRubyObject op_equal(ThreadContext contextlong other) {
         return RubyBoolean.newBoolean(context.runtime == other);
     }
 
     public boolean op_equal_boolean(ThreadContext contextlong other) {
         return  == other;
     }
 
     public boolean fastEqual(RubyFixnum other) {
         return  == other.value;
     }
 
     private IRubyObject op_equalOther(ThreadContext contextIRubyObject other) {
         if (other instanceof RubyBignum) {
             return RubyBoolean.newBoolean(context.runtime,
                     BigInteger.valueOf().compareTo(((RubyBignumother).getValue()) == 0);
         }
         if (other instanceof RubyFloat) {
             return RubyBoolean.newBoolean(context.runtime, (double == ((RubyFloatother).getDoubleValue());
         }
         return super.op_num_equal(contextother);
     }
 
     @Override
     public final int compareTo(IRubyObject other) {
         if (other instanceof RubyFixnum) {
             long otherValue = ((RubyFixnum)other).;
             return  == otherValue ? 0 :  > otherValue ? 1 : -1; 
         }
         return compareToOther(other);
     }
 
     private int compareToOther(IRubyObject other) {
         if (other instanceof RubyBignumreturn BigInteger.valueOf().compareTo(((RubyBignum)other).getValue());
         if (other instanceof RubyFloatreturn Double.compare((double), ((RubyFloat)other).getDoubleValue());
         return (int)coerceCmp(getRuntime().getCurrentContext(), "<=>"other).convertToInteger().getLongValue();
     }

    
fix_cmp
 
     @JRubyMethod(name = "<=>")
     public IRubyObject op_cmp(ThreadContext contextIRubyObject other) {
         if (other instanceof RubyFixnumreturn op_cmp(context, ((RubyFixnum)other).);
         return context.is19 ?
                 compareOther(contextother) :
                 coerceCmp(context"<=>"other);
     }
 
     public IRubyObject op_cmp(ThreadContext contextlong other) {
         Ruby runtime = context.runtime;
         return  == other ? RubyFixnum.zero(runtime) :  > other ?
                 RubyFixnum.one(runtime) : RubyFixnum.minus_one(runtime);
     }
 
     private IRubyObject compareOther(ThreadContext contextIRubyObject other) {
         if (other instanceof RubyBignum) {
             return newFixnum(context.runtime, BigInteger.valueOf().compareTo(((RubyBignum)other).getValue()));
         }
         if (other instanceof RubyFloat) {
             return dbl_cmp(context.runtime, (double), ((RubyFloat)other).getDoubleValue());
         }
         return coerceCmp(context"<=>"other);
     }

    
fix_gt
 
     @JRubyMethod(name = ">")
     public IRubyObject op_gt(ThreadContext contextIRubyObject other) {
         if (other instanceof RubyFixnum) {
             return RubyBoolean.newBoolean(context.runtime > ((RubyFixnumother).);
         }
         return context.is19 ?
                 op_gtOther(contextother) :
                 coerceRelOp(context">"other);
     }
 
     public IRubyObject op_gt(ThreadContext contextlong other) {
         return RubyBoolean.newBoolean(context.runtime > other);
     }
 
     public boolean op_gt_boolean(ThreadContext contextlong other) {
         return  > other;
     }
 
     private IRubyObject op_gtOther(ThreadContext contextIRubyObject other) {
         if (other instanceof RubyBignum) {
             return RubyBoolean.newBoolean(context.runtime,
                     BigInteger.valueOf().compareTo(((RubyBignumother).getValue()) > 0);
         }
         if (other instanceof RubyFloat) {
             return RubyBoolean.newBoolean(context.runtime, (double > ((RubyFloatother).getDoubleValue());
         }
         return coerceRelOp(context">"other);
     }

    
fix_ge
 
     @JRubyMethod(name = ">=")
     public IRubyObject op_ge(ThreadContext contextIRubyObject other) {
         if (other instanceof RubyFixnum) {
             return RubyBoolean.newBoolean(context.runtime >= ((RubyFixnumother).);
         }
         return context.is19 ?
                 op_geOther(contextother) :
                 coerceRelOp(context">="other);
     }
 
     public IRubyObject op_ge(ThreadContext contextlong other) {
         return RubyBoolean.newBoolean(context.runtime >= other);
     }
 
     public boolean op_ge_boolean(ThreadContext contextlong other) {
         return  >= other;
     }
 
     private IRubyObject op_geOther(ThreadContext contextIRubyObject other) {
         if (other instanceof RubyBignum) {
             return RubyBoolean.newBoolean(context.runtime,
                     BigInteger.valueOf().compareTo(((RubyBignumother).getValue()) >= 0);
         }
         if (other instanceof RubyFloat) {
             return RubyBoolean.newBoolean(context.runtime, (double >= ((RubyFloatother).getDoubleValue());
         }
         return coerceRelOp(context">="other);
     }

    
fix_lt
 
     @JRubyMethod(name = "<")
     public IRubyObject op_lt(ThreadContext contextIRubyObject other) {
         if (other instanceof RubyFixnum) {
             return RubyBoolean.newBoolean(context.runtime < ((RubyFixnumother).);
         }
         return context.is19 ?
                 op_ltOther(contextother) :
                 coerceRelOp(context"<"other);
     }
 
     public IRubyObject op_lt(ThreadContext contextlong other) {
         return RubyBoolean.newBoolean(context.runtime < other);
     }
 
     public boolean op_lt_boolean(ThreadContext contextlong other) {
         return  < other;
     }
 
     private IRubyObject op_ltOther(ThreadContext contextIRubyObject other) {
         if (other instanceof RubyBignum) {
             return RubyBoolean.newBoolean(context.runtime,
                     BigInteger.valueOf().compareTo(((RubyBignumother).getValue()) < 0);
        }
        if (other instanceof RubyFloat) {
            return RubyBoolean.newBoolean(context.runtime, (double < ((RubyFloatother).getDoubleValue());
        }
        return coerceRelOp(context"<"other);
    }

    
fix_le
    @JRubyMethod(name = "<=")
    public IRubyObject op_le(ThreadContext contextIRubyObject other) {
        if (other instanceof RubyFixnum) {
            return RubyBoolean.newBoolean(context.runtime <= ((RubyFixnumother).);
        }
        return context.is19 ?
                op_leOther(contextother) :
                coerceRelOp(context"<="other);
    }
    public IRubyObject op_le(ThreadContext contextlong other) {
        return RubyBoolean.newBoolean(context.runtime <= other);
    }
    public boolean op_le_boolean(ThreadContext contextlong other) {
        return  <= other;
    }
    private IRubyObject op_leOther(ThreadContext contextIRubyObject other) {
        if (other instanceof RubyBignum) {
            return RubyBoolean.newBoolean(context.runtime,
                    BigInteger.valueOf().compareTo(((RubyBignumother).