Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
1
   /*
2
    ***** BEGIN LICENSE BLOCK *****
3
    * Version: CPL 1.0/GPL 2.0/LGPL 2.1
4
    *
5
    * The contents of this file are subject to the Common Public
6
    * License Version 1.0 (the "License"); you may not use this file
7
    * except in compliance with the License. You may obtain a copy of
8
    * the License at http://www.eclipse.org/legal/cpl-v10.html
9
    *
10
   * Software distributed under the License is distributed on an "AS
11
   * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
12
   * implied. See the License for the specific language governing
13
   * rights and limitations under the License.
14
   *
15
   * Copyright (C) 2001 Alan Moore <alan_moore@gmx.net>
16
   * Copyright (C) 2001-2004 Jan Arne Petersen <jpetersen@uni-bonn.de>
17
   * Copyright (C) 2002 Benoit Cerrina <b.cerrina@wanadoo.fr>
18
   * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se>
19
   * Copyright (C) 2002-2006 Thomas E Enebo <enebo@acm.org>
20
   * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de>
21
   * Copyright (C) 2005 David Corbin <dcorbin@users.sourceforge.net>
22
   * Copyright (C) 2006 Antti Karanta <antti.karanta@napa.fi>
23
   * Copyright (C) 2007 Miguel Covarrubias <mlcovarrubias@gmail.com>
24
   * 
25
   * Alternatively, the contents of this file may be used under the terms of
26
   * either of the GNU General Public License Version 2 or later (the "GPL"),
27
   * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
28
   * in which case the provisions of the GPL or the LGPL are applicable instead
29
   * of those above. If you wish to allow use of your version of this file only
30
   * under the terms of either the GPL or the LGPL, and not to allow others to
31
   * use your version of this file under the terms of the CPL, indicate your
32
   * decision by deleting the provisions above and replace them with the notice
33
   * and other provisions required by the GPL or the LGPL. If you do not delete
34
   * the provisions above, a recipient may use your version of this file under
35
   * the terms of any one of the CPL, the GPL or the LGPL.
36
   ***** END LICENSE BLOCK *****/
37
  package org.jruby;
38
  
40
  import java.util.HashMap;
41
  import java.util.Map;
42
  
58
  import static org.jruby.CompatVersion.*;

Implementation of the Fixnum class. 
62
  
63
  @JRubyClass(name="Fixnum", parent="Integer", include="Precision")
