Collections and Data Structures
Iteration
逐次反復は、iterate 関数によって実装されています。一般的な for ループ:
for i in iter # or "for i = iter"
# body
endは、次のように変換されます。
next = iterate(iter)
while next !== nothing
(i, state) = next
# body
next = iterate(iter, state)
endstate オブジェクトには任意のものを指定でき、反復可能な型ごとに適切なものを選ぶ必要があります。カスタムの反復可能な型の定義について詳しくは、manual section on the iteration interface を参照してください。
Base.iterate — Function
iterate(iter [, state])::Union{Nothing, Tuple{Any, Any}}イテレーターを進めて次の要素を取得します。要素が残っていない場合は、nothingを返します。そうでない場合は、次の要素と新しい反復状態からなる2要素タプルを返します。
Base.IteratorSize — Type
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()Base.IteratorEltype — Type
IteratorEltype(itertype::Type)::IteratorEltypeイテレータの型を指定すると、次のいずれかの値を返します。
- イテレータが生成する要素の型が事前にわからない場合は、
EltypeUnknown()。 - 要素の型がわかっており、
eltypeが意味のある値を返す場合は、HasEltype()。
イテレータはeltypeを実装していると想定されるため、デフォルト値はHasEltype()です。
このトレイトは一般に、特定の型の結果を事前に確保するアルゴリズムと、生成された値の型に基づいて結果の型を選ぶアルゴリズムを切り替えるために使われます。
julia> Base.IteratorEltype(1:5)
Base.HasEltype()完全に実装されているもの:
AbstractRangeUnitRangeTupleNumberAbstractArrayBitSetIdDictDictWeakKeyDictEachLineAbstractStringSetPairNamedTuple
Constructors and Types
Base.OrdinalRange — Type
OrdinalRange{T, S} <: AbstractRange{T}要素の型がTで、間隔の型がSである序数範囲のスーパータイプです。ステップ幅は常にoneunitの整数倍でなければならず、Tは、oneunitより小さい値を取れない「離散」型でなければなりません。たとえば、IntegerやDateの型は該当しますが、Float64は該当しません(この型はoneunit(Float64)より小さい値を表現できるためです)。UnitRange、StepRangeなどの型は、この型のサブタイプです。
Base.AbstractUnitRange — Type
AbstractUnitRange{T} <: OrdinalRange{T, T}要素の型がTで、ステップ幅がoneunit(T)の範囲のスーパータイプです。UnitRangeなどの型は、この型のサブタイプです。
Base.StepRange — Type
StepRange{T, S} <: OrdinalRange{T, S}要素の型がTで、間隔の型がSの範囲です。各要素間のステップは一定で、範囲は型がTのstartとstop、および型がSのstepで定義されます。TもSも、浮動小数点型にしてはいけません。b != 0、a、b、cがすべて整数であるa:b:cという構文は、StepRangeを作成します。
Examples
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}Base.UnitRange — Type
UnitRange{T<:Real}start と stop でパラメーター化された範囲で、型は T です。start から stop を超えるまで、1 間隔で要素が並びます。a と b がどちらも Integer である場合、構文 a:b は UnitRange を生成します。
Examples
julia> collect(UnitRange(2.3, 5.2))
3-element Vector{Float64}:
2.3
3.3
4.3
julia> typeof(1:10)
UnitRange{Int64}Base.AbstractOneTo — Type
Base.LinRange — Type
LinRange{T,L}startからstopまでを線形間隔で分割した、len個の要素を持つ範囲です。間隔の大きさはlenで指定します。これはIntegerでなければなりません。
Examples
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.5rangeを使う場合と比べて、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対数間隔の点については、Base.LogRangeも参照してください。
General Collections
Base.isempty — Function
isempty(condition)条件待ちのタスクがない場合はtrueを返し、ある場合はfalseを返します。
isempty(collection)::Boolコレクションが空(要素を持たない)かどうかを判定します。
isempty(itr) は、適切な Base.isdone(itr) メソッドが定義されていない場合、状態を持つイテレータ itr の次の要素を消費することがあります。状態を持つイテレータでは isdone を実装することが推奨されますが、あらゆる型のイテレータに対応する汎用コードを書く場合は、isempty の使用を避けることを検討してください。
Examples
julia> isempty([])
true
julia> isempty([1 2 3])
falseBase.isdone — Function
isdone(itr, [state])::Union{Bool, Missing}この関数は、イテレーターの完了を高速に判定するためのヒントを提供します。これは、ユーザーに公開されない要素が消費されるのを避けたいステートフルなイテレーターに役立ちます(たとえば、isempty または zip で完了状態を確認する場合)。
この機能を利用するステートフルなイテレーターは、イテレーターが完了しているかどうかに応じて true または false を返す isdone メソッドを定義してください。ステートレスなイテレーターでは、この関数を実装する必要はありません。
結果が missing の場合、isdone ではイテレーターの状態が終端かどうかを判定できません。そのため、呼び出し側は確定的な答えを得るために iterate(itr, state) === nothing を計算する必要があります。
Base.empty! — Function
empty!(c::Channel)内部バッファに対してempty!を呼び出し、cを空にします。空になったチャネルを返します。
empty!(collection) -> collectioncollectionからすべての要素を削除します。
Examples
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}()Base.checked_length — Function
Base.checked_length(r)length(r) を計算します。ただし、結果が Union{Integer(eltype(r)),Int} に収まらない場合は、該当する箇所でオーバーフローエラーをチェックすることがあります。
完全に実装されているもの:
AbstractRangeUnitRangeTupleNumberAbstractArrayBitSetIdDictDictWeakKeyDictAbstractStringSetNamedTuple
Iterable Collections
Base.in — Function
in(item, collection)::Bool
∈(item, collection)::Bool指定されたコレクションを反復して生成される値のいずれかに==かどうかを判定します。中置記法でも同様に使用できます。
item in collection
item ∈ collectionBoolの値を返します。ただし、itemがmissingである場合、またはcollectionにmissingが含まれ、itemは含まれない場合は、missingを返します(three-valued logic。anyおよび==と同じ動作です)。コレクションによっては、定義が少し異なります。たとえば、Setでは、項目がいずれかの要素にisequalかどうかを調べます。Dictではkey=>valueのペアを検索し、keyはisequalを使って比較します。
辞書にキーが存在するかどうかを調べるには、haskeyまたはk in keys(dict)を使用してください。上記のコレクションでは、結果は常にBoolです。
in.(items, collection)またはitems .∈ collectionでブロードキャストすると、itemsとcollectionの両方がブロードキャストされますが、これは意図した動作でないことがよくあります。たとえば、両方の引数がベクトルで(次元が一致している場合)、コレクションitemsの各値が、collectionの対応する位置にある値にinかどうかを示すベクトルが返されます。itemsの各値がcollectionに含まれるかどうかを示すベクトルを得るには、次のようにcollectionをタプルまたはRefで囲みます。in.(items, Ref(collection))またはitems .∈ Ref(collection)。
関連項目:∉、insorted、contains、occursin、issubset。
Examples
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
1Base.:∉ — Function
∉(item, collection)::Bool
∌(collection, item)::Bool∈および∋の否定、つまり、itemがcollectionに含まれていないことを確認します。
items .∉ collectionでブロードキャストすると、itemsとcollectionの両方がブロードキャストされますが、これは意図した動作でないことがよくあります。たとえば、両方の引数がベクトルで(次元が一致している場合)、結果は、コレクションitemsの各値が、collectionの対応する位置にある値に含まれていないかどうかを示すベクトルになります。itemsの各値がcollectionに含まれていないかどうかを示すベクトルを得るには、次のようにcollectionをタプルまたはRefで囲みます。items .∉ Ref(collection)。
Examples
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
0Base.hasfastin — Function
Base.hasfastin(T)collection::T の場合に、計算 x ∈ collection を「高速」な操作(通常は定数時間または対数時間の計算量)とみなせるかどうかを判定します。定義 hasfastin(x) = hasfastin(typeof(x)) は、型の代わりにインスタンスを渡せるようにするための便宜的なものです。ただし、新しい型については、型引数を受け取る形式を定義する必要があります。
hasfastin(T) のデフォルト値は、AbstractSet、AbstractDict、AbstractRange のサブタイプでは true、それ以外では false です。
Base.eltype — Function
eltype(type)指定されたtypeのコレクションを反復処理したときに生成される要素の型を判定します。辞書型の場合、これはPair{KeyType,ValType}になります。インスタンスを型の代わりに渡せるよう、便宜上eltype(x) = eltype(typeof(x))の定義も用意されています。ただし、新しい型では、型引数を受け取る形式を定義してください。
Examples
julia> eltype(fill(1f0, (2,2)))
Float32
julia> eltype(fill(0x1, (2,2)))
UInt8Base.indexin — Function
indexin(a, b)aの各値について、bの要素である場合に、b内で最初に現れるインデックスを含む配列を返します。aがbの要素でない場合、出力配列にはnothingが含まれます。
Examples
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
3Base.unique — Function
unique(A::AbstractArray; dims::Int)Aの一意な領域を、dimsに沿って返します。
Examples
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 0unique(f, itr)itr の各要素に f を適用して得られる一意な値ごとに、itr の値を1つずつ含む配列を返します。
Examples
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)
trueunique(itr)itrで指定されたコレクションから、isequalおよびhashに従って一意な要素のみを含む配列を返します。同値な要素の各集合については、元のコレクションで最初に現れた要素の順序を保ちます。入力の要素型は保持されます。
関連項目: unique!、allunique、allequal。
Examples
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
2Base.unique! — Function
unique!(A::AbstractVector)isequal と hash によって判定される重複項目を削除し、変更後の A を返します。unique! は、A の要素を出現順に返します。返されるデータの順序を気にしない場合は、A の要素をソートできることを条件に、(sort!(A); unique!(A)) を呼び出すほうがはるかに効率的です。
Examples
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! is able to process sorted data much more efficiently.
julia> unique!(B)
3-element Vector{Int64}:
6
7
42unique!(f, A::AbstractVector)A の各要素に f を適用して得られる一意な値ごとに、A から値を1つ選択し、変更後の A を返します。
Examples
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
3Base.allunique — Function
allunique(itr)::Bool
allunique(f, itr)::Boolitr のすべての値が isequal と比較して互いに異なる場合は、true を返します。2つ目の方法では、[f(x) for x in itr] のすべての値が互いに異なる場合に返します。
allunique(f, itr) は、f を length(itr) 回より少なく呼び出すことがあります。呼び出し回数の正確な値は、実装の詳細とみなされます。
入力がソート済みの場合、allunique は専用の実装を使用することがあります。
関連項目: unique、issorted、allequal。
Examples
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])
falseBase.allequal — Function
allequal(itr)::Bool
allequal(f, itr)::Booltrueを返します。これは、isequalで比較したときに、itrのすべての値が等しい場合です。2つ目の方法では、[f(x) for x in itr]のすべての値が等しい場合にも返します。
allequal(f, itr)がlength(itr)回より少ない回数しかfを呼び出さない場合があることに注意してください。呼び出し回数の正確な値は、実装の詳細とみなされます。
Examples
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])
trueBase.reduce — Method
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 の将来のバージョンでは、アルゴリズムが変更される可能性があります。順序付きコレクションを使う場合、要素の順序は変更されません。
Examples
julia> reduce(*, [2; 3; 4])
24
julia> reduce(*, Int[]; init=1)
1Base.reduce — Method
reduce(f, A::AbstractArray; dims=:, [init])2引数関数 f を、A の次元に沿って縮約します。dims は縮約する次元を指定するベクトルで、キーワード引数 init は縮約の初期値です。+、*、max、min では、引数 init は省略できます。
縮約の結合順序は実装に依存します。左から右など、特定の結合順序が必要な場合は、独自のループを記述するか、foldl または foldr の使用を検討してください。reduce のドキュメントを参照してください。
Examples
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 16Base.foldl — Method
foldl(op, itr; [init])reduceと同様ですが、左結合性が保証されています。指定した場合、キーワード引数initは1回だけ使用されます。一般に、空のコレクションで動作させるにはinitを指定する必要があります。
関連項目:mapfoldl、foldr、accumulate。
Examples
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)Base.foldr — Method
foldr(op, itr; [init])reduceと同様ですが、右結合性が保証されています。指定した場合、キーワード引数initは1回だけ使用されます。一般に、空のコレクションで動作させるにはinitを指定する必要があります。
Examples
julia> foldr(=>, 1:4)
1 => (2 => (3 => 4))
julia> foldr(=>, 1:4; init=0)
1 => (2 => (3 => (4 => 0)))Base.maximum — Function
maximum(f, A::AbstractArray; dims)指定された次元にわたる配列の各要素に対して関数 f を呼び出し、その最大値を計算します。
Examples
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
16maximum(A::AbstractArray; dims)指定した次元に沿って、配列の最大値を計算します。2つ以上の引数の最大値を求める関数については、max(a,b)も参照してください。この関数は、配列に対して要素ごとに適用できます(max.(a,b))。
関連項目:maximum!、extrema、findmax、argmax。
Examples
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
4maximum(itr; [init])コレクション内の最大の要素を返します。
空の itr に対して返す値は、init で指定できます。空でないコレクションで init が使用されるかどうかは定められていないため、この値は max の中立元(つまり、ほかのどの要素以下でもある値)でなければなりません。
Examples
julia> maximum(-20.5:10)
9.5
julia> maximum([1,2,3])
3
julia> maximum(())
ERROR: ArgumentError: reducing over an empty collection is not allowed; consider supplying `init` to the reducer
Stacktrace:
[...]
julia> maximum((); init=-Inf)
-Infmaximum(f, itr; [init])f を itr の各要素に適用した結果の最大値を返します。
空の itr に対して返す値は、init で指定できます。init が空でないコレクションに対して使われるかどうかは未指定のため、この値は max の中立元(つまり、ほかのどの要素以下でもある値)でなければなりません。
Examples
julia> maximum(length, ["Julion", "Julia", "Jule"])
6
julia> maximum(length, []; init=-1)
-1
julia> maximum(sin, Real[]; init=-1.0) # good, since output of sin is >= -1
-1.0Base.maximum! — Function
maximum!(r, A)r の単一要素の次元に沿って A の最大値を計算し、結果を r に書き込みます。
Examples
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 4Base.minimum — Function
minimum(f, A::AbstractArray; dims)指定された次元に沿って配列の各要素に関数 f を適用し、その最小値を計算します。
Examples
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
9minimum(A::AbstractArray; dims)指定した次元に沿って、配列の最小値を計算します。2つ以上の引数の最小値を求めるmin(a,b)関数も参照してください。この関数は、min.(a,b)を使って配列に要素ごとに適用できます。
関連項目: minimum!、extrema、findmin、argmin。
Examples
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
3minimum(itr; [init])コレクション内の最小の要素を返します。
空のitrに対して返す値は、initで指定できます。この値はminの中立元(つまり、ほかのどの要素以上でもある値)でなければなりません。空でないコレクションに対してinitが使われるかどうかは指定されていないためです。
Examples
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)
Infminimum(f, itr; [init])itr の各要素に関数 f を適用した結果のうち、最小の値を返します。
空の itr に対して返す値は、init で指定できます。この値は min の中立元(つまり、他のどの要素以上でもある値)でなければなりません。空でないコレクションでは init が使われるかどうかが未指定だからです。
Examples
julia> minimum(length, ["Julion", "Julia", "Jule"])
4
julia> minimum(length, []; init=typemax(Int64))
9223372036854775807
julia> minimum(sin, Real[]; init=1.0) # good, since output of sin is <= 1
1.0Base.minimum! — Function
minimum!(r, A)r の単一要素の次元に沿って A の最小値を計算し、結果を r に書き込みます。
Examples
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 2Base.extrema — Function
extrema(f, A::AbstractArray; dims) -> Array{Tuple}指定された A の各要素に f を適用し、その最小値と最大値を計算します。
extrema(A::AbstractArray; dims) -> Array{Tuple}指定された次元に沿って、配列の最小要素と最大要素を計算します。
関連項目: minimum、maximum、extrema!。
Examples
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, itr; [init]) -> (mn, mx)itr の各要素に f を適用し、その最小値 mn と最大値 mx を計算して、2 タプルとして返します。itr は 1 回だけ走査されます。
空の itr に対して返す値は、init で指定できます。これは、1 番目と 2 番目の要素がそれぞれ min と max の中立元(つまり、ほかのどの要素よりも大きいか等しい値、および小さいか等しい値)である 2 タプルでなければなりません。これは空でないコレクションに対して使用されます。注: 空の itr の場合、返される値 (mn, mx) は mn ≥ mx を満たしますが、空でない itr の場合は mn ≤ mx を満たします。これは「逆説的」ですが、想定どおりの結果です。
Examples
julia> extrema(sin, 0:π)
(0.0, 0.9092974268256817)
julia> extrema(sin, Real[]; init = (1.0, -1.0)) # good, since -1 ≤ sin(::Real) ≤ 1
(1.0, -1.0)extrema(itr; [init]) -> (mn, mx)1回の走査で最小の mn 要素と最大の mx 要素の両方を計算し、2タプルとして返します。
空の itr に対して返される値は、init で指定できます。これは、1番目と2番目の要素がそれぞれ min と max の中立元(つまり、ほかのどの要素よりも大きいか等しい値、および小さいか等しい値)である2タプルでなければなりません。その結果、itr が空の場合、返される (mn, mx) タプルは mn ≥ mx を満たします。init が指定されている場合は、空でない itr に対しても使用できます。
Examples
julia> extrema(2:10)
(2, 10)
julia> extrema([9,pi,4.5])
(3.141592653589793, 9.0)
julia> extrema([]; init = (Inf, -Inf))
(Inf, -Inf)Base.extrema! — Function
extrema!(r, A)A の最小値と最大値を r の単一要素の次元に沿って計算し、その結果を r に書き込みます。
Examples
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)Base.argmax — Function
argmax(A; dims) -> indices配列を入力として受け取り、指定された次元における最大値のインデックスを返します。NaN は、missing を除くすべての値より大きいものとして扱われます。
Examples
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)argmax(itr)コレクション内の最大要素のインデックスまたはキーを返します。最大要素が複数ある場合は、最初の要素が返されます。
コレクションは空であってはなりません。
インデックスの型は、keys(itr) および pairs(itr) が返す型と同じです。
値は isless によって比較されます。
Examples
julia> argmax([8, 0.1, -9, pi])
1
julia> argmax([1, 7, 7, 6])
2
julia> argmax([1, 7, 7, NaN])
4argmax(f, domain)domainの中から、f(x)が最大となるxを返します。f(x)が最大値を複数持つ場合は、最初の値が見つかります。
domainは空でない反復可能オブジェクトでなければなりません。
値はislessで比較されます。
Examples
julia> argmax(abs, -10:5)
-10
julia> argmax(cos, 0:π/2:2π)
0.0argmax(r::AbstractRange)範囲には極大要素が複数存在する場合があります。その場合、argmax は極大なインデックスを返しますが、必ずしも最初のものとは限りません。
Base.argmin — Function
argmin(A; dims) -> indices配列を入力すると、指定された次元における最小値のインデックスを返します。NaN は、missing を除くすべての値より小さいものとして扱われます。
Examples
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)argmin(itr)コレクション内の最小要素のインデックスまたはキーを返します。最小要素が複数ある場合は、最初の要素が返されます。
コレクションは空であってはなりません。
インデックスの型は、keys(itr)およびpairs(itr)が返す型と同じです。
NaNは、missingを除くすべての値より小さいものとして扱われます。
Examples
julia> argmin([8, 0.1, -9, pi])
3
julia> argmin([7, 1, 1, 6])
2
julia> argmin([7, 1, 1, NaN])
4argmin(f, domain)x を返します。これは domain の中から f(x) が最小となる値です。f(x) が最小となる値が複数ある場合は、最初の値が返されます。
domain は空でない反復可能オブジェクトでなければなりません。
NaN は、missing を除くすべての値より小さいものとして扱われます。
Examples
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.0argmin(r::AbstractRange)範囲には極小要素が複数存在する場合があります。その場合、argminは極小のインデックスを返しますが、必ずしも最初のものとは限りません。
Base.findmax — Function
findmax(f, A; dims) -> (f(x), index)配列を入力として受け取り、指定された次元に沿って f を最大化する値と、その値に対応するインデックスを返します。
Examples
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);;])findmax(A; dims) -> (maxval, index)配列を入力として、指定された次元における最大値とそのインデックスを返します。NaN は、missing を除くすべての値より大きいものとして扱われます。
Examples
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(itr) -> (x, index)コレクション itr の最大要素と、そのインデックスまたはキーを返します。最大要素が複数ある場合は、最初の要素を返します。値の比較には isless を使用します。
インデックスの型は、keys(itr) および pairs(itr) が返す型と同じです。
Examples
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(f, domain) -> (f(x), index)f の出力である値と、f への入力である domain 内の対応する値のインデックスまたはキーのペアを返します。このペアは、f(x) が最大となるものです。最大値をとる点が複数ある場合は、最初のものを返します。
domain は、空でなく、keys をサポートする反復可能オブジェクトでなければなりません。インデックスの型は、keys(domain) が返すものと同じです。
値は isless で比較されます。
Examples
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)Base.findmin — Function
findmin(f, A; dims) -> (f(x), index)配列を入力として受け取り、指定された次元に沿って f を最小化する値と、その値に対応するインデックスを値域から返します。
Examples
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);;])findmin(A; dims) -> (minval, index)配列を入力すると、指定された次元における最小値とそのインデックスを返します。NaN は、missing を除くすべての値より小さいものとして扱われます。
Examples
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(itr) -> (x, index)コレクション itr の最小要素と、そのインデックスまたはキーを返します。最小要素が複数ある場合は、最初の要素を返します。NaN は、missing を除くすべての値より小さいものとして扱われます。
インデックスの型は、keys(itr) および pairs(itr) が返す型と同じです。
Examples
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(f, domain) -> (f(x), index)f の出力である値と、f への入力である domain 内の対応する値のインデックスまたはキーを返します。f(x) が最小となるものを返し、最小値をとる点が複数ある場合は最初のものを返します。
domain は空でない反復可能オブジェクトでなければなりません。
インデックスの型は、keys(domain) および pairs(domain) が返す型と同じです。
NaN は、missing を除くすべての値より小さいものとして扱われます。
Examples
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)Base.findmax! — Function
findmax!(rval, rind, A) -> (maxval, index)rvalとrindの単一要素次元に沿って、Aの最大値と対応する線形インデックスを求め、その結果をrvalとrindに格納します。NaNは、missingを除くすべての値より大きいものとして扱われます。
Base.findmin! — Function
findmin!(rval, rind, A) -> (minval, index)rval と rind の単一要素次元に沿って、A の最小値と、それに対応する線形インデックスを求め、結果を rval と rind に格納します。NaN は、missing を除くすべての値より小さいものとして扱われます。
Base.sum — Function
sum(f, A::AbstractArray; dims)指定された次元に沿って、配列の各要素に関数 f を適用した結果を合計します。
Examples
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
25sum(A::AbstractArray; dims)指定された次元に沿って配列の要素を合計します。
Examples
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
7sum(itr; [init])コレクション内のすべての要素の合計を返します。
戻り値の型は、システムワードサイズ未満の符号付き整数の場合は Int、システムワードサイズ未満の符号なし整数の場合は UInt です。それ以外の引数では、すべての引数が昇格される共通の戻り値の型が決定されます。
空の itr に対して返される値は、init で指定できます。空でないコレクションで init が使われるかどうかは未規定のため、この値は加法単位元(つまりゼロ)でなければなりません。
関連項目: reduce、mapreduce、count、union。
Examples
julia> sum(1:20)
210
julia> sum(1:20; init = 0.0)
210.0sum(f, itr; [init])itr の各要素に対して関数 f を呼び出し、その結果を合計します。
システムワードサイズ未満の符号付き整数の場合、戻り値の型は Int です。システムワードサイズ未満の符号なし整数の場合は UInt です。それ以外の引数では、すべての引数が昇格される共通の戻り値の型が決定されます。
空の itr に対して返される値は、init で指定できます。この値は加法単位元(つまりゼロ)でなければなりません。空でないコレクションでは init が使われるかどうかは規定されていないためです。
Examples
julia> sum(abs2, [2; 3; 4])
29要素型が小さい整数である配列では、sum(A) と reduce(+, A) の重要な違いに注意してください。
julia> sum(Int8[100, 28])
128
julia> reduce(+, Int8[100, 28])
-128前者では整数がシステムワードサイズまで拡張されるため、結果は 128 になります。後者ではそのような拡張は行われず、整数オーバーフローによって -128 になります。
Base.prod — Function
prod(f, A::AbstractArray; dims)指定された次元に沿って、配列の各要素に対して関数 f を呼び出し、その結果を乗算します。
Examples
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
144prod(A::AbstractArray; dims)指定された次元に沿って、配列の要素を乗算します。
Examples
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
12prod(itr; [init])コレクションのすべての要素の積を返します。
システムワードサイズ未満の符号付き整数の場合、戻り値の型はIntです。システムワードサイズ未満の符号なし整数の場合はUIntです。それ以外の引数では、すべての引数が昇格される共通の戻り値の型が決定されます。
空のitrに対して返される値は、initで指定できます。空でないコレクションではinitが使われるかどうかは未規定のため、この値は乗法単位元(つまり1)でなければなりません。
Examples
julia> prod(1:5)
120
julia> prod(1:5; init = 1.0)
120.0prod(f, itr; [init])itr の各要素に f を適用した結果の積を返します。
システムワードサイズ未満の符号付き整数の場合、戻り値の型は Int です。システムワードサイズ未満の符号なし整数の場合は UInt です。それ以外の引数では、すべての引数が変換される共通の戻り値の型が決定されます。
空の itr に対して返す値は、init で指定できます。この値は乗法単位元(つまり 1)でなければなりません。空でないコレクションで init が使われるかどうかは未規定です。
Examples
julia> prod(abs2, [2; 3; 4])
576Base.prod! — Function
prod!(r, A)Aの要素を、rの単一要素の次元に沿って乗算し、結果をrに書き込みます。
Examples
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 8Base.any — Method
any(itr)::Boolブール値のコレクションにtrueである要素があるかを調べ、itr内で最初にtrueの値が見つかった時点で(短絡評価により)trueを返します。falseで短絡評価するには、allを使用してください。
入力にmissingの値が含まれる場合、欠損値以外のすべての値がfalseであれば(または同じことですが、入力にtrueの値が含まれなければ)、three-valued logicに従ってmissingを返します。
Examples
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])
missingBase.any — Method
any(p, itr)::Bool述語 p が itr の要素に対して true を返すかどうかを判定します。itr の項目のうち、p が true を返す最初の項目が見つかった時点で、true を返します(短絡評価)。false で短絡評価するには、all を使用してください。
入力に missing の値が含まれる場合、欠損値でない値がすべて false であれば(または、入力に true の値が含まれなければ)、missing を返します。これは three-valued logic に従います。
Examples
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])
falseBase.all — Method
all(itr)::Boolブール値のコレクションのすべての要素がtrueであるかをテストします。itr内で最初のfalse値が見つかると、直ちにfalseを返します(短絡評価)。trueで短絡評価するには、anyを使用してください。
入力にmissing値が含まれる場合、three-valued logicに従い、欠損値以外のすべての値がtrueであれば(つまり、入力にfalse値が含まれなければ)、missingを返します。
関連項目: all!、any、count、&、&&、allunique。
Examples
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])
missingBase.all — Method
all(p, itr)::Bool述語 p が itr のすべての要素に対して true を返すかどうかを判定します。itr のうち、p が false を返す最初の要素が見つかると、ただちに false を返します(短絡評価)。true で短絡評価するには、any を使用してください。
入力に missing の値が含まれる場合、欠損値でない値がすべて true であれば(つまり、入力に false の値が含まれない場合も同様に)、missing を返します。これは three-valued logic に従います。
Examples
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])
trueBase.count — Function
count([f=identity,] A::AbstractArray; dims=:)指定された次元にわたって、A の要素のうち、f が true を返すものの数を数えます。
Examples
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
0count(
pattern::Union{AbstractChar,AbstractString,AbstractPattern},
string::AbstractString;
overlap::Bool = false,
)string 内で pattern に一致する箇所の数を返します。これは length(findall(pattern, string)) を呼び出すのと同等ですが、より効率的です。
overlap=true の場合、一致する並びは元の文字列内でインデックスが重複してもかまいません。それ以外の場合は、互いに重ならない文字範囲に含まれている必要があります。
Examples
julia> count('a', "JuliaLang")
2
julia> count(r"a(.)a", "cabacabac", overlap=true)
3
julia> count(r"a(.)a", "cabacabac")
2See also
count([f=identity,] itr; init=0)::Integerf が true を返す要素の数を、itr から数えます。f を省略した場合は、itr(ブール値のコレクションである必要があります)に含まれる true 要素の数を数えます。init は、カウントの開始値を指定するオプションの引数であり、出力の型も決定します。
Examples
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=UInt(0))
0x0000000000000004Base.foreach — Function
foreach(f, c...) -> nothing反復可能オブジェクトcの各要素に対して、関数fを呼び出します。複数の反復可能引数を指定した場合は、fが要素ごとに呼び出され、いずれかのイテレーターが終了した時点で反復も終了します。
fの結果が不要な場合は、mapの代わりにforeachを使用してください。たとえば、foreach(println, array)の場合です。
Examples
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 cBase.map — Function
map(f, A::AbstractArray...) -> N-array同じndimsの多次元配列に対して処理を行う場合、すべての配列のaxesが同じでなければならず、結果も同じになります。
サイズが一致しない場合に使えるbroadcastも参照してください。
Examples
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)) # iterates until 3rd is exhausted
3-element Vector{Float64}:
2.0
13.0
102.0map(f, c...) -> collectionコレクション c の各要素に f を適用して変換します。複数のコレクションを引数に指定した場合は、f を要素ごとに適用し、いずれかのコレクションの要素がなくなった時点で処理を終了します。
結果の要素型は、collect と同じ方法で決定されます。
関連項目: map!、foreach、mapreduce、mapslices、zip、Iterators.map。
Examples
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
33Base.map! — Function
map!(f, values(dict::AbstractDict))dictを変更し、各値をvalからf(val)へ変換します。dictの型は変更できない点に注意してください。f(val)がdictの値型のインスタンスでない場合、可能であれば値型に変換され、変換できなければエラーが発生します。
Examples
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
1map!(function, array)mapと同様ですが、結果は同じ配列に格納されます。
このメソッドを使用するには、Julia 1.12以降が必要です。以前のバージョンにも対応するには、同等のmap!(function, array, array)を使用してください。
Examples
julia> a = [1 2 3; 4 5 6];
julia> map!(x -> x^3, a);
julia> a
2×3 Matrix{Int64}:
1 8 27
64 125 216map!(function, destination, collection...)mapと同様ですが、新しいコレクションではなくdestinationに結果を格納します。destinationは、最小のコレクション以上の大きさでなければなりません。
関連項目: map、foreach、zip、copyto!。
Examples
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
0Base.mapreduce — Method
mapreduce(f, op, itrs...; [init])itrs の各要素に f を適用し、その結果を二項関数 op で畳み込みます。init を指定する場合、それは op の単位元でなければならず、空のコレクションに対して返されます。空でないコレクションで init が使われるかどうかは未規定です。一般に、空のコレクションを扱うには init を指定する必要があります。
mapreduce は reduce(op, map(f, itr); init=init) を呼び出すのと機能的に同等ですが、中間コレクションを作成する必要がないため、一般により高速に実行されます。reduce および map のドキュメントも参照してください。
Examples
julia> mapreduce(x->x^2, +, [1:3;]) # == 1 + 4 + 9
14畳み込みの結合順序は実装に依存します。また、実装によっては、itr 内に複数回現れる要素に対して、f の戻り値を再利用する場合があります。左結合または右結合を保証し、すべての値に対して f が呼び出されるようにするには、代わりに mapfoldl または mapfoldr を使用してください。
Base.mapfoldl — Method
mapfoldl(f, op, itr; [init])mapreduceと同様ですが、foldlのように、左結合性が保証されます。指定した場合、キーワード引数initは1回だけ使用されます。一般に、空のコレクションで動作させるにはinitを指定する必要があります。
Base.mapfoldr — Method
mapfoldr(f, op, itr; [init])mapreduceと同様ですが、foldrのように、右結合性が保証されます。キーワード引数initが指定されている場合、これはちょうど1回使用されます。一般に、空のコレクションを扱うにはinitを指定する必要があります。
Base.first — Function
first(s::AbstractString, n::Integer)sの先頭からn文字を取り出した文字列を取得します。
Examples
julia> first("∀ϵ≠0: ϵ²>0", 0)
""
julia> first("∀ϵ≠0: ϵ²>0", 1)
"∀"
julia> first("∀ϵ≠0: ϵ²>0", 3)
"∀ϵ≠"first(itr, n::Integer)反復可能なコレクション itr の先頭から n 個の要素を取得します。ただし、itr の長さが足りない場合は、取得できる要素数だけを返します。
関連項目: startswith、Iterators.take。
Examples
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(coll)反復可能なコレクションの最初の要素を取得します。AbstractRangeが空の場合でも、その開始点を返します。
関連項目: only、firstindex、last。
Examples
julia> first(2:2:10)
2
julia> first([1; 2; 3; 4])
1Base.last — Function
last(s::AbstractString, n::Integer)s の末尾 n 文字からなる文字列を取得します。
Examples
julia> last("∀ϵ≠0: ϵ²>0", 0)
""
julia> last("∀ϵ≠0: ϵ²>0", 1)
"0"
julia> last("∀ϵ≠0: ϵ²>0", 3)
"²>0"last(itr, n::Integer)反復可能なコレクションitrの末尾からn個の要素を取得します。itrの長さが足りない場合は、取得できる分だけ返します。
Examples
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(coll)O(1) 時間で計算できる場合、順序付きコレクションの最後の要素を取得します。これは、最後のインデックスを取得するために lastindex を呼び出すことで実現します。空であっても、AbstractRange の終点を返します。
Examples
julia> last(1:2:10)
9
julia> last([1; 2; 3; 4])
4Base.front — Function
front(x::Tuple)::TupleTupleは、xの最後の要素を除いたものです。
Examples
julia> Base.front((1,2,3))
(1, 2)
julia> Base.front(())
ERROR: ArgumentError: Cannot call front on an empty tuple.Base.step — Function
step(r)AbstractRange オブジェクトのステップサイズを取得します。
Examples
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.1Base.collect — Method
collect(iterator)コレクションまたはイテレータのすべての要素を含むArrayを返します。辞書の場合は、Vectorのkey=>value Pairを返します。引数が配列のようなオブジェクトであるか、HasShapeトレイトを持つイテレータである場合、結果は引数と同じ形状および次元数になります。
comprehensionsがgenerator expressionをArrayに変換するために使用します。そのため、ジェネレータでは、collectを呼び出す代わりに角括弧表記を使用できます。2つ目の例を参照してください。
返される配列の要素型は、収集された値の型に基づきます。ただし、イテレータが空の場合、返される(空の)配列の要素型は型推論によって決まります。
Examples
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結果の型が型推論に依存する、空のイテレータからの収集:
julia> [rand(Bool) ? 1 : missing for _ in []]
Union{Missing, Int64}[]イテレータが空でない場合、結果の型は値のみによって決まります。
julia> [rand(Bool) ? 1 : missing for _ in [""]]
1-element Vector{Int64}:
1Base.collect — Method
collect(element_type, collection)コレクションまたはイテラブル内のすべての要素を、指定した要素型の Array に変換して返します。結果の形状と次元数は collection と同じです。
Examples
julia> collect(Float64, 1:2:5)
3-element Vector{Float64}:
1.0
3.0
5.0Base.filter — Function
filter(f, itr::SkipMissing{<:AbstractArray})指定されたSkipMissingイテレータでラップされた配列に似たベクトルを返します。ただし、欠損値と、fがfalseを返す要素はすべて除外されます。
Examples
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}:
1filter(f, d::AbstractDict)d のコピーを返します。ただし、f が false である要素は削除します。関数 f には、key=>value のペアを渡します。
Examples
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)f を filter で使って引数をフィルタリングする関数を作成します。つまり、x -> filter(f, x) と同等の関数です。
返される関数の型は Base.Fix1{typeof(filter)} で、これを使って特化したメソッドを実装できます。
Examples
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, a)aから、fがfalseである要素を取り除いたコレクションのコピーを返します。この関数fには、引数を1つ渡します。
関連項目: filter!、Iterators.filter。
Examples
julia> a = 1:10
1:10
julia> filter(isodd, a)
5-element Vector{Int64}:
1
3
5
7
9Base.filter! — Function
filter!(f, d::AbstractDict)dを更新し、fがfalseである要素を削除します。関数fには、key=>valueのペアを渡します。
Examples
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"filter!(f, a)a コレクションを更新し、f が false である要素を削除します。この関数 f には、引数を1つ渡します。
Examples
julia> filter!(isodd, Vector(1:10))
5-element Vector{Int64}:
1
3
5
7
9Base.replace — Method
replace(A, old_new::Pair...; [count::Integer])old_new 内の各 old=>new について、A のすべての old を new に置き換えたコレクションのコピーを返します。等価性の判定には isequal を使用します。count が指定されている場合、置換されるのは合計で最大 count 個です。
結果の要素型は、A の要素型と、ペア内の new の値の型に基づく型昇格(promote_type を参照)によって決まります。count が省略され、A の要素型が Union の場合、異なる型の値に置き換えられるシングルトン型は、結果の要素型に含まれません。たとえば、missing が置き換えられると、Union{T,Missing} は T になります。
関連項目: replace!、splice!、delete!、insert!。
Examples
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
0Base.replace — Method
replace(new::Union{Function, Type}, A; [count::Integer])A のコピーを返します。このコピーでは、A 内の各 x を new(x) に置き換えます。count が指定されている場合、置き換える値の合計は最大 count 個です(置き換えとは new(x) !== x と定義されます)。
Examples
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 => 3Base.replace! — Function
replace!(new::Union{Function, Type}, A; [count::Integer])コレクション A 内の各要素 x を new(x) に置き換えます。count が指定されている場合、置き換える値の合計は最大 count 個です(置き換えとは new(x) !== x と定義されます)。
Examples
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
12replace!(A, old_new::Pair...; [count::Integer])old_new 内の各ペア old=>new について、コレクション A 内にあるすべての old を new に置き換えます。等値性は isequal を使用して判定します。count を指定した場合、置換する出現箇所は合計で最大 count 個となります。replace も参照してください。
Examples
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
3Base.rest — Function
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 のように末尾に置かれた slurping in assignments の動作をカスタマイズできます。
関連項目: first, Iterators.rest, Base.split_rest。
Examples
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 — Function
Base.split_rest(collection, n::Int[, itr_state]) -> (rest_but_n, last_n)collection の末尾を、特定の反復状態 itr_state から分割する汎用関数です。2つの新しいコレクションからなるタプルを返します。1つ目には、末尾の要素のうち最後の n 個を除いたすべてが含まれ、除かれた要素は2つ目のコレクションに格納されます。
1つ目のコレクションの型は、通常 Base.rest の型に従います。ただし、フォールバックの場合は遅延評価されず、ベクターに即時収集されます。
ユーザー定義のコレクション型でオーバーロードすることで、slurping in assignments が末尾以外の位置にある場合の動作(たとえば a, b..., c = collection)をカスタマイズできます。
関連項目: Base.rest。
Examples
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]))Indexable Collections
Base.getindex — Function
getindex(collection, key...)コレクション内の指定したキーまたはインデックスに格納されている値を取得します。構文 a[i,j,...] は、コンパイラーによって getindex(a, i, j, ...) に変換されます。
Examples
julia> A = Dict("a" => 1, "b" => 2)
Dict{String, Int64} with 2 entries:
"b" => 2
"a" => 1
julia> getindex(A, "a")
1Base.setindex! — Function
setindex!(collection, value, key...)指定した値を、コレクション内の指定したキーまたはインデックスに格納します。構文 a[i,j,...] = x は、コンパイラーによって (setindex!(a, x, i, j, ...); x) に変換されます。
Examples
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" => 1Base.firstindex — Function
firstindex(collection)::Integer
firstindex(collection, d)::Integercollectionの最初のインデックスを返します。dが指定されている場合は、次元dに沿ったcollectionの最初のインデックスを返します。
構文A[begin]およびA[1, begin]は、それぞれA[firstindex(A)]およびA[1, firstindex(A, 2)]に変換されます。
関連項目: first、axes、lastindex、nextind。
Examples
julia> firstindex([1,2,4])
1
julia> firstindex(rand(3,4,5), 2)
1Base.lastindex — Function
lastindex(collection)::Integer
lastindex(collection, d)::Integercollectionの最後のインデックスを返します。dが指定されている場合は、次元dに沿ったcollectionの最後のインデックスを返します。
構文A[end]およびA[end, end]は、それぞれA[lastindex(A)]およびA[lastindex(A, 1), lastindex(A, 2)]に展開されます。
関連項目: axes、firstindex、eachindex、prevind。
Examples
julia> lastindex([1,2,4])
3
julia> lastindex(rand(3,4,5), 2)
4完全に実装されているもの:
ArrayBitArrayAbstractArraySubArray
部分的に実装されているもの:
Dictionaries
Dict は標準の辞書です。その実装では、キーのハッシュ関数として hash を、等価性の判定に isequal を使用します。ハッシュテーブルでのカスタム型の格納方法を変更するには、これら2つの関数を定義してください。
IdDict は、キーが常にオブジェクトの同一性である特殊なハッシュテーブルです。
WeakKeyDict は、キーとしてオブジェクトへの弱参照を使用するハッシュテーブルの実装です。そのため、ハッシュテーブルから参照されていても、オブジェクトはガベージコレクションの対象になることがあります。Dict と同様に、ハッシュには hash を、等価性の判定には isequal を使用します。一方、Dict とは異なり、挿入時にキーを変換しません。
Dict は、=> で構築したペアオブジェクトを Dict コンストラクターに渡すことで作成できます: Dict("A"=>1, "B"=>2)。この呼び出しでは、キーと値から型情報を推論しようとします(つまり、この例では Dict{String, Int64} が作成されます)。型を明示的に指定するには、Dict{KeyType,ValueType}(...) の構文を使用します。たとえば、Dict{String,Int32}("A"=>1, "B"=>2) のようにします。
辞書はジェネレーターを使って作成することもできます。たとえば、Dict(i => f(i) for i = 1:10) のようにします。
辞書 D に対して、構文 D[x] は、キー x の値を返します(キーが存在する場合)。存在しない場合はエラーをスローします。また、D[x] = y は、キーと値のペア x => y を D に格納します(キー x に既存の値があれば置き換えます)。D[...] に複数の引数を渡すと、それらはタプルに変換されます。たとえば、構文 D[x,y] は D[(x,y)] と同等であり、タプル (x,y) をキーとする値を参照します。
Base.AbstractDict — Type
AbstractDict{K, V}キーの型がK、値の型がVである、辞書のような型のスーパータイプです。Dict、IdDictなどの型は、この型のサブタイプです。AbstractDict{K, V}は、Pair{K, V}のイテレーターである必要があります。
Base.Dict — Type
Dict([itr])Dict{K,V}() は、キーの型が K、値の型が V のハッシュテーブルを構築します。キーの比較には isequal を、ハッシュ値の計算には hash を使用します。
反復可能な引数を1つ指定すると、その引数が生成する2要素タプル (key,value) からキーと値のペアを取り出し、Dict を構築します。
Examples
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キーは変更可能でも構いませんが、格納済みのキーを変更すると、ハッシュテーブルの内部整合性が損なわれ、Dict が正しく動作しなくなることがあります。キーを変更する必要がある場合は、代わりに IdDict を使用できます。
Base.IdDict — Type
IdDict([itr])IdDict{K,V}() は、objectid をハッシュ関数、=== を等価性判定として、キーの型が K、値の型が V のハッシュテーブルを構築します。詳しくは Dict を参照してください。また、集合版については IdSet を参照してください。
以下の例では、Dict のキーはすべて isequal であるため、同じハッシュ値になり、上書きされます。一方、IdDict はオブジェクト ID に基づいてハッシュ化するため、3 つの異なるキーが保持されます。
Examples
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"Base.WeakKeyDict — Type
WeakKeyDict([itr])WeakKeyDict()は、ハッシュテーブル内で参照されていてもガベージコレクションの対象となり得るオブジェクトへの弱参照をキーとするハッシュテーブルを構築します。
詳しくはDictを参照してください。なお、Dictとは異なり、WeakKeyDictは挿入時にキーを変換しません。変換すると、挿入前にはキーオブジェクトがどこからも参照されていなかったことを意味してしまうためです。
WeakRefも参照してください。
Base.ImmutableDict — Type
ImmutableDictImmutableDictは、不変の連結リストとして実装された辞書です。個別の挿入を何度も行って構築する小さな辞書に最適です。値を削除することはできませんが、同じキーで新しい値を挿入すれば、既存の値を部分的に上書きして隠すことができます。
ImmutableDict(KV::Pair)ImmutableDictにkey => valueのペアを新しく追加します。
- この組み合わせがプロパティセットに含まれているかどうかを確認するには、
(key => value) in dictを使います。 - 特定のキーに対応する最新の値を取得するには、
get(dict, key, default)を使います。
Base.PersistentDict — Type
PersistentDictPersistentDict は、ハッシュ配列マップトライとして実装された辞書です。永続性が必要な場合に最適で、各操作は以前の辞書とは別の新しい辞書を返します。一方、内部実装はメモリ効率に優れており、複数の独立した辞書間でストレージを共有できる場合があります。
PersistentDict(KV::Pair)Examples
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 => 2Base.haskey — Function
haskey(collection, key)::Boolコレクションに、指定した key に対応するマッピングがあるかどうかを判定します。
Examples
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')
falseBase.get — Function
get(f::Union{Function, Type}, collection, key)指定したキーに対応する値を返します。キーに対応するマッピングがない場合は、f()を返します。デフォルト値も辞書に保存するには、get!を使用してください。
これは、doブロック構文で呼び出すことを想定しています。
get(dict, key) do
# default value calculated here
time()
endget(collection, key, default)指定したキーに対応する値を返します。キーに対応するマッピングが存在しない場合は、指定したデフォルト値を返します。
Examples
julia> d = Dict("a"=>1, "b"=>2);
julia> get(d, "a", 3)
1
julia> get(d, "c", 3)
3Base.get! — Function
get!(f::Union{Function, Type}, collection, key)指定したキーに対応する値を返します。キーに対応するマッピングが存在しない場合は、key => f()を格納し、f()を返します。
これは、doブロック構文で呼び出すことを想定しています。
Examples
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 => 4get!(collection, key, default)指定されたキーに対応する値を返します。キーに対応するマッピングが存在しない場合は、key => defaultを格納して、defaultを返します。
Examples
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" => 4Base.getkey — Function
getkey(collection, key, default)key に一致する引数が collection に存在する場合は、そのキーを返します。存在しない場合は、default を返します。
Examples
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)Base.delete! — Function
delete!(collection, key)コレクション内に指定したキーのマッピングがあれば削除し、コレクションを返します。
Examples
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 is left unchanged
Dict{String, Int64} with 1 entry:
"a" => 1Base.pop! — Method
pop!(collection, key[, default])collection に key が存在する場合は、そのマッピングを削除して返します。存在しない場合は default を返します。default が指定されていない場合は、エラーをスローします。
Examples
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)
4Base.values — Function
values(a::AbstractDict)コレクション内のすべての値を反復処理するイテレーターを返します。collect(values(a))は値の配列を返します。Dictのように値がハッシュテーブルに内部保存されている場合、返される順序は変わることがあります。一方、keys(a)、values(a)、pairs(a)はいずれもaを反復処理し、同じ順序で要素を返します。
Examples
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
3values(iterator)キーと値を持つイテレータまたはコレクションの場合、値を反復するイテレータを返します。一般的なイテレータの要素は通常「値」とみなされるため、デフォルトでは引数をそのまま返します。
Examples
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}:
2Base.pairs — Function
pairs(collection)キーの集合を値の集合に対応付ける任意のコレクションについて、key => value ペアを返すイテレーターです。配列もこれに含まれ、配列のキーはインデックスです。Dict のように、エントリーが内部的にハッシュテーブルに格納されている場合、返される順序は変わることがあります。一方、keys(a)、values(a)、pairs(a) はいずれも a を反復処理し、同じ順序で要素を返します。
Examples
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
3pairs(IndexLinear(), A)
pairs(IndexCartesian(), A)
pairs(IndexStyle(A), A)配列 A の各要素にアクセスし、i => x を返すイテレータです。ここで、i は要素のインデックス、x = A[i] です。pairs(A) と同じですが、インデックスの形式を選択できます。また、enumerate(A) とも似ていますが、i は A の有効なインデックスになる一方、enumerate は A のインデックスにかかわらず、常に 1 から数えます。
IndexLinear() を指定すると、i が整数になります。IndexCartesian() を指定すると、i は Base.CartesianIndex になります。IndexStyle(A) を指定すると、配列 A に対してネイティブなインデックス形式として定義されている形式が選択されます。
基になる配列の境界を変更すると、このイテレータは無効になります。
Examples
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。
Base.merge — Function
merge(initial::StyledStrings.Face, others::StyledStrings.Face...)initial フェイスと others フェイスのプロパティをマージします。後に指定されたフェイスのプロパティが優先されます。
複数のフェイスのスタイルを組み合わせたり、継承を解決したりするために使用します。
merge(a::NamedTuple, iterable)キーと値のペアの反復可能オブジェクトを名前付きタプルとして解釈し、マージを行います。
julia> merge((a=1, b=2, c=3), [:b=>4, :d=>5])
(a = 1, b = 4, c = 3, d = 5)merge(a::NamedTuple, bs::NamedTuple...)2つ以上の既存の名前付きタプルを左結合でマージし、新しい名前付きタプルを作成します。マージは名前付きタプルのペアごとに左から右へ進みます。そのため、最左の名前付きタプルと最右の名前付きタプルの両方に存在するフィールドは、最左の名前付きタプルでの位置を保ちます。ただし、値には、そのフィールドを含む最右の名前付きタプルのものが使われます。ペアの右側の名前付きタプルにのみ存在するフィールドは末尾に追加されます。名前付きタプルが1つだけ指定された場合に備えて、次のシグネチャを持つフォールバックが実装されています。merge(a::NamedTuple)
Examples
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(d::AbstractDict, others::AbstractDict...)指定されたコレクションを結合して、新しいコレクションを作成します。必要に応じて、結合後のコレクションの型は、結合するコレクションの型に対応できるように昇格されます。同じキーが別のコレクションにも存在する場合、そのキーの値には、最後に指定されたコレクションの値が使われます。同じキーを持つ値をカスタム処理する方法については、mergewithも参照してください。
Examples
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.0Base.mergewith — Function
mergewith(combine, d::AbstractDict, others::AbstractDict...)
mergewith(combine)指定されたコレクションから、結合したコレクションを構築します。必要に応じて、結合後のコレクションの型は、結合するコレクションの型に対応できるように昇格されます。同じキーを持つ値は、結合関数を使ってまとめられます。カリー化形式の mergewith(combine) は、関数 (args...) -> mergewith(combine, args...) を返します。
Examples
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
julia> mergewith(-, Dict(), Dict(:a=>1)) # Combining function only used if key is present in both
Dict{Any, Any} with 1 entry:
:a => 1Base.merge! — Function
merge!(d::AbstractDict, others::AbstractDict...)他のコレクションのペアでコレクションを更新します。mergeも参照してください。
Examples
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 => 4Base.mergewith! — Function
mergewith!(combine, d::AbstractDict, others::AbstractDict...) -> d
mergewith!(combine)
merge!(combine, d::AbstractDict, others::AbstractDict...) -> d他のコレクションのペアを使ってコレクションを更新します。同じキーを持つ値は、結合関数を使って結合されます。カリー化形式のmergewith!(combine)は、関数(args...) -> mergewith!(combine, args...)を返します。
mergewith!(combine, args...)の別名であるメソッドmerge!(combine::Union{Function,Type}, args...)は、後方互換性のため引き続き利用できます。
Examples
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 => 4Base.sizehint! — Function
sizehint!(s, n; first::Bool=false, shrink::Bool=true) -> sコレクション s に、少なくとも n 個の要素を格納できる容量を確保します。つまり、s に多数の値を追加する予定がある場合、あらかじめ一度に容量を確保しておけば、段階的な再割り当てのコストを避けられ、パフォーマンスが向上することがあります。
first が true の場合、追加の領域はコレクションの先頭より前に確保されます。これにより、後続の pushfirst! の呼び出しは、push! の呼び出しより高速になることがあります。このキーワードを指定すると、コレクションが順序付けられていない場合や、このコレクションで pushfirst! がサポートされていない場合にエラーになることがあります。
shrink=true(デフォルト)の場合、現在の容量が n より大きければ、コレクションの容量が縮小されることがあります。
resize! も参照してください。
Notes on the performance model
sizehint! をサポートする型では、次のようになります。
push!メソッドとappend!メソッドは、一般に追加の領域を事前確保することがあります(必須ではありません)。Baseで実装された型では、通常、汎用的な用途に最適化されたヒューリスティックを使って事前確保します。sizehint!で、この事前確保を制御できることがあります。Baseの型では、通常、この方法で制御できます。- この種の事前確保をサポートする型では、
empty!のコストはほぼゼロ(O(1))です。
Base.keytype — Function
keytype(T::Type{<:AbstractArray})
keytype(A::AbstractArray)配列のキー型を返します。これは keys(...) の結果の eltype と等しく、主に辞書インターフェースとの互換性のために用意されています。
Examples
julia> keytype([1, 2, 3]) == Int
true
julia> keytype([1 2; 3 4])
CartesianIndex{2}Base.valtype — Function
valtype(T::Type{<:AbstractArray})
valtype(A::AbstractArray)配列の値の型を返します。これはeltypeと同じで、主に辞書インターフェースとの互換性のために用意されています。
Examples
julia> valtype(["one", "two", "three"])
String完全に実装されているもの:
部分的に実装されているもの:
Set-Like Collections
Base.AbstractSet — Type
Base.Set — Type
Set{T} <: AbstractSet{T}Setは、メンバーシップを高速に判定できる可変コンテナーです。
Setでは、in、union、intersectなどの集合演算が効率的に実装されています。Set内の要素は、各要素のisequalの定義に従って一意です。Set内の要素の順序は実装の詳細であり、依存することはできません。
関連項目: AbstractSet、BitSet、Dict、push!、empty!、union!、in、isequal
Examples
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
trueBase.BitSet — Type
BitSet([itr])指定された反復可能オブジェクトから生成されるIntのソート済み集合を構築します。反復可能オブジェクトが空の場合は、空の集合を返します。ビット文字列として実装されているため、整数が密に並ぶ集合向けです。集合が疎になる場合(たとえば、非常に大きな整数を少数だけ含む場合)は、代わりにSetを使用してください。
Base.IdSet — Type
IdSet{T}([itr])
IdSet()IdSet{T}() は、型 T の値を === で等しいとみなして集合を構築します(Set)。
以下の例では、値はすべて isequal なので、通常の Set では上書きされます。IdSet は === で比較するため、3つの異なる値が保持されます。
Examples
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
trueBase.union — Function
union(s, itrs...)
∪(s, itrs...)すべての引数に含まれる、重複のない要素をすべて含むオブジェクトを構築します。
最初の引数によって、返されるコンテナーの種類が決まります。配列の場合は、各要素が最初に現れた順序が保たれます。
Unicode ∪ は、Julia REPL や多くのエディターで \cup と入力してから Tab キーを押すと入力できます。これは中置演算子であり、s ∪ itr を可能にします。
関連項目: unique、intersect、isdisjoint、vcat、Iterators.flatten。
Examples
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
1Base.union! — Function
union!(s::Union{AbstractSet,AbstractVector}, itrs...)渡された集合のunionを構築し、その結果でsを上書きします。配列を使って順序を維持してください。
Examples
julia> a = Set([3, 4, 5]);
julia> union!(a, 1:2:7);
julia> a
Set{Int64} with 5 elements:
5
4
7
3
1union!(s::IntDisjointSet{T}, x::T, y::T)xを含む部分集合と、yを含む部分集合をマージし、新しい集合のルートを返します。
Base.intersect — Function
intersect(s, itrs...)
∩(s, itrs...)すべての引数に含まれる要素からなる集合を構築します。
返されるコンテナーの種類は、最初の引数によって決まります。最初の引数が配列の場合、要素が最初に現れた順序が保たれます。
Unicode ∩ は、Julia REPL や多くのエディターで \cap と入力して Tab キーを押すと入力できます。これは中置演算子であり、s ∩ itr を可能にします。
関連項目: setdiff、isdisjoint、issubset、issetequal。
Examples
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.0Base.setdiff — Function
setdiff(s, itrs...)s に含まれ、itrs のいずれの反復可能オブジェクトにも含まれない要素からなる集合を構築します。配列を使うと、順序が維持されます。結果の要素型は s と同じになります。
関連項目: setdiff!、union、intersect。
Examples
julia> setdiff([1,2,3], [3,4,5])
2-element Vector{Int64}:
1
2
julia> setdiff([1,2,3], [1.0, 2.0])
1-element Vector{Int64}:
3Base.setdiff! — Function
setdiff!(s, itrs...)s から、itrs 内の各反復可能オブジェクトの要素をそれぞれ削除します(インプレース)。
Examples
julia> a = Set([1, 3, 4, 5]);
julia> setdiff!(a, 1:2:6);
julia> a
Set{Int64} with 1 element:
4Base.symdiff! — Function
symdiff!(s::Union{AbstractSet,AbstractVector}, itrs...)渡された集合の対称差を構築し、その結果でsを上書きします。sが配列の場合、順序は維持されます。この場合、要素の多重度が重要になる点に注意してください。
Base.intersect! — Function
intersect!(s::Union{AbstractSet,AbstractVector}, itrs...)渡されたすべての集合の共通部分を求め、その結果でsを上書きします。配列では順序を維持します。
Base.in! — Function
in!(x, s::AbstractSet)::Boolx が s に含まれている場合は、true を返します。含まれていない場合は、x を s にプッシュし、false を返します。これは in(x, s) ? true : (push!(s, x); false) と同等ですが、より効率的に実装できる場合があります。
Examples
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
1Base.issetequal — Function
issetequal(x)引数を x と比較する関数を、issetequal を使って作成します。つまり、y -> issetequal(y, x) と同等の関数です。返される関数の型は Base.Fix2{typeof(issetequal)} で、これを使って特化したメソッドを実装できます。
issetequal(a, b)::Boolaとbの要素が同じかどうかを判定します。可能な場合は、a ⊆ b && b ⊆ aと同等の処理をより効率的に行います。
関連項目:isdisjoint、union。
Examples
julia> issetequal([1, 2], [1, 2, 3])
false
julia> issetequal([1, 2], [2, 1])
trueBase.isdisjoint — Function
isdisjoint(x)引数を x と比較する関数を、isdisjoint を使って作成します。つまり、y -> isdisjoint(y, x) と同等の関数です。返される関数の型は Base.Fix2{typeof(isdisjoint)} で、これを使って特化したメソッドを実装できます。
isdisjoint(a, b)::Boolコレクション a と b が互いに素かどうかを判定します。isempty(a ∩ b) と同等ですが、可能な場合はこちらのほうが効率的です。
関連項目: intersect、isempty、issetequal。
Examples
julia> isdisjoint([1, 2], [2, 3, 4])
false
julia> isdisjoint([3, 1], [2, 4])
true完全に実装されているもの:
部分的に実装されているもの:
Deques
Base.push! — Function
push!(collection, items...) -> collectioncollection に、1つ以上の items を挿入します。collection が順序付きコンテナの場合、要素は指定された順序で末尾に挿入されます。
Examples
julia> push!([1, 2, 3], 4, 5, 6)
6-element Vector{Int64}:
1
2
3
4
5
6collection が順序付きの場合は、append! を使って、別のコレクションのすべての要素を追加します。先ほどの例の結果は、append!([1, 2, 3], [4, 5, 6]) と同等です。AbstractSet オブジェクトには、代わりに union! を使用できます。
パフォーマンスモデルについては、sizehint! を参照してください。
pushfirst! も参照してください。
Base.pop! — Function
pop!(collection, key[, default])collection に key が存在する場合は、そのマッピングを削除して返します。存在しない場合は default を返します。default が指定されていない場合は、エラーをスローします。
Examples
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)
4pop!(collection) -> itemcollectionから要素を1つ取り除いて返します。collectionが順序付きコンテナの場合は最後の要素を返し、順序なしコンテナの場合は任意の要素を返します。
関連項目: popfirst!、popat!、delete!、deleteat!、splice!、push!。
Examples
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 => 2Base.popat! — Function
popat!(a::Vector, i::Integer, [default])指定されたiの位置にある要素を削除して返します。後続の要素は、空いた位置を埋めるように移動します。aに対してiが有効なインデックスでない場合、defaultが指定されていなければエラーをスローし、指定されていればdefaultを返します。
関連項目: pop!、popfirst!、deleteat!、splice!。
Examples
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]
[...]Base.pushfirst! — Function
pushfirst!(collection, items...) -> collectioncollectionの先頭に、1つ以上のitemsを挿入します。
この関数は、ほかの多くのプログラミング言語ではunshiftと呼ばれます。
Examples
julia> pushfirst!([1, 2, 3, 4], 5, 6)
6-element Vector{Int64}:
5
6
1
2
3
4Base.popfirst! — Function
popfirst!(collection) -> itemcollection から最初の item を削除します。
この関数は、ほかの多くのプログラミング言語では shift と呼ばれます。
Examples
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
6Base.deleteat! — Function
deleteat!(a::Vector, inds)indsで指定されたインデックスの要素を削除し、変更後のaを返します。後続の要素は、空いた位置を埋めるように詰められます。
indsには、ソート済みで重複のない整数インデックスのイテレーターまたはコレクションを指定できます。または、aと同じ長さのブールベクトルを指定し、trueで削除する要素を示すこともできます。
Examples
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:
[...]deleteat!(a::Vector, i::Integer)指定したiの要素を削除し、変更後のaを返します。後続の要素は、空いた位置を埋めるように移動します。
関連項目: keepat!、delete!、popat!、splice!。
Examples
julia> deleteat!([6, 5, 4, 3, 2, 1], 2)
5-element Vector{Int64}:
6
4
3
2
1Base.keepat! — Function
keepat!(a::Vector, m::AbstractVector{Bool})
keepat!(a::BitVector, m::AbstractVector{Bool})論理インデックス指定のインプレース版 a = a[m] です。つまり、同じ長さのベクトル a と m に対して keepat!(a, m) を実行すると、対応するインデックスの m が false である要素が a からすべて削除されます。
Examples
julia> a = [:a, :b, :c];
julia> keepat!(a, [true, false, true])
2-element Vector{Symbol}:
:a
:c
julia> a
2-element Vector{Symbol}:
:a
:ckeepat!(a::Vector, inds)
keepat!(a::BitVector, inds)indsで指定されていないすべてのインデックスの要素を削除し、変更後のaを返します。残された要素は、できた隙間を埋めるように移動します。
indsは、昇順に並んだ重複のない整数インデックスのイテレーターでなければなりません。deleteat!も参照してください。
Examples
julia> keepat!([6, 5, 4, 3, 2, 1], 1:2:5)
3-element Vector{Int64}:
6
4
2Base.splice! — Function
splice!(a::Vector, indices, [replacement]) -> items指定したインデックスの要素を削除し、削除した要素を含むコレクションを返します。後続の要素は左に詰められ、空いた位置を埋めます。指定した場合は、順序付きコレクションの置換値が削除した要素の位置に挿入されます。この場合、indices は AbstractUnitRange でなければなりません。
要素を削除せずに、インデックス n の前に replacement を挿入するには、splice!(collection, n:n-1, replacement) を使用します。
Examples
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
-1splice!(a::Vector, index::Integer, [replacement]) -> item指定したインデックスの項目を削除し、削除した項目を返します。後続の項目は左に詰められ、空いた位置を埋めます。指定した場合は、順序付きコレクションの置換値が、削除した項目の位置に挿入されます。
関連項目: replace、delete!、deleteat!、pop!、popat!。
Examples
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) を使用します。
Base.resize! — Function
resize!(a::Vector, n::Integer) -> aaの要素数をnに変更します。nが現在のコレクションの長さより小さい場合、先頭のn個の要素が保持されます。nが大きい場合、新しい要素が初期化されている保証はありません。
Examples
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
1Base.append! — Function
append!(collection, collections...) -> collection.順序付きコンテナ collection に、各 collections の要素を末尾に追加します。
Examples
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! も参照してください。
Base.prepend! — Function
prepend!(a::Vector, collections...) -> collection各 collections の要素を、a の先頭に挿入します。
collections で複数のコレクションを指定した場合、順序は維持されます。collections[1] の要素が a の最も左側に配置され、以降も同様です。
Examples
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完全に実装されているもの:
Utility Collections
Core.Pair — Type
Pair(x, y)
x => y型がPair{typeof(x), typeof(y)}のPairオブジェクトを構築します。要素はフィールドfirstおよびsecondに格納されます。反復処理によってアクセスすることもできます(ただし、ブロードキャスト演算ではPairは単一の「スカラー」として扱われます)。
関連項目:Dict。
Examples
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 — Type
Base.Pairs(values, keys) <: AbstractDict{eltype(keys), eltype(values)}インデックス可能なコンテナーを、同じデータを参照する辞書ビューに変換します。元データのキー空間を変更すると、このオブジェクトが無効になる場合があります。