集合和数据结构

迭代

序列迭代由 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)
end

state 对象可以是任何对象，并且对于每个可迭代类型应该选择合适的 state 对象。 请参照 帮助文档接口的迭代小节 来获取关于定义一个常见迭代类型的更多细节。

Base.iterate — Function

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

Advance the iterator to obtain the next element. If no elements remain, nothing should be returned. Otherwise, a 2-tuple of the next element and the new iteration state should be returned.

source

Base.IteratorSize — Type

IteratorSize(itertype::Type) -> IteratorSize

Given the type of an iterator, return one of the following values:

• SizeUnknown() if the length (number of elements) cannot be determined in advance.
• HasLength() if there is a fixed, finite length.
• HasShape{N}() if there is a known length plus a notion of multidimensional shape (as for an array). In this case N should give the number of dimensions, and the axes function is valid for the iterator.
• IsInfinite() if the iterator yields values forever.

The default value (for iterators that do not define this function) is HasLength(). This means that most iterators are assumed to implement length.

This trait is generally used to select between algorithms that pre-allocate space for their result, and algorithms that resize their result incrementally.

julia> Base.IteratorSize(1:5)
Base.HasShape{1}()
julia> Base.IteratorSize((2,3))
Base.HasLength()

source

Base.IteratorEltype — Type

IteratorEltype(itertype::Type) -> IteratorEltype

Given the type of an iterator, return one of the following values:

• EltypeUnknown() if the type of elements yielded by the iterator is not known in advance.
• HasEltype() if the element type is known, and eltype would return a meaningful value.

HasEltype() is the default, since iterators are assumed to implement eltype.

This trait is generally used to select between algorithms that pre-allocate a specific type of result, and algorithms that pick a result type based on the types of yielded values.

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

source

以下类型均完全实现了上述函数：

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

构造函数和类型

Base.AbstractRange — Type

AbstractRange{T}

Supertype for ranges with elements of type T. UnitRange and other types are subtypes of this.

source

Base.OrdinalRange — Type

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

Supertype for ordinal ranges with elements of type T with spacing(s) of type S. The steps should be always-exact multiples of oneunit, and T should be a “discrete” type, which cannot have values smaller than oneunit. For example, Integer or Date types would qualify, whereas Float64 would not (since this type can represent values smaller than oneunit(Float64). UnitRange, StepRange, and other types are subtypes of this.

source

Base.AbstractUnitRange — Type

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

Supertype for ranges with a step size of oneunit(T) with elements of type T. UnitRange and other types are subtypes of this.

source

Base.StepRange — Type

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

Ranges with elements of type T with spacing of type S. The step between each element is constant, and the range is defined in terms of a start and stop of type T and a step of type S. Neither T nor S should be floating point types. The syntax a:b:c with b > 1 and a, b, and c all integers creates a StepRange.

Examples

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}

source

Base.UnitRange — Type

UnitRange{T<:Real}

A range parameterized by a start and stop of type T, filled with elements spaced by 1 from start until stop is exceeded. The syntax a:b with a and b both Integers creates a UnitRange.

Examples

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

source

Base.LinRange — Type

LinRange{T}

A range with len linearly spaced elements between its start and stop. The size of the spacing is controlled by len, which must be an Int.

Examples

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

source

通用集合

Base.isempty — Function

isempty(collection) -> Bool

Determine whether a collection is empty (has no elements).

Examples

julia> isempty([])
true
julia> isempty([1 2 3])
false

source

isempty(condition)

Return true if no tasks are waiting on the condition, false otherwise.

source

Base.empty! — Function

empty!(collection) -> collection

Remove all elements from a collection.

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} with 0 entries

source

Base.length — Function

length(collection) -> Integer

Return the number of elements in the collection.

Use lastindex to get the last valid index of an indexable collection.

Examples

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

source

以下类型均完全实现了上述函数：

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

可迭代集合

Base.in — Function

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

