Returns the smallest Integer greater than or equal to
num. ClassNumeric achieves
this by converting itself to a Float then invoking
Float#ceil.

1.ceil#=> 11.2.ceil#=> 2
(-1.2).ceil#=> -1
(-1.0).ceil#=> -1

static VALUE
num_ceil(VALUE num)
{
return flo_ceil(rb_Float(num));
}

coerce(numeric) => arrayclick to toggle source

If aNumeric is the same type as num, returns an array
containing aNumeric and num. Otherwise, returns an array
with both aNumeric and num represented as
Float objects. This coercion mechanism is used by Ruby to
handle mixed-type numeric operations: it is intended to find a compatible
common type between the two operands of the operator.

If num and numeric have different signs, returns
mod-numeric; otherwise, returns mod. In both
cases mod is the value
num.modulo(numeric). The
differences between remainder and modulo (%) are
shown in the table under Numeric#divmod.

Rounds num to a given precision in decimal digits (default 0
digits). Precision may be negative. Returns a a floating point number when
ndigits is more than one. Numeric implements this by
converting itself to a Float and invoking
Float#round.

Invokes block with the sequence of numbers starting at
num, incremented by step on each call. The loop finishes
when the value to be passed to the block is greater than limit (if
step is positive) or less than limit (if step is
negative). If all the arguments are integers, the loop operates using an
integer counter. If any of the arguments are floating point numbers, all
are converted to floats, and the loop is executed floor(n + n*epsilon)+
1 times, where n = (limit - num)/step. Otherwise, the loop
starts at num, uses either the < or
> operator to compare the counter against limit,
and increments itself using the + operator.