Collections and Data Structures

iterate(iter [, state]) -> Union{Nothing, Tuple{Any, Any}}

イテレータを進めて次の要素を取得します。要素が残っていない場合は、nothingが返されるべきです。そうでなければ、次の要素と新しいイテレーション状態の2タプルが返されるべきです。

IteratorSize(itertype::Type) -> IteratorSize

イテレータの型を与えると、次のいずれかの値を返します：

• SizeUnknown() もし長さ（要素の数）が事前に決定できない場合。
• HasLength() もし固定された有限の長さがある場合。
• HasShape{N}() もし既知の長さに加えて多次元の形状の概念がある場合（配列のように）。この場合、N は次元の数を示し、axes 関数はイテレータに対して有効です。
• IsInfinite() もしイテレータが永遠に値を生成する場合。

デフォルト値（この関数を定義していないイテレータの場合）は HasLength() です。これは、ほとんどのイテレータが length を実装していると仮定されることを意味します。

この特性は、結果のためにスペースを事前に割り当てるアルゴリズムと、結果を段階的にサイズ変更するアルゴリズムを選択するために一般的に使用されます。

julia> Base.IteratorSize(1:5)
Base.HasShape{1}()

julia> Base.IteratorSize((2,3))
Base.HasLength()

IteratorEltype(itertype::Type) -> IteratorEltype

イテレータの型が与えられたとき、次のいずれかの値を返します：

• EltypeUnknown() イテレータによって生成される要素の型が事前に知られていない場合。
• HasEltype() 要素の型が知られており、eltype が意味のある値を返す場合。

HasEltype() はデフォルトであり、イテレータは eltype を実装していると仮定されます。

この特性は、特定の型の結果を事前に割り当てるアルゴリズムと、生成される値の型に基づいて結果の型を選択するアルゴリズムの間で選択するために一般的に使用されます。

julia> Base.IteratorEltype(1:5)
Base.HasEltype()

AbstractRange{T} <: AbstractVector{T}

型 T の要素を持つ線形範囲のスーパタイプです。 UnitRange、LinRange およびその他の型はこのサブタイプです。

すべてのサブタイプは step を定義する必要があります。したがって、LogRange は AbstractRange のサブタイプではありません。

OrdinalRange{T, S} <: AbstractRange{T}

型 T の要素を持ち、型 S の間隔を持つ順序範囲のスーパタイプ。ステップは常に oneunit の正確な倍数である必要があり、T は "離散的" 型でなければならず、oneunit より小さい値を持つことはできません。例えば、Integer や Date 型は適格ですが、Float64 型は適格ではありません（この型は oneunit(Float64) より小さい値を表すことができるため）。UnitRange、StepRange、およびその他の型はこのサブタイプです。

AbstractUnitRange{T} <: OrdinalRange{T, T}

ステップサイズがoneunit(T)で、要素の型がTの範囲のスーパークラスです。UnitRangeやその他の型はこのサブタイプです。

StepRange{T, S} <: OrdinalRange{T, S}

要素の型 T と間隔の型 S を持つ範囲。各要素間のステップは一定で、範囲は型 T の start と stop、および型 S の step に基づいて定義されます。T も S も浮動小数点型であってはなりません。a:b:c という構文は、b != 0 であり、a、b、c がすべて整数である場合に StepRange を作成します。

例

julia> collect(StepRange(1, Int8(2), 10))
5-element Vector{Int64}:
 1
 3
 5
 7
 9

julia> typeof(StepRange(1, Int8(2), 10))
StepRange{Int64, Int8}

julia> typeof(1:3:6)
StepRange{Int64, Int64}

UnitRange{T<:Real}

start と stop の型 T によってパラメータ化された範囲で、start から stop を超えるまで 1 ずつ間隔を空けた要素で満たされています。a:b という構文は、a と b の両方が Integer の場合に UnitRange を作成します。

例

julia> collect(UnitRange(2.3, 5.2))
3-element Vector{Float64}:
 2.3
 3.3
 4.3

julia> typeof(1:10)
UnitRange{Int64}

LinRange{T,L}

start と stop の間に len 個の線形に間隔を空けた要素を持つ範囲。間隔のサイズは len によって制御され、Integer でなければなりません。

例

julia> LinRange(1.5, 5.5, 9)
9-element LinRange{Float64, Int64}:
 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0, 5.5

range を使用するのと比較して、LinRange を直接構築する方がオーバーヘッドが少なくなりますが、浮動小数点エラーを修正しようとはしません：

julia> collect(range(-0.1, 0.3, length=5))
5-element Vector{Float64}:
 -0.1
  0.0
  0.1
  0.2
  0.3

julia> collect(LinRange(-0.1, 0.3, 5))
5-element Vector{Float64}:
 -0.1
 -1.3877787807814457e-17
  0.09999999999999999
  0.19999999999999998
  0.3

対数間隔の点については Logrange も参照してください。

isempty(collection) -> Bool

コレクションが空であるか（要素がないか）を判断します。

例

julia> isempty([])
true

julia> isempty([1 2 3])
false

isempty(condition)

条件に待機しているタスクがない場合は true を返し、そうでない場合は false を返します。

isdone(itr, [state]) -> Union{Bool, Missing}

この関数は、イテレータの完了に関する高速パスのヒントを提供します。これは、ユーザーに公開されない要素が消費されるのを避けたい状態を持つイテレータにとって便利です（例えば、isemptyやzipで完了状態を確認する際など）。

この機能を利用したい状態を持つイテレータは、イテレータが完了しているかどうかに応じて真偽値を返すisdoneメソッドを定義する必要があります。状態を持たないイテレータは、この関数を実装する必要はありません。

結果がmissingの場合、呼び出し元はiterate(x, state) === nothingを計算して明確な答えを得ることができます。

他にもiterate、isemptyを参照してください。

empty!(collection) -> collection

コレクションからすべての要素を削除します。

例

julia> A = Dict("a" => 1, "b" => 2)
Dict{String, Int64} with 2 entries:
  "b" => 2
  "a" => 1

julia> empty!(A);

julia> A
Dict{String, Int64}()

empty!(c::Channel)

チャンネル c を内部バッファに対して empty! を呼び出すことで空にします。空のチャンネルを返します。

length(collection) -> 整数

コレクション内の要素の数を返します。

インデックス可能なコレクションの最後の有効なインデックスを取得するには、lastindexを使用してください。

関連情報: size, ndims, eachindex.

例

julia> length(1:5)
5

julia> length([1, 2, 3, 4])
4

julia> length([1 2; 3 4])
4

Base.checked_length(r)

length(r)を計算しますが、結果がUnion{Integer(eltype(r)),Int}に収まらない場合、適用可能な場合はオーバーフローエラーをチェックすることがあります。

in(item, collection) -> Bool
∈(item, collection) -> Bool

指定されたコレクションにアイテムが含まれているかどうかを判断します。これは、アイテムがコレクションを反復処理して生成された値のいずれかと==であるという意味です。itemがmissingであるか、collectionがitemを含まないmissingを含む場合を除いて、Bool値を返します。この場合、missingが返されます（三値論理、anyおよび==の動作に一致します）。

一部のコレクションは、わずかに異なる定義に従います。たとえば、Setはアイテムが要素のいずれかとisequalであるかどうかを確認します。Dictはkey=>valueペアを探し、keyはisequalを使用して比較されます。

辞書内のキーの存在をテストするには、haskeyまたはk in keys(dict)を使用します。上記のコレクションの場合、結果は常にBoolです。

in.(items, collection)またはitems .∈ collectionでブロードキャストすると、itemとcollectionの両方がブロードキャストされ、これはしばしば意図したものではありません。たとえば、両方の引数がベクトルで（次元が一致する場合）、結果はコレクションitemsの各値がcollectionの対応する位置の値にinであるかどうかを示すベクトルになります。itemsの各値がcollectionに含まれているかどうかを示すベクトルを取得するには、collectionをタプルまたはRefでラップします。例えば、in.(items, Ref(collection))またはitems .∈ Ref(collection)のようにします。

関連項目: ∉, insorted, contains, occursin, issubset。

例

julia> a = 1:3:20
1:3:19

julia> 4 in a
true

julia> 5 in a
false

julia> missing in [1, 2]
missing

julia> 1 in [2, missing]
missing

julia> 1 in [1, missing]
true

julia> missing in Set([1, 2])
false

julia> (1=>missing) in Dict(1=>10, 2=>20)
missing

julia> [1, 2] .∈ [2, 3]
2-element BitVector:
 0
 0

julia> [1, 2] .∈ ([2, 3],)
2-element BitVector:
 0
 1

∉(item, collection) -> Bool
∌(collection, item) -> Bool

∈ と ∋ の否定、すなわち item が collection に含まれていないことをチェックします。

items .∉ collection でブロードキャストすると、item と collection の両方がブロードキャストされるため、意図した結果にならないことがよくあります。たとえば、両方の引数がベクトルで（次元が一致する場合）、結果は collection の対応する位置の値に対して items の各値が含まれていないかどうかを示すベクトルになります。items の各値が collection に含まれていないかどうかを示すベクトルを得るには、collection をタプルまたは Ref でラップします。例えば、items .∉ Ref(collection) のようにします。

例

julia> 1 ∉ 2:4
true

julia> 1 ∉ 1:3
false

julia> [1, 2] .∉ [2, 3]
2-element BitVector:
 1
 1

julia> [1, 2] .∉ ([2, 3],)
2-element BitVector:
 1
 0

Base.hasfastin(T)

collection::T に対して x ∈ collection の計算が「高速」な操作（通常は定数または対数の複雑さ）と見なされるかどうかを判断します。便利のために、hasfastin(x) = hasfastin(typeof(x)) という定義が提供されているので、インスタンスを型の代わりに渡すことができます。ただし、型引数を受け入れる形式は新しい型のために定義する必要があります。

hasfastin(T) のデフォルトは、AbstractSet、AbstractDict、および AbstractRange のサブタイプに対して true であり、それ以外は false です。

eltype(type)

与えられた type のコレクションを反復処理することによって生成される要素の型を決定します。辞書型の場合、これは Pair{KeyType,ValType} になります。便利のために eltype(x) = eltype(typeof(x)) という定義が提供されているので、型の代わりにインスタンスを渡すことができます。ただし、型引数を受け取る形式は新しい型のために定義する必要があります。

関連情報: keytype, typeof.

例

julia> eltype(fill(1f0, (2,2)))
Float32

julia> eltype(fill(0x1, (2,2)))
UInt8

indexin(a, b)

bの各値に対するaの最初のインデックスを含む配列を返します。出力配列は、aがbのメンバーでない場合にnothingを含みます。

関連情報: sortperm, findfirst.

例

julia> a = ['a', 'b', 'c', 'b', 'd', 'a'];

julia> b = ['a', 'b', 'c'];

julia> indexin(a, b)
6-element Vector{Union{Nothing, Int64}}:
 1
 2
 3
 2
  nothing
 1

julia> indexin(b, a)
3-element Vector{Union{Nothing, Int64}}:
 1
 2
 3

unique(itr)

コレクション itr のユニークな要素のみを含む配列を返します。これは isequal と hash によって決定され、同等の要素の最初の出現順に並べられます。入力の要素タイプは保持されます。

関連情報: unique!, allunique, allequal.

例

julia> unique([1, 2, 6, 2])
3-element Vector{Int64}:
 1
 2
 6

julia> unique(Real[1, 1.0, 2])
2-element Vector{Real}:
 1
 2

unique(f, itr)

itrの要素に適用されたfによって生成された各ユニークな値に対して、itrから1つの値を含む配列を返します。

例

julia> unique(x -> x^2, [1, -1, 3, -3, 4])
3-element Vector{Int64}:
 1
 3
 4

この機能は、配列内のユニークな要素の最初の出現のインデックスを抽出するためにも使用できます：

julia> a = [3.1, 4.2, 5.3, 3.1, 3.1, 3.1, 4.2, 1.7];

julia> i = unique(i -> a[i], eachindex(a))
4-element Vector{Int64}:
 1
 2
 3
 8

julia> a[i]
4-element Vector{Float64}:
 3.1
 4.2
 5.3
 1.7

julia> a[i] == unique(a)
true

unique(A::AbstractArray; dims::Int)

