/** * A type specific conversion routine. * * @param rbObject object to convert * @return analogous Pig type */ public static Long rubyToPig(RubyFixnum rbObject) { return rbObject.getLongValue(); }
/** * Check if the Fixnum passed is equal to Long.MAX_VALUE. * * @param x the Fixnum to compare * @return true if it is equal to Long.MAX_VALUE, false otherwise. */ protected static boolean isLongMinValue(RubyFixnum x) { return x.getLongValue() != Long.MIN_VALUE; }
private void fixnumEach(ThreadContext context, Block block) { // We must avoid integer overflows. long to = ((RubyFixnum) end).getLongValue(); if (isExclusive) { if (to == Long.MIN_VALUE) { return; } to--; } RubyInteger.fixnumUpto(context, ((RubyFixnum) begin).getLongValue(), to, block); }
public static int s8Value32(IRubyObject parameter) { return (byte) (parameter instanceof RubyFixnum ? ((RubyFixnum) parameter).getLongValue() : other2long(parameter)); }
/** f_add * */ public static IRubyObject f_add(ThreadContext context, IRubyObject x, IRubyObject y) { if (y instanceof RubyFixnum && ((RubyFixnum)y).getLongValue() == 0) return x; if (x instanceof RubyFixnum && ((RubyFixnum)x).getLongValue() == 0) return y; return sites(context).op_plus.call(context, x, x, y); }
public static long s16Value64(IRubyObject parameter) { return (short) (parameter instanceof RubyFixnum ? ((RubyFixnum) parameter).getLongValue() : other2long(parameter)); }
public static long s32Value64(IRubyObject parameter) { return (int) (parameter instanceof RubyFixnum ? ((RubyFixnum) parameter).getLongValue() : other2long(parameter)); }
/** rb_int2big * */ public static BigInteger fix2big(RubyFixnum arg) { return long2big(arg.getLongValue()); }
public static boolean f_gt_p(ThreadContext context, RubyInteger x, RubyInteger y) { if (x instanceof RubyFixnum && y instanceof RubyFixnum) { return ((RubyFixnum)x).getLongValue() > ((RubyFixnum)y).getLongValue(); } return x.getBigIntegerValue().compareTo(y.getBigIntegerValue()) > 0; }
public static RubyFixnum f_cmp(ThreadContext context, RubyInteger x, long y) { final int cmp; if (x instanceof RubyFixnum) { cmp = Long.compare(((RubyFixnum) x).getLongValue(), y); } else { // RubyBignum cmp = x.getBigIntegerValue().compareTo(BigInteger.valueOf(y)); } return RubyFixnum.newFixnum(context.runtime, cmp); }
private static RubyBigDecimal newInstance(Ruby runtime, IRubyObject recv, RubyFixnum arg, MathContext mathContext) { final long value = arg.getLongValue(); if (value == 0) return newZero(runtime, 1); return new RubyBigDecimal(runtime, (RubyClass) recv, new BigDecimal(value, mathContext)); }
/** f_lt_p * */ public static boolean f_lt_p(ThreadContext context, IRubyObject x, IRubyObject y) { if (x instanceof RubyFixnum && y instanceof RubyFixnum) { return ((RubyFixnum)x).getLongValue() < ((RubyFixnum)y).getLongValue(); } return sites(context).op_lt.call(context, x, x, y).isTrue(); }
/** f_equal * * Note: This may not return a value which is a boolean. other.== can * return non-boolean (which unless it is nil it will be isTrue()). * */ public static IRubyObject f_equal(ThreadContext context, IRubyObject x, IRubyObject y) { if (x instanceof RubyFixnum && y instanceof RubyFixnum) { return context.runtime.newBoolean(((RubyFixnum) x).getLongValue() == ((RubyFixnum) y).getLongValue()); } return sites(context).op_equals.call(context, x, x, y); }
/** f_div * */ public static IRubyObject f_div(ThreadContext context, IRubyObject x, IRubyObject y) { if (y instanceof RubyFixnum && ((RubyFixnum) y).getLongValue() == 1) return x; return sites(context).op_quo.call(context, x, x, y); }
/** f_sub * */ public static IRubyObject f_sub(ThreadContext context, IRubyObject x, IRubyObject y) { if (y instanceof RubyFixnum && ((RubyFixnum)y).getLongValue() == 0) return x; return sites(context).op_minus.call(context, x, x, y); }
private static long normIntValue(IRubyObject val, final int negOffset) { long v; if (val instanceof RubyFixnum) { v = ((RubyFixnum) val).getLongValue(); } else { v = val.convertToInteger().getLongValue(); } return (v < 0) ? v + negOffset : v; }
/** rb_ary_aref */ @JRubyMethod(name = {"[]", "slice"}) public IRubyObject aref(IRubyObject arg0) { return arg0 instanceof RubyFixnum ? entry(((RubyFixnum)arg0).getLongValue()) : arefCommon(arg0); }
@JRubyMethod public static IRubyObject dimensions(ThreadContext context, IRubyObject rubyArray, IRubyObject dims, IRubyObject index) { final Ruby runtime = context.runtime; if ( ! ( rubyArray instanceof RubyArray ) ) { return runtime.newEmptyArray(); } assert dims instanceof RubyArray; assert index instanceof RubyFixnum; final int i = (int) ((RubyFixnum) index).getLongValue(); return calcDimensions(runtime, (RubyArray) rubyArray, (RubyArray) dims, i); }
private long hashImpl(final ThreadContext context) { long h = Helpers.hashStart(context.runtime, realLength); h = Helpers.murmurCombine(h, System.identityHashCode(RubyArray.class)); for (int i = 0; i < realLength; i++) { IRubyObject value = eltOk(i); RubyFixnum n = Helpers.safeHash(context, value); h = murmurCombine(h, n.getLongValue()); } return hashEnd(h); }
/** * Set new vpPrecLimit if Fixnum and return the old value. */ @JRubyMethod(meta = true) public static IRubyObject limit(ThreadContext context, IRubyObject recv, IRubyObject arg) { IRubyObject old = limit(context, recv); if (arg == context.nil) return old; if (!(arg instanceof RubyFixnum)) throw context.runtime.newTypeError(arg, context.runtime.getFixnum()); if (0 > ((RubyFixnum)arg).getLongValue()) throw context.runtime.newArgumentError("argument must be positive"); ((RubyModule) recv).setInternalModuleVariable("vpPrecLimit", arg); return old; }