Determine whether an item is in the given collection, in the sense that it is == to one of the values generated by iterating over the collection. Returns a Bool value, except if item is missing or collection contains missing but not item, in which case missing is returned (three-valued logic, matching the behavior of any and ==).

Some collections follow a slightly different definition. For example, Sets check whether the item isequal to one of the elements. Dicts look for key=>value pairs, and the key is compared using isequal. To test for the presence of a key in a dictionary, use haskey or k in keys(dict). For these collections, the result is always a Bool and never missing.

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

source

Base.:∉ — Function

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

Negation of ∈ and ∋, i.e. checks that item is not in collection.

Examples

julia> 1 ∉ 2:4
true
julia> 1 ∉ 1:3
false

source

Base.eltype — Function

eltype(type)

Determine the type of the elements generated by iterating a collection of the given type. For dictionary types, this will be a Pair{KeyType,ValType}. The definition eltype(x) = eltype(typeof(x)) is provided for convenience so that instances can be passed instead of types. However the form that accepts a type argument should be defined for new types.

Examples

julia> eltype(fill(1f0, (2,2)))
Float32
julia> eltype(fill(0x1, (2,2)))
UInt8

source

Base.indexin — Function

indexin(a, b)

Return an array containing the first index in b for each value in a that is a member of b. The output array contains nothing wherever a is not a member of b.

Examples

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

source

Base.unique — Function

unique(itr)

Return an array containing only the unique elements of collection itr, as determined by isequal, in the order that the first of each set of equivalent elements originally appears. The element type of the input is preserved.

Examples

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

source

unique(f, itr)

Returns an array containing one value from itr for each unique value produced by f applied to elements of itr.

Examples

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

source

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

Return unique regions of A along dimension 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 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

source

Base.unique! — Function

unique!(f, A::AbstractVector)

Selects one value from A for each unique value produced by f applied to elements of A , then return the modified A.

Julia 1.1

This method is available as of Julia 1.1.

Examples

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

source

unique!(A::AbstractVector)

Remove duplicate items as determined by isequal, then return the modified A. unique! will return the elements of A in the order that they occur. If you do not care about the order of the returned data, then calling (sort!(A); unique!(A)) will be much more efficient as long as the elements of A can be sorted.

Examples

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! is able to process sorted data much more efficiently.
julia> unique!(B)
3-element Array{Int64,1}:
  6
  7
 42

source

Base.allunique — Function

allunique(itr) -> Bool

Return true if all values from itr are distinct when compared with isequal.

Examples

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

source

Base.reduce — Method

reduce(op, itr; [init])

Reduce the given collection itr with the given binary operator op. If provided, the initial value init must be a neutral element for op that will be returned for empty collections. It is unspecified whether init is used for non-empty collections.

For empty collections, providing init will be necessary, except for some special cases (e.g. when op is one of +, *, max, min, &, |) when Julia can determine the neutral element of op.

Reductions for certain commonly-used operators may have special implementations, and should be used instead: maximum(itr), minimum(itr), sum(itr), prod(itr), any(itr), all(itr).

The associativity of the reduction is implementation dependent. This means that you can’t use non-associative operations like - because it is undefined whether reduce(-,[1,2,3]) should be evaluated as (1-2)-3 or 1-(2-3). Use foldl or foldr instead for guaranteed left or right associativity.

Some operations accumulate error. Parallelism will be easier if the reduction can be executed in groups. Future versions of Julia might change the algorithm. Note that the elements are not reordered if you use an ordered collection.

Examples

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

source

Base.foldl — Method

foldl(op, itr; [init])

Like reduce, but with guaranteed left associativity. If provided, the keyword argument init will be used exactly once. In general, it will be necessary to provide init to work with empty collections.

Examples

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

source

Base.foldr — Method

foldr(op, itr; [init])

Like reduce, but with guaranteed right associativity. If provided, the keyword argument init will be used exactly once. In general, it will be necessary to provide init to work with empty collections.

Examples

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

source

Base.maximum — Function

maximum(f, itr)

