Class: Numeric

Inherits:
NSNumber show all
Includes:
Comparable

Direct Known Subclasses

Complex, Float, Integer, Rational

Instance Method Summary (collapse)

Methods included from Comparable

#, #, #==, #>, #>=, #between?

Methods inherited from NSNumber

#boolValue, #charValue, #compare:, #decimalValue, #descriptionWithLocale:, #doubleValue, #floatValue, #initWithBool:, #initWithChar:, #initWithDouble:, #initWithFloat:, #initWithInt:, #initWithInteger:, #initWithLong:, #initWithLongLong:, #initWithShort:, #initWithUnsignedChar:, #initWithUnsignedInt:, #initWithUnsignedInteger:, #initWithUnsignedLong:, #initWithUnsignedLongLong:, #initWithUnsignedShort:, #intValue, #integerValue, #isEqualToNumber:, #longLongValue, #longValue, numberWithBool:, numberWithChar:, numberWithDouble:, numberWithFloat:, numberWithInt:, numberWithInteger:, numberWithLong:, numberWithLongLong:, numberWithShort:, numberWithUnsignedChar:, numberWithUnsignedInt:, numberWithUnsignedInteger:, numberWithUnsignedLong:, numberWithUnsignedLongLong:, numberWithUnsignedShort:, #objCType, #shortValue, #stringValue, #unsignedCharValue, #unsignedIntValue, #unsignedIntegerValue, #unsignedLongLongValue, #unsignedLongValue, #unsignedShortValue

Methods inherited from NSValue

#getValue:, #initWithBytes:objCType:, #isEqualToValue:, #nonretainedObjectValue, #objCType, #pointerValue, #rangeValue, value:withObjCType:, valueWithBytes:objCType:, valueWithNonretainedObject:, valueWithPointer:, valueWithRange:

Methods inherited from NSObject

#!, #!=, #!~, #==, #===, #=~, #Rational, #__callee__, #__method__, #__send__, #__type__, `, alloc, allocWithZone:, #autoContentAccessingProxy, autoload, autoload?, autorelease_pool, #awakeAfterUsingCoder:, binding, block_given?, caller, cancelPreviousPerformRequestsWithTarget:, cancelPreviousPerformRequestsWithTarget:selector:object:, catch, class, classFallbacksForKeyedArchiver, #classForCoder, #classForKeyedArchiver, classForKeyedUnarchiver, #clone, conformsToProtocol:, #copy, copyWithZone:, #dealloc, #define_singleton_method, description, display, #doesNotRecognizeSelector:, #enum_for, #equal?, #extend, fail, #finalize, format, #forwardInvocation:, #forwardingTargetForSelector:, framework, #freeze, #frozen?, getpass, gets, global_variables, #init, initialize, #initialize_clone, #initialize_dup, #inspect, instanceMethodForSelector:, instanceMethodSignatureForSelector:, #instance_eval, #instance_exec, #instance_of?, #instance_variable_defined?, #instance_variable_get, #instance_variable_set, #instance_variables, instancesRespondToSelector:, isSubclassOfClass:, #is_a?, iterator?, #kind_of?, lambda, load, load_bridge_support_file, load_plist, local_variables, loop, #method, #methodForSelector:, #methodSignatureForSelector:, #methods, #mutableCopy, mutableCopyWithZone:, new, #nil?, open, p, #performSelector:onThread:withObject:waitUntilDone:, #performSelector:onThread:withObject:waitUntilDone:modes:, #performSelector:withObject:afterDelay:, #performSelector:withObject:afterDelay:inModes:, #performSelectorInBackground:withObject:, #performSelectorOnMainThread:withObject:waitUntilDone:, #performSelectorOnMainThread:withObject:waitUntilDone:modes:, print, printf, #private_methods, proc, #protected_methods, #public_method, #public_methods, #public_send, putc, puts, raise, rand, readline, readlines, #replacementObjectForCoder:, #replacementObjectForKeyedArchiver:, require, resolveClassMethod:, resolveInstanceMethod:, #respond_to?, #respond_to_missing?, select, #send, setVersion:, #singleton_methods, sprintf, srand, superclass, #taint, #tainted?, #tap, test, throw, #to_plist, #to_s, trace_var, trap, #trust, #untaint, untrace_var, #untrust, #untrusted?, version