次元 dims に沿った A のユニークな領域を返します。

例

julia> A = map(isodd, reshape(Vector(1:8), (2,2,2)))
2×2×2 Array{Bool, 3}:
[:, :, 1] =
 1  1
 0  0

[:, :, 2] =
 1  1
 0  0

julia> unique(A)
2-element Vector{Bool}:
 1
 0

julia> unique(A, dims=2)
2×1×2 Array{Bool, 3}:
[:, :, 1] =
 1
 0

[:, :, 2] =
 1
 0

julia> unique(A, dims=3)
2×2×1 Array{Bool, 3}:
[:, :, 1] =
 1  1
 0  0

unique!(f, A::AbstractVector)

Aの要素に適用されたfによって生成された各ユニークな値に対して、Aから1つの値を選択し、修正されたAを返します。

例

julia> unique!(x -> x^2, [1, -1, 3, -3, 4])
3-element Vector{Int64}:
 1
 3
 4

julia> unique!(n -> n%3, [5, 1, 8, 9, 3, 4, 10, 7, 2, 6])
3-element Vector{Int64}:
 5
 1
 9

julia> unique!(iseven, [2, 3, 5, 7, 9])
2-element Vector{Int64}:
 2
 3

unique!(A::AbstractVector)

isequal と hash によって決定される重複アイテムを削除し、修正された A を返します。unique! は、A の要素を発生する順序で返します。返されるデータの順序を気にしない場合は、(sort!(A); unique!(A)) を呼び出す方が、A の要素がソート可能である限り、はるかに効率的です。

例

julia> unique!([1, 1, 1])
1-element Vector{Int64}:
 1

julia> A = [7, 3, 2, 3, 7, 5];

julia> unique!(A)
4-element Vector{Int64}:
 7
 3
 2
 5

julia> B = [7, 6, 42, 6, 7, 42];

julia> sort!(B);  # unique! はソートされたデータをより効率的に処理できます。

julia> unique!(B)
3-element Vector{Int64}:
  6
  7
 42

allunique(itr) -> Bool
allunique(f, itr) -> Bool

itrのすべての値がisequalで比較したときに異なる場合はtrueを返します。2番目のメソッドでは、[f(x) for x in itr]のすべてが異なる場合も同様です。

allunique(f, itr)は、fをlength(itr)回未満呼び出す場合があります。呼び出しの正確な回数は実装の詳細と見なされます。

alluniqueは、入力がソートされている場合に特化した実装を使用することがあります。

関連項目: unique, issorted, allequal.

例

julia> allunique([1, 2, 3])
true

julia> allunique([1, 2, 1, 2])
false

julia> allunique(Real[1, 1.0, 2])
false

julia> allunique([NaN, 2.0, NaN, 4.0])
false

julia> allunique(abs, [1, -1, 2])
false

allequal(itr) -> Bool
allequal(f, itr) -> Bool

itrのすべての値がisequalで比較したときに等しい場合はtrueを返します。あるいは、2番目のメソッドの場合、[f(x) for x in itr]のすべてが等しい場合です。

allequal(f, itr)は、fをlength(itr)回未満呼び出す場合があります。呼び出しの正確な回数は実装の詳細と見なされます。

関連: unique, allunique.

例

julia> allequal([])
true

julia> allequal([1])
true

julia> allequal([1, 1])
true

julia> allequal([1, 2])
false

julia> allequal(Dict(:a => 1, :b => 1))
false

julia> allequal(abs2, [1, -1])
true

reduce(op, itr; [init])

与えられたコレクション itr を与えられた二項演算子 op で縮約します。提供されている場合、初期値 init は op の中立要素でなければならず、空のコレクションに対して返されます。非空のコレクションに対して init が使用されるかどうかは未定義です。

空のコレクションに対しては、init を提供する必要がありますが、いくつかの特別なケース（例えば、op が +、*、max、min、&、| のいずれかである場合）では、Julia が op の中立要素を決定できます。

特定の一般的に使用される演算子の縮約には特別な実装がある場合があり、代わりに使用すべきです: maximum(itr), minimum(itr), sum(itr), prod(itr), any(itr), all(itr). 特定の配列の配列を連結するための効率的な方法は、reduce(vcat, arr) または reduce(hcat, arr) を呼び出すことです。

縮約の結合性は実装に依存します。これは、- のような非結合的な操作を使用できないことを意味します。なぜなら、reduce(-,[1,2,3]) が (1-2)-3 と評価されるべきか、1-(2-3) と評価されるべきかは未定義だからです。左または右の結合性が保証されるためには、代わりに foldl または foldr を使用してください。

いくつかの操作は誤差を蓄積します。縮約がグループで実行できる場合、並列処理が容易になります。将来のバージョンの Julia ではアルゴリズムが変更される可能性があります。順序付きコレクションを使用する場合、要素は再配置されないことに注意してください。

例

julia> reduce(*, [2; 3; 4])
24

julia> reduce(*, [2; 3; 4]; init=-1)
-24

reduce(f, A::AbstractArray; dims=:, [init])

2引数関数 f を A の次元に沿って縮小します。dims は縮小する次元を指定するベクトルであり、キーワード引数 init は縮小に使用する初期値です。+、*、max および min の場合、init 引数はオプションです。

縮小の結合性は実装に依存します。特定の結合性、例えば左から右への結合性が必要な場合は、自分でループを書くか、foldl または foldr の使用を検討してください。 reduce のドキュメントを参照してください。

例

julia> a = reshape(Vector(1:16), (4,4))
4×4 Matrix{Int64}:
 1  5   9  13
 2  6  10  14
 3  7  11  15
 4  8  12  16

julia> reduce(max, a, dims=2)
4×1 Matrix{Int64}:
 13
 14
 15
 16

julia> reduce(max, a, dims=1)
1×4 Matrix{Int64}:
 4  8  12  16

foldl(op, itr; [init])

reduceと同様ですが、左結合性が保証されています。キーワード引数initが提供された場合、それは正確に1回だけ使用されます。一般的に、空のコレクションで作業するにはinitを提供する必要があります。

他にmapfoldl、foldr、accumulateも参照してください。

例

julia> foldl(=>, 1:4)
((1 => 2) => 3) => 4

julia> foldl(=>, 1:4; init=0)
(((0 => 1) => 2) => 3) => 4

julia> accumulate(=>, (1,2,3,4))
(1, 1 => 2, (1 => 2) => 3, ((1 => 2) => 3) => 4)

foldr(op, itr; [init])

reduceと同様ですが、右結合性が保証されています。キーワード引数initが提供された場合、それは正確に1回使用されます。一般的に、空のコレクションで作業するにはinitを提供する必要があります。

例

julia> foldr(=>, 1:4)
1 => (2 => (3 => 4))

julia> foldr(=>, 1:4; init=0)
1 => (2 => (3 => (4 => 0)))

maximum(f, itr; [init])

関数 f を itr の各要素に適用した結果の中で、最大の結果を返します。

空の itr に対して返される値は init で指定できます。これは max に対して中立的な要素でなければなりません（すなわち、他のどの要素よりも小さいか等しい必要があります）。init が非空のコレクションに対して使用されるかどうかは未定義です。

例

julia> maximum(length, ["Julion", "Julia", "Jule"])
6

julia> maximum(length, []; init=-1)
-1

julia> maximum(sin, Real[]; init=-1.0)  # 良い、なぜなら sin の出力は >= -1
-1.0

maximum(itr; [init])

コレクション内の最大の要素を返します。

空の itr に対して返される値は init によって指定できます。これは max に対して中立的な要素でなければなりません（すなわち、他のどの要素よりも小さいか等しい必要があります）。init が非空のコレクションに対して使用されるかどうかは未定義です。

例

julia> maximum(-20.5:10)
9.5

julia> maximum([1,2,3])
3

julia> maximum(())
ERROR: ArgumentError: 空のコレクションに対して削減は許可されていません; リデューサに `init` を供給することを検討してください
Stacktrace:
[...]

julia> maximum((); init=-Inf)
-Inf

maximum(A::AbstractArray; dims)

与えられた次元にわたる配列の最大値を計算します。二つ以上の引数の最大値を取るmax(a,b)関数も参照してください。これはmax.(a,b)を介して配列に要素ごとに適用できます。

また、maximum!、extrema、findmax、argmaxも参照してください。

例

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> maximum(A, dims=1)
1×2 Matrix{Int64}:
 3  4

julia> maximum(A, dims=2)
2×1 Matrix{Int64}:
 2
 4

maximum(f, A::AbstractArray; dims)

与えられた次元にわたって配列の各要素に関数 f を適用することによって最大値を計算します。

例

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> maximum(abs2, A, dims=1)
1×2 Matrix{Int64}:
 9  16

julia> maximum(abs2, A, dims=2)
2×1 Matrix{Int64}:
  4
 16

maximum!(r, A)

Aの単一次元にわたる最大値を計算し、結果をrに書き込みます。

例

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> maximum!([1; 1], A)
2-element Vector{Int64}:
 2
 4

julia> maximum!([1 1], A)
1×2 Matrix{Int64}:
 3  4

minimum(f, itr; [init])

関数 f を itr の各要素に適用した結果の中で最小の値を返します。

空の itr に対して返される値は init で指定できます。これは min に対して中立的な要素でなければならず（すなわち、他のどの要素よりも大きいか等しい必要があります）、init が非空のコレクションに対して使用されるかどうかは未定義です。

例

julia> minimum(length, ["Julion", "Julia", "Jule"])
4

julia> minimum(length, []; init=typemax(Int64))
9223372036854775807

julia> minimum(sin, Real[]; init=1.0)  # 良い、なぜなら sin の出力は <= 1 だから
1.0

minimum(itr; [init])

コレクション内の最小要素を返します。

空の itr に対して返される値は init によって指定できます。これは min に対して中立的な要素でなければなりません（すなわち、他のどの要素よりも大きいか等しいものでなければなりません）。init が非空のコレクションに対して使用されるかどうかは未定義です。

例

julia> minimum(-20.5:10)
-20.5

julia> minimum([1,2,3])
1

julia> minimum([])
ERROR: ArgumentError: reducing over an empty collection is not allowed; consider supplying `init` to the reducer
Stacktrace:
[...]

julia> minimum([]; init=Inf)
Inf

minimum(A::AbstractArray; dims)

与えられた次元にわたる配列の最小値を計算します。二つ以上の引数の最小値を取るmin(a,b)関数も参照してください。これはmin.(a,b)を介して配列に要素ごとに適用できます。

他にもminimum!、extrema、findmin、argminを参照してください。

例

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> minimum(A, dims=1)
1×2 Matrix{Int64}:
 1  2

julia> minimum(A, dims=2)
2×1 Matrix{Int64}:
 1
 3

minimum(f, A::AbstractArray; dims)

与えられた次元にわたって配列の各要素に関数 f を適用することによって最小値を計算します。

例

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> minimum(abs2, A, dims=1)
1×2 Matrix{Int64}:
 1  4

julia> minimum(abs2, A, dims=2)
2×1 Matrix{Int64}:
 1
 9

minimum!(r, A)

Aの単一次元にわたる最小値を計算し、結果をrに書き込みます。

例

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> minimum!([1; 1], A)
2-element Vector{Int64}:
 1
 3

julia> minimum!([1 1], A)
1×2 Matrix{Int64}:
 1  2

extrema(itr; [init]) -> (mn, mx)

単一のパスで最小値 mn と最大値 mx の両方の要素を計算し、それらを2タプルとして返します。

空の itr に対して返される値は init で指定できます。これは、最初の要素と第二の要素がそれぞれ min と max の中立要素である2タプルでなければなりません（すなわち、他のどの要素よりも大きい/小さいか等しい）。その結果、itr が空の場合、返される (mn, mx) タプルは mn ≥ mx を満たします。init が指定されている場合、空でない itr に対しても使用できます。

例

julia> extrema(2:10)
(2, 10)

julia> extrema([9,pi,4.5])
(3.141592653589793, 9.0)

julia> extrema([]; init = (Inf, -Inf))
(Inf, -Inf)

extrema(f, itr; [init]) -> (mn, mx)

itrの各要素に適用されたfの最小値mnと最大値mxを計算し、それらを2タプルとして返します。itrに対しては1回のパスのみが行われます。

