Find Usages Diff Raw Download HTML Widget
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 Benoit Cerrina <b.cerrina@wanadoo.fr> Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se> Copyright (C) 2002-2004 Thomas E Enebo <enebo@acm.org> Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> Copyright (C) 2006 Miguel Covarrubias <mlcovarrubias@gmail.com> Copyright (C) 2006 Antti Karanta <Antti.Karanta@napa.fi> 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 ***
34
  
35
  package org.jruby;
36
  
37
  import static org.jruby.RubyEnumerator.enumeratorize;
38
  import static org.jruby.util.Numeric.f_abs;
39
  import static org.jruby.util.Numeric.f_arg;
40
  import static org.jruby.util.Numeric.f_mul;
41
  import static org.jruby.util.Numeric.f_negative_p;
42
  
44
  
59
  import static org.jruby.CompatVersion.*;
60
  
61
  import static org.jruby.runtime.Helpers.invokedynamic;
62
  
Base class for all numerical types in ruby. 
67
  
68
  // TODO: Numeric.new works in Ruby and it does here too.  However trying to use
69
  //   that instance in a numeric operation should generate an ArgumentError. Doing
70
  //   this seems so pathological I do not see the need to fix this now.
71
  @JRubyClass(name="Numeric", include="Comparable")
72
  public class RubyNumeric extends RubyObject {
73
      
74
      public static RubyClass createNumericClass(Ruby runtime) {
75
          RubyClass numeric = runtime.defineClass("Numeric", runtime.getObject(), );
76
          runtime.setNumeric(numeric);
77
  
78
          numeric.index = .;
79
          numeric.setReifiedClass(RubyNumeric.class);
80
  
81
          numeric.kindOf = new RubyModule.JavaClassKindOf(RubyNumeric.class);
82
  
83
          numeric.includeModule(runtime.getComparable());
84
          numeric.defineAnnotatedMethods(RubyNumeric.class);
85
  
86
          return numeric;
87
      }
88
  
89
      protected static final ObjectAllocator NUMERIC_ALLOCATOR = new ObjectAllocator() {
90
          public IRubyObject allocate(Ruby runtime, RubyClass klass) {
91
              return new RubyNumeric(runtime, klass);
92
          }
93
      };
94
  
95
      public static final double DBL_EPSILON=2.2204460492503131e-16;
96
  
97
      private static IRubyObject convertToNum(double val, Ruby runtime) {
98
  
99
          if (val >= (double) . || val < (double) .) {
100
             return RubyBignum.newBignum(runtime, val);
101
         }
102
         return RubyFixnum.newFixnum(runtime, (long) val);
103
     }
104
     
105
     public RubyNumeric(Ruby runtime, RubyClass metaClass) {
106
         super(runtime, metaClass);
107
     }
108
 
109
     public RubyNumeric(RubyClass metaClass) {
110
         super(metaClass);
111
     }
112
 
113
     public RubyNumeric(Ruby runtime, RubyClass metaClass, boolean useObjectSpace) {
114
         super(runtime, metaClass, useObjectSpace);
115
     }    
116
 
117
     @Deprecated
118
     public RubyNumeric(Ruby runtime, RubyClass metaClass, boolean useObjectSpace, boolean canBeTainted) {
119
         super(runtime, metaClass, useObjectSpace, canBeTainted);
120
     }    
121
     
122
     // The implementations of these are all bonus (see TODO above)  I was going
123
     // to throw an error from these, but it appears to be the wrong place to
124
     // do it.
125
     public double getDoubleValue() {
126
         return 0;
127
     }
128
 
129
     public long getLongValue() {
130
         return 0;
131
     }
132
 
133
     public BigInteger getBigIntegerValue() {
134
         return .;
135
     }
136
     
137
     public static RubyNumeric newNumeric(Ruby runtime) {
138
     	return new RubyNumeric(runtime, runtime.getNumeric());
139
     }
140
 
141
     /*  ================
142
      *  Utility Methods
143
      *  ================ 
144
      */

    
rb_num2int, NUM2INT 
148
 
149
     public static int num2int(IRubyObject arg) {
150
         long num = num2long(arg);
151
 
152
         checkInt(arg, num);
153
         return (int)num;
154
     }
    
    
check_int 
158
 
159
     public static void checkInt(IRubyObject arg, long num){
160
         if (num < .) {
161
             tooSmall(arg, num);
162
         } else if (num > .) {
163
             tooBig(arg, num);
164
         } else {
165
             return;
166
         }
167
     }
168
     
169
     private static void tooSmall(IRubyObject arg, long num) {
170
         throw arg.getRuntime().newRangeError("integer " + num + " too small to convert to `int'");
171
     }
172
     
173
     private static void tooBig(IRubyObject arg, long num) {
174
         throw arg.getRuntime().newRangeError("integer " + num + " too big to convert to `int'");
175
     }

    
NUM2CHR 
179
 
180
     public static byte num2chr(IRubyObject arg) {
181
         if (arg instanceof RubyString) {
182
             String value = ((RubyString) arg).toString();
183
 
184
             if (value != null && value.length() > 0) return (byte) value.charAt(0);
185
         } 
186
 
187
         return (byte) num2int(arg);
188
     }

    
rb_num2long and FIX2LONG (numeric.c) 
192
 
193
     public static long num2long(IRubyObject arg) {
194
         if (arg instanceof RubyFixnum) {
195
             return ((RubyFixnum) arg).getLongValue();
196
         } else {
197
             return other2long(arg);
198
         }
199
     }
200
 
201
     private static long other2long(IRubyObject arg) throws RaiseException {
202
         if (arg.isNil()) {
203
             throw arg.getRuntime().newTypeError("no implicit conversion from nil to integer");
204
         } else if (arg instanceof RubyFloat) {
205
             return float2long((RubyFloat)arg);
206
         } else if (arg instanceof RubyBignum) {
207
             return RubyBignum.big2long((RubyBignum) arg);
208
         }
209
         return arg.convertToInteger().getLongValue();
210
     }
211
     
212
     private static long float2long(RubyFloat flt) {
213
         double aFloat = flt.getDoubleValue();
214
         if (aFloat <= (double) . && aFloat >= (double) .) {
215
             return (long) aFloat;
216
         } else {
217
             // TODO: number formatting here, MRI uses "%-.10g", 1.4 API is a must?
218
             throw flt.getRuntime().newRangeError("float " + aFloat + " out of range of integer");
219
         }
220
     }

    
rb_dbl2big + LONG2FIX at once (numeric.c) 
224
 
225
     public static IRubyObject dbl2num(Ruby runtime, double val) {
226
         if (Double.isInfinite(val)) {
227
             throw runtime.newFloatDomainError(val < 0 ? "-Infinity" : "Infinity");
228
         }
229
         if (Double.isNaN(val)) {
230
             throw runtime.newFloatDomainError("NaN");
231
         }
232
         return convertToNum(val, runtime);
233
     }

    
rb_num2dbl and NUM2DBL 
237
 
238
     public static double num2dbl(IRubyObject arg) {
239
         if (arg instanceof RubyFloat) {
240
             return ((RubyFloat) arg).getDoubleValue();
241
         } else if (arg instanceof RubyString) {
242
             throw arg.getRuntime().newTypeError("no implicit conversion to float from string");
243
         } else if (arg == arg.getRuntime().getNil()) {
244
             throw arg.getRuntime().newTypeError("no implicit conversion to float from nil");
245
         }
246
         return RubyKernel.new_float(arg, arg).getDoubleValue();
247
     }

    
rb_dbl_cmp (numeric.c) 
251
 
252
     public static IRubyObject dbl_cmp(Ruby runtime, double a, double b) {
253
         if (Double.isNaN(a) || Double.isNaN(b)) return runtime.getNil();
254
         return a == b ? RubyFixnum.zero(runtime) : a > b ?
255
                 RubyFixnum.one(runtime) : RubyFixnum.minus_one(runtime);
256
     }
257
 
258
     public static long fix2long(IRubyObject arg) {
259
         return ((RubyFixnum) arg).getLongValue();
260
     }
261
 
262
     public static int fix2int(IRubyObject arg) {
263
         long num = arg instanceof RubyFixnum ? fix2long(arg) : num2long(arg);
264
         checkInt(arg, num);
265
         return (int) num;
266
     }
267
 
268
     public static int fix2int(RubyFixnum arg) {
269
         long num = arg.getLongValue();
270
         checkInt(arg, num);
271
         return (int) num;
272
     }
273
 
274
     public static RubyInteger str2inum(Ruby runtime, RubyString str, int base) {
275
         return str2inum(runtime,str,base,false);
276
     }
277
 
278
     public static RubyNumeric int2fix(Ruby runtime, long val) {
279
         return RubyFixnum.newFixnum(runtime,val);
280
     }

    
rb_num2fix 
284
 
285
     public static IRubyObject num2fix(IRubyObject val) {
286
         if (val instanceof RubyFixnum) {
287
             return val;
288
         }
289
         if (val instanceof RubyBignum) {
290
             // any BigInteger is bigger than Fixnum and we don't have FIXABLE
291
             throw val.getRuntime().newRangeError("integer " + val + " out of range of fixnum");
292
         }
293
         return RubyFixnum.newFixnum(val.getRuntime(), num2long(val));
294
     }

    
Converts a string representation of an integer to the integer value. Parsing starts at the beginning of the string (after leading and trailing whitespace have been removed), and stops at the end or at the first character that can't be part of an integer. Leading signs are allowed. If base is zero, strings that begin with '0[xX]', '0[bB]', or '0' (optionally preceded by a sign) will be treated as hex, binary, or octal numbers, respectively. If a non-zero base is given, only the prefix (if any) that is appropriate to that base will be parsed correctly. For example, if the base is zero or 16, the string "0xff" will be converted to 256, but if the base is 10, it will come out as zero, since 'x' is not a valid decimal digit. If the string fails to parse as a number, zero is returned.

Parameters:
runtime the ruby runtime
str the string to be converted
base the expected base of the number (for example, 2, 8, 10, 16), or 0 if the method should determine the base automatically (defaults to 10). Values 0 and 2-36 are permitted. Any other value will result in an ArgumentError.
strict if true, enforce the strict criteria for String encoding of numeric values, as required by Integer('n'), and raise an exception when those criteria are not met. Otherwise, allow lax expression of values, as permitted by String#to_i, and return a value in almost all cases (excepting illegal radix). TODO: describe the rules/criteria
Returns:
a RubyFixnum or (if necessary) a RubyBignum representing the result of the conversion, which will be zero if the conversion failed.
325
 
326
     public static RubyInteger str2inum(Ruby runtime, RubyString str, int base, boolean strict) {
327
         ByteList s = str.getByteList();
328
         return ConvertBytes.byteListToInum(runtime, s, base, strict);
329
     }
330
 
331
     public static RubyFloat str2fnum(Ruby runtime, RubyString arg) {
332
         return str2fnum(runtime,arg,false);
333
     }

    
Converts a string representation of a floating-point number to the numeric value. Parsing starts at the beginning of the string (after leading and trailing whitespace have been removed), and stops at the end or at the first character that can't be part of a number. If the string fails to parse as a number, 0.0 is returned.

Parameters:
runtime the ruby runtime
arg the string to be converted
strict if true, enforce the strict criteria for String encoding of numeric values, as required by Float('n'), and raise an exception when those criteria are not met. Otherwise, allow lax expression of values, as permitted by String#to_f, and return a value in all cases. TODO: describe the rules/criteria
Returns:
a RubyFloat representing the result of the conversion, which will be 0.0 if the conversion failed.
352
 
353
     public static RubyFloat str2fnum(Ruby runtime, RubyString arg, boolean strict) {
354
         return str2fnumCommon(runtime, arg, strict, );
355
     }
356
     
357
     public static RubyFloat str2fnum19(Ruby runtime, RubyString arg, boolean strict) {
358
         return str2fnumCommon(runtime, arg, strict, );
359
     }
360
 
361
     private static RubyFloat str2fnumCommon(Ruby runtime, RubyString arg, boolean strict, ByteListCaller caller) {
362
         final double ZERO = 0.0;
363
         try {
364
             return new RubyFloat(runtime, caller.yield(arg, strict));
365
         } catch (NumberFormatException e) {
366
             if (strict) {
367
                 throw runtime.newArgumentError("invalid value for Float(): "
368
                         + arg.callMethod(runtime.getCurrentContext(), "inspect").toString());
369
             }
370
             return new RubyFloat(runtime,ZERO);
371
         }
372
     }
373
 
374
     private static interface ByteListCaller {
375
         public double yield(RubyString arg, boolean strict);
376
     }
377
 
378
     private static class ByteListCaller18 implements ByteListCaller {
379
         public double yield(RubyString arg, boolean strict) {
380
             return ConvertDouble.byteListToDouble(arg.getByteList(),strict);
381
         }
382
     }
383
     private static final ByteListCaller18 biteListCaller18 = new ByteListCaller18();
384
 
385
     private static class ByteListCaller19 implements ByteListCaller {
386
         public double yield(RubyString arg, boolean strict) {
387
             return ConvertDouble.byteListToDouble19(arg.getByteList(),strict);
388
         }
389
     }
390
     private static final ByteListCaller19 biteListCaller19 = new ByteListCaller19();

    
    
Numeric methods. (num_*) 
395
 
396
     
397
     protected IRubyObject[] getCoerced(ThreadContext context, IRubyObject other, boolean error) {
398
         IRubyObject result;
399
         
400
         try {
401
             result = other.callMethod(context, "coerce", this);
402
         } catch (RaiseException e) {
403
             if (error) {
404
                 throw getRuntime().newTypeError(
405
                         other.getMetaClass().getName() + " can't be coerced into " + getMetaClass().getName());
406
             }
407
              
408
             return null;
409
         }
410
         
411
         if (!(result instanceof RubyArray) || ((RubyArray)result).getLength() != 2) {
412
             throw getRuntime().newTypeError("coerce must return [x, y]");
413
         }
414
         
415
         return ((RubyArray)result).toJavaArray();
416
     }
417
 
418
     protected IRubyObject callCoerced(ThreadContext context, String method, IRubyObject other, boolean err) {
419
         IRubyObject[] args = getCoerced(context, other, err);
420
         if(args == null) {
421
             return getRuntime().getNil();
422
         }
423
         return args[0].callMethod(context, method, args[1]);
424
     }
425
 
426
     public IRubyObject callCoerced(ThreadContext context, String method, IRubyObject other) {
427
         IRubyObject[] args = getCoerced(context, other, false);
428
         if(args == null) {
429
             return getRuntime().getNil();
430
         }
431
         return args[0].callMethod(context, method, args[1]);
432
     }
433
     
434
     // beneath are rewritten coercions that reflect MRI logic, the aboves are used only by RubyBigDecimal
435
 
    
coerce_body 
438
 
439
     protected final IRubyObject coerceBody(ThreadContext context, IRubyObject other) {
440
         return other.callMethod(context, "coerce", this);
441
     }

    
do_coerce 
445
 
446
     protected final RubyArray doCoerce(ThreadContext context, IRubyObject other, boolean err) {
447
         IRubyObject result;
448
         try {
449
             result = coerceBody(context, other);
450
         } catch (RaiseException e) {
451
             if (err) {
452
                 throw getRuntime().newTypeError(
453
                         other.getMetaClass().getName() + " can't be coerced into " + getMetaClass().getName());
454
             }
455
             return null;
456
         }
457
     
458
         if (!(result instanceof RubyArray) || ((RubyArray) result).getLength() != 2) {
459
             if (err) {
460
                 throw getRuntime().newTypeError("coerce must return [x, y]");
461
             }
462
             return null;
463
         }
464
         return (RubyArray) result;
465
     }

    
rb_num_coerce_bin coercion taking two arguments 
469
 
470
     protected final IRubyObject coerceBin(ThreadContext context, String method, IRubyObject other) {
471
         RubyArray ary = doCoerce(context, other, true);
472
         return (ary.eltInternal(0)).callMethod(context, method, ary.eltInternal(1));
473
     }
    
    
rb_num_coerce_cmp coercion used for comparisons 
477
 
478
     protected final IRubyObject coerceCmp(ThreadContext context, String method, IRubyObject other) {
479
         RubyArray ary = doCoerce(context, other, false);
480
         if (ary == null) {
481
             return getRuntime().getNil(); // MRI does it!
482
         } 
483
         return (ary.eltInternal(0)).callMethod(context, method, ary.eltInternal(1));
484
     }
        
    
rb_num_coerce_relop coercion used for relative operators 
488
 
489
     protected final IRubyObject coerceRelOp(ThreadContext context, String method, IRubyObject other) {
490
         RubyArray ary = doCoerce(context, other, false);
491
         if (ary == null) {
492
             return RubyComparable.cmperr(this, other);
493
         }
494
 
495
         return unwrapCoerced(context, method, other, ary);
496
     }
497
     
498
     private final IRubyObject unwrapCoerced(ThreadContext context, String method, IRubyObject other, RubyArray ary) {
499
         IRubyObject result = (ary.eltInternal(0)).callMethod(context, method, ary.eltInternal(1));
500
         if (result.isNil()) {
501
             return RubyComparable.cmperr(this, other);
502
         }
503
         return result;
504
     }
505
         
506
     public RubyNumeric asNumeric() {
507
         return this;
508
     }
509
 
510
     /*  ================
511
      *  Instance Methods
512
      *  ================ 
513
      */

    
num_sadded 
517
 
518
     @JRubyMethod(name = "singleton_method_added")
519
     public IRubyObject sadded(IRubyObject name) {
520
         throw getRuntime().newTypeError("can't define singleton method " + name + " for " + getType().getName());
521
     } 
        
    
num_init_copy 
525
 
526
     @Override
527
     @JRubyMethod(name = "initialize_copy", visibility = .)
528
     public IRubyObject initialize_copy(IRubyObject arg) {
529
         throw getRuntime().newTypeError("can't copy " + getType().getName());
530
     }
    
    
num_coerce 
534
 
535
     @JRubyMethod(name = "coerce")
536
     public IRubyObject coerce(IRubyObject other) {
537
         if (getMetaClass() == other.getMetaClass()) return getRuntime().newArray(other, this);
538
 
539
         IRubyObject cdr = RubyKernel.new_float(this, this);
540
         IRubyObject car = RubyKernel.new_float(this, other);
541
 
542
         return getRuntime().newArray(car, cdr);
543
     }

    
num_uplus 
547
 
548
     @JRubyMethod(name = "+@")
549
     public IRubyObject op_uplus() {
550
         return this;
551
     }

    
num_imaginary 
555
 
556
     @JRubyMethod(name = "i", compat = .)
557
     public IRubyObject num_imaginary(ThreadContext context) {
558
         return RubyComplex.newComplexRaw(context.runtime, RubyFixnum.zero(context.runtime), this);
559
     }

    
num_uminus 
563
 
564
     @JRubyMethod(name = "-@")
565
     public IRubyObject op_uminus(ThreadContext context) {
566
         RubyArray ary = RubyFixnum.zero(context.runtime).doCoerce(context, this, true);
567
         return ary.eltInternal(0).callMethod(context, "-", ary.eltInternal(1));
568
     }
    
    
num_cmp 
572
 
573
     @JRubyMethod(name = "<=>")
574
     public IRubyObject op_cmp(IRubyObject other) {
575
         if (this == other) { // won't hurt fixnums
576
             return RubyFixnum.zero(getRuntime());
577
         }
578
         return getRuntime().getNil();
579
     }

    
num_eql 
583
 
584
     @JRubyMethod(name = "eql?")
585
     public IRubyObject eql_p(ThreadContext context, IRubyObject other) {
586
         if (getClass() != other.getClass()) return getRuntime().getFalse();
587
         return equalInternal(context, this, other) ? getRuntime().getTrue() : getRuntime().getFalse();
588
     }

    
num_quo (1.8) quo and fdiv in 1.8 just invokes "/" 
592
 
593
     @JRubyMethod(name = {"quo", "fdiv"}, compat = .)
594
     public IRubyObject quo(ThreadContext context, IRubyObject other) {
595
         return callMethod(context, "/", other);
596
     }
    
    
num_quo (1.9) 
600
 
601
     @JRubyMethod(name = "quo", compat = .)
602
     public IRubyObject quo_19(ThreadContext context, IRubyObject other) {
603
         return RubyRational.newRationalRaw(context.runtime, this).callMethod(context, "/", other);
604
     }

    
num_div 
608
 
609
     @JRubyMethod(name = "div", compat = )
610
     public IRubyObject div(ThreadContext context, IRubyObject other) {
611
         return callMethod(context, "/", other).convertToFloat().floor();
612
     }

    
num_div 
616
 
617
     @JRubyMethod(name = "div", compat = )
618
     public IRubyObject div19(ThreadContext context, IRubyObject other) {
619
         if (other instanceof RubyNumeric) {
620
             RubyNumeric numeric = (RubyNumeric) other;
621
             if (numeric.zero_p(context).isTrue()) {
622
                 throw context.runtime.newZeroDivisionError();
623
             }
624
         }
625
         return callMethod(context, "/", other).callMethod(context, "floor");
626
     }

    
num_divmod 
630
 
631
     @JRubyMethod(name = "divmod", compat = )
632
     public IRubyObject divmod(ThreadContext context, IRubyObject other) {
633
         return RubyArray.newArray(getRuntime(), div(context, other), modulo(context, other));
634
     }

    
num_divmod 
638
 
639
     @JRubyMethod(name = "divmod", compat = )
640
     public IRubyObject divmod19(ThreadContext context, IRubyObject other) {
641
         return RubyArray.newArray(getRuntime(), div(context, other), modulo19(context, other));
642
     }
    
    
num_fdiv (1.9)
644
 
645
     @JRubyMethod(name = "fdiv", compat = )
646
     public IRubyObject fdiv(ThreadContext context, IRubyObject other) {
647
         return Helpers.invoke(context, this.convertToFloat(), "/", other);
648
     }

    
num_modulo 
652
 
653
     @JRubyMethod(name = "modulo", compat = )
654
     public IRubyObject modulo(ThreadContext context, IRubyObject other) {
655
         return callMethod(context, "%", other);
656
     }

    
num_modulo 
660
 
661
     @JRubyMethod(name = "modulo", compat = )
662
     public IRubyObject modulo19(ThreadContext context, IRubyObject other) {
663
         return callMethod(context, "-", other.callMethod(context, "*", callMethod(context, "div", other)));
664
     }

    
num_remainder 
668
 
669
     @JRubyMethod(name = "remainder")
670
     public IRubyObject remainder(ThreadContext context, IRubyObject dividend) {
671
         IRubyObject z = callMethod(context, "%", dividend);
672
         IRubyObject x = this;
673
         RubyFixnum zero = RubyFixnum.zero(getRuntime());
674
 
675
         if (!equalInternal(context, z, zero) &&
676
                 ((x.callMethod(context, "<", zero).isTrue() &&
677
                 dividend.callMethod(context, ">", zero).isTrue()) ||
678
                 (x.callMethod(context, ">", zero).isTrue() &&
679
                 dividend.callMethod(context, "<", zero).isTrue()))) {
680
             return z.callMethod(context, "-", dividend);
681
         } else {
682
             return z;
683
         }
684
     }

    
num_abs 
688
 
689
     @JRubyMethod(name = "abs")
690
     public IRubyObject abs(ThreadContext context) {
691
         if (callMethod(context, "<", RubyFixnum.zero(getRuntime())).isTrue()) {
692
             return callMethod(context, "-@");
693
         }
694
         return this;
695
     }

    
num_abs/1.9 
699
 
700
     @JRubyMethod(name = "magnitude", compat = .)
701
     public IRubyObject magnitude(ThreadContext context) {
702
         return abs(context);
703
     }

    
num_to_int 
707
 
708
     @JRubyMethod(name = "to_int")
709
     public IRubyObject to_int(ThreadContext context) {
710
         return Helpers.invoke(context, this, "to_i");
711
     }

    
num_real_p 
715
 
716
     @JRubyMethod(name = "real?", compat = .)
717
     public IRubyObject scalar_p() {
718
         return getRuntime().getTrue();
719
     }

    
num_int_p 
723
 
724
     @JRubyMethod(name = "integer?")
725
     public IRubyObject integer_p() {
726
         return getRuntime().getFalse();
727
     }
    
    
num_zero_p 
731
 
732
     @JRubyMethod(name = "zero?")
733
     public IRubyObject zero_p(ThreadContext context) {
734
         return equalInternal(context, this, RubyFixnum.zero(getRuntime())) ? getRuntime().getTrue() : getRuntime().getFalse();
735
     }
    
    
num_nonzero_p 
739
 
740
     @JRubyMethod(name = "nonzero?")
741
     public IRubyObject nonzero_p(ThreadContext context) {
742
         if (callMethod(context, "zero?").isTrue()) {
743
             return getRuntime().getNil();
744
         }
745
         return this;
746
     }

    
num_floor 
750
 
751
     @JRubyMethod(name = "floor")
752
     public IRubyObject floor() {
753
         return convertToFloat().floor();
754
     }
        
    
num_ceil 
758
 
759
     @JRubyMethod(name = "ceil")
760
     public IRubyObject ceil() {
761
         return convertToFloat().ceil();
762
     }

    
num_round 
766
 
767
     @JRubyMethod(name = "round")
768
     public IRubyObject round() {
769
         return convertToFloat().round();
770
     }

    
num_truncate 
774
 
775
     @JRubyMethod(name = "truncate")
776
     public IRubyObject truncate() {
777
         return convertToFloat().truncate();
778
     }
779
 
780
     @JRubyMethod
781
     public IRubyObject step(ThreadContext context, IRubyObject arg0, Block block) {
782
         return block.isGiven() ? stepCommon(context, arg0, RubyFixnum.one(context.runtime), block) : enumeratorize(context.runtime, this, "step", arg0);
783
     }
784
 
785
     @JRubyMethod
786
     public IRubyObject step(ThreadContext context, IRubyObject to, IRubyObject step, Block block) {
787
         return block.isGiven() ? stepCommon(context, to, step, block) : enumeratorize(context.runtime, this, "step", new IRubyObject[] {to, step});
788
     }
789
 
790
     private IRubyObject stepCommon(ThreadContext context, IRubyObject to, IRubyObject step, Block block) {
791
         Ruby runtime = context.runtime;
792
         if (this instanceof RubyFixnum && to instanceof RubyFixnum && step instanceof RubyFixnum) {
793
             fixnumStep(context, runtime, ((RubyFixnum)this).getLongValue(),
794
                                          ((RubyFixnum)to).getLongValue(),
795
                                          ((RubyFixnum)step).getLongValue(),
796
                                           block);
797
         } else if (this instanceof RubyFloat || to instanceof RubyFloat || step instanceof RubyFloat) {
798
             floatStep19(context, runtime, this, to, step, false, block);
799
         } else {
800
             duckStep(context, runtime, this, to, step, block);
801
         }
802
         return this;
803
     }
804
 
805
     private static void fixnumStep(ThreadContext context, Ruby runtime, long from, long to, long step, Block block) {
806
         // We must avoid integer overflows in "i += step".
807
         if (step == 0) throw runtime.newArgumentError("step cannot be 0");
808
         if (step > 0) {
809
             long tov = . - step;
810
             if (to < tov) tov = to;
811
             long i;
812
             for (i = from; i <= tov; i += step) {
813
                 block.yield(context, RubyFixnum.newFixnum(runtime, i));
814
             }
815
             if (i <= to) {
816
                 block.yield(context, RubyFixnum.newFixnum(runtime, i));
817
             }
818
         } else {
819
             long tov = . - step;
820
             if (to > tov) tov = to;
821
             long i;
822
             for (i = from; i >= tov; i += step) {
823
                 block.yield(context, RubyFixnum.newFixnum(runtime, i));
824
             }
825
             if (i >= to) {
826
                 block.yield(context, RubyFixnum.newFixnum(runtime, i));
827
             }
828
         }
829
     }
830
 
831
     protected static void floatStep(ThreadContext context, Ruby runtime, IRubyObject from, IRubyObject to, IRubyObject step, Block block) { 
832
         double beg = num2dbl(from);
833
         double end = num2dbl(to);
834
         double unit = num2dbl(step);
835
 
836
         if (unit == 0) throw runtime.newArgumentError("step cannot be 0");
837
 
838
         double n = (end - beg)/unit;
839
         double err = (Math.abs(beg) + Math.abs(end) + Math.abs(end - beg)) / Math.abs(unit) * ;
840
 
841
         if (err > 0.5) err = 0.5;            
842
         n = Math.floor(n + err) + 1;
843
 
844
         for (long i = 0; i < n; i++) {
845
             block.yield(context, RubyFloat.newFloat(runtime, i * unit + beg));
846
         }
847
     }
848
 
849
     static void floatStep19(ThreadContext context, Ruby runtime, IRubyObject from, IRubyObject to, IRubyObject step, boolean excl, Block block) { 
850
         double beg = num2dbl(from);
851
         double end = num2dbl(to);
852
         double unit = num2dbl(step);
853
 
854
         // TODO: remove
855
         if (unit == 0) throw runtime.newArgumentError("step cannot be 0");
856
 
857
         double n = (end - beg)/unit;
858
         double err = (Math.abs(beg) + Math.abs(end) + Math.abs(end - beg)) / Math.abs(unit) * ;
859
 
860
         if (Double.isInfinite(unit)) {
861
             if (unit > 0) block.yield(context, RubyFloat.newFloat(runtime, beg));
862
         } else {
863
             if (err > 0.5) err = 0.5;            
864
             n = Math.floor(n + err);
865
             if (!excl) n++;
866
             for (long i = 0; i < n; i++){
867
                 block.yield(context, RubyFloat.newFloat(runtime, i * unit + beg));
868
             }
869
         }
870
     }
871
 
872
     private static void duckStep(ThreadContext context, Ruby runtime, IRubyObject from, IRubyObject to, IRubyObject step, Block block) {
873
         IRubyObject i = from;
874
         String cmpString = step.callMethod(context, ">", RubyFixnum.zero(runtime)).isTrue() ? ">" : "<";
875
 
876
         while (true) {
877
             if (i.callMethod(context, cmpString, to).isTrue()) break;
878
             block.yield(context, i);
879
             i = i.callMethod(context, "+", step);
880
         }
881
     }

    
num_equal, doesn't override RubyObject.op_equal 
885
 
886
     protected final IRubyObject op_num_equal(ThreadContext context, IRubyObject other) {
887
         // it won't hurt fixnums
888
         if (this == other)  return getRuntime().getTrue();
889
 
890
         return invokedynamic(context, other, ., this);
891
     }

    
num_numerator 
895
 
896
     @JRubyMethod(name = "numerator", compat = .)
897
     public IRubyObject numerator(ThreadContext context) {
898
         return RubyRational.newRationalConvert(context, this).callMethod(context, "numerator");
899
     }
    
    
num_denominator 
903
 
904
     @JRubyMethod(name = "denominator", compat = .)
905
     public IRubyObject denominator(ThreadContext context) {
906
         return RubyRational.newRationalConvert(context, this).callMethod(context, "denominator");
907
     }

    
numeric_to_c 
911
 
912
     @JRubyMethod(name = "to_c", compat = .)
913
     public IRubyObject to_c(ThreadContext context) {
914
         return RubyComplex.newComplexCanonicalize(context, this);
915
     }

    
numeric_real 
919
 
920
     @JRubyMethod(name = "real", compat = .)
921
     public IRubyObject real(ThreadContext context) {
922
         return this;
923
     }

    
numeric_image 
927
 
928
     @JRubyMethod(name = {"imaginary", "imag"}, compat = .)
929
     public IRubyObject image(ThreadContext context) {
930
         return RubyFixnum.zero(context.runtime);
931
     }

    
numeric_abs2 
935
 
936
     @JRubyMethod(name = "abs2", compat = .)
937
     public IRubyObject abs2(ThreadContext context) {
938
         return f_mul(context, this, this);
939
     }

    
numeric_arg 
943
 
944
     @JRubyMethod(name = {"arg", "angle", "phase"}, compat = .)
945
     public IRubyObject arg(ThreadContext context) {
946
         double value = this.getDoubleValue();
947
         if (Double.isNaN(value)) {
948
             return this;
949
         }
950
         if (f_negative_p(context, this) || (value == 0.0 && 1/value == .)) {
951
             // negative or -0.0
952
             return context.runtime.getMath().getConstant("PI");
953
         }
954
         return RubyFixnum.zero(context.runtime);
955
     }    

    
numeric_rect 
959
 
960
     @JRubyMethod(name = {"rectangular", "rect"}, compat = .)
961
     public IRubyObject rect(ThreadContext context) {
962
         return context.runtime.newArray(this, RubyFixnum.zero(context.runtime));
963
     }    

    
numeric_polar 
967
 
968
     @JRubyMethod(name = "polar", compat = .)
969
     public IRubyObject polar(ThreadContext context) {
970
         return context.runtime.newArray(f_abs(context, this), f_arg(context, this));
971
     }    

    
numeric_real 
975
 
976
     @JRubyMethod(name = {"conjugate", "conj"}, compat = .)
977
     public IRubyObject conjugate(ThreadContext context) {
978
         return this;
979
     }
980
 
981
     @Override
982
     public Object toJava(Class target) {
983
         return JavaUtil.getNumericConverter(target).coerce(this, target);
984
     }
985
 
986
     public static class InvalidIntegerException extends NumberFormatException {
987
         private static final long serialVersionUID = 55019452543252148L;
988
         
989
         public InvalidIntegerException() {
990
             super();
991
         }
992
         public InvalidIntegerException(String message) {
993
             super(message);
994
         }
995
         @Override
996
         public Throwable fillInStackTrace() {
997
             return this;
998
         }
999
     }
1000
    
1001
    public static class NumberTooLargeException extends NumberFormatException {
1002
        private static final long serialVersionUID = -1835120694982699449L;
1003
        public NumberTooLargeException() {
1004
            super();
1005
        }
1006
        public NumberTooLargeException(String message) {
1007
            super(message);
1008
        }
1009
        @Override
1010
        public Throwable fillInStackTrace() {
1011
            return this;
1012
        }
1013
    }