コレクションとデータ構造

反復

逐次反復は iterate 関数で実装されます。一般的な for ループ

for i in iter   # または "for i = iter"
    # body
end

は、次のコードへ変換されます:

next = iterate(iter)
while next !== nothing
    (i, state) = next
    # body
    next = iterate(iter, state)
end

state オブジェクトは何でもよく、反復可能オブジェクトの型に合わせて適切なものを選択します。反復可能な型を独自に定義する方法について詳しくはマニュアルの反復インターフェースの節を参照してください。

このインターフェースは次の型で完全に実装されます:

AbstractRange
UnitRange
Tuple
Number
AbstractArray
BitSet
IdDict
Dict
WeakKeyDict
EachLine
AbstractString
Set
Pair
NamedTuple

`Base.iterate` ── 関数

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

反復子を進め、次の要素を取得します。要素が残っていないなら nothing を返すべきで、要素が存在するなら次の要素と新しい反復状態からなる二要素のタプルを返すべきです。

ソースコード

コンストラクタと型

`Base.AbstractRange` ── 型

AbstractRange{T}

T 型の要素を持つ区間を表す上位型です。UnitRange などを部分型に持ちます。

ソースコード

`Base.OrdinalRange` ── 型

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

T 型の要素と S 型の間隔を持つ順序付き区間を表す上位型です。T は oneunit(T) より小さい値が存在しない具象型で、間隔は必ず oneunit(T) の倍数である必要があります。例えば Integer や Date は T として使えますが、Float64 は (oneunit(Float64) より小さい Float64 型の値が存在するので) 使えません。UnitRange や StepRange を部分型に持ちます。

ソースコード

`Base.AbstractUnitRange` ── 型

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

T 型の要素と oneunit(T) の間隔を持つ区間を表す上位型です。UnitRange などを部分型に持ちます。

ソースコード

`Base.StepRange` ── 型

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

T 型の要素と S 型の間隔を持つ区間です。各要素間の間隔は定数で、区間は T 型の値 start と stop および S 型の値 step で定義されます。T または S を浮動小数点数型にすることはできません。整数 a, b, c (b > 1) に対する a:b:c は StepRange を作成します。

例