空のitrに対して返される値はinitで指定できます。これは、最初の要素と2番目の要素がそれぞれminとmaxの中立要素である2タプルでなければなりません（すなわち、他のどの要素よりも大きい/小さいか等しい）。これは非空のコレクションに使用されます。注意: これは、空のitrに対して返される値(mn, mx)がmn ≥ mxを満たすことを意味しますが、非空のitrに対してはmn ≤ mxを満たします。これは「逆説的」ですが、期待される結果です。

例

julia> extrema(sin, 0:π)
(0.0, 0.9092974268256817)

julia> extrema(sin, Real[]; init = (1.0, -1.0))  # 良い、なぜなら -1 ≤ sin(::Real) ≤ 1
(1.0, -1.0)

extrema(A::AbstractArray; dims) -> Array{Tuple}

与えられた次元にわたって配列の最小および最大要素を計算します。

参照: minimum, maximum, extrema!.

例

julia> A = reshape(Vector(1:2:16), (2,2,2))
2×2×2 Array{Int64, 3}:
[:, :, 1] =
 1  5
 3  7

[:, :, 2] =
  9  13
 11  15

julia> extrema(A, dims = (1,2))
1×1×2 Array{Tuple{Int64, Int64}, 3}:
[:, :, 1] =
 (1, 7)

[:, :, 2] =
 (9, 15)

extrema(f, A::AbstractArray; dims) -> Array{Tuple}

与えられた次元の A の各要素に適用された f の最小値と最大値を計算します。

extrema!(r, A)

Aの単一次元にわたる最小値と最大値を計算し、結果をrに書き込みます。

例

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> extrema!([(1, 1); (1, 1)], A)
2-element Vector{Tuple{Int64, Int64}}:
 (1, 2)
 (3, 4)

julia> extrema!([(1, 1);; (1, 1)], A)
1×2 Matrix{Tuple{Int64, Int64}}:
 (1, 3)  (2, 4)

argmax(r::AbstractRange)

範囲は複数の最大要素を持つことがあります。その場合、argmaxは最大のインデックスを返しますが、必ずしも最初のものではありません。

argmax(f, domain)

f(x) が最大化される domain からの値 x を返します。f(x) の最大値が複数ある場合は、最初のものが見つかります。

domain は空でない反復可能なものでなければなりません。

値は isless で比較されます。

関連情報として argmin、findmax を参照してください。

例

julia> argmax(abs, -10:5)
-10

julia> argmax(cos, 0:π/2:2π)
0.0

argmax(itr)

コレクション内の最大要素のインデックスまたはキーを返します。最大要素が複数ある場合は、最初のものが返されます。

コレクションは空であってはいけません。

インデックスは、keys(itr) および pairs(itr) によって返されるものと同じ型です。

値は isless で比較されます。

関連項目: argmin, findmax.

例

julia> argmax([8, 0.1, -9, pi])
1

julia> argmax([1, 7, 7, 6])
2

julia> argmax([1, 7, 7, NaN])
4

argmax(A; dims) -> indices

配列入力の場合、指定された次元にわたる最大要素のインデックスを返します。NaNは、missingを除くすべての値よりも大きいと見なされます。

例

julia> A = [1.0 2; 3 4]
2×2 Matrix{Float64}:
 1.0  2.0
 3.0  4.0

julia> argmax(A, dims=1)
1×2 Matrix{CartesianIndex{2}}:
 CartesianIndex(2, 1)  CartesianIndex(2, 2)

julia> argmax(A, dims=2)
2×1 Matrix{CartesianIndex{2}}:
 CartesianIndex(1, 2)
 CartesianIndex(2, 2)

argmin(r::AbstractRange)

範囲は複数の最小要素を持つことがあります。その場合、argminは最小のインデックスを返しますが、必ずしも最初のものではありません。

argmin(f, domain)

f(x) が最小化される domain からの値 x を返します。f(x) の最小値が複数ある場合は、最初のものが見つかります。

domain は空でない反復可能なものでなければなりません。

NaN は missing を除くすべての値よりも小さいと見なされます。

argmax や findmin も参照してください。

例

julia> argmin(sign, -10:5)
-10

julia> argmin(x -> -x^3 + x^2 - 10, -5:5)
5

julia> argmin(acos, 0:0.1:1)
1.0

argmin(itr)

コレクション内の最小要素のインデックスまたはキーを返します。最小要素が複数ある場合は、最初のものが返されます。

コレクションは空であってはいけません。

インデックスは keys(itr) および pairs(itr) によって返されるものと同じ型です。

NaN は missing を除くすべての値よりも小さいものとして扱われます。

関連項目: argmax, findmin.

例

julia> argmin([8, 0.1, -9, pi])
3

julia> argmin([7, 1, 1, 6])
2

julia> argmin([7, 1, 1, NaN])
4

argmin(A; dims) -> indices

配列入力の場合、指定された次元にわたる最小要素のインデックスを返します。NaNは、missingを除くすべての値よりも小さいと見なされます。

例

julia> A = [1.0 2; 3 4]
2×2 Matrix{Float64}:
 1.0  2.0
 3.0  4.0

julia> argmin(A, dims=1)
1×2 Matrix{CartesianIndex{2}}:
 CartesianIndex(1, 1)  CartesianIndex(1, 2)

julia> argmin(A, dims=2)
2×1 Matrix{CartesianIndex{2}}:
 CartesianIndex(1, 1)
 CartesianIndex(2, 1)

findmax(f, domain) -> (f(x), index)

コドメイン内の値（fの出力）と、domain内の対応する値のインデックスまたはキー（fへの入力）のペアを返します。ここで、f(x)が最大化されます。最大点が複数ある場合は、最初のものが返されます。

domainは、keysをサポートする非空のイテラブルでなければなりません。インデックスは、keys(domain)によって返されるものと同じ型です。

値はislessで比較されます。

例

julia> findmax(identity, 5:9)
(9, 5)

julia> findmax(-, 1:10)
(-1, 1)

julia> findmax(first, [(1, :a), (3, :b), (3, :c)])
(3, 2)

julia> findmax(cos, 0:π/2:2π)
(1.0, 1)

findmax(itr) -> (x, index)

コレクション itr の最大要素とそのインデックスまたはキーを返します。最大要素が複数ある場合は、最初のものが返されます。値は isless で比較されます。

インデックスは keys(itr) および pairs(itr) によって返されるものと同じ型です。

関連情報: findmin, argmax, maximum.

例

julia> findmax([8, 0.1, -9, pi])
(8.0, 1)

julia> findmax([1, 7, 7, 6])
(7, 2)

julia> findmax([1, 7, 7, NaN])
(NaN, 4)

findmax(A; dims) -> (maxval, index)

配列入力に対して、指定された次元における最大値とそのインデックスを返します。NaNは、missingを除くすべての値よりも大きいと見なされます。

例

julia> A = [1.0 2; 3 4]
2×2 Matrix{Float64}:
 1.0  2.0
 3.0  4.0

julia> findmax(A, dims=1)
([3.0 4.0], CartesianIndex{2}[CartesianIndex(2, 1) CartesianIndex(2, 2)])

julia> findmax(A, dims=2)
([2.0; 4.0;;], CartesianIndex{2}[CartesianIndex(1, 2); CartesianIndex(2, 2);;])

findmax(f, A; dims) -> (f(x), index)

配列入力の場合、指定された次元にわたって f を最大化する対応する値のコドメイン内の値とインデックスを返します。

例

julia> A = [-1.0 1; -0.5 2]
2×2 Matrix{Float64}:
 -1.0  1.0
 -0.5  2.0

julia> findmax(abs2, A, dims=1)
([1.0 4.0], CartesianIndex{2}[CartesianIndex(1, 1) CartesianIndex(2, 2)])

julia> findmax(abs2, A, dims=2)
([1.0; 4.0;;], CartesianIndex{2}[CartesianIndex(1, 1); CartesianIndex(2, 2);;])

findmin(f, domain) -> (f(x), index)

コドメイン内の値（fの出力）と、domain内の対応する値のインデックスまたはキー（fの入力）のペアを返します。f(x)が最小化されるようにします。最小点が複数ある場合は、最初のものが返されます。

domainは空でないイテラブルでなければなりません。

インデックスはkeys(domain)およびpairs(domain)によって返されるものと同じ型です。

NaNは、missingを除くすべての値よりも小さいと見なされます。

例

julia> findmin(identity, 5:9)
(5, 1)

julia> findmin(-, 1:10)
(-10, 10)

julia> findmin(first, [(2, :a), (2, :b), (3, :c)])
(2, 1)

julia> findmin(cos, 0:π/2:2π)
(-1.0, 3)

findmin(itr) -> (x, index)

コレクション itr の最小要素とそのインデックスまたはキーを返します。複数の最小要素がある場合は、最初のものが返されます。NaN は missing を除くすべての値よりも小さいと見なされます。

インデックスは keys(itr) および pairs(itr) によって返されるものと同じ型です。

関連項目: findmax, argmin, minimum.

例

julia> findmin([8, 0.1, -9, pi])
(-9.0, 3)

julia> findmin([1, 7, 7, 6])
(1, 1)

julia> findmin([1, 7, 7, NaN])
(NaN, 4)

findmin(A; dims) -> (minval, index)

配列入力の場合、指定された次元における最小値とそのインデックスを返します。NaNは、missingを除くすべての値よりも小さいと見なされます。

例

julia> A = [1.0 2; 3 4]
2×2 Matrix{Float64}:
 1.0  2.0
 3.0  4.0

julia> findmin(A, dims=1)
([1.0 2.0], CartesianIndex{2}[CartesianIndex(1, 1) CartesianIndex(1, 2)])

julia> findmin(A, dims=2)
([1.0; 3.0;;], CartesianIndex{2}[CartesianIndex(1, 1); CartesianIndex(2, 1);;])

findmin(f, A; dims) -> (f(x), index)

配列入力の場合、指定された次元にわたって f を最小化する対応する値のコドメイン内の値とインデックスを返します。

例

julia> A = [-1.0 1; -0.5 2]
2×2 Matrix{Float64}:
 -1.0  1.0
 -0.5  2.0

julia> findmin(abs2, A, dims=1)
([0.25 1.0], CartesianIndex{2}[CartesianIndex(2, 1) CartesianIndex(1, 2)])

julia> findmin(abs2, A, dims=2)
([1.0; 0.25;;], CartesianIndex{2}[CartesianIndex(1, 1); CartesianIndex(2, 1);;])

findmax!(rval, rind, A) -> (maxval, index)

Aの最大値と対応する線形インデックスをrvalとrindの単一次元に沿って見つけ、結果をrvalとrindに格納します。NaNはmissingを除くすべての他の値よりも大きいと見なされます。

findmin!(rval, rind, A) -> (minval, index)

Aの最小値と対応する線形インデックスをrvalとrindの単一次元に沿って見つけ、結果をrvalとrindに格納します。NaNはmissingを除くすべての値よりも小さいと見なされます。

sum(f, itr; [init])

itrの各要素に対して関数fを呼び出した結果を合計します。

返り値の型は、システムのワードサイズ未満の符号付き整数の場合はInt、システムのワードサイズ未満の符号なし整数の場合はUIntです。その他の引数については、すべての引数が昇格される共通の返り値の型が見つかります。

空のitrに対して返される値はinitで指定できます。これは加法的単位（すなわちゼロ）でなければならず、initが非空のコレクションに使用されるかどうかは未定義です。

例

julia> sum(abs2, [2; 3; 4])
29

小さな整数のeltypeを持つ配列に対するsum(A)とreduce(+, A)の重要な違いに注意してください：

julia> sum(Int8[100, 28])
128

julia> reduce(+, Int8[100, 28])
-128

前者の場合、整数はシステムのワードサイズに拡張されるため、結果は128になります。後者の場合、そのような拡張は行われず、整数のオーバーフローが発生し、-128になります。

sum(itr; [init])

コレクション内のすべての要素の合計を返します。

返り値の型は、システムのワードサイズ未満の符号付き整数の場合は Int、システムのワードサイズ未満の符号なし整数の場合は UInt です。その他のすべての引数については、すべての引数が昇格される共通の返り値の型が見つかります。

空の itr に対して返される値は init によって指定できます。これは加法的単位元（すなわちゼロ）でなければならず、init が非空のコレクションに使用されるかどうかは未定義です。