64
  public class RubyFixnum extends RubyInteger {
65
      
66
      public static RubyClass createFixnumClass(Ruby runtime) {
67
          RubyClass fixnum = runtime.defineClass("Fixnum", runtime.getInteger(),
68
                  .);
69
          runtime.setFixnum(fixnum);
70
  
71
          fixnum.index = .;
72
          fixnum.setReifiedClass(RubyFixnum.class);
73
          
74
          fixnum.kindOf = new RubyModule.KindOf() {
75
              @Override
76
              public boolean isKindOf(IRubyObject obj, RubyModule type) {
77
                  return obj instanceof RubyFixnum;
78
              }
79
          };
80
  
81
          if (!runtime.is1_9()) {
82
              fixnum.includeModule(runtime.getPrecision());
83
          }
84
  
85
          fixnum.defineAnnotatedMethods(RubyFixnum.class);
86
          
87
          for (int i = 0; i < runtime.fixnumCache.length; i++) {
88
              runtime.fixnumCache[i] = new RubyFixnum(fixnum, i - );
89
          }
90
  
91
          return fixnum;
92
      }
93
      
94
      private final long value;
95
      private static final int BIT_SIZE = 64;
96
      public static final long SIGN_BIT = (1L << ( - 1));
97
      public static final long MAX = (1L<<( - 1)) - 1;
98
      public static final long MIN = -1 *  - 1;
99
      public static final long MAX_MARSHAL_FIXNUM = (1L << 30) - 1; // 0x3fff_ffff
100
     public static final long MIN_MARSHAL_FIXNUM = - (1L << 30);   // -0x4000_0000
101
     public static final int CACHE_OFFSET = 256;
102
 
103
     private static IRubyObject fixCoerce(IRubyObject x) {
104
         do {
105
             x = x.convertToInteger();
106
         } while (!(x instanceof RubyFixnum) && !(x instanceof RubyBignum));
107
         return x;
108
     }
109
     
110
     private static IRubyObject bitCoerce(IRubyObject x) {
111
         do {
112
             if (x instanceof RubyFloat)
113
                 throw x.getRuntime().newTypeError("can't convert Float to Integer");
114
             x = x.convertToInteger("to_int");
115
         } while (!(x instanceof RubyFixnum) && !(x instanceof RubyBignum));
116
         return x;
117
     }
118
     
119
     public RubyFixnum(Ruby runtime) {
120
         this(runtime, 0);
121
     }
122
 
123
     public RubyFixnum(Ruby runtime, long value) {
124
         super(runtime.getFixnum());
125
         this. = value;
126
     }
127
     
128
     private RubyFixnum(RubyClass klazz, long value) {
129
         super(klazz);
130
         this. = value;
131
     }
132
     
133
     @Override
134
     public int getNativeTypeIndex() {
135
         return .;
136
     }
    
    
short circuit for Fixnum key comparison 
140
 
141
     @Override
142
     public final boolean eql(IRubyObject other) {
143
         return other instanceof RubyFixnum &&  == ((RubyFixnum)other).;
144
     }
145
 
146
     @Override
147
     public IRubyObject equal_p(ThreadContext context, IRubyObject obj) {
148
         return equal_p19(context, obj);
149
     }
150
 
151
     @Override
152
     public IRubyObject equal_p19(ThreadContext context, IRubyObject obj) {
153
         return context.runtime.newBoolean(this == obj || eql(obj));
154
     }
155
     
156
     @Override
157
     public boolean isImmediate() {
158
     	return true;
159
     }
160
     
161
     @Override
162
     public RubyClass getSingletonClass() {
163
         throw getRuntime().newTypeError("can't define singleton");
164
     }
165
 
166
     @Override
167
     public Class<?> getJavaClass() {
168
         return long.class;
169
     }
170
 
171
     @Override
172
     public double getDoubleValue() {
173
         return ;
174
     }
175
 
176
     @Override
177
     public long getLongValue() {
178
         return ;
179
     }
180
 
181
     @Override
182
     public BigInteger getBigIntegerValue() {
183
         return BigInteger.valueOf();
184
     }
185
 
186
     public static RubyFixnum newFixnum(Ruby runtime, long value) {
187
         if (isInCacheRange(value)) {
188
             return runtime.fixnumCache[(int) value + ];
189
         }
190
         return new RubyFixnum(runtime, value);
191
     }
192
     
193
     private static boolean isInCacheRange(long value) {
194
         return value <=  - 1 && value >= -;
195
     }
196
 
197
     public RubyFixnum newFixnum(long newValue) {
198
         return newFixnum(getRuntime(), newValue);
199
     }
200
 
201
     public static RubyFixnum zero(Ruby runtime) {
202
         return runtime.fixnumCache[];
203
     }
204
 
205
     public static RubyFixnum one(Ruby runtime) {
206
         return runtime.fixnumCache[ + 1];
207
     }
208
     
209
     public static RubyFixnum two(Ruby runtime) {
210
         return runtime.fixnumCache[ + 2];
211
     }
212
     
213
     public static RubyFixnum three(Ruby runtime) {
214
         return runtime.fixnumCache[ + 3];
215
     }
216
     
217
     public static RubyFixnum four(Ruby runtime) {
218
         return runtime.fixnumCache[ + 4];
219
     }
220
     
221
     public static RubyFixnum five(Ruby runtime) {
222
         return runtime.fixnumCache[ + 5];
223
     }
224
 
225
     public static RubyFixnum minus_one(Ruby runtime) {
226
         return runtime.fixnumCache[ - 1];
227
     }
228
 
229
     @Override
230
     public RubyFixnum hash() {
231
         return newFixnum(hashCode());
232
     }
233
 
234
     @Override
235
     public final int hashCode() {
236
         return (int)( ^  >>> 32);
237
     }
238
 
239
     @Override
240
     public boolean equals(Object other) {
241
         if (other == this) {
242
             return true;
243
         }
244
         
245
         if (other instanceof RubyFixnum) { 
246
             RubyFixnum num = (RubyFixnum)other;
247
             
248
             if (num.value == ) {
249
                 return true;
250
             }
251
         }
252
         
253
         return false;
254
     }
255
 
256
     /*  ================
257
      *  Instance Methods
258
      *  ================ 
259
      */
260
     @Override
261
     @JRubyMethod
262
     public IRubyObject times(ThreadContext context, Block block) {
263
         if (block.isGiven()) {
264
             Ruby runtime = context.runtime;
265
             long lvalue = this.;
266
             if (block.getBody().getArgumentType() == .) {
267
                 IRubyObject nil = runtime.getNil();
268
                 for (long i = 0; i < lvalue; i++) {
269
                     block.yield(context, nil);
270
                 }
271
             } else {
272
                 for (long i = 0; i < lvalue; i++) {
273
                     block.yield(context, RubyFixnum.newFixnum(runtime, i));
274
                 }
275
             }
276
             return this;
277
         } else {
278
             return RubyEnumerator.enumeratorize(context.runtime, this, "times");
279
         }
280
     }

    
fix_to_s 
284
 
285
     public RubyString to_s(IRubyObject[] args) {
286
         switch (args.length) {
287
         case 0: return to_s();
288
         case 1: return to_s(args[0]);
289
         default: throw getRuntime().newArgumentError(args.length, 1);
290
         }
291
     }
292
     
293
     @JRubyMethod
294
     @Override
295
     public RubyString to_s() {
296
         int base = 10;
297
         ByteList bl = ConvertBytes.longToByteList(, base);
298
         if (getRuntime().is1_9()) bl.setEncoding(.);
299
         return getRuntime().newString(bl);
300
     }
301
     
302
     @JRubyMethod
303
     public RubyString to_s(IRubyObject arg0) {
304
         int base = num2int(arg0);
305
         if (base < 2 || base > 36) {
306
             throw getRuntime().newArgumentError("illegal radix " + base);
307
         }
308
         ByteList bl = ConvertBytes.longToByteList(, base);
309
         if (getRuntime().is1_9()) bl.setEncoding(.);
310
         return getRuntime().newString(bl);
311
     }

    
fix_id2name 
315
 
316
     @JRubyMethod
317
     public IRubyObject id2name() {
318
         RubySymbol symbol = RubySymbol.getSymbolLong(getRuntime(), );
319
         
320
         if (symbol != null) return getRuntime().newString(symbol.asJavaString());
321
 
322
         return getRuntime().getNil();
323
     }

    
fix_to_sym 
327
 
328
     @JRubyMethod(compat = )
329
     public IRubyObject to_sym() {
330
         RubySymbol symbol = RubySymbol.getSymbolLong(getRuntime(), );
331
         
332
         return symbol != null ? symbol : getRuntime().getNil(); 
333
     }

    
fix_uminus 
337
 
338
     @JRubyMethod(name = "-@")
339
     public IRubyObject op_uminus() {
340
         if ( == ) { // a gotcha
341
             return RubyBignum.newBignum(getRuntime(), BigInteger.valueOf().negate());
342
         }
343
         return RubyFixnum.newFixnum(getRuntime(), -);
344
     }

    
fix_plus 
348
 
349
     @JRubyMethod(name = "+")
350
     public IRubyObject op_plus(ThreadContext context, IRubyObject other) {
351
         if (other instanceof RubyFixnum) {
352
             return addFixnum(context, (RubyFixnum)other);
353
         }
354
         return addOther(context, other);
355
     }
356
     
357
     public IRubyObject op_plus(ThreadContext context, long otherValue) {
358
         long result =  + otherValue;
359
         if (additionOverflowed(, otherValue, result)) {
360
             return addAsBignum(context, otherValue);
361
         }
362
         return newFixnum(context.runtime, result);
363
     }
364
     
365
     public IRubyObject op_plus_one(ThreadContext context) {
366
         long result =  + 1;
367
         if (result == .) {
368
             return addAsBignum(context, 1);
369
         }
370
         return newFixnum(context.runtime, result);
371
     }
372
     
373
     public IRubyObject op_plus_two(ThreadContext context) {
374
         long result =  + 2;
375
     //- if (result == Long.MIN_VALUE + 1) {     //-code
376
         if (result < ) {                   //+code+patch; maybe use  if (result <= value) {
377
             return addAsBignum(context, 2);
378
         }
379
         return newFixnum(context.runtime, result);
380
     }
381
     
382
     private IRubyObject addFixnum(ThreadContext context, RubyFixnum other) {
383
         long otherValue = other.value;
384
         long result =  + otherValue;
385
         if (additionOverflowed(, otherValue, result)) {
386
             return addAsBignum(context, other);
387
         }
388
         return newFixnum(context.runtime, result);
389
     }
390
     
391
     private static boolean additionOverflowed(long original, long other, long result) {
392
         return (~(original ^ other) & (original ^ result) & ) != 0;
393
     }
394
     
395
     private static boolean subtractionOverflowed(long original, long other, long result) {
396
         return (~(original ^ ~other) & (original ^ result) & ) != 0;
397
     }
398
     
399
     private IRubyObject addAsBignum(ThreadContext context, RubyFixnum other) {
400
         return RubyBignum.newBignum(context.runtime, ).op_plus(context, other);
401
     }
402
 
403
     private IRubyObject addAsBignum(ThreadContext context, long other) {
404
         return RubyBignum.newBignum(context.runtime, ).op_plus(context, other);
405
     }
406
     
407
     private IRubyObject addOther(ThreadContext context, IRubyObject other) {
408
         if (other instanceof RubyBignum) {
409
             return ((RubyBignum) other).op_plus(context, this);
410
         }
411
         if (other instanceof RubyFloat) {
412
             return context.runtime.newFloat((double)  + ((RubyFloat) other).getDoubleValue());
413
         }
414
         return coerceBin(context, "+", other);
415
     }

    
fix_minus 
419
 
420
     @JRubyMethod(name = "-")
421
     public IRubyObject op_minus(ThreadContext context, IRubyObject other) {
422
         if (other instanceof RubyFixnum) {
423
             return subtractFixnum(context, (RubyFixnum)other);
424
         }
425
         return subtractOther(context, other);
426
     }
427
 
428
     public IRubyObject op_minus(ThreadContext context, long otherValue) {
429
         long result =  - otherValue;
430
         if (subtractionOverflowed(, otherValue, result)) {
431
             return subtractAsBignum(context, otherValue);
432
         }
433
         return newFixnum(context.runtime, result);
434
     }
435
 
436
     public IRubyObject op_minus_one(ThreadContext context) {
437
         long result =  - 1;
438
         if (result == .) {
439
             return subtractAsBignum(context, 1);
440
         }
441
         return newFixnum(context.runtime, result);
442
     }
443
 
444
     public IRubyObject op_minus_two(ThreadContext context) {
445
         long result =  - 2;
446
     //- if (result == Long.MAX_VALUE - 1) {     //-code
447
         if ( < result) {                   //+code+patch; maybe use  if (value <= result) {
448
             return subtractAsBignum(context, 2);
449
         }
450
         return newFixnum(context.runtime, result);
451
     }
452
 
453
     private IRubyObject subtractFixnum(ThreadContext context, RubyFixnum other) {
454
         long otherValue = other.value;
455
         long result =  - otherValue;
456
         if (subtractionOverflowed(, otherValue, result)) {
457
             return subtractAsBignum(context, other);
458
         }
459
         return newFixnum(context.runtime, result);
460
     }
461
     
462
     private IRubyObject subtractAsBignum(ThreadContext context, RubyFixnum other) {
463
         return RubyBignum.newBignum(context.runtime, ).op_minus(context, other);
464
     }
465
 
466
     private IRubyObject subtractAsBignum(ThreadContext context, long other) {
467
         return RubyBignum.newBignum(context.runtime, ).op_minus(context, other);
468
     }
469
     
470
     private IRubyObject subtractOther(ThreadContext context, IRubyObject other) {
471
         if (other instanceof RubyBignum) {
472
             return RubyBignum.newBignum(context.runtime, ).op_minus(context, other);
473
         } else if (other instanceof RubyFloat) {
474
             return context.runtime.newFloat((double)  - ((RubyFloat) other).getDoubleValue());
475
         }
476
         return coerceBin(context, "-", other);
477
     }

    
fix_mul 
481
 
482
     @JRubyMethod(name = "*")
483
     public IRubyObject op_mul(ThreadContext context, IRubyObject other) {
484
         if (other instanceof RubyFixnum) {
485
             return multiplyFixnum(context, other);
486
         } else {
487
             return multiplyOther(context, other);
488
         }
489
     }
490
 
491
     private IRubyObject multiplyFixnum(ThreadContext context, IRubyObject other) {
492
         return op_mul(context, ((RubyFixnum) other).);
493
     }
494
 
495
     private IRubyObject multiplyOther(ThreadContext context, IRubyObject other) {
496
         Ruby runtime = context.runtime;
497
         if (other instanceof RubyBignum) {
498
             return ((RubyBignum) other).op_mul(context, this);
499
         } else if (other instanceof RubyFloat) {
500
             return runtime.newFloat((double)  * ((RubyFloat) other).getDoubleValue());
501
         }
502
         return coerceBin(context, "*", other);
503
     }
504
 
505
     public IRubyObject op_mul(ThreadContext context, long otherValue) {
506
         // See JRUBY-6612 for reasons for these different cases.
507
         // The problem is that these Java long calculations overflow:
508
         //   value == -1; otherValue == Long.MIN_VALUE;
509
         //   result = value * othervalue;  #=> Long.MIN_VALUE (overflow)
510
         //   result / value  #=>  Long.MIN_VALUE (overflow) == otherValue
511
         Ruby runtime = context.runtime;
512
         if ( == 0) {
513
             return RubyFixnum.zero(runtime);
514
         }
515
         if ( == -1) {
516
             if (otherValue != .) {
517
                 return newFixnum(runtime, -otherValue);
518
             }
519
         } else {
520
             long result =  * otherValue;
521
             if (result /  == otherValue) {
522
                 return newFixnum(runtime, result);
523
             }
524
         }
525
         // if here (value * otherValue) overflows long, so must return Bignum
526
         return RubyBignum.newBignum(runtime, ).op_mul(context, otherValue);
527
     }

    
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 
538
 
539
     @JRubyMethod(name = "div")
540
     public IRubyObject div_div(ThreadContext context, IRubyObject other) {
541
         if (context.is19) checkZeroDivisionError(context, other);
542
         return idiv(context, other, "div");
543
     }
544
     	
545
     @JRubyMethod(name = "/")
546
     public IRubyObject op_div(ThreadContext context, IRubyObject other) {
547
         return idiv(context, other, "/");
548
     }
549
 
550
     public IRubyObject op_div(ThreadContext context, long other) {
551
         return idiv(context, other, "/");
552
     }
553
 
554
     @JRubyMethod(name = {"odd?"}, compat = )
555
     public RubyBoolean odd_p(ThreadContext context) {
556
         if(%2 != 0) {
557
             return context.runtime.getTrue();
558
         }
559
         return context.runtime.getFalse();
560
     }
561
 
562
     @JRubyMethod(name = {"even?"}, compat = )
563
     public RubyBoolean even_p(ThreadContext context) {
564
         if(%2 == 0) {
565
             return context.runtime.getTrue();
566
         }
567
         return context.runtime.getFalse();
568
     }
569
 
570
     @JRubyMethod(compat = )
571
     public IRubyObject pred(ThreadContext context) {
572
         return context.runtime.newFixnum(-1);
573
     }
574
 
575
     public IRubyObject idiv(ThreadContext context, IRubyObject other, String method) {
576
         if (other instanceof RubyFixnum) {
577
             return idivLong(context, , ((RubyFixnum) other).);
578
         } 
579
         return coerceBin(context, method, other);
580
     }
581
 
582
     public IRubyObject idiv(ThreadContext context, long y, String method) {
583
         long x = ;
584
 
585
         return idivLong(context, x, y);
586
     }
587
 
588
     private IRubyObject idivLong(ThreadContext context, long x, long y) {
589
         Ruby runtime = context.runtime;
590
         if (y == 0) {
591
             throw runtime.newZeroDivisionError();
592
         }
593
         long result;
594
         if (y > 0) {
595
             if (x >= 0) {
596
                 result = x / y;          // x >= 0, y > 0;
597
             } else {
598
                 result = (x + 1) / y - 1;  // x < 0, y > 0;  // OOPS "=" was omitted
599
             }
600
         } else if (x > 0) {
601
             result = (x - 1) / y - 1;    // x > 0, y < 0;
602
         } else if (y == -1) {
603
             if (x == ) {
604
                 return RubyBignum.newBignum(runtime, BigInteger.valueOf(x).negate());
605
             }
606
             result = -x;
607
         } else {
608
             result = x / y;  // x <= 0, y < 0;
609
         }
610
         return runtime.newFixnum(result);
611
     }
        
    
fix_mod 
615
 
616
     @JRubyMethod(name = {"%", "modulo"})
617
     public IRubyObject op_mod(ThreadContext context, IRubyObject other) {
618
         if (context.runtime.is1_9()) checkZeroDivisionError(context, other);
619
         if (other instanceof RubyFixnum) {
620
             return moduloFixnum(context, (RubyFixnum)other);
621
         }
622
         return coerceBin(context, "%", other);
623
     }
624
     
625
     public IRubyObject op_mod(ThreadContext context, long other) {
626
         return moduloFixnum(context, other);
627
     }
628
 
629
     private IRubyObject moduloFixnum(ThreadContext context, RubyFixnum other) {
630
         return moduloFixnum(context, other.value);
631
     }
632
 
633
     private IRubyObject moduloFixnum(ThreadContext context, long other) {
634
         // Java / and % are not the same as ruby
635
         long x = ;
636
         long y = other;
637
         if (y == 0) {
638
             throw context.runtime.newZeroDivisionError();
639
         }
640
         long mod = x % y;
641
         if (mod < 0 && y > 0 || mod > 0 && y < 0) {
642
             mod += y;
643
         }
644
         return context.runtime.newFixnum(mod);
645
     }
                
    
fix_divmod 
649
 
650
     @JRubyMethod(name = "divmod")
651
     @Override
652
     public IRubyObject divmod(ThreadContext context, IRubyObject other) {
653
         if (context.runtime.is1_9()) checkZeroDivisionError(context, other);
654
         if (other instanceof RubyFixnum) {
655
             return divmodFixnum(context, other);
656
         }
657
         return coerceBin(context, "divmod", other);
658
     }
659
 
660
     private IRubyObject divmodFixnum(ThreadContext context, IRubyObject other) {
661
         long x = ;
662
         long y = ((RubyFixnum) other).;
663
         final Ruby runtime = context.runtime;
664
         if (y == 0) {
665
             throw runtime.newZeroDivisionError();
666
         }
667
 
668
         long mod;
669
         IRubyObject integerDiv;
670
         if (y == -1) {
671
             if (x == ) {
672
                 integerDiv = RubyBignum.newBignum(runtime, BigInteger.valueOf(x).negate());
673
             } else {
674
                 integerDiv = RubyFixnum.newFixnum(runtime, -x);
675
             }
676
             mod = 0;
677
         } else {
678
             long div = x / y;
679
             // Next line avoids using the slow: mod = x % y,
680
             // and I believe there is no possibility of integer overflow.
681
             mod = x - y * div;
682
             if (mod < 0 && y > 0 || mod > 0 && y < 0) {
683
                 div -= 1; // horrible sudden thought: might this overflow? probably not?
684
                 mod += y;
685
             }
686
             integerDiv = RubyFixnum.newFixnum(runtime, div);
687
         }
688
         IRubyObject fixMod = RubyFixnum.newFixnum(runtime, mod);
689
         return RubyArray.newArray(runtime, integerDiv, fixMod);
690
     }
    	
    
fix_quo 
694
 
695
     @JRubyMethod(name = "quo", compat = )
696
     @Override
697
     public IRubyObject quo(ThreadContext context, IRubyObject other) {
698
         if (other instanceof RubyFixnum) {
699
             return RubyFloat.newFloat(context.runtime, (double)  / (double) ((RubyFixnum) other).);
700
         } else if (other instanceof RubyBignum) {
701
             return RubyFloat.newFloat(context.runtime, (double)  / (double) ((RubyBignum) other).getDoubleValue());
702
         }
703
         return coerceBin(context, "quo", other);
704
     }

    
fix_pow 
708
 
709
     @JRubyMethod(name = "**")
710
     public IRubyObject op_pow(ThreadContext context, IRubyObject other) {
711
         if (context.is19) return op_pow_19(context, other);
712
         if(other instanceof RubyFixnum) {
713
             return powerFixnum(context, ((RubyFixnum)other).);
714
         } else {
715
             return powerOther(context, other);
716
         }
717
     }
718
 
719
     public IRubyObject op_pow(ThreadContext context, long other) {
720
         // FIXME this needs to do the right thing for 1.9 mode before we can use it
721
         if (context.is19) throw context.runtime.newRuntimeError("bug: using direct op_pow(long) in 1.8 mode");
722
         return powerFixnum(context, other);
723
     }
724
 
725
     private IRubyObject powerFixnum(ThreadContext context, long other) {
726
         Ruby runtime = context.runtime;
727
         if (other == 0) {
728
             return RubyFixnum.one(runtime);
729
         }
730
         if (other == 1) {
731
             return this;
732
         }
733
         if (other > 0) {
734
             return RubyBignum.newBignum(runtime, ).op_pow(context, other);
735
         }
736
         return RubyFloat.newFloat(runtime, Math.pow(, other));
737
     }
738
 
739
     private IRubyObject powerOther(ThreadContext context, IRubyObject other) {
740
         Ruby runtime = context.runtime;
741
         if (other instanceof RubyFloat) {
742
             return RubyFloat.newFloat(runtime, Math.pow(, ((RubyFloat) other)
743
                     .getDoubleValue()));
744
         }
745
         return coerceBin(context, "**", other);
746
     }
747
 
748
     public IRubyObject op_pow_19(ThreadContext context, IRubyObject other) {
749
         if (other instanceof RubyNumeric) {
750
             double d_other = ((RubyNumeric) other).getDoubleValue();
751
             if ( < 0 && (d_other != Math.round(d_other))) {
752
                 return RubyComplex.newComplexRaw(getRuntime(), this).callMethod(context, "**", other);
753
             }
754
             if (other instanceof RubyFixnum) {
755
                 return powerFixnum19(context, other);
756
             }
757
         }
758
         return powerOther19(context, other);
759
     }
760
 
761
     private IRubyObject powerOther19(ThreadContext context, IRubyObject other) {
762
         Ruby runtime = context.runtime;
763
         long a = ;
764
         if (other instanceof RubyBignum) {
765
             if (other.callMethod(context, "<", RubyFixnum.zero(runtime)).isTrue()) {
766
                 return RubyRational.newRationalRaw(runtime, this).callMethod(context, "**", other);
767
             }
768
             if (a == 0) return RubyFixnum.zero(runtime);
769
             if (a == 1) return RubyFixnum.one(runtime);
770
             if (a == -1) {
771
                 return ((RubyBignum)other).even_p(context).isTrue() ? RubyFixnum.one(runtime) : RubyFixnum.minus_one(runtime);
772
             }
773
             RubyBignum.newBignum(runtime, RubyBignum.fix2big(this)).op_pow(context, other);
774
         } else if (other instanceof RubyFloat) {
775
             double b = ((RubyFloat)other).getValue();
776
             if (b == 0.0 || a == 1) return runtime.newFloat(1.0);
777
             if (a == 0) return runtime.newFloat(b < 0 ? 1.0 / 0.0 : 0.0);
778
             return RubyFloat.newFloat(runtime, Math.pow(a, b));
779
         }
780
         return coerceBin(context, "**", other);
781
     }
782
 
783
     private IRubyObject powerFixnum19(ThreadContext context, IRubyObject other) {
784
         Ruby runtime = context.runtime;
785
         long a = ;
786
         long b = ((RubyFixnum) other).;
787
         if (b < 0) {
788
             return RubyRational.newRationalRaw(runtime, this).callMethod(context, "**", other);
789
         }
790
         if (b == 0) {
791
             return RubyFixnum.one(runtime);
792
         }
793
         if (b == 1) {
794
             return this;
795
         }
796
         if (a == 0) {
797
             return b > 0 ? RubyFixnum.zero(runtime) : RubyNumeric.dbl2num(runtime, 1.0 / 0.0);
798
         }
799
         if (a == 1) {
800
             return RubyFixnum.one(runtime);
801
         }
802
         if (a == -1) {
803
             return b % 2 == 0 ? RubyFixnum.one(runtime) : RubyFixnum.minus_one(runtime);
804
         }
805
         return Numeric.int_pow(context, a, b);
806
     }

    
fix_abs 
810
 
811
     @JRubyMethod
812
     @Override
813
     public IRubyObject abs(ThreadContext context) {
814
         if ( < 0) {
815
             // A gotcha for Long.MIN_VALUE: value = -value
816
             if ( == .) {
817
                 return RubyBignum.newBignum(
818
                         context.runtime, BigInteger.valueOf().negate());
819
             }
820
             return RubyFixnum.newFixnum(context.runtime, -);
821
         }
822
         return this;
823
     }

    
fix_abs/1.9 
827
 
828
     @JRubyMethod(name = "magnitude", compat = )
829
     @Override
830
     public IRubyObject magnitude(ThreadContext context) {
831
         return abs(context);
832
     }

    
fix_equal 
836
 
837
     @JRubyMethod(name = "==")
838
     @Override
839
     public IRubyObject op_equal(ThreadContext context, IRubyObject other) {
840
         if (other instanceof RubyFixnum) return op_equal(context, ((RubyFixnum) other).);
841
         return context.is19 ?
842
                 op_equalOther(context, other) :
843
                 super.op_num_equal(context, other);
844
     }
845
 
846
     public IRubyObject op_equal(ThreadContext context, long other) {
847
         return RubyBoolean.newBoolean(context.runtime,  == other);
848
     }
849
 
850
     public boolean op_equal_boolean(ThreadContext context, long other) {
851
         return  == other;
852
     }
853
 
854
     public boolean fastEqual(RubyFixnum other) {
855
         return  == other.value;
856
     }
857
 
858
     private IRubyObject op_equalOther(ThreadContext context, IRubyObject other) {
859
         if (other instanceof RubyBignum) {
860
             return RubyBoolean.newBoolean(context.runtime,
861
                     BigInteger.valueOf().compareTo(((RubyBignum) other).getValue()) == 0);
862
         }
863
         if (other instanceof RubyFloat) {
864
             return RubyBoolean.newBoolean(context.runtime, (double)  == ((RubyFloat) other).getDoubleValue());
865
         }
866
         return super.op_num_equal(context, other);
867
     }
868
 
869
     @Override
870
     public final int compareTo(IRubyObject other) {
871
         if (other instanceof RubyFixnum) {
872
             long otherValue = ((RubyFixnum)other).;
873
             return  == otherValue ? 0 :  > otherValue ? 1 : -1; 
874
         }
875
         return compareToOther(other);
876
     }
877
 
878
     private int compareToOther(IRubyObject other) {
879
         if (other instanceof RubyBignum) return BigInteger.valueOf().compareTo(((RubyBignum)other).getValue());
880
         if (other instanceof RubyFloat) return Double.compare((double), ((RubyFloat)other).getDoubleValue());
881
         return (int)coerceCmp(getRuntime().getCurrentContext(), "<=>", other).convertToInteger().getLongValue();
882
     }

    
fix_cmp 
886
 
887
     @JRubyMethod(name = "<=>")
888
     public IRubyObject op_cmp(ThreadContext context, IRubyObject other) {
889
         if (other instanceof RubyFixnum) return op_cmp(context, ((RubyFixnum)other).);
890
         return context.is19 ?
891
                 compareOther(context, other) :
892
                 coerceCmp(context, "<=>", other);
893
     }
894
 
895
     public IRubyObject op_cmp(ThreadContext context, long other) {
896
         Ruby runtime = context.runtime;
897
         return  == other ? RubyFixnum.zero(runtime) :  > other ?
898
                 RubyFixnum.one(runtime) : RubyFixnum.minus_one(runtime);
899
     }
900
 
901
     private IRubyObject compareOther(ThreadContext context, IRubyObject other) {
902
         if (other instanceof RubyBignum) {
903
             return newFixnum(context.runtime, BigInteger.valueOf().compareTo(((RubyBignum)other).getValue()));
904
         }
905
         if (other instanceof RubyFloat) {
906
             return dbl_cmp(context.runtime, (double), ((RubyFloat)other).getDoubleValue());
907
         }
908
         return coerceCmp(context, "<=>", other);
909
     }

    
fix_gt 
913
 
914
     @JRubyMethod(name = ">")
915
     public IRubyObject op_gt(ThreadContext context, IRubyObject other) {
916
         if (other instanceof RubyFixnum) {
917
             return RubyBoolean.newBoolean(context.runtime,  > ((RubyFixnum) other).);
918
         }
919
         return context.is19 ?
920
                 op_gtOther(context, other) :
921
                 coerceRelOp(context, ">", other);
922
     }
923
 
924
     public IRubyObject op_gt(ThreadContext context, long other) {
925
         return RubyBoolean.newBoolean(context.runtime,  > other);
926
     }
927
 
928
     public boolean op_gt_boolean(ThreadContext context, long other) {
929
         return  > other;
930
     }
931
 
932
     private IRubyObject op_gtOther(ThreadContext context, IRubyObject other) {
933
         if (other instanceof RubyBignum) {
934
             return RubyBoolean.newBoolean(context.runtime,
935
                     BigInteger.valueOf().compareTo(((RubyBignum) other).getValue()) > 0);
936
         }
937
         if (other instanceof RubyFloat) {
938
             return RubyBoolean.newBoolean(context.runtime, (double)  > ((RubyFloat) other).getDoubleValue());
939
         }
940
         return coerceRelOp(context, ">", other);
941
     }

    
fix_ge 
945
 
946
     @JRubyMethod(name = ">=")
947
     public IRubyObject op_ge(ThreadContext context, IRubyObject other) {
948
         if (other instanceof RubyFixnum) {
949
             return RubyBoolean.newBoolean(context.runtime,  >= ((RubyFixnum) other).);
950
         }
951
         return context.is19 ?
952
                 op_geOther(context, other) :
953
                 coerceRelOp(context, ">=", other);
954
     }
955
 
956
     public IRubyObject op_ge(ThreadContext context, long other) {
957
         return RubyBoolean.newBoolean(context.runtime,  >= other);
958
     }
959
 
960
     public boolean op_ge_boolean(ThreadContext context, long other) {
961
         return  >= other;
962
     }
963
 
964
     private IRubyObject op_geOther(ThreadContext context, IRubyObject other) {
965
         if (other instanceof RubyBignum) {
966
             return RubyBoolean.newBoolean(context.runtime,
967
                     BigInteger.valueOf().compareTo(((RubyBignum) other).getValue()) >= 0);
968
         }
969
         if (other instanceof RubyFloat) {
970
             return RubyBoolean.newBoolean(context.runtime, (double)  >= ((RubyFloat) other).getDoubleValue());
971
         }
972
         return coerceRelOp(context, ">=", other);
973
     }

    
fix_lt 
977
 
978
     @JRubyMethod(name = "<")
979
     public IRubyObject op_lt(ThreadContext context, IRubyObject other) {
980
         if (other instanceof RubyFixnum) {
981
             return RubyBoolean.newBoolean(context.runtime,  < ((RubyFixnum) other).);
982
         }
983
         return context.is19 ?
984
                 op_ltOther(context, other) :
985
                 coerceRelOp(context, "<", other);
986
     }
987
 
988
     public IRubyObject op_lt(ThreadContext context, long other) {
989
         return RubyBoolean.newBoolean(context.runtime,  < other);
990
     }
991
 
992
     public boolean op_lt_boolean(ThreadContext context, long other) {
993
         return  < other;
994
     }
995
 
996
     private IRubyObject op_ltOther(ThreadContext context, IRubyObject other) {
997
         if (other instanceof RubyBignum) {
998
             return RubyBoolean.newBoolean(context.runtime,
999
                     BigInteger.valueOf().compareTo(((RubyBignum) other).getValue()) < 0);
1000
        }
1001
        if (other instanceof RubyFloat) {
1002
            return RubyBoolean.newBoolean(context.runtime, (double)  < ((RubyFloat) other).getDoubleValue());
1003
        }
1004
        return coerceRelOp(context, "<", other);
1005
    }

    
fix_le 
1010
    @JRubyMethod(name = "<=")
1011
    public IRubyObject op_le(ThreadContext context, IRubyObject other) {
1012
        if (other instanceof RubyFixnum) {
1013
            return RubyBoolean.newBoolean(context.runtime,  <= ((RubyFixnum) other).);
1014
        }
1015
        return context.is19 ?
1016
                op_leOther(context, other) :
1017
                coerceRelOp(context, "<=", other);
1018
    }
1020
    public IRubyObject op_le(ThreadContext context, long other) {
1021
        return RubyBoolean.newBoolean(context.runtime,  <= other);
1022
    }
1024
    public boolean op_le_boolean(ThreadContext context, long other) {
1025
        return  <= other;
1026
    }
1028
    private IRubyObject op_leOther(ThreadContext context, IRubyObject other) {
1029
        if (other instanceof RubyBignum) {
1030
            return RubyBoolean.newBoolean(context.runtime,
1031
                    BigInteger.valueOf().compareTo(((