るりまサーチ (Ruby 2.4.0)

最速Rubyリファレンスマニュアル検索！
784件ヒット [201-300件を表示] （0.307秒）
トップページ > クエリ:_builtin[x] > バージョン:2.4.0[x] > クエリ:at[x]

別のキーワード

  1. _builtin new
  2. _builtin inspect
  3. _builtin []
  4. _builtin to_s
  5. _builtin each

種類

ライブラリ

クラス

モジュール

オブジェクト

キーワード

検索結果

先頭5件

  1. MatchData#captures -> [String]
  2. MatchData#end(n) -> Integer | nil
  3. MatchData#eql?(other) -> bool
  4. MatchData#hash -> Integer
  5. MatchData#inspect -> String
<< < 1 2 3 4 5 ... > >>

MatchData#captures -> [String] (42001.0)

$1, $2, ... を格納した配列を返します。

$1, $2, ... を格納した配列を返します。

MatchData#to_a と異なり $& を要素に含みません。
グループにマッチした部分文字列がなければ対応する要素は nil になります。

//emlist[例][ruby]{
/(foo)(bar)(BAZ)?/ =~ "foobarbaz"
p $~.to_a # => ["foobar", "foo", "bar", nil]
p $~.captures # => ["foo", "bar", nil]
//}

@see MatchData#to_a, MatchData#named_captures

MatchData#end(n) -> Integer | nil (42001.0)

n 番目の部分文字列終端のオフセットを返します。

n 番目の部分文字列終端のオフセットを返します。

0 はマッチ全体を意味します。
n 番目の部分文字列がマッチしていなければ nil を返します。

@param n 部分文字列を指定する数値。

@raise IndexError 範囲外の n を指定した場合に発生します。

//emlist[例][ruby]{
/(foo)(bar)(BAZ)?/ =~ "foobarbaz"
p $~.end(0) # => 6
p $~.end(1) # => 3
p $~.end(2) # => 6
p $~.end(3) # => nil
p $~.end(4) # => ...

MatchData#eql?(other) -> bool (42001.0)

self と other のマッチ対象になった文字列、元になった正規表現オブジェク ト、マッチした位置が等しければ true を返します。そうでない場合には false を返します。

self と other のマッチ対象になった文字列、元になった正規表現オブジェク
ト、マッチした位置が等しければ true を返します。そうでない場合には
false を返します。

@param other 比較対象のオブジェクトを指定します。

//emlist[文字列][ruby]{
s = "abc"
m1 = s.match("a")
m2 = s.match("b")
m1 == m2 # => false
m2 = s.match("a")
m1 == m2 # => true
//}

//emlist[正規表現][ruby]{
r = /abc/
m1 = r.mat...

MatchData#hash -> Integer (42001.0)

self のマッチ対象になった文字列、元になった正規表現オブジェクト、マッチ した位置を元にハッシュ値を計算して返します。

self のマッチ対象になった文字列、元になった正規表現オブジェクト、マッチ
した位置を元にハッシュ値を計算して返します。

MatchData#inspect -> String (42001.0)

self の内容を人間に読みやすい文字列にして返します。

self の内容を人間に読みやすい文字列にして返します。

//emlist[例][ruby]{
puts /.$/.match("foo").inspect
# => #<MatchData "o">

puts /(.)(.)(.)/.match("foo").inspect
# => #<MatchData "foo" 1:"f" 2:"o" 3:"o">

puts /(.)(.)?(.)/.match("fo").inspect
# => #<MatchData "fo" 1:"f" 2:nil 3:"o">

puts /(?<foo>.)(?<bar>.)(?<baz>.)/....

絞り込み条件を変える

MatchData#length -> Integer (42001.0)

部分文字列の数を返します(self.to_a.size と同じです)。

部分文字列の数を返します(self.to_a.size と同じです)。

//emlist[例][ruby]{
/(foo)(bar)(BAZ)?/ =~ "foobarbaz"
p $~.size # => 4
//}

MatchData#named_captures -> Hash (42001.0)

名前付きキャプチャをHashで返します。

名前付きキャプチャをHashで返します。

Hashのキーは名前付きキャプチャの名前です。Hashの値はキーの名前に対応した名前付きグループのうち最後にマッチした文字列です。

//emlist[例][ruby]{
m = /(?<a>.)(?<b>.)/.match("01")
m.named_captures # => {"a" => "0", "b" => "1"}

m = /(?<a>.)(?<b>.)?/.match("0")
m.named_captures # => {"a" => "0", "b" => nil}

