290件ヒット
[1-100件を表示]
（0.051秒）
:![[x]](/images/drop-condition-icon.png "条件を削除"){kind=icon}
:Floatライブラリ
- ビルトイン (196)
- benchmark (12)
- bigdecimal (7)
-
bigdecimal
/ newton (1) -
bigdecimal
/ util (2) - csv (3)
- fiddle (5)
- json (6)
- matrix (20)
-
net
/ http (1) - objspace (1)
- optparse (12)
- securerandom (1)
- stringio (1)
-
webrick
/ httpserver (1) - win32ole (4)
クラス
-
Benchmark
:: Tms (11) - BigDecimal (3)
- CSV (2)
- Complex (11)
- Enumerator (2)
-
Enumerator
:: Chain (1) -
Enumerator
:: Lazy (7) -
Enumerator
:: Product (1) -
Fiddle
:: Function (2) - Float (58)
-
IO
:: Buffer (4) - Integer (6)
- Matrix (12)
-
Matrix
:: EigenvalueDecomposition (1) -
Net
:: HTTP (1) - NilClass (1)
- Numeric (18)
- Object (1)
- OptionParser (12)
-
Process
:: Tms (4) - Random (6)
- Range (6)
- Rational (8)
- Regexp (2)
- Set (1)
- String (6)
- StringIO (1)
- Time (9)
- Vector (7)
-
WEBrick
:: HTTPServer (1) -
WIN32OLE
_ TYPELIB (2) -
WIN32OLE
_ VARIANT (2)
モジュール
- Benchmark (1)
- BigMath (2)
- Enumerable (1)
- Fiddle (3)
-
GC
:: Profiler (1) - JSON (3)
-
JSON
:: Generator :: GeneratorMethods :: Float (1) - Kernel (8)
- Math (29)
- Newton (1)
- ObjectSpace (5)
- Process (2)
- SecureRandom (1)
キーワード
- % (2)
- * (3)
- ** (2)
- + (3)
- - (5)
- -@ (2)
-
/ (5) -
1
. 6 . 8から1 . 8 . 0への変更点(まとめ) (1) - < (1)
- <= (1)
- <=> (1)
- == (1)
- > (1)
- >= (1)
-
ALIGN
_ FLOAT (1) - BigDecimal (2)
- Converters (1)
- DIG (1)
- E (1)
- EPSILON (1)
- FloatDomainError (1)
- INFINITY (1)
- Infinity (1)
-
MANT
_ DIG (1) - MAX (1)
-
MAX
_ 10 _ EXP (1) -
MAX
_ EXP (1) - MIN (1)
-
MIN
_ 10 _ EXP (1) -
MIN
_ EXP (1) - Marshal フォーマット (1)
- MinusInfinity (1)
- NAN (1)
-
NEWS for Ruby 2
. 0 . 0 (1) -
NEWS for Ruby 2
. 2 . 0 (1) -
NEWS for Ruby 2
. 4 . 0 (1) -
NEWS for Ruby 2
. 6 . 0 (1) -
NEWS for Ruby 2
. 7 . 0 (1) -
NEWS for Ruby 3
. 4 . 0 (1) - NaN (1)
- Numeric (1)
- PI (1)
- RADIX (1)
- Rational (2)
- Ruby用語集 (1)
-
SIZEOF
_ FLOAT (1) -
TYPE
_ FLOAT (1) - []= (1)
- abs (2)
- acos (1)
- acosh (1)
- angle (2)
-
angle
_ with (1) - arg (2)
- asin (1)
- asinh (1)
- at (6)
- atan (1)
- atan2 (1)
- atanh (1)
- bigdecimal (1)
-
bigdecimal
/ util (1) - bsearch (2)
- call (1)
- cbrt (1)
- ceil (1)
- classify (1)
-
clock
_ getres (1) -
clock
_ gettime (1) - coerce (1)
- cofactor (1)
-
cofactor
_ expansion (1) - converters (1)
- cos (1)
- cosh (1)
- cstime (2)
- cutime (2)
- denominator (2)
- det (1)
-
det
_ e (1) - determinant (1)
-
determinant
_ e (1) - div (1)
- divmod (1)
- dot (1)
-
double
_ fig (1) - each (2)
-
each
_ object (4) - eigenvalues (1)
-
elements
_ to _ f (2) -
enum
_ for (2) - eql? (1)
- erf (1)
- erfc (1)
- exp (2)
- fdiv (4)
- fiddle (1)
- finite? (3)
- floor (1)
- format (1)
- frexp (1)
- gamma (1)
-
get
_ value (1) -
get
_ values (1) - grep (1)
-
grep
_ v (1) - hash (1)
- hex (1)
- hypot (1)
- infinite? (3)
-
inner
_ product (1) - inspect (2)
-
laplace
_ expansion (1) - lazy (2)
- ldexp (1)
- lgamma (1)
- log (3)
- log10 (1)
- log2 (1)
- magnitude (3)
- matrix (1)
- memberwise (1)
- modulo (1)
- nan? (1)
- negative? (1)
- new (5)
-
next
_ float (1) - norm (2)
- numerator (2)
- oct (1)
- on (12)
- overlap? (1)
-
parse
_ csv (1) - phase (2)
- positive? (1)
-
prev
_ float (1) - putc (1)
- quo (2)
- r (1)
- rand (8)
-
random
_ number (1) - rank (1)
- rationalize (4)
-
reachable
_ objects _ from (1) - real (1)
- realtime (1)
- round (3)
-
ruby 1
. 6 feature (1) -
set
_ value (1) - sin (1)
-
singleton
_ class (1) - sinh (1)
- size (4)
- split (1)
- sprintf (1)
- sprintf フォーマット (1)
- sqrt (1)
- step (9)
- stime (2)
- tan (1)
- tanh (1)
- timeout (2)
-
to
_ d (2) -
to
_ enum (2) -
to
_ f (8) -
to
_ i (2) -
to
_ json (1) -
to
_ r (1) -
to
_ s (2) - total (1)
-
total
_ time (1) - tr (1)
- trace (1)
- truncate (1)
- utime (2)
- values (1)
- version (1)
-
write
_ timeout= (1) - zero? (1)
- リテラル (1)
- 正規表現 (1)
検索結果
先頭5件
-
Float (114049.0)
-
浮動小数点数のクラス。`Float` の実装は C 言語の double で、その精度は環境に依存します。
浮動小数点数のクラス。`Float` の実装は C 言語の double で、その精度は環境に依存します。
一般にはせいぜい15桁です。詳しくは多くのシステムで採用されている浮動小数点標準規格、IEEE 754 を参照してください。
- **SEE** <https://ja.wikipedia.org/wiki/IEEE_754>
```ruby title="あるシステムでの 1/3(=0.333...) の結果"
printf("%.50f\n", 1.0/3)
# => 0.33333333333333331482961625624739099293947219848633
... -
Float
# next _ float -> Float (81913.0) -
浮動小数点数で表現可能な `self` の次の値を返します。
浮動小数点数で表現可能な `self` の次の値を返します。
`Float::MAX.next_float`、`Float::INFINITY.next_float` は
`Float::INFINITY` を返します。`Float::NAN.next_float` は
`Float::NAN` を返します。
```ruby title="例"
p 0.01.next_float # => 0.010000000000000002
p 1.0.next_float # => 1.0000000000000002
p 100.0.next_float # => 100.0000000... -
Float
# prev _ float -> Float (81913.0) -
浮動小数点数で表現可能な `self` の前の値を返します。
浮動小数点数で表現可能な `self` の前の値を返します。
`(-Float::MAX).prev_float` と `(-Float::INFINITY).prev_float`
は `-Float::INFINITY` を返します。`Float::NAN.prev_float` は
`Float::NAN` を返します。
```ruby title="例"
p 0.01.prev_float # => 0.009999999999999998
p 1.0.prev_float # => 0.9999999999999999
p 100.0.prev_float # => 99... -
Float
:: MIN -> Float (63406.0) -
`Float` が取り得る最小の正の値です。
`Float` が取り得る最小の正の値です。
通常はデフォルトで 2.2250738585072014e-308 です。
`Float` が取り得る最小の有限の値は `-Float::MAX` です。
- **SEE** [m:Float::MAX] -
Float
# ceil(ndigits = 0) -> Integer | Float (63376.0) -
`self` と等しいかより大きな整数のうち最小のものを返します。
`self` と等しいかより大きな整数のうち最小のものを返します。
- **param** `ndigits` -- 10進数での小数点以下の有効桁数を整数で指定します。
正の整数を指定した場合、[c:Float] を返します。
小数点以下を、最大 n 桁にします。
負の整数を指定した場合、[c:Integer] を返します。
小数点位置から左に少なくとも n 個の 0 が並びます。
```ruby title="例"
p 1.2.ceil # => 2
p 2.... -
Float
:: MAX -> Float (63370.0) -
`Float` が取り得る最大の有限の値です。
`Float` が取り得る最大の有限の値です。
通常はデフォルトで 1.7976931348623157e+308 です。
- **SEE** [m:Float::MIN] -
Float
# round(ndigits = 0) -> Integer | Float (63361.0) -
`self` ともっとも近い整数もしくは実数を返します。
`self` ともっとも近い整数もしくは実数を返します。
中央値 0.5, -0.5 はそれぞれ 1,-1 に切り上げされます。
いわゆる四捨五入ですが、偶数丸めではありません。
- **param** `ndigits` -- 丸める位を指定します。
`ndigits` が0ならば、小数点以下を四捨五入し、整数を返します。
`ndigits` が0より大きいならば、小数点以下の指定された位で四捨五入されます。
`ndigits` が0より小さいならば、小数点以上の指定された位で四捨五入されます。
- **param** `half` -- ちょ... -
Float
# round(ndigits = 0 , half: :up) -> Integer | Float (63361.0) -
`self` ともっとも近い整数もしくは実数を返します。
`self` ともっとも近い整数もしくは実数を返します。
中央値 0.5, -0.5 はそれぞれ 1,-1 に切り上げされます。
いわゆる四捨五入ですが、偶数丸めではありません。
- **param** `ndigits` -- 丸める位を指定します。
`ndigits` が0ならば、小数点以下を四捨五入し、整数を返します。
`ndigits` が0より大きいならば、小数点以下の指定された位で四捨五入されます。
`ndigits` が0より小さいならば、小数点以上の指定された位で四捨五入されます。
- **param** `half` -- ちょ... -
Float
:: INFINITY -> Float (63358.0) -
浮動小数点数における正の無限大です。
浮動小数点数における正の無限大です。
負の無限大は `-Float::INFINITY` です。
- **SEE** [m:Float#finite?], [m:Float#infinite?] -
Float
:: EPSILON -> Float (63352.0) -
`1.0 + Float::EPSILON != 1.0` となる最小の正の値です。
`1.0 + Float::EPSILON != 1.0` となる最小の正の値です。
通常はデフォルトで 2.2204460492503131e-16 です。 -
Float
# floor(ndigits = 0) -> Integer | Float (63340.0) -
`self` と等しいかより小さな整数のうち最大のものを返します。
`self` と等しいかより小さな整数のうち最大のものを返します。
- **param** `ndigits` -- 10進数での小数点以下の有効桁数を整数で指定します。
正の整数を指定した場合、[c:Float] を返します。
小数点以下を、最大 n 桁にします。
負の整数を指定した場合、[c:Integer] を返します。
小数点位置から左に少なくとも n 個の 0 が並びます。
```ruby title="例"
p 1.2.floor # => 1
p 2... -
Float
# truncate(ndigits = 0) -> Integer | Float (63322.0) -
小数点以下を切り捨てて値を整数に変換します。
小数点以下を切り捨てて値を整数に変換します。
- **param** `ndigits` -- 10進数での小数点以下の有効桁数を整数で指定します。
正の整数を指定した場合、[c:Float] を返します。
小数点以下を、最大 n 桁にします。
負の整数を指定した場合、[c:Integer] を返します。
小数点位置から左に少なくとも n 個の 0 が並びます。
```ruby title="例"
p 2.8.truncate # => 2
p (-2.... -
Float
:: NAN -> Float (63322.0) -
浮動小数点数における NaN(Not a number)です。
浮動小数点数における NaN(Not a number)です。
- **SEE** [m:Float#nan?] -
Float
# angle -> 0 | Float (63310.0) -
`self` の偏角(正の数なら `0`、負の数なら [m:Math::PI])を返します。
`self` の偏角(正の数なら `0`、負の数なら [m:Math::PI])を返します。
```ruby title="例"
p 1.arg # => 0
p -1.arg # => 3.141592653589793
```
ただし、`self` が NaN(Not a number) であった場合は、NaN を返します。 -
Float
# arg -> 0 | Float (63310.0) -
`self` の偏角(正の数なら `0`、負の数なら [m:Math::PI])を返します。
`self` の偏角(正の数なら `0`、負の数なら [m:Math::PI])を返します。
```ruby title="例"
p 1.arg # => 0
p -1.arg # => 3.141592653589793
```
ただし、`self` が NaN(Not a number) であった場合は、NaN を返します。 -
Float
# phase -> 0 | Float (63310.0) -
`self` の偏角(正の数なら `0`、負の数なら [m:Math::PI])を返します。
`self` の偏角(正の数なら `0`、負の数なら [m:Math::PI])を返します。
```ruby title="例"
p 1.arg # => 0
p -1.arg # => 3.141592653589793
```
ただし、`self` が NaN(Not a number) であった場合は、NaN を返します。 -
Float
# %(other) -> Float (63307.0) -
算術演算子。剰余を計算します。
算術演算子。剰余を計算します。
- **param** `other` -- 二項演算の右側の引数(対象)
```ruby title="例"
# 剰余
p 3.0 % 1.2 # => 0.6000000000000001
3.0 % 0.0 # ZeroDivisionError
``` -
Float
# abs -> Float (63307.0) -
`self` の絶対値を返します。
`self` の絶対値を返します。
```ruby title="例"
p 34.56.abs # => 34.56
p -34.56.abs # => 34.56
``` -
Float
# magnitude -> Float (63307.0) -
`self` の絶対値を返します。
`self` の絶対値を返します。
```ruby title="例"
p 34.56.abs # => 34.56
p -34.56.abs # => 34.56
``` -
Float
# modulo(other) -> Float (63307.0) -
算術演算子。剰余を計算します。
算術演算子。剰余を計算します。
- **param** `other` -- 二項演算の右側の引数(対象)
```ruby title="例"
# 剰余
p 3.0 % 1.2 # => 0.6000000000000001
3.0 % 0.0 # ZeroDivisionError
``` -
Float
# *(other) -> Float (63304.0) -
算術演算子。積を計算します。
算術演算子。積を計算します。
- **param** `other` -- 二項演算の右側の引数(対象)
```ruby title="例"
# 積
p 2.4 * 3 # => 7.2
``` -
Float
# **(other) -> Float (63304.0) -
算術演算子。冪を計算します。
算術演算子。冪を計算します。
- **param** `other` -- 二項演算の右側の引数(対象)
```ruby title="例"
# 冪
p 1.2 ** 3.0 # => 1.7279999999999998
p 3.0 + 4.5 - 1.3 / 2.4 * 3 % 1.2 ** 3.0 # => 5.875
p 0.0 ** 0 # => 1.0
``` -
Float
# +(other) -> Float (63304.0) -
算術演算子。和を計算します。
算術演算子。和を計算します。
- **param** `other` -- 二項演算の右側の引数(対象)
```ruby title="例"
# 和
p 3.0 + 4.5 # => 7.5
``` -
Float
# -(other) -> Float (63304.0) -
算術演算子。差を計算します。
算術演算子。差を計算します。
- **param** `other` -- 二項演算の右側の引数(対象)
```ruby title="例"
# 差
p 4.5 - 1.3 # => 3.2
``` -
Float
# -@ -> Float (63304.0) -
単項演算子の `-` です。 `self` の符号を反転させたものを返します。
単項演算子の `-` です。
`self` の符号を反転させたものを返します。
```ruby title="例"
p(- 1.2) # => -1.2
p(- -1.2) # => 1.2
``` -
Float
# / (other) -> Float (63304.0) -
算術演算子。商を計算します。
算術演算子。商を計算します。
- **param** `other` -- 二項演算の右側の引数(対象)
```ruby title="例"
# 商
p 1.3 / 2.4 # => 0.541666666666667
p 1.0 / 0 # => Infinity
``` -
Float
# to _ r -> Rational (63163.0) -
`self` を [c:Rational] オブジェクトに変換したものを返します。
`self` を [c:Rational] オブジェクトに変換したものを返します。
浮動小数点数は、`Float::INFINITY`, `-Float::INFINITY`, `Float::NAN` を除けば数学的には有理数を表しています。その値を得るメソッドです。
- **raise** `FloatDomainError` -- `self` が `Float::INFINITY`, `-Float::INFINITY`, `Float::NAN` の場合に発生します。
```ruby title="例"
p 0.0.to_r # => (0/1)
p 0.75.to_r #... -
Float
# <=>(other) -> -1 | 0 | 1 | nil (63091.0) -
`self` を `other` と比較し、`self` のほうが大きい場合に `1`、等しい場合に `0`、小さい場合に `-1` を返します。 比較できない場合は `nil` を返します
`self` を `other` と比較し、`self` のほうが大きい場合に `1`、等しい場合に `0`、小さい場合に `-1` を返します。
比較できない場合は `nil` を返します
返り値を覚えるには、`<=>` を `-` に置き換えてみるとよいでしょう。`x <=> y` と `x - y` は符号が一致します。
```ruby title="比較できる例"
p 3.05 <=> 3.14 # => -1
p 1.732 <=> 1.414 # => 1
p 3.3 - 3.3 <=> 0.0 # => 0
# 正負の無限大も比較できる
p 3.14 <=> ... -
Float
# ==(other) -> bool (63091.0) -
比較演算子。数値として等しいか判定します。
比較演算子。数値として等しいか判定します。
- **param** `other` -- 比較対象の数値
- **return** -- `self` と `other` が等しい場合 `true` を返します。
そうでなければ `false` を返します。
```ruby title="例"
p 3.14 == 3.14000 # => true
p 3.14 == 3.1415 # => false
```
NaNどうしの比較は、未定義です。
```ruby title="例"
p Float::NAN == Float::NAN # => f... -
Float
:: MAX _ EXP -> Integer (63067.0) -
最大の `Float::RADIX` 進の指数です。
最大の `Float::RADIX` 進の指数です。
通常はデフォルトで 1024 です。
- **SEE** [m:Float::MIN_EXP] -
Float
:: MIN _ EXP -> Integer (63067.0) -
最小の `Float::RADIX` 進の指数です。
最小の `Float::RADIX` 進の指数です。
通常はデフォルトで -1021 です。
- **SEE** [m:Float::MAX_EXP] -
Float
# inspect -> String (63055.0) -
{: since=""}
{: since=""}
`self` を人間が読みやすい形の文字列表現にして返します。
10進固定小数点、10進浮動小数点の形式か、`"Infinity"`、`"-Infinity"`、`"NaN"` のいずれかを返します。
- **return** -- 文字列を返します。
```ruby title="例"
p 0.00001.to_s # => "1.0e-05"
p 3.14.to_s # => "3.14"
p 10000_00000_00000.0.to_s # => "100000000000000.0"
p 10000_0... -
Float
# rationalize -> Rational (63055.0) -
`self` から `eps` で指定した許容誤差の範囲に収まるような、できるだけ簡潔な [c:Rational] を返します。
`self` から `eps` で指定した許容誤差の範囲に収まるような、できるだけ簡潔な [c:Rational] を返します。
`eps` を省略した場合は、`self` の浮動小数点数としての精度に基づいて許容誤差が自動的に決定され、その範囲に収まる簡潔な [c:Rational] を返します。そのため [m:Float#to_r] が返す厳密な値とは異なります。誤差のない厳密な値が必要な場合は [m:Float#to_r] を使ってください。
- **param** `eps` -- 許容する誤差
```ruby title="例"
p 0.3.rationalize ... -
Float
# rationalize(eps) -> Rational (63055.0) -
`self` から `eps` で指定した許容誤差の範囲に収まるような、できるだけ簡潔な [c:Rational] を返します。
`self` から `eps` で指定した許容誤差の範囲に収まるような、できるだけ簡潔な [c:Rational] を返します。
`eps` を省略した場合は、`self` の浮動小数点数としての精度に基づいて許容誤差が自動的に決定され、その範囲に収まる簡潔な [c:Rational] を返します。そのため [m:Float#to_r] が返す厳密な値とは異なります。誤差のない厳密な値が必要な場合は [m:Float#to_r] を使ってください。
- **param** `eps` -- 許容する誤差
```ruby title="例"
p 0.3.rationalize ... -
Float
# to _ s -> String (63055.0) -
{: since=""}
{: since=""}
`self` を人間が読みやすい形の文字列表現にして返します。
10進固定小数点、10進浮動小数点の形式か、`"Infinity"`、`"-Infinity"`、`"NaN"` のいずれかを返します。
- **return** -- 文字列を返します。
```ruby title="例"
p 0.00001.to_s # => "1.0e-05"
p 3.14.to_s # => "3.14"
p 10000_00000_00000.0.to_s # => "100000000000000.0"
p 10000_0... -
Float
:: DIG -> Integer (63049.0) -
`Float` が表現できる最大の 10 進桁数です。
`Float` が表現できる最大の 10 進桁数です。
通常はデフォルトで 15 です。 -
Float
:: MANT _ DIG -> Integer (63049.0) -
仮数部の `Float::RADIX` 進法での桁数です。
仮数部の `Float::RADIX` 進法での桁数です。
通常はデフォルトで 53 です。 -
Float
# to _ i -> Integer (63022.0) -
小数点以下を切り捨てて値を整数に変換します。
小数点以下を切り捨てて値を整数に変換します。
- **param** `ndigits` -- 10進数での小数点以下の有効桁数を整数で指定します。
正の整数を指定した場合、[c:Float] を返します。
小数点以下を、最大 n 桁にします。
負の整数を指定した場合、[c:Integer] を返します。
小数点位置から左に少なくとも n 個の 0 が並びます。
```ruby title="例"
p 2.8.truncate # => 2
p (-2.... -
Float
# denominator -> Integer (63019.0) -
`self` を [c:Rational] に変換した時の分母を返します。
`self` を [c:Rational] に変換した時の分母を返します。
- **return** -- 分母を返します。
```ruby title="例"
p 2.0.denominator # => 1
p 0.5.denominator # => 2
```
- **SEE** [m:Float#numerator] -
Float
# finite? -> bool (63019.0) -
`self` が ∞, -∞, NaN のどれでもない場合に `true` を返します。 それ以外の場合に `false` を返します。
`self` が ∞, -∞, NaN のどれでもない場合に `true` を返します。
それ以外の場合に `false` を返します。
```ruby title="例"
p 3.14.finite? # => true
inf = 1.0/0
p inf.finite? # => false
```
- **SEE** [m:Float#infinite?] -
Float
# infinite? -> 1 | -1 | nil (63019.0) -
`self` が +∞ のとき `1`、-∞のとき `-1` を返します。それ以外は `nil` を返します。
`self` が +∞ のとき `1`、-∞のとき `-1` を返します。それ以外は `nil` を返します。
```ruby title="例"
inf = 1.0/0
p inf # => Infinity
p inf.infinite? # => 1
inf = -1.0/0
p inf # => -Infinity
p inf.infinite? # => -1
```
- **SEE** [m:Float#finite?] -
Float
# negative? -> bool (63019.0) -
`self` が 0 未満の場合に `true` を返します。そうでない場合に `false` を返します。
`self` が 0 未満の場合に `true` を返します。そうでない場合に `false` を返します。
```ruby title="例"
p -0.1.negative? # => true
p 0.0.negative? # => false
p 0.1.negative? # => false
```
- **SEE** [m:Float#positive?] -
Float
# numerator -> Integer (63019.0) -
`self` を [c:Rational] に変換した時の分子を返します。
`self` を [c:Rational] に変換した時の分子を返します。
- **return** -- 分子を返します。
```ruby title="例"
p 2.0.numerator # => 2
p 0.5.numerator # => 1
```
- **SEE** [m:Float#denominator] -
Float
# positive? -> bool (63019.0) -
`self` が 0 より大きい場合に `true` を返します。そうでない場合に `false` を返します。
`self` が 0 より大きい場合に `true` を返します。そうでない場合に `false` を返します。
```ruby title="例"
p 0.1.positive? # => true
p 0.0.positive? # => false
p -0.1.positive? # => false
```
- **SEE** [m:Float#negative?] -
Float
# to _ d -> BigDecimal (63019.0) -
自身を [c:BigDecimal] に変換します。
自身を [c:BigDecimal] に変換します。
- **param** `prec` -- 計算結果の精度。省略した場合は [m:Float::DIG] + 1 です。
- **return** -- [c:BigDecimal] に変換したオブジェクト
```ruby
require 'bigdecimal'
require 'bigdecimal/util'
p 1.0.to_d # => 0.1e1
p (1.0 / 0).to_d # => Infinity
p (1.0 / 3).to_d / (2.0 / 3).to_d # => 0.5e0
p (... -
Float
# to _ d(prec) -> BigDecimal (63019.0) -
自身を [c:BigDecimal] に変換します。
自身を [c:BigDecimal] に変換します。
- **param** `prec` -- 計算結果の精度。省略した場合は [m:Float::DIG] + 1 です。
- **return** -- [c:BigDecimal] に変換したオブジェクト
```ruby
require 'bigdecimal'
require 'bigdecimal/util'
p 1.0.to_d # => 0.1e1
p (1.0 / 0).to_d # => Infinity
p (1.0 / 3).to_d / (2.0 / 3).to_d # => 0.5e0
p (... -
Float
:: MAX _ 10 _ EXP -> Integer (63019.0) -
最大の 10 進の指数です。
最大の 10 進の指数です。
通常はデフォルトで 308 です。
- **SEE** [m:Float::MIN_10_EXP] -
Float
:: MIN _ 10 _ EXP -> Integer (63019.0) -
最小の 10 進の指数です。
最小の 10 進の指数です。
通常はデフォルトで -307 です。
- **SEE** [m:Float::MAX_10_EXP] -
Float
# <(other) -> bool (63001.0) -
比較演算子。数値として小さいか判定します。
比較演算子。数値として小さいか判定します。
- **param** `other` -- 比較対象の数値
- **return** -- `self` よりも `other` が大きい場合 `true` を返します。
そうでなければ `false` を返します。
```ruby title="例"
p 3.14 < 3.1415 # => true
p 3.14 <= 3.1415 # => true
``` -
Float
# <=(other) -> bool (63001.0) -
比較演算子。数値として等しいまたは小さいか判定します。
比較演算子。数値として等しいまたは小さいか判定します。
- **param** `other` -- 比較対象の数値
- **return** -- `self` よりも `other` の方が大きい場合か、
両者が等しい場合 `true` を返します。
そうでなければ `false` を返します。
```ruby title="例"
p 3.14 < 3.1415 # => true
p 3.14 <= 3.1415 # => true
``` -
Float
# >(other) -> bool (63001.0) -
比較演算子。数値として大きいか判定します。
比較演算子。数値として大きいか判定します。
- **param** `other` -- 比較対象の数値
- **return** -- `self` よりも `other` の方が小さい場合 `true` を返します。
そうでなければ `false` を返します。
```ruby title="例"
p 3.14 > 3.1415 # => false
p 3.14 >= 3.1415 # => false
``` -
Float
# >=(other) -> bool (63001.0) -
比較演算子。数値として等しいまたは大きいか判定します。
比較演算子。数値として等しいまたは大きいか判定します。
- **param** `other` -- 比較対象の数値
- **return** -- `self` よりも `other` の方が小さい場合か、
両者が等しい場合 `true` を返します。
そうでなければ `false` を返します。
```ruby title="例"
p 3.14 > 3.1415 # => false
p 3.14 >= 3.1415 # => false
``` -
Float
# divmod(other) -> [Numeric] (63001.0) -
`self` を `other` で割った商 `q` と余り `r` を、 `[q, r]` という 2 要素の配列にして返します。 商 `q` は常に整数ですが、余り `r` は整数であるとは限りません。
`self` を `other` で割った商 `q` と余り `r` を、
`[q, r]` という 2 要素の配列にして返します。
商 `q` は常に整数ですが、余り `r` は整数であるとは限りません。
ここで、商 `q` と余り `r` は、
- `self == other * q + r`
と
- `other > 0` のとき: `0 <= r < other`
- `other < 0` のとき: `other < r <= 0`
- `q` は整数
をみたす数です。
このメソッドは、メソッド `/` と `%` によって定義されています。
... -
Float
# eql?(other) -> bool (63001.0) -
`self` と `other` のクラスが等しくかつ `==` メソッドで比較して等しい場合に `true` を返します。 そうでない場合に `false` を返します。
`self` と `other` のクラスが等しくかつ `==` メソッドで比較して等しい場合に `true` を返します。
そうでない場合に `false` を返します。
- **param** `other` -- `self` と比較したい数値を指定します。
```ruby title="例"
p 1.0.eql?(1) # => false
p 1.0.eql?(1.0) # => true
``` -
Float
# hash -> Integer (63001.0) -
ハッシュ値を返します。
ハッシュ値を返します。
```ruby title="例"
pi1 = 3.14
pi2 = 3.14
pi3 = 3.1415
pi1.hash # => 335364239
pi2.hash # => 335364239
pi3.hash # => 420540030
``` -
Float
# nan? -> bool (63001.0) -
`self` が NaN(Not a number)のとき `true` を返し、そうでないとき `false` を返します。
`self` が NaN(Not a number)のとき `true` を返し、そうでないとき `false` を返します。
```ruby title="例"
nan = 0.0/0.0
p nan # => NaN
p nan.nan? # => true
``` -
Float
# to _ f -> self (63001.0) -
`self` を返します。
`self` を返します。
```ruby title="例"
p 3.14.to_f # => 3.14
``` -
Float
# zero? -> bool (63001.0) -
`self` がゼロの時、`true` を返します。そうでない場合は `false` を返します。
`self` がゼロの時、`true` を返します。そうでない場合は `false` を返します。
```ruby title="例"
p 10.0.zero? # => false
p 0.zero? # => true
p 0.0.zero? # => true
``` -
Float
:: RADIX -> Integer (63001.0) -
指数表現の基数です。
指数表現の基数です。 -
Kernel
. # Float(arg , exception: true) -> Float | nil (55213.0) -
引数を浮動小数点数([c:Float])に変換した結果を返します。
...なせるもののみ変換します。
メソッド Float は文字列に対し [m:String#to_f] よりも厳密な変換を行います。
Ruby 3.4 以降は "1." のように小数点以下を省略した表記も受け付けます。
- **param** `arg` -- 変換対象のオブジェクトです... -
JSON
:: Ext :: Generator :: GeneratorMethods :: Float (54049.0) -
Alias of JSON::Generator::GeneratorMethods::Float
Alias of JSON::Generator::GeneratorMethods::Float -
JSON
:: Generator :: GeneratorMethods :: Float (54049.0) -
[c:Float] に JSON で使用するインスタンスメソッドを追加するためのモジュールです。
[c:Float] に JSON で使用するインスタンスメソッドを追加するためのモジュールです。 -
Fiddle
:: ALIGN _ FLOAT -> Integer (18352.0) -
C の構造体における float のアライメントの値。
C の構造体における float のアライメントの値。 -
Fiddle
:: SIZEOF _ FLOAT -> Integer (18352.0) -
Cでの sizeof(float) の値
Cでの sizeof(float) の値 -
Fiddle
:: TYPE _ FLOAT -> Integer (18352.0) -
C の float 型を表す定数。
C の float 型を表す定数。 -
FloatDomainError (18109.0)
-
正負の無限大や NaN (Not a Number) を、それに対応していない数値クラスに変換しようとしたとき発生します。
正負の無限大や NaN (Not a Number) を、それに対応していない数値クラスに変換しようとしたとき発生します。
```ruby title="FloatDomainErrorが発生する例"
# Integer には正負の無限大や NaN に対応する値が無い
Float::INFINITY.to_i # ~> FloatDomainError
(-Float::INFINITY).to_i # ~> FloatDomainError
Float::NAN.to_i # ~> FloatDomainError
# Rational には正負の無限大や NaN ... -
JSON
:: Generator :: GeneratorMethods :: Float # to _ json(state _ or _ hash = nil) -> String (9001.0) -
自身から生成した JSON 形式の文字列を返します。
自身から生成した JSON 形式の文字列を返します。
- **param** `state_or_hash` -- 生成する JSON 形式の文字列をカスタマイズするため
に [c:JSON::State] のインスタンスか、
[m:JSON::State.new] の引数と同じ [c:Hash] を
指定します。
```ruby title="例"
require "json"
p (1.0).to_json # => "1.0"
``` -
Process
. # clock _ gettime(clock _ id , unit=:float _ second) -> Float | Integer (733.0) -
POSIX の clock_gettime() 関数の時間を返します。
...FreeBSD 3.0, NetBSD 2.0, OpenBSD 2.1, macOS 10.12
- **`[m:Process::CLOCK_MONOTONIC]`**:
SUSv3 to 4, Linux 2.5.63, FreeBSD 3.0, NetBSD 2.0, OpenBSD 3.4, macOS 10.12
- **`[m:Process::CLOCK_PROCESS_CPUTIME_ID]`**:
SUSv3 to 4, Linux 2.5.63, OpenBSD 5.4, macOS 10.12
- **`[m:Process::CLOCK_THREAD_CPUT... -
Process
. # clock _ getres(clock _ id , unit=:float _ second) -> Float | Integer (643.0) -
POSIX の clock_getres() 関数を使って、クロックの分解能を返します。
POSIX の clock_getres() 関数を使って、クロックの分解能を返します。
```ruby title="例"
p Process.clock_getres(Process::CLOCK_MONOTONIC) # => 1.0e-09
```
- **param** `clock_id` -- クロックの種類を指定します。指定できる値は
[m:Process?.clock_gettime] の clock_id と同じです。
- **param** `unit` -- 返値の型を指定します。[m:Process?.clock_gettime... -
1
. 6 . 8から1 . 8 . 0への変更点(まとめ) (631.0) -
1.6.8から1.8.0への変更点(まとめ) * ((<1.6.8から1.8.0への変更点(まとめ)/インタプリタの変更>)) * ((<1.6.8から1.8.0への変更点(まとめ)/追加されたクラス／モジュール>)) * ((<1.6.8から1.8.0への変更点(まとめ)/追加されたメソッド>)) * ((<1.6.8から1.8.0への変更点(まとめ)/追加された定数>)) * ((<1.6.8から1.8.0への変更点(まとめ)/拡張されたクラス／メソッド(互換性のある変更)>)) * ((<1.6.8から1.8.0への変更点(まとめ)/変更されたクラス／メソッド(互換性のない変更)>)) * ((<1.6.8から1.8.0への変更点(まとめ)/文法の変更>)) * ((<1.6.8から1.8.0への変更点(まとめ)/正規表現>)) * ((<1.6.8から1.8.0への変更点(まとめ)/Marshal>)) * ((<1.6.8から1.8.0への変更点(まとめ)/Windows 対応>)) * ((<1.6.8から1.8.0への変更点(まとめ)/廃止された(される予定の)機能>)) * ((<1.6.8から1.8.0への変更点(まとめ)/ライブラリ>)) * ((<1.6.8から1.8.0への変更点(まとめ)/拡張ライブラリAPI>)) * ((<1.6.8から1.8.0への変更点(まとめ)/バグ修正>)) * ((<1.6.8から1.8.0への変更点(まとめ)/サポートプラットフォームの追加>))
1.6.8から1.8.0への変更点(まとめ)
* ((<1.6.8から1.8.0への変更点(まとめ)/インタプリタの変更>))
* ((<1.6.8から1.8.0への変更点(まとめ)/追加されたクラス／モジュール>))
* ((<1.6.8から1.8.0への変更点(まとめ)/追加されたメソッド>))
* ((<1.6.8から1.8.0への変更点(まとめ)/追加された定数>))
* ((<1.6.8から1.8.0への変更点(まとめ)/拡張されたクラス／メソッド(互換性のある変更)>))
* ((<1.6.8から1.8.0への変更点(まとめ)/変更されたクラス／メソッド(互換性のない変更)>))... -
Numeric
# fdiv(other) -> Float | Complex (436.0) -
self を other で割った商を [c:Float] で返します。 ただし [c:Complex] が関わる場合は例外です。 その場合も成分は Float になります。
self を other で割った商を [c:Float] で返します。
ただし [c:Complex] が関わる場合は例外です。
その場合も成分は Float になります。
self が [c:Integer] や [c:Rational] で、other が虚部を持つ [c:Complex]
の場合は、商を [c:Float] に変換できないため [c:RangeError] が発生します。
Numeric のサブクラスは、このメソッドを適切に再定義しなければなりません。
- **param** `other` -- 自身を割る数を指定します。
```ruby title="例"... -
Integer
# to _ f -> Float (424.0) -
`self` を浮動小数点数([c:Float])に変換します。
`self` を浮動小数点数([c:Float])に変換します。
`self` が [c:Float] の範囲に収まらない場合、[m:Float::INFINITY] を返します。
```ruby
p 1.to_f # => 1.0
p (Float::MAX.to_i * 2).to_f # => Infinity
p (-Float::MAX.to_i * 2).to_f # => -Infinity
``` -
String
# to _ f -> Float (424.0) -
文字列を 10 進数表現と解釈して、浮動小数点数 [c:Float] に変換します。
...数付きの表記では Ruby 3.3 以前と結果が変わることがあります
(3.3 以前は "1." で解釈を打ち切っていましたが、3.4 以降は指数まで解釈します)。
```ruby
p "1.".to_f # => 1.0
p "1.e2".to_f # => 100.0 # Ruby 3.3 以前は 1.0
```
以下の例... -
Numeric
# step(by: 1 , to: Float :: INFINITY) -> Enumerator (403.0) -
self からはじめ step を足しながら limit を越える前までブロックを繰り返します。step は負の数も指定できます。また、limit や step には [c:Float] なども指定できます。
self からはじめ step を足しながら limit を越える前までブロックを繰り返します。step は負の数も指定できます。また、limit や step には [c:Float] なども指定できます。
- **param** `limit` -- ループの上限あるいは下限を数値で指定します。step に負の数が指定された場合は、
下限として解釈されます。
- **param** `step` -- 各ステップの大きさを数値で指定します。負の数を指定することもできます。
- **param** `to` -- 引数limitと同じですが、省略した場合はキーワード引数... -
Numeric
# step(by: 1 , to: Float :: INFINITY) -> Enumerator :: ArithmeticSequence (403.0) -
self からはじめ step を足しながら limit を越える前までブロックを繰り返します。step は負の数も指定できます。また、limit や step には [c:Float] なども指定できます。
self からはじめ step を足しながら limit を越える前までブロックを繰り返します。step は負の数も指定できます。また、limit や step には [c:Float] なども指定できます。
- **param** `limit` -- ループの上限あるいは下限を数値で指定します。step に負の数が指定された場合は、
下限として解釈されます。
- **param** `step` -- 各ステップの大きさを数値で指定します。負の数を指定することもできます。
- **param** `to` -- 引数limitと同じですが、省略した場合はキーワード引数... -
Numeric
# step(by: 1 , to: Float :: INFINITY) {|n| . . . } -> self (403.0) -
self からはじめ step を足しながら limit を越える前までブロックを繰り返します。step は負の数も指定できます。また、limit や step には [c:Float] なども指定できます。
self からはじめ step を足しながら limit を越える前までブロックを繰り返します。step は負の数も指定できます。また、limit や step には [c:Float] なども指定できます。
- **param** `limit` -- ループの上限あるいは下限を数値で指定します。step に負の数が指定された場合は、
下限として解釈されます。
- **param** `step` -- 各ステップの大きさを数値で指定します。負の数を指定することもできます。
- **param** `to` -- 引数limitと同じですが、省略した場合はキーワード引数... -
Numeric
# step(by: , to: -Float :: INFINITY) -> Enumerator (403.0) -
self からはじめ step を足しながら limit を越える前までブロックを繰り返します。step は負の数も指定できます。また、limit や step には [c:Float] なども指定できます。
self からはじめ step を足しながら limit を越える前までブロックを繰り返します。step は負の数も指定できます。また、limit や step には [c:Float] なども指定できます。
- **param** `limit` -- ループの上限あるいは下限を数値で指定します。step に負の数が指定された場合は、
下限として解釈されます。
- **param** `step` -- 各ステップの大きさを数値で指定します。負の数を指定することもできます。
- **param** `to` -- 引数limitと同じですが、省略した場合はキーワード引数... -
Numeric
# step(by: , to: -Float :: INFINITY) -> Enumerator :: ArithmeticSequence (403.0) -
self からはじめ step を足しながら limit を越える前までブロックを繰り返します。step は負の数も指定できます。また、limit や step には [c:Float] なども指定できます。
self からはじめ step を足しながら limit を越える前までブロックを繰り返します。step は負の数も指定できます。また、limit や step には [c:Float] なども指定できます。
- **param** `limit` -- ループの上限あるいは下限を数値で指定します。step に負の数が指定された場合は、
下限として解釈されます。
- **param** `step` -- 各ステップの大きさを数値で指定します。負の数を指定することもできます。
- **param** `to` -- 引数limitと同じですが、省略した場合はキーワード引数... -
Numeric
# step(by: , to: -Float :: INFINITY) {|n| . . . } -> self (403.0) -
self からはじめ step を足しながら limit を越える前までブロックを繰り返します。step は負の数も指定できます。また、limit や step には [c:Float] なども指定できます。
self からはじめ step を足しながら limit を越える前までブロックを繰り返します。step は負の数も指定できます。また、limit や step には [c:Float] なども指定できます。
- **param** `limit` -- ループの上限あるいは下限を数値で指定します。step に負の数が指定された場合は、
下限として解釈されます。
- **param** `step` -- 各ステップの大きさを数値で指定します。負の数を指定することもできます。
- **param** `to` -- 引数limitと同じですが、省略した場合はキーワード引数... -
Rational
# to _ f -> Float (370.0) -
`self` の値を最も良く表現する [c:Float] に変換します。
`self` の値を最も良く表現する [c:Float] に変換します。
絶対値が極端に小さい、または大きい場合にはゼロや無限大が返ることがあります。
- **return** -- [c:Float] を返します。
```ruby title="例"
p Rational(2).to_f # => 2.0
p Rational(9, 4).to_f # => 2.25
p Rational(-3, 4).to_f # => -0.75
p Rational(20, 3).to_f # => 6.666666666666667
... -
Range
# size -> Integer | Float :: INFINITY | nil (358.0) -
範囲内の要素数を返します。
範囲内の要素数を返します。
始端が整数でない場合は、始端が succ メソッドを持つ場合は nil を返し、始端が succ メソッドを持たない場合は TypeError が発生します。
- **raise** `TypeError` -- self がイテレート可能でない場合に発生します。
```ruby title="例"
p (10..20).size # => 11
p ("a".."z").size # => nil
p (1..).size # => Infinity
(-Float::INFINITY..Float::INFINITY).size # => c... -
Rational
# **(other) -> Rational | Float (358.0) -
冪(べき)乗を計算します。
冪(べき)乗を計算します。
- **param** `other` -- `self` を `other` 乗する数
- **raise** `ArgumentError` -- 計算結果の分母・分子が巨大すぎる場合に発生します。
`other` に [c:Float] を指定した場合は、計算結果を [c:Float] で返します。
`other` が有理数であっても、計算結果が無理数だった場合は [c:Float] を返します。
```ruby title="例"
r = Rational(3, 4)
p r ** Rational(2, 1) # => (9/16)
p r **... -
BigDecimal
# to _ f -> Float (352.0) -
self の近似値を表す [c:Float] オブジェクトに変換します。
self の近似値を表す [c:Float] オブジェクトに変換します。
仮数部や指数部の情報が必要な場合は、[m:BigDecimal#split] メソッドを利用してください。
- **SEE** [m:BigDecimal#split] -
Complex
# to _ f -> Float (352.0) -
自身を [c:Float] に変換します。
自身を [c:Float] に変換します。
- **raise** `RangeError` -- 虚部が実数か、0 ではない場合に発生します。
```ruby title="例"
p Complex(3).to_f # => 3.0
p Complex(3.5).to_f # => 3.5
Complex(3, 2).to_f # ~> RangeError
``` -
Math
:: E -> Float (352.0) -
自然対数の底の近似値。Float で表せる最も正確な値です。
自然対数の底の近似値。Float で表せる最も正確な値です。
```ruby title="例"
p Math::E
# => 2.718281828
``` -
Math
:: PI -> Float (352.0) -
円周率の近似値。Float で表せる最も正確な値です。
円周率の近似値。Float で表せる最も正確な値です。
```ruby title="例"
p Math::PI
# => 3.141592654
``` -
Rational
# fdiv(other) -> Float (352.0) -
`self` を `other` で割った商を [c:Float] で返します。 `other` に虚数を指定することは出来ません。
`self` を `other` で割った商を [c:Float] で返します。
`other` に虚数を指定することは出来ません。
- **param** `other` -- `self` を割る数
```ruby title="例"
p Rational(2, 3).fdiv(1) # => 0.6666666666666666
p Rational(2, 3).fdiv(0.5) # => 1.3333333333333333
p Rational(2).fdiv(3) # => 0.6666666666666666
p Rational(1).fdiv(Complex(... -
Time
# -(time) -> Float (352.0) -
自身と time との時刻の差を [c:Float] で返します。単位は秒です。
自身と time との時刻の差を [c:Float] で返します。単位は秒です。
- **param** `time` -- 自身との差を算出したい Time オブジェクトを指定します。
```ruby
p t = Time.local(2000) # => 2000-01-01 00:00:00 +0900
p t2 = t + 2592000 # => 2000-01-31 00:00:00 +0900
p t2 - t # => 2592000.0
``` -
Random
# rand -> Float (346.0) -
一様な擬似乱数を発生させます。
一様な擬似乱数を発生させます。
最初の形式では 0.0 以上 1.0 未満の実数を返します。
二番目の形式では 0 以上 max 未満の数を返します。
max が正の整数なら整数を、正の実数なら実数を返します。
0 や負の数を指定することは出来ません。
三番目の形式では range で指定された範囲の値を返します。
range の始端と終端が共に整数の場合は整数を、少なくとも片方が実数の場合は実数を返します。
rangeが終端を含まない(つまり ... で生成した場合)には終端の値は乱数の範囲から除かれます。
range.end - range.begin が整数を返す場合は rang... -
Random
# rand(max) -> Integer | Float (346.0) -
一様な擬似乱数を発生させます。
一様な擬似乱数を発生させます。
最初の形式では 0.0 以上 1.0 未満の実数を返します。
二番目の形式では 0 以上 max 未満の数を返します。
max が正の整数なら整数を、正の実数なら実数を返します。
0 や負の数を指定することは出来ません。
三番目の形式では range で指定された範囲の値を返します。
range の始端と終端が共に整数の場合は整数を、少なくとも片方が実数の場合は実数を返します。
rangeが終端を含まない(つまり ... で生成した場合)には終端の値は乱数の範囲から除かれます。
range.end - range.begin が整数を返す場合は rang... -
Random
# rand(range) -> Integer | Float (346.0) -
一様な擬似乱数を発生させます。
一様な擬似乱数を発生させます。
最初の形式では 0.0 以上 1.0 未満の実数を返します。
二番目の形式では 0 以上 max 未満の数を返します。
max が正の整数なら整数を、正の実数なら実数を返します。
0 や負の数を指定することは出来ません。
三番目の形式では range で指定された範囲の値を返します。
range の始端と終端が共に整数の場合は整数を、少なくとも片方が実数の場合は実数を返します。
rangeが終端を含まない(つまり ... で生成した場合)には終端の値は乱数の範囲から除かれます。
range.end - range.begin が整数を返す場合は rang... -
Rational
# / (other) -> Rational | Float (343.0) -
商を計算します。
商を計算します。
- **param** `other` -- `self` を割る数
`other` に [c:Float] を指定した場合は、計算結果を [c:Float] で返します。
```ruby title="例"
r = Rational(3, 4)
p r / 2 # => (3/8)
p r / 2.0 # => 0.375
p r / 0.5 # => 1.5
p r / Rational(1, 2) # => (3/2)
r / 0 # ~> ZeroDivisio... -
Rational
# quo(other) -> Rational | Float (343.0) -
商を計算します。
商を計算します。
- **param** `other` -- `self` を割る数
`other` に [c:Float] を指定した場合は、計算結果を [c:Float] で返します。
```ruby title="例"
r = Rational(3, 4)
p r / 2 # => (3/8)
p r / 2.0 # => 0.375
p r / 0.5 # => 1.5
p r / Rational(1, 2) # => (3/2)
r / 0 # ~> ZeroDivisio... -
Enumerator
# size -> Integer | Float :: INFINITY | nil (340.0) -
{: since="2.0.0"}
{: since="2.0.0"}
self の要素数を返します。
要素数が無限の場合は [m:Float::INFINITY] を返します。
[m:Enumerator.new] に [c:Proc] オブジェクトを指定していた場合はその実行結果を返します。呼び出した時に要素数が不明であった場合は nil を返します。
```ruby title="例"
p (1..100).to_a.permutation(4).size # => 94109400
p loop.size # => Float::INFINITY
p (1..100).drop_while.size # => ni... -
Numeric
# quo(other) -> Rational | Float | Complex (340.0) -
self を other で割った商を返します。 整商を得たい場合は [m:Numeric#div] を使ってください。
self を other で割った商を返します。
整商を得たい場合は [m:Numeric#div] を使ってください。
[m:Numeric#fdiv] が結果を [c:Float] で返すメソッドなのに対して quo はなるべく正確な数値を返すことを意図しています。
具体的には有理数の範囲に収まる計算では [c:Rational] の値を返します。
[c:Float] や [c:Complex] が関わるときはそれらのクラスになります。
Numeric のサブクラスは、このメソッドを適切に再定義しなければなりません。
- **param** `other` -- 自身を割る数を指定... -
Rational
# *(other) -> Rational | Float (340.0) -
積を計算します。
積を計算します。
- **param** `other` -- `self` に掛ける数
`other` に [c:Float] を指定した場合は、計算結果を [c:Float] で返します。
```ruby title="例"
r = Rational(3, 4)
p r * 2 # => (3/2)
p r * 4 # => (3/1)
p r * 0.5 # => 0.375
p r * Rational(1, 2) # => (3/8)
``` -
Rational
# +(other) -> Rational | Float (340.0) -
和を計算します。
和を計算します。
- **param** `other` -- `self` に足す数
`other` に [c:Float] を指定した場合は、計算結果を [c:Float] で返します。
```ruby title="例"
r = Rational(3, 4)
p r + Rational(1, 2) # => (5/4)
p r + 1 # => (7/4)
p r + 0.5 # => 1.25
``` -
Rational
# -(other) -> Rational | Float (340.0) -
差を計算します。
差を計算します。
- **param** `other` -- `self` から引く数
`other` に [c:Float] を指定した場合は、計算結果を [c:Float] で返します。
```ruby title="例"
r = Rational(3, 4)
p r - 1 # => (-1/4)
p r - 0.5 # => 0.25
``` -
Numeric (337.0)
-
数値を表す抽象クラスです。[c:Integer] や [c:Float] などの数値クラスは Numeric のサブクラスとして実装されています。
数値を表す抽象クラスです。[c:Integer] や [c:Float] などの数値クラスは Numeric のサブクラスとして実装されています。
演算や比較を行うメソッド(+, -, *, /, <=>)は Numeric のサブクラスで定義されます。Numeric で定義されているメソッドは、サブクラスで提供されているメソッド
(+, -, *, /, %) を利用して定義されるものがほとんどです。
つまり Numeric で定義されているメソッドは、Numeric のサブクラスとして新たに数値クラスを定義した時に、演算メソッド(+, -, *, /, %, <=>, coerce)だけ... -
Random
. rand -> Float (328.0) -
擬似乱数を発生させます。
擬似乱数を発生させます。
[m:Random#rand] を参照してください。
擬似乱数生成器が [m:Kernel?.rand] と共通なため [m:Kernel?.srand] などの影響を受けます。
- **param** `max` -- 乱数値の上限を正の整数または実数で指定します。
- **param** `range` -- 発生させる乱数値の範囲を [c:Range] オブジェクトで指定します。
range の境界は数値でなければなりません。
- **raise** `Errno::EDOM` -- rand(1..Float::INFI...