Returns the largest result of calling function f on each element of itr.

Examples

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

source

maximum(itr)

Returns the largest element in a collection.

Examples

julia> maximum(-20.5:10)
9.5
julia> maximum([1,2,3])
3

source

maximum(A::AbstractArray; dims)

Compute the maximum value of an array over the given dimensions. See also the max(a,b) function to take the maximum of two or more arguments, which can be applied elementwise to arrays via max.(a,b).

Examples

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

source

Base.maximum! — Function

maximum!(r, A)

Compute the maximum value of A over the singleton dimensions of r, and write results to r.

Examples

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

source

Base.minimum — Function

minimum(f, itr)

Returns the smallest result of calling function f on each element of itr.

Examples

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

source

minimum(itr)

Returns the smallest element in a collection.

Examples

julia> minimum(-20.5:10)
-20.5
julia> minimum([1,2,3])
1

source

minimum(A::AbstractArray; dims)

Compute the minimum value of an array over the given dimensions. See also the min(a,b) function to take the minimum of two or more arguments, which can be applied elementwise to arrays via min.(a,b).

Examples

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

source

Base.minimum! — Function

minimum!(r, A)

Compute the minimum value of A over the singleton dimensions of r, and write results to r.

Examples

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

source

Base.extrema — Function

extrema(itr) -> Tuple

Compute both the minimum and maximum element in a single pass, and return them as a 2-tuple.

Examples

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

source

extrema(f, itr) -> Tuple

Compute both the minimum and maximum of f applied to each element in itr and return them as a 2-tuple. Only one pass is made over itr.

Julia 1.2

This method requires Julia 1.2 or later.

Examples

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

source

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

Compute the minimum and maximum elements of an array over the given dimensions.

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)

source

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

Compute the minimum and maximum of f applied to each element in the given dimensions of A.

Julia 1.2

This method requires Julia 1.2 or later.

source

Base.argmax — Function

argmax(itr) -> Integer

Return the index of the maximum element in a collection. If there are multiple maximal elements, then the first one will be returned.

The collection must not be empty.

Examples

julia> argmax([8,0.1,-9,pi])
1
julia> argmax([1,7,7,6])
2
julia> argmax([1,7,7,NaN])
4

source

argmax(A; dims) -> indices

For an array input, return the indices of the maximum elements over the given dimensions. NaN is treated as greater than all other values.

Examples

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)

source

Base.argmin — Function

argmin(itr) -> Integer

Return the index of the minimum element in a collection. If there are multiple minimal elements, then the first one will be returned.

The collection must not be empty.

Examples

julia> argmin([8,0.1,-9,pi])
3
julia> argmin([7,1,1,6])
2
julia> argmin([7,1,1,NaN])
4

source

argmin(A; dims) -> indices

For an array input, return the indices of the minimum elements over the given dimensions. NaN is treated as less than all other values.

Examples

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)

source

Base.findmax — Function

findmax(itr) -> (x, index)

Return the maximum element of the collection itr and its index. If there are multiple maximal elements, then the first one will be returned. If any data element is NaN, this element is returned. The result is in line with max.

The collection must not be empty.

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)

source

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

For an array input, returns the value and index of the maximum over the given dimensions. NaN is treated as greater than all other values.

Examples

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

source

Base.findmin — Function

findmin(itr) -> (x, index)

Return the minimum element of the collection itr and its index. If there are multiple minimal elements, then the first one will be returned. If any data element is NaN, this element is returned. The result is in line with min.

The collection must not be empty.

Examples

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)

source

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

For an array input, returns the value and index of the minimum over the given dimensions. NaN is treated as less than all other values.

Examples

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

source

Base.findmax! — Function

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

Find the maximum of A and the corresponding linear index along singleton dimensions of rval and rind, and store the results in rval and rind. NaN is treated as greater than all other values.

source

Base.findmin! — Function

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

Find the minimum of A and the corresponding linear index along singleton dimensions of rval and rind, and store the results in rval and rind. NaN is treated as less than all other values.