m = /(?<a>.)(?<a>.)/.match("0...

MatchData#names -> [String] (42001.0)

名前付きキャプチャの名前を文字列配列で返します。

名前付きキャプチャの名前を文字列配列で返します。

self.regexp.names と同じです。

//emlist[例][ruby]{
/(?<foo>.)(?<bar>.)(?<baz>.)/.match("hoge").names
# => ["foo", "bar", "baz"]

m = /(?<x>.)(?<y>.)?/.match("a") # => #<MatchData "a" x:"a" y:nil>
m.names # => ["x", "y"]
//}

MatchData#offset(n) -> [Integer, Integer] | [nil, nil] (42001.0)

n 番目の部分文字列のオフセットの配列 [start, end] を返 します。

n 番目の部分文字列のオフセットの配列 [start, end] を返
します。

//emlist[例][ruby]{
[ self.begin(n), self.end(n) ]
//}

と同じです。n番目の部分文字列がマッチしていなければ
[nil, nil] を返します。

@param n 部分文字列を指定する数値

@raise IndexError 範囲外の n を指定した場合に発生します。

@see MatchData#begin, MatchData#end

MatchData#offset(name) -> [Integer, Integer] | [nil, nil] (42001.0)

name という名前付きグループに対応する部分文字列のオフセットの配列 [start, end] を返 します。

name という名前付きグループに対応する部分文字列のオフセットの配列 [start, end] を返
します。

//emlist[例][ruby]{
[ self.begin(name), self.end(name) ]
//}

と同じです。nameの名前付きグループにマッチした部分文字列がなければ
[nil, nil] を返します。

@param name 名前(シンボルか文字列)

@raise IndexError 正規表現中で定義されていない name を指定した場合に発生します。

//emlist[例][ruby]{
/(?<year>\d{4})年(?<month>\...

絞り込み条件を変える

MatchData#regexp -> Regexp (42001.0)

自身の元になった正規表現オブジェクトを返します。

自身の元になった正規表現オブジェクトを返します。

//emlist[例][ruby]{
m = /a.*b/.match("abc")
m.regexp # => /a.*b/
//}

MatchData#size -> Integer (42001.0)

部分文字列の数を返します(self.to_a.size と同じです)。

部分文字列の数を返します(self.to_a.size と同じです)。

//emlist[例][ruby]{
/(foo)(bar)(BAZ)?/ =~ "foobarbaz"
p $~.size # => 4
//}

MatchData#string -> String (42001.0)

マッチ対象になった文字列の複製を返します。

マッチ対象になった文字列の複製を返します。

返す文字列はフリーズ(Object#freeze)されています。

//emlist[例][ruby]{
m = /(.)(.)(\d+)(\d)/.match("THX1138.")
m.string # => "THX1138."
//}

MatchData#to_a -> [String] (42001.0)

$&, $1, $2,... を格納した配列を返します。

$&, $1, $2,... を格納した配列を返します。

//emlist[例][ruby]{
/(foo)(bar)(BAZ)?/ =~ "foobarbaz"
p $~.to_a # => ["foobar", "foo", "bar", nil]
//}

@see MatchData#captures

MatchData#to_s -> String (42001.0)

マッチした文字列全体を返します。

マッチした文字列全体を返します。

//emlist[例][ruby]{
/bar/ =~ "foobarbaz"
p $~ # => #<MatchData:0x401b1be4>
p $~.to_s # => "bar"
//}

絞り込み条件を変える

Math (42001.0)

浮動小数点演算をサポートするモジュールです。

浮動小数点演算をサポートするモジュールです。

Math モジュールにはさまざま数学関数がモジュール関数として定義されています。
モジュール関数は以下のように，モジュールの特異メソッドとして呼び出す使い方と、
モジュールをインクルードしてレシーバーを省略した形で呼び出す使い方の両方ができます。

=== 例

//emlist[][ruby]{
pi = Math.atan2(1, 1)*4;
include Math
pi2 = atan2(1, 1)*4
//}

Rational (42001.0)

有理数を扱うクラスです。

有理数を扱うクラスです。

「1/3」のような有理数を扱う事ができます。Integer や Float
と同様に Rational.new ではなく、 Kernel.#Rational を使用して
Rational オブジェクトを作成します。

//emlist[例][ruby]{
Rational(1, 3) # => (1/3)
Rational('1/3') # => (1/3)
Rational('0.33') # => (33/100)
Rational.new(1, 3) # => NoMethodError
//}

Rational オブジェク...

StopIteration (42001.0)

イテレーションを止めるときに発生する例外です。

イテレーションを止めるときに発生する例外です。

Thread::Backtrace::Location (42001.0)

Ruby のフレームを表すクラスです。

Ruby のフレームを表すクラスです。

Kernel.#caller_locations から生成されます。

//emlist[例1][ruby]{
# caller_locations.rb
def a(skip)
caller_locations(skip)
end
def b(skip)
a(skip)
end
def c(skip)
b(skip)
end

c(0..2).map do |call|
puts call.to_s
end
//}

例1の実行結果:

caller_locations.rb:2:in `a'
caller_locations...

fatal (42001.0)

インタプリタ内部で致命的なエラーが起こったときに発生します。

インタプリタ内部で致命的なエラーが起こったときに発生します。

致命的なエラーとは、例えば以下のような状態です。

* スレッドのデッドロックが発生した
* -x オプションや -C オプションで指定されたディレクトリに移動できなかった
* -i オプション付きで起動されたが、
パーミッションなどの関係でファイルを変更できなかった

通常の手段では、
Ruby プログラムからは fatal クラスにはアクセスできません。

絞り込み条件を変える

Enumerator::Lazy#chunk(initial_state) {|elt, state| ... } -> Enumerator::Lazy (33901.0)

Enumerable#chunk と同じですが、配列ではなく Enumerator::Lazy を返します。

Enumerable#chunk と同じですが、配列ではなく Enumerator::Lazy を返します。

//emlist[例][ruby]{
1.step.lazy.chunk{ |n| n % 3 == 0 }
# => #<Enumerator::Lazy: #<Enumerator: #<Enumerator::Generator:0x007f8bf18118f0>:each>>

1.step.lazy.chunk{ |n| n % 3 == 0 }.take(5).force
# => [[false, [1, 2]], [true, [3]], [false, [4, 5...

Enumerator::Lazy#slice_before(initial_state) {|elt, state| bool } -> Enumerator::Lazy (33901.0)

Enumerable#slice_before と同じですが、配列ではなく Enumerator::Lazy を返します。

Enumerable#slice_before と同じですが、配列ではなく Enumerator::Lazy を返します。

//emlist[例][ruby]{
1.step.lazy.slice_before { |e| e.even? }
# => #<Enumerator::Lazy: #<Enumerator: #<Enumerator::Generator:0x00007f9f31844ce8>:each>>

1.step.lazy.slice_before { |e| e % 3 == 0 }.take(5).force
# => [[1, 2], [3, 4, 5], [6...

Enumerator::Lazy#grep(pattern) {|item| ... } -> Enumerator::Lazy (33601.0)

Enumerable#grep と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerable#grep と同じですが、配列ではなくEnumerator::Lazy を返します。

//emlist[例][ruby]{
(100..Float::INFINITY).lazy.map(&:to_s).grep(/\A(\d)\1+\z/)
# => #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator::Lazy: 100..Infinity>:map>:grep(/\A(\d)\1+\z/)>
(100..Float::INFINITY).lazy.map(&:to_s).grep(/\A(\d)\1+\z/)....

Enumerator::Lazy#grep_v(pattern) {|item| ... } -> Enumerator::Lazy (33601.0)

Enumerable#grep_v と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerable#grep_v と同じですが、配列ではなくEnumerator::Lazy を返します。

//emlist[例][ruby]{
(100..Float::INFINITY).lazy.map(&:to_s).grep_v(/(\d).*\1/)
# => #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator::Lazy: 100..Infinity>:map>:grep_v(/(\d).*\1/)>
(100..Float::INFINITY).lazy.map(&:to_s).grep_v(/(\d).*\1/).t...

Enumerator::Lazy#slice_after(pattern) -> Enumerator::Lazy (33601.0)

Enumerable#slice_after と同じですが、配列ではなく Enumerator::Lazy を返します。

Enumerable#slice_after と同じですが、配列ではなく Enumerator::Lazy を返します。

//emlist[例][ruby]{
1.step.lazy.slice_after { |e| e % 3 == 0 }
# => #<Enumerator::Lazy: #<Enumerator: #<Enumerator::Generator:0x007fd73980e6f8>:each>>

1.step.lazy.slice_after { |e| e % 3 == 0 }.take(5).force
# => [[1, 2, 3], [4, 5, 6], [...

絞り込み条件を変える

Enumerator::Lazy#slice_before(pattern) -> Enumerator::Lazy (33601.0)

Enumerable#slice_before と同じですが、配列ではなく Enumerator::Lazy を返します。

Enumerable#slice_before と同じですが、配列ではなく Enumerator::Lazy を返します。

//emlist[例][ruby]{
1.step.lazy.slice_before { |e| e.even? }
# => #<Enumerator::Lazy: #<Enumerator: #<Enumerator::Generator:0x00007f9f31844ce8>:each>>

1.step.lazy.slice_before { |e| e % 3 == 0 }.take(5).force
# => [[1, 2], [3, 4, 5], [6...

File::Stat.new(path) -> File::Stat (33601.0)

path に関する File::Stat オブジェクトを生成して返します。 File.stat と同じです。

path に関する File::Stat オブジェクトを生成して返します。
File.stat と同じです。

@param path ファイルのパスを指定します。

@raise Errno::ENOENT pathに該当するファイルが存在しない場合発生します。

//emlist[][ruby]{
p $:[0]
#=> 例
# "C:/Program Files/ruby-1.8/lib/ruby/site_ruby/1.8"
p File::Stat.new($:[0])
#=> 例
#<File::Stat dev=0x2, ino=0, mode=040755, nlink=1,...

Rational#*(other) -> Rational | Float (33601.0)

積を計算します。

積を計算します。

@param other 自身に掛ける数

other に Float を指定した場合は、計算結果を Float で返しま
す。

//emlist[例][ruby]{
r = Rational(3, 4)
r * 2 # => (3/2)
r * 4 # => (3/1)
r * 0.5 # => 0.375
r * Rational(1, 2) # => (3/8)
//}

Rational#**(other) -> Rational | Float (33601.0)

冪(べき)乗を計算します。

冪(べき)乗を計算します。

@param other 自身を other 乗する数

other に Float を指定した場合は、計算結果を Float で返しま
す。other が有理数であっても、計算結果が無理数だった場合は Float
を返します。

//emlist[例][ruby]{
r = Rational(3, 4)
r ** Rational(2, 1) # => (9/16)
r ** 2 # => (9/16)
r ** 2.0 # => 0.5625
r ** Rational(1, 2) # => 0.866...

Rational#+(other) -> Rational | Float (33601.0)

和を計算します。

和を計算します。

@param other 自身に足す数

other に Float を指定した場合は、計算結果を Float で返しま
す。

//emlist[例][ruby]{
r = Rational(3, 4)
r + Rational(1, 2) # => (5/4)
r + 1 # => (7/4)
r + 0.5 # => 1.25
//}

絞り込み条件を変える

Rational#-(other) -> Rational | Float (33601.0)

差を計算します。

差を計算します。

@param other 自身から引く数

other に Float を指定した場合は、計算結果を Float で返しま
す。

//emlist[例][ruby]{
r = Rational(3, 4)
r - 1 # => (-1/4)
r - 0.5 # => 0.25
//}

Rational#/(other) -> Rational | Float (33601.0)

商を計算します。

商を計算します。

@param other 自身を割る数

other に Float を指定した場合は、計算結果を Float で返します。

//emlist[例][ruby]{
r = Rational(3, 4)
r / 2 # => (3/8)
r / 2.0 # => 0.375
r / 0.5 # => 1.5
r / Rational(1, 2) # => (3/2)
r / 0 # => ZeroDivisionError
//}

@raise ZeroD...

Rational#quo(other) -> Rational | Float (33601.0)

商を計算します。

商を計算します。

@param other 自身を割る数

other に Float を指定した場合は、計算結果を Float で返します。

//emlist[例][ruby]{
r = Rational(3, 4)
r / 2 # => (3/8)
r / 2.0 # => 0.375
r / 0.5 # => 1.5
r / Rational(1, 2) # => (3/2)
r / 0 # => ZeroDivisionError
//}

@raise ZeroD...

ARGF.class#path -> String (33301.0)

現在開いている処理対象のファイル名を返します。

現在開いている処理対象のファイル名を返します。

標準入力に対しては - を返します。
組み込み変数 $FILENAME と同じです。

$ echo "foo" > foo
$ echo "bar" > bar
$ echo "glark" > glark

$ ruby argf.rb foo bar glark

ARGF.filename # => "foo"
ARGF.read(5) # => "foo\nb"
ARGF.filename # => "bar"
ARGF.skip
ARGF.filename # => "glark"

Complex#conjugate -> Complex (33301.0)

自身の共役複素数を返します。

自身の共役複素数を返します。

//emlist[例][ruby]{
Complex(1, 2).conj # => (1-2i)
//}

絞り込み条件を変える

Complex#to_r -> Rational (33301.0)

自身を Rational に変換します。

自身を Rational に変換します。

@param eps 許容する誤差。常に無視されます。

@raise RangeError 虚部が実数か、0 ではない場合に発生します。

//emlist[例][ruby]{
Complex(3).to_r # => (3/1)
Complex(3, 2).to_r # => RangeError
//}

Enumerator#each(*args) -> Enumerator (33301.0)

生成時のパラメータに従ってブロックを繰り返します。 *args を渡した場合は、生成時のパラメータ内引数末尾へ *args を追加した状態で繰り返します。 ブロック付きで呼び出された場合は、 生成時に指定したイテレータの戻り値をそのまま返します。

生成時のパラメータに従ってブロックを繰り返します。
*args を渡した場合は、生成時のパラメータ内引数末尾へ *args を追加した状態で繰り返します。
ブロック付きで呼び出された場合は、
生成時に指定したイテレータの戻り値をそのまま返します。

@param args 末尾へ追加する引数

//emlist[例1][ruby]{
str = "Yet Another Ruby Hacker"

enum = Enumerator.new {|y| str.scan(/\w+/) {|w| y << w }}
enum.each {|word| p word } ...

Enumerator#size -> Integer | Float::INFINITY | nil (33301.0)

self の要素数を返します。

self の要素数を返します。

要素数が無限の場合は Float::INFINITY を返します。
Enumerator.new に Proc オブジェクトを指定していた場合はその
実行結果を返します。呼び出した時に要素数が不明であった場合は nil を返し
ます。

//emlist[例][ruby]{
(1..100).to_a.permutation(4).size # => 94109400
loop.size # => Float::INFINITY
(1..100).drop_while.size # => nil
//}

@see Enumerator.new

Enumerator#with_index(offset = 0) -> Enumerator (33301.0)

生成時のパラメータに従って、要素にインデックスを添えて繰り返します。 インデックスは offset から始まります。

生成時のパラメータに従って、要素にインデックスを添えて繰り返します。
インデックスは offset から始まります。

ブロックを指定した場合の戻り値は生成時に指定したレシーバ自身です。

//emlist[例][ruby]{
str = "xyz"

enum = Enumerator.new {|y| str.each_byte {|b| y << b }}
enum.with_index {|byte, idx| p [byte, idx] }
# => [120, 0]
# [121, 1]
# [122, 2]

require "stringi...

Enumerator#with_object(obj) -> Enumerator (33301.0)

繰り返しの各要素に obj を添えてブロックを繰り返し、obj を返り値として返します。

繰り返しの各要素に obj を添えてブロックを繰り返し、obj を返り値として返します。

obj には任意のオブジェクトを渡すことができます。

ブロックが渡されなかった場合は、上で説明した繰り返しを実行し、
最後に obj を返す Enumerator を返します。

//emlist[例][ruby]{
# 0,1,2 と呼びだす enumeratorを作る
to_three = Enumerator.new do |y|
3.times do |x|
y << x
end
end

to_three_with_string = to_three.with_object...

絞り込み条件を変える

Enumerator.new(obj, method = :each, *args) -> Enumerator (33301.0)

オブジェクト obj について、 each の代わりに method という 名前のメソッドを使って繰り返すオブジェクトを生成して返します。 args を指定すると、 method の呼び出し時に渡されます。

オブジェクト obj について、 each の代わりに method という
名前のメソッドを使って繰り返すオブジェクトを生成して返します。
args を指定すると、 method の呼び出し時に渡されます。

@param obj イテレータメソッドのレシーバとなるオブジェクト
@param method イテレータメソッドの名前を表すシンボルまたは文字列
@param args イテレータメソッドの呼び出しに渡す任意個の引数

//emlist[例][ruby]{
str = "xyz"

enum = Enumerator.new(str, :each_byte)
p enum.map...

Enumerator.new(size=nil) {|y| ... } -> Enumerator (33301.0)

Enumerator オブジェクトを生成して返します。与えられたブロックは Enumerator::Yielder オブジェクトを 引数として実行されます。

Enumerator オブジェクトを生成して返します。与えられたブロックは Enumerator::Yielder オブジェクトを
引数として実行されます。

生成された Enumerator オブジェクトに対して each を呼ぶと、この生成時に指定されたブロックを
実行し、Yielder オブジェクトに対して << メソッドが呼ばれるたびに、
each に渡されたブロックが繰り返されます。

new に渡されたブロックが終了した時点で each の繰り返しが終わります。
このときのブロックの返り値が each の返り値となります。

@param size 生成する Enumerator...

Enumerator::Lazy#chunk {|elt| ... } -> Enumerator::Lazy (33301.0)

Enumerable#chunk と同じですが、配列ではなく Enumerator::Lazy を返します。

Enumerable#chunk と同じですが、配列ではなく Enumerator::Lazy を返します。

//emlist[例][ruby]{
1.step.lazy.chunk{ |n| n % 3 == 0 }
# => #<Enumerator::Lazy: #<Enumerator: #<Enumerator::Generator:0x007f8bf18118f0>:each>>

1.step.lazy.chunk{ |n| n % 3 == 0 }.take(5).force
# => [[false, [1, 2]], [true, [3]], [false, [4, 5...

Enumerator::Lazy#chunk_while {|elt_before, elt_after| ... } -> Enumerator::Lazy (33301.0)

Enumerable#chunk_while と同じですが、Enumerator ではなく Enumerator::Lazy を返します。

Enumerable#chunk_while と同じですが、Enumerator ではなく Enumerator::Lazy を返します。

@raise ArgumentError ブロックを指定しなかった場合に発生します。

Enumerator::Lazy#collect {|item| ... } -> Enumerator::Lazy (33301.0)

Enumerable#map と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerable#map と同じですが、配列ではなくEnumerator::Lazy を返します。

@raise ArgumentError ブロックを指定しなかった場合に発生します。

//emlist[例][ruby]{
1.step.lazy.map{ |n| n % 3 == 0 }
# => #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator: 1:step>>:map>

1.step.lazy.collect{ |n| n.succ }.take(10).force
# => [2, 3, 4, 5, 6, 7, 8,...

絞り込み条件を変える

Enumerator::Lazy#drop(n) -> Enumerator::Lazy (33301.0)

Enumerable#drop と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerable#drop と同じですが、配列ではなくEnumerator::Lazy を返します。

@param n 要素数を指定します。

@raise ArgumentError n に負の数を指定した場合に発生します。

//emlist[例][ruby]{
1.step.lazy.drop(3)
# => #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator: 1:step>>:drop(3)>

1.step.lazy.drop(3).take(10).force
# => [4, 5, 6, 7, 8, 9, 10, 1...

Enumerator::Lazy#drop_while {|item| ... } -> Enumerator::Lazy (33301.0)

Enumerable#drop_while と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerable#drop_while と同じですが、配列ではなくEnumerator::Lazy を返します。

//emlist[例][ruby]{
1.step.lazy.drop_while { |i| i < 42 }
# => #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator: 1:step>>:drop_while>

1.step.lazy.drop_while { |i| i < 42 }.take(10).force
# => [42, 43, 44, 45, 46, 47, 48, 49, 50, 51]
//...

Enumerator::Lazy#enum_for(method = :each, *args) -> Enumerator::Lazy (33301.0)

Object#to_enum と同じですが、Enumerator::Lazy を返します。

Object#to_enum と同じですが、Enumerator::Lazy を返します。

to_enum は「ブロック付きで呼ぶとループを実行し、ブロックを省略した場合は
Enumerator を返す」ようなメソッドを定義するときによく使われます。
このときに lazy 性が正しく引き継がれるように、Lazy#to_enum は
素のEnumerator ではなく Enumerator::Lazy を返すようになっています。

//emlist[例][ruby]{
module Enumerable
# 要素をn回ずつ繰り返すメソッド
# 例：[1,2,3].repeat(2) ...

Enumerator::Lazy#enum_for(method = :each, *args) {|*args| block} -> Enumerator::Lazy (33301.0)

Object#to_enum と同じですが、Enumerator::Lazy を返します。

Object#to_enum と同じですが、Enumerator::Lazy を返します。

to_enum は「ブロック付きで呼ぶとループを実行し、ブロックを省略した場合は
Enumerator を返す」ようなメソッドを定義するときによく使われます。
このときに lazy 性が正しく引き継がれるように、Lazy#to_enum は
素のEnumerator ではなく Enumerator::Lazy を返すようになっています。

//emlist[例][ruby]{
module Enumerable
# 要素をn回ずつ繰り返すメソッド
# 例：[1,2,3].repeat(2) ...

Enumerator::Lazy#find_all {|item| ... } -> Enumerator::Lazy (33301.0)

Enumerable#select と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerable#select と同じですが、配列ではなくEnumerator::Lazy を返します。

@raise ArgumentError ブロックを指定しなかった場合に発生します。

//emlist[例][ruby]{
1.step.lazy.find_all { |i| i.even? }
# => #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator: 1:step>>:find_all>

1.step.lazy.select { |i| i.even? }.take(10).force
# => [2, 4, 6,...

絞り込み条件を変える

Enumerator::Lazy#map {|item| ... } -> Enumerator::Lazy (33301.0)

Enumerable#map と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerable#map と同じですが、配列ではなくEnumerator::Lazy を返します。

@raise ArgumentError ブロックを指定しなかった場合に発生します。

//emlist[例][ruby]{
1.step.lazy.map{ |n| n % 3 == 0 }
# => #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator: 1:step>>:map>

1.step.lazy.collect{ |n| n.succ }.take(10).force
# => [2, 3, 4, 5, 6, 7, 8,...

Enumerator::Lazy#reject {|item| ... } -> Enumerator::Lazy (33301.0)

Enumerable#reject と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerable#reject と同じですが、配列ではなくEnumerator::Lazy を返します。

@raise ArgumentError ブロックを指定しなかった場合に発生します。

//emlist[例][ruby]{
1.step.lazy.reject { |i| i.even? }
# => #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator: 1:step>>:reject>

1.step.lazy.reject { |i| i.even? }.take(10).force
# => [1, 3, 5, 7, ...

Enumerator::Lazy#select {|item| ... } -> Enumerator::Lazy (33301.0)

Enumerable#select と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerable#select と同じですが、配列ではなくEnumerator::Lazy を返します。

@raise ArgumentError ブロックを指定しなかった場合に発生します。

//emlist[例][ruby]{
1.step.lazy.find_all { |i| i.even? }
# => #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator: 1:step>>:find_all>

1.step.lazy.select { |i| i.even? }.take(10).force
# => [2, 4, 6,...

Enumerator::Lazy#slice_after {|elt| bool } -> Enumerator::Lazy (33301.0)

Enumerable#slice_after と同じですが、配列ではなく Enumerator::Lazy を返します。

Enumerable#slice_after と同じですが、配列ではなく Enumerator::Lazy を返します。

//emlist[例][ruby]{
1.step.lazy.slice_after { |e| e % 3 == 0 }
# => #<Enumerator::Lazy: #<Enumerator: #<Enumerator::Generator:0x007fd73980e6f8>:each>>

1.step.lazy.slice_after { |e| e % 3 == 0 }.take(5).force
# => [[1, 2, 3], [4, 5, 6], [...

Enumerator::Lazy#slice_before {|elt| bool } -> Enumerator::Lazy (33301.0)

Enumerable#slice_before と同じですが、配列ではなく Enumerator::Lazy を返します。

Enumerable#slice_before と同じですが、配列ではなく Enumerator::Lazy を返します。

//emlist[例][ruby]{
1.step.lazy.slice_before { |e| e.even? }
# => #<Enumerator::Lazy: #<Enumerator: #<Enumerator::Generator:0x00007f9f31844ce8>:each>>

1.step.lazy.slice_before { |e| e % 3 == 0 }.take(5).force
# => [[1, 2], [3, 4, 5], [6...

絞り込み条件を変える

Enumerator::Lazy#slice_when {|elt_before, elt_after| bool } -> Enumerator::Lazy (33301.0)

Enumerable#slice_when と同じですが、配列ではなく Enumerator::Lazy を返します。

Enumerable#slice_when と同じですが、配列ではなく Enumerator::Lazy を返します。

//emlist[例][ruby]{
1.step.lazy.slice_when { |i, j| (i + j) % 5 == 0 }
# => #<Enumerator::Lazy: #<Enumerator: #<Enumerator::Generator:0x00007fce84118348>:each>>

1.step.lazy.slice_when { |i, j| (i + j) % 5 == 0 }.take(5).force
# => [[1, 2]...

Enumerator::Lazy#take(n) -> Enumerator::Lazy (33301.0)

Enumerable#take と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerable#take と同じですが、配列ではなくEnumerator::Lazy を返します。

n が大きな数 (100000とか) の場合に備えて再定義されています。
配列が必要な場合は Enumerable#first を使って下さい。

@param n 要素数を指定します。

@raise ArgumentError n に負の数を指定した場合に発生します。

//emlist[例][ruby]{
1.step.lazy.take(5)
# => #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator: 1:step>>:...

Enumerator::Lazy#take_while -> Enumerator::Lazy (33301.0)

Enumerable#take_while と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerable#take_while と同じですが、配列ではなくEnumerator::Lazy を返します。

//emlist[例][ruby]{
1.step.lazy.zip(('a'..'z').cycle).take_while { |e| e.first < 100_000 }
# => #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator: 1:step>>:zip(#<Enumerator: "a".."z":cycle>)>:take_while>

1.step.lazy....

Enumerator::Lazy#take_while {|item| ... } -> Enumerator::Lazy (33301.0)

Enumerable#take_while と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerable#take_while と同じですが、配列ではなくEnumerator::Lazy を返します。

//emlist[例][ruby]{
1.step.lazy.zip(('a'..'z').cycle).take_while { |e| e.first < 100_000 }
# => #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator: 1:step>>:zip(#<Enumerator: "a".."z":cycle>)>:take_while>

1.step.lazy....

Enumerator::Lazy#to_enum(method = :each, *args) -> Enumerator::Lazy (33301.0)

Object#to_enum と同じですが、Enumerator::Lazy を返します。

Object#to_enum と同じですが、Enumerator::Lazy を返します。

to_enum は「ブロック付きで呼ぶとループを実行し、ブロックを省略した場合は
Enumerator を返す」ようなメソッドを定義するときによく使われます。
このときに lazy 性が正しく引き継がれるように、Lazy#to_enum は
素のEnumerator ではなく Enumerator::Lazy を返すようになっています。

//emlist[例][ruby]{
module Enumerable
# 要素をn回ずつ繰り返すメソッド
# 例：[1,2,3].repeat(2) ...

絞り込み条件を変える

Enumerator::Lazy#to_enum(method = :each, *args) {|*args| block} -> Enumerator::Lazy (33301.0)

Object#to_enum と同じですが、Enumerator::Lazy を返します。

Object#to_enum と同じですが、Enumerator::Lazy を返します。

to_enum は「ブロック付きで呼ぶとループを実行し、ブロックを省略した場合は
Enumerator を返す」ようなメソッドを定義するときによく使われます。
このときに lazy 性が正しく引き継がれるように、Lazy#to_enum は
素のEnumerator ではなく Enumerator::Lazy を返すようになっています。

//emlist[例][ruby]{
module Enumerable
# 要素をn回ずつ繰り返すメソッド
# 例：[1,2,3].repeat(2) ...

Enumerator::Lazy#uniq -> Enumerator::Lazy (33301.0)

Enumerable#uniq と同じですが、配列ではなく Enumerator::Lazy を返します。

Enumerable#uniq と同じですが、配列ではなく Enumerator::Lazy を返します。

Enumerator::Lazy#uniq {|item| ... } -> Enumerator::Lazy (33301.0)

Enumerable#uniq と同じですが、配列ではなく Enumerator::Lazy を返します。

Enumerable#uniq と同じですが、配列ではなく Enumerator::Lazy を返します。

Enumerator::Lazy#zip(*lists) -> Enumerator::Lazy (33301.0)

Enumerable#zip と同じですが、配列ではなくEnumerator::Lazy を返します。

Enumerable#zip と同じですが、配列ではなくEnumerator::Lazy を返します。

ただし一貫性のため、ブロック付きで呼び出した場合は Enumerable#zip と
同じ挙動になります。

//emlist[例][ruby]{
1.step.lazy.zip(('a'..'z').cycle)
# => #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator: 1:step>>:zip(#<Enumerator: "a".."z":cycle>)>

1.step.lazy.zip(('a'..'z').cycle)...

Enumerator::Lazy.new(obj, size=nil) {|yielder, *values| ... } -> Enumerator::Lazy (33301.0)

Lazy Enumerator を作成します。Enumerator::Lazy#force メソッドなどに よって列挙が実行されたとき、objのeachメソッドが実行され、値が一つずつ ブロックに渡されます。ブロックは、yielder を使って最終的に yield される値を 指定できます。

Lazy Enumerator を作成します。Enumerator::Lazy#force メソッドなどに
よって列挙が実行されたとき、objのeachメソッドが実行され、値が一つずつ
ブロックに渡されます。ブロックは、yielder を使って最終的に yield される値を
指定できます。

//emlist[Enumerable#filter_map と、その遅延評価版を定義する例][ruby]{
module Enumerable
def filter_map(&block)
map(&block).compact
end
end

class Enumerator::...

絞り込み条件を変える

Float#%(other) -> Float (33301.0)

算術演算子。剰余を計算します。

算術演算子。剰余を計算します。

@param other 二項演算の右側の引数(対象)

//emlist[例][ruby]{
# 剰余
3.0 % 1.2 # => 0.6000000000000001
3.0 % 0.0 # ZeroDivisionError
//}

Float#*(other) -> Float (33301.0)

算術演算子。積を計算します。

算術演算子。積を計算します。

@param other 二項演算の右側の引数(対象)

//emlist[例][ruby]{
# 積
2.4 * 3 # => 7.2
//}

Float#**(other) -> Float (33301.0)

算術演算子。冪を計算します。

算術演算子。冪を計算します。

@param other 二項演算の右側の引数(対象)

//emlist[例][ruby]{
# 冪
1.2 ** 3.0 # => 1.7279999999999998
3.0 + 4.5 - 1.3 / 2.4 * 3 % 1.2 ** 3.0 # => 5.875
0.0 ** 0 # => 1.0
//}

Float#+(other) -> Float (33301.0)

算術演算子。和を計算します。

算術演算子。和を計算します。

@param other 二項演算の右側の引数(対象)

//emlist[例][ruby]{
# 和
3.0 + 4.5 # => 7.5
//}

Float#-(other) -> Float (33301.0)

算術演算子。差を計算します。

算術演算子。差を計算します。

@param other 二項演算の右側の引数(対象)

//emlist[例][ruby]{
# 差
4.5 - 1.3 # => 3.2
//}

絞り込み条件を変える

Float#-@ -> Float (33301.0)

単項演算子の - です。 self の符号を反転させたものを返します。

単項演算子の - です。
self の符号を反転させたものを返します。

//emlist[例][ruby]{
- 1.2 # => -1.2
- -1.2 # => 1.2
//}

Float#/(other) -> Float (33301.0)

算術演算子。商を計算します。

算術演算子。商を計算します。

@param other 二項演算の右側の引数(対象)

//emlist[例][ruby]{
# 商
1.3 / 2.4 # => 0.541666666666667
1.0 / 0 # => Infinity
//}

Float#abs -> Float (33301.0)

自身の絶対値を返します。

自身の絶対値を返します。

//emlist[例][ruby]{
34.56.abs # => 34.56
-34.56.abs # => 34.56
//}

Float#angle -> 0 | Float (33301.0)

自身の偏角(正の数なら 0、負の数なら Math::PI)を返します。

自身の偏角(正の数なら 0、負の数なら Math::PI)を返します。

//emlist[例][ruby]{
1.arg # => 0
-1.arg # => 3.141592653589793
//}

ただし、自身が NaN(Not a number) であった場合は、NaN を返します。

Float#arg -> 0 | Float (33301.0)

自身の偏角(正の数なら 0、負の数なら Math::PI)を返します。

自身の偏角(正の数なら 0、負の数なら Math::PI)を返します。

//emlist[例][ruby]{
1.arg # => 0
-1.arg # => 3.141592653589793
//}

ただし、自身が NaN(Not a number) であった場合は、NaN を返します。

絞り込み条件を変える

Float#ceil(ndigits = 0) -> Integer | Float (33301.0)

自身と等しいかより大きな整数のうち最小のものを返します。

自身と等しいかより大きな整数のうち最小のものを返します。

@param ndigits 10進数での小数点以下の有効桁数を整数で指定します。
正の整数を指定した場合、Float を返します。
小数点以下を、最大 n 桁にします。
負の整数を指定した場合、Integer を返します。
小数点位置から左に少なくとも n 個の 0 が並びます。

//emlist[例][ruby]{
1.2.ceil # => 2
2.0.ceil # => 2
(-1.2...

Float#floor(ndigits = 0) -> Integer | Float (33301.0)

自身と等しいかより小さな整数のうち最大のものを返します。

自身と等しいかより小さな整数のうち最大のものを返します。

@param ndigits 10進数での小数点以下の有効桁数を整数で指定します。
正の整数を指定した場合、Float を返します。
小数点以下を、最大 n 桁にします。
負の整数を指定した場合、Integer を返します。
小数点位置から左に少なくとも n 個の 0 が並びます。

//emlist[例][ruby]{
1.2.floor # => 1
2.0.floor # => 2
(-1...

Float#magnitude -> Float (33301.0)

自身の絶対値を返します。

自身の絶対値を返します。

//emlist[例][ruby]{
34.56.abs # => 34.56
-34.56.abs # => 34.56
//}

Float#modulo(other) -> Float (33301.0)

算術演算子。剰余を計算します。

算術演算子。剰余を計算します。

@param other 二項演算の右側の引数(対象)

//emlist[例][ruby]{
# 剰余
3.0 % 1.2 # => 0.6000000000000001
3.0 % 0.0 # ZeroDivisionError
//}

Float#phase -> 0 | Float (33301.0)

自身の偏角(正の数なら 0、負の数なら Math::PI)を返します。

自身の偏角(正の数なら 0、負の数なら Math::PI)を返します。

//emlist[例][ruby]{
1.arg # => 0
-1.arg # => 3.141592653589793
//}

ただし、自身が NaN(Not a number) であった場合は、NaN を返します。

絞り込み条件を変える

Float#round(ndigits = 0) -> Integer | Float (33301.0)

自身ともっとも近い整数もしくは実数を返します。

自身ともっとも近い整数もしくは実数を返します。

中央値 0.5, -0.5 はそれぞれ 1,-1 に切り上げされます。
いわゆる四捨五入ですが、偶数丸めではありません。

@param ndigits 丸める位を指定します。
ndigitsが0ならば、小数点以下を四捨五入し、整数を返します。
ndigitsが0より大きいならば、小数点以下の指定された位で四捨五入されます。
ndigitsが0より小さいならば、小数点以上の指定された位で四捨五入されます。
@param half ちょうど半分の値の丸め方を指定します。
サポートされている...

Float#round(ndigits = 0, half: :up) -> Integer | Float (33301.0)

自身ともっとも近い整数もしくは実数を返します。

自身ともっとも近い整数もしくは実数を返します。

中央値 0.5, -0.5 はそれぞれ 1,-1 に切り上げされます。
いわゆる四捨五入ですが、偶数丸めではありません。

@param ndigits 丸める位を指定します。
ndigitsが0ならば、小数点以下を四捨五入し、整数を返します。
ndigitsが0より大きいならば、小数点以下の指定された位で四捨五入されます。
ndigitsが0より小さいならば、小数点以上の指定された位で四捨五入されます。
@param half ちょうど半分の値の丸め方を指定します。
サポートされている...

Float#to_r -> Rational (33301.0)

自身を Rational に変換します。

自身を Rational に変換します。

//emlist[例][ruby]{
0.5.to_r # => (1/2)
//}

Float::EPSILON -> Float (33301.0)

1.0 + Float::EPSILON != 1.0 となる最小の正の値です。

1.0 + Float::EPSILON != 1.0 となる最小の正の値です。

通常はデフォルトで 2.2204460492503131e-16 です。

Float::INFINITY -> Float (33301.0)

浮動小数点数における正の無限大です。

浮動小数点数における正の無限大です。

負の無限大は -Float::INFINITY です。

@see Float#finite?, Float#infinite?

絞り込み条件を変える

Float::MAX -> Float (33301.0)

Float が取り得る最大の有限の値です。

Float が取り得る最大の有限の値です。

通常はデフォルトで 1.7976931348623157e+308 です。

@see Float::MIN

Float::MIN -> Float (33301.0)

Float が取り得る最小の正の値です。

Float が取り得る最小の正の値です。

通常はデフォルトで 2.2250738585072014e-308 です。

Float が取り得る最小の有限の値は -Float::MAX です。

@see Float::MAX

Float::NAN -> Float (33301.0)

浮動小数点数における NaN(Not a number)です。

浮動小数点数における NaN(Not a number)です。

@see Float#nan?

Hash#update(other) -> self (33301.0)

selfとotherのハッシュの内容をマージ(統合)します。

selfとotherのハッシュの内容をマージ(統合)します。

デフォルト値はselfの設定のままです。

self と other に同じキーがあった場合はブロック付きか否かで
判定方法が違います。ブロック付きのときはブロックを呼び出して
その返す値を重複キーに対応する値にします。ブロック付きでない
場合は常に other の値を使います。

otherがハッシュではない場合、otherのメソッドto_hashを使って暗黙の変換を試みます。

@param other マージ用のハッシュまたはメソッド to_hash でハッシュに変換できるオブジェクトです。
@return マージ後のse...

Hash#update(other) {|key, self_val, other_val| ... } -> self (33301.0)

selfとotherのハッシュの内容をマージ(統合)します。

selfとotherのハッシュの内容をマージ(統合)します。

デフォルト値はselfの設定のままです。

self と other に同じキーがあった場合はブロック付きか否かで
判定方法が違います。ブロック付きのときはブロックを呼び出して
その返す値を重複キーに対応する値にします。ブロック付きでない
場合は常に other の値を使います。

otherがハッシュではない場合、otherのメソッドto_hashを使って暗黙の変換を試みます。

@param other マージ用のハッシュまたはメソッド to_hash でハッシュに変換できるオブジェクトです。
@return マージ後のse...

絞り込み条件を変える

Kernel$$LOADED_FEATURES -> [String] (33301.0)

Kernel.#require でロードされたファイル名を含む配列です。

Kernel.#require でロードされたファイル名を含む配列です。

Kernel.#require で同じファイルを
複数回ロードしないようにするためのロックとして使われます。

この変数はグローバルスコープです。

Kernel$$LOAD_PATH -> [String] (33301.0)

Rubyライブラリをロードするときの検索パスです。

Rubyライブラリをロードするときの検索パスです。

Kernel.#load や Kernel.#require
がファイルをロードする時に検索するディレクトリのリストを含む配列です。

起動時にはコマンドラインオプション -I で指定したディレクトリ、
環境変数 RUBYLIB の値、
コンパイル時に指定したデフォルト値
をこの順番で含みます。

以下に典型的な UNIX システム上でのロードパスを示します。

-I で指定したパス
環境変数 RUBYLIB の値
/usr/local/lib/ruby/site_ruby/VERSION サイト固有、バージョン依...

Kernel.#iterator? -> bool (33301.0)

メソッドにブロックが与えられていれば真を返します。

メソッドにブロックが与えられていれば真を返します。

このメソッドはカレントコンテキストにブロックが与えられているかを調べるので、
メソッド内部以外で使っても単に false を返します。

iterator? は （ブロックが必ずイテレートするとはいえないので）推奨されていないの
で block_given? を使ってください。

//emlist[例][ruby]{
def check
if block_given?
puts "Block is given."
else
puts "Block isn't given."
end
end
check{} #=...

Kernel.#sprintf(format, *arg) -> String (33301.0)

format 文字列を C 言語の sprintf と同じように解釈し、 引数をフォーマットした文字列を返します。

format 文字列を C 言語の sprintf と同じように解釈し、
引数をフォーマットした文字列を返します。

@param format フォーマット文字列です。
@param arg フォーマットされる引数です。
@see Kernel.#printf,Time#strftime,Date.strptime

=== sprintf フォーマット

Ruby の sprintf フォーマットは基本的に C 言語の sprintf(3)
のものと同じです。ただし、short や long などの C 特有の型に対する修飾子が
ないこと、2進数の指示子(%b, %B)が存在すること、s...

Math.#acos(x) -> Float (33301.0)

x の逆余弦関数（arccosine）の値をラジアンで返します。

x の逆余弦関数（arccosine）の値をラジアンで返します。

@param x -1.0 <= x <= 1 の範囲内の実数

@return 返される値の範囲は [0, +π] です。

@raise TypeError x に数値以外を指定した場合に発生します。

@raise Math::DomainError x に範囲外の実数を指定した場合に発生します。

@raise RangeError x に実数以外の数値を指定した場合に発生します。

//emlist[例][ruby]{
Math.acos(0) == Math::PI/2 # => true
//}

@see ...

絞り込み条件を変える

Math.#acosh(x) -> Float (33301.0)

x の逆双曲線余弦関数（area hyperbolic cosine）の値を返します。

x の逆双曲線余弦関数（area hyperbolic cosine）の値を返します。

=== 定義

acosh(x) = log(x + sqrt(x * x - 1)) [x >= 1]

@param x x >= 1 の範囲の実数

@raise TypeError x に数値以外を指定した場合に発生します。

@raise Math::DomainError x に範囲外の実数を指定した場合に発生します。

@raise RangeError x に実数以外の数値を指定した場合に発生します。

@see Math.#cosh

Math.#asin(x) -> Float (33301.0)

x の逆正弦関数（arcsine）の値をラジアンで返します。

x の逆正弦関数（arcsine）の値をラジアンで返します。

@param x -1.0 <= x <= 1 の範囲内の実数

@return 返される値の範囲は[-π/2, +π/2] です。

@raise TypeError x に数値以外を指定した場合に発生します。

@raise Math::DomainError x に範囲外の実数を指定した場合に発生します。

@raise RangeError x に実数以外の数値を指定した場合に発生します。

//emlist[例][ruby]{
Math.asin(1) == Math::PI/2 # => true
//}

@se...

Math.#asinh(x) -> Float (33301.0)

x の逆双曲線正弦関数（area hyperbolic sine）の値を返します。

x の逆双曲線正弦関数（area hyperbolic sine）の値を返します。

=== 定義

asinh(x) = log(x + sqrt(x * x + 1))

@param x 実数

@raise TypeError x に数値以外を指定した場合に発生します。

@raise RangeError x に実数以外の数値を指定した場合に発生します。

@see Math.#sinh

Math.#cbrt(x) -> Float (33301.0)

x の立方根（cubic root）を返します。

x の立方根（cubic root）を返します。

@param x 実数

@raise TypeError xに数値以外を指定した場合に発生します。

@raise RangeError xに実数以外の数値を指定した場合に発生します。

//emlist[例][ruby]{
-9.upto(9) {|x|
p [x, Math.cbrt(x), Math.cbrt(x)**3]
}
# => [-9, -2.0800838230519, -9.0]
# [-8, -2.0, -8.0]
# [-7, -1.91293118277239, -7.0]
# [-6, -1.8...

Math.#cos(x) -> Float (33301.0)

x の余弦関数（cosine）の値を返します。

x の余弦関数（cosine）の値を返します。

@param x 実数（ラジアンで与えます）

@return [-1, 1] の実数

@raise TypeError x に数値以外を指定した場合に発生します。

@raise RangeError x に実数以外の数値を指定した場合に発生します。

//emlist[例][ruby]{
Math.cos(Math::PI) # => -1.0
//}

@see Math.#acos

絞り込み条件を変える

<< < 1 2 3 4 5 ... > >>

検索対象のドキュメントは るりまプロジェクト の成果物です。

検索エンジンは Groonga 13.0.0 を使っています。

Groongaは Rroonga 12.1.0 経由で利用しています。

Powered by Ruby 3.1.2.

るりまサーチのリポジトリ は GitHub 上にあります。