参照: reduce, mapreduce, count, union.

例

julia> sum(1:20)
210

julia> sum(1:20; init = 0.0)
210.0

sum(A::AbstractArray; dims)

指定された次元にわたって配列の要素を合計します。

例

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> sum(A, dims=1)
1×2 Matrix{Int64}:
 4  6

julia> sum(A, dims=2)
2×1 Matrix{Int64}:
 3
 7

sum(f, A::AbstractArray; dims)

配列の各要素に対して関数 f を呼び出した結果を、指定された次元にわたって合計します。

例

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> sum(abs2, A, dims=1)
1×2 Matrix{Int64}:
 10  20

julia> sum(abs2, A, dims=2)
2×1 Matrix{Int64}:
  5
 25

sum!(r, A)

Aの要素をrの単一次元にわたって合計し、結果をrに書き込みます。

例

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> sum!([1; 1], A)
2-element Vector{Int64}:
 3
 7

julia> sum!([1 1], A)
1×2 Matrix{Int64}:
 4  6

prod(f, itr; [init])

itrの各要素に適用されたfの積を返します。

返り値の型は、システムのワードサイズ未満の符号付き整数の場合はInt、システムのワードサイズ未満の符号なし整数の場合はUIntです。その他の引数については、すべての引数が昇格される共通の返り値の型が見つかります。

空のitrに対して返される値はinitで指定できます。initは乗法的単位（すなわち1）でなければならず、非空のコレクションに対してinitが使用されるかどうかは未定義です。

例

julia> prod(abs2, [2; 3; 4])
576

prod(itr; [init])

コレクションのすべての要素の積を返します。

返り値の型は、システムのワードサイズ未満の符号付き整数の場合は Int、システムのワードサイズ未満の符号なし整数の場合は UInt です。その他の引数については、すべての引数が昇格される共通の返り値の型が見つかります。

空の itr に対して返される値は init によって指定できます。これは乗法的単位（すなわち1）でなければならず、init が非空のコレクションに使用されるかどうかは未定義です。

参照: reduce, cumprod, any.

例

julia> prod(1:5)
120

julia> prod(1:5; init = 1.0)
120.0

prod(A::AbstractArray; dims)

指定された次元にわたって配列の要素を乗算します。

例

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> prod(A, dims=1)
1×2 Matrix{Int64}:
 3  8

julia> prod(A, dims=2)
2×1 Matrix{Int64}:
  2
 12

prod(f, A::AbstractArray; dims)

与えられた次元にわたって配列の各要素に対して関数 f を呼び出した結果を掛け算します。

例

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> prod(abs2, A, dims=1)
1×2 Matrix{Int64}:
 9  64

julia> prod(abs2, A, dims=2)
2×1 Matrix{Int64}:
   4
 144

prod!(r, A)

Aの要素をrの単一次元にわたって乗算し、結果をrに書き込みます。

例

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> prod!([1; 1], A)
2-element Vector{Int64}:
  2
 12

julia> prod!([1 1], A)
1×2 Matrix{Int64}:
 3  8

any(itr) -> Bool

ブールコレクションの要素の中に true があるかどうかをテストし、itr の中で最初に true の値が見つかった時点で true を返します（ショートサーキット）。false でショートサーキットするには、all を使用してください。

入力に missing 値が含まれている場合、すべての非欠損値が false である場合（または同等に、入力に true 値が含まれていない場合）には missing を返します。これは 三値論理 に従います。

関連項目: all, count, sum, |, , ||.

例

julia> a = [true,false,false,true]
4-element Vector{Bool}:
 1
 0
 0
 1

julia> any(a)
true

julia> any((println(i); v) for (i, v) in enumerate(a))
1
true

julia> any([missing, true])
true

julia> any([false, missing])
missing

any(p, itr) -> Bool

述語 p が itr の任意の要素に対して true を返すかどうかを判定し、p が true を返す itr の最初のアイテムに出会った時点で true を返します（ショートサーキット）。false に対してショートサーキットを行うには、all を使用してください。

入力に missing 値が含まれている場合、すべての非欠損値が false である場合（または同等に、入力に true 値が含まれていない場合）には missing を返します。これは 三値論理 に従います。

例

julia> any(i->(4<=i<=6), [3,5,7])
true

julia> any(i -> (println(i); i > 3), 1:10)
1
2
3
4
true

julia> any(i -> i > 0, [1, missing])
true

julia> any(i -> i > 0, [-1, missing])
missing

julia> any(i -> i > 0, [-1, 0])
false

any!(r, A)

Aの中の任意の値がrの単一次元に沿ってtrueであるかどうかをテストし、結果をrに書き込みます。

例

julia> A = [true false; true false]
2×2 Matrix{Bool}:
 1  0
 1  0

julia> any!([1; 1], A)
2-element Vector{Int64}:
 1
 1

julia> any!([1 1], A)
1×2 Matrix{Int64}:
 1  0

all(itr) -> Bool

ブールコレクションのすべての要素が true であるかどうかをテストし、itr で最初の false 値が見つかった時点で false を返します（ショートサーキット）。true でショートサーキットするには、any を使用してください。

入力に missing 値が含まれている場合、すべての非欠損値が true である場合（または同等に、入力に false 値が含まれていない場合）には missing を返します。これは 三値論理 に従います。

関連項目: all!, any, count, &, , &&, allunique.

例

julia> a = [true,false,false,true]
4-element Vector{Bool}:
 1
 0
 0
 1

julia> all(a)
false

julia> all((println(i); v) for (i, v) in enumerate(a))
1
2
false

julia> all([missing, false])
false

julia> all([true, missing])
missing

all(p, itr) -> Bool

述語 p が itr のすべての要素に対して true を返すかどうかを判定し、p が false を返す最初のアイテムが itr で見つかった時点で false を返します（ショートサーキット）。true でショートサーキットするには、any を使用してください。

入力に missing 値が含まれている場合、すべての非欠損値が true である場合（または同等に、入力に false 値が含まれていない場合）には missing を返します。これは 三値論理 に従います。

例

julia> all(i->(4<=i<=6), [4,5,6])
true

julia> all(i -> (println(i); i < 3), 1:10)
1
2
3
false

julia> all(i -> i > 0, [1, missing])
missing

julia> all(i -> i > 0, [-1, missing])
false

julia> all(i -> i > 0, [1, 2])
true

all!(r, A)

Aの中のすべての値がrの単一次元に沿ってtrueであるかどうかをテストし、結果をrに書き込みます。

例

julia> A = [true false; true false]
2×2 Matrix{Bool}:
 1  0
 1  0

julia> all!([1; 1], A)
2-element Vector{Int64}:
 0
 0

julia> all!([1 1], A)
1×2 Matrix{Int64}:
 1  0

count([f=identity,] itr; init=0) -> Integer

f が true を返す itr の要素の数をカウントします。f が省略された場合、itr の true 要素の数をカウントします（これはブール値のコレクションである必要があります）。init はカウントを開始する値を指定するオプションであり、出力の型も決定します。

参照: any, sum.

例

julia> count(i->(4<=i<=6), [2,3,4,5,6])
3

julia> count([true, false, true, true])
3

julia> count(>(3), 1:7, init=0x03)
0x07

count(
    pattern::Union{AbstractChar,AbstractString,AbstractPattern},
    string::AbstractString;
    overlap::Bool = false,
)

patternがstring内で一致する回数を返します。これはlength(findall(pattern, string))を呼び出すのと同等ですが、より効率的です。

overlap=trueの場合、一致するシーケンスは元の文字列内でインデックスが重なることが許可されます。そうでない場合、重なることのない文字範囲からでなければなりません。

例

julia> count('a', "JuliaLang")
2

julia> count(r"a(.)a", "cabacabac", overlap=true)
3

julia> count(r"a(.)a", "cabacabac")
2

count([f=identity,] A::AbstractArray; dims=:)

Aの要素のうち、fがtrueを返すものの数を指定された次元にわたってカウントします。

例

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> count(<=(2), A, dims=1)
1×2 Matrix{Int64}:
 1  1

julia> count(<=(2), A, dims=2)
2×1 Matrix{Int64}:
 2
 0

foreach(f, c...) -> Nothing

イテラブル c の各要素に対して関数 f を呼び出します。複数のイテラブル引数がある場合、f は要素ごとに呼び出され、いずれかのイテレータが終了するとイテレーションは停止します。

f の結果が必要ない場合は、foreach(println, array) のように map の代わりに foreach を使用するべきです。

例

julia> tri = 1:3:7; res = Int[];

julia> foreach(x -> push!(res, x^2), tri)

julia> res
3-element Vector{Int64}:
  1
 16
 49

julia> foreach((x, y) -> println(x, " with ", y), tri, 'a':'z')
1 with a
4 with b
7 with c

map(f, c...) -> collection

コレクション c を変換し、各要素に f を適用します。複数のコレクション引数がある場合、要素ごとに f を適用し、いずれかが尽きた時点で停止します。

他にも map!, foreach, mapreduce, mapslices, zip, Iterators.map を参照してください。

例

julia> map(x -> x * 2, [1, 2, 3])
3-element Vector{Int64}:
 2
 4
 6

julia> map(+, [1, 2, 3], [10, 20, 30, 400, 5000])
3-element Vector{Int64}:
 11
 22
 33

map(f, A::AbstractArray...) -> N-array

同じ ndims を持つ多次元配列に作用する場合、それらはすべて同じ axes を持たなければならず、答えも同様になります。

サイズが不一致のものを許可する broadcast も参照してください。

例