source

Base.sum — Function

sum(f, itr)

Sum the results of calling function f on each element of itr.

The return type is Int for signed integers of less than system word size, and UInt for unsigned integers of less than system word size. For all other arguments, a common return type is found to which all arguments are promoted.

Examples

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

Note the important difference between sum(A) and reduce(+, A) for arrays with small integer eltype:

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

In the former case, the integers are widened to system word size and therefore the result is 128. In the latter case, no such widening happens and integer overflow results in -128.

source

sum(itr)

Returns the sum of all elements in a collection.

The return type is Int for signed integers of less than system word size, and UInt for unsigned integers of less than system word size. For all other arguments, a common return type is found to which all arguments are promoted.

Examples

julia> sum(1:20)
210

source

sum(A::AbstractArray; dims)

Sum elements of an array over the given dimensions.

Examples

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

source

Base.sum! — Function

sum!(r, A)

Sum elements of A over the singleton dimensions of r, and write results to r.

Examples

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

source

Base.prod — Function

prod(f, itr)

Returns the product of f applied to each element of itr.

The return type is Int for signed integers of less than system word size, and UInt for unsigned integers of less than system word size. For all other arguments, a common return type is found to which all arguments are promoted.

Examples

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

source

prod(itr)

Returns the product of all elements of a collection.

The return type is Int for signed integers of less than system word size, and UInt for unsigned integers of less than system word size. For all other arguments, a common return type is found to which all arguments are promoted.

Examples

julia> prod(1:20)
2432902008176640000

source

prod(A::AbstractArray; dims)

Multiply elements of an array over the given dimensions.

Examples

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

source

Base.prod! — Function

prod!(r, A)

Multiply elements of A over the singleton dimensions of r, and write results to r.

Examples

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

source

Base.any — Method

any(itr) -> Bool

Test whether any elements of a boolean collection are true, returning true as soon as the first true value in itr is encountered (short-circuiting).

If the input contains missing values, return missing if all non-missing values are false (or equivalently, if the input contains no true value), following three-valued logic.

Examples

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

source

Base.any — Method

any(p, itr) -> Bool

Determine whether predicate p returns true for any elements of itr, returning true as soon as the first item in itr for which p returns true is encountered (short-circuiting).

If the input contains missing values, return missing if all non-missing values are false (or equivalently, if the input contains no true value), following 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])
false

source

Base.any! — Function

any!(r, A)

Test whether any values in A along the singleton dimensions of r are true, and write results to r.

Examples

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

source

Base.all — Method

all(itr) -> Bool

Test whether all elements of a boolean collection are true, returning false as soon as the first false value in itr is encountered (short-circuiting).

If the input contains missing values, return missing if all non-missing values are true (or equivalently, if the input contains no false value), following three-valued logic.

Examples

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

source

Base.all — Method

all(p, itr) -> Bool

Determine whether predicate p returns true for all elements of itr, returning false as soon as the first item in itr for which p returns false is encountered (short-circuiting).

If the input contains missing values, return missing if all non-missing values are true (or equivalently, if the input contains no false value), following 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])
true

source

Base.all! — Function

all!(r, A)

Test whether all values in A along the singleton dimensions of r are true, and write results to r.

Examples

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

source

Base.count — Function

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

Count the number of elements in itr for which predicate p returns true. If p is omitted, counts the number of true elements in itr (which should be a collection of boolean values).

Examples

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

source

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

Return the number of matches for pattern in string. This is equivalent to calling length(findall(pattern, string)) but more efficient.

If overlap=true, the matching sequences are allowed to overlap indices in the original string, otherwise they must be from disjoint character ranges.

source

Base.any — Method

any(p, itr) -> Bool

Determine whether predicate p returns true for any elements of itr, returning true as soon as the first item in itr for which p returns true is encountered (short-circuiting).

If the input contains missing values, return missing if all non-missing values are false (or equivalently, if the input contains no true value), following 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])
false

source

Base.all — Method

all(p, itr) -> Bool

Determine whether predicate p returns true for all elements of itr, returning false as soon as the first item in itr for which p returns false is encountered (short-circuiting).

If the input contains missing values, return missing if all non-missing values are true (or equivalently, if the input contains no false value), following 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])
true

source

Base.foreach — Function

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

Call function f on each element of iterable c. For multiple iterable arguments, f is called elementwise. foreach should be used instead of map when the results of f are not needed, for example in foreach(println, array).

Examples

julia> a = 1:3:7;
julia> foreach(x -> println(x^2), a)
1
16
49

source

Base.map — Function

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

Transform collection c by applying f to each element. For multiple collection arguments, apply f elementwise.

See also: mapslices

Examples

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

source

Base.map! — Function

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

Like map, but stores the result in destination rather than a new collection. destination must be at least as large as the first collection.

Examples

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

source

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

Modifies dict by transforming each value from val to f(val). Note that the type of dict cannot be changed: if f(val) is not an instance of the key type of dict then it will be converted to the key type if possible and otherwise raise an error.

Examples

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

julia> map!(v -> v-1, values(d)) Dict{Symbol,Int64} with 2 entries: :a => 0 :b => 1 ```

source

Base.mapreduce — Method

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

Apply function f to each element(s) in itrs, and then reduce the result using the binary function op. If provided, init must be a neutral element for op that will be returned for empty collections. It is unspecified whether init is used for non-empty collections. In general, it will be necessary to provide init to work with empty collections.

mapreduce is functionally equivalent to calling reduce(op, map(f, itr); init=init), but will in general execute faster since no intermediate collection needs to be created. See documentation for reduce and map.

Julia 1.2

mapreduce with multiple iterators requires Julia 1.2 or later.

Examples

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

The associativity of the reduction is implementation-dependent. Additionally, some implementations may reuse the return value of f for elements that appear multiple times in itr. Use mapfoldl or mapfoldr instead for guaranteed left or right associativity and invocation of f for every value.

source

Base.mapfoldl — Method

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

Like mapreduce, but with guaranteed left associativity, as in foldl. If provided, the keyword argument init will be used exactly once. In general, it will be necessary to provide init to work with empty collections.

source

Base.mapfoldr — Method

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

Like mapreduce, but with guaranteed right associativity, as in foldr. If provided, the keyword argument init will be used exactly once. In general, it will be necessary to provide init to work with empty collections.

source

Base.first — Function

first(coll)

Get the first element of an iterable collection. Return the start point of an AbstractRange even if it is empty.

Examples

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

source

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

Get a string consisting of the first n characters of s.

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

source

Base.last — Function

last(coll)

Get the last element of an ordered collection, if it can be computed in O(1) time. This is accomplished by calling lastindex to get the last index. Return the end point of an AbstractRange even if it is empty.

Examples

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

source

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

Get a string consisting of the last n characters of s.

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

source

Base.step — Function

step(r)

Get the step size of an AbstractRange object.

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

source

Base.collect — Method

collect(collection)

Return an Array of all items in a collection or iterator. For dictionaries, returns Pair{KeyType, ValType}. If the argument is array-like or is an iterator with the HasShape trait, the result will have the same shape and number of dimensions as the argument.

Examples

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

source

Base.collect — Method

collect(element_type, collection)

Return an Array with the given element type of all items in a collection or iterable. The result has the same shape and number of dimensions as collection.

Examples

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

source

Base.filter — Function

filter(f, a::AbstractArray)

Return a copy of a, removing elements for which f is false. The function f is passed one argument.

Examples

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

source

filter(f, d::AbstractDict)

Return a copy of d, removing elements for which f is false. The function f is passed key=>value pairs.

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"

source

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

Return a vector similar to the array wrapped by the given SkipMissing iterator but with all missing elements and those for which f returns false removed.

Julia 1.2

This method requires Julia 1.2 or later.

Examples

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