Constructor Details

This class inherits a constructor from NSObject

Dynamic Method Handling

This class handles dynamic methods through the method_missing method in the class NSObject

Instance Method Details

- (Object) modulo(numeric)

x.modulo(y) means x-y*(x/y).floor

Equivalent to num.divmod(aNumeric).

See Numeric#divmod.

- (Numeric) +

Unary Plus---Returns the receiver's value.

Returns:

- (Numeric) -

Unary Minus---Returns the receiver's value, negated.

Returns:

- (0?) <=>(other)

Returns zero if num equals other, nil otherwise.

Returns:

  • (0, nil)

- (Numeric) abs - (Numeric) magnitude

Returns the absolute value of num.

12.abs         #=> 12
(-34.56).abs   #=> 34.56
-34.56.abs     #=> 34.56

Overloads:

- (Object) abs2

Returns square of self.

- (0, Float) arg - (0, Float) angle - (0, Float) phase

Returns 0 if the value is positive, pi otherwise.

Overloads:

  • - arg

    Returns:

  • - angle

    Returns:

  • - phase

    Returns:

- (0, Float) arg - (0, Float) angle - (0, Float) phase

Returns 0 if the value is positive, pi otherwise.

Overloads:

  • - arg

    Returns:

  • - angle

    Returns:

  • - phase

    Returns:

- (Integer) ceil

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

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

Returns:

- (Object) class

Override NSObject methods.

- (Array) coerce(numeric)

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.

1.coerce(2.5)   #=> [2.5, 1.0]
1.2.coerce(3)   #=> [3.0, 1.2]
1.coerce(2)     #=> [2, 1]

Returns:

- (self) conj - (self) conjugate

Returns self.

Overloads:

  • - conj

    Returns:

    • (self)
  • - conjugate

    Returns:

    • (self)

- (self) conj - (self) conjugate

Returns self.

Overloads:

  • - conj

    Returns:

    • (self)
  • - conjugate

    Returns:

    • (self)

- (Integer) denominator

Returns the denominator (always positive).

Returns:

- (Integer) div(numeric)

Uses / to perform division, then converts the result to an integer. numeric does not define the / operator; this is left to subclasses.

Equivalent to num.divmod(aNumeric).

See Numeric#divmod.

Returns:

- (Array) divmod(numeric)

Returns an array containing the quotient and modulus obtained by dividing num by numeric. If q, r = x.divmod(y), then

q = floor(x/y)
x = q*y+r

The quotient is rounded toward -infinity, as shown in the following table:

 a    |  b  |  a.divmod(b)  |   a/b   | a.modulo(b) | a.remainder(b)
------+-----+---------------+---------+-------------+---------------
 13   |  4  |   3,    1     |   3     |    1        |     1
------+-----+---------------+---------+-------------+---------------
 13   | -4  |  -4,   -3     |  -4     |   -3        |     1
------+-----+---------------+---------+-------------+---------------
-13   |  4  |  -4,    3     |  -4     |    3        |    -1
------+-----+---------------+---------+-------------+---------------
-13   | -4  |   3,   -1     |   3     |   -1        |    -1
------+-----+---------------+---------+-------------+---------------
 11.5 |  4  |   2,    3.5   |   2.875 |    3.5      |     3.5
------+-----+---------------+---------+-------------+---------------
 11.5 | -4  |  -3,   -0.5   |  -2.875 |   -0.5      |     3.5
------+-----+---------------+---------+-------------+---------------
-11.5 |  4  |  -3,    0.5   |  -2.875 |    0.5      |    -3.5
------+-----+---------------+---------+-------------+---------------
-11.5 | -4  |   2,   -3.5   |   2.875 |   -3.5      |    -3.5

Examples

11.divmod(3)         #=> [3, 2]
11.divmod(-3)        #=> [-4, -1]
11.divmod(3.5)       #=> [3, 0.5]
(-11).divmod(3.5)    #=> [-4, 3.0]
(11.5).divmod(3.5)   #=> [3, 1.0]

Returns:

- (Object) dup

- (Boolean) eql?(numeric)

Returns true if num and numeric are the same type and have equal values.

