844 lines
122 KiB
HTML
844 lines
122 KiB
HTML
<!DOCTYPE html>
|
||
<html lang="en"><head><meta charset="UTF-8"/><meta name="viewport" content="width=device-width, initial-scale=1.0"/><title>Collections and Data Structures · The Julia Language</title><script>(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
|
||
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
|
||
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
|
||
})(window,document,'script','https://www.google-analytics.com/analytics.js','ga');
|
||
|
||
ga('create', 'UA-28835595-6', 'auto');
|
||
ga('send', 'pageview');
|
||
</script><link href="https://cdnjs.cloudflare.com/ajax/libs/normalize/4.2.0/normalize.min.css" rel="stylesheet" type="text/css"/><link href="https://fonts.googleapis.com/css?family=Lato|Roboto+Mono" rel="stylesheet" type="text/css"/><link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.6.3/css/font-awesome.min.css" rel="stylesheet" type="text/css"/><link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/default.min.css" rel="stylesheet" type="text/css"/><script>documenterBaseURL=".."</script><script src="https://cdnjs.cloudflare.com/ajax/libs/require.js/2.2.0/require.min.js" data-main="../assets/documenter.js"></script><script src="../siteinfo.js"></script><script src="../../versions.js"></script><link href="../assets/documenter.css" rel="stylesheet" type="text/css"/><link href="../assets/julia-manual.css" rel="stylesheet" type="text/css"/></head><body><nav class="toc"><a href="../index.html"><img class="logo" src="../assets/logo.png" alt="The Julia Language logo"/></a><h1>The Julia Language</h1><select id="version-selector" onChange="window.location.href=this.value" style="visibility: hidden"></select><form class="search" id="search-form" action="../search.html"><input id="search-query" name="q" type="text" placeholder="Search docs"/></form><ul><li><a class="toctext" href="../index.html">Home</a></li><li><span class="toctext">Manual</span><ul><li><a class="toctext" href="../manual/introduction.html">Introduction</a></li><li><a class="toctext" href="../manual/getting-started.html">Getting Started</a></li><li><a class="toctext" href="../manual/variables.html">Variables</a></li><li><a class="toctext" href="../manual/integers-and-floating-point-numbers.html">Integers and Floating-Point Numbers</a></li><li><a class="toctext" href="../manual/mathematical-operations.html">Mathematical Operations and Elementary Functions</a></li><li><a class="toctext" href="../manual/complex-and-rational-numbers.html">Complex and Rational Numbers</a></li><li><a class="toctext" href="../manual/strings.html">Strings</a></li><li><a class="toctext" href="../manual/functions.html">Functions</a></li><li><a class="toctext" href="../manual/control-flow.html">Control Flow</a></li><li><a class="toctext" href="../manual/variables-and-scoping.html">Scope of Variables</a></li><li><a class="toctext" href="../manual/types.html">Types</a></li><li><a class="toctext" href="../manual/methods.html">Methods</a></li><li><a class="toctext" href="../manual/constructors.html">Constructors</a></li><li><a class="toctext" href="../manual/conversion-and-promotion.html">Conversion and Promotion</a></li><li><a class="toctext" href="../manual/interfaces.html">Interfaces</a></li><li><a class="toctext" href="../manual/modules.html">Modules</a></li><li><a class="toctext" href="../manual/documentation.html">Documentation</a></li><li><a class="toctext" href="../manual/metaprogramming.html">Metaprogramming</a></li><li><a class="toctext" href="../manual/arrays.html">Multi-dimensional Arrays</a></li><li><a class="toctext" href="../manual/linear-algebra.html">Linear algebra</a></li><li><a class="toctext" href="../manual/networking-and-streams.html">Networking and Streams</a></li><li><a class="toctext" href="../manual/parallel-computing.html">Parallel Computing</a></li><li><a class="toctext" href="../manual/dates.html">Date and DateTime</a></li><li><a class="toctext" href="../manual/interacting-with-julia.html">Interacting With Julia</a></li><li><a class="toctext" href="../manual/running-external-programs.html">Running External Programs</a></li><li><a class="toctext" href="../manual/calling-c-and-fortran-code.html">Calling C and Fortran Code</a></li><li><a class="toctext" href="../manual/handling-operating-system-variation.html">Handling Operating System Variation</a></li><li><a class="toctext" href="../manual/environment-variables.html">Environment Variables</a></li><li><a class="toctext" href="../manual/embedding.html">Embedding Julia</a></li><li><a class="toctext" href="../manual/packages.html">Packages</a></li><li><a class="toctext" href="../manual/profile.html">Profiling</a></li><li><a class="toctext" href="../manual/stacktraces.html">Stack Traces</a></li><li><a class="toctext" href="../manual/performance-tips.html">Performance Tips</a></li><li><a class="toctext" href="../manual/workflow-tips.html">Workflow Tips</a></li><li><a class="toctext" href="../manual/style-guide.html">Style Guide</a></li><li><a class="toctext" href="../manual/faq.html">Frequently Asked Questions</a></li><li><a class="toctext" href="../manual/noteworthy-differences.html">Noteworthy Differences from other Languages</a></li><li><a class="toctext" href="../manual/unicode-input.html">Unicode Input</a></li></ul></li><li><span class="toctext">Standard Library</span><ul><li><a class="toctext" href="base.html">Essentials</a></li><li class="current"><a class="toctext" href="collections.html">Collections and Data Structures</a><ul class="internal"><li><a class="toctext" href="#lib-collections-iteration-1">Iteration</a></li><li><a class="toctext" href="#General-Collections-1">General Collections</a></li><li><a class="toctext" href="#Iterable-Collections-1">Iterable Collections</a></li><li><a class="toctext" href="#Indexable-Collections-1">Indexable Collections</a></li><li><a class="toctext" href="#Associative-Collections-1">Associative Collections</a></li><li><a class="toctext" href="#Set-Like-Collections-1">Set-Like Collections</a></li><li><a class="toctext" href="#Dequeues-1">Dequeues</a></li></ul></li><li><a class="toctext" href="math.html">Mathematics</a></li><li><a class="toctext" href="numbers.html">Numbers</a></li><li><a class="toctext" href="strings.html">Strings</a></li><li><a class="toctext" href="arrays.html">Arrays</a></li><li><a class="toctext" href="parallel.html">Tasks and Parallel Computing</a></li><li><a class="toctext" href="linalg.html">Linear Algebra</a></li><li><a class="toctext" href="constants.html">Constants</a></li><li><a class="toctext" href="file.html">Filesystem</a></li><li><a class="toctext" href="io-network.html">I/O and Network</a></li><li><a class="toctext" href="punctuation.html">Punctuation</a></li><li><a class="toctext" href="sort.html">Sorting and Related Functions</a></li><li><a class="toctext" href="pkg.html">Package Manager Functions</a></li><li><a class="toctext" href="dates.html">Dates and Time</a></li><li><a class="toctext" href="iterators.html">Iteration utilities</a></li><li><a class="toctext" href="test.html">Unit Testing</a></li><li><a class="toctext" href="c.html">C Interface</a></li><li><a class="toctext" href="libc.html">C Standard Library</a></li><li><a class="toctext" href="libdl.html">Dynamic Linker</a></li><li><a class="toctext" href="profile.html">Profiling</a></li><li><a class="toctext" href="stacktraces.html">StackTraces</a></li><li><a class="toctext" href="simd-types.html">SIMD Support</a></li></ul></li><li><span class="toctext">Developer Documentation</span><ul><li><a class="toctext" href="../devdocs/reflection.html">Reflection and introspection</a></li><li><span class="toctext">Documentation of Julia's Internals</span><ul><li><a class="toctext" href="../devdocs/init.html">Initialization of the Julia runtime</a></li><li><a class="toctext" href="../devdocs/ast.html">Julia ASTs</a></li><li><a class="toctext" href="../devdocs/types.html">More about types</a></li><li><a class="toctext" href="../devdocs/object.html">Memory layout of Julia Objects</a></li><li><a class="toctext" href="../devdocs/eval.html">Eval of Julia code</a></li><li><a class="toctext" href="../devdocs/callconv.html">Calling Conventions</a></li><li><a class="toctext" href="../devdocs/compiler.html">High-level Overview of the Native-Code Generation Process</a></li><li><a class="toctext" href="../devdocs/functions.html">Julia Functions</a></li><li><a class="toctext" href="../devdocs/cartesian.html">Base.Cartesian</a></li><li><a class="toctext" href="../devdocs/meta.html">Talking to the compiler (the <code>:meta</code> mechanism)</a></li><li><a class="toctext" href="../devdocs/subarrays.html">SubArrays</a></li><li><a class="toctext" href="../devdocs/sysimg.html">System Image Building</a></li><li><a class="toctext" href="../devdocs/llvm.html">Working with LLVM</a></li><li><a class="toctext" href="../devdocs/stdio.html">printf() and stdio in the Julia runtime</a></li><li><a class="toctext" href="../devdocs/boundscheck.html">Bounds checking</a></li><li><a class="toctext" href="../devdocs/locks.html">Proper maintenance and care of multi-threading locks</a></li><li><a class="toctext" href="../devdocs/offset-arrays.html">Arrays with custom indices</a></li><li><a class="toctext" href="../devdocs/libgit2.html">Base.LibGit2</a></li><li><a class="toctext" href="../devdocs/require.html">Module loading</a></li></ul></li><li><span class="toctext">Developing/debugging Julia's C code</span><ul><li><a class="toctext" href="../devdocs/backtraces.html">Reporting and analyzing crashes (segfaults)</a></li><li><a class="toctext" href="../devdocs/debuggingtips.html">gdb debugging tips</a></li><li><a class="toctext" href="../devdocs/valgrind.html">Using Valgrind with Julia</a></li><li><a class="toctext" href="../devdocs/sanitizers.html">Sanitizer support</a></li></ul></li></ul></li></ul></nav><article id="docs"><header><nav><ul><li>Standard Library</li><li><a href="collections.html">Collections and Data Structures</a></li></ul><a class="edit-page" href="https://github.com/JuliaLang/julia/blob/master/doc/src/stdlib/collections.md"><span class="fa"></span> Edit on GitHub</a></nav><hr/><div id="topbar"><span>Collections and Data Structures</span><a class="fa fa-bars" href="#"></a></div></header><h1><a class="nav-anchor" id="Collections-and-Data-Structures-1" href="#Collections-and-Data-Structures-1">Collections and Data Structures</a></h1><h2><a class="nav-anchor" id="lib-collections-iteration-1" href="#lib-collections-iteration-1">Iteration</a></h2><p>Sequential iteration is implemented by the methods <a href="collections.html#Base.start"><code>start()</code></a>, <a href="collections.html#Base.done"><code>done()</code></a>, and <a href="collections.html#Base.next"><code>next()</code></a>. The general <code>for</code> loop:</p><pre><code class="language-julia">for i = I # or "for i in I"
|
||
# body
|
||
end</code></pre><p>is translated into:</p><pre><code class="language-julia">state = start(I)
|
||
while !done(I, state)
|
||
(i, state) = next(I, state)
|
||
# body
|
||
end</code></pre><p>The <code>state</code> object may be anything, and should be chosen appropriately for each iterable type. See the <a href="../manual/interfaces.html#man-interface-iteration-1">manual section on the iteration interface</a> for more details about defining a custom iterable type.</p><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.start" href="#Base.start"><code>Base.start</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">start(iter) -> state</code></pre><p>Get initial iteration state for an iterable object.</p><p><strong>Examples</strong></p><pre><code class="language-julia-repl">julia> start(1:5)
|
||
1
|
||
|
||
julia> start([1;2;3])
|
||
1
|
||
|
||
julia> start([4;2;3])
|
||
1</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/docs/helpdb/Base.jl#L2119-L2135">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.done" href="#Base.done"><code>Base.done</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">done(iter, state) -> Bool</code></pre><p>Test whether we are done iterating.</p><p><strong>Examples</strong></p><pre><code class="language-julia-repl">julia> done(1:5, 3)
|
||
false
|
||
|
||
julia> done(1:5, 5)
|
||
false
|
||
|
||
julia> done(1:5, 6)
|
||
true</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/docs/helpdb/Base.jl#L2154-L2170">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.next" href="#Base.next"><code>Base.next</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">next(iter, state) -> item, state</code></pre><p>For a given iterable object and iteration state, return the current item and the next iteration state.</p><p><strong>Examples</strong></p><pre><code class="language-julia-repl">julia> next(1:5, 3)
|
||
(3, 4)
|
||
|
||
julia> next(1:5, 5)
|
||
(5, 6)</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/docs/helpdb/Base.jl#L1098-L1111">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.iteratorsize" href="#Base.iteratorsize"><code>Base.iteratorsize</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">iteratorsize(itertype::Type) -> IteratorSize</code></pre><p>Given the type of an iterator, returns one of the following values:</p><ul><li><p><code>SizeUnknown()</code> if the length (number of elements) cannot be determined in advance.</p></li><li><p><code>HasLength()</code> if there is a fixed, finite length.</p></li><li><p><code>HasShape()</code> if there is a known length plus a notion of multidimensional shape (as for an array). In this case the <a href="arrays.html#Base.size"><code>size</code></a> function is valid for the iterator.</p></li><li><p><code>IsInfinite()</code> if the iterator yields values forever.</p></li></ul><p>The default value (for iterators that do not define this function) is <code>HasLength()</code>. This means that most iterators are assumed to implement <a href="arrays.html#Base.length-Tuple{AbstractArray}"><code>length</code></a>.</p><p>This trait is generally used to select between algorithms that pre-allocate space for their result, and algorithms that resize their result incrementally.</p><pre><code class="language-julia-repl">julia> Base.iteratorsize(1:5)
|
||
Base.HasShape()
|
||
|
||
julia> Base.iteratorsize((2,3))
|
||
Base.HasLength()</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/generator.jl#L57-L81">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.iteratoreltype" href="#Base.iteratoreltype"><code>Base.iteratoreltype</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">iteratoreltype(itertype::Type) -> IteratorEltype</code></pre><p>Given the type of an iterator, returns one of the following values:</p><ul><li><p><code>EltypeUnknown()</code> if the type of elements yielded by the iterator is not known in advance.</p></li><li><p><code>HasEltype()</code> if the element type is known, and <a href="collections.html#Base.eltype"><code>eltype</code></a> would return a meaningful value.</p></li></ul><p><code>HasEltype()</code> is the default, since iterators are assumed to implement <a href="collections.html#Base.eltype"><code>eltype</code></a>.</p><p>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.</p><pre><code class="language-julia-repl">julia> Base.iteratoreltype(1:5)
|
||
Base.HasEltype()</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/generator.jl#L89-L107">source</a></section><p>Fully implemented by:</p><ul><li><p><code>Range</code></p></li><li><p><code>UnitRange</code></p></li><li><p><code>Tuple</code></p></li><li><p><code>Number</code></p></li><li><p><a href="arrays.html#Core.AbstractArray"><code>AbstractArray</code></a></p></li><li><p><a href="collections.html#Base.IntSet"><code>IntSet</code></a></p></li><li><p><a href="collections.html#Base.ObjectIdDict"><code>ObjectIdDict</code></a></p></li><li><p><a href="collections.html#Base.Dict"><code>Dict</code></a></p></li><li><p><a href="collections.html#Base.WeakKeyDict"><code>WeakKeyDict</code></a></p></li><li><p><code>EachLine</code></p></li><li><p><code>AbstractString</code></p></li><li><p><a href="collections.html#Base.Set"><code>Set</code></a></p></li></ul><h2><a class="nav-anchor" id="General-Collections-1" href="#General-Collections-1">General Collections</a></h2><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.isempty" href="#Base.isempty"><code>Base.isempty</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">isempty(collection) -> Bool</code></pre><p>Determine whether a collection is empty (has no elements).</p><p><strong>Examples</strong></p><pre><code class="language-julia-repl">julia> isempty([])
|
||
true
|
||
|
||
julia> isempty([1 2 3])
|
||
false</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/docs/helpdb/Base.jl#L1586-L1599">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.empty!" href="#Base.empty!"><code>Base.empty!</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">empty!(collection) -> collection</code></pre><p>Remove all elements from a <code>collection</code>.</p><pre><code class="language-julia-repl">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</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/dict.jl#L286-L302">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.length-Tuple{Any}" href="#Base.length-Tuple{Any}"><code>Base.length</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">length(collection) -> Integer</code></pre><p>For ordered, indexable collections, returns the maximum index <code>i</code> for which <code>getindex(collection, i)</code> is valid. For unordered collections, returns the number of elements.</p><p><strong>Examples</strong></p><pre><code class="language-julia-repl">julia> length(1:5)
|
||
5
|
||
|
||
julia> length([1; 2; 3; 4])
|
||
4</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/docs/helpdb/Base.jl#L2008-L2023">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.endof" href="#Base.endof"><code>Base.endof</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">endof(collection) -> Integer</code></pre><p>Returns the last index of the collection.</p><p><strong>Example</strong></p><pre><code class="language-julia-repl">julia> endof([1,2,4])
|
||
3</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/docs/helpdb/Base.jl#L1085-L1095">source</a></section><p>Fully implemented by:</p><ul><li><p><code>Range</code></p></li><li><p><code>UnitRange</code></p></li><li><p><code>Tuple</code></p></li><li><p><code>Number</code></p></li><li><p><a href="arrays.html#Core.AbstractArray"><code>AbstractArray</code></a></p></li><li><p><a href="collections.html#Base.IntSet"><code>IntSet</code></a></p></li><li><p><a href="collections.html#Base.ObjectIdDict"><code>ObjectIdDict</code></a></p></li><li><p><a href="collections.html#Base.Dict"><code>Dict</code></a></p></li><li><p><a href="collections.html#Base.WeakKeyDict"><code>WeakKeyDict</code></a></p></li><li><p><code>AbstractString</code></p></li><li><p><a href="collections.html#Base.Set"><code>Set</code></a></p></li></ul><h2><a class="nav-anchor" id="Iterable-Collections-1" href="#Iterable-Collections-1">Iterable Collections</a></h2><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.in" href="#Base.in"><code>Base.in</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">in(item, collection) -> Bool
|
||
∈(item,collection) -> Bool
|
||
∋(collection,item) -> Bool
|
||
∉(item,collection) -> Bool
|
||
∌(collection,item) -> Bool</code></pre><p>Determine whether an item is in the given collection, in the sense that it is <code>==</code> to one of the values generated by iterating over the collection. Some collections need a slightly different definition; for example <a href="collections.html#Base.Set"><code>Set</code></a>s check whether the item <a href="base.html#Base.isequal-Tuple{Any,Any}"><code>isequal</code></a> to one of the elements. <a href="collections.html#Base.Dict"><code>Dict</code></a>s look for <code>(key,value)</code> pairs, and the key is compared using <a href="base.html#Base.isequal-Tuple{Any,Any}"><code>isequal</code></a>. To test for the presence of a key in a dictionary, use <a href="collections.html#Base.haskey"><code>haskey</code></a> or <code>k in keys(dict)</code>.</p><pre><code class="language-julia-repl">julia> a = 1:3:20
|
||
1:3:19
|
||
|
||
julia> 4 in a
|
||
true
|
||
|
||
julia> 5 in a
|
||
false</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reduce.jl#L606-L630">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.eltype" href="#Base.eltype"><code>Base.eltype</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">eltype(type)</code></pre><p>Determine the type of the elements generated by iterating a collection of the given <code>type</code>. For associative collection types, this will be a <code>Pair{KeyType,ValType}</code>. The definition <code>eltype(x) = eltype(typeof(x))</code> 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.</p><pre><code class="language-julia-repl">julia> eltype(ones(Float32,2,2))
|
||
Float32
|
||
|
||
julia> eltype(ones(Int8,2,2))
|
||
Int8</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/array.jl#L26-L42">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.indexin" href="#Base.indexin"><code>Base.indexin</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">indexin(a, b)</code></pre><p>Returns a vector containing the highest index in <code>b</code> for each value in <code>a</code> that is a member of <code>b</code> . The output vector contains 0 wherever <code>a</code> is not a member of <code>b</code>.</p><p><strong>Examples</strong></p><pre><code class="language-julia-repl">julia> a = ['a', 'b', 'c', 'b', 'd', 'a'];
|
||
|
||
julia> b = ['a','b','c'];
|
||
|
||
julia> indexin(a,b)
|
||
6-element Array{Int64,1}:
|
||
1
|
||
2
|
||
3
|
||
2
|
||
0
|
||
1
|
||
|
||
julia> indexin(b,a)
|
||
3-element Array{Int64,1}:
|
||
6
|
||
4
|
||
3</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/array.jl#L1774-L1802">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.findin" href="#Base.findin"><code>Base.findin</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">findin(a, b)</code></pre><p>Returns the indices of elements in collection <code>a</code> that appear in collection <code>b</code>.</p><p><strong>Examples</strong></p><pre><code class="language-julia-repl">julia> a = collect(1:3:15)
|
||
5-element Array{Int64,1}:
|
||
1
|
||
4
|
||
7
|
||
10
|
||
13
|
||
|
||
julia> b = collect(2:4:10)
|
||
3-element Array{Int64,1}:
|
||
2
|
||
6
|
||
10
|
||
|
||
julia> findin(a,b) # 10 is the only common element
|
||
1-element Array{Int64,1}:
|
||
4</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/array.jl#L1808-L1833">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.unique" href="#Base.unique"><code>Base.unique</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">unique(itr)</code></pre><p>Returns an array containing one value from <code>itr</code> for each unique value, as determined by <a href="base.html#Base.isequal-Tuple{Any,Any}"><code>isequal</code></a>.</p><pre><code class="language-julia-repl">julia> unique([1; 2; 2; 6])
|
||
3-element Array{Int64,1}:
|
||
1
|
||
2
|
||
6</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/set.jl#L115-L128">source</a><div><pre><code class="language-none">unique(f, itr)</code></pre><p>Returns an array containing one value from <code>itr</code> for each unique value produced by <code>f</code> applied to elements of <code>itr</code>.</p><pre><code class="language-julia-repl">julia> unique(isodd, [1; 2; 2; 6])
|
||
2-element Array{Int64,1}:
|
||
1
|
||
2</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/set.jl#L170-L182">source</a><div><pre><code class="language-none">unique(itr[, dim])</code></pre><p>Returns an array containing only the unique elements of the iterable <code>itr</code>, in the order that the first of each set of equivalent elements originally appears. If <code>dim</code> is specified, returns unique regions of the array <code>itr</code> along <code>dim</code>.</p><pre><code class="language-julia-repl">julia> A = map(isodd, reshape(collect(1:8), (2,2,2)))
|
||
2×2×2 Array{Bool,3}:
|
||
[:, :, 1] =
|
||
true true
|
||
false false
|
||
|
||
[:, :, 2] =
|
||
true true
|
||
false false
|
||
|
||
julia> unique(A)
|
||
2-element Array{Bool,1}:
|
||
true
|
||
false
|
||
|
||
julia> unique(A, 2)
|
||
2×1×2 Array{Bool,3}:
|
||
[:, :, 1] =
|
||
true
|
||
false
|
||
|
||
[:, :, 2] =
|
||
true
|
||
false
|
||
|
||
julia> unique(A, 3)
|
||
2×2×1 Array{Bool,3}:
|
||
[:, :, 1] =
|
||
true true
|
||
false false</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/multidimensional.jl#L1353-L1392">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.allunique" href="#Base.allunique"><code>Base.allunique</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">allunique(itr) -> Bool</code></pre><p>Return <code>true</code> if all values from <code>itr</code> are distinct when compared with <a href="base.html#Base.isequal-Tuple{Any,Any}"><code>isequal</code></a>.</p><pre><code class="language-julia-repl">julia> a = [1; 2; 3]
|
||
3-element Array{Int64,1}:
|
||
1
|
||
2
|
||
3
|
||
|
||
julia> allunique([a, a])
|
||
false</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/set.jl#L196-L211">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.reduce-Tuple{Any,Any,Any}" href="#Base.reduce-Tuple{Any,Any,Any}"><code>Base.reduce</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">reduce(op, v0, itr)</code></pre><p>Reduce the given collection <code>ìtr</code> with the given binary operator <code>op</code>. <code>v0</code> must be a neutral element for <code>op</code> that will be returned for empty collections. It is unspecified whether <code>v0</code> is used for non-empty collections.</p><p>Reductions for certain commonly-used operators have special implementations which should be used instead: <code>maximum(itr)</code>, <code>minimum(itr)</code>, <code>sum(itr)</code>, <code>prod(itr)</code>, <code>any(itr)</code>, <code>all(itr)</code>.</p><p>The associativity of the reduction is implementation dependent. This means that you can't use non-associative operations like <code>-</code> because it is undefined whether <code>reduce(-,[1,2,3])</code> should be evaluated as <code>(1-2)-3</code> or <code>1-(2-3)</code>. Use <a href="collections.html#Base.foldl-Tuple{Any,Any,Any}"><code>foldl</code></a> or <a href="collections.html#Base.foldr-Tuple{Any,Any,Any}"><code>foldr</code></a> instead for guaranteed left or right associativity.</p><p>Some operations accumulate error, and parallelism will also 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.</p><p><strong>Examples</strong></p><pre><code class="language-julia-repl">julia> reduce(*, 1, [2; 3; 4])
|
||
24</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reduce.jl#L289-L315">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.reduce-Tuple{Any,Any}" href="#Base.reduce-Tuple{Any,Any}"><code>Base.reduce</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">reduce(op, itr)</code></pre><p>Like <code>reduce(op, v0, itr)</code>. This cannot be used with empty collections, except for some special cases (e.g. when <code>op</code> is one of <code>+</code>, <code>*</code>, <code>max</code>, <code>min</code>, <code>&</code>, <code>|</code>) when Julia can determine the neutral element of <code>op</code>.</p><pre><code class="language-julia-repl">julia> reduce(*, [2; 3; 4])
|
||
24</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reduce.jl#L318-L329">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.foldl-Tuple{Any,Any,Any}" href="#Base.foldl-Tuple{Any,Any,Any}"><code>Base.foldl</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">foldl(op, v0, itr)</code></pre><p>Like <a href="collections.html#Base.reduce-Tuple{Any,Any,Any}"><code>reduce</code></a>, but with guaranteed left associativity. <code>v0</code> will be used exactly once.</p><pre><code class="language-julia-repl">julia> foldl(-, 1, 2:5)
|
||
-13</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reduce.jl#L76-L86">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.foldl-Tuple{Any,Any}" href="#Base.foldl-Tuple{Any,Any}"><code>Base.foldl</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">foldl(op, itr)</code></pre><p>Like <code>foldl(op, v0, itr)</code>, but using the first element of <code>itr</code> as <code>v0</code>. In general, this cannot be used with empty collections (see <code>reduce(op, itr)</code>).</p><pre><code class="language-julia-repl">julia> foldl(-, 2:5)
|
||
-10</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reduce.jl#L89-L99">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.foldr-Tuple{Any,Any,Any}" href="#Base.foldr-Tuple{Any,Any,Any}"><code>Base.foldr</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">foldr(op, v0, itr)</code></pre><p>Like <a href="collections.html#Base.reduce-Tuple{Any,Any,Any}"><code>reduce</code></a>, but with guaranteed right associativity. <code>v0</code> will be used exactly once.</p><pre><code class="language-julia-repl">julia> foldr(-, 1, 2:5)
|
||
-1</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reduce.jl#L142-L152">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.foldr-Tuple{Any,Any}" href="#Base.foldr-Tuple{Any,Any}"><code>Base.foldr</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">foldr(op, itr)</code></pre><p>Like <code>foldr(op, v0, itr)</code>, but using the last element of <code>itr</code> as <code>v0</code>. In general, this cannot be used with empty collections (see <code>reduce(op, itr)</code>).</p><pre><code class="language-julia-repl">julia> foldr(-, 2:5)
|
||
-2</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reduce.jl#L155-L165">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.maximum-Tuple{Any}" href="#Base.maximum-Tuple{Any}"><code>Base.maximum</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">maximum(itr)</code></pre><p>Returns the largest element in a collection.</p><pre><code class="language-julia-repl">julia> maximum(-20.5:10)
|
||
9.5
|
||
|
||
julia> maximum([1,2,3])
|
||
3</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reduce.jl#L441-L453">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.maximum-Tuple{Any,Any}" href="#Base.maximum-Tuple{Any,Any}"><code>Base.maximum</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">maximum(A, dims)</code></pre><p>Compute the maximum value of an array over the given dimensions. See also the <a href="math.html#Base.max"><code>max(a,b)</code></a> function to take the maximum of two or more arguments, which can be applied elementwise to arrays via <code>max.(a,b)</code>.</p><pre><code class="language-julia-repl">julia> A = [1 2; 3 4]
|
||
2×2 Array{Int64,2}:
|
||
1 2
|
||
3 4
|
||
|
||
julia> maximum(A, 1)
|
||
1×2 Array{Int64,2}:
|
||
3 4
|
||
|
||
julia> maximum(A, 2)
|
||
2×1 Array{Int64,2}:
|
||
2
|
||
4</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reducedim.jl#L378-L400">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.maximum!" href="#Base.maximum!"><code>Base.maximum!</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">maximum!(r, A)</code></pre><p>Compute the maximum value of <code>A</code> over the singleton dimensions of <code>r</code>, and write results to <code>r</code>.</p><p><strong>Examples</strong></p><pre><code class="language-julia-repl">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</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reducedim.jl#L403-L424">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.minimum-Tuple{Any}" href="#Base.minimum-Tuple{Any}"><code>Base.minimum</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">minimum(itr)</code></pre><p>Returns the smallest element in a collection.</p><pre><code class="language-julia-repl">julia> minimum(-20.5:10)
|
||
-20.5
|
||
|
||
julia> minimum([1,2,3])
|
||
1</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reduce.jl#L456-L468">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.minimum-Tuple{Any,Any}" href="#Base.minimum-Tuple{Any,Any}"><code>Base.minimum</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">minimum(A, dims)</code></pre><p>Compute the minimum value of an array over the given dimensions. See also the <a href="math.html#Base.min"><code>min(a,b)</code></a> function to take the minimum of two or more arguments, which can be applied elementwise to arrays via <code>min.(a,b)</code>.</p><p><strong>Examples</strong></p><pre><code class="language-julia-repl">julia> A = [1 2; 3 4]
|
||
2×2 Array{Int64,2}:
|
||
1 2
|
||
3 4
|
||
|
||
julia> minimum(A, 1)
|
||
1×2 Array{Int64,2}:
|
||
1 2
|
||
|
||
julia> minimum(A, 2)
|
||
2×1 Array{Int64,2}:
|
||
1
|
||
3</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reducedim.jl#L427-L450">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.minimum!" href="#Base.minimum!"><code>Base.minimum!</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">minimum!(r, A)</code></pre><p>Compute the minimum value of <code>A</code> over the singleton dimensions of <code>r</code>, and write results to <code>r</code>.</p><p><strong>Examples</strong></p><pre><code class="language-julia-repl">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</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reducedim.jl#L453-L474">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.extrema-Tuple{Any}" href="#Base.extrema-Tuple{Any}"><code>Base.extrema</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">extrema(itr) -> Tuple</code></pre><p>Compute both the minimum and maximum element in a single pass, and return them as a 2-tuple.</p><pre><code class="language-julia-repl">julia> extrema(2:10)
|
||
(2, 10)
|
||
|
||
julia> extrema([9,pi,4.5])
|
||
(3.141592653589793, 9.0)</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reduce.jl#L476-L488">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.extrema-Tuple{AbstractArray,Any}" href="#Base.extrema-Tuple{AbstractArray,Any}"><code>Base.extrema</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">extrema(A, dims) -> Array{Tuple}</code></pre><p>Compute the minimum and maximum elements of an array over the given dimensions.</p><p><strong>Example</strong></p><pre><code class="language-julia-repl">julia> A = reshape(collect(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, (1,2))
|
||
1×1×2 Array{Tuple{Int64,Int64},3}:
|
||
[:, :, 1] =
|
||
(1, 7)
|
||
|
||
[:, :, 2] =
|
||
(9, 15)</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/multidimensional.jl#L1464-L1489">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.indmax" href="#Base.indmax"><code>Base.indmax</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">indmax(itr) -> Integer</code></pre><p>Returns the index of the maximum element in a collection. If there are multiple maximal elements, then the first one will be returned. <code>NaN</code> values are ignored, unless all elements are <code>NaN</code>.</p><p>The collection must not be empty.</p><p><strong>Examples</strong></p><pre><code class="language-julia-repl">julia> indmax([8,0.1,-9,pi])
|
||
1
|
||
|
||
julia> indmax([1,7,7,6])
|
||
2
|
||
|
||
julia> indmax([1,7,7,NaN])
|
||
2</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/array.jl#L1727-L1747">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.indmin" href="#Base.indmin"><code>Base.indmin</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">indmin(itr) -> Integer</code></pre><p>Returns the index of the minimum element in a collection. If there are multiple minimal elements, then the first one will be returned. <code>NaN</code> values are ignored, unless all elements are <code>NaN</code>.</p><p>The collection must not be empty.</p><p><strong>Examples</strong></p><pre><code class="language-julia-repl">julia> indmin([8,0.1,-9,pi])
|
||
3
|
||
|
||
julia> indmin([7,1,1,6])
|
||
2
|
||
|
||
julia> indmin([7,1,1,NaN])
|
||
2</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/array.jl#L1750-L1770">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.findmax-Tuple{Any}" href="#Base.findmax-Tuple{Any}"><code>Base.findmax</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">findmax(itr) -> (x, index)</code></pre><p>Returns the maximum element of the collection <code>itr</code> and its index. If there are multiple maximal elements, then the first one will be returned. <code>NaN</code> values are ignored, unless all elements are <code>NaN</code>.</p><p>The collection must not be empty.</p><p><strong>Examples</strong></p><pre><code class="language-julia-repl">julia> findmax([8,0.1,-9,pi])
|
||
(8.0, 1)
|
||
|
||
julia> findmax([1,7,7,6])
|
||
(7, 2)
|
||
|
||
julia> findmax([1,7,7,NaN])
|
||
(7.0, 2)</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/array.jl#L1649-L1669">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.findmax-Tuple{AbstractArray,Any}" href="#Base.findmax-Tuple{AbstractArray,Any}"><code>Base.findmax</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">findmax(A, region) -> (maxval, index)</code></pre><p>For an array input, returns the value and index of the maximum over the given region.</p><p><strong>Examples</strong></p><pre><code class="language-julia-repl">julia> A = [1 2; 3 4]
|
||
2×2 Array{Int64,2}:
|
||
1 2
|
||
3 4
|
||
|
||
julia> findmax(A,1)
|
||
([3 4], [2 4])
|
||
|
||
julia> findmax(A,2)
|
||
([2; 4], [3; 4])</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reducedim.jl#L687-L705">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.findmin-Tuple{Any}" href="#Base.findmin-Tuple{Any}"><code>Base.findmin</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">findmin(itr) -> (x, index)</code></pre><p>Returns the minimum element of the collection <code>itr</code> and its index. If there are multiple minimal elements, then the first one will be returned. <code>NaN</code> values are ignored, unless all elements are <code>NaN</code>.</p><p>The collection must not be empty.</p><p><strong>Examples</strong></p><pre><code class="language-julia-repl">julia> findmin([8,0.1,-9,pi])
|
||
(-9.0, 3)
|
||
|
||
julia> findmin([7,1,1,6])
|
||
(1, 2)
|
||
|
||
julia> findmin([7,1,1,NaN])
|
||
(1.0, 2)</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/array.jl#L1688-L1708">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.findmin-Tuple{AbstractArray,Any}" href="#Base.findmin-Tuple{AbstractArray,Any}"><code>Base.findmin</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">findmin(A, region) -> (minval, index)</code></pre><p>For an array input, returns the value and index of the minimum over the given region.</p><p><strong>Examples</strong></p><pre><code class="language-julia-repl">julia> A = [1 2; 3 4]
|
||
2×2 Array{Int64,2}:
|
||
1 2
|
||
3 4
|
||
|
||
julia> findmin(A, 1)
|
||
([1 2], [1 3])
|
||
|
||
julia> findmin(A, 2)
|
||
([1; 3], [1; 2])</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reducedim.jl#L648-L666">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.findmax!" href="#Base.findmax!"><code>Base.findmax!</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">findmax!(rval, rind, A, [init=true]) -> (maxval, index)</code></pre><p>Find the maximum of <code>A</code> and the corresponding linear index along singleton dimensions of <code>rval</code> and <code>rind</code>, and store the results in <code>rval</code> and <code>rind</code>.</p></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reducedim.jl#L676-L681">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.findmin!" href="#Base.findmin!"><code>Base.findmin!</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">findmin!(rval, rind, A, [init=true]) -> (minval, index)</code></pre><p>Find the minimum of <code>A</code> and the corresponding linear index along singleton dimensions of <code>rval</code> and <code>rind</code>, and store the results in <code>rval</code> and <code>rind</code>.</p></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reducedim.jl#L637-L642">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.sum" href="#Base.sum"><code>Base.sum</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">sum(f, itr)</code></pre><p>Sum the results of calling function <code>f</code> on each element of <code>itr</code>.</p><pre><code class="language-julia-repl">julia> sum(abs2, [2; 3; 4])
|
||
29</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reduce.jl#L337-L346">source</a><div><pre><code class="language-none">sum(itr)</code></pre><p>Returns the sum of all elements in a collection.</p><pre><code class="language-julia-repl">julia> sum(1:20)
|
||
210</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reduce.jl#L349-L358">source</a><div><pre><code class="language-none">sum(A, dims)</code></pre><p>Sum elements of an array over the given dimensions.</p><p><strong>Examples</strong></p><pre><code class="language-julia-repl">julia> A = [1 2; 3 4]
|
||
2×2 Array{Int64,2}:
|
||
1 2
|
||
3 4
|
||
|
||
julia> sum(A, 1)
|
||
1×2 Array{Int64,2}:
|
||
4 6
|
||
|
||
julia> sum(A, 2)
|
||
2×1 Array{Int64,2}:
|
||
3
|
||
7</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reducedim.jl#L282-L303">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.sum!" href="#Base.sum!"><code>Base.sum!</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">sum!(r, A)</code></pre><p>Sum elements of <code>A</code> over the singleton dimensions of <code>r</code>, and write results to <code>r</code>.</p><p><strong>Examples</strong></p><pre><code class="language-julia-repl">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</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reducedim.jl#L306-L327">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.prod" href="#Base.prod"><code>Base.prod</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">prod(f, itr)</code></pre><p>Returns the product of <code>f</code> applied to each element of <code>itr</code>.</p><pre><code class="language-julia-repl">julia> prod(abs2, [2; 3; 4])
|
||
576</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reduce.jl#L395-L404">source</a><div><pre><code class="language-none">prod(itr)</code></pre><p>Returns the product of all elements of a collection.</p><pre><code class="language-julia-repl">julia> prod(1:20)
|
||
2432902008176640000</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reduce.jl#L407-L416">source</a><div><pre><code class="language-none">prod(A, dims)</code></pre><p>Multiply elements of an array over the given dimensions.</p><p><strong>Examples</strong></p><pre><code class="language-julia-repl">julia> A = [1 2; 3 4]
|
||
2×2 Array{Int64,2}:
|
||
1 2
|
||
3 4
|
||
|
||
julia> prod(A, 1)
|
||
1×2 Array{Int64,2}:
|
||
3 8
|
||
|
||
julia> prod(A, 2)
|
||
2×1 Array{Int64,2}:
|
||
2
|
||
12</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reducedim.jl#L330-L351">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.prod!" href="#Base.prod!"><code>Base.prod!</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">prod!(r, A)</code></pre><p>Multiply elements of <code>A</code> over the singleton dimensions of <code>r</code>, and write results to <code>r</code>.</p><p><strong>Examples</strong></p><pre><code class="language-julia-repl">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</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reducedim.jl#L354-L375">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.any-Tuple{Any}" href="#Base.any-Tuple{Any}"><code>Base.any</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">any(itr) -> Bool</code></pre><p>Test whether any elements of a boolean collection are <code>true</code>, returning <code>true</code> as soon as the first <code>true</code> value in <code>itr</code> is encountered (short-circuiting).</p><pre><code class="language-julia-repl">julia> a = [true,false,false,true]
|
||
4-element Array{Bool,1}:
|
||
true
|
||
false
|
||
false
|
||
true
|
||
|
||
julia> any(a)
|
||
true
|
||
|
||
julia> any((println(i); v) for (i, v) in enumerate(a))
|
||
1
|
||
true</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reduce.jl#L504-L525">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.any-Tuple{AbstractArray,Any}" href="#Base.any-Tuple{AbstractArray,Any}"><code>Base.any</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">any(A, dims)</code></pre><p>Test whether any values along the given dimensions of an array are <code>true</code>.</p><p><strong>Examples</strong></p><pre><code class="language-julia-repl">julia> A = [true false; true false]
|
||
2×2 Array{Bool,2}:
|
||
true false
|
||
true false
|
||
|
||
julia> any(A, 1)
|
||
1×2 Array{Bool,2}:
|
||
true false
|
||
|
||
julia> any(A, 2)
|
||
2×1 Array{Bool,2}:
|
||
true
|
||
true</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reducedim.jl#L525-L546">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.any!" href="#Base.any!"><code>Base.any!</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">any!(r, A)</code></pre><p>Test whether any values in <code>A</code> along the singleton dimensions of <code>r</code> are <code>true</code>, and write results to <code>r</code>.</p><p><strong>Examples</strong></p><pre><code class="language-julia-repl">julia> A = [true false; true false]
|
||
2×2 Array{Bool,2}:
|
||
true false
|
||
true false
|
||
|
||
julia> any!([1; 1], A)
|
||
2-element Array{Int64,1}:
|
||
1
|
||
1
|
||
|
||
julia> any!([1 1], A)
|
||
1×2 Array{Int64,2}:
|
||
1 0</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reducedim.jl#L549-L571">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.all-Tuple{Any}" href="#Base.all-Tuple{Any}"><code>Base.all</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">all(itr) -> Bool</code></pre><p>Test whether all elements of a boolean collection are <code>true</code>, returning <code>false</code> as soon as the first <code>false</code> value in <code>itr</code> is encountered (short-circuiting).</p><pre><code class="language-julia-repl">julia> a = [true,false,false,true]
|
||
4-element Array{Bool,1}:
|
||
true
|
||
false
|
||
false
|
||
true
|
||
|
||
julia> all(a)
|
||
false
|
||
|
||
julia> all((println(i); v) for (i, v) in enumerate(a))
|
||
1
|
||
2
|
||
false</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reduce.jl#L528-L550">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.all-Tuple{AbstractArray,Any}" href="#Base.all-Tuple{AbstractArray,Any}"><code>Base.all</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">all(A, dims)</code></pre><p>Test whether all values along the given dimensions of an array are <code>true</code>.</p><p><strong>Examples</strong></p><pre><code class="language-julia-repl">julia> A = [true false; true true]
|
||
2×2 Array{Bool,2}:
|
||
true false
|
||
true true
|
||
|
||
julia> all(A, 1)
|
||
1×2 Array{Bool,2}:
|
||
true false
|
||
|
||
julia> all(A, 2)
|
||
2×1 Array{Bool,2}:
|
||
false
|
||
true</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reducedim.jl#L477-L498">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.all!" href="#Base.all!"><code>Base.all!</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">all!(r, A)</code></pre><p>Test whether all values in <code>A</code> along the singleton dimensions of <code>r</code> are <code>true</code>, and write results to <code>r</code>.</p><p><strong>Examples</strong></p><pre><code class="language-julia-repl">julia> A = [true false; true false]
|
||
2×2 Array{Bool,2}:
|
||
true false
|
||
true false
|
||
|
||
julia> all!([1; 1], A)
|
||
2-element Array{Int64,1}:
|
||
0
|
||
0
|
||
|
||
julia> all!([1 1], A)
|
||
1×2 Array{Int64,2}:
|
||
1 0</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reducedim.jl#L501-L522">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.count" href="#Base.count"><code>Base.count</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">count(p, itr) -> Integer
|
||
count(itr) -> Integer</code></pre><p>Count the number of elements in <code>itr</code> for which predicate <code>p</code> returns <code>true</code>. If <code>p</code> is omitted, counts the number of <code>true</code> elements in <code>itr</code> (which should be a collection of boolean values).</p><pre><code class="language-julia-repl">julia> count(i->(4<=i<=6), [2,3,4,5,6])
|
||
3
|
||
|
||
julia> count([true, false, true, true])
|
||
3</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reduce.jl#L673-L688">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.any-Tuple{Any,Any}" href="#Base.any-Tuple{Any,Any}"><code>Base.any</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">any(p, itr) -> Bool</code></pre><p>Determine whether predicate <code>p</code> returns <code>true</code> for any elements of <code>itr</code>, returning <code>true</code> as soon as the first item in <code>itr</code> for which <code>p</code> returns <code>true</code> is encountered (short-circuiting).</p><pre><code class="language-julia-repl">julia> any(i->(4<=i<=6), [3,5,7])
|
||
true
|
||
|
||
julia> any(i -> (println(i); i > 3), 1:10)
|
||
1
|
||
2
|
||
3
|
||
4
|
||
true</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reduce.jl#L553-L571">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.all-Tuple{Any,Any}" href="#Base.all-Tuple{Any,Any}"><code>Base.all</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">all(p, itr) -> Bool</code></pre><p>Determine whether predicate <code>p</code> returns <code>true</code> for all elements of <code>itr</code>, returning <code>false</code> as soon as the first item in <code>itr</code> for which <code>p</code> returns <code>false</code> is encountered (short-circuiting).</p><pre><code class="language-julia-repl">julia> all(i->(4<=i<=6), [4,5,6])
|
||
true
|
||
|
||
julia> all(i -> (println(i); i < 3), 1:10)
|
||
1
|
||
2
|
||
3
|
||
false</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reduce.jl#L579-L596">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.foreach" href="#Base.foreach"><code>Base.foreach</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">foreach(f, c...) -> Void</code></pre><p>Call function <code>f</code> on each element of iterable <code>c</code>. For multiple iterable arguments, <code>f</code> is called elementwise. <code>foreach</code> should be used instead of <code>map</code> when the results of <code>f</code> are not needed, for example in <code>foreach(println, array)</code>.</p><p><strong>Example</strong></p><pre><code class="language-julia-repl">julia> a = 1:3:7;
|
||
|
||
julia> foreach(x -> println(x^2), a)
|
||
1
|
||
16
|
||
49</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/abstractarray.jl#L1714-L1731">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.map" href="#Base.map"><code>Base.map</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">map(f, c...) -> collection</code></pre><p>Transform collection <code>c</code> by applying <code>f</code> to each element. For multiple collection arguments, apply <code>f</code> elementwise.</p><p><strong>Examples</strong></p><pre><code class="language-julia-repl">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</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/abstractarray.jl#L1871-L1891">source</a><div><pre><code class="language-none">map(f, x::Nullable)</code></pre><p>Return <code>f</code> applied to the value of <code>x</code> if it has one, as a <code>Nullable</code>. If <code>x</code> is null, then return a null value of type <code>Nullable{S}</code>. <code>S</code> is guaranteed to be either <code>Union{}</code> or a concrete type. Whichever of these is chosen is an implementation detail, but typically the choice that maximizes performance would be used. If <code>x</code> has a value, then the return type is guaranteed to be of type <code>Nullable{typeof(f(x))}</code>.</p></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/nullable.jl#L270-L279">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.map!" href="#Base.map!"><code>Base.map!</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">map!(function, destination, collection...)</code></pre><p>Like <a href="collections.html#Base.map"><code>map</code></a>, but stores the result in <code>destination</code> rather than a new collection. <code>destination</code> must be at least as large as the first collection.</p><p><strong>Example</strong></p><pre><code class="language-julia-repl">julia> x = zeros(3);
|
||
|
||
julia> map!(x -> x * 2, x, [1, 2, 3]);
|
||
|
||
julia> x
|
||
3-element Array{Float64,1}:
|
||
2.0
|
||
4.0
|
||
6.0</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/abstractarray.jl#L1914-L1932">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.mapreduce-NTuple{4,Any}" href="#Base.mapreduce-NTuple{4,Any}"><code>Base.mapreduce</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">mapreduce(f, op, v0, itr)</code></pre><p>Apply function <code>f</code> to each element in <code>itr</code>, and then reduce the result using the binary function <code>op</code>. <code>v0</code> must be a neutral element for <code>op</code> that will be returned for empty collections. It is unspecified whether <code>v0</code> is used for non-empty collections.</p><p><a href="collections.html#Base.mapreduce-NTuple{4,Any}"><code>mapreduce</code></a> is functionally equivalent to calling <code>reduce(op, v0, map(f, itr))</code>, but will in general execute faster since no intermediate collection needs to be created. See documentation for <a href="collections.html#Base.reduce-Tuple{Any,Any,Any}"><code>reduce</code></a> and <a href="collections.html#Base.map"><code>map</code></a>.</p><pre><code class="language-julia-repl">julia> mapreduce(x->x^2, +, [1:3;]) # == 1 + 4 + 9
|
||
14</code></pre><p>The associativity of the reduction is implementation-dependent. Additionally, some implementations may reuse the return value of <code>f</code> for elements that appear multiple times in <code>itr</code>. Use <a href="collections.html#Base.mapfoldl-NTuple{4,Any}"><code>mapfoldl</code></a> or <a href="collections.html#Base.mapfoldr-NTuple{4,Any}"><code>mapfoldr</code></a> instead for guaranteed left or right associativity and invocation of <code>f</code> for every value.</p></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reduce.jl#L208-L228">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.mapreduce-Tuple{Any,Any,Any}" href="#Base.mapreduce-Tuple{Any,Any,Any}"><code>Base.mapreduce</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">mapreduce(f, op, itr)</code></pre><p>Like <code>mapreduce(f, op, v0, itr)</code>. In general, this cannot be used with empty collections (see <code>reduce(op, itr)</code>).</p></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reduce.jl#L200-L205">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.mapfoldl-NTuple{4,Any}" href="#Base.mapfoldl-NTuple{4,Any}"><code>Base.mapfoldl</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">mapfoldl(f, op, v0, itr)</code></pre><p>Like <a href="collections.html#Base.mapreduce-NTuple{4,Any}"><code>mapreduce</code></a>, but with guaranteed left associativity, as in <a href="collections.html#Base.foldl-Tuple{Any,Any,Any}"><code>foldl</code></a>. <code>v0</code> will be used exactly once.</p></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reduce.jl#L52-L57">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.mapfoldl-Tuple{Any,Any,Any}" href="#Base.mapfoldl-Tuple{Any,Any,Any}"><code>Base.mapfoldl</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">mapfoldl(f, op, itr)</code></pre><p>Like <code>mapfoldl(f, op, v0, itr)</code>, but using the first element of <code>itr</code> as <code>v0</code>. In general, this cannot be used with empty collections (see <code>reduce(op, itr)</code>).</p></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reduce.jl#L60-L65">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.mapfoldr-NTuple{4,Any}" href="#Base.mapfoldr-NTuple{4,Any}"><code>Base.mapfoldr</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">mapfoldr(f, op, v0, itr)</code></pre><p>Like <a href="collections.html#Base.mapreduce-NTuple{4,Any}"><code>mapreduce</code></a>, but with guaranteed right associativity, as in <a href="collections.html#Base.foldr-Tuple{Any,Any,Any}"><code>foldr</code></a>. <code>v0</code> will be used exactly once.</p></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reduce.jl#L120-L125">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.mapfoldr-Tuple{Any,Any,Any}" href="#Base.mapfoldr-Tuple{Any,Any,Any}"><code>Base.mapfoldr</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">mapfoldr(f, op, itr)</code></pre><p>Like <code>mapfoldr(f, op, v0, itr)</code>, but using the first element of <code>itr</code> as <code>v0</code>. In general, this cannot be used with empty collections (see <code>reduce(op, itr)</code>).</p></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/reduce.jl#L128-L133">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.first" href="#Base.first"><code>Base.first</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">first(coll)</code></pre><p>Get the first element of an iterable collection. Returns the start point of a <code>Range</code> even if it is empty.</p><pre><code class="language-julia-repl">julia> first(2:2:10)
|
||
2
|
||
|
||
julia> first([1; 2; 3; 4])
|
||
1</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/abstractarray.jl#L137-L150">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.last" href="#Base.last"><code>Base.last</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">last(coll)</code></pre><p>Get the last element of an ordered collection, if it can be computed in O(1) time. This is accomplished by calling <a href="collections.html#Base.endof"><code>endof</code></a> to get the last index. Returns the end point of a <code>Range</code> even if it is empty.</p><pre><code class="language-julia-repl">julia> last(1:2:10)
|
||
9
|
||
|
||
julia> last([1; 2; 3; 4])
|
||
4</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/abstractarray.jl#L157-L171">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.step" href="#Base.step"><code>Base.step</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">step(r)</code></pre><p>Get the step size of a <code>Range</code> object.</p><pre><code class="language-julia-repl">julia> step(1:10)
|
||
1
|
||
|
||
julia> step(1:2:10)
|
||
2
|
||
|
||
julia> step(2.5:0.3:10.9)
|
||
0.3
|
||
|
||
julia> step(linspace(2.5,10.9,85))
|
||
0.1</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/range.jl#L343-L360">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.collect-Tuple{Any}" href="#Base.collect-Tuple{Any}"><code>Base.collect</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">collect(collection)</code></pre><p>Return an <code>Array</code> of all items in a collection or iterator. For associative collections, returns <code>Pair{KeyType, ValType}</code>. If the argument is array-like or is an iterator with the <code>HasShape()</code> trait, the result will have the same shape and number of dimensions as the argument.</p><p><strong>Example</strong></p><pre><code class="language-julia-repl">julia> collect(1:2:13)
|
||
7-element Array{Int64,1}:
|
||
1
|
||
3
|
||
5
|
||
7
|
||
9
|
||
11
|
||
13</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/array.jl#L406-L425">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.collect-Tuple{Type,Any}" href="#Base.collect-Tuple{Type,Any}"><code>Base.collect</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">collect(element_type, collection)</code></pre><p>Return an <code>Array</code> with the given element type of all items in a collection or iterable. The result has the same shape and number of dimensions as <code>collection</code>.</p><pre><code class="language-julia-repl">julia> collect(Float64, 1:2:5)
|
||
3-element Array{Float64,1}:
|
||
1.0
|
||
3.0
|
||
5.0</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/array.jl#L374-L387">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.issubset-Tuple{Any,Any}" href="#Base.issubset-Tuple{Any,Any}"><code>Base.issubset</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">issubset(a, b)
|
||
⊆(a,b) -> Bool
|
||
⊈(a,b) -> Bool
|
||
⊊(a,b) -> Bool</code></pre><p>Determine whether every element of <code>a</code> is also in <code>b</code>, using <a href="collections.html#Base.in"><code>in</code></a>.</p><p><strong>Examples</strong></p><pre><code class="language-julia-repl">julia> issubset([1, 2], [1, 2, 3])
|
||
true
|
||
|
||
julia> issubset([1, 2, 3], [1, 2])
|
||
false</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/docs/helpdb/Base.jl#L2326-L2342">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.filter" href="#Base.filter"><code>Base.filter</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">filter(function, collection)</code></pre><p>Return a copy of <code>collection</code>, removing elements for which <code>function</code> is <code>false</code>. For associative collections, the function is passed two arguments (key and value).</p><p><strong>Examples</strong></p><pre><code class="language-jldocttest">julia> a = 1:10
|
||
1:10
|
||
|
||
julia> filter(isodd, a)
|
||
5-element Array{Int64,1}:
|
||
1
|
||
3
|
||
5
|
||
7
|
||
9
|
||
|
||
julia> d = Dict(1=>"a", 2=>"b")
|
||
Dict{Int64,String} with 2 entries:
|
||
2 => "b"
|
||
1 => "a"
|
||
|
||
julia> filter((x,y)->isodd(x), d)
|
||
Dict{Int64,String} with 1 entry:
|
||
1 => "a"</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/array.jl#L1869-L1897">source</a><div><pre><code class="language-none">filter(p, x::Nullable)</code></pre><p>Return null if either <code>x</code> is null or <code>p(get(x))</code> is false, and <code>x</code> otherwise.</p></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/nullable.jl#L251-L255">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.filter!" href="#Base.filter!"><code>Base.filter!</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">filter!(function, collection)</code></pre><p>Update <code>collection</code>, removing elements for which <code>function</code> is <code>false</code>. For associative collections, the function is passed two arguments (key and value).</p><p><strong>Example</strong></p><pre><code class="language-julia-repl">julia> filter!(isodd, collect(1:10))
|
||
5-element Array{Int64,1}:
|
||
1
|
||
3
|
||
5
|
||
7
|
||
9</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/docs/helpdb/Base.jl#L313-L329">source</a></section><h2><a class="nav-anchor" id="Indexable-Collections-1" href="#Indexable-Collections-1">Indexable Collections</a></h2><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.getindex-Tuple{Any,Vararg{Any,N} where N}" href="#Base.getindex-Tuple{Any,Vararg{Any,N} where N}"><code>Base.getindex</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">getindex(collection, key...)</code></pre><p>Retrieve the value(s) stored at the given key or index within a collection. The syntax <code>a[i,j,...]</code> is converted by the compiler to <code>getindex(a, i, j, ...)</code>.</p><p><strong>Example</strong></p><pre><code class="language-julia-repl">julia> A = Dict("a" => 1, "b" => 2)
|
||
Dict{String,Int64} with 2 entries:
|
||
"b" => 2
|
||
"a" => 1
|
||
|
||
julia> getindex(A, "a")
|
||
1</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/docs/helpdb/Base.jl#L150-L166">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.setindex!-Tuple{Any,Any,Vararg{Any,N} where N}" href="#Base.setindex!-Tuple{Any,Any,Vararg{Any,N} where N}"><code>Base.setindex!</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">setindex!(collection, value, key...)</code></pre><p>Store the given value at the given key or index within a collection. The syntax <code>a[i,j,...] = x</code> is converted by the compiler to <code>(setindex!(a, x, i, j, ...); x)</code>.</p></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/docs/helpdb/Base.jl#L2295-L2300">source</a></section><p>Fully implemented by:</p><ul><li><p><a href="arrays.html#Core.Array"><code>Array</code></a></p></li><li><p><a href="arrays.html#Base.BitArray"><code>BitArray</code></a></p></li><li><p><a href="arrays.html#Core.AbstractArray"><code>AbstractArray</code></a></p></li><li><p><code>SubArray</code></p></li><li><p><a href="collections.html#Base.ObjectIdDict"><code>ObjectIdDict</code></a></p></li><li><p><a href="collections.html#Base.Dict"><code>Dict</code></a></p></li><li><p><a href="collections.html#Base.WeakKeyDict"><code>WeakKeyDict</code></a></p></li><li><p><code>AbstractString</code></p></li></ul><p>Partially implemented by:</p><ul><li><p><code>Range</code></p></li><li><p><code>UnitRange</code></p></li><li><p><code>Tuple</code></p></li></ul><h2><a class="nav-anchor" id="Associative-Collections-1" href="#Associative-Collections-1">Associative Collections</a></h2><p><a href="collections.html#Base.Dict"><code>Dict</code></a> is the standard associative collection. Its implementation uses <a href="base.html#Base.hash"><code>hash()</code></a> as the hashing function for the key, and <a href="base.html#Base.isequal-Tuple{Any,Any}"><code>isequal()</code></a> to determine equality. Define these two functions for custom types to override how they are stored in a hash table.</p><p><a href="collections.html#Base.ObjectIdDict"><code>ObjectIdDict</code></a> is a special hash table where the keys are always object identities.</p><p><a href="collections.html#Base.WeakKeyDict"><code>WeakKeyDict</code></a> is a hash table implementation where the keys are weak references to objects, and thus may be garbage collected even when referenced in a hash table.</p><p><a href="collections.html#Base.Dict"><code>Dict</code></a>s can be created by passing pair objects constructed with <code>=>()</code> to a <a href="collections.html#Base.Dict"><code>Dict</code></a> constructor: <code>Dict("A"=>1, "B"=>2)</code>. This call will attempt to infer type information from the keys and values (i.e. this example creates a <code>Dict{String, Int64}</code>). To explicitly specify types use the syntax <code>Dict{KeyType,ValueType}(...)</code>. For example, <code>Dict{String,Int32}("A"=>1, "B"=>2)</code>.</p><p>Associative collections may also be created with generators. For example, <code>Dict(i => f(i) for i = 1:10)</code>.</p><p>Given a dictionary <code>D</code>, the syntax <code>D[x]</code> returns the value of key <code>x</code> (if it exists) or throws an error, and <code>D[x] = y</code> stores the key-value pair <code>x => y</code> in <code>D</code> (replacing any existing value for the key <code>x</code>). Multiple arguments to <code>D[...]</code> are converted to tuples; for example, the syntax <code>D[x,y]</code> is equivalent to <code>D[(x,y)]</code>, i.e. it refers to the value keyed by the tuple <code>(x,y)</code>.</p><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.Dict" href="#Base.Dict"><code>Base.Dict</code></a> — <span class="docstring-category">Type</span>.</div><div><pre><code class="language-none">Dict([itr])</code></pre><p><code>Dict{K,V}()</code> constructs a hash table with keys of type <code>K</code> and values of type <code>V</code>.</p><p>Given a single iterable argument, constructs a <a href="collections.html#Base.Dict"><code>Dict</code></a> whose key-value pairs are taken from 2-tuples <code>(key,value)</code> generated by the argument.</p><pre><code class="language-julia-repl">julia> Dict([("A", 1), ("B", 2)])
|
||
Dict{String,Int64} with 2 entries:
|
||
"B" => 2
|
||
"A" => 1</code></pre><p>Alternatively, a sequence of pair arguments may be passed.</p><pre><code class="language-julia-repl">julia> Dict("A"=>1, "B"=>2)
|
||
Dict{String,Int64} with 2 entries:
|
||
"B" => 2
|
||
"A" => 1</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/dict.jl#L68-L91">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.ObjectIdDict" href="#Base.ObjectIdDict"><code>Base.ObjectIdDict</code></a> — <span class="docstring-category">Type</span>.</div><div><pre><code class="language-none">ObjectIdDict([itr])</code></pre><p><code>ObjectIdDict()</code> constructs a hash table where the keys are (always) object identities. Unlike <code>Dict</code> it is not parameterized on its key and value type and thus its <code>eltype</code> is always <code>Pair{Any,Any}</code>.</p><p>See <a href="collections.html#Base.Dict"><code>Dict</code></a> for further help.</p></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/associative.jl#L379-L387">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.WeakKeyDict" href="#Base.WeakKeyDict"><code>Base.WeakKeyDict</code></a> — <span class="docstring-category">Type</span>.</div><div><pre><code class="language-none">WeakKeyDict([itr])</code></pre><p><code>WeakKeyDict()</code> constructs a hash table where the keys are weak references to objects, and thus may be garbage collected even when referenced in a hash table.</p><p>See <a href="collections.html#Base.Dict"><code>Dict</code></a> for further help.</p></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/weakkeydict.jl#L5-L13">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.haskey" href="#Base.haskey"><code>Base.haskey</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">haskey(collection, key) -> Bool</code></pre><p>Determine whether a collection has a mapping for a given key.</p><pre><code class="language-julia-repl">julia> a = Dict('a'=>2, 'b'=>3)
|
||
Dict{Char,Int64} with 2 entries:
|
||
'b' => 3
|
||
'a' => 2
|
||
|
||
julia> haskey(a,'a')
|
||
true
|
||
|
||
julia> haskey(a,'c')
|
||
false</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/dict.jl#L487-L504">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.get-Tuple{Any,Any,Any}" href="#Base.get-Tuple{Any,Any,Any}"><code>Base.get</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">get(collection, key, default)</code></pre><p>Return the value stored for the given key, or the given default value if no mapping for the key is present.</p><p><strong>Examples</strong></p><pre><code class="language-julia-repl">julia> d = Dict("a"=>1, "b"=>2);
|
||
|
||
julia> get(d, "a", 3)
|
||
1
|
||
|
||
julia> get(d, "c", 3)
|
||
3</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/docs/helpdb/Base.jl#L1418-L1434">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.get" href="#Base.get"><code>Base.get</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">get(f::Function, collection, key)</code></pre><p>Return the value stored for the given key, or if no mapping for the key is present, return <code>f()</code>. Use <a href="collections.html#Base.get!-Tuple{Any,Any,Any}"><code>get!</code></a> to also store the default value in the dictionary.</p><p>This is intended to be called using <code>do</code> block syntax</p><pre><code class="language-julia">get(dict, key) do
|
||
# default value calculated here
|
||
time()
|
||
end</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/docs/helpdb/Base.jl#L1437-L1451">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.get!-Tuple{Any,Any,Any}" href="#Base.get!-Tuple{Any,Any,Any}"><code>Base.get!</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">get!(collection, key, default)</code></pre><p>Return the value stored for the given key, or if no mapping for the key is present, store <code>key => default</code>, and return <code>default</code>.</p><p><strong>Examples</strong></p><pre><code class="language-julia-repl">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</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/docs/helpdb/Base.jl#L1947-L1970">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.get!-Tuple{Function,Any,Any}" href="#Base.get!-Tuple{Function,Any,Any}"><code>Base.get!</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">get!(f::Function, collection, key)</code></pre><p>Return the value stored for the given key, or if no mapping for the key is present, store <code>key => f()</code>, and return <code>f()</code>.</p><p>This is intended to be called using <code>do</code> block syntax:</p><pre><code class="language-julia">get!(dict, key) do
|
||
# default value calculated here
|
||
time()
|
||
end</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/docs/helpdb/Base.jl#L1973-L1986">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.getkey" href="#Base.getkey"><code>Base.getkey</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">getkey(collection, key, default)</code></pre><p>Return the key matching argument <code>key</code> if one exists in <code>collection</code>, otherwise return <code>default</code>.</p><pre><code class="language-julia-repl">julia> a = Dict('a'=>2, 'b'=>3)
|
||
Dict{Char,Int64} with 2 entries:
|
||
'b' => 3
|
||
'a' => 2
|
||
|
||
julia> getkey(a,'a',1)
|
||
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)
|
||
|
||
julia> getkey(a,'d','a')
|
||
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/dict.jl#L508-L525">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.delete!" href="#Base.delete!"><code>Base.delete!</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">delete!(collection, key)</code></pre><p>Delete the mapping for the given key in a collection, and return the collection.</p><p><strong>Example</strong></p><pre><code class="language-julia-repl">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</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/docs/helpdb/Base.jl#L1331-L1347">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.pop!-Tuple{Any,Any,Any}" href="#Base.pop!-Tuple{Any,Any,Any}"><code>Base.pop!</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">pop!(collection, key[, default])</code></pre><p>Delete and return the mapping for <code>key</code> if it exists in <code>collection</code>, otherwise return <code>default</code>, or throw an error if <code>default</code> is not specified.</p><p><strong>Examples</strong></p><pre><code class="language-julia-repl">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:
|
||
[1] pop!(::Dict{String,Int64}, ::String) at ./dict.jl:539
|
||
|
||
julia> pop!(d, "e", 4)
|
||
4</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/docs/helpdb/Base.jl#L2600-L2621">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.keys" href="#Base.keys"><code>Base.keys</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">keys(a::Associative)</code></pre><p>Return an iterator over all keys in a collection. <code>collect(keys(a))</code> returns an array of keys. Since the keys are stored internally in a hash table, the order in which they are returned may vary. But <code>keys(a)</code> and <code>values(a)</code> both iterate <code>a</code> and return the elements in the same order.</p><pre><code class="language-julia-repl">julia> a = Dict('a'=>2, 'b'=>3)
|
||
Dict{Char,Int64} with 2 entries:
|
||
'b' => 3
|
||
'a' => 2
|
||
|
||
julia> collect(keys(a))
|
||
2-element Array{Char,1}:
|
||
'b'
|
||
'a'</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/associative.jl#L63-L84">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.values" href="#Base.values"><code>Base.values</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">values(a::Associative)</code></pre><p>Return an iterator over all values in a collection. <code>collect(values(a))</code> returns an array of values. Since the values are stored internally in a hash table, the order in which they are returned may vary. But <code>keys(a)</code> and <code>values(a)</code> both iterate <code>a</code> and return the elements in the same order.</p><pre><code class="language-julia-repl">julia> a = Dict('a'=>2, 'b'=>3)
|
||
Dict{Char,Int64} with 2 entries:
|
||
'b' => 3
|
||
'a' => 2
|
||
|
||
julia> collect(values(a))
|
||
2-element Array{Int64,1}:
|
||
3
|
||
2</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/associative.jl#L88-L109">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.merge" href="#Base.merge"><code>Base.merge</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">merge(d::Associative, others::Associative...)</code></pre><p>Construct a merged collection from the given collections. If necessary, the types of the resulting collection will be promoted to accommodate the types of the merged collections. If the same key is present in another collection, the value for that key will be the value it has in the last collection listed.</p><pre><code class="language-julia-repl">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</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/associative.jl#L224-L255">source</a><div><pre><code class="language-none">merge(combine, d::Associative, others::Associative...)</code></pre><p>Construct a merged collection from the given collections. If necessary, the types of the resulting collection will be promoted to accommodate the types of the merged collections. Values with the same key will be combined using the combiner function.</p><pre><code class="language-julia-repl">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" => 4753.0
|
||
"baz" => 17.0
|
||
"foo" => 0.0</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/associative.jl#L259-L284">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.merge!" href="#Base.merge!"><code>Base.merge!</code></a> — <span class="docstring-category">Function</span>.</div><div><p>Merge changes into current head </p></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/libgit2/merge.jl#L66">source</a><div><p>Internal implementation of merge. Returns <code>true</code> if merge was successful, otherwise <code>false</code></p></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/libgit2/merge.jl#L80-L83">source</a><div><pre><code class="language-none">merge!(repo::GitRepo; kwargs...) -> Bool</code></pre><p>Perform a git merge on the repository <code>repo</code>, merging commits with diverging history into the current branch. Returns <code>true</code> if the merge succeeded, <code>false</code> if not.</p><p>The keyword arguments are:</p><ul><li><p><code>committish::AbstractString=""</code>: Merge the named commit(s) in <code>committish</code>.</p></li><li><p><code>branch::AbstractString=""</code>: Merge the branch <code>branch</code> and all its commits since it diverged from the current branch.</p></li><li><p><code>fastforward::Bool=false</code>: If <code>fastforward</code> is <code>true</code>, only merge if the merge is a fast-forward (the current branch head is an ancestor of the commits to be merged), otherwise refuse to merge and return <code>false</code>. This is equivalent to the git CLI option <code>--ff-only</code>.</p></li><li><p><code>merge_opts::MergeOptions=MergeOptions()</code>: <code>merge_opts</code> specifies options for the merge, such as merge strategy in case of conflicts.</p></li><li><p><code>checkout_opts::CheckoutOptions=CheckoutOptions()</code>: <code>checkout_opts</code> specifies options for the checkout step.</p></li></ul><p>Equivalent to <code>git merge [--ff-only] [<committish> | <branch>]</code>.</p><div class="admonition note"><div class="admonition-title">Note</div><div class="admonition-text"><p>If you specify a <code>branch</code>, this must be done in reference format, since the string will be turned into a <code>GitReference</code>. For example, if you wanted to merge branch <code>branch_a</code>, you would call <code>merge!(repo, branch="refs/heads/branch_a")</code>.</p></div></div></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/libgit2/libgit2.jl#L625-L652">source</a><div><pre><code class="language-none">merge!(d::Associative, others::Associative...)</code></pre><p>Update collection with pairs from the other collections. See also <a href="collections.html#Base.merge"><code>merge</code></a>.</p><pre><code class="language-julia-repl">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</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/associative.jl#L120-L139">source</a><div><pre><code class="language-none">merge!(combine, d::Associative, others::Associative...)</code></pre><p>Update collection with pairs from the other collections. Values with the same key will be combined using the combiner function.</p><pre><code class="language-julia-repl">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 => 6
|
||
|
||
julia> merge!(-, d1, d1);
|
||
|
||
julia> d1
|
||
Dict{Int64,Int64} with 3 entries:
|
||
4 => 0
|
||
3 => 0
|
||
1 => 0</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/associative.jl#L149-L177">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.sizehint!" href="#Base.sizehint!"><code>Base.sizehint!</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">sizehint!(s, n)</code></pre><p>Suggest that collection <code>s</code> reserve capacity for at least <code>n</code> elements. This can improve performance.</p></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/docs/helpdb/Base.jl#L1114-L1118">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.keytype" href="#Base.keytype"><code>Base.keytype</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">keytype(type)</code></pre><p>Get the key type of an associative collection type. Behaves similarly to <a href="collections.html#Base.eltype"><code>eltype</code></a>.</p><pre><code class="language-julia-repl">julia> keytype(Dict(Int32(1) => "foo"))
|
||
Int32</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/associative.jl#L196-L205">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.valtype" href="#Base.valtype"><code>Base.valtype</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">valtype(type)</code></pre><p>Get the value type of an associative collection type. Behaves similarly to <a href="collections.html#Base.eltype"><code>eltype</code></a>.</p><pre><code class="language-julia-repl">julia> valtype(Dict(Int32(1) => "foo"))
|
||
String</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/associative.jl#L210-L219">source</a></section><p>Fully implemented by:</p><ul><li><p><a href="collections.html#Base.ObjectIdDict"><code>ObjectIdDict</code></a></p></li><li><p><a href="collections.html#Base.Dict"><code>Dict</code></a></p></li><li><p><a href="collections.html#Base.WeakKeyDict"><code>WeakKeyDict</code></a></p></li></ul><p>Partially implemented by:</p><ul><li><p><a href="collections.html#Base.IntSet"><code>IntSet</code></a></p></li><li><p><a href="collections.html#Base.Set"><code>Set</code></a></p></li><li><p><a href="base.html#Base.EnvHash"><code>EnvHash</code></a></p></li><li><p><a href="arrays.html#Core.Array"><code>Array</code></a></p></li><li><p><a href="arrays.html#Base.BitArray"><code>BitArray</code></a></p></li></ul><h2><a class="nav-anchor" id="Set-Like-Collections-1" href="#Set-Like-Collections-1">Set-Like Collections</a></h2><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.Set" href="#Base.Set"><code>Base.Set</code></a> — <span class="docstring-category">Type</span>.</div><div><pre><code class="language-none">Set([itr])</code></pre><p>Construct a <a href="collections.html#Base.Set"><code>Set</code></a> of the values generated by the given iterable object, or an empty set. Should be used instead of <a href="collections.html#Base.IntSet"><code>IntSet</code></a> for sparse integer sets, or for sets of arbitrary objects.</p></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/docs/helpdb/Base.jl#L2557-L2563">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.IntSet" href="#Base.IntSet"><code>Base.IntSet</code></a> — <span class="docstring-category">Type</span>.</div><div><pre><code class="language-none">IntSet([itr])</code></pre><p>Construct a sorted set of positive <code>Int</code>s generated by the given iterable object, or an empty set. Implemented as a bit string, and therefore designed for dense integer sets. Only <code>Int</code>s greater than 0 can be stored. If the set will be sparse (for example holding a few very large integers), use <a href="collections.html#Base.Set"><code>Set</code></a> instead.</p></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/docs/helpdb/Base.jl#L1630-L1637">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.union" href="#Base.union"><code>Base.union</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">union(s1,s2...)
|
||
∪(s1,s2...)</code></pre><p>Construct the union of two or more sets. Maintains order with arrays.</p><p><strong>Examples</strong></p><pre><code class="language-julia-repl">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</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/docs/helpdb/Base.jl#L944-L971">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.union!" href="#Base.union!"><code>Base.union!</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">union!(s, iterable)</code></pre><p>Union each element of <code>iterable</code> into set <code>s</code> in-place.</p></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/docs/helpdb/Base.jl#L2511-L2515">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.intersect" href="#Base.intersect"><code>Base.intersect</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">intersect(s1,s2...)
|
||
∩(s1,s2)</code></pre><p>Construct the intersection of two or more sets. Maintains order and multiplicity of the first argument for arrays and ranges.</p></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/docs/helpdb/Base.jl#L2069-L2075">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.setdiff" href="#Base.setdiff"><code>Base.setdiff</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">setdiff(a, b)</code></pre><p>Construct the set of elements in <code>a</code> but not <code>b</code>. Maintains order with arrays. Note that both arguments must be collections, and both will be iterated over. In particular, <code>setdiff(set,element)</code> where <code>element</code> is a potential member of <code>set</code>, will not work in general.</p><p><strong>Example</strong></p><pre><code class="language-julia-repl">julia> setdiff([1,2,3],[3,4,5])
|
||
2-element Array{Int64,1}:
|
||
1
|
||
2</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/array.jl#L1963-L1978">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.setdiff!" href="#Base.setdiff!"><code>Base.setdiff!</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">setdiff!(s, iterable)</code></pre><p>Remove each element of <code>iterable</code> from set <code>s</code> in-place.</p></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/docs/helpdb/Base.jl#L792-L796">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.symdiff" href="#Base.symdiff"><code>Base.symdiff</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">symdiff(a, b, rest...)</code></pre><p>Construct the symmetric difference of elements in the passed in sets or arrays. Maintains order with arrays.</p><p><strong>Example</strong></p><pre><code class="language-julia-repl">julia> symdiff([1,2,3],[3,4,5],[4,5,6])
|
||
3-element Array{Int64,1}:
|
||
1
|
||
2
|
||
6</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/array.jl#L1999-L2013">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.symdiff!-Tuple{IntSet,Integer}" href="#Base.symdiff!-Tuple{IntSet,Integer}"><code>Base.symdiff!</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">symdiff!(s, n)</code></pre><p>The set <code>s</code> is destructively modified to toggle the inclusion of integer <code>n</code>.</p></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/intset.jl#L137-L141">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.symdiff!-Tuple{IntSet,Any}" href="#Base.symdiff!-Tuple{IntSet,Any}"><code>Base.symdiff!</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">symdiff!(s, itr)</code></pre><p>For each element in <code>itr</code>, destructively toggle its inclusion in set <code>s</code>.</p></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/intset.jl#L131-L135">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.symdiff!-Tuple{IntSet,IntSet}" href="#Base.symdiff!-Tuple{IntSet,IntSet}"><code>Base.symdiff!</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">symdiff!(s, itr)</code></pre><p>For each element in <code>itr</code>, destructively toggle its inclusion in set <code>s</code>.</p></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/intset.jl#L131-L135">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.intersect!" href="#Base.intersect!"><code>Base.intersect!</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">intersect!(s1::IntSet, s2::IntSet)</code></pre><p>Intersects sets <code>s1</code> and <code>s2</code> and overwrites the set <code>s1</code> with the result. If needed, <code>s1</code> will be expanded to the size of <code>s2</code>.</p></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/intset.jl#L112-L117">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.issubset" href="#Base.issubset"><code>Base.issubset</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">issubset(A, S) -> Bool
|
||
⊆(A,S) -> Bool</code></pre><p>Return <code>true</code> if <code>A</code> is a subset of or equal to <code>S</code>.</p></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/docs/helpdb/Base.jl#L2345-L2350">source</a></section><p>Fully implemented by:</p><ul><li><p><a href="collections.html#Base.IntSet"><code>IntSet</code></a></p></li><li><p><a href="collections.html#Base.Set"><code>Set</code></a></p></li></ul><p>Partially implemented by:</p><ul><li><p><a href="arrays.html#Core.Array"><code>Array</code></a></p></li></ul><h2><a class="nav-anchor" id="Dequeues-1" href="#Dequeues-1">Dequeues</a></h2><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.push!" href="#Base.push!"><code>Base.push!</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">push!(collection, items...) -> collection</code></pre><p>Insert one or more <code>items</code> at the end of <code>collection</code>.</p><p><strong>Example</strong></p><pre><code class="language-julia-repl">julia> push!([1, 2, 3], 4, 5, 6)
|
||
6-element Array{Int64,1}:
|
||
1
|
||
2
|
||
3
|
||
4
|
||
5
|
||
6</code></pre><p>Use <a href="collections.html#Base.append!"><code>append!</code></a> to add all the elements of another collection to <code>collection</code>. The result of the preceding example is equivalent to <code>append!([1, 2, 3], [4, 5, 6])</code>.</p></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/docs/helpdb/Base.jl#L384-L404">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.pop!-Tuple{Any}" href="#Base.pop!-Tuple{Any}"><code>Base.pop!</code></a> — <span class="docstring-category">Method</span>.</div><div><pre><code class="language-none">pop!(collection) -> item</code></pre><p>Remove the last item in <code>collection</code> and return it.</p><p><strong>Examples</strong></p><pre><code class="language-julia-repl">julia> A=[1, 2, 3, 4, 5, 6]
|
||
6-element Array{Int64,1}:
|
||
1
|
||
2
|
||
3
|
||
4
|
||
5
|
||
6
|
||
|
||
julia> pop!(A)
|
||
6
|
||
|
||
julia> A
|
||
5-element Array{Int64,1}:
|
||
1
|
||
2
|
||
3
|
||
4
|
||
5</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/docs/helpdb/Base.jl#L2624-L2651">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.unshift!" href="#Base.unshift!"><code>Base.unshift!</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">unshift!(collection, items...) -> collection</code></pre><p>Insert one or more <code>items</code> at the beginning of <code>collection</code>.</p><p><strong>Example</strong></p><pre><code class="language-julia-repl">julia> unshift!([1, 2, 3, 4], 5, 6)
|
||
6-element Array{Int64,1}:
|
||
5
|
||
6
|
||
1
|
||
2
|
||
3
|
||
4</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/array.jl#L793-L809">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.shift!" href="#Base.shift!"><code>Base.shift!</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">shift!(collection) -> item</code></pre><p>Remove the first <code>item</code> from <code>collection</code>.</p><p><strong>Example</strong></p><pre><code class="language-julia-repl">julia> A = [1, 2, 3, 4, 5, 6]
|
||
6-element Array{Int64,1}:
|
||
1
|
||
2
|
||
3
|
||
4
|
||
5
|
||
6
|
||
|
||
julia> shift!(A)
|
||
1
|
||
|
||
julia> A
|
||
5-element Array{Int64,1}:
|
||
2
|
||
3
|
||
4
|
||
5
|
||
6</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/docs/helpdb/Base.jl#L1489-L1516">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.insert!" href="#Base.insert!"><code>Base.insert!</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">insert!(a::Vector, index::Integer, item)</code></pre><p>Insert an <code>item</code> into <code>a</code> at the given <code>index</code>. <code>index</code> is the index of <code>item</code> in the resulting <code>a</code>.</p><p><strong>Example</strong></p><pre><code class="language-julia-repl">julia> insert!([6, 5, 4, 2, 1], 4, 3)
|
||
6-element Array{Int64,1}:
|
||
6
|
||
5
|
||
4
|
||
3
|
||
2
|
||
1</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/array.jl#L826-L843">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.deleteat!" href="#Base.deleteat!"><code>Base.deleteat!</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">deleteat!(a::Vector, i::Integer)</code></pre><p>Remove the item at the given <code>i</code> and return the modified <code>a</code>. Subsequent items are shifted to fill the resulting gap.</p><p><strong>Example</strong></p><pre><code class="language-julia-repl">julia> deleteat!([6, 5, 4, 3, 2, 1], 2)
|
||
5-element Array{Int64,1}:
|
||
6
|
||
4
|
||
3
|
||
2
|
||
1</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/array.jl#L853-L869">source</a><div><pre><code class="language-none">deleteat!(a::Vector, inds)</code></pre><p>Remove the items at the indices given by <code>inds</code>, and return the modified <code>a</code>. Subsequent items are shifted to fill the resulting gap.</p><p><code>inds</code> can be either an iterator or a collection of sorted and unique integer indices, or a boolean vector of the same length as <code>a</code> with <code>true</code> indicating entries to delete.</p><p><strong>Examples</strong></p><pre><code class="language-julia-repl">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:
|
||
[1] _deleteat!(::Array{Int64,1}, ::Tuple{Int64,Int64}) at ./array.jl:921
|
||
[2] deleteat!(::Array{Int64,1}, ::Tuple{Int64,Int64}) at ./array.jl:908</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/array.jl#L878-L907">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.splice!" href="#Base.splice!"><code>Base.splice!</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">splice!(a::Vector, index::Integer, [replacement]) -> item</code></pre><p>Remove the item at the given index, and return the removed item. Subsequent items are shifted left to fill the resulting gap. If specified, replacement values from an ordered collection will be spliced in place of the removed item.</p><p><strong>Examples</strong></p><pre><code class="language-julia-repl">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</code></pre><p>To insert <code>replacement</code> before an index <code>n</code> without removing any items, use <code>splice!(collection, n:n-1, replacement)</code>.</p></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/array.jl#L955-L1003">source</a><div><pre><code class="language-none">splice!(a::Vector, range, [replacement]) -> items</code></pre><p>Remove items in the specified index range, and return a collection containing the removed items. Subsequent items are shifted left to fill the resulting gap. If specified, replacement values from an ordered collection will be spliced in place of the removed items.</p><p>To insert <code>replacement</code> before an index <code>n</code> without removing any items, use <code>splice!(collection, n:n-1, replacement)</code>.</p><p><strong>Example</strong></p><pre><code class="language-julia-repl">julia> splice!(A, 4:3, 2)
|
||
0-element Array{Int64,1}
|
||
|
||
julia> A
|
||
8-element Array{Int64,1}:
|
||
-1
|
||
-2
|
||
-3
|
||
2
|
||
5
|
||
4
|
||
3
|
||
-1</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/array.jl#L1022-L1050">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.resize!" href="#Base.resize!"><code>Base.resize!</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">resize!(a::Vector, n::Integer) -> Vector</code></pre><p>Resize <code>a</code> to contain <code>n</code> elements. If <code>n</code> is smaller than the current collection length, the first <code>n</code> elements will be retained. If <code>n</code> is larger, the new elements are not guaranteed to be initialized.</p><p><strong>Examples</strong></p><pre><code class="language-julia-repl">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</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/array.jl#L736-L765">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.append!" href="#Base.append!"><code>Base.append!</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">append!(collection, collection2) -> collection.</code></pre><p>Add the elements of <code>collection2</code> to the end of <code>collection</code>.</p><p><strong>Examples</strong></p><pre><code class="language-julia-repl">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</code></pre><p>Use <a href="collections.html#Base.push!"><code>push!</code></a> to add individual items to <code>collection</code> which are not already themselves in another collection. The result is of the preceding example is equivalent to <code>push!([1, 2, 3], 4, 5, 6)</code>.</p></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/docs/helpdb/Base.jl#L756-L782">source</a></section><section class="docstring"><div class="docstring-header"><a class="docstring-binding" id="Base.prepend!" href="#Base.prepend!"><code>Base.prepend!</code></a> — <span class="docstring-category">Function</span>.</div><div><pre><code class="language-none">prepend!(a::Vector, items) -> collection</code></pre><p>Insert the elements of <code>items</code> to the beginning of <code>a</code>.</p><p><strong>Example</strong></p><pre><code class="language-julia-repl">julia> prepend!([3],[1,2])
|
||
3-element Array{Int64,1}:
|
||
1
|
||
2
|
||
3</code></pre></div><a class="source-link" target="_blank" href="https://github.com/JuliaLang/julia/blob/d55cadc350d426a95fd967121ba77494d08364c8/base/array.jl#L685-L698">source</a></section><p>Fully implemented by:</p><ul><li><p><code>Vector</code> (a.k.a. 1-dimensional <a href="arrays.html#Core.Array"><code>Array</code></a>)</p></li><li><p><code>BitVector</code> (a.k.a. 1-dimensional <a href="arrays.html#Base.BitArray"><code>BitArray</code></a>)</p></li></ul><footer><hr/><a class="previous" href="base.html"><span class="direction">Previous</span><span class="title">Essentials</span></a><a class="next" href="math.html"><span class="direction">Next</span><span class="title">Mathematics</span></a></footer></article></body></html>
|