Ruby/Справочник/Numeric

Класс Numeric

Numeric — это базовый класс для всех видов чисел (Fixnum, Float и так далее). Его методы добавляются ко всем классам, которые отвечают за числа.

Примеси

Comparable (<, <=, ==, >, >=, between?)

Методы объекта

+@, -@, <=>, abs, ceil, coerce, divmod, div, eql?, floor, integer?, modulo, nonzero?, quo, remainder, round, singleton_method_added, step, to_int, truncate, zero?

Numeric#+@

+num    #-> num

Унарный плюс — возвращает число num в качестве результата.

Numeric#-@

-num    #-> numeric

Унарный минус — возвращает число num с противоположным знаком в качестве результата.

Numeric#<=>

first <=> second #-> -1 или 0 или 1

Возвращает:

first > second #=> 1
first == second #=> 0
first < second #=> −1.

Numeric#abs

num.abs   #-> num или numeric

Возвращает абсолютное значение («по модулю») числа num.

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

Numeric#ceil

num.ceil    #-> integer

Возвращает наименьшее целое число, которое больше или равно num. Класс Numeric добивается этого конвертацией num в дробное число и вызова метода Float#ceil.

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

Полезно посмотреть на методы round, floor и truncate, которые имеют схожую функциональность

Numeric#coerce

num.coerce(numeric)   #-> array

Если numeric такого же типа, что и num, то возвращает массив, состоящий из numeric и num. Иначе, возвращает массив с numeric и num преобразованных в дробные числа. Этот метод используется при обработке арифметических операций со смешанными типами.

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

Numeric#div

num.div(numeric)    #-> integer

Использует оператор / для выполнения деления числа num на число numeric, после чего конвертирует результат в целое число. В классе Numeric отсутствует оператор /; вызывается оператор, реализованный в его подклассах.

Numeric#divmod

num.divmod( aNumeric ) #-> anArray

Возвращает массив, состоящий из результата целочисленного деления и остатка от деления числа num на число aNumeric. То есть, если

q, r = x.divmod(y)

тогда действительно следующее равенство

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

Частное округляется в меньшую сторону, как показано в таблице:

a	b	a.divmod(b)	a/b	a.modulo(b)	a.remainder(b)
13	4	[3, 1]	3	1	1
13	-4	[-4, -3]	-3	-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

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]

Полезно посмотреть на методы modulo и remainder, которые имеют схожую функциональность

Numeric#eql?

num.eql?(numeric)    #-> true или false

Возвращает true, если num и numeric одного и того же типа и имеют одинаковые значения.

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

Numeric#floor

num.floor    #-> integer

Возвращает наибольшее целое число, которое меньше или равно num. Класс Numeric добивается этого конвертацией num в дробное число и вызова метода Float#floor.

0.3.floor               #-> 0
(-0.3).floor            #-> -1
(12345.54321).floor(3)  #-> 12345.543
(12345.54321).floor(-3) #-> 12000

Полезно посмотреть на методы round, ceil и truncate, которые имеют схожую функциональность

Numeric#integer?

num.integer? #-> true или false

Возвращает true, если num является целым числом.

Numeric#modulo

num.modulo(numeric)    #-> result

Получение остатка от деления числа num на число numeric. Эквивалентен вызову num.divmod(numeric)[1].

Полезно посмотреть на методы divmod и remainder, которые имеют схожую функциональность

Numeric#nonzero?

num.nonzero?    #-> num или nil

Возвращает num, если num не является нулем, если num это ноль, то возвращает nil. Данный метод обычно используется совместно с оператором сравнения:

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"]

Numeric#quo

num.quo(numeric)    #->   result

Эквивалентен оператору /, но переопределяется в подклассах.

Numeric#remainder

num.remainder(numeric)    #-> result

Если num и numeric имеют разные знаки, то возвращает разность mod-numeric; иначе, возвращает mod. Для обоих случаев mod вычисляется по формуле:

num.modulo(numeric)

Различия между remainder и modulo (%) можно посмотреть в таблице, которая прилагается к методу divmod

Numeric#round

num.round    #-> integer

Округляет число num до ближайшего целого. Класс Numeric добивается этого конвертацией num в дробное число и вызова метода Float#round.

Полезно посмотреть на методы ceil, floor и truncate, которые имеют схожую функциональность

Numeric#singleton_method_added

num.singleton_method_added( new_method )

Перехватывает попытки добавления метода к объекту класса Numeric (и его наследников). Всегда вызывает ошибку типа TypeError.

Numeric#step

num.step(limit, step ) {|i| block }     #-> num

Выполняет блок для всех чисел с шагом step, начиная с num и заканчивая limit. Значение step может быть как положительное, так и отрицательное. Главное, чтобы значение step согласовывалось с значением limit (если step < 0, то limit должен быть меньше num). Если все аргументы метода — целые числа, то счетчик итератора (который передается параметром в блок), тоже будет целочисленным. Если хотя бы один из аргументов метода — дробный, то все остальные преобразуются в дробное число и блок выполняется floor(n + n*epsilon)+ 1 раз, где n = (limit - num)/step.

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

результат:

 1 3 5 7 9
 2.71828182845905 2.91828182845905 3.11828182845905

Numeric#to_int

num.to_int    #-> integer

Вызывает метод to_i (реализованный в подклассах) для преобразования num в целое число.

Numeric#truncate

num.truncate    #-> integer

Возвращает целую часть числа num. Класс Numeric добивается этого конвертацией num в дробное число и вызова метода Float#trancate.

Полезно посмотреть на методы round, floor и ceil, которые имеют схожую функциональность

Numeric#zero?

num.zero?    #-> true или false

Возвращает true, если num равен нулю.