1 == 1.0          #=> true
1.eql?(1.0)       #=> false
(1.0).eql?(1.0)   #=> true

Returns:

  • (Boolean)

Returns:

  • (Boolean)

- (Float) fdiv(numeric)

Returns float division.

Returns:

- (Integer) floor

Returns the largest integer less than or equal to num. Numeric implements this by converting anInteger to a Float and invoking Float#floor.

1.floor      #=> 1
(-1).floor   #=> -1

Returns:

- (Complex(0]) i

Returns the corresponding imaginary number. Not available for complex numbers.

Complex(0]

Returns:

- (0) imag - (0) imaginary

Returns zero.

Overloads:

  • - imag

    Returns:

    • (0)
  • - imaginary

    Returns:

    • (0)

- (0) imag - (0) imaginary

Returns zero.

Overloads:

  • - imag

    Returns:

    • (0)
  • - imaginary

    Returns:

    • (0)

- (Object) initialize_copy

:nodoc:

- (Boolean) integer?

Returns true if num is an Integer (including Fixnum and Bignum).

Returns:

  • (Boolean)

Returns:

  • (Boolean)

- (Numeric) abs - (Numeric) magnitude

Returns the absolute value of num.

12.abs         #=> 12
(-34.56).abs   #=> 34.56
-34.56.abs     #=> 34.56

Overloads:

- (Object) modulo(numeric)

x.modulo(y) means x-y*(x/y).floor

Equivalent to num.divmod(aNumeric).

See Numeric#divmod.

- (self?) nonzero?

Returns self if num is not zero, nil otherwise. This behavior is useful when chaining comparisons:

a = %w( z Bb bB bb BB a aA Aa AA A )
b = a.sort {|a,b| (a.downcase <=> b.downcase).nonzero? || a <=> b }
b   #=> ["A", "a", "AA", "Aa", "aA", "BB", "Bb", "bB", "bb", "z"]

Returns:

  • (self, nil)

Returns:

  • (Boolean)

- (Integer) numerator

Returns the numerator.

Returns:

- (0, Float) arg - (0, Float) angle - (0, Float) phase

Returns 0 if the value is positive, pi otherwise.

Overloads:

  • - arg

    Returns:

  • - angle

    Returns:

  • - phase

    Returns:

- (Array) polar

Returns an array; [num.abs, num.arg].

Returns:

- (Object) quo(numeric)

Returns most exact division (rational for integers, float for floats).

- (self) real

Returns self.

Returns:

  • (self)

- (Boolean) real?

Returns true if num is a Real (i.e. non Complex).

Returns:

  • (Boolean)

Returns:

  • (Boolean)

- (Array) rect

Returns an array; [num, 0].

Returns:

- (Array) rect

Returns an array; [num, 0].

Returns:

- (Object) remainder(numeric)

x.remainder(y) means x-y*(x/y).truncate

See Numeric#divmod.

- (Integer, Float) round([ndigits])

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

Returns:

- (Boolean) scalar?

Returns true if num is an Scalar (i.e. non Complex).

Returns:

  • (Boolean)

Returns:

  • (Boolean)

- (Object) singleton_method_added

Trap attempts to add methods to Numeric objects. Always raises a TypeError

- (self) step(limit[, step]) {|i| ... } - (Enumerator) step(limit[, step])

Invokes block with the sequence of numbers starting at num, incremented by step (default 1) 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 operator to compare the counter against limit, and increments itself using the + operator.

If no block is given, an enumerator is returned instead.

1.step(10, 2) { |i| print i, " " }
Math::E.step(Math::PI, 0.2) { |f| print f, " " }

produces:

1 3 5 7 9
2.71828182845905 2.91828182845905 3.11828182845905

Overloads:

  • - step {|i| ... }

    Yields:

    • (i)

    Returns:

    • (self)
  • - step

    Returns:

- (Object) to_c

Returns the value as a complex.

- (Integer) to_int

Invokes the child class's to_i method to convert num to an integer.

Returns:

- (Integer) truncate

Returns num truncated to an integer. Numeric implements this by converting its value to a float and invoking Float#truncate.

Returns:

- (Boolean) zero?

Returns true if num has a zero value.

Returns:

  • (Boolean)

Returns:

  • (Boolean)