julia> map(//, [1 2; 3 4], [4 3; 2 1])
2×2 Matrix{Rational{Int64}}:
 1//4  2//3
 3//2  4//1

julia> map(+, [1 2; 3 4], zeros(2,1))
ERROR: DimensionMismatch

julia> map(+, [1 2; 3 4], [1,10,100,1000], zeros(3,1))  # 3番目が尽きるまで反復
3-element Vector{Float64}:
   2.0
  13.0
 102.0

map!(function, destination, collection...)

mapと同様ですが、新しいコレクションではなくdestinationに結果を格納します。destinationは最小のコレクションと同じ大きさ以上でなければなりません。

参照: map, foreach, zip, copyto!.

例

julia> a = zeros(3);

julia> map!(x -> x * 2, a, [1, 2, 3]);

julia> a
3-element Vector{Float64}:
 2.0
 4.0
 6.0

julia> map!(+, zeros(Int, 5), 100:999, 1:3)
5-element Vector{Int64}:
 101
 103
 105
   0
   0

map!(f, values(dict::AbstractDict))

dictを修正し、各値をvalからf(val)に変換します。dictの型は変更できないことに注意してください：f(val)がdictの値の型のインスタンスでない場合、可能であれば値の型に変換され、それ以外の場合はエラーが発生します。

例

julia> d = Dict(:a => 1, :b => 2)
Dict{Symbol, Int64} with 2 entries:
  :a => 1
  :b => 2

julia> map!(v -> v-1, values(d))
ValueIterator for a Dict{Symbol, Int64} with 2 entries. Values:
  0
  1

mapreduce(f, op, itrs...; [init])

関数 f を itrs の各要素に適用し、その後、結果を二項関数 op を使用して縮約します。提供されている場合、init は空のコレクションに対して返される op の中立要素でなければなりません。init が非空のコレクションに使用されるかどうかは不明です。一般的に、空のコレクションで作業するには init を提供する必要があります。

mapreduce は、reduce(op, map(f, itr); init=init) を呼び出すのと機能的に同等ですが、中間コレクションを作成する必要がないため、一般的に実行速度が速くなります。reduce および map のドキュメントを参照してください。

例

julia> mapreduce(x->x^2, +, [1:3;]) # == 1 + 4 + 9
14

縮約の結合性は実装に依存します。さらに、一部の実装では、itr に複数回現れる要素に対して f の戻り値を再利用する場合があります。すべての値に対して f を呼び出し、左または右の結合性を保証するには、mapfoldl または mapfoldr を使用してください。

mapfoldl(f, op, itr; [init])

mapreduceと同様ですが、foldlのように左結合性が保証されています。提供された場合、キーワード引数initは正確に1回使用されます。一般的に、空のコレクションで作業するにはinitを提供する必要があります。

mapfoldr(f, op, itr; [init])

mapreduceと同様ですが、foldrのように右結合性が保証されています。提供された場合、キーワード引数initは正確に1回使用されます。一般的に、空のコレクションで作業するにはinitを提供する必要があります。

first(coll)

イテラブルコレクションの最初の要素を取得します。空であってもAbstractRangeの開始点を返します。

関連情報: only, firstindex, last.

例

julia> first(2:2:10)
2

julia> first([1; 2; 3; 4])
1

first(itr, n::Integer)

イテラブルコレクション itr の最初の n 要素を取得します。itr が十分に長くない場合は、より少ない要素が返されます。

関連情報: startswith, Iterators.take.

例

julia> first(["foo", "bar", "qux"], 2)
2-element Vector{String}:
 "foo"
 "bar"

julia> first(1:6, 10)
1:6

julia> first(Bool[], 1)
Bool[]

first(s::AbstractString, n::Integer)

文字列sの最初のn文字からなる文字列を取得します。

例

julia> first("∀ϵ≠0: ϵ²>0", 0)
""

julia> first("∀ϵ≠0: ϵ²>0", 1)
"∀"

julia> first("∀ϵ≠0: ϵ²>0", 3)
"∀ϵ≠"

last(coll)

順序付きコレクションの最後の要素を取得します。これはO(1)時間で計算できる場合に限ります。これは、lastindexを呼び出して最後のインデックスを取得することで実現されます。空であっても、AbstractRangeの終点を返します。

他にfirst、endswithも参照してください。

例

julia> last(1:2:10)
9

julia> last([1; 2; 3; 4])
4

last(itr, n::Integer)

イテラブルコレクション itr の最後の n 要素を取得します。itr が十分に長くない場合は、より少ない要素が返されます。

例

julia> last(["foo", "bar", "qux"], 2)
2-element Vector{String}:
 "bar"
 "qux"

julia> last(1:6, 10)
1:6

julia> last(Float64[], 1)
Float64[]

last(s::AbstractString, n::Integer)

文字列 s の最後の n 文字からなる文字列を取得します。

例

julia> last("∀ϵ≠0: ϵ²>0", 0)
""

julia> last("∀ϵ≠0: ϵ²>0", 1)
"0"

julia> last("∀ϵ≠0: ϵ²>0", 3)
"²>0"

front(x::Tuple)::Tuple

xの最後の要素を除いたすべての要素からなるTupleを返します。

関連情報: first, tail.

例

julia> Base.front((1,2,3))
(1, 2)

julia> Base.front(())
ERROR: ArgumentError: 空のタプルに対してfrontを呼び出すことはできません。

tail(x::Tuple)::Tuple

xの最初のコンポーネントを除くすべての要素からなるTupleを返します。

参照: front, rest, first, Iterators.peel.

例

julia> Base.tail((1,2,3))
(2, 3)

julia> Base.tail(())
ERROR: ArgumentError: 空のタプルに対してtailを呼び出すことはできません。

step(r)

AbstractRange オブジェクトのステップサイズを取得します。

例

julia> step(1:10)
1

julia> step(1:2:10)
2

julia> step(2.5:0.3:10.9)
0.3

julia> step(range(2.5, stop=10.9, length=85))
0.1

collect(collection)

コレクションまたはイテレータ内のすべてのアイテムの Array を返します。辞書の場合、key=>value Pair の Vector を返します。引数が配列のようであるか、HasShape 特性を持つイテレータである場合、結果は引数と同じ形状および次元数を持ちます。

comprehensions によって、generator expression を Array に変換するために使用されます。したがって、ジェネレータに対して、角括弧の表記法を使用することができ、collect を呼び出す代わりに使用できます。2番目の例を参照してください。

例

UnitRange{Int64} コレクションからアイテムを収集します：

julia> collect(1:3)
3-element Vector{Int64}:
 1
 2
 3

ジェネレータからアイテムを収集します（[x^2 for x in 1:3] と同じ出力）：

julia> collect(x^2 for x in 1:3)
3-element Vector{Int64}:
 1
 4
 9

collect(element_type, collection)

指定された要素型のすべてのアイテムを含む Array を、コレクションまたはイテラブルから返します。結果は collection と同じ形状と次元数を持ちます。

例

julia> collect(Float64, 1:2:5)
3-element Vector{Float64}:
 1.0
 3.0
 5.0

filter(f, a)

コレクション a のコピーを返し、f が false の要素を削除します。関数 f には1つの引数が渡されます。

参照: filter!, Iterators.filter.

例

julia> a = 1:10
1:10

julia> filter(isodd, a)
5-element Vector{Int64}:
 1
 3
 5
 7
 9

filter(f)

関数 f を使用して引数をフィルタリングする関数を作成します。これは、x -> filter(f, x) に相当する関数です。

返される関数は Base.Fix1{typeof(filter)} 型であり、特化したメソッドを実装するために使用できます。

例

julia> (1, 2, Inf, 4, NaN, 6) |> filter(isfinite)
(1, 2, 4, 6)

julia> map(filter(iseven), [1:3, 2:4, 3:5])
3-element Vector{Vector{Int64}}:
 [2]
 [2, 4]
 [4]

filter(f, d::AbstractDict)

f が false の要素を削除して d のコピーを返します。関数 f には key=>value ペアが渡されます。

例

julia> d = Dict(1=>"a", 2=>"b")
Dict{Int64, String} with 2 entries:
  2 => "b"
  1 => "a"

julia> filter(p->isodd(p.first), d)
Dict{Int64, String} with 1 entry:
  1 => "a"

filter(f, itr::SkipMissing{<:AbstractArray})

与えられた SkipMissing イテレータでラップされた配列に似たベクトルを返しますが、すべての欠損要素と f が false を返す要素は削除されます。

例

julia> x = [1 2; missing 4]
2×2 Matrix{Union{Missing, Int64}}:
 1         2
  missing  4

julia> filter(isodd, skipmissing(x))
1-element Vector{Int64}:
 1

filter!(f, a)

コレクション a を更新し、f が false の要素を削除します。関数 f には1つの引数が渡されます。

例

julia> filter!(isodd, Vector(1:10))
5-element Vector{Int64}:
 1
 3
 5
 7
 9

filter!(f, d::AbstractDict)

dを更新し、fがfalseである要素を削除します。関数fにはkey=>valueペアが渡されます。

例

julia> d = Dict(1=>"a", 2=>"b", 3=>"c")
Dict{Int64, String} with 3 entries:
  2 => "b"
  3 => "c"
  1 => "a"

julia> filter!(p->isodd(p.first), d)
Dict{Int64, String} with 2 entries:
  3 => "c"
  1 => "a"

replace(A, old_new::Pair...; [count::Integer])

コレクション A のコピーを返します。ここで、old_new の各ペア old=>new に対して、すべての old の出現が new に置き換えられます。等価性は isequal を使用して決定されます。count が指定されている場合、合計で最大 count 回の出現を置き換えます。

結果の要素型は、A の要素型とペアの new 値の型に基づいて昇格（promote_type を参照）を使用して選択されます。count が省略され、A の要素型が Union の場合、異なる型の値で置き換えられる単一型は結果の要素型に含まれません。たとえば、Union{T,Missing} は missing が置き換えられると T になります。

他にも replace!、splice!、delete!、insert! を参照してください。

例

julia> replace([1, 2, 1, 3], 1=>0, 2=>4, count=2)
4-element Vector{Int64}:
 0
 4
 1
 3

julia> replace([1, missing], missing=>0)
2-element Vector{Int64}:
 1
 0

replace(new::Union{Function, Type}, A; [count::Integer])

Aの各値xをnew(x)で置き換えたコピーを返します。countが指定されている場合、合計で最大countの値を置き換えます（置き換えはnew(x) !== xとして定義されます）。

例

julia> replace(x -> isodd(x) ? 2x : x, [1, 2, 3, 4])
4-element Vector{Int64}:
 2
 2
 6
 4

julia> replace(Dict(1=>2, 3=>4)) do kv
           first(kv) < 3 ? first(kv)=>3 : kv
       end
Dict{Int64, Int64} with 2 entries:
  3 => 4
  1 => 3

replace!(A, old_new::Pair...; [count::Integer])

各ペア old=>new に対して、コレクション A 内の old のすべての出現を new に置き換えます。等価性は isequal を使用して決定されます。count が指定されている場合、合計で最大 count 回の出現を置き換えます。詳細は replace を参照してください。

例

julia> replace!([1, 2, 1, 3], 1=>0, 2=>4, count=2)
4-element Vector{Int64}:
 0
 4
 1
 3

julia> replace!(Set([1, 2, 3]), 1=>0)
Set{Int64} with 3 elements:
  0
  2
  3

replace!(new::Union{Function, Type}, A; [count::Integer])

コレクション A の各要素 x を new(x) で置き換えます。count が指定されている場合、合計で最大 count の値を置き換えます（置き換えは new(x) !== x と定義されます）。

例

julia> replace!(x -> isodd(x) ? 2x : x, [1, 2, 3, 4])
4-element Vector{Int64}:
 2
 2
 6
 4

julia> replace!(Dict(1=>2, 3=>4)) do kv
           first(kv) < 3 ? first(kv)=>3 : kv
       end
Dict{Int64, Int64} with 2 entries:
  3 => 4
  1 => 3

julia> replace!(x->2x, Set([3, 6]))
Set{Int64} with 2 elements:
  6
  12

Base.rest(collection[, itr_state])

特定のイテレーション状態 itr_state から始めて collection の末尾を取得するための汎用関数。collection 自体が Tuple の場合は Tuple を返し、collection が AbstractArray の場合は AbstractVector のサブタイプを返し、collection が AbstractString の場合は AbstractString のサブタイプを返し、それ以外の場合は任意のイテレーターを返し、Iterators.rest(collection[, itr_state]) にフォールバックします。

ユーザー定義のコレクションタイプに対してオーバーロード可能で、最終位置での スラープによる代入 の動作をカスタマイズできます。例えば、a, b... = collection のように。

参照: first, Iterators.rest, Base.split_rest.

例

julia> a = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> first, state = iterate(a)
(1, 2)

julia> first, Base.rest(a, state)
(1, [3, 2, 4])

Base.split_rest(collection, n::Int[, itr_state]) -> (rest_but_n, last_n)

コレクションの尾を特定のイテレーション状態 itr_state から分割するための汎用関数。2つの新しいコレクションのタプルを返します。最初のコレクションには、最後の n 個の要素を除くすべての要素が含まれ、これが2番目のコレクションを構成します。

最初のコレクションの型は一般的に Base.rest の型に従いますが、フォールバックケースは遅延ではなく、ベクターに即座に収集されます。

ユーザー定義のコレクションタイプに対してオーバーロード可能で、非最終位置での スラープによる代入 の動作をカスタマイズできます。例えば、a, b..., c = collection のように。

関連情報: Base.rest.

例

julia> a = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> first, state = iterate(a)
(1, 2)

julia> first, Base.split_rest(a, 1, state)
(1, ([3, 2], [4]))

getindex(collection, key...)

指定されたキーまたはインデックス内のコレクションに格納されている値を取得します。構文 a[i,j,...] はコンパイラによって getindex(a, i, j, ...) に変換されます。

関連情報としては get, keys, eachindex があります。

例

julia> A = Dict("a" => 1, "b" => 2)
Dict{String, Int64} with 2 entries:
  "b" => 2
  "a" => 1

julia> getindex(A, "a")
1

setindex!(collection, value, key...)

指定された値をコレクション内の指定されたキーまたはインデックスに格納します。構文 a[i,j,...] = x はコンパイラによって (setindex!(a, x, i, j, ...); x) に変換されます。

例

julia> a = Dict("a"=>1)
Dict{String, Int64} with 1 entry:
  "a" => 1

julia> setindex!(a, 2, "b")
Dict{String, Int64} with 2 entries:
  "b" => 2
  "a" => 1

firstindex(collection) -> 整数
firstindex(collection, d) -> 整数

collectionの最初のインデックスを返します。dが指定されている場合、次元dに沿ったcollectionの最初のインデックスを返します。

構文A[begin]およびA[1, begin]はそれぞれA[firstindex(A)]およびA[1, firstindex(A, 2)]に変換されます。

参照: first, axes, lastindex, nextind.

例

julia> firstindex([1,2,4])
1

julia> firstindex(rand(3,4,5), 2)
1

lastindex(collection) -> 整数
lastindex(collection, d) -> 整数

collectionの最後のインデックスを返します。dが指定されている場合、次元dに沿ったcollectionの最後のインデックスを返します。

構文A[end]およびA[end, end]はそれぞれA[lastindex(A)]およびA[lastindex(A, 1), lastindex(A, 2)]に変換されます。

関連項目: axes, firstindex, eachindex, prevind。

例

julia> lastindex([1,2,4])
3

julia> lastindex(rand(3,4,5), 2)
4

AbstractDict{K, V}

キーの型が K で値の型が V の辞書のような型のスーパークラスです。 Dict、IdDict およびその他の型はこのサブタイプです。 AbstractDict{K, V} は Pair{K, V} のイテレータであるべきです。

Dict([itr])

Dict{K,V}() は、型 K のキーと型 V の値を持つハッシュテーブルを構築します。キーは isequal で比較され、hash でハッシュ化されます。

単一のイテラブル引数を与えると、引数によって生成された 2-タプル (key,value) からキーと値のペアを取る Dict が構築されます。

例

julia> Dict([("A", 1), ("B", 2)])
Dict{String, Int64} with 2 entries:
  "B" => 2
  "A" => 1

また、ペア引数のシーケンスを渡すこともできます。

julia> Dict("A"=>1, "B"=>2)
Dict{String, Int64} with 2 entries:
  "B" => 2
  "A" => 1

IdDict([itr])

IdDict{K,V}() は、objectid をハッシュとして、=== を等価性として使用し、キーの型 K と値の型 V を持つハッシュテーブルを構築します。詳細については Dict を参照し、これのセットバージョンについては IdSet を参照してください。

以下の例では、Dict のキーはすべて isequal であり、したがって同じようにハッシュされ、上書きされます。IdDict はオブジェクトIDでハッシュされるため、3つの異なるキーを保持します。

例

julia> Dict(true => "yes", 1 => "no", 1.0 => "maybe")
Dict{Real, String} with 1 entry:
  1.0 => "maybe"

julia> IdDict(true => "yes", 1 => "no", 1.0 => "maybe")
IdDict{Any, String} with 3 entries:
  true => "yes"
  1.0  => "maybe"
  1    => "no"

WeakKeyDict([itr])

WeakKeyDict() は、キーがオブジェクトへの弱い参照であるハッシュテーブルを構築します。これにより、ハッシュテーブル内で参照されていても、オブジェクトがガベージコレクトされる可能性があります。

さらなるヘルプについては、Dictを参照してください。なお、Dictとは異なり、WeakKeyDictは挿入時にキーを変換しません。これは、キーオブジェクトが挿入前にどこにも参照されていなかったことを意味します。

また、WeakRefも参照してください。

ImmutableDict

ImmutableDictは、不変のリンクリストとして実装された辞書であり、多くの個別の挿入を通じて構築される小さな辞書に最適です。値を削除することはできませんが、同じキーで新しい値を挿入することで部分的に上書きしたり隠したりすることができます。

ImmutableDict(KV::Pair)

key => valueペアのためにImmutableDictに新しいエントリを作成します。

• (key => value) in dictを使用して、この特定の組み合わせがプロパティセットに含まれているかどうかを確認します。
• get(dict, key, default)を使用して、特定のキーの最新の値を取得します。

PersistentDict

PersistentDict はハッシュ配列マップトライとして実装された辞書で、永続性が必要な状況に最適です。各操作は前の辞書とは別の新しい辞書を返しますが、基盤となる実装はスペース効率が良く、複数の別々の辞書間でストレージを共有することがあります。

PersistentDict(KV::Pair)

例

julia> dict = Base.PersistentDict(:a=>1)
Base.PersistentDict{Symbol, Int64} with 1 entry:
  :a => 1

julia> dict2 = Base.delete(dict, :a)
Base.PersistentDict{Symbol, Int64}()

julia> dict3 = Base.PersistentDict(dict, :a=>2)
Base.PersistentDict{Symbol, Int64} with 1 entry:
  :a => 2

haskey(collection, key) -> Bool

指定された key に対してコレクションにマッピングがあるかどうかを判断します。

例

julia> D = Dict('a'=>2, 'b'=>3)
Dict{Char, Int64} with 2 entries:
  'a' => 2
  'b' => 3

julia> haskey(D, 'a')
true

julia> haskey(D, 'c')
false

get(collection, key, default)

指定されたキーに対して保存されている値を返します。キーに対するマッピングが存在しない場合は、指定されたデフォルト値を返します。

例

julia> d = Dict("a"=>1, "b"=>2);

julia> get(d, "a", 3)
1

julia> get(d, "c", 3)
3

get(f::Union{Function, Type}, collection, key)

指定されたキーに対して保存されている値を返します。キーに対するマッピングが存在しない場合は、f()を返します。デフォルト値を辞書に保存するには、get!を使用してください。

これはdoブロック構文を使用して呼び出すことを意図しています。

get(dict, key) do
    # ここでデフォルト値を計算
    time()
end

get!(collection, key, default)

指定されたキーに対して保存されている値を返します。キーに対するマッピングが存在しない場合は、key => defaultを保存し、defaultを返します。

例

julia> d = Dict("a"=>1, "b"=>2, "c"=>3);

julia> get!(d, "a", 5)
1

julia> get!(d, "d", 4)
4

julia> d
Dict{String, Int64} with 4 entries:
  "c" => 3
  "b" => 2
  "a" => 1
  "d" => 4

get!(f::Union{Function, Type}, collection, key)

指定されたキーに対して保存されている値を返します。キーに対するマッピングが存在しない場合は、key => f()を保存し、f()を返します。

これはdoブロック構文を使用して呼び出すことを意図しています。

例

julia> squares = Dict{Int, Int}();

julia> function get_square!(d, i)
           get!(d, i) do
               i^2
           end
       end
get_square! (generic function with 1 method)

julia> get_square!(squares, 2)
4

julia> squares
Dict{Int64, Int64} with 1 entry:
  2 => 4

getkey(collection, key, default)

引数 key に一致するキーが collection に存在する場合はそのキーを返し、存在しない場合は default を返します。

例

julia> D = Dict('a'=>2, 'b'=>3)
Dict{Char, Int64} with 2 entries:
  'a' => 2
  'b' => 3

julia> getkey(D, 'a', 1)
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

julia> getkey(D, 'd', 'a')
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

delete!(collection, key)

指定されたキーに対するマッピングをコレクションから削除し、コレクションを返します。

例

julia> d = Dict("a"=>1, "b"=>2)
Dict{String, Int64} with 2 entries:
  "b" => 2
  "a" => 1

julia> delete!(d, "b")
Dict{String, Int64} with 1 entry:
  "a" => 1

julia> delete!(d, "b") # dは変更されません
Dict{String, Int64} with 1 entry:
  "a" => 1

pop!(collection, key[, default])

collection に key が存在する場合は、そのマッピングを削除して返します。存在しない場合は default を返すか、default が指定されていない場合はエラーをスローします。

例

julia> d = Dict("a"=>1, "b"=>2, "c"=>3);

julia> pop!(d, "a")
1

julia> pop!(d, "d")
ERROR: KeyError: key "d" not found
Stacktrace:
[...]

julia> pop!(d, "e", 4)
4

keys(iterator)

キーと値を持つイテレータまたはコレクション（例：配列や辞書）に対して、キーのイテレータを返します。

values(iterator)

キーと値を持つイテレータまたはコレクションに対して、値のイテレータを返します。この関数はデフォルトで引数をそのまま返します。一般的なイテレータの要素は通常「値」と見なされるためです。

例

julia> d = Dict("a"=>1, "b"=>2);

julia> values(d)
ValueIterator for a Dict{String, Int64} with 2 entries. Values:
  2
  1

julia> values([2])
1-element Vector{Int64}:
 2

values(a::AbstractDict)

コレクション内のすべての値に対するイテレータを返します。 collect(values(a)) は値の配列を返します。値が内部的にハッシュテーブルに格納されている場合、Dict のように、返される順序は異なる場合があります。しかし、keys(a)、values(a) および pairs(a) はすべて a をイテレートし、同じ順序で要素を返します。

例

julia> D = Dict('a'=>2, 'b'=>3)
Dict{Char, Int64} with 2 entries:
  'a' => 2
  'b' => 3

julia> collect(values(D))
2-element Vector{Int64}:
 2
 3

pairs(IndexLinear(), A)
pairs(IndexCartesian(), A)
pairs(IndexStyle(A), A)

配列 A の各要素にアクセスするイテレータで、i => x を返します。ここで i は要素のインデックスで、x = A[i] です。pairs(A) と同じですが、インデックスのスタイルを選択できます。また、enumerate(A) に似ていますが、i は A の有効なインデックスであり、enumerate は常に1からカウントします。

IndexLinear() を指定すると、i は整数になります。IndexCartesian() を指定すると、i は Base.CartesianIndex になります。IndexStyle(A) を指定すると、配列 A のネイティブインデックススタイルとして定義されているものが選択されます。

基になる配列の境界を変更すると、このイテレータは無効になります。

例

julia> A = ["a" "d"; "b" "e"; "c" "f"];

julia> for (index, value) in pairs(IndexStyle(A), A)
           println("$index $value")
       end
1 a
2 b
3 c
4 d
5 e
6 f

julia> S = view(A, 1:2, :);

julia> for (index, value) in pairs(IndexStyle(S), S)
           println("$index $value")
       end
CartesianIndex(1, 1) a
CartesianIndex(2, 1) b
CartesianIndex(1, 2) d
CartesianIndex(2, 2) e

さらに IndexStyle、axes を参照してください。

pairs(collection)

任意のコレクションに対して key => value ペアのイテレータを返します。これは、キーのセットを値のセットにマッピングするコレクションを含みます。配列の場合、キーは配列のインデックスです。エントリが内部的にハッシュテーブルに格納されている場合（Dict の場合など）、返される順序は異なる場合があります。しかし、keys(a)、values(a)、および pairs(a) はすべて a を反復処理し、同じ順序で要素を返します。

例

julia> a = Dict(zip(["a", "b", "c"], [1, 2, 3]))
Dict{String, Int64} with 3 entries:
  "c" => 3
  "b" => 2
  "a" => 1

julia> pairs(a)
Dict{String, Int64} with 3 entries:
  "c" => 3
  "b" => 2
  "a" => 1

julia> foreach(println, pairs(["a", "b", "c"]))
1 => "a"
2 => "b"
3 => "c"

julia> (;a=1, b=2, c=3) |> pairs |> collect
3-element Vector{Pair{Symbol, Int64}}:
 :a => 1
 :b => 2
 :c => 3

julia> (;a=1, b=2, c=3) |> collect
3-element Vector{Int64}:
 1
 2
 3

merge(initial::Face, others::Face...)

initialフェイスとothersのプロパティをマージし、後のフェイスが優先されます。

merge(d::AbstractDict, others::AbstractDict...)

与えられたコレクションからマージされたコレクションを構築します。必要に応じて、結果のコレクションの型はマージされたコレクションの型に合わせて昇格されます。同じキーが別のコレクションに存在する場合、そのキーの値は最後にリストされたコレクションにある値になります。値が同じキーを持つ場合のカスタム処理については、mergewithを参照してください。

例

julia> a = Dict("foo" => 0.0, "bar" => 42.0)
Dict{String, Float64} with 2 entries:
  "bar" => 42.0
  "foo" => 0.0

julia> b = Dict("baz" => 17, "bar" => 4711)
Dict{String, Int64} with 2 entries:
  "bar" => 4711
  "baz" => 17

julia> merge(a, b)
Dict{String, Float64} with 3 entries:
  "bar" => 4711.0
  "baz" => 17.0
  "foo" => 0.0

julia> merge(b, a)
Dict{String, Float64} with 3 entries:
  "bar" => 42.0
  "baz" => 17.0
  "foo" => 0.0

merge(a::NamedTuple, bs::NamedTuple...)

2つ以上の既存の名前付きタプルを左結合的にマージして新しい名前付きタプルを構築します。マージは、名前付きタプルのペア間で左から右に進行し、最も左側と最も右側の名前付きタプルの両方に存在するフィールドの順序は、最も左側の名前付きタプルで見つかった位置と同じになります。ただし、値は、そのフィールドを含む最も右側の名前付きタプルの一致するフィールドから取得されます。ペアの最も右側の名前付きタプルにのみ存在するフィールドは、最後に追加されます。シグネチャ merge(a::NamedTuple) を持つ単一の名前付きタプルのみが供給された場合のフォールバックが実装されています。

例

julia> merge((a=1, b=2, c=3), (b=4, d=5))
(a = 1, b = 4, c = 3, d = 5)

julia> merge((a=1, b=2), (b=3, c=(d=1,)), (c=(d=2,),))
(a = 1, b = 3, c = (d = 2,))

merge(a::NamedTuple, iterable)

キーと値のペアのイテラブルを名前付きタプルとして解釈し、マージを実行します。

julia> merge((a=1, b=2, c=3), [:b=>4, :d=>5])
(a = 1, b = 4, c = 3, d = 5)

mergewith(combine, d::AbstractDict, others::AbstractDict...)
mergewith(combine)
merge(combine, d::AbstractDict, others::AbstractDict...)

与えられたコレクションからマージされたコレクションを構築します。必要に応じて、結果のコレクションの型はマージされたコレクションの型に合わせて昇格されます。同じキーを持つ値は、コンバイナ関数を使用して結合されます。カリー化された形式 mergewith(combine) は、関数 (args...) -> mergewith(combine, args...) を返します。

メソッド merge(combine::Union{Function,Type}, args...) は mergewith(combine, args...) のエイリアスとして、後方互換性のためにまだ利用可能です。

例

julia> a = Dict("foo" => 0.0, "bar" => 42.0)
Dict{String, Float64} with 2 entries:
  "bar" => 42.0
  "foo" => 0.0

julia> b = Dict("baz" => 17, "bar" => 4711)
Dict{String, Int64} with 2 entries:
  "bar" => 4711
  "baz" => 17

julia> mergewith(+, a, b)
Dict{String, Float64} with 3 entries:
  "bar" => 4753.0
  "baz" => 17.0
  "foo" => 0.0

julia> ans == mergewith(+)(a, b)
true

merge!(d::AbstractDict, others::AbstractDict...)

他のコレクションからのペアでコレクションを更新します。詳細は merge を参照してください。

例

julia> d1 = Dict(1 => 2, 3 => 4);

julia> d2 = Dict(1 => 4, 4 => 5);

julia> merge!(d1, d2);

julia> d1
Dict{Int64, Int64} with 3 entries:
  4 => 5
  3 => 4
  1 => 4

mergewith!(combine, d::AbstractDict, others::AbstractDict...) -> d
mergewith!(combine)
merge!(combine, d::AbstractDict, others::AbstractDict...) -> d

他のコレクションからのペアでコレクションを更新します。同じキーを持つ値は、コンバイナ関数を使用して結合されます。カリー化された形式 mergewith!(combine) は、関数 (args...) -> mergewith!(combine, args...) を返します。

メソッド merge!(combine::Union{Function,Type}, args...) は mergewith!(combine, args...) のエイリアスとして、後方互換性のためにまだ利用可能です。

例

julia> d1 = Dict(1 => 2, 3 => 4);

julia> d2 = Dict(1 => 4, 4 => 5);

julia> mergewith!(+, d1, d2);

julia> d1
Dict{Int64, Int64} with 3 entries:
  4 => 5
  3 => 4
  1 => 6

julia> mergewith!(-, d1, d1);

julia> d1
Dict{Int64, Int64} with 3 entries:
  4 => 0
  3 => 0
  1 => 0

julia> foldl(mergewith!(+), [d1, d2]; init=Dict{Int64, Int64}())
Dict{Int64, Int64} with 3 entries:
  4 => 5
  3 => 0
  1 => 4

sizehint!(s, n; first::Bool=false, shrink::Bool=true) -> s

コレクション s が少なくとも n 要素の容量を予約することを提案します。つまり、s に多くの値をプッシュする必要があると予想される場合、最初に一度だけ行うことで、段階的な再割り当てのコストを回避できます。これにより、パフォーマンスが向上する可能性があります。

first が true の場合、コレクションの開始前に追加のスペースが予約されます。この方法により、pushfirst!（push! の代わりに）への後続の呼び出しが速くなる可能性があります。このキーワードを指定すると、コレクションが順序付けられていない場合や、pushfirst! がこのコレクションでサポートされていない場合にエラーが発生することがあります。

shrink=true（デフォルト）である場合、コレクションの現在の容量が n より大きい場合、コレクションの容量が減少する可能性があります。

詳細は resize! を参照してください。

パフォーマンスモデルに関するノート

sizehint! をサポートする型について、

1. push! および append! メソッドは、一般的に（ただし必ずしも必要ではない）追加のストレージを事前に割り当てることがあります。Base に実装された型の場合、通常はそうであり、一般的な使用ケースに最適化されたヒューリスティックを使用します。
2. sizehint! はこの事前割り当てを制御することがあります。再度言いますが、通常は Base の型に対してこれを行います。
3. empty! は、この種の事前割り当てをサポートする型にとってほぼコストがかからず（O(1)）、非常に効率的です。

keytype(T::Type{<:AbstractArray})
keytype(A::AbstractArray)

配列のキータイプを返します。これは keys(...) の結果の eltype と等しく、主に辞書インターフェースとの互換性のために提供されています。

例

julia> keytype([1, 2, 3]) == Int
true

julia> keytype([1 2; 3 4])
CartesianIndex{2}

keytype(type)

辞書型のキータイプを取得します。eltypeと似たように動作します。

例

julia> keytype(Dict(Int32(1) => "foo"))
Int32

valtype(T::Type{<:AbstractArray})
valtype(A::AbstractArray)

配列の値の型を返します。これはeltypeと同じであり、主に辞書インターフェースとの互換性のために提供されています。

例

julia> valtype(["one", "two", "three"])
String

valtype(type)

辞書型の値の型を取得します。eltypeと似た動作をします。

例

julia> valtype(Dict(Int32(1) => "foo"))
String

AbstractSet{T}

型 T の要素を持つ集合のような型のスーパタイプです。 Set、BitSet などの他の型はこのサブタイプです。

Set{T} <: AbstractSet{T}

Setは、迅速なメンバーシップテストを提供する可変コンテナです。

Setは、in、union、intersectなどの集合演算の効率的な実装を持っています。Set内の要素は、要素のisequalの定義によって決定されるユニークなものです。Set内の要素の順序は実装の詳細であり、信頼することはできません。

参照: AbstractSet, BitSet, Dict, push!, empty!, union!, in, isequal

例

julia> s = Set("aaBca")
Set{Char} with 3 elements:
  'a'
  'c'
  'B'

julia> push!(s, 'b')
Set{Char} with 4 elements:
  'a'
  'b'
  'B'
  'c'

julia> s = Set([NaN, 0.0, 1.0, 2.0]);

julia> -0.0 in s # isequal(0.0, -0.0) is false
false

julia> NaN in s # isequal(NaN, NaN) is true
true

BitSet([itr])

与えられたイテラブルオブジェクトによって生成された Int のソートされたセットを構築するか、空のセットを構築します。ビット文字列として実装されているため、密な整数セット用に設計されています。セットがスパースである場合（例えば、非常に大きな整数をいくつか保持する場合）、代わりに Set を使用してください。

IdSet{T}([itr])
IdSet()

IdSet{T}() は、型 T の値に対して === を等価性として使用してセット（Setを参照）を構築します。

以下の例では、値はすべて isequal であるため、通常の Set では上書きされます。IdSet は === で比較するため、3つの異なる値を保持します。

例

julia> Set(Any[true, 1, 1.0])
Set{Any} with 1 element:
  1.0

julia> IdSet{Any}(Any[true, 1, 1.0])
IdSet{Any} with 3 elements:
  1.0
  1
  true

union(s, itrs...)
∪(s, itrs...)

すべての引数からの異なる要素を含むオブジェクトを構築します。

最初の引数は、返されるコンテナの種類を制御します。これが配列である場合、要素が最初に現れる順序を維持します。

Unicode ∪ は、Julia REPL で \cup と書いてタブを押すことで入力できます。また、多くのエディタでも同様です。これは中置演算子であり、s ∪ itr のように使用できます。

関連項目としては unique、intersect、isdisjoint、vcat、Iterators.flatten があります。

例

julia> union([1, 2], [3])
3-element Vector{Int64}:
 1
 2
 3

julia> union([4 2 3 4 4], 1:3, 3.0)
4-element Vector{Float64}:
 4.0
 2.0
 3.0
 1.0

julia> (0, 0.0) ∪ (-0.0, NaN)
3-element Vector{Real}:
   0
  -0.0
 NaN

julia> union(Set([1, 2]), 2:3)
Set{Int64} with 3 elements:
  2
  3
  1

union!(s::Union{AbstractSet,AbstractVector}, itrs...)

渡された集合のunionを構築し、結果でsを上書きします。配列の順序を維持します。

例

julia> a = Set([3, 4, 5]);

julia> union!(a, 1:2:7);

julia> a
Set{Int64} with 5 elements:
  5
  4
  7
  3
  1

intersect(s, itrs...)
∩(s, itrs...)

すべての引数に出現する要素を含む集合を構築します。

最初の引数は、返されるコンテナの種類を制御します。これが配列である場合、要素が最初に出現する順序を維持します。

Unicode ∩ は、Julia REPL で \cap と書いてタブを押すことで入力できます。また、多くのエディタでも同様です。これは中置演算子であり、s ∩ itr のように使用できます。

他にも setdiff、isdisjoint、issubset、issetequal を参照してください。

例

julia> intersect([1, 2, 3], [3, 4, 5])
1-element Vector{Int64}:
 3

julia> intersect([1, 4, 4, 5, 6], [6, 4, 6, 7, 8])
2-element Vector{Int64}:
 4
 6

julia> intersect(1:16, 7:99)
7:16

julia> (0, 0.0) ∩ (-0.0, 0)
1-element Vector{Real}:
 0

julia> intersect(Set([1, 2]), BitSet([2, 3]), 1.0:10.0)
Set{Float64} with 1 element:
  2.0

setdiff(s, itrs...)

sの要素のうち、itrsのいずれかに含まれない要素の集合を構築します。配列の順序を維持します。

setdiff!、union、およびintersectも参照してください。

例

julia> setdiff([1,2,3], [3,4,5])
2-element Vector{Int64}:
 1
 2

setdiff!(s, itrs...)

セット s から、各イテラブル itrs の各要素を（インプレースで）削除します。配列の順序を維持します。

例

julia> a = Set([1, 3, 4, 5]);

julia> setdiff!(a, 1:2:6);

julia> a
Set{Int64} with 1 element:
  4

symdiff(s, itrs...)

渡された集合の要素の対称差を構築します。sがAbstractSetでない場合、順序は保持されます。

関連項目としては symdiff!、setdiff、union および intersect があります。

例

julia> symdiff([1,2,3], [3,4,5], [4,5,6])
3-element Vector{Int64}:
 1
 2
 6

julia> symdiff([1,2,1], [2, 1, 2])
Int64[]

symdiff!(s::Union{AbstractSet,AbstractVector}, itrs...)

渡された集合の対称差を構築し、結果で s を上書きします。s が配列の場合、順序は維持されます。この場合、要素の重複が重要です。

intersect!(s::Union{AbstractSet,AbstractVector}, itrs...)

渡されたすべての集合を交差させ、結果でsを上書きします。配列の順序を維持します。

issubset(a, b) -> Bool
⊆(a, b) -> Bool
⊇(b, a) -> Bool

a のすべての要素が b にも含まれているかどうかを判断します。 in を使用します。

他に ⊊、⊈、∩、∪、contains も参照してください。

例

julia> issubset([1, 2], [1, 2, 3])
true

julia> [1, 2, 3] ⊆ [1, 2]
false

julia> [1, 2, 3] ⊇ [1, 2]
true

in!(x, s::AbstractSet) -> Bool

sにxが含まれている場合はtrueを返します。含まれていない場合は、xをsに追加してfalseを返します。これはin(x, s) ? true : (push!(s, x); false)と同等ですが、より効率的な実装が可能です。

関連情報: in, push!, Set

例

julia> s = Set{Any}([1, 2, 3]); in!(4, s)
false

julia> length(s)
4

julia> in!(0x04, s)
true

julia> s
Set{Any} with 4 elements:
  4
  2
  3
  1

⊈(a, b) -> Bool
⊉(b, a) -> Bool

⊆ と ⊇ の否定、すなわち a が b の部分集合でないことをチェックします。

詳細は issubset (⊆)、⊊ を参照してください。

例

julia> (1, 2) ⊈ (2, 3)
true

julia> (1, 2) ⊈ (1, 2, 3)
false

⊊(a, b) -> Bool
⊋(b, a) -> Bool

aがbの部分集合であるが、等しくないかどうかを判断します。

関連情報としては、issubset (⊆)、⊈があります。

例

julia> (1, 2) ⊊ (1, 2, 3)
true

julia> (1, 2) ⊊ (1, 2)
false

issetequal(a, b) -> Bool

a と b が同じ要素を持っているかどうかを判断します。a ⊆ b && b ⊆ a と同等ですが、可能な場合はより効率的です。

関連情報: isdisjoint, union.

例

julia> issetequal([1, 2], [1, 2, 3])
false

julia> issetequal([1, 2], [2, 1])
true

issetequal(x)

xをissetequalを使用して比較する関数を作成します。つまり、y -> issetequal(y, x)に相当する関数です。返される関数はBase.Fix2{typeof(issetequal)}型であり、特化したメソッドを実装するために使用できます。

isdisjoint(a, b) -> Bool

コレクション a と b が互いに素であるかどうかを判断します。isempty(a ∩ b) と同等ですが、可能な場合はより効率的です。

関連情報: intersect, isempty, issetequal。

例

julia> isdisjoint([1, 2], [2, 3, 4])
false

julia> isdisjoint([3, 1], [2, 4])
true

isdisjoint(x)

引数を x と比較する関数を作成します。これは isdisjoint を使用し、すなわち y -> isdisjoint(y, x) と同等の関数です。返される関数は Base.Fix2{typeof(isdisjoint)} 型であり、特化したメソッドを実装するために使用できます。

push!(collection, items...) -> collection

1つ以上のitemsをcollectionに挿入します。collectionが順序付きコンテナである場合、アイテムは最後に（指定された順序で）挿入されます。

例

julia> push!([1, 2, 3], 4, 5, 6)
6-element Vector{Int64}:
 1
 2
 3
 4
 5
 6

collectionが順序付きである場合、append!を使用して別のコレクションのすべての要素を追加します。前の例の結果は、append!([1, 2, 3], [4, 5, 6])と同等です。AbstractSetオブジェクトの場合は、union!を代わりに使用できます。

パフォーマンスモデルに関する注意については、sizehint!を参照してください。

また、pushfirst!も参照してください。

pop!(collection) -> item

collection からアイテムを削除し、それを返します。collection が順序付きコンテナの場合、最後のアイテムが返されます; 順序なしコンテナの場合は、任意の要素が返されます。

関連項目: popfirst!, popat!, delete!, deleteat!, splice!, および push!。

例

julia> A=[1, 2, 3]
3-element Vector{Int64}:
 1
 2
 3

julia> pop!(A)
3

julia> A
2-element Vector{Int64}:
 1
 2

julia> S = Set([1, 2])
Set{Int64} with 2 elements:
  2
  1

julia> pop!(S)
2

julia> S
Set{Int64} with 1 element:
  1

julia> pop!(Dict(1=>2))
1 => 2

pop!(collection, key[, default])

collection に key が存在する場合は、そのマッピングを削除して返します。存在しない場合は default を返すか、default が指定されていない場合はエラーをスローします。

例

julia> d = Dict("a"=>1, "b"=>2, "c"=>3);

julia> pop!(d, "a")
1

julia> pop!(d, "d")
ERROR: KeyError: key "d" not found
Stacktrace:
[...]

julia> pop!(d, "e", 4)
4

popat!(a::Vector, i::Integer, [default])

指定された i のアイテムを削除し、それを返します。以降のアイテムは、結果として生じた隙間を埋めるためにシフトされます。i が a の有効なインデックスでない場合、default を返すか、default が指定されていない場合はエラーをスローします。

関連情報: pop!, popfirst!, deleteat!, splice!.

例

julia> a = [4, 3, 2, 1]; popat!(a, 2)
3

julia> a
3-element Vector{Int64}:
 4
 2
 1

julia> popat!(a, 4, missing)
missing

julia> popat!(a, 4)
ERROR: BoundsError: attempt to access 3-element Vector{Int64} at index [4]
[...]

pushfirst!(collection, items...) -> collection

コレクションの先頭に1つ以上のitemsを挿入します。

この関数は多くの他のプログラミング言語ではunshiftと呼ばれています。

例

julia> pushfirst!([1, 2, 3, 4], 5, 6)
6-element Vector{Int64}:
 5
 6
 1
 2
 3
 4

popfirst!(collection) -> item

コレクションから最初の item を削除します。

この関数は多くの他のプログラミング言語では shift と呼ばれています。

参照: pop!, popat!, delete!.

例

julia> A = [1, 2, 3, 4, 5, 6]
6-element Vector{Int64}:
 1
 2
 3
 4
 5
 6

julia> popfirst!(A)
1

julia> A
5-element Vector{Int64}:
 2
 3
 4
 5
 6

insert!(a::Vector, index::Integer, item)

指定されたindexでaにitemを挿入します。indexは結果のaにおけるitemのインデックスです。

参照: push!, replace, popat!, splice!.

例

julia> insert!(Any[1:6;], 3, "here")
7-element Vector{Any}:
 1
 2
  "here"
 3
 4
 5
 6

deleteat!(a::Vector, i::Integer)

指定された i のアイテムを削除し、修正された a を返します。後続のアイテムは、結果として生じた隙間を埋めるためにシフトされます。

参照: keepat!, delete!, popat!, splice!.

例

julia> deleteat!([6, 5, 4, 3, 2, 1], 2)
5-element Vector{Int64}:
 6
 4
 3
 2
 1

deleteat!(a::Vector, inds)

inds で指定されたインデックスのアイテムを削除し、修正された a を返します。後続のアイテムは、結果として生じた隙間を埋めるためにシフトされます。

inds は、イテレータまたはソートされていてユニークな整数インデックスのコレクション、または a と同じ長さのブールベクターで、true が削除するエントリを示すことができます。

例

julia> deleteat!([6, 5, 4, 3, 2, 1], 1:2:5)
3-element Vector{Int64}:
 5
 3
 1

julia> deleteat!([6, 5, 4, 3, 2, 1], [true, false, true, false, true, false])
3-element Vector{Int64}:
 5
 3
 1

julia> deleteat!([6, 5, 4, 3, 2, 1], (2, 2))
ERROR: ArgumentError: indices must be unique and sorted
Stacktrace:
[...]

keepat!(a::Vector, inds)
keepat!(a::BitVector, inds)

与えられた inds によって指定されていないすべてのインデックスのアイテムを削除し、修正された a を返します。保持されるアイテムは、結果のギャップを埋めるためにシフトされます。

inds は、ソートされていてユニークな整数インデックスのイテレータでなければなりません。詳細は deleteat! を参照してください。

例

julia> keepat!([6, 5, 4, 3, 2, 1], 1:2:5)
3-element Vector{Int64}:
 6
 4
 2

keepat!(a::Vector, m::AbstractVector{Bool})
keepat!(a::BitVector, m::AbstractVector{Bool})

論理インデックスのインプレースバージョン a = a[m]。すなわち、長さが等しいベクトル a と m に対して keepat!(a, m) を実行すると、対応するインデックスで m が false である a のすべての要素が削除されます。

例

julia> a = [:a, :b, :c];

julia> keepat!(a, [true, false, true])
2-element Vector{Symbol}:
 :a
 :c

julia> a
2-element Vector{Symbol}:
 :a
 :c

splice!(a::Vector, index::Integer, [replacement]) -> item

指定されたインデックスのアイテムを削除し、削除されたアイテムを返します。以降のアイテムは、結果として生じた隙間を埋めるために左にシフトされます。指定された場合、順序付きコレクションからの置換値が削除されたアイテムの代わりに挿入されます。

関連情報: replace, delete!, deleteat!, pop!, popat!。

例

julia> A = [6, 5, 4, 3, 2, 1]; splice!(A, 5)
2

julia> A
5-element Vector{Int64}:
 6
 5
 4
 3
 1

julia> splice!(A, 5, -1)
1

julia> A
5-element Vector{Int64}:
  6
  5
  4
  3
 -1

julia> splice!(A, 1, [-1, -2, -3])
6

julia> A
7-element Vector{Int64}:
 -1
 -2
 -3
  5
  4
  3
 -1

アイテムを削除せずにインデックス n の前に replacement を挿入するには、splice!(collection, n:n-1, replacement) を使用します。

splice!(a::Vector, indices, [replacement]) -> items

指定されたインデックスでアイテムを削除し、削除されたアイテムを含むコレクションを返します。以降のアイテムは、結果として生じる隙間を埋めるために左にシフトされます。指定された場合、順序付きコレクションからの置換値が削除されたアイテムの代わりに挿入されます。この場合、indicesはAbstractUnitRangeでなければなりません。

アイテムを削除せずにインデックスnの前にreplacementを挿入するには、splice!(collection, n:n-1, replacement)を使用します。

例

julia> A = [-1, -2, -3, 5, 4, 3, -1]; splice!(A, 4:3, 2)
Int64[]

julia> A
8-element Vector{Int64}:
 -1
 -2
 -3
  2
  5
  4
  3
 -1

resize!(a::Vector, n::Integer) -> Vector

aをn要素を含むようにサイズ変更します。nが現在のコレクションの長さより小さい場合、最初のn要素が保持されます。nが大きい場合、新しい要素が初期化されることは保証されません。

例

julia> resize!([6, 5, 4, 3, 2, 1], 3)
3-element Vector{Int64}:
 6
 5
 4

julia> a = resize!([6, 5, 4, 3, 2, 1], 8);

julia> length(a)
8

julia> a[1:6]
6-element Vector{Int64}:
 6
 5
 4
 3
 2
 1

append!(collection, collections...) -> collection.

順序付きコンテナ collection に、各 collections の要素をその末尾に追加します。

例

julia> append!([1], [2, 3])
3-element Vector{Int64}:
 1
 2
 3

julia> append!([1, 2, 3], [4, 5], [6])
6-element Vector{Int64}:
 1
 2
 3
 4
 5
 6

個別のアイテムを collection に追加するには、push! を使用します。これらは他のコレクションには含まれていません。前の例の結果は push!([1, 2, 3], 4, 5, 6) と同等です。

パフォーマンスモデルに関する注意については、sizehint! を参照してください。

ベクトルについては vcat、集合については union!、逆の順序については prepend! と pushfirst! も参照してください。

prepend!(a::Vector, collections...) -> collection

各 collections の要素を a の先頭に挿入します。

collections が複数のコレクションを指定する場合、順序は維持されます： collections[1] の要素が a の最も左に表示され、その後に続きます。

例

julia> prepend!([3], [1, 2])
3-element Vector{Int64}:
 1
 2
 3

julia> prepend!([6], [1, 2], [3, 4, 5])
6-element Vector{Int64}:
 1
 2
 3
 4
 5
 6

Pair(x, y)
x => y

Pairオブジェクトを型Pair{typeof(x), typeof(y)}で構築します。要素はフィールドfirstとsecondに格納されます。また、イテレーションを通じてアクセスすることもできます（ただし、Pairはブロードキャスト操作のために単一の「スカラー」として扱われます）。

Dictも参照してください。

例

julia> p = "foo" => 7
"foo" => 7

julia> typeof(p)
Pair{String, Int64}

julia> p.first
"foo"

julia> for x in p
           println(x)
       end
foo
7

julia> replace.(["xops", "oxps"], "x" => "o")
2-element Vector{String}:
 "oops"
 "oops"

Base.Pairs(values, keys) <: AbstractDict{eltype(keys), eltype(values)}

インデックス可能なコンテナを同じデータの辞書ビューに変換します。基になるデータのキー空間を変更すると、このオブジェクトが無効になる可能性があります。