julia> collect(StepRange(1, Int8(2), 10))
5-element Array{Int64,1}:
 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` ── 型

UnitRange{T<:Real}

T 型の値 start と stop でパラメータ化される区間です。from から 1 ずつ増やしていって stop を超えるまでの値を表します。整数 a, b に対する a:b という構文は UnitRange を作成します。

例

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

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

ソースコード

`Base.LinRange` ── 型

LinRange{T}

start から stop まで等間隔に並ぶ len 個の要素からなる区間です。間隔のサイズは len で制御され、この値は Int である必要があります。

例

julia> LinRange(1.5, 5.5, 9)
9-element LinRange{Float64}:
 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 Array{Float64,1}:
 -0.1
  0.0
  0.1
  0.2
  0.3

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

ソースコード

コレクション

このインターフェースは次の型で完全に実装されます:

AbstractRange
UnitRange
Tuple
Number
AbstractArray
BitSet
IdDict
Dict
WeakKeyDict
AbstractString
Set
NamedTuple

`Base.isempty` ── 関数

isempty(collection) -> Bool

collection が空 (要素を持たない) かどうかを判定します。

例

julia> isempty([])
true

julia> isempty([1 2 3])
false

ソースコード

isempty(condition)

指定した条件を待っているタスクが無いなら true を返し、あるなら false を返します。

ソースコード

`Base.empty!` ── 関数

empty!(collection) -> 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}()

ソースコード

`Base.length` ── 関数

length(collection) -> Integer

collection の要素数を返します。

添え字アクセス可能なコレクションに対する最後の正当な添え字を取得するには lastindex を使ってください。

例

julia> length(1:5)
5

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

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

ソースコード

反復可能コレクション

`Base.in` ── 関数

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

item が collection に含まれるかどうかを判定します。ここで「含まれる」は「コレクションを反復して生成される値のいずれかと == になる」を意味します。基本的に Bool 型の値を返しますが、item が missing のとき、および collection が missing を含み item を含まないときは missing を返します (これは三値論理に従った振る舞いであり、any や == と同様です)。

一部のコレクションでは定義が少しだけ異なります。例えば Set では、要素のいずれかが item と isequal かどうかが判定されます。また Dict では key=>value の組が検索され、キーの比較には isequal が使われます。辞書のキーが存在するかどうかを判定するには k in keys(dict) または haskey を使ってください。Set と Dict に対する返り値は必ず Bool 型の値であり、missing は返りません。

要素がコレクションに存在しないことを判定するには ∉ を使ってください。!(a in b) とすれば in を否定でき、これは論理的に not in に近い命題を意味します。

in.(items, collection) あるいは items .∈ collection としてブロードキャストすると、item と collection 両方に関するブロードキャストが起きます。例えば両方の引数が (次元が同じ) ベクトルなら、item の各要素が collection の対応する位置にあるコレクションに含まれるかどうかを示すベクトルが計算されます。しかしこれが意図した動作でない場合はよくあります。items の各要素が collection に含まれるかどうかを示すベクトルを計算するには、in.(items, Ref(collection)) や items .∈ Ref(collection) のように右辺を Ref (またはタプル) でラップしてください。

例

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> !(21 in a)
true

julia> !(19 in a)
false

julia> [1, 2] .∈ [2, 3]
2-element BitArray{1}:
 0
 0

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

ソースコード

`Base.:∉` ── 関数

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

∈ および ∋ の否定です。item が collection に含まれないかどうかを判定します。

items .∉ collection でブロードキャストすると、item と collection 両方に関するブロードキャストが起きます。例えば両方の引数が (次元が同じ) ベクトルなら、item の各要素が collection の対応する位置にあるコレクションに含まれないかどうかを示すベクトルが計算されます。しかしこれが意図した動作でない場合はよくあります。items の各要素が collection に含まれないかどうかを示すベクトルを計算するには、items .∉ Ref(collection) のように右辺を Ref (またはタプル) でラップしてください。

例

julia> 1 ∉ 2:4
true

julia> 1 ∉ 1:3
false

julia> [1, 2] .∉ [2, 3]
2-element BitArray{1}:
 1
 1

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

ソースコード

`Base.eltype` ── 関数

eltype(type)

type 型のコレクションを反復したときに生成される要素の型を返します。辞書型に対しては Pair{KeyType,ValType} が返り値となります。利便性のため eltype(x) = eltype(typeof(x)) が定義されるので、型ではなくインスタンスを渡すこともできます。ただし新しい型に対しては型を引数に受け取る形式を定義するべきです。

例

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

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

ソースコード

`Base.indexin` ── 関数

indexin(a, b)

a の各要素の b における添え字からなる配列を返します。a のある要素が b に存在しないときは、出力の配列の対応する要素は nothing となります。

例

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

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

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

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

ソースコード

`Base.unique` ── 関数

unique(itr)

コレクション itr に含まれるユニークな要素だけからなる配列を返します。等価性は isequal で判定され、複数ある要素は最初にある要素だけが残されます。入力の要素型がそのまま出力の要素型となります。

例

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

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

ソースコード

unique(f, itr)

f を適用したときにユニークな値を返す itr の要素からなる配列を返します。

例

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

ソースコード

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 Array{Bool,1}:
 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

ソースコード

`Base.unique!` ── 関数

unique!(f, A::AbstractVector)

f を適用したときにユニークな値を返す要素だけが残るよう A を改変し、改変した A を返します。

Julia 1.1

このメソッドは Julia 1.1 以降で利用できます。

例

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

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

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

ソースコード

unique!(A::AbstractVector)

重複する要素を A から削除し、変更した A を返します。重複は isequal を使って判定され、A の要素は元々の順序が保たれます。返り値のデータの順番を気にしないなら、sort!(A); unique!(A) とすることで格段に速く重複要素の削除を行えます (ただし A がソートできる必要があります)。

例

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

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

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

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

julia> sort!(B);  # unique! はソートされたデータをずっと速く処理できる。

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

ソースコード

`Base.allunique` ── 関数

allunique(itr) -> Bool

itr が生成する値が全て異なるなら true を返します。比較は isequal で行われます。

例

julia> a = [1; 2; 3]
3-element Array{Int64,1}:
 1
 2
 3

julia> allunique([a, a])
false

ソースコード

`Base.reduce` ── メソッド

reduce(op, itr; [init])

二項演算 op を使ってコレクション itr を縮約します。初期値 init が指定されるなら、それは空のコレクションが返す op の単位元である必要があります。init が空でないコレクションで使われるかどうかは規定されません。

空のコレクションに対する値を計算するには基本的に init が必要です。ただし op が +, *, max, min, &, | のときは Julia が op の単位元を知っているので例外的に与えなくても構いません。

よく使われる演算を使った縮約は特殊な実装を持つことがあります。maximum(itr), minimum(itr), sum(itr), prod(itr), any(itr), all(itr) が使えるならそちらを使うべきです。

縮約が結合性を持って実行されるかどうかは実装依存です。これは - のような結合性を持たない演算子を使った縮約が行えないことを意味します。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

ソースコード

`Base.foldl` ── メソッド

foldl(op, itr; [init])

基本的に reduce と同様ですが、左からの連結性を保証して評価を行います。init が与えられると、その値は正確に一度だけ使われます。一般に、空のコレクションに対して正しい値を計算するには init を与える必要があります。

例

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

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

ソースコード

`Base.foldr` ── メソッド

foldr(op, itr; [init])

基本的に reduce と同様ですが、右からの連結性を保証して評価を行います。init が与えられると、その値は正確に一度だけ使われます。一般に、空のコレクションに対して正しい値を計算するには init を与える必要があります。

例

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

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

ソースコード

`Base.maximum` ── 関数

maximum(f, itr)

itr の各要素に f を適用した結果の最大値を返します。

例

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

ソースコード

maximum(itr)

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

例

julia> maximum(-20.5:10)
9.5

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

ソースコード

maximum(A::AbstractArray; dims)

dims 番目の次元に沿った配列の最大値を計算します。二つ以上の引数から最大値を取る max(a,b) 関数もあり、max.(a,b) とすれば配列に対して要素ごとに最大値を計算できます。

例

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

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

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

ソースコード

`Base.maximum!` ── 関数

maximum!(r, A)

r のシングルトン次元¹に関する A の最大値を計算し、結果を r に格納します。

例

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

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

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

ソースコード

`Base.minimum` ── 関数

minimum(f, itr)

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

例

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

ソースコード

minimum(itr)

コレクションの最小値を返します。

例

julia> minimum(-20.5:10)
-20.5

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

ソースコード

minimum(A::AbstractArray; dims)

dims 番目の次元に沿った配列 A の最小値を計算します。二つ以上の引数から最小値を取る min(a,b) 関数もあり、min.(a,b) とすれば配列に対して要素ごとに最小値を計算できます。

例

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

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

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

ソースコード

`Base.minimum!` ── 関数

minimum!(r, A)

r のシングルトン次元に関する A の最小値を計算し、結果を r に格納します。

例

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

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

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

ソースコード

`Base.extrema` ── 関数

extrema(itr) -> Tuple

itr の最小要素と最大要素を一度の走査で計算し、二要素のタプルとして返します。

例

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

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

ソースコード

extrema(f, itr) -> Tuple

itr の各要素に f を適用した結果の最小値と最大値を計算し、二要素のタプルとして返します。itr は一度だけ走査されます。

Julia 1.2

このメソッドは Julia 1.2 以降でサポートされます。

例

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

ソースコード

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

指定された次元に関する最小値と最大値を計算します。

例

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 を適用した結果の最小値と最大値を計算します。

Julia 1.2

このメソッドは Julia 1.2 以降でサポートされます。

ソースコード

`Base.argmax` ── 関数

argmax(itr) -> Integer

コレクションの最大要素の添え字を返します。最大要素が複数あるなら、その中で一番小さい添え字が返ります。

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

例

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 は他のどんな値よりも大きいものとして扱われます。

例

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

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

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

ソースコード

`Base.argmin` ── 関数

argmin(itr) -> Integer

コレクションの最小要素の添え字を返します。最小要素が複数あるなら、その中で一番小さい添え字を返します。

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

例

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 は他のどんな値よりも小さいものとして扱われます。

例

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

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

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

ソースコード

`Base.findmax` ── 関数

findmax(itr) -> (x, index)

コレクション itr の最大要素とその添え字を返します。最大要素が複数あるなら、最初のものを返します。itr に NaN が含まれるなら、NaN とその添え字が返ります。返り値は max と同様です。

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

例

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 は任意の値より大きいものとして扱われます。

例

julia> A = [1.0 2; 3 4]
2×2 Array{Float64,2}:
 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)])

ソースコード

`Base.findmin` ── 関数

findmin(itr) -> (x, index)

コレクション itr の最小要素とその添え字を返します。最小要素が複数あるなら、最初のものを返します。itr に NaN が含まれるなら、NaN とその添え字が返ります。返り値は min と同様です。

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

例

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

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

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

ソースコード

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

配列の入力に対して、指定された次元に関する最小値とその添え字を返します。NaN は任意の値より小さいものとして扱われます。

例

julia> A = [1.0 2; 3 4]
2×2 Array{Float64,2}:
 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)])

ソースコード

`Base.findmax!` ── 関数

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

rval と rind のシングルトン次元に関する A の最大値と対応する線形添え字を計算し、結果を rval と rind に保存します。NaN は任意の値より大きいものとして扱われます。

ソースコード

`Base.findmin!` ── 関数

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

rval と rind のシングルトン次元に関する A の最小値と対応する線形添え字を計算し、結果を rval と rind に保存します。NaN は任意の値より小さいものとして扱われます。

ソースコード

`Base.sum` ── 関数

sum(f, itr)

itr の各要素に f を適用した結果の和を返します。

返り値の型は、f を適用した結果が全てシステムのワードサイズより小さい符号付き整数なら Int となり、全てシステムのワードサイズより小さい符号無し整数なら UInt となります。それ以外の場合には f が返す値を昇格した型の値が返ります。

例

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 が結果となります。

ソースコード

sum(itr)

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

返り値の型は、コレクションの要素が全てシステムのワードサイズより小さい符号付き整数なら Int となり、全てシステムのワードサイズより小さい符号無し整数なら UInt となります。それ以外の場合にはコレクションの要素を昇格した型の値が返ります。

例

julia> sum(1:20)
210

ソースコード

sum(A::AbstractArray; dims)

指定した次元に関する配列の要素の和を計算します。

例

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

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

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

ソースコード

`Base.sum!` ── 関数

sum!(r, A)

r のシングルトン次元に関する A の要素の和を計算し、結果を r に格納します。

例

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

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

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

ソースコード

`Base.prod` ── 関数

prod(f, itr)

itr の各要素に対して f を適用した結果の積を返します。

例

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

ソースコード

prod(itr)

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

例

julia> prod(1:20)
2432902008176640000

ソースコード

prod(A::AbstractArray; dims)

指定された次元に関する配列要素の積を返します。

例

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

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

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

ソースコード

`Base.prod!` ── 関数

prod!(r, A)

r のシングルトン次元に関する A の要素の積を計算し、結果を r に格納します。

例

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

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

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

ソースコード

`Base.any` ── メソッド

any(itr) -> Bool

真偽値のコレクションが true を含むかどうかを判定します。itr から true が得られた時点で true を返します (短絡評価が行われます)。

入力に値 missing が含まれるときは、missing でない全ての値が false のとき (言い換えると、入力に true が含まれないとき) missing を返します。これは三値論理に従った振る舞いです。

例

julia> a = [true,false,false,true]
4-element Array{Bool,1}:
 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

ソースコード

`Base.any` ── メソッド

any(p, itr) -> Bool

述語 p が itr の要素のいずれかに対して true を返すかどうかを判定します。p が true となる itr の要素が見つかった時点で true を返します (短絡評価が行われます)。

p が返す値 missing が含まれるときは、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

ソースコード

`Base.any!` ── 関数

any!(r, A)

r のシングルトン次元に沿って A が true の要素を持つかどうかを判定し、結果を r に格納します。

例

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

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

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

ソースコード

`Base.all` ── メソッド

all(itr) -> Bool

真偽値のコレクションが全て true かどうかを判定します。itr から false が得られた時点で false を返します (短絡評価が行われます)。

入力に値 missing が含まれるときは、missing でない全ての値が true のとき (言い換えると、入力に false が含まれないとき) missing を返します。これは三値論理に従った振る舞いです。

例

julia> a = [true,false,false,true]
4-element Array{Bool,1}:
 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

ソースコード

`Base.all` ── メソッド

all(p, itr) -> Bool

述語 p が itr の要素の全てに対して true を返すかどうかを判定します。p が false となる itr の要素が見つかった時点で false を返します (短絡評価が行われます)。

p が返す値 missing が含まれるときは、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

ソースコード

`Base.all!` ── 関数

all!(r, A)

r のシングルトン次元に沿って A の要素が全て false かどうかを判定し、結果を r に格納します。

例

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

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

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

ソースコード

`Base.count` ── 関数

count(p, itr) -> Integer
count(itr) -> Integer

述語 p が true を返す itr の要素の個数を返します。p が与えられないなら、itr に含まれる true の個数を返します (このとき itr は真偽値の配列である必要があります)。

例

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

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

ソースコード

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

string に含まれる pattern とのマッチの個数を返します。length(findall(pattern, string)) と等価ですが、ずっと高速です。

overlap=true だと、マッチするシーケンスが string 内で重なることが許可されます。そうでなければ、マッチは重ならない区間を占める必要があります。

ソースコード

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

f が true を返す A の要素の個数を、指定した次元に沿って数えて返します。

Julia 1.5

キーワード引数 dims は Julia 1.5 で追加されました。

例

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

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

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

ソースコード

`Base.any` ── メソッド

any(p, itr) -> Bool

p が返す値に missing が含まれるときは、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

ソースコード

`Base.all` ── メソッド

all(p, itr) -> Bool

p が返す値に missing が含まれるときは、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

ソースコード

`Base.foreach` ── 関数

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

反復可能オブジェクト c の各要素に対して関数 f を呼び出します。引数に複数の反復可能オブジェクトを与えると、それぞれから要素を一つずつ取ったものが f の引数となります。f の返り値が必要ないときは map ではなく foreach を使うべきです (例えば foreach(println, array) など)。

例

julia> a = 1:3:7;

julia> foreach(x -> println(x^2), a)
1
16
49

ソースコード

`Base.map` ── 関数

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

コレクション c を各要素に f を適用することで変形します。引数に複数のコレクションを与えると、それぞれから要素を一つずつ取ったものが f の引数となります。

mapslices も参照してください。

例

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

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

ソースコード

`Base.map!` ── 関数

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

map と同様ですが、結果を新しいコレクションにして返すのではなく destination に格納します。desitination は一つ目のコレクションと同じかそれより大きいサイズを持つ必要があります。

例

julia> a = zeros(3);

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

julia> a
3-element Array{Float64,1}:
 2.0
 4.0
 6.0

ソースコード

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

dict の全てのバリューを val から f(val) に置き換えることで dict を変形します。dict の型は変えられないことに注意してください。f(val) が dict のバリュー型のインスタンスでないときは変換が行われ、変換できなければエラーが発生します。

Julia 1.2

map!(f, values(dict::AbstractDict)) は Julia 1.2 以降でサポートされます。

例

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

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

ソースコード

`Base.mapreduce` ── メソッド

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

関数 f を itrs の各要素に適用し、その結果を二項関数 op で縮約します。初期値 init が指定されるなら、それは空のコレクションが返す op の単位元である必要があります。init が空でないコレクションで使われるかどうかは規定されません。一般に、空のコレクションに対する値を計算するには init が必要です。

mapreduce は機能的に reduce(op, map(f, itr); init=init) を呼び出すのと等価ですが、途中でコレクションを作成する必要がないので一般に動作が高速です。reduce と map のドキュメントも参照してください。

Julia 1.2

mapreduce に複数の反復子を渡す機能は Julia 1.2 以降でサポートされます。

例

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

縮約が結合性を持って実行されるかどうかは実装依存です。加えて、実装は itr に複数含まれる要素に対する f の返り値を計算せずに使い回す可能性があります。左または右の結合性および全ての要素に対して f が呼ばれることを保証するには、mapfoldl または mapfoldr を使ってください。

ソースコード

`Base.mapfoldl` ── メソッド

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

mapreduce と同様ですが、foldl のように左結合性が保証されます。キーワード引数 init が指定されるなら、init はちょうど一度だけ使われます。一般に、空のコレクションに対する値を計算するには init が必要です。

ソースコード

`Base.mapfoldr` ── メソッド

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

mapreduce と同様ですが、foldr のように右結合性が保証されます。キーワード引数 init が指定されるなら、init はちょうど一度だけ使われます。一般に、空のコレクションに対する値を計算するには init が必要です。

ソースコード

`Base.first` ── 関数

first(coll)

反復可能コレクションの最初の要素を取得します。AbstractRange に対しては、たとえそれが空であったとしても開始点を返します。

例

julia> first(2:2:10)
2

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

ソースコード

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

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

例

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

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

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

ソースコード

`Base.last` ── 関数

last(coll)

順序付きコレクションの最後の要素を O(1) の時間で計算できるなら、それを計算して返します。この関数は lastindex を使って最後の添え字を取得します。AbstractRange に対しては、たとえそれが空であったとしても終了点を返します。

例

julia> last(1:2:10)
9

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

ソースコード

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

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

例

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

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

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

ソースコード

`Base.front` ── 関数

front(x::Tuple)::Tuple

x の最後以外の要素からなる Tuple を返します。

例

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

julia> Base.front(())
ERROR: ArgumentError: Cannot call front on an empty tuple.

ソースコード

`Base.tail` ── 関数

tail(x::Tuple)::Tuple

x の最初以外の要素からなる Tuple を返します。

例

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

julia> Base.tail(())
ERROR: ArgumentError: Cannot call tail on an empty tuple.

ソースコード

`Base.step` ── 関数

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

ソースコード

`Base.collect` ── メソッド

collect(collection)

コレクションまたは反復子に含まれる全ての要素からなる Array を返します。辞書に対しては Pair{KeyType, ValType} の配列を返します。引数が配列の仲間または HasShape トレイトを実装した反復子なら、引数と同じ形状と次元数を持った配列が返ります。

例

julia> collect(1:2:13)
7-element Array{Int64,1}:
  1
  3
  5
  7
  9
 11
 13

ソースコード

`Base.collect` ── メソッド

collect(element_type, collection)

コレクションまたは反復可能オブジェクトに含まれる全ての要素からなる指定された要素型の Array を返します。返り値の形状と次元数は collection と一致します。

例

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

ソースコード

`Base.filter` ── 関数

filter(f, a)

f が false を返す要素を取り除いた a のコピーを返します。f は単一の引数を受け取ります。

Julia 1.4

filter の a にタプルを渡す機能は Julia 1.4 以降でサポートされます。

例

julia> a = 1:10
1:10

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

ソースコード

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 1.2

このメソッドは Julia 1.2 以降でサポートされます。

例

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

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

ソースコード

`Base.filter!` ── 関数

filter!(f, a)

コレクション a から f が false を返す要素を取り除き、結果で a を更新します。関数 f は一つの引数を受け取ります。

例

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

ソースコード

filter!(f, d::AbstractDict)

d から f が false を返す要素を取り除き、結果で d を更新します。関数 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"

ソースコード

`Base.replace` ── メソッド

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

コレクション A のコピーを作成し、old_new に含まれる組 old=>new それぞれについてコピーに含まれる old を new に置き換え、コピーを返します。等価性は isequal で判定されます。count が指定されると、置換を最大でも count 回だけ行います。

返り値の要素型は A の要素型と組 old_new に含まれる new から昇格 (promote_type) で決められます。count が省略され、かつ A の要素型がシングルトン型を含む Union だと、シングルトン型の値が他の型に置き換わったときに返り値の要素型からシングルトン型が削除されます。例えば要素型が Union{T,Missing} のとき missing を T 型の値に置換すると、返り値の要素型は T になります。

replace! も参照してください。

例

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

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

ソースコード

`Base.replace` ── メソッド

replace(new::Function, 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 Array{Int64,1}:
 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

ソースコード

`Base.replace!` ── 関数

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

old_new に含まれる組 old=>new のそれぞれについて、コレクション A に含まれる old を new で置き換えます。等価性は isequal で判定されます。count が指定されると、置換は最大でも count 回だけ行われます。replace も参照してください。

例

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

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

ソースコード

replace!(new::Function, 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 Array{Int64,1}:
 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

ソースコード

添え字アクセス可能なコレクション

このインターフェースは次の型で完全に実装されます:

次の型で部分的に実装されます:

AbstractRange
UnitRange
Tuple
AbstractString
Dict
IdDict
WeakKeyDict
NamedTuple

`Base.getindex` ── 関数

getindex(collection, key...)

コレクションの指定されたキーまたは添え字に対応する値を取得します。構文 a[i,j,...] はコンパイラによって getindex(a, i, j, ...) に変換されます。

例

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

julia> getindex(A, "a")
1

ソースコード

`Base.setindex!` ── 関数

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

コレクションの指定されたキーまたは添え字に対応する値を設定します。構文 a[i,j,...] = x はコンパイラによって (setindex!(a, x, i, j, ...); x) に変換されます。

ソースコード

`Base.firstindex` ── 関数

firstindex(collection) -> Integer
firstindex(collection, d) -> Integer

collection の最初の添え字を返します。d が与えられるなら、collection の d 番目の次元に関する最初の添え字を返します。

例

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

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

ソースコード

`Base.lastindex` ── 関数

lastindex(collection) -> Integer
lastindex(collection, d) -> Integer

collection の最後の添え字を返します。d が与えられるなら、collection の d 番目の次元に関する最後の添え字を返します。

構文 A[end] と A[end, end] は A[lastindex(A)] と A[lastindex(A, 1), lastindex(A, 2)] にそれぞれ展開されます。

例

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

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

ソースコード

辞書

標準的な辞書は Dict です。Dict の実装はキーのハッシュ関数に hash を使い、等価性の判定に isequal を使います。この二つの関数を独自の型に定義すればハッシュテーブルに格納されるときの振る舞いをオーバーライドできます。

IdDict はオブジェクトの ID をキーに使う特殊なハッシュテーブルです。

WeakKeyDict はオブジェクトの弱参照 (weak reference) をキーとするハッシュテーブルの実装であり、キーが参照するオブジェクトに対するガベージコレクトが許可されます。Dict と同様 WeakKeyDict は hash でハッシュを計算し isequal で等価性を判定しますが、Dict と異なり要素を挿入するときキーの変換を行いません。

Dict は => で作った (一つ以上の) 組オブジェクトをコンストラクタに渡すことで構築します。例えば Dict("A"=>1, "B"=>2) とします。この呼び出しは渡されたキーとバリューから型を推論するので、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] とすると、タプル (x,y) に対応するバリューが参照されます。

このインターフェースは次の型で完全に実装されます:

IdDict
Dict
WeakKeyDict

次の型で部分的に実装されます:

BitSet
Set
EnvDict
Array
BitArray
ImmutableDict
Iterators.Pairs

`Base.AbstractDict` ── 型

AbstractDict(K, V)

K 型のキーと V 型のバリューを持つ辞書とみなせる型を表す上位型です。Dict や IdDict などを部分型に持ちます。AbstractDict{K, V} 型の値は Pair{K, V} 型の値を生成する反復子であるべきです。

ソースコード

`Base.Dict` ── 型

Dict([itr])

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

引数に単一の反復可能オブジェクトを与えると、その引数が生成する二要素のタプル (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

ソースコード

`Base.IdDict` ── 型

IdDict([itr])

IdDict{K,V}() はオブジェクトの ID をハッシュに使うハッシュテーブルを構築します。K 型のキーと V 型のバリューを持ち、キー同士およびバリュー同士は === で等価性が判定されます。

詳しくは Dict を参照してください。

ソースコード

`Base.WeakKeyDict` ── 型

WeakKeyDict([itr])

WeakKeyDict() はキーが弱参照 (weak reference) であるハッシュテーブルを構築します。弱参照が指すオブジェクトは、弱参照によって参照されるにもかかわらず、ガベージコレクトが許可されます。

詳しくは Dict を参照してください。なお Dict と異なり、WeakKeyDict は挿入するキーを変換しません。

ソースコード

`Base.ImmutableDict` ── 型

ImmutableDict

ImmutableDict は不変連結リストとして実装される辞書です。いくつかの挿入を一度だけ行うことで構築される小さい辞書に適しています。ImmutableDict が持つ値は削除できませんが、既存の値と同じキーを持つ値を挿入して部分的に書き換えたり隠したりすることは可能です²。

ImmutableDict(KV::Pair)

組 key => value を使って ImmutableDict を作成します。

特定のキーとバリューの組が辞書に含まれるかどうかを判定するには (key => value) in dict を使ってください。
キーに対して最後に設定されたバリューを取得するには get(dict, key, default) を使ってください。

ソースコード

`Base.haskey` ── 関数

haskey(collection, key) -> Bool

collection が 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

ソースコード

`Base.get` ── 関数

get(collection, key, default)

key に対応するバリューを collection が持つならそれを返し、持たないなら default を返します。

例

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

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

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

ソースコード

get(f::Function, collection, key)

key に対応するバリューを collection が持つならそれを返し、持たないなら f() を返します。get! を使うと加えてデフォルト値を保存できます。

このメソッドは do ブロック構文を使って呼び出すことが意図されています:

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

ソースコード

`Base.get!` ── メソッド

get!(collection, key, default)

key に対応するバリューを collection が持つならそれを返し、持たないなら key => default を collection に追加した上で 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

ソースコード

`Base.get!` ── メソッド

get!(f::Function, collection, key)

key に対応するバリューを collection が持つならそれを返し、持たないなら key => f() を collection に追加した上で f() を返します。

このメソッドは do ブロック構文を使って呼び出すことが意図されています:

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

ソースコード

`Base.getkey` ── 関数

getkey(collection, key, default)

key に対応するバリューが collection に存在するなら key を返し、存在しないなら 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)

ソースコード

`Base.delete!` ── 関数

delete!(collection, key)

key に対するマッピングが collection に存在するなら、それを削除します。collection を返します。

例

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

ソースコード

`Base.pop!` ── メソッド

pop!(collection, key[, default])

key に対するマッピングが collection に存在するなら、それを collection から削除して返します。存在しないなら 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

ソースコード

`Base.keys` ── 関数

keys(iterator)

キーとバリューを持つ反復子またはコレクション (配列や辞書) を受け取り、キーに対する反復子を返します。

ソースコード

`Base.values` ── 関数

values(iterator)

キーとバリューを持つ反復子またはコレクションを受け取り、バリューに対する反復子を返します。一般に反復子は "バリュー" を返すのが通常の動作なので、この関数のデフォルトの動作は引数をそのまま返すだけです。

例

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

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

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

ソースコード

values(a::AbstractDict)

コレクション内の全てのバリューに対する反復子を返します。collect(values(a)) はバリューからなる配列を返します。Dict のようにバリューが内部でハッシュテーブルとして保存される場合は、返り値の反復子から得られるバリューの順序は規定されません。ただし keys(a) と values(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 Array{Int64,1}:
 2
 3

ソースコード

`Base.pairs` ── 関数

pairs(collection)

キーの集合をバリューの集合に対応付ける任意のコレクションを受け取り、key => value という組を返す反復子を返します。配列を渡すこともでき、その場合は配列の添え字がキーとなります。

ソースコード

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

「配列 A の各要素の添え字 i と値 x = A[i] に対して i => x を返す反復子」を返します。添え字の形式が指定できることを除けば pairs(A) と同じです。enumerate(A) とも似ていますが、pairs を使うと i は必ず A の有効な添え字となります。これに対して enumerate は A が使う添え字の形式に関わらず 1 からカウントを始めます。

IndexLinear() を指定すると i を必ず整数にできます。IndexCartesian() を指定すると i は CartesianIndex となり、IndexStyle(A) を指定すると配列 A のネイティブな添え字形式が選択されます。

pairs 関数に渡した配列の境界を変更すると、pairs が返す反復子は無効になります。

例

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` ── 関数

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

与えられた複数のコレクションを合併した一つのコレクションを構築します。必要なら、構築されるコレクションの型は合併されるコレクションの型を全て保持できるよう昇格されます。同じキーが複数のコレクションに含まれる場合は、そのキーを含むコレクションの中で最後にあるものが持つバリューを採用します。

例

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...)

複数の名前付きタプルを合併して新しい名前付きタプルを作成します。合併は左結合で行われます。左から右に、名前付きタプルの組ごとに合併を行うので、一番左の名前付きタプルに含まれるフィールドは返り値でも同じ順序で並びます。ただしフィールドのバリューは、そのフィールドを持つ最も右の名前付きタプルにおける値となります。引数に名前付きタプルが一つだけ与えられた場合の merge(a::NamedTuple) というシグネチャを持つメソッドもフォールバックとして実装されます。

Julia 1.1

三つ以上の NamedTuple を merge するには Julia 1.1 以上が必要です。

例

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)

ソースコード

`Base.mergewith` ── 関数

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

与えられたコレクションを合併して新しいコレクションを構築します。必要なら、返り値のコレクションの型は合併するコレクションの型を全て保持できるよう昇格されます。同じキーを持つバリューは combine 関数を使って合成されます。カリー化された mergewith(combine) は関数 (args...) -> mergewith(combine, args...) を返します。

merge(combine::Union{Function,Type}, args...) は mergewith(combine, args...) の別名であり、後方互換性のために提供されます。

Julia 1.5

mergewith は Julia 1.5 以降でサポートされます。

例

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

ソースコード

`Base.merge!` ── 関数

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

他のコレクションに含まれる組を使ってコレクション d を更新します。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

ソースコード

`Base.mergewith!` ── 関数

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

他のコレクションに含まれる組を使ってコレクション d を更新します。同じキーを持つバリューは combine 関数を使って合成されます。カリー化された mergewith!(combine) は関数 (args...) -> mergewith!(combine, args...) を返します。

merge!(combine::Union{Function,Type}, args...) は mergewith!(combine, args...) の別名であり、後方互換性のために提供されます。

Julia 1.5

mergewith! は Julia 1.5 以降でサポートされます。

例

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

ソースコード

`Base.sizehint!` ── 関数

sizehint!(s, n)

コレクション s に対して最低でも n 要素の容量を確保するよう提案します。これによって性能が向上する可能性があります。

ソースコード

`Base.keytype` ── 関数

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

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

例

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

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

Julia 1.2

配列に対する keytype は Julia 1.2 以降でサポートされます。

ソースコード

keytype(type)

辞書型のキーの型を返します。振る舞いは eltype と同様です。

例

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

ソースコード

`Base.valtype` ── 関数

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

配列型のバリューの型を返します。これは eltype に等しく、主に辞書型のインターフェースとの互換性のために提供されます。

例

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

Julia 1.2

配列に対する valtype は Julia 1.2 以降でサポートされます。

ソースコード

valtype(type)

辞書型のバリューの型を返します。振る舞いは eltype と同様です。

例

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

ソースコード

集合に似たコレクション

このインターフェースは次の型で完全に実装されます:

BitSet
Set

次の型で部分的に実装されます:

Array

`Base.AbstractSet` ── 型

AbstractSet(T)

T 型の要素を持つ集合に似た型を表す上位型です。部分型に Set や BitSet があります。

ソースコード

`Base.Set` ── 型

Set([itr])

反復可能オブジェクト itr から生成される値を使って Set を構築します。itr が指定されなければ空の Set を構築します。疎な整数集合や任意のオブジェクトを含む集合に対しては Set を使うべきです。

ソースコード

`Base.BitSet` ── 型

BitSet([itr])

反復可能オブジェクト itr から生成される値を使って Int の集合を構築します。ビット列として実装されるので、密な整数集合に適しています。集合が疎 (例えば少数の非常に大きい整数を格納するだけ) なら Set を使ってください。

ソースコード

`Base.union` ── 関数

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

和集合を構築します。配列では順序が保たれます。

例

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

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

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

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

ソースコード

`Base.union!` ── 関数

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

引数の和集合を構築し、その結果で s を更新します。配列では順序が保たれます。

例

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

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

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

ソースコード

`Base.intersect` ── 関数

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

共通部分集合を構築します。配列では順序が保たれます。

例

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

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

julia> intersect(Set([1, 2]), BitSet([2, 3]))
Set{Int64} with 1 element:
  2

ソースコード

`Base.setdiff` ── 関数

setdiff(s, itrs...)

s に含まれ itrs のいずれにも含まれない要素からなる集合を構築します。配列では順序が保たれます。

例

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

ソースコード

`Base.setdiff!` ── 関数

setdiff!(s, itrs...)

itrs 内の反復可能オブジェクトに含まれる要素を s から (インプレースに) 取り除きます。配列では順序が保たれます。

例

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

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

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

ソースコード

`Base.symdiff` ── 関数

symdiff(s, itrs...)

与えられた集合の対称差を構築します。s が AbstractSet でないなら順序が保たれます。要素が重複するたびに結果に含まれるかどうかが変わることに注意してください。

例

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

julia> symdiff([1,2,1], [2, 1, 2])
2-element Array{Int64,1}:
 1
 2

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

ソースコード

`Base.symdiff!` ── 関数

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

与えられた集合の対称差を構築し、結果で s を更新します。s が配列なら順序が保たれます。要素が重複するたびに結果に含まれるかどうかが変わることに注意してください。

ソースコード

`Base.intersect!` ── 関数

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

与えられた集合全ての共通部分集合を構築し、結果で s を更新します。配列では順序が保たれます。

ソースコード

`Base.issubset` ── 関数

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

任意の a の要素が b の要素かどうかを判定します。要素が集合に属するかどうかの判定には in が使われます。

例

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

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

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

ソースコード

`Base.:⊈` ── 関数

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

⊆ と ⊇ の否定です。つまり、a が b の部分集合でないかどうかを判定します。

例

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

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

ソースコード

`Base.:⊊` ── 関数

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

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

例

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

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

ソースコード

`Base.issetequal` ── 関数

issetequal(a, b) -> Bool

a と b が同じ要素を持つかどうかを判定します。a ⊆ b && b ⊆ a と等価ですが、可能な場合には高速な実装が使われます。

例

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

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

ソースコード

`Base.isdisjoint` ── 関数

isdisjoint(v1, v2) -> Bool

v1 と v2 が互いに素かどうか、つまり共通部分集合が空かどうかを判定します。

Julia 1.5

この関数は Julia 1.5 以降でサポートされます。

ソースコード

デキュー

このインターフェースは次の型で完全に実装されます:

Vector (一次元 Array の別名)
BitVector (一次元 BitArray の別名)

`Base.push!` ── 関数

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

collection に items を挿入します。items は一つ以上の要素を表します。collection が順序を持つコンテナなら、要素は最後に (与えられた順番で) 挿入されます。

例

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

他のコレクションに含まれる要素を全て加えるには、そのコレクションが順序を持つなら append! を使ってください。例えば append!([1, 2, 3], [4, 5, 6]) とすれば上の例と同じになります。AbstractSet オブジェクトに対しては union! が利用できます。

ソースコード

`Base.pop!` ── 関数

pop!(collection) -> item

collection から要素を一つ取り除き、取り除いた要素を返します。collection が順序を持つコンテナなら、最後の要素が返ります。

例

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

julia> pop!(A)
3

julia> A
2-element Array{Int64,1}:
 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])

key に対するマッピングが collection に存在するなら、それを collection から削除して返します。存在しないなら 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

ソースコード

`Base.popat!` ── 関数

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

位置 i にある要素を削除して返します。削除によってできる空間は i より後ろにある要素をそれぞれ一つ上に移動させることで埋められます。i が a に対する正当な添え字でないなら default を返しますが、default が指定されなければエラーを送出します。deleteat! と splice! も参照してください。

Julia 1.5

この関数は Julia 1.5 以降でサポートされます。

例

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

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

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

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

ソースコード

`Base.pushfirst!` ── 関数

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

collection の先頭に items を挿入します。items は一つ以上の要素を表します。

例

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

ソースコード

`Base.popfirst!` ── 関数

popfirst!(collection) -> item

collection の最初の要素を削除して返します。

例

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

julia> popfirst!(A)
1

julia> A
5-element Array{Int64,1}:
 2
 3
 4
 5
 6

ソースコード

`Base.insert!` ── 関数

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

item を a の位置 index に挿入します。この関数が返ると、a の位置 index の要素は item となります。

例

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

ソースコード

`Base.deleteat!` ── 関数

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

位置 i の要素を a から削除し、変更された a を返します。削除によってできる空間は i より後ろの要素をそれぞれ一つ上に移動させることで埋められます。

例

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

ソースコード

deleteat!(a::Vector, inds)

inds が示す位置にある要素を a から削除し、変更された a を返します。削除によってできる空間は i より後ろの要素をそれぞれ一つ上に移動させることで埋められます。

inds として渡せるのはユニークかつソート済みの整数からなる反復子またはコレクション、あるいは a と同じ長さの真偽値ベクトルです。真偽値ベクトルでは true が削除すべき要素を表します。

例

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

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

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

ソースコード

`Base.splice!` ── 関数

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

位置 index にある要素を a から削除し、削除した要素を返します。削除によってできる空間は i より後ろの要素をそれぞれ一つ上に移動させることで埋められます。replacement が指定されると、削除した位置に replacement が接合 (splice) されます。

例

julia> A = [6, 5, 4, 3, 2, 1]; splice!(A, 5)
2

julia> A
5-element Array{Int64,1}:
 6
 5
 4
 3
 1

julia> splice!(A, 5, -1)
1

julia> A
5-element Array{Int64,1}:
  6
  5
  4
  3
 -1

julia> splice!(A, 1, [-1, -2, -3])
6

julia> A
7-element Array{Int64,1}:
 -1
 -2
 -3
  5
  4
  3
 -1

splice!(collection, n:n-1, replacement) を使うと、要素を削除することなく位置 n の前に replacement を挿入できます。

ソースコード

splice!(a::Vector, indices, [replacement]) -> items

コレクションによって指定される位置にある要素を削除し、削除された要素からなるコレクションを返します。削除によって生まれる空間は以降の要素を上に移動させることで埋められます。replacement が指定されると、削除した部分に replacement が接合 (splice) されます。なお replacement を指定するときは indices が UnitRange である必要があります。

splice!(collection, n:n-1, replacement) を使うと、要素を削除することなく位置 n の前に replacement を挿入できます。

Julia 1.5

Julia 1.5 より前のバージョンでは、indices は UnitRange である必要があります。

例

julia> A = [-1, -2, -3, 5, 4, 3, -1]; splice!(A, 4:3, 2)
Int64[]

julia> A
8-element Array{Int64,1}:
 -1
 -2
 -3
  2
  5
  4
  3
 -1

ソースコード

`Base.resize!` ── 関数

resize!(a::Vector, n::Integer) -> Vector

a のサイズを変更して要素数を n にします。n が現在の長さより小さいなら、最初の n 要素が保持されます。n が現在の長さより大きいなら、新しい要素が初期化される保証はありません。

例

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

julia> a = resize!([6, 5, 4, 3, 2, 1], 8);

julia> length(a)
8

julia> a[1:6]
6-element Array{Int64,1}:
 6
 5
 4
 3
 2
 1

ソースコード

`Base.append!` ── 関数

append!(collection, collection2) -> collection

順序付きコンテナ collection の終わりに collection2 の要素を付け足します。

例

julia> append!([1],[2,3])
3-element Array{Int64,1}:
 1
 2
 3

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

コレクションに入っていない要素を collection に追加するには push! を使ってください。例えば上の例は push!([1, 2, 3], 4, 5, 6) と書けます。

ソースコード

`Base.prepend!` ── 関数

prepend!(a::Vector, items) -> collection

a の最初に items の要素を挿入します。

例

julia> prepend!([3],[1,2])
3-element Array{Int64,1}:
 1
 2
 3

ソースコード

ユーティリティコレクション

`Base.Pair` ── 型

Pair(x, y)
x => y

Pair(typeof(x), typeof(y)) 型の Pair オブジェクトを構築します。二つの要素はそれぞれ 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

ソースコード

`Base.Iterators.Pairs` ── 型

Iterators.Pairs(values, keys) <: AbstractDict{eltype(keys), eltype(values)}

添え字アクセス可能なコンテナを同じデータに対する辞書ビューに変形します。内部データのキー空間を変更すると、この関数が返すオブジェクトが無効になる可能性があります。

ソースコード

訳注: シングルトン次元とは大きさが 1 の次元のこと。maximum!(zeros(1,3,1), rand(3,3,3)) のように r が複数のシングルトン次元を持っていてもよい。^[return]
訳注: 既存の ImmutableDict の値を書き換えるには、新しい ImmutableDict の構築が必要になる。例えば d = Base.ImmutableDict(:a => "a"); d = Base.ImmutableDict(d, :a => "new a") とする。^[return]