diff --git a/Makefile b/Makefile index e215159a79c52..2eb7dccf8219f 100644 --- a/Makefile +++ b/Makefile @@ -38,6 +38,45 @@ debug release: | $(DIRS) $(build_datarootdir)/julia/base $(build_datarootdir)/ju @export private_libdir=$(private_libdir) && \ $(MAKE) $(QUIET_MAKE) LD_LIBRARY_PATH=$(build_libdir):$(LD_LIBRARY_PATH) JULIA_EXECUTABLE="$(JULIA_EXECUTABLE_$@)" $(build_private_libdir)/sys.$(SHLIB_EXT) +release-candidate: release test + @#Check documentation + @./julia doc/NEWS-update.jl #Add missing cross-references to NEWS.md + @./julia doc/DocCheck.jl > doc/UNDOCUMENTED.rst 2>&1 #Check for undocumented items + @if [ -z "$(cat doc/UNDOCUMENTED.rst)" ]; then \ + rm doc/UNDOCUMENTED.rst; \ + else \ + echo "Undocumented functions found in doc/UNDOCUMENTED.rst; document them, then retry"; \ + exit 1; \ + fi + @$(MAKE) -C doc html SPHINXOPTS="-W" #Rebuild Julia HTML docs pedantically + @$(MAKE) -C doc latex SPHINXOPTS="-W" #Rebuild Julia PDF docs pedantically + @$(MAKE) -C doc doctest #Run Julia doctests + @$(MAKE) -C doc linkcheck #Check all links + @$(MAKE) -C doc helpdb.jl #Rebuild Julia online documentation for help(), apropos(), etc... + + @# Check to see if the above make invocations changed anything important + @if [ -n "$(git status --porcelain)" ]; then \ + echo "Git repository dirty; Verify and commit changes to the repository, then retry"; \ + exit 1; \ + fi + + @#Check that benchmarks work + @$(MAKE) -C test/perf + @#Check that netload tests work + @#for test in test/netload/*.jl; do julia $$test; if [ $$? -ne 0 ]; then exit 1; fi; done + @echo + @echo To complete the release candidate checklist: + @echo + + @echo 1. Remove deprecations in base/deprecated.jl + @echo 2. Bump VERSION + @echo 3. Create tag, push to github "\(git tag v\`cat VERSION]\` && git push --tags\)" + @echo 4. Replace github release tarball with tarball created from make source-dist + @echo 5. Follow packaging instructions in DISTRIBUTING.md to create binary packages for all platforms + @echo 6. Upload to AWS, update http://julialang.org/downloads links + @echo 7. Announce on mailing lists + @echo + julia-debug-symlink: @ln -sf $(build_bindir)/julia-debug julia diff --git a/doc/helpdb.jl b/doc/helpdb.jl index ebe310505671a..e2fa87e8e891d 100644 --- a/doc/helpdb.jl +++ b/doc/helpdb.jl @@ -4,6 +4,7 @@ ("Base","exit","exit([code]) + Quit (or control-D at the prompt). The default exit code is zero, indicating that the processes completed successfully. @@ -11,6 +12,7 @@ ("Base","quit","quit() + Quit the program indicating that the processes completed succesfully. This function calls \"exit(0)\" (see \"exit()\"). @@ -18,18 +20,21 @@ ("Base","atexit","atexit(f) + Register a zero-argument function to be called at exit. "), ("Base","isinteractive","isinteractive() -> Bool + Determine whether Julia is running an interactive session. "), ("Base","whos","whos([Module,] [pattern::Regex]) + Print information about global variables in a module, optionally restricted to those matching \"pattern\". @@ -37,6 +42,7 @@ ("Base","edit","edit(file::String[, line]) + Edit a file optionally providing a line number to edit at. Returns to the julia prompt when you quit the editor. @@ -44,6 +50,7 @@ ("Base","edit","edit(function[, types]) + Edit the definition of a function, optionally specifying a tuple of types to indicate which method to edit. @@ -51,6 +58,7 @@ ("Base","@edit","@edit() + Evaluates the arguments to the function call, determines their types, and calls the \"edit\" function on the resulting expression @@ -58,6 +66,7 @@ ("Base","less","less(file::String[, line]) + Show a file using the default pager, optionally providing a starting line number. Returns to the julia prompt when you quit the pager. @@ -66,6 +75,7 @@ ("Base","less","less(function[, types]) + Show the definition of a function using the default pager, optionally specifying a tuple of types to indicate which method to see. @@ -74,6 +84,7 @@ ("Base","@less","@less() + Evaluates the arguments to the function call, determines their types, and calls the \"less\" function on the resulting expression @@ -81,6 +92,7 @@ ("Base","clipboard","clipboard(x) + Send a printed form of \"x\" to the operating system clipboard (\"copy\"). @@ -88,6 +100,7 @@ ("Base","clipboard","clipboard() -> String + Return a string with the contents of the operating system clipboard (\"paste\"). @@ -95,6 +108,7 @@ ("Base","require","require(file::String...) + Load source files once, in the context of the \"Main\" module, on every active node, searching standard locations for files. \"require\" is considered a top-level operation, so it sets the @@ -111,6 +125,7 @@ ("Base","reload","reload(file::String) + Like \"require\", except forces loading of files regardless of whether they have been loaded before. Typically used when interactively developing libraries. @@ -119,6 +134,7 @@ ("Base","include","include(path::String) + Evaluate the contents of a source file in the current context. During including, a task-local include path is set to the directory containing the file. Nested calls to \"include\" will search @@ -132,6 +148,7 @@ ("Base","include_string","include_string(code::String) + Like \"include\", except reads code from the given string rather than from a file. Since there is no file path involved, no path processing or fetching from node 1 is done. @@ -140,18 +157,21 @@ ("Base","help","help(name) + Get help for a function. \"name\" can be an object or a string. "), ("Base","apropos","apropos(string) + Search documentation for functions related to \"string\". "), ("Base","which","which(f, types) + Return the method of \"f\" (a \"Method\" object) that will be called for arguments with the given types. @@ -159,6 +179,7 @@ ("Base","@which","@which() + Evaluates the arguments to the function call, determines their types, and calls the \"which\" function on the resulting expression @@ -166,6 +187,7 @@ ("Base","methods","methods(f[, types]) + Show all methods of \"f\" with their argument types. If \"types\" is specified, an array of methods whose types match is @@ -175,6 +197,7 @@ ("Base","methodswith","methodswith(typ[, showparents]) + Return an array of methods with an argument of type \"typ\". If optional \"showparents\" is \"true\", also return arguments with a parent type of \"typ\", excluding type \"Any\". @@ -183,12 +206,14 @@ ("Base","@show","@show() + Show an expression and result, returning the result "), ("Base","versioninfo","versioninfo([verbose::Bool]) + Print information about the version of Julia in use. If the \"verbose\" argument is true, detailed system information is shown as well. @@ -197,6 +222,7 @@ ("Base","workspace","workspace() + Replace the top-level module (\"Main\") with a new one, providing a clean workspace. The previous \"Main\" module is made available as \"LastMain\". A previously-loaded package can be accessed using a @@ -208,6 +234,7 @@ ("Base","is","is(x, y) -> Bool + Determine whether \"x\" and \"y\" are identical, in the sense that no program could distinguish them. Compares mutable objects by address in memory, and compares immutable objects (such as numbers) @@ -218,12 +245,14 @@ ("Base","isa","isa(x, type) -> Bool + Determine whether \"x\" is of the given \"type\". "), ("Base","isequal","isequal(x, y) + Similar to \"==\", except treats all floating-point \"NaN\" values as equal to each other, and treats \"-0.0\" as unequal to \"0.0\". For values that are not floating-point, \"isequal\" is the same as @@ -245,6 +274,7 @@ ("Base","isless","isless(x, y) + Test whether \"x\" is less than \"y\", according to a canonical total order. Values that are normally unordered, such as \"NaN\", are ordered in an arbitrary but consistent fashion. This is the @@ -257,6 +287,7 @@ ("Base","ifelse","ifelse(condition::Bool, x, y) + Return \"x\" if \"condition\" is true, otherwise return \"y\". This differs from \"?\" or \"if\" in that it is an ordinary function, so all the arguments are evaluated first. @@ -265,6 +296,7 @@ ("Base","lexcmp","lexcmp(x, y) + Compare \"x\" and \"y\" lexicographically and return -1, 0, or 1 depending on whether \"x\" is less than, equal to, or greater than \"y\", respectively. This function should be defined for @@ -275,24 +307,28 @@ ("Base","lexless","lexless(x, y) + Determine whether \"x\" is lexicographically less than \"y\". "), ("Base","typeof","typeof(x) + Get the concrete type of \"x\". "), ("Base","tuple","tuple(xs...) + Construct a tuple of the given objects. "), ("Base","ntuple","ntuple(n, f::Function) + Create a tuple of length \"n\", computing each element as \"f(i)\", where \"i\" is the index of the element. @@ -300,6 +336,7 @@ ("Base","object_id","object_id(x) + Get a unique integer id for \"x\". \"object_id(x)==object_id(y)\" if and only if \"is(x,y)\". @@ -307,6 +344,7 @@ ("Base","hash","hash(x[, h]) + Compute an integer hash code such that \"isequal(x,y)\" implies \"hash(x)==hash(y)\". The optional second argument \"h\" is a hash code to be mixed with the result. New types should implement the @@ -316,6 +354,7 @@ ("Base","finalizer","finalizer(x, function) + Register a function \"f(x)\" to be called when there are no program-accessible references to \"x\". The behavior of this function is unpredictable if \"x\" is of a bits type. @@ -324,6 +363,7 @@ ("Base","copy","copy(x) + Create a shallow copy of \"x\": the outer structure is copied, but not all internal values. For example, copying an array produces a new array with identically-same elements as the original. @@ -332,6 +372,7 @@ ("Base","deepcopy","deepcopy(x) + Create a deep copy of \"x\": everything is copied recursively, resulting in a fully independent object. For example, deep-copying an array produces a new array whose elements are deep-copies of the @@ -355,6 +396,7 @@ ("Base","isdefined","isdefined([object], index | symbol) + Tests whether an assignable location is defined. The arguments can be an array and index, a composite object and field name (as a symbol), or a module and a symbol. With a single symbol argument, @@ -365,6 +407,7 @@ ("Base","convert","convert(type, x) + Try to convert \"x\" to the given type. Conversions from floating point to integer, rational to integer, and complex to real will raise an \"InexactError\" if \"x\" cannot be represented exactly in @@ -374,6 +417,7 @@ ("Base","promote","promote(xs...) + Convert all arguments to their common promotion type (if any), and return them all (as a tuple). @@ -381,12 +425,14 @@ ("Base","oftype","oftype(x, y) + Convert \"y\" to the type of \"x\". "), ("Base","widen","widen(type | x) + If the argument is a type, return a \"larger\" type (for numeric types, this will be a type with at least as much range and precision as the argument, and usually more). Otherwise the @@ -404,18 +450,21 @@ ("Base","identity","identity(x) + The identity function. Returns its argument. "), ("Base","super","super(T::DataType) + Return the supertype of DataType T "), ("Base","issubtype","issubtype(type1, type2) + True if and only if all values of \"type1\" are also of \"type2\". Can also be written using the \"<:\" infix operator as \"type1 <: type2\". @@ -424,12 +473,14 @@ ("Base","<:","<:(T1, T2) + Subtype operator, equivalent to \"issubtype(T1,T2)\". "), ("Base","subtypes","subtypes(T::DataType) + Return a list of immediate subtypes of DataType T. Note that all currently loaded subtypes are included, including those not visible in the current module. @@ -438,6 +489,7 @@ ("Base","subtypetree","subtypetree(T::DataType) + Return a nested list of all subtypes of DataType T. Note that all currently loaded subtypes are included, including those not visible in the current module. @@ -446,18 +498,21 @@ ("Base","typemin","typemin(type) + The lowest value representable by the given (real) numeric type. "), ("Base","typemax","typemax(type) + The highest value representable by the given (real) numeric type. "), ("Base","realmin","realmin(type) + The smallest in absolute value non-subnormal value representable by the given floating-point type @@ -465,6 +520,7 @@ ("Base","realmax","realmax(type) + The highest finite value representable by the given floating-point type @@ -472,6 +528,7 @@ ("Base","maxintfloat","maxintfloat(type) + The largest integer losslessly representable by the given floating- point type @@ -479,6 +536,7 @@ ("Base","sizeof","sizeof(type) + Size, in bytes, of the canonical binary representation of the given type, if any. @@ -486,6 +544,7 @@ ("Base","eps","eps([type]) + The distance between 1.0 and the next larger representable floating-point value of \"type\". Only floating-point types are sensible arguments. If \"type\" is omitted, then \"eps(Float64)\" @@ -495,6 +554,7 @@ ("Base","eps","eps(x) + The distance between \"x\" and the next larger representable floating-point value of the same type as \"x\". @@ -502,6 +562,7 @@ ("Base","promote_type","promote_type(type1, type2) + Determine a type big enough to hold values of each argument type without loss, whenever possible. In some cases, where no type exists which to which both types can be promoted losslessly, some @@ -513,6 +574,7 @@ ("Base","promote_rule","promote_rule(type1, type2) + Specifies what type should be used by \"promote\" when given values of types \"type1\" and \"type2\". This function should not be called directly, but should have definitions added to it for new @@ -522,6 +584,7 @@ ("Base","getfield","getfield(value, name::Symbol) + Extract a named field from a value of composite type. The syntax \"a.b\" calls \"getfield(a, :b)\", and the syntax \"a.(b)\" calls \"getfield(a, b)\". @@ -530,6 +593,7 @@ ("Base","setfield!","setfield!(value, name::Symbol, x) + Assign \"x\" to a named field in \"value\" of composite type. The syntax \"a.b = c\" calls \"setfield!(a, :b, c)\", and the syntax \"a.(b) = c\" calls \"setfield!(a, b, c)\". @@ -538,6 +602,7 @@ ("Base","fieldoffsets","fieldoffsets(type) + The byte offset of each field of a type relative to the data start. For example, we could use it in the following manner to summarize information about a struct type: @@ -549,6 +614,7 @@ ("Base","fieldtype","fieldtype(value, name::Symbol) + Determine the declared type of a named field in a value of composite type. @@ -556,6 +622,7 @@ ("Base","isimmutable","isimmutable(v) + True if value \"v\" is immutable. See *Immutable Composite Types* for a discussion of immutability. @@ -563,6 +630,7 @@ ("Base","isbits","isbits(T) + True if \"T\" is a \"plain data\" type, meaning it is immutable and contains no references to other values. Typical examples are numeric types such as \"Uint8\", \"Float64\", and @@ -572,6 +640,7 @@ ("Base","isleaftype","isleaftype(T) + Determine whether \"T\" is a concrete type that can have instances, meaning its only subtypes are itself and \"None\" (but \"T\" itself is not \"None\"). @@ -580,12 +649,14 @@ ("Base","typejoin","typejoin(T, S) + Compute a type that contains both \"T\" and \"S\". "), ("Base","typeintersect","typeintersect(T, S) + Compute a type that contains the intersection of \"T\" and \"S\". Usually this will be the smallest such type or one close to it. @@ -593,6 +664,7 @@ ("Base","apply","apply(f, x...) + Accepts a function and several arguments, each of which must be iterable. The elements generated by all the arguments are appended into a single list, which is then passed to \"f\" as its argument @@ -617,6 +689,7 @@ ("Base","method_exists","method_exists(f, tuple) -> Bool + Determine whether the given generic function has a method matching the given tuple of argument types. @@ -629,6 +702,7 @@ ("Base","applicable","applicable(f, args...) -> Bool + Determine whether the given generic function has a method applicable to the given arguments. @@ -648,6 +722,7 @@ ("Base","invoke","invoke(f, (types...), args...) + Invoke a method for the given generic function matching the specified types (as a tuple), on the specified arguments. The arguments must be compatible with the specified types. This allows @@ -660,6 +735,7 @@ ("Base","|>","|>(x, f) + Applies a function to the preceding argument. This allows for easy function chaining. @@ -669,6 +745,7 @@ ("Base","eval","eval([m::Module], expr::Expr) + Evaluate an expression in the given module and return the result. Every module (except those defined with \"baremodule\") has its own 1-argument definition of \"eval\", which evaluates expressions in @@ -678,12 +755,14 @@ ("Base","@eval","@eval() + Evaluate an expression and return the value. "), ("Base","evalfile","evalfile(path::String) + Evaluate all expressions in the given file, and return the value of the last one. No other processing (path searching, fetching from node 1, etc.) is performed. @@ -692,6 +771,7 @@ ("Base","esc","esc(e::ANY) + Only valid in the context of an Expr returned from a macro. Prevents the macro hygiene pass from turning embedded variables into gensym variables. See the *Macros* section of the @@ -702,6 +782,7 @@ ("Base","gensym","gensym([tag]) + Generates a symbol which will not conflict with other variable names. @@ -709,6 +790,7 @@ ("Base","@gensym","@gensym() + Generates a gensym symbol for a variable. For example, *@gensym x y* is transformed into *x = gensym(\"x\"); y = gensym(\"y\")*. @@ -716,6 +798,7 @@ ("Base","parse","parse(str, start; greedy=true, raise=true) + Parse the expression string and return an expression (which could later be passed to eval for execution). Start is the index of the first character to start parsing. If \"greedy\" is true (default), @@ -729,6 +812,7 @@ ("Base","parse","parse(str; raise=true) + Parse the whole string greedily, returning a single expression. An error is thrown if there are additional characters after the first expression. If \"raise\" is true (default), syntax errors will @@ -739,18 +823,21 @@ ("Base","start","start(iter) -> state + Get initial iteration state for an iterable object "), ("Base","done","done(iter, state) -> Bool + Test whether we are done iterating "), ("Base","next","next(iter, state) -> item, state + For a given iterable object and iteration state, return the current item and the next iteration state @@ -758,6 +845,7 @@ ("Base","zip","zip(iters...) + For a set of iterable objects, returns an iterable of tuples, where the \"i\"th tuple contains the \"i\"th component of each input iterable. @@ -769,6 +857,7 @@ ("Base","enumerate","enumerate(iter) + Return an iterator that yields \"(i, x)\" where \"i\" is an index starting at 1, and \"x\" is the \"ith\" value from the given iterator. It's useful when you need not only the values *x* over @@ -788,6 +877,7 @@ ("Base","isempty","isempty(collection) -> Bool + Determine whether a collection is empty (has no elements). **Examples**: @@ -804,12 +894,14 @@ ("Base","empty!","empty!(collection) -> collection + Remove all elements from a \"collection\". "), ("Base","length","length(collection) -> Integer + For ordered, indexable collections, the maximum index \"i\" for which \"getindex(collection, i)\" is valid. For unordered collections, the number of elements. @@ -818,6 +910,7 @@ ("Base","endof","endof(collection) -> Integer + Returns the last index of the collection. **Example**: @@ -829,6 +922,7 @@ ("Base","in","in(item, collection) -> Bool + Determine whether an item is in the given collection, in the sense that it is \"==\" to one of the values generated by iterating over the collection. Some collections need a slightly different @@ -841,6 +935,7 @@ ("Base","eltype","eltype(collection) + Determine the type of the elements generated by iterating \"collection\". For associative collections, this will be a \"(key,value)\" tuple type. @@ -849,6 +944,7 @@ ("Base","indexin","indexin(a, b) + Returns a vector containing the highest index in \"b\" for each value in \"a\" that is a member of \"b\" . The output vector contains 0 wherever \"a\" is not a member of \"b\". @@ -857,6 +953,7 @@ ("Base","findin","findin(a, b) + Returns the indices of elements in collection \"a\" that appear in collection \"b\" @@ -864,6 +961,7 @@ ("Base","unique","unique(itr[, dim]) + Returns an array containing only the unique elements of the iterable \"itr\", in the order that the first of each set of equivalent elements originally appears. If \"dim\" is specified, @@ -873,6 +971,7 @@ ("Base","reduce","reduce(op, v0, itr) + Reduce the given collection \"ìtr\" with the given binary operator. Reductions for certain commonly-used operators have special implementations which should be used instead: \"maximum(itr)\", @@ -894,48 +993,56 @@ ("Base","reduce","reduce(op, itr) + Like \"reduce\" but using the first element as v0. "), ("Base","foldl","foldl(op, v0, itr) + Like \"reduce\", but with guaranteed left associativity. "), ("Base","foldl","foldl(op, itr) + Like \"foldl\", but using the first element as v0. "), ("Base","foldr","foldr(op, v0, itr) + Like \"reduce\", but with guaranteed right associativity. "), ("Base","foldr","foldr(op, itr) + Like \"foldr\", but using the last element as v0. "), ("Base","maximum","maximum(itr) + Returns the largest element in a collection. "), ("Base","maximum","maximum(A, dims) + Compute the maximum value of an array over the given dimensions. "), ("Base","maximum!","maximum!(r, A) + Compute the maximum value of \"A\" over the singleton dimensions of \"r\", and write results to \"r\". @@ -943,18 +1050,21 @@ ("Base","minimum","minimum(itr) + Returns the smallest element in a collection. "), ("Base","minimum","minimum(A, dims) + Compute the minimum value of an array over the given dimensions. "), ("Base","minimum!","minimum!(r, A) + Compute the minimum value of \"A\" over the singleton dimensions of \"r\", and write results to \"r\". @@ -962,6 +1072,7 @@ ("Base","extrema","extrema(itr) + Compute both the minimum and maximum element in a single pass, and return them as a 2-tuple. @@ -969,24 +1080,28 @@ ("Base","indmax","indmax(itr) -> Integer + Returns the index of the maximum element in a collection. "), ("Base","indmin","indmin(itr) -> Integer + Returns the index of the minimum element in a collection. "), ("Base","findmax","findmax(itr) -> (x, index) + Returns the maximum element and its index. "), ("Base","findmax","findmax(A, dims) -> (maxval, index) + For an array input, returns the value and index of the maximum over the given dimensions. @@ -994,12 +1109,14 @@ ("Base","findmin","findmin(itr) -> (x, index) + Returns the minimum element and its index. "), ("Base","findmin","findmin(A, dims) -> (minval, index) + For an array input, returns the value and index of the minimum over the given dimensions. @@ -1007,18 +1124,21 @@ ("Base","maxabs","maxabs(itr) + Compute the maximum absolute value of a collection of values. "), ("Base","maxabs","maxabs(A, dims) + Compute the maximum absolute values over given dimensions. "), ("Base","maxabs!","maxabs!(r, A) + Compute the maximum absolute values over the singleton dimensions of \"r\", and write values to \"r\". @@ -1026,18 +1146,21 @@ ("Base","minabs","minabs(itr) + Compute the minimum absolute value of a collection of values. "), ("Base","minabs","minabs(A, dims) + Compute the minimum absolute values over given dimensions. "), ("Base","minabs!","minabs!(r, A) + Compute the minimum absolute values over the singleton dimensions of \"r\", and write values to \"r\". @@ -1045,18 +1168,21 @@ ("Base","sum","sum(itr) + Returns the sum of all elements in a collection. "), ("Base","sum","sum(A, dims) + Sum elements of an array over the given dimensions. "), ("Base","sum!","sum!(r, A) + Sum elements of \"A\" over the singleton dimensions of \"r\", and write results to \"r\". @@ -1064,6 +1190,7 @@ ("Base","sum","sum(f, itr) + Sum the results of calling function \"f\" on each element of \"itr\". @@ -1071,6 +1198,7 @@ ("Base","sumabs","sumabs(itr) + Sum absolute values of all elements in a collection. This is equivalent to *sum(abs(itr))* but faster. @@ -1078,6 +1206,7 @@ ("Base","sumabs","sumabs(A, dims) + Sum absolute values of elements of an array over the given dimensions. @@ -1085,6 +1214,7 @@ ("Base","sumabs!","sumabs!(r, A) + Sum absolute values of elements of \"A\" over the singleton dimensions of \"r\", and write results to \"r\". @@ -1092,6 +1222,7 @@ ("Base","sumabs2","sumabs2(itr) + Sum squared absolute values of all elements in a collection. This is equivalent to *sum(abs2(itr))* but faster. @@ -1099,6 +1230,7 @@ ("Base","sumabs2","sumabs2(A, dims) + Sum squared absolute values of elements of an array over the given dimensions. @@ -1106,6 +1238,7 @@ ("Base","sumabs2!","sumabs2!(r, A) + Sum squared absolute values of elements of \"A\" over the singleton dimensions of \"r\", and write results to \"r\". @@ -1113,18 +1246,21 @@ ("Base","prod","prod(itr) + Returns the product of all elements of a collection. "), ("Base","prod","prod(A, dims) + Multiply elements of an array over the given dimensions. "), ("Base","prod!","prod!(r, A) + Multiply elements of \"A\" over the singleton dimensions of \"r\", and write results to \"r\". @@ -1132,12 +1268,14 @@ ("Base","any","any(itr) -> Bool + Test whether any elements of a boolean collection are true. "), ("Base","any","any(A, dims) + Test whether any values along the given dimensions of an array are true. @@ -1145,6 +1283,7 @@ ("Base","any!","any!(r, A) + Test whether any values in \"A\" along the singleton dimensions of \"r\" are true, and write results to \"r\". @@ -1152,12 +1291,14 @@ ("Base","all","all(itr) -> Bool + Test whether all elements of a boolean collection are true. "), ("Base","all","all(A, dims) + Test whether all values along the given dimensions of an array are true. @@ -1165,6 +1306,7 @@ ("Base","all!","all!(r, A) + Test whether all values in \"A\" along the singleton dimensions of \"r\" are true, and write results to \"r\". @@ -1172,6 +1314,7 @@ ("Base","count","count(p, itr) -> Integer + Count the number of elements in \"itr\" for which predicate \"p\" returns true. @@ -1179,6 +1322,7 @@ ("Base","any","any(p, itr) -> Bool + Determine whether predicate \"p\" returns true for any elements of \"itr\". @@ -1186,6 +1330,7 @@ ("Base","all","all(p, itr) -> Bool + Determine whether predicate \"p\" returns true for all elements of \"itr\". @@ -1198,6 +1343,7 @@ ("Base","map","map(f, c...) -> collection + Transform collection \"c\" by applying \"f\" to each element. For multiple collection arguments, apply \"f\" elementwise. @@ -1212,12 +1358,14 @@ ("Base","map!","map!(function, collection) + In-place version of \"map()\". "), ("Base","map!","map!(function, destination, collection...) + Like \"map()\", but stores the result in \"destination\" rather than a new collection. \"destination\" must be at least as large as the first collection. @@ -1226,6 +1374,7 @@ ("Base","mapreduce","mapreduce(f, op, itr) + Applies function \"f\" to each element in \"itr\" and then reduces the result using the binary function \"op\". @@ -1239,12 +1388,14 @@ ("Base","first","first(coll) + Get the first element of an iterable collection. "), ("Base","last","last(coll) + Get the last element of an ordered collection, if it can be computed in O(1) time. This is accomplished by calling \"endof\" to get the last index. @@ -1253,12 +1404,14 @@ ("Base","step","step(r) + Get the step size of a \"Range\" object. "), ("Base","collect","collect(collection) + Return an array of all items in a collection. For associative collections, returns (key, value) tuples. @@ -1266,6 +1419,7 @@ ("Base","collect","collect(element_type, collection) + Return an array of type \"Array{element_type,1}\" of all items in a collection. @@ -1273,6 +1427,7 @@ ("Base","issubset","issubset(a, b) + Determine whether every element of \"a\" is also in \"b\", using the \"in\" function. @@ -1280,6 +1435,7 @@ ("Base","filter","filter(function, collection) + Return a copy of \"collection\", removing elements for which \"function\" is false. For associative collections, the function is passed two arguments (key and value). @@ -1288,6 +1444,7 @@ ("Base","filter!","filter!(function, collection) + Update \"collection\", removing elements for which \"function\" is false. For associative collections, the function is passed two arguments (key and value). @@ -1296,6 +1453,7 @@ ("Base","getindex","getindex(collection, key...) + Retrieve the value(s) stored at the given key or index within a collection. The syntax \"a[i,j,...]\" is converted by the compiler to \"getindex(a, i, j, ...)\". @@ -1304,6 +1462,7 @@ ("Base","setindex!","setindex!(collection, value, key...) + Store the given value at the given key or index within a collection. The syntax \"a[i,j,...] = x\" is converted by the compiler to \"setindex!(a, x, i, j, ...)\". @@ -1312,6 +1471,7 @@ ("Base","Dict","Dict() + \"Dict{K,V}()\" constructs a hashtable with keys of type K and values of type V. The literal syntax is \"{\"A\"=>1, \"B\"=>2}\" for a \"Dict{Any,Any}\", or \"[\"A\"=>1, \"B\"=>2]\" for a \"Dict\" @@ -1321,12 +1481,14 @@ ("Base","haskey","haskey(collection, key) -> Bool + Determine whether a collection has a mapping for a given key. "), ("Base","get","get(collection, key, default) + Return the value stored for the given key, or the given default value if no mapping for the key is present. @@ -1334,6 +1496,7 @@ ("Base","get","get(f::Function, collection, key) + Return the value stored for the given key, or if no mapping for the key is present, return \"f()\". Use \"get!\" to also store the default value in the dictionary. @@ -1349,6 +1512,7 @@ ("Base","get!","get!(collection, key, default) + Return the value stored for the given key, or if no mapping for the key is present, store \"key => default\", and return \"default\". @@ -1356,6 +1520,7 @@ ("Base","get!","get!(f::Function, collection, key) + Return the value stored for the given key, or if no mapping for the key is present, store \"key => f()\", and return \"f()\". @@ -1370,6 +1535,7 @@ ("Base","getkey","getkey(collection, key, default) + Return the key matching argument \"key\" if one exists in \"collection\", otherwise return \"default\". @@ -1377,6 +1543,7 @@ ("Base","delete!","delete!(collection, key) + Delete the mapping for the given key in a collection, and return the colection. @@ -1384,6 +1551,7 @@ ("Base","pop!","pop!(collection, key[, default]) + Delete and return the mapping for \"key\" if it exists in \"collection\", otherwise return \"default\", or throw an error if default is not specified. @@ -1392,6 +1560,7 @@ ("Base","keys","keys(collection) + Return an iterator over all keys in a collection. \"collect(keys(d))\" returns an array of keys. @@ -1399,6 +1568,7 @@ ("Base","values","values(collection) + Return an iterator over all values in a collection. \"collect(values(d))\" returns an array of values. @@ -1406,18 +1576,21 @@ ("Base","merge","merge(collection, others...) + Construct a merged collection from the given collections. "), ("Base","merge!","merge!(collection, others...) + Update collection with pairs from the other collections "), ("Base","sizehint","sizehint(s, n) + Suggest that collection \"s\" reserve capacity for at least \"n\" elements. This can improve performance. @@ -1425,6 +1598,7 @@ ("Base","Set","Set([itr]) + Construct a \"Set\" of the values generated by the given iterable object, or an empty set. Should be used instead of \"IntSet\" for sparse integer sets, or for sets of arbitrary objects. @@ -1433,6 +1607,7 @@ ("Base","IntSet","IntSet([itr]) + Construct a sorted set of the integers generated by the given iterable object, or an empty set. Implemented as a bit string, and therefore designed for dense integer sets. If the set will be @@ -1443,6 +1618,7 @@ ("Base","union","union(s1, s2...) + Construct the union of two or more sets. Maintains order with arrays. @@ -1450,12 +1626,14 @@ ("Base","union!","union!(s, iterable) + Union each element of \"iterable\" into set \"s\" in-place. "), ("Base","intersect","intersect(s1, s2...) + Construct the intersection of two or more sets. Maintains order and multiplicity of the first argument for arrays and ranges. @@ -1463,6 +1641,7 @@ ("Base","setdiff","setdiff(s1, s2) + Construct the set of elements in \"s1\" but not \"s2\". Maintains order with arrays. Note that both arguments must be collections, and both will be iterated over. In particular, @@ -1473,12 +1652,14 @@ ("Base","setdiff!","setdiff!(s, iterable) + Remove each element of \"iterable\" from set \"s\" in-place. "), ("Base","symdiff","symdiff(s1, s2...) + Construct the symmetric difference of elements in the passed in sets or arrays. Maintains order with arrays. @@ -1486,6 +1667,7 @@ ("Base","symdiff!","symdiff!(s, n) + IntSet s is destructively modified to toggle the inclusion of integer \"n\". @@ -1493,6 +1675,7 @@ ("Base","symdiff!","symdiff!(s, itr) + For each element in \"itr\", destructively toggle its inclusion in set \"s\". @@ -1500,6 +1683,7 @@ ("Base","symdiff!","symdiff!(s1, s2) + Construct the symmetric difference of IntSets \"s1\" and \"s2\", storing the result in \"s1\". @@ -1507,18 +1691,21 @@ ("Base","complement","complement(s) + Returns the set-complement of IntSet s. "), ("Base","complement!","complement!(s) + Mutates IntSet s into its set-complement. "), ("Base","intersect!","intersect!(s1, s2) + Intersects IntSets s1 and s2 and overwrites the set s1 with the result. If needed, s1 will be expanded to the size of s2. @@ -1526,42 +1713,49 @@ ("Base","issubset","issubset(A, S) -> Bool + True if \"A ⊆ S\" (A is a subset of or equal to S) "), ("Base","push!","push!(collection, items...) -> collection + Insert items at the end of a collection. "), ("Base","pop!","pop!(collection) -> item + Remove the last item in a collection and return it. "), ("Base","unshift!","unshift!(collection, items...) -> collection + Insert items at the beginning of a collection. "), ("Base","shift!","shift!(collection) -> item + Remove the first item in a collection. "), ("Base","insert!","insert!(collection, index, item) + Insert an item at the given index. "), ("Base","deleteat!","deleteat!(collection, index) + Remove the item at the given index, and return the modified collection. Subsequent items are shifted to fill the resulting gap. @@ -1569,6 +1763,7 @@ ("Base","deleteat!","deleteat!(collection, itr) + Remove the items at the indices given by *itr*, and return the modified collection. Subsequent items are shifted to fill the resulting gap. *itr* must be sorted and unique. @@ -1577,6 +1772,7 @@ ("Base","splice!","splice!(collection, index[, replacement]) -> item + Remove the item at the given index, and return the removed item. Subsequent items are shifted down to fill the resulting gap. If specified, replacement values from an ordered collection will be @@ -1589,6 +1785,7 @@ ("Base","splice!","splice!(collection, range[, replacement]) -> items + Remove items in the specified index range, and return a collection containing the removed items. Subsequent items are shifted down to fill the resulting gap. If specified, replacement values from an @@ -1601,12 +1798,14 @@ ("Base","resize!","resize!(collection, n) -> collection + Resize collection to contain \"n\" elements. "), ("Base","append!","append!(collection, items) -> collection. + Add the elements of \"items\" to the end of a collection. \"append!([1],[2,3]) => [1,2,3]\" @@ -1614,6 +1813,7 @@ ("Base","prepend!","prepend!(collection, items) -> collection + Insert the elements of \"items\" to the beginning of a collection. \"prepend!([3],[1,2]) => [1,2,3]\" @@ -1621,18 +1821,21 @@ ("Base","length","length(s) + The number of characters in string \"s\". "), ("Base","sizeof","sizeof(s::String) + The number of bytes in string \"s\". "), ("Base","*","*(s, t) + Concatenate strings. The \"*\" operator is an alias to this function. @@ -1645,6 +1848,7 @@ ("Base","^","^(s, n) + Repeat \"n\" times the string \"s\". The \"^\" operator is an alias to this function. @@ -1657,18 +1861,21 @@ ("Base","string","string(xs...) + Create a string from any values using the \"print\" function. "), ("Base","repr","repr(x) + Create a string from any value using the \"showall\" function. "), ("Base","bytestring","bytestring(::Ptr{Uint8}[, length]) + Create a string from the address of a C (0-terminated) string encoded in ASCII or UTF-8. A copy is made; the ptr can be safely freed. If \"length\" is specified, the string does not have to be @@ -1678,6 +1885,7 @@ ("Base","bytestring","bytestring(s) + Convert a string to a contiguous byte array representation appropriate for passing it to C functions. The string will be encoded as either ASCII or UTF-8. @@ -1686,12 +1894,14 @@ ("Base","ascii","ascii(::Array{Uint8, 1}) + Create an ASCII string from a byte array. "), ("Base","ascii","ascii(s) + Convert a string to a contiguous ASCII string (all characters must be valid ASCII characters). @@ -1699,12 +1909,14 @@ ("Base","utf8","utf8(::Array{Uint8, 1}) + Create a UTF-8 string from a byte array. "), ("Base","utf8","utf8(s) + Convert a string to a contiguous UTF-8 string (all characters must be valid UTF-8 characters). @@ -1712,6 +1924,7 @@ ("Base","normalize_string","normalize_string(s, normalform::Symbol) + Normalize the string \"s\" according to one of the four \"normal forms\" of the Unicode standard: \"normalform\" can be \":NFC\", \":NFD\", \":NFKC\", or \":NFKD\". Normal forms C (canonical @@ -1739,10 +1952,10 @@ * \"casefold=true\": perform Unicode case folding, e.g. for case- insensitive string comparison - * \"newline2lf=true\", \"newline2ls=true\", or \"newline2ps=true\": - convert various newline sequences (LF, CRLF, CR, NEL) into a - linefeed (LF), line-separation (LS), or paragraph-separation (PS) - character, respectively + * \"newline2lf=true\", \"newline2ls=true\", or + \"newline2ps=true\": convert various newline sequences (LF, CRLF, + CR, NEL) into a linefeed (LF), line-separation (LS), or + paragraph-separation (PS) character, respectively * \"stripmark=true\": strip diacritical marks (e.g. accents) @@ -1765,6 +1978,7 @@ ("Base","is_valid_ascii","is_valid_ascii(s) -> Bool + Returns true if the string or byte vector is valid ASCII, false otherwise. @@ -1772,6 +1986,7 @@ ("Base","is_valid_utf8","is_valid_utf8(s) -> Bool + Returns true if the string or byte vector is valid UTF-8, false otherwise. @@ -1779,6 +1994,7 @@ ("Base","is_valid_char","is_valid_char(c) -> Bool + Returns true if the given char or integer is a valid Unicode code point. @@ -1786,6 +2002,7 @@ ("Base","is_assigned_char","is_assigned_char(c) -> Bool + Returns true if the given char or integer is an assigned Unicode code point. @@ -1793,6 +2010,7 @@ ("Base","ismatch","ismatch(r::Regex, s::String) -> Bool + Test whether a string contains a match of the given regular expression. @@ -1800,6 +2018,7 @@ ("Base","match","match(r::Regex, s::String[, idx::Integer[, addopts]]) + Search for the first match of the regular expression \"r\" in \"s\" and return a RegexMatch object containing the match, or nothing if the match failed. The matching substring can be retrieved by @@ -1809,7 +2028,9 @@ "), -("Base","eachmatch","eachmatch(r::Regex, s::String[, overlap::Bool=false]) +("Base","eachmatch","eachmatch(r::Regex, s::String[, +overlap::Bool=false]) + Search for all matches of a the regular expression \"r\" in \"s\" and return a iterator over the matches. If overlap is true, the @@ -1818,7 +2039,9 @@ "), -("Base","matchall","matchall(r::Regex, s::String[, overlap::Bool=false]) -> Vector{String} +("Base","matchall","matchall(r::Regex, s::String[, +overlap::Bool=false]) -> Vector{String} + Return a vector of the matching substrings from eachmatch. @@ -1826,6 +2049,7 @@ ("Base","lpad","lpad(string, n, p) + Make a string at least \"n\" characters long by padding on the left with copies of \"p\". @@ -1833,6 +2057,7 @@ ("Base","rpad","rpad(string, n, p) + Make a string at least \"n\" characters long by padding on the right with copies of \"p\". @@ -1840,6 +2065,7 @@ ("Base","search","search(string, chars[, start]) + Search for the first occurance of the given characters within the given string. The second argument may be a single character, a vector or a set of characters, a string, or a regular expression @@ -1859,6 +2085,7 @@ ("Base","rsearch","rsearch(string, chars[, start]) + Similar to \"search\", but returning the last occurance of the given characters within the given string, searching in reverse from \"start\". @@ -1867,6 +2094,7 @@ ("Base","searchindex","searchindex(string, substring[, start]) + Similar to \"search\", but return only the start index at which the substring is found, or 0 if it is not. @@ -1874,6 +2102,7 @@ ("Base","rsearchindex","rsearchindex(string, substring[, start]) + Similar to \"rsearch\", but return only the start index at which the substring is found, or 0 if it is not. @@ -1881,12 +2110,14 @@ ("Base","contains","contains(haystack, needle) + Determine whether the second argument is a substring of the first. "), ("Base","replace","replace(string, pat, r[, n]) + Search for the given pattern \"pat\", and replace each occurrence with \"r\". If \"n\" is provided, replace at most \"n\" occurrences. As with search, the second argument may be a single @@ -1898,6 +2129,7 @@ ("Base","split","split(string, [chars, [limit,] [include_empty]]) + Return an array of substrings by splitting the given string on occurrences of the given character delimiters, which may be specified in any of the formats allowed by \"search\"'s second @@ -1912,12 +2144,14 @@ ("Base","rsplit","rsplit(string, [chars, [limit,] [include_empty]]) + Similar to \"split\", but starting from the end of the string. "), ("Base","strip","strip(string[, chars]) + Return \"string\" with any leading and trailing whitespace removed. If \"chars\" (a character, or vector or set of characters) is provided, instead remove characters contained in it. @@ -1926,6 +2160,7 @@ ("Base","lstrip","lstrip(string[, chars]) + Return \"string\" with any leading whitespace removed. If \"chars\" (a character, or vector or set of characters) is provided, instead remove characters contained in it. @@ -1934,6 +2169,7 @@ ("Base","rstrip","rstrip(string[, chars]) + Return \"string\" with any trailing whitespace removed. If \"chars\" (a character, or vector or set of characters) is provided, instead remove characters contained in it. @@ -1942,6 +2178,7 @@ ("Base","beginswith","beginswith(string, prefix | chars) + Returns \"true\" if \"string\" starts with \"prefix\". If the second argument is a vector or set of characters, tests whether the first character of \"string\" belongs to that set. @@ -1950,6 +2187,7 @@ ("Base","endswith","endswith(string, suffix | chars) + Returns \"true\" if \"string\" ends with \"suffix\". If the second argument is a vector or set of characters, tests whether the last character of \"string\" belongs to that set. @@ -1958,30 +2196,35 @@ ("Base","uppercase","uppercase(string) + Returns \"string\" with all characters converted to uppercase. "), ("Base","lowercase","lowercase(string) + Returns \"string\" with all characters converted to lowercase. "), ("Base","ucfirst","ucfirst(string) + Returns \"string\" with the first character converted to uppercase. "), ("Base","lcfirst","lcfirst(string) + Returns \"string\" with the first character converted to lowercase. "), ("Base","join","join(strings, delim) + Join an array of strings into a single string, inserting the given delimiter between adjacent strings. @@ -1989,36 +2232,42 @@ ("Base","chop","chop(string) + Remove the last character from a string "), ("Base","chomp","chomp(string) + Remove a trailing newline from a string "), ("Base","ind2chr","ind2chr(string, i) + Convert a byte index to a character index "), ("Base","chr2ind","chr2ind(string, i) + Convert a character index to a byte index "), ("Base","isvalid","isvalid(str, i) + Tells whether index \"i\" is valid for the given string "), ("Base","nextind","nextind(str, i) + Get the next valid string index after \"i\". Returns a value greater than \"endof(str)\" at or after the end of the string. @@ -2026,6 +2275,7 @@ ("Base","prevind","prevind(str, i) + Get the previous valid string index before \"i\". Returns a value less than \"1\" at the beginning of the string. @@ -2033,6 +2283,7 @@ ("Base","randstring","randstring(len) + Create a random ASCII string of length \"len\", consisting of upper- and lower-case letters and the digits 0-9 @@ -2040,18 +2291,21 @@ ("Base","charwidth","charwidth(c) + Gives the number of columns needed to print a character. "), ("Base","strwidth","strwidth(s) + Gives the number of columns needed to print a string. "), ("Base","isalnum","isalnum(c::Union(Char, String)) -> Bool + Tests whether a character is alphanumeric, or whether this is true for all elements of a string. @@ -2059,6 +2313,7 @@ ("Base","isalpha","isalpha(c::Union(Char, String)) -> Bool + Tests whether a character is alphabetic, or whether this is true for all elements of a string. @@ -2066,6 +2321,7 @@ ("Base","isascii","isascii(c::Union(Char, String)) -> Bool + Tests whether a character belongs to the ASCII character set, or whether this is true for all elements of a string. @@ -2073,6 +2329,7 @@ ("Base","isblank","isblank(c::Union(Char, String)) -> Bool + Tests whether a character is a tab or space, or whether this is true for all elements of a string. @@ -2080,6 +2337,7 @@ ("Base","iscntrl","iscntrl(c::Union(Char, String)) -> Bool + Tests whether a character is a control character, or whether this is true for all elements of a string. @@ -2087,6 +2345,7 @@ ("Base","isdigit","isdigit(c::Union(Char, String)) -> Bool + Tests whether a character is a numeric digit (0-9), or whether this is true for all elements of a string. @@ -2094,6 +2353,7 @@ ("Base","isgraph","isgraph(c::Union(Char, String)) -> Bool + Tests whether a character is printable, and not a space, or whether this is true for all elements of a string. @@ -2101,6 +2361,7 @@ ("Base","islower","islower(c::Union(Char, String)) -> Bool + Tests whether a character is a lowercase letter, or whether this is true for all elements of a string. @@ -2108,6 +2369,7 @@ ("Base","isprint","isprint(c::Union(Char, String)) -> Bool + Tests whether a character is printable, including space, or whether this is true for all elements of a string. @@ -2115,6 +2377,7 @@ ("Base","ispunct","ispunct(c::Union(Char, String)) -> Bool + Tests whether a character is printable, and not a space or alphanumeric, or whether this is true for all elements of a string. @@ -2122,6 +2385,7 @@ ("Base","isspace","isspace(c::Union(Char, String)) -> Bool + Tests whether a character is any whitespace character, or whether this is true for all elements of a string. @@ -2129,6 +2393,7 @@ ("Base","isupper","isupper(c::Union(Char, String)) -> Bool + Tests whether a character is an uppercase letter, or whether this is true for all elements of a string. @@ -2136,6 +2401,7 @@ ("Base","isxdigit","isxdigit(c::Union(Char, String)) -> Bool + Tests whether a character is a valid hexadecimal digit, or whether this is true for all elements of a string. @@ -2143,12 +2409,14 @@ ("Base","symbol","symbol(str) -> Symbol + Convert a string to a \"Symbol\". "), ("Base","escape_string","escape_string(str::String) -> String + General escaping of traditional C and Unicode escape sequences. See \"print_escaped()\" for more general escaping. @@ -2156,6 +2424,7 @@ ("Base","unescape_string","unescape_string(s::String) -> String + General unescaping of traditional C and Unicode escape sequences. Reverse of \"escape_string()\". See also \"print_unescaped()\". @@ -2163,6 +2432,7 @@ ("Base","utf16","utf16(s) + Create a UTF-16 string from a byte array, array of \"Uint16\", or any other string type. (Data must be valid UTF-16. Conversions of byte arrays check for a byte-order marker in the first two bytes, @@ -2183,6 +2453,7 @@ ("Base","utf16","utf16(::Union(Ptr{Uint16}, Ptr{Int16})[, length]) + Create a string from the address of a NUL-terminated UTF-16 string. A copy is made; the pointer can be safely freed. If \"length\" is specified, the string does not have to be NUL-terminated. @@ -2191,12 +2462,14 @@ ("Base","is_valid_utf16","is_valid_utf16(s) -> Bool + Returns true if the string or \"Uint16\" array is valid UTF-16. "), ("Base","utf32","utf32(s) + Create a UTF-32 string from a byte array, array of \"Uint32\", or any other string type. (Conversions of byte arrays check for a byte-order marker in the first four bytes, and do not include it in @@ -2215,7 +2488,9 @@ "), -("Base","utf32","utf32(::Union(Ptr{Char}, Ptr{Uint32}, Ptr{Int32})[, length]) +("Base","utf32","utf32(::Union(Ptr{Char}, Ptr{Uint32}, Ptr{Int32})[, +length]) + Create a string from the address of a NUL-terminated UTF-32 string. A copy is made; the pointer can be safely freed. If \"length\" is @@ -2225,6 +2500,7 @@ ("Base","wstring","wstring(s) + This is a synonym for either \"utf32(s)\" or \"utf16(s)\", depending on whether \"Cwchar_t\" is 32 or 16 bits, respectively. The synonym \"WString\" for \"UTF32String\" or \"UTF16String\" is @@ -2234,23 +2510,28 @@ ("Base","STDOUT","STDOUT + Global variable referring to the standard out stream. "), ("Base","STDERR","STDERR + Global variable referring to the standard error stream. "), ("Base","STDIN","STDIN + Global variable referring to the standard input stream. "), -("Base","open","open(file_name[, read, write, create, truncate, append]) -> IOStream +("Base","open","open(file_name[, read, write, create, truncate, +append]) -> IOStream + Open a file in a mode specified by five boolean arguments. The default is to open files for reading only. Returns a stream for @@ -2260,6 +2541,7 @@ ("Base","open","open(file_name[, mode]) -> IOStream + Alternate syntax for open, where a string-based mode specifier is used instead of the five booleans. The values of \"mode\" correspond to those from \"fopen(3)\" or Perl \"open\", and are @@ -2283,6 +2565,7 @@ ("Base","open","open(f::function, args...) + Apply the function \"f\" to the result of \"open(args...)\" and close the resulting file descriptor upon completion. @@ -2292,24 +2575,28 @@ ("Base","IOBuffer","IOBuffer() -> IOBuffer + Create an in-memory I/O stream. "), ("Base","IOBuffer","IOBuffer(size::Int) + Create a fixed size IOBuffer. The buffer will not grow dynamically. "), ("Base","IOBuffer","IOBuffer(string) + Create a read-only IOBuffer on the data underlying the given string "), ("Base","IOBuffer","IOBuffer([data][, readable, writable[, maxsize]]) + Create an IOBuffer, which may optionally operate on a pre-existing array. If the readable/writable arguments are given, they restrict whether or not the buffer may be read from or written to @@ -2321,6 +2608,7 @@ ("Base","takebuf_array","takebuf_array(b::IOBuffer) + Obtain the contents of an \"IOBuffer\" as an array, without copying. @@ -2328,12 +2616,15 @@ ("Base","takebuf_string","takebuf_string(b::IOBuffer) + Obtain the contents of an \"IOBuffer\" as a string, without copying. "), -("Base","fdio","fdio([name::String], fd::Integer[, own::Bool]) -> IOStream +("Base","fdio","fdio([name::String], fd::Integer[, own::Bool]) -> +IOStream + Create an \"IOStream\" object from an integer file descriptor. If \"own\" is true, closing this object will close the underlying @@ -2345,12 +2636,14 @@ ("Base","flush","flush(stream) + Commit all currently buffered writes to the given stream. "), ("Base","flush_cstdio","flush_cstdio() + Flushes the C \"stdout\" and \"stderr\" streams (which may have been written to by external C code). @@ -2358,12 +2651,14 @@ ("Base","close","close(stream) + Close an I/O stream. Performs a \"flush\" first. "), ("Base","write","write(stream, x) + Write the canonical binary representation of a value to the given stream. @@ -2371,6 +2666,7 @@ ("Base","read","read(stream, type) + Read a value of the given type from a stream, in canonical binary representation. @@ -2378,6 +2674,7 @@ ("Base","read","read(stream, type, dims) + Read a series of values of the given type from a stream, in canonical binary representation. \"dims\" is either a tuple or a series of integer arguments specifying the size of \"Array\" to @@ -2387,11 +2684,14 @@ ("Base","read!","read!(stream, array::Array) + Read binary data from a stream, filling in the argument \"array\". "), -("Base","readbytes!","readbytes!(stream, b::Vector{Uint8}, nb=length(b)) +("Base","readbytes!","readbytes!(stream, b::Vector{Uint8}, +nb=length(b)) + Read at most \"nb\" bytes from the stream into \"b\", returning the number of bytes read (increasing the size of \"b\" as needed). @@ -2400,6 +2700,7 @@ ("Base","readbytes","readbytes(stream, nb=typemax(Int)) + Read at most \"nb\" bytes from the stream, returning a \"Vector{Uint8}\" of the bytes read. @@ -2407,36 +2708,42 @@ ("Base","position","position(s) + Get the current position of a stream. "), ("Base","seek","seek(s, pos) + Seek a stream to the given position. "), ("Base","seekstart","seekstart(s) + Seek a stream to its beginning. "), ("Base","seekend","seekend(s) + Seek a stream to its end. "), ("Base","skip","skip(s, offset) + Seek a stream relative to the current position. "), ("Base","mark","mark(s) + Add a mark at the current position of stream \"s\". Returns the marked position. @@ -2446,6 +2753,7 @@ ("Base","unmark","unmark(s) + Remove a mark from stream \"s\". Returns \"true\" if the stream was marked, \"false\" otherwise. @@ -2455,6 +2763,7 @@ ("Base","reset","reset(s) + Reset a stream \"s\" to a previously marked position, and remove the mark. Returns the previously marked position. Throws an error if the stream is not marked. @@ -2465,6 +2774,7 @@ ("Base","ismarked","ismarked(s) + Returns true if stream \"s\" is marked. See also \"mark()\", \"unmark()\", \"reset()\" @@ -2473,6 +2783,7 @@ ("Base","eof","eof(stream) -> Bool + Tests whether an I/O stream is at end-of-file. If the stream is not yet exhausted, this function will block to wait for more data if necessary, and then return \"false\". Therefore it is always safe @@ -2484,12 +2795,14 @@ ("Base","isreadonly","isreadonly(stream) -> Bool + Determine whether a stream is read-only. "), ("Base","isopen","isopen(stream) -> Bool + Determine whether a stream is open (i.e. has not been closed yet). If the connection has been closed remotely (in case of e.g. a socket), \"isopen\" will return \"false\" even though buffered data @@ -2499,6 +2812,7 @@ ("Base","ntoh","ntoh(x) + Converts the endianness of a value from Network byte order (big- endian) to that used by the Host. @@ -2506,6 +2820,7 @@ ("Base","hton","hton(x) + Converts the endianness of a value from that used by the Host to Network byte order (big-endian). @@ -2513,6 +2828,7 @@ ("Base","ltoh","ltoh(x) + Converts the endianness of a value from Little-endian to that used by the Host. @@ -2520,6 +2836,7 @@ ("Base","htol","htol(x) + Converts the endianness of a value from that used by the Host to Little-endian. @@ -2527,6 +2844,7 @@ ("Base","ENDIAN_BOM","ENDIAN_BOM + The 32-bit byte-order-mark indicates the native byte order of the host machine. Little-endian machines will contain the value 0x04030201. Big-endian machines will contain the value 0x01020304. @@ -2535,6 +2853,7 @@ ("Base","serialize","serialize(stream, value) + Write an arbitrary value to a stream in an opaque format, such that it can be read back by \"deserialize\". The read-back value will be as identical as possible to the original. In general, this process @@ -2546,12 +2865,14 @@ ("Base","deserialize","deserialize(stream) + Read a value written by \"serialize\". "), ("Base","print_escaped","print_escaped(io, str::String, esc::String) + General escaping of traditional C and Unicode escape sequences, plus any characters in esc are also escaped (with a backslash). @@ -2559,6 +2880,7 @@ ("Base","print_unescaped","print_unescaped(io, s::String) + General unescaping of traditional C and Unicode escape sequences. Reverse of \"print_escaped()\". @@ -2566,6 +2888,7 @@ ("Base","print_joined","print_joined(io, items, delim[, last]) + Print elements of \"items\" to \"io\" with \"delim\" between them. If \"last\" is specified, it is used as the final delimiter instead of \"delim\". @@ -2574,6 +2897,7 @@ ("Base","print_shortest","print_shortest(io, x) + Print the shortest possible representation of number \"x\" as a floating point number, ensuring that it would parse to the exact same number. @@ -2582,6 +2906,7 @@ ("Base","fd","fd(stream) + Returns the file descriptor backing the stream or file. Note that this function only applies to synchronous *File*'s and *IOStream*'s not to any of the asynchronous streams. @@ -2590,6 +2915,7 @@ ("Base","redirect_stdout","redirect_stdout() + Create a pipe to which all C and Julia level STDOUT output will be redirected. Returns a tuple (rd,wr) representing the pipe ends. Data written to STDOUT may now be read from the rd end of the pipe. @@ -2600,6 +2926,7 @@ ("Base","redirect_stdout","redirect_stdout(stream) + Replace STDOUT by stream for all C and julia level output to STDOUT. Note that *stream* must be a TTY, a Pipe or a TcpSocket. @@ -2607,12 +2934,14 @@ ("Base","redirect_stderr","redirect_stderr([stream]) + Like redirect_stdout, but for STDERR "), ("Base","redirect_stdin","redirect_stdin([stream]) + Like redirect_stdout, but for STDIN. Note that the order of the return tuple is still (rd,wr), i.e. data to be read from STDIN, may be written to wr. @@ -2621,6 +2950,7 @@ ("Base","readchomp","readchomp(x) + Read the entirety of x as a string but remove trailing newlines. Equivalent to chomp(readall(x)). @@ -2628,6 +2958,7 @@ ("Base","readdir","readdir([dir]) -> Vector{ByteString} + Returns the files and directories in the directory *dir* (or the current working directory if not given). @@ -2635,6 +2966,7 @@ ("Base","truncate","truncate(file, n) + Resize the file or buffer given by the first argument to exactly *n* bytes, filling previously unallocated space with '0' if the file or buffer is grown @@ -2643,6 +2975,7 @@ ("Base","skipchars","skipchars(stream, predicate; linecomment::Char) + Advance the stream until before the first character for which \"predicate\" returns false. For example \"skipchars(stream, isspace)\" will skip all whitespace. If keyword argument @@ -2653,6 +2986,7 @@ ("Base","countlines","countlines(io[, eol::Char]) + Read io until the end of the stream/file and count the number of non-empty lines. To specify a file pass the filename as the first argument. EOL markers other than 'n' are supported by passing them @@ -2662,6 +2996,7 @@ ("Base","PipeBuffer","PipeBuffer() + An IOBuffer that allows reading and performs writes by appending. Seeking and truncating are not supported. See IOBuffer for the available constructors. @@ -2670,6 +3005,7 @@ ("Base","PipeBuffer","PipeBuffer(data::Vector{Uint8}[, maxsize]) + Create a PipeBuffer to operate on a data vector, optionally specifying a size beyond which the underlying Array may not be grown. @@ -2678,6 +3014,7 @@ ("Base","readavailable","readavailable(stream) + Read all available data on the stream, blocking the task only if no data is available. @@ -2685,6 +3022,7 @@ ("Base","stat","stat(file) + Returns a structure whose fields contain information about the file. The fields of the structure are: @@ -2718,6 +3056,7 @@ ("Base","lstat","lstat(file) + Like stat, but for symbolic links gets the info for the link itself rather than the file it refers to. This function must be called on a file path rather than a file object or a file descriptor. @@ -2726,30 +3065,35 @@ ("Base","ctime","ctime(file) + Equivalent to stat(file).ctime "), ("Base","mtime","mtime(file) + Equivalent to stat(file).mtime "), ("Base","filemode","filemode(file) + Equivalent to stat(file).mode "), ("Base","filesize","filesize(path...) + Equivalent to stat(file).size "), ("Base","uperm","uperm(file) + Gets the permissions of the owner of the file as a bitfield of +------+-----------------------+ @@ -2766,12 +3110,14 @@ ("Base","gperm","gperm(file) + Like uperm but gets the permissions of the group owning the file "), ("Base","operm","operm(file) + Like uperm but gets the permissions for people who neither own the file nor are a member of the group owning the file @@ -2779,12 +3125,14 @@ ("Base","cp","cp(src::String, dst::String) + Copy a file from *src* to *dest*. "), ("Base","download","download(url[, localfile]) + Download a file from the given url, optionally renaming it to the given local file name. Note that this function relies on the availability of external tools such as \"curl\", \"wget\" or @@ -2796,12 +3144,14 @@ ("Base","mv","mv(src::String, dst::String) + Move a file from *src* to *dst*. "), ("Base","rm","rm(path::String; recursive=false) + Delete the file, link, or empty directory at the given path. If \"recursive=true\" is passed and the path is a directory, then all contents are removed recursively. @@ -2810,24 +3160,28 @@ ("Base","touch","touch(path::String) + Update the last-modified timestamp on a file to the current time. "), ("Base","connect","connect([host], port) -> TcpSocket + Connect to the host \"host\" on port \"port\" "), ("Base","connect","connect(path) -> Pipe + Connect to the Named Pipe/Domain Socket at \"path\" "), ("Base","listen","listen([addr], port) -> TcpServer + Listen on port on the address specified by \"addr\". By default this listens on localhost only. To listen on all interfaces pass, \"IPv4(0)\" or \"IPv6(0)\" as appropriate. @@ -2836,36 +3190,42 @@ ("Base","listen","listen(path) -> PipeServer + Listens on/Creates a Named Pipe/Domain Socket "), ("Base","getaddrinfo","getaddrinfo(host) + Gets the IP address of the \"host\" (may have to do a DNS lookup) "), ("Base","parseip","parseip(addr) + Parse a string specifying an IPv4 or IPv6 ip address. "), ("Base","IPv4","IPv4(host::Integer) -> IPv4 + Returns IPv4 object from ip address formatted as Integer "), ("Base","IPv6","IPv6(host::Integer) -> IPv6 + Returns IPv6 object from ip address formatted as Integer "), ("Base","nb_available","nb_available(stream) + Returns the number of bytes available for reading before a read from this stream or buffer will block. @@ -2873,6 +3233,7 @@ ("Base","accept","accept(server[, client]) + Accepts a connection on the given server and returns a connection to the client. An uninitialized client stream may be provided, in which case it will be used instead of creating a new stream. @@ -2881,6 +3242,7 @@ ("Base","listenany","listenany(port_hint) -> (Uint16, TcpServer) + Create a TcpServer on any port, using hint as a starting point. Returns a tuple of the actual port that the server was created on and the server itself. @@ -2889,6 +3251,7 @@ ("Base","watch_file","watch_file(cb=false, s; poll=false) + Watch file or directory \"s\" and run callback \"cb\" when \"s\" is modified. The \"poll\" parameter specifies whether to use file system event monitoring or polling. The callback function \"cb\" @@ -2901,7 +3264,9 @@ "), -("Base","poll_fd","poll_fd(fd, seconds::Real; readable=false, writable=false) +("Base","poll_fd","poll_fd(fd, seconds::Real; readable=false, +writable=false) + Poll a file descriptor fd for changes in the read or write availability and with a timeout given by the second argument. If @@ -2913,7 +3278,9 @@ "), -("Base","poll_file","poll_file(s, interval_seconds::Real, seconds::Real) +("Base","poll_file","poll_file(s, interval_seconds::Real, +seconds::Real) + Monitor a file for changes by polling every *interval_seconds* seconds for *seconds* seconds. A return value of true indicates the @@ -2923,6 +3290,7 @@ ("Base","show","show(x) + Write an informative text representation of a value to the current output stream. New types should overload \"show(io, x)\" where the first argument is a stream. The representation used by \"show\" @@ -2932,6 +3300,7 @@ ("Base","showcompact","showcompact(x) + Show a more compact representation of a value. This is used for printing array elements. If a new type has a different compact representation, it should overload \"showcompact(io, x)\" where the @@ -2941,12 +3310,14 @@ ("Base","showall","showall(x) + Similar to \"show\", except shows all elements of arrays. "), ("Base","summary","summary(x) + Return a string giving a brief description of a value. By default returns \"string(typeof(x))\". For arrays, returns strings like \"2x2 Float64 Array\". @@ -2955,6 +3326,7 @@ ("Base","print","print(x) + Write (to the default output stream) a canonical (un-decorated) text representation of a value if there is one, otherwise call \"show\". The representation used by \"print\" includes minimal @@ -2964,11 +3336,14 @@ ("Base","println","println(x) + Print (using \"print()\") \"x\" followed by a newline. "), -("Base","print_with_color","print_with_color(color::Symbol[, io], strings...) +("Base","print_with_color","print_with_color(color::Symbol[, io], +strings...) + Print strings in a color specified as a symbol, for example \":red\" or \":blue\". @@ -2977,18 +3352,21 @@ ("Base","info","info(msg) + Display an informational message. "), ("Base","warn","warn(msg) + Display a warning. "), ("Base","@printf","@printf([io::IOStream], \"%Fmt\", args...) + Print arg(s) using C \"printf()\" style format specification string. Optionally, an IOStream may be passed as the first argument to redirect output. @@ -2997,12 +3375,14 @@ ("Base","@sprintf","@sprintf(\"%Fmt\", args...) + Return \"@printf\" formatted output as string. "), ("Base","sprint","sprint(f::Function, args...) + Call the given function with an I/O stream and the supplied extra arguments. Everything written to this I/O stream is returned as a string. @@ -3011,30 +3391,35 @@ ("Base","showerror","showerror(io, e) + Show a descriptive representation of an exception object. "), ("Base","dump","dump(x) + Show all user-visible structure of a value. "), ("Base","xdump","xdump(x) + Show all structure of a value, including all fields of objects. "), ("Base","readall","readall(stream) + Read the entire contents of an I/O stream as a string. "), ("Base","readline","readline(stream=STDIN) + Read a single line of text, including a trailing newline character (if one is reached before the end of the input), from the given \"stream\" (defaults to \"STDIN\"), @@ -3043,23 +3428,29 @@ ("Base","readuntil","readuntil(stream, delim) + Read a string, up to and including the given delimiter byte. "), ("Base","readlines","readlines(stream) + Read all lines as an array. "), ("Base","eachline","eachline(stream) + Create an iterable object that will yield each line from a stream. "), -("Base","readdlm","readdlm(source, delim::Char, T::Type, eol::Char; header=false, skipstart=0, use_mmap, ignore_invalid_chars=false, quotes=true, dims, comments=true, comment_char='#') +("Base","readdlm","readdlm(source, delim::Char, T::Type, eol::Char; +header=false, skipstart=0, use_mmap, ignore_invalid_chars=false, +quotes=true, dims, comments=true, comment_char='#') + Read a matrix from the source where each line (separated by \"eol\") gives one row, with elements separated by the given @@ -3103,6 +3494,7 @@ ("Base","readdlm","readdlm(source, delim::Char, eol::Char; options...) + If all data is numeric, the result will be a numeric array. If some elements cannot be parsed as numbers, a cell array of numbers and strings is returned. @@ -3111,12 +3503,14 @@ ("Base","readdlm","readdlm(source, delim::Char, T::Type; options...) + The end of line delimiter is taken as \"\\n\". "), ("Base","readdlm","readdlm(source, delim::Char; options...) + The end of line delimiter is taken as \"\\n\". If all data is numeric, the result will be a numeric array. If some elements cannot be parsed as numbers, a cell array of numbers and strings is @@ -3126,6 +3520,7 @@ ("Base","readdlm","readdlm(source, T::Type; options...) + The columns are assumed to be separated by one or more whitespaces. The end of line delimiter is taken as \"\\n\". @@ -3133,6 +3528,7 @@ ("Base","readdlm","readdlm(source; options...) + The columns are assumed to be separated by one or more whitespaces. The end of line delimiter is taken as \"\\n\". If all data is numeric, the result will be a numeric array. If some elements @@ -3143,6 +3539,7 @@ ("Base","writedlm","writedlm(f, A, delim='t') + Write \"A\" (either an array type or an iterable collection of iterable rows) as text to \"f\" (either a filename string or an \"IO\" stream) using the given delimeter \"delim\" (which defaults @@ -3157,18 +3554,21 @@ ("Base","readcsv","readcsv(source, [T::Type]; options...) + Equivalent to \"readdlm\" with \"delim\" set to comma. "), ("Base","writecsv","writecsv(filename, A) + Equivalent to \"writedlm\" with \"delim\" set to comma. "), ("Base","Base64Pipe","Base64Pipe(ostream) + Returns a new write-only I/O stream, which converts any bytes written to it into base64-encoded ASCII bytes written to \"ostream\". Calling \"close\" on the \"Base64Pipe\" stream is @@ -3178,6 +3578,7 @@ "), ("Base","base64","base64(writefunc, args...) + base64(args...) Given a \"write\"-like function \"writefunc\", which takes an I/O @@ -3191,6 +3592,7 @@ base64(args...) "), ("Base","display","display(x) + display(d::Display, x) display(mime, x) display(d::Display, mime, x) @@ -3214,6 +3616,7 @@ display(d::Display, mime, x) "), ("Base","redisplay","redisplay(x) + redisplay(d::Display, x) redisplay(mime, x) redisplay(d::Display, mime, x) @@ -3228,6 +3631,7 @@ redisplay(d::Display, mime, x) "), ("Base","displayable","displayable(mime) -> Bool + displayable(d::Display, mime) -> Bool Returns a boolean value indicating whether the given \"mime\" type @@ -3239,6 +3643,7 @@ displayable(d::Display, mime) -> Bool ("Base","writemime","writemime(stream, mime, x) + The \"display\" functions ultimately call \"writemime\" in order to write an object \"x\" as a given \"mime\" type to a given I/O \"stream\" (usually a memory buffer), if possible. In order to @@ -3267,6 +3672,7 @@ displayable(d::Display, mime) -> Bool ("Base","mimewritable","mimewritable(mime, x) + Returns a boolean value indicating whether or not the object \"x\" can be written as the given \"mime\" type. (By default, this is determined automatically by the existence of the corresponding @@ -3276,6 +3682,7 @@ displayable(d::Display, mime) -> Bool ("Base","reprmime","reprmime(mime, x) + Returns a \"String\" or \"Vector{Uint8}\" containing the representation of \"x\" in the requested \"mime\" type, as written by \"writemime\" (throwing a \"MethodError\" if no appropriate @@ -3294,6 +3701,7 @@ displayable(d::Display, mime) -> Bool ("Base","stringmime","stringmime(mime, x) + Returns a \"String\" containing the representation of \"x\" in the requested \"mime\" type. This is similar to \"reprmime\" except that binary data is base64-encoded as an ASCII string. @@ -3302,6 +3710,7 @@ displayable(d::Display, mime) -> Bool ("Base","pushdisplay","pushdisplay(d::Display) + Pushes a new display \"d\" on top of the global display-backend stack. Calling \"display(x)\" or \"display(mime, x)\" will display \"x\" on the topmost compatible backend in the stack (i.e., the @@ -3310,6 +3719,7 @@ displayable(d::Display, mime) -> Bool "), ("Base","popdisplay","popdisplay() + popdisplay(d::Display) Pop the topmost backend off of the display-backend stack, or the @@ -3319,6 +3729,7 @@ popdisplay(d::Display) ("Base","TextDisplay","TextDisplay(stream) + Returns a \"TextDisplay <: Display\", which can display any object as the text/plain MIME type (only), writing the text representation to the given I/O stream. (The text representation is the same as @@ -3328,12 +3739,14 @@ popdisplay(d::Display) ("Base","istext","istext(m::MIME) + Determine whether a MIME type is text data. "), ("Base","mmap_array","mmap_array(type, dims, stream[, offset]) + Create an \"Array\" whose values are linked to a file, using memory-mapping. This provides a convenient way of working with data too large to fit in the computer's memory. @@ -3384,6 +3797,7 @@ popdisplay(d::Display) ("Base","mmap_bitarray","mmap_bitarray([type], dims, stream[, offset]) + Create a \"BitArray\" whose values are linked to a file, using memory-mapping; it has the same purpose, works in the same way, and has the same arguments, as \"mmap_array()\", but the byte @@ -3399,6 +3813,7 @@ popdisplay(d::Display) ("Base","msync","msync(array) + Forces synchronization between the in-memory version of a memory- mapped \"Array\" or \"BitArray\" and the on-disk version. @@ -3406,6 +3821,7 @@ popdisplay(d::Display) ("Base","msync","msync(ptr, len[, flags]) + Forces synchronization of the mmap'd memory region from ptr to ptr+len. Flags defaults to MS_SYNC, but can be a combination of MS_ASYNC, MS_SYNC, or MS_INVALIDATE. See your platform man page for @@ -3420,6 +3836,7 @@ popdisplay(d::Display) ("Base","MS_ASYNC","MS_ASYNC + Enum constant for msync. See your platform man page for details. (not available on Windows). @@ -3427,6 +3844,7 @@ popdisplay(d::Display) ("Base","MS_SYNC","MS_SYNC + Enum constant for msync. See your platform man page for details. (not available on Windows). @@ -3434,6 +3852,7 @@ popdisplay(d::Display) ("Base","MS_INVALIDATE","MS_INVALIDATE + Enum constant for msync. See your platform man page for details. (not available on Windows). @@ -3441,12 +3860,14 @@ popdisplay(d::Display) ("Base","mmap","mmap(len, prot, flags, fd, offset) + Low-level interface to the mmap system call. See the man page. "), ("Base","munmap","munmap(pointer, len) + Low-level interface for unmapping memory (see the man page). With mmap_array you do not need to call this directly; the memory is unmapped for you when the array goes out of scope. @@ -3455,102 +3876,119 @@ popdisplay(d::Display) ("Base","-","-(x) + Unary minus operator. "), ("Base","+","+(x, y) + Binary addition operator. "), ("Base","-","-(x, y) + Binary subtraction operator. "), ("Base","*","*(x, y) + Binary multiplication operator. "), ("Base","/","/(x, y) + Binary left-division operator. "), ("Base","\\","\\(x, y) + Binary right-division operator. "), ("Base","^","^(x, y) + Binary exponentiation operator. "), ("Base",".+",".+(x, y) + Element-wise binary addition operator. "), ("Base",".-",".-(x, y) + Element-wise binary subtraction operator. "), ("Base",".*",".*(x, y) + Element-wise binary multiplication operator. "), ("Base","./","./(x, y) + Element-wise binary left division operator. "), ("Base",".\\",".\\(x, y) + Element-wise binary right division operator. "), ("Base",".^",".^(x, y) + Element-wise binary exponentiation operator. "), ("Base","div","div(a, b) + Compute a/b, truncating to an integer "), ("Base","fld","fld(a, b) + Largest integer less than or equal to a/b "), ("Base","mod","mod(x, m) + Modulus after division, returning in the range [0,m) "), ("Base","mod2pi","mod2pi(x) + Modulus after division by 2pi, returning in the range [0,2pi). This function computes a floating point representation of the @@ -3562,42 +4000,49 @@ popdisplay(d::Display) ("Base","rem","rem(x, m) + Remainder after division "), ("Base","divrem","divrem(x, y) + Compute \"x/y\" and \"x%y\" at the same time "), ("Base","%","%(x, m) + Remainder after division. The operator form of \"rem\". "), ("Base","mod1","mod1(x, m) + Modulus after division, returning in the range (0,m] "), ("Base","rem1","rem1(x, m) + Remainder after division, returning in the range (0,m] "), ("Base","//","//(num, den) + Rational division "), ("Base","rationalize","rationalize([Type=Int], x; tol=eps(x)) + Approximate floating point number \"x\" as a Rational number with components of the given integer type. The result will differ from \"x\" by no more than \"tol\". @@ -3606,36 +4051,42 @@ popdisplay(d::Display) ("Base","num","num(x) + Numerator of the rational representation of \"x\" "), ("Base","den","den(x) + Denominator of the rational representation of \"x\" "), ("Base","<<","<<(x, n) + Left shift operator. "), ("Base",">>",">>(x, n) + Right shift operator. "), ("Base",">>>",">>>(x, n) + Unsigned right shift operator. "), ("Base",":",":(start[, step], stop) + Range operator. \"a:b\" constructs a range from \"a\" to \"b\" with a step size of 1, and \"a:s:b\" is similar but uses a step size of \"s\". These syntaxes call the function \"colon\". The colon is @@ -3645,12 +4096,14 @@ popdisplay(d::Display) ("Base","colon","colon(start[, step], stop) + Called by \":\" syntax for constructing ranges. "), ("Base","range","range(start[, step], length) + Construct a range by length, given a starting value and optional step (defaults to 1). @@ -3658,12 +4111,14 @@ popdisplay(d::Display) ("Base","linrange","linrange(start, end, length) + Construct a range by length, given a starting and ending value. "), ("Base","==","==(x, y) + Generic equality operator, giving a single \"Bool\" result. Falls back to \"===\". Should be implemented for all types with a notion of equality, based on the abstract value that an instance @@ -3684,6 +4139,7 @@ popdisplay(d::Display) ("Base","!=","!=(x, y) + Not-equals comparison operator. Always gives the opposite answer as \"==\". New types should generally not implement this, and rely on the fallback definition \"!=(x,y) = !(x==y)\" instead. @@ -3692,18 +4148,21 @@ popdisplay(d::Display) ("Base","===","===(x, y) + See the \"is()\" operator "), ("Base","!==","!==(x, y) + Equivalent to \"!is(x, y)\" "), ("Base","<","<(x, y) + Less-than comparison operator. New numeric types should implement this function for two arguments of the new type. Because of the behavior of floating-point NaN values, \"<\" implements a partial @@ -3714,12 +4173,14 @@ popdisplay(d::Display) ("Base","<=","<=(x, y) + Less-than-or-equals comparison operator. "), ("Base",">",">(x, y) + Greater-than comparison operator. Generally, new types should implement \"<\" instead of this function, and rely on the fallback definition \">(x,y) = y=",">=(x, y) + Greater-than-or-equals comparison operator. "), ("Base",".==",".==(x, y) + Element-wise equality comparison operator. "), ("Base",".!=",".!=(x, y) + Element-wise not-equals comparison operator. "), ("Base",".<",".<(x, y) + Element-wise less-than comparison operator. "), ("Base",".<=",".<=(x, y) + Element-wise less-than-or-equals comparison operator. "), ("Base",".>",".>(x, y) + Element-wise greater-than comparison operator. "), ("Base",".>=",".>=(x, y) + Element-wise greater-than-or-equals comparison operator. "), ("Base","cmp","cmp(x, y) + Return -1, 0, or 1 depending on whether \"x\" is less than, equal to, or greater than \"y\", respectively. Uses the total order implemented by \"isless\". For floating-point numbers, uses \"<\" @@ -3779,161 +4248,189 @@ popdisplay(d::Display) ("Base","~","~(x) + Bitwise not "), ("Base","&","&(x, y) + Bitwise and "), ("Base","|","|(x, y) + Bitwise or "), ("Base","\$","\$(x, y) + Bitwise exclusive or "), ("Base","!","!(x) + Boolean not "), ("","x && y","x && y + Short-circuiting boolean and "), ("","x || y","x || y + Short-circuiting boolean or "), ("Base","A_ldiv_Bc","A_ldiv_Bc(a, b) + Matrix operator A \\ B^H "), ("Base","A_ldiv_Bt","A_ldiv_Bt(a, b) + Matrix operator A \\ B^T "), ("Base","A_mul_B","A_mul_B(...) + Matrix operator A B "), ("Base","A_mul_Bc","A_mul_Bc(...) + Matrix operator A B^H "), ("Base","A_mul_Bt","A_mul_Bt(...) + Matrix operator A B^T "), ("Base","A_rdiv_Bc","A_rdiv_Bc(...) + Matrix operator A / B^H "), ("Base","A_rdiv_Bt","A_rdiv_Bt(a, b) + Matrix operator A / B^T "), ("Base","Ac_ldiv_B","Ac_ldiv_B(...) + Matrix operator A^H \\ B "), ("Base","Ac_ldiv_Bc","Ac_ldiv_Bc(...) + Matrix operator A^H \\ B^H "), ("Base","Ac_mul_B","Ac_mul_B(...) + Matrix operator A^H B "), ("Base","Ac_mul_Bc","Ac_mul_Bc(...) + Matrix operator A^H B^H "), ("Base","Ac_rdiv_B","Ac_rdiv_B(a, b) + Matrix operator A^H / B "), ("Base","Ac_rdiv_Bc","Ac_rdiv_Bc(a, b) + Matrix operator A^H / B^H "), ("Base","At_ldiv_B","At_ldiv_B(...) + Matrix operator A^T \\ B "), ("Base","At_ldiv_Bt","At_ldiv_Bt(...) + Matrix operator A^T \\ B^T "), ("Base","At_mul_B","At_mul_B(...) + Matrix operator A^T B "), ("Base","At_mul_Bt","At_mul_Bt(...) + Matrix operator A^T B^T "), ("Base","At_rdiv_B","At_rdiv_B(a, b) + Matrix operator A^T / B "), ("Base","At_rdiv_Bt","At_rdiv_Bt(a, b) + Matrix operator A^T / B^T "), -("Base","isapprox","isapprox(x::Number, y::Number; rtol::Real=cbrt(maxeps), atol::Real=sqrt(maxeps)) +("Base","isapprox","isapprox(x::Number, y::Number; +rtol::Real=cbrt(maxeps), atol::Real=sqrt(maxeps)) + Inexact equality comparison - behaves slightly different depending on types of input args: @@ -3956,42 +4453,49 @@ popdisplay(d::Display) ("Base","sin","sin(x) + Compute sine of \"x\", where \"x\" is in radians "), ("Base","cos","cos(x) + Compute cosine of \"x\", where \"x\" is in radians "), ("Base","tan","tan(x) + Compute tangent of \"x\", where \"x\" is in radians "), ("Base","sind","sind(x) + Compute sine of \"x\", where \"x\" is in degrees "), ("Base","cosd","cosd(x) + Compute cosine of \"x\", where \"x\" is in degrees "), ("Base","tand","tand(x) + Compute tangent of \"x\", where \"x\" is in degrees "), ("Base","sinpi","sinpi(x) + Compute \\sin(\\pi x) more accurately than \"sin(pi*x)\", especially for large \"x\". @@ -3999,6 +4503,7 @@ popdisplay(d::Display) ("Base","cospi","cospi(x) + Compute \\cos(\\pi x) more accurately than \"cos(pi*x)\", especially for large \"x\". @@ -4006,36 +4511,42 @@ popdisplay(d::Display) ("Base","sinh","sinh(x) + Compute hyperbolic sine of \"x\" "), ("Base","cosh","cosh(x) + Compute hyperbolic cosine of \"x\" "), ("Base","tanh","tanh(x) + Compute hyperbolic tangent of \"x\" "), ("Base","asin","asin(x) + Compute the inverse sine of \"x\", where the output is in radians "), ("Base","acos","acos(x) + Compute the inverse cosine of \"x\", where the output is in radians "), ("Base","atan","atan(x) + Compute the inverse tangent of \"x\", where the output is in radians @@ -4043,6 +4554,7 @@ popdisplay(d::Display) ("Base","atan2","atan2(y, x) + Compute the inverse tangent of \"y/x\", using the signs of both \"x\" and \"y\" to determine the quadrant of the return value. @@ -4050,18 +4562,21 @@ popdisplay(d::Display) ("Base","asind","asind(x) + Compute the inverse sine of \"x\", where the output is in degrees "), ("Base","acosd","acosd(x) + Compute the inverse cosine of \"x\", where the output is in degrees "), ("Base","atand","atand(x) + Compute the inverse tangent of \"x\", where the output is in degrees @@ -4069,48 +4584,56 @@ popdisplay(d::Display) ("Base","sec","sec(x) + Compute the secant of \"x\", where \"x\" is in radians "), ("Base","csc","csc(x) + Compute the cosecant of \"x\", where \"x\" is in radians "), ("Base","cot","cot(x) + Compute the cotangent of \"x\", where \"x\" is in radians "), ("Base","secd","secd(x) + Compute the secant of \"x\", where \"x\" is in degrees "), ("Base","cscd","cscd(x) + Compute the cosecant of \"x\", where \"x\" is in degrees "), ("Base","cotd","cotd(x) + Compute the cotangent of \"x\", where \"x\" is in degrees "), ("Base","asec","asec(x) + Compute the inverse secant of \"x\", where the output is in radians "), ("Base","acsc","acsc(x) + Compute the inverse cosecant of \"x\", where the output is in radians @@ -4118,6 +4641,7 @@ popdisplay(d::Display) ("Base","acot","acot(x) + Compute the inverse cotangent of \"x\", where the output is in radians @@ -4125,12 +4649,14 @@ popdisplay(d::Display) ("Base","asecd","asecd(x) + Compute the inverse secant of \"x\", where the output is in degrees "), ("Base","acscd","acscd(x) + Compute the inverse cosecant of \"x\", where the output is in degrees @@ -4138,6 +4664,7 @@ popdisplay(d::Display) ("Base","acotd","acotd(x) + Compute the inverse cotangent of \"x\", where the output is in degrees @@ -4145,66 +4672,77 @@ popdisplay(d::Display) ("Base","sech","sech(x) + Compute the hyperbolic secant of \"x\" "), ("Base","csch","csch(x) + Compute the hyperbolic cosecant of \"x\" "), ("Base","coth","coth(x) + Compute the hyperbolic cotangent of \"x\" "), ("Base","asinh","asinh(x) + Compute the inverse hyperbolic sine of \"x\" "), ("Base","acosh","acosh(x) + Compute the inverse hyperbolic cosine of \"x\" "), ("Base","atanh","atanh(x) + Compute the inverse hyperbolic tangent of \"x\" "), ("Base","asech","asech(x) + Compute the inverse hyperbolic secant of \"x\" "), ("Base","acsch","acsch(x) + Compute the inverse hyperbolic cosecant of \"x\" "), ("Base","acoth","acoth(x) + Compute the inverse hyperbolic cotangent of \"x\" "), ("Base","sinc","sinc(x) + Compute \\sin(\\pi x) / (\\pi x) if x \\neq 0, and 1 if x = 0. "), ("Base","cosc","cosc(x) + Compute \\cos(\\pi x) / x - \\sin(\\pi x) / (\\pi x^2) if x \\neq 0, and 0 if x = 0. This is the derivative of \"sinc(x)\". @@ -4212,24 +4750,28 @@ popdisplay(d::Display) ("Base","deg2rad","deg2rad(x) + Convert \"x\" from degrees to radians "), ("Base","rad2deg","rad2deg(x) + Convert \"x\" from radians to degrees "), ("Base","hypot","hypot(x, y) + Compute the \\sqrt{x^2+y^2} avoiding overflow and underflow "), ("Base","log","log(x) + Compute the natural logarithm of \"x\". Throws \"DomainError\" for negative \"Real\" arguments. Use complex negative arguments instead. @@ -4238,6 +4780,7 @@ popdisplay(d::Display) ("Base","log","log(b, x) + Compute the base \"b\" logarithm of \"x\". Throws \"DomainError\" for negative \"Real\" arguments. @@ -4245,6 +4788,7 @@ popdisplay(d::Display) ("Base","log2","log2(x) + Compute the logarithm of \"x\" to base 2. Throws \"DomainError\" for negative \"Real\" arguments. @@ -4252,6 +4796,7 @@ popdisplay(d::Display) ("Base","log10","log10(x) + Compute the logarithm of \"x\" to base 10. Throws \"DomainError\" for negative \"Real\" arguments. @@ -4259,6 +4804,7 @@ popdisplay(d::Display) ("Base","log1p","log1p(x) + Accurate natural logarithm of \"1+x\". Throws \"DomainError\" for \"Real\" arguments less than -1. @@ -4266,6 +4812,7 @@ popdisplay(d::Display) ("Base","frexp","frexp(val) + Return \"(x,exp)\" such that \"x\" has a magnitude in the interval \"[1/2, 1)\" or 0, and val = x \\times 2^{exp}. @@ -4273,30 +4820,35 @@ popdisplay(d::Display) ("Base","exp","exp(x) + Compute e^x "), ("Base","exp2","exp2(x) + Compute 2^x "), ("Base","exp10","exp10(x) + Compute 10^x "), ("Base","ldexp","ldexp(x, n) + Compute x \\times 2^n "), ("Base","modf","modf(x) + Return a tuple (fpart,ipart) of the fractional and integral parts of a number. Both parts have the same sign as the argument. @@ -4304,12 +4856,14 @@ popdisplay(d::Display) ("Base","expm1","expm1(x) + Accurately compute e^x-1 "), ("Base","round","round(x[, digits[, base]]) + \"round(x)\" returns the nearest integral value of the same type as \"x\" to \"x\". \"round(x, digits)\" rounds to the specified number of digits after the decimal place, or before if negative, e.g., @@ -4321,6 +4875,7 @@ popdisplay(d::Display) ("Base","ceil","ceil(x[, digits[, base]]) + Returns the nearest integral value of the same type as \"x\" not less than \"x\". \"digits\" and \"base\" work as above. @@ -4328,6 +4883,7 @@ popdisplay(d::Display) ("Base","floor","floor(x[, digits[, base]]) + Returns the nearest integral value of the same type as \"x\" not greater than \"x\". \"digits\" and \"base\" work as above. @@ -4335,6 +4891,7 @@ popdisplay(d::Display) ("Base","trunc","trunc(x[, digits[, base]]) + Returns the nearest integral value of the same type as \"x\" not greater in magnitude than \"x\". \"digits\" and \"base\" work as above. @@ -4343,30 +4900,35 @@ popdisplay(d::Display) ("Base","iround","iround(x) -> Integer + Returns the nearest integer to \"x\". "), ("Base","iceil","iceil(x) -> Integer + Returns the nearest integer not less than \"x\". "), ("Base","ifloor","ifloor(x) -> Integer + Returns the nearest integer not greater than \"x\". "), ("Base","itrunc","itrunc(x) -> Integer + Returns the nearest integer not greater in magnitude than \"x\". "), ("Base","signif","signif(x, digits[, base]) + Rounds (in the sense of \"round\") \"x\" so that there are \"digits\" significant digits, under a base \"base\" representation, default 10. E.g., \"signif(123.456, 2)\" is @@ -4376,6 +4938,7 @@ popdisplay(d::Display) ("Base","min","min(x, y, ...) + Return the minimum of the arguments. Operates elementwise over arrays. @@ -4383,6 +4946,7 @@ popdisplay(d::Display) ("Base","max","max(x, y, ...) + Return the maximum of the arguments. Operates elementwise over arrays. @@ -4390,6 +4954,7 @@ popdisplay(d::Display) ("Base","minmax","minmax(x, y) + Return \"(min(x,y), max(x,y))\". See also: \"extrema()\" that returns \"(minimum(x), maximum(x))\" @@ -4397,6 +4962,7 @@ popdisplay(d::Display) ("Base","clamp","clamp(x, lo, hi) + Return x if \"lo <= x <= hi\". If \"x < lo\", return \"lo\". If \"x > hi\", return \"hi\". Arguments are promoted to a common type. Operates elementwise over \"x\" if it is an array. @@ -4405,24 +4971,28 @@ popdisplay(d::Display) ("Base","abs","abs(x) + Absolute value of \"x\" "), ("Base","abs2","abs2(x) + Squared absolute value of \"x\" "), ("Base","copysign","copysign(x, y) + Return \"x\" such that it has the same sign as \"y\" "), ("Base","sign","sign(x) + Return \"+1\" if \"x\" is positive, \"0\" if \"x == 0\", and \"-1\" if \"x\" is negative. @@ -4430,6 +5000,7 @@ popdisplay(d::Display) ("Base","signbit","signbit(x) + Returns \"1\" if the value of the sign of \"x\" is negative, otherwise \"0\". @@ -4437,6 +5008,7 @@ popdisplay(d::Display) ("Base","flipsign","flipsign(x, y) + Return \"x\" with its sign flipped if \"y\" is negative. For example \"abs(x) = flipsign(x,x)\". @@ -4444,6 +5016,7 @@ popdisplay(d::Display) ("Base","sqrt","sqrt(x) + Return \\sqrt{x}. Throws \"DomainError\" for negative \"Real\" arguments. Use complex negative arguments instead. The prefix operator \"√\" is equivalent to \"sqrt\". @@ -4452,6 +5025,7 @@ popdisplay(d::Display) ("Base","isqrt","isqrt(n) + Integer square root: the largest integer \"m\" such that \"m*m <= n\". @@ -4459,6 +5033,7 @@ popdisplay(d::Display) ("Base","cbrt","cbrt(x) + Return x^{1/3}. The prefix operator \"∛\" is equivalent to \"cbrt\". @@ -4466,6 +5041,7 @@ popdisplay(d::Display) ("Base","erf","erf(x) + Compute the error function of \"x\", defined by \\frac{2}{\\sqrt{\\pi}} \\int_0^x e^{-t^2} dt for arbitrary complex \"x\". @@ -4474,6 +5050,7 @@ popdisplay(d::Display) ("Base","erfc","erfc(x) + Compute the complementary error function of \"x\", defined by 1 - \\operatorname{erf}(x). @@ -4481,6 +5058,7 @@ popdisplay(d::Display) ("Base","erfcx","erfcx(x) + Compute the scaled complementary error function of \"x\", defined by e^{x^2} \\operatorname{erfc}(x). Note also that \\operatorname{erfcx}(-ix) computes the Faddeeva function w(x). @@ -4489,6 +5067,7 @@ popdisplay(d::Display) ("Base","erfi","erfi(x) + Compute the imaginary error function of \"x\", defined by -i \\operatorname{erf}(ix). @@ -4496,6 +5075,7 @@ popdisplay(d::Display) ("Base","dawson","dawson(x) + Compute the Dawson function (scaled imaginary error function) of \"x\", defined by \\frac{\\sqrt{\\pi}}{2} e^{-x^2} \\operatorname{erfi}(x). @@ -4504,6 +5084,7 @@ popdisplay(d::Display) ("Base","erfinv","erfinv(x) + Compute the inverse error function of a real \"x\", defined by \\operatorname{erf}(\\operatorname{erfinv}(x)) = x. @@ -4511,6 +5092,7 @@ popdisplay(d::Display) ("Base","erfcinv","erfcinv(x) + Compute the inverse error complementary function of a real \"x\", defined by \\operatorname{erfc}(\\operatorname{erfcinv}(x)) = x. @@ -4518,18 +5100,21 @@ popdisplay(d::Display) ("Base","real","real(z) + Return the real part of the complex number \"z\" "), ("Base","imag","imag(z) + Return the imaginary part of the complex number \"z\" "), ("Base","reim","reim(z) + Return both the real and imaginary parts of the complex number \"z\" @@ -4537,42 +5122,49 @@ popdisplay(d::Display) ("Base","conj","conj(z) + Compute the complex conjugate of a complex number \"z\" "), ("Base","angle","angle(z) + Compute the phase angle of a complex number \"z\" "), ("Base","cis","cis(z) + Return \\exp(iz). "), ("Base","binomial","binomial(n, k) + Number of ways to choose \"k\" out of \"n\" items "), ("Base","factorial","factorial(n) + Factorial of n "), ("Base","factorial","factorial(n, k) + Compute \"factorial(n)/factorial(k)\" "), ("Base","factor","factor(n) -> Dict + Compute the prime factorization of an integer \"n\". Returns a dictionary. The keys of the dictionary correspond to the factors, and hence are of the same type as \"n\". The value associated with @@ -4588,6 +5180,7 @@ popdisplay(d::Display) ("Base","gcd","gcd(x, y) + Greatest common (positive) divisor (or zero if x and y are both zero). @@ -4595,12 +5188,14 @@ popdisplay(d::Display) ("Base","lcm","lcm(x, y) + Least common (non-negative) multiple. "), ("Base","gcdx","gcdx(x, y) + Greatest common (positive) divisor, also returning integer coefficients \"u\" and \"v\" that solve \"ux+vy == gcd(x,y)\" @@ -4608,12 +5203,14 @@ popdisplay(d::Display) ("Base","ispow2","ispow2(n) -> Bool + Test whether \"n\" is a power of two "), ("Base","nextpow2","nextpow2(n) + The smallest power of two not less than \"n\". Returns 0 for \"n==0\", and returns \"-nextpow2(-n)\" for negative arguments. @@ -4621,6 +5218,7 @@ popdisplay(d::Display) ("Base","prevpow2","prevpow2(n) + The largest power of two not greater than \"n\". Returns 0 for \"n==0\", and returns \"-prevpow2(-n)\" for negative arguments. @@ -4628,6 +5226,7 @@ popdisplay(d::Display) ("Base","nextpow","nextpow(a, x) + The smallest \"a^n\" not less than \"x\", where \"n\" is a non- negative integer. \"a\" must be greater than 1, and \"x\" must be greater than 0. @@ -4636,6 +5235,7 @@ popdisplay(d::Display) ("Base","prevpow","prevpow(a, x) + The largest \"a^n\" not greater than \"x\", where \"n\" is a non- negative integer. \"a\" must be greater than 1, and \"x\" must not be less than 1. @@ -4644,6 +5244,7 @@ popdisplay(d::Display) ("Base","nextprod","nextprod([k_1, k_2, ...], n) + Next integer not less than \"n\" that can be written as \\prod k_i^{p_i} for integers p_1, p_2, etc. @@ -4651,6 +5252,7 @@ popdisplay(d::Display) ("Base","prevprod","prevprod([k_1, k_2, ...], n) + Previous integer not greater than \"n\" that can be written as \\prod k_i^{p_i} for integers p_1, p_2, etc. @@ -4658,6 +5260,7 @@ popdisplay(d::Display) ("Base","invmod","invmod(x, m) + Take the inverse of \"x\" modulo \"m\": \"y\" such that xy = 1 \\pmod m @@ -4665,30 +5268,35 @@ popdisplay(d::Display) ("Base","powermod","powermod(x, p, m) + Compute x^p \\pmod m "), ("Base","gamma","gamma(x) + Compute the gamma function of \"x\" "), ("Base","lgamma","lgamma(x) + Compute the logarithm of absolute value of \"gamma(x)\" "), ("Base","lfact","lfact(x) + Compute the logarithmic factorial of \"x\" "), ("Base","digamma","digamma(x) + Compute the digamma function of \"x\" (the logarithmic derivative of \"gamma(x)\") @@ -4696,12 +5304,14 @@ popdisplay(d::Display) ("Base","invdigamma","invdigamma(x) + Compute the inverse digamma function of \"x\". "), ("Base","trigamma","trigamma(x) + Compute the trigamma function of \"x\" (the logarithmic second derivative of \"gamma(x)\") @@ -4709,6 +5319,7 @@ popdisplay(d::Display) ("Base","polygamma","polygamma(m, x) + Compute the polygamma function of order \"m\" of argument \"x\" (the \"(m+1)th\" derivative of the logarithm of \"gamma(x)\") @@ -4716,42 +5327,49 @@ popdisplay(d::Display) ("Base","airy","airy(k, x) + kth derivative of the Airy function \\operatorname{Ai}(x). "), ("Base","airyai","airyai(x) + Airy function \\operatorname{Ai}(x). "), ("Base","airyprime","airyprime(x) + Airy function derivative \\operatorname{Ai}'(x). "), ("Base","airyaiprime","airyaiprime(x) + Airy function derivative \\operatorname{Ai}'(x). "), ("Base","airybi","airybi(x) + Airy function \\operatorname{Bi}(x). "), ("Base","airybiprime","airybiprime(x) + Airy function derivative \\operatorname{Bi}'(x). "), ("Base","airyx","airyx(k, x) + scaled kth derivative of the Airy function, return \\operatorname{Ai}(x) e^{\\frac{2}{3} x \\sqrt{x}} for \"k == 0 || k == 1\", and \\operatorname{Ai}(x) e^{- \\left| \\operatorname{Re} @@ -4762,24 +5380,28 @@ popdisplay(d::Display) ("Base","besselj0","besselj0(x) + Bessel function of the first kind of order 0, J_0(x). "), ("Base","besselj1","besselj1(x) + Bessel function of the first kind of order 1, J_1(x). "), ("Base","besselj","besselj(nu, x) + Bessel function of the first kind of order \"nu\", J_\\nu(x). "), ("Base","besseljx","besseljx(nu, x) + Scaled Bessel function of the first kind of order \"nu\", J_\\nu(x) e^{- | \\operatorname{Im}(x) |}. @@ -4787,24 +5409,28 @@ popdisplay(d::Display) ("Base","bessely0","bessely0(x) + Bessel function of the second kind of order 0, Y_0(x). "), ("Base","bessely1","bessely1(x) + Bessel function of the second kind of order 1, Y_1(x). "), ("Base","bessely","bessely(nu, x) + Bessel function of the second kind of order \"nu\", Y_\\nu(x). "), ("Base","besselyx","besselyx(nu, x) + Scaled Bessel function of the second kind of order \"nu\", Y_\\nu(x) e^{- | \\operatorname{Im}(x) |}. @@ -4812,12 +5438,14 @@ popdisplay(d::Display) ("Base","hankelh1","hankelh1(nu, x) + Bessel function of the third kind of order \"nu\", H^{(1)}_\\nu(x). "), ("Base","hankelh1x","hankelh1x(nu, x) + Scaled Bessel function of the third kind of order \"nu\", H^{(1)}_\\nu(x) e^{-x i}. @@ -4825,12 +5453,14 @@ popdisplay(d::Display) ("Base","hankelh2","hankelh2(nu, x) + Bessel function of the third kind of order \"nu\", H^{(2)}_\\nu(x). "), ("Base","hankelh2x","hankelh2x(nu, x) + Scaled Bessel function of the third kind of order \"nu\", H^{(2)}_\\nu(x) e^{x i}. @@ -4838,6 +5468,7 @@ popdisplay(d::Display) ("Base","besselh","besselh(nu, k, x) + Bessel function of the third kind of order \"nu\" (Hankel function). \"k\" is either 1 or 2, selecting \"hankelh1\" or \"hankelh2\", respectively. @@ -4846,6 +5477,7 @@ popdisplay(d::Display) ("Base","besseli","besseli(nu, x) + Modified Bessel function of the first kind of order \"nu\", I_\\nu(x). @@ -4853,6 +5485,7 @@ popdisplay(d::Display) ("Base","besselix","besselix(nu, x) + Scaled modified Bessel function of the first kind of order \"nu\", I_\\nu(x) e^{- | \\operatorname{Re}(x) |}. @@ -4860,6 +5493,7 @@ popdisplay(d::Display) ("Base","besselk","besselk(nu, x) + Modified Bessel function of the second kind of order \"nu\", K_\\nu(x). @@ -4867,6 +5501,7 @@ popdisplay(d::Display) ("Base","besselkx","besselkx(nu, x) + Scaled modified Bessel function of the second kind of order \"nu\", K_\\nu(x) e^x. @@ -4874,6 +5509,7 @@ popdisplay(d::Display) ("Base","beta","beta(x, y) + Euler integral of the first kind \\operatorname{B}(x,y) = \\Gamma(x)\\Gamma(y)/\\Gamma(x+y). @@ -4881,6 +5517,7 @@ popdisplay(d::Display) ("Base","lbeta","lbeta(x, y) + Natural logarithm of the absolute value of the beta function \\log(|\\operatorname{B}(x,y)|). @@ -4888,6 +5525,7 @@ popdisplay(d::Display) ("Base","eta","eta(x) + Dirichlet eta function \\eta(s) = \\sum^\\infty_{n=1}(-)^{n-1}/n^{s}. @@ -4895,12 +5533,14 @@ popdisplay(d::Display) ("Base","zeta","zeta(s) + Riemann zeta function \\zeta(s). "), ("Base","zeta","zeta(s, z) + Hurwitz zeta function \\zeta(s, z). (This is equivalent to the Riemann zeta function \\zeta(s) for the case of \"z=1\".) @@ -4908,18 +5548,21 @@ popdisplay(d::Display) ("Base","ndigits","ndigits(n, b) + Compute the number of digits in number \"n\" written in base \"b\". "), ("Base","widemul","widemul(x, y) + Multiply \"x\" and \"y\", giving the result as a larger type. "), ("Base","@evalpoly","@evalpoly(z, c...) + Evaluate the polynomial \\sum_k c[k] z^{k-1} for the coefficients \"c[1]\", \"c[2]\", ...; that is, the coefficients are given in ascending order by power of \"z\". This macro expands to efficient @@ -4930,6 +5573,7 @@ popdisplay(d::Display) ("Base","bin","bin(n[, pad]) + Convert an integer to a binary string, optionally specifying a number of digits to pad to. @@ -4937,6 +5581,7 @@ popdisplay(d::Display) ("Base","hex","hex(n[, pad]) + Convert an integer to a hexadecimal string, optionally specifying a number of digits to pad to. @@ -4944,6 +5589,7 @@ popdisplay(d::Display) ("Base","dec","dec(n[, pad]) + Convert an integer to a decimal string, optionally specifying a number of digits to pad to. @@ -4951,6 +5597,7 @@ popdisplay(d::Display) ("Base","oct","oct(n[, pad]) + Convert an integer to an octal string, optionally specifying a number of digits to pad to. @@ -4958,6 +5605,7 @@ popdisplay(d::Display) ("Base","base","base(base, n[, pad]) + Convert an integer to a string in the given base, optionally specifying a number of digits to pad to. The base can be specified as either an integer, or as a \"Uint8\" array of character values @@ -4967,6 +5615,7 @@ popdisplay(d::Display) ("Base","digits","digits(n[, base][, pad]) + Returns an array of the digits of \"n\" in the given base, optionally padded with zeros to a specified size. More significant digits are at higher indexes, such that \"n == @@ -4976,12 +5625,14 @@ popdisplay(d::Display) ("Base","bits","bits(n) + A string giving the literal bit representation of a number. "), ("Base","parseint","parseint([type], str[, base]) + Parse a string as an integer in the given base (default 10), yielding a number of the specified type (default \"Int\"). @@ -4989,6 +5640,7 @@ popdisplay(d::Display) ("Base","parsefloat","parsefloat([type], str) + Parse a string as a decimal floating point number, yielding a number of the specified type. @@ -4996,6 +5648,7 @@ popdisplay(d::Display) ("Base","big","big(x) + Convert a number to a maximum precision representation (typically \"BigInt\" or \"BigFloat\"). See \"BigFloat\" for information about some pitfalls with floating-point numbers. @@ -5004,12 +5657,14 @@ popdisplay(d::Display) ("Base","bool","bool(x) + Convert a number or numeric array to boolean "), ("Base","int","int(x) + Convert a number or array to the default integer type on your platform. Alternatively, \"x\" can be a string, which is parsed as an integer. @@ -5018,6 +5673,7 @@ popdisplay(d::Display) ("Base","uint","uint(x) + Convert a number or array to the default unsigned integer type on your platform. Alternatively, \"x\" can be a string, which is parsed as an unsigned integer. @@ -5026,6 +5682,7 @@ popdisplay(d::Display) ("Base","integer","integer(x) + Convert a number or array to integer type. If \"x\" is already of integer type it is unchanged, otherwise it converts it to the default integer type on your platform. @@ -5034,95 +5691,112 @@ popdisplay(d::Display) ("Base","signed","signed(x) + Convert a number to a signed integer "), ("Base","unsigned","unsigned(x) -> Unsigned + Convert a number to an unsigned integer "), ("Base","int8","int8(x) + Convert a number or array to \"Int8\" data type "), ("Base","int16","int16(x) + Convert a number or array to \"Int16\" data type "), ("Base","int32","int32(x) + Convert a number or array to \"Int32\" data type "), ("Base","int64","int64(x) + Convert a number or array to \"Int64\" data type "), ("Base","int128","int128(x) + Convert a number or array to \"Int128\" data type "), ("Base","uint8","uint8(x) + Convert a number or array to \"Uint8\" data type "), ("Base","uint16","uint16(x) + Convert a number or array to \"Uint16\" data type "), ("Base","uint32","uint32(x) + Convert a number or array to \"Uint32\" data type "), ("Base","uint64","uint64(x) + Convert a number or array to \"Uint64\" data type "), ("Base","uint128","uint128(x) + Convert a number or array to \"Uint128\" data type "), ("Base","float16","float16(x) + Convert a number or array to \"Float16\" data type "), ("Base","float32","float32(x) + Convert a number or array to \"Float32\" data type "), ("Base","float64","float64(x) + Convert a number or array to \"Float64\" data type "), -("Base","float32_isvalid","float32_isvalid(x, out::Vector{Float32}) -> Bool +("Base","float32_isvalid","float32_isvalid(x, out::Vector{Float32}) -> +Bool + Convert a number or array to \"Float32\" data type, returning true if successful. The result of the conversion is stored in @@ -5130,7 +5804,9 @@ popdisplay(d::Display) "), -("Base","float64_isvalid","float64_isvalid(x, out::Vector{Float64}) -> Bool +("Base","float64_isvalid","float64_isvalid(x, out::Vector{Float64}) -> +Bool + Convert a number or array to \"Float64\" data type, returning true if successful. The result of the conversion is stored in @@ -5140,6 +5816,7 @@ popdisplay(d::Display) ("Base","float","float(x) + Convert a number, array, or string to a \"FloatingPoint\" data type. For numeric data, the smallest suitable \"FloatingPoint\" type is used. Converts strings to \"Float64\". @@ -5151,6 +5828,7 @@ popdisplay(d::Display) ("Base","significand","significand(x) + Extract the significand(s) (a.k.a. mantissa), in binary representation, of a floating-point number or array. @@ -5161,12 +5839,14 @@ popdisplay(d::Display) ("Base","exponent","exponent(x) -> Int + Get the exponent of a normalized floating-point number. "), ("Base","complex64","complex64(r[, i]) + Convert to \"r + i*im\" represented as a \"Complex64\" data type. \"i\" defaults to zero. @@ -5174,6 +5854,7 @@ popdisplay(d::Display) ("Base","complex128","complex128(r[, i]) + Convert to \"r + i*im\" represented as a \"Complex128\" data type. \"i\" defaults to zero. @@ -5181,24 +5862,28 @@ popdisplay(d::Display) ("Base","complex","complex(r[, i]) + Convert real numbers or arrays to complex. \"i\" defaults to zero. "), ("Base","char","char(x) + Convert a number or array to \"Char\" data type "), ("Base","bswap","bswap(n) + Byte-swap an integer "), ("Base","num2hex","num2hex(f) + Get a hexadecimal string of the binary representation of a floating point number @@ -5206,6 +5891,7 @@ popdisplay(d::Display) ("Base","hex2num","hex2num(str) + Convert a hexadecimal string to the floating point number it represents @@ -5213,6 +5899,7 @@ popdisplay(d::Display) ("Base","hex2bytes","hex2bytes(s::ASCIIString) + Convert an arbitrarily long hexadecimal string to its binary representation. Returns an Array{Uint8, 1}, i.e. an array of bytes. @@ -5220,6 +5907,7 @@ popdisplay(d::Display) ("Base","bytes2hex","bytes2hex(bin_arr::Array{Uint8, 1}) + Convert an array of bytes to its hexadecimal representation. All characters are in lower-case. Returns an ASCIIString. @@ -5227,6 +5915,7 @@ popdisplay(d::Display) ("Base","one","one(x) + Get the multiplicative identity element for the type of x (x can also specify the type itself). For matrices, returns an identity matrix of the appropriate size and type. @@ -5235,6 +5924,7 @@ popdisplay(d::Display) ("Base","zero","zero(x) + Get the additive identity element for the type of x (x can also specify the type itself). @@ -5242,90 +5932,105 @@ popdisplay(d::Display) ("Base","pi","pi + The constant pi "), ("Base","im","im + The imaginary unit "), ("Base","e","e + The constant e "), ("Base","catalan","catalan + Catalan's constant "), ("Base","Inf","Inf + Positive infinity of type Float64 "), ("Base","Inf32","Inf32 + Positive infinity of type Float32 "), ("Base","Inf16","Inf16 + Positive infinity of type Float16 "), ("Base","NaN","NaN + A not-a-number value of type Float64 "), ("Base","NaN32","NaN32 + A not-a-number value of type Float32 "), ("Base","NaN16","NaN16 + A not-a-number value of type Float16 "), ("Base","issubnormal","issubnormal(f) -> Bool + Test whether a floating point number is subnormal "), ("Base","isfinite","isfinite(f) -> Bool + Test whether a number is finite "), ("Base","isinf","isinf(f) -> Bool + Test whether a number is infinite "), ("Base","isnan","isnan(f) -> Bool + Test whether a floating point number is not a number (NaN) "), ("Base","inf","inf(f) + Returns positive infinity of the floating point type \"f\" or of the same floating point type as \"f\" @@ -5333,6 +6038,7 @@ popdisplay(d::Display) ("Base","nan","nan(f) + Returns NaN (not-a-number) of the floating point type \"f\" or of the same floating point type as \"f\" @@ -5340,18 +6046,21 @@ popdisplay(d::Display) ("Base","nextfloat","nextfloat(f) + Get the next floating point number in lexicographic order "), ("Base","prevfloat","prevfloat(f) -> FloatingPoint + Get the previous floating point number in lexicographic order "), ("Base","isinteger","isinteger(x) -> Bool + Test whether \"x\" or all its elements are numerically equal to some integer @@ -5359,6 +6068,7 @@ popdisplay(d::Display) ("Base","isreal","isreal(x) -> Bool + Test whether \"x\" or all its elements are numerically equal to some real number @@ -5366,6 +6076,7 @@ popdisplay(d::Display) ("Base","BigInt","BigInt(x) + Create an arbitrary precision integer. \"x\" may be an \"Int\" (or anything that can be converted to an \"Int\") or a \"String\". The usual mathematical operators are defined for this type, and results @@ -5375,6 +6086,7 @@ popdisplay(d::Display) ("Base","BigFloat","BigFloat(x) + Create an arbitrary precision floating point number. \"x\" may be an \"Integer\", a \"Float64\", a \"String\" or a \"BigInt\". The usual mathematical operators are defined for this type, and results @@ -5387,6 +6099,7 @@ popdisplay(d::Display) ("Base","get_rounding","get_rounding(T) + Get the current floating point rounding mode for type \"T\". Valid modes are \"RoundNearest\", \"RoundToZero\", \"RoundUp\", \"RoundDown\", and \"RoundFromZero\" (\"BigFloat\" only). @@ -5395,6 +6108,7 @@ popdisplay(d::Display) ("Base","set_rounding","set_rounding(T, mode) + Set the rounding mode of floating point type \"T\". Note that this may affect other types, for instance changing the rounding mode of \"Float64\" will change the rounding mode of \"Float32\". See @@ -5404,6 +6118,7 @@ popdisplay(d::Display) ("Base","with_rounding","with_rounding(f::Function, T, mode) + Change the rounding mode of floating point type \"T\" for the duration of \"f\". It is logically equivalent to: @@ -5418,6 +6133,7 @@ popdisplay(d::Display) ("Base","count_ones","count_ones(x::Integer) -> Integer + Number of ones in the binary representation of \"x\". **Example**: \"count_ones(7) -> 3\" @@ -5426,6 +6142,7 @@ popdisplay(d::Display) ("Base","count_zeros","count_zeros(x::Integer) -> Integer + Number of zeros in the binary representation of \"x\". **Example**: \"count_zeros(int32(2 ^ 16 - 1)) -> 16\" @@ -5434,6 +6151,7 @@ popdisplay(d::Display) ("Base","leading_zeros","leading_zeros(x::Integer) -> Integer + Number of zeros leading the binary representation of \"x\". **Example**: \"leading_zeros(int32(1)) -> 31\" @@ -5442,6 +6160,7 @@ popdisplay(d::Display) ("Base","leading_ones","leading_ones(x::Integer) -> Integer + Number of ones leading the binary representation of \"x\". **Example**: \"leading_ones(int32(2 ^ 32 - 2)) -> 31\" @@ -5450,6 +6169,7 @@ popdisplay(d::Display) ("Base","trailing_zeros","trailing_zeros(x::Integer) -> Integer + Number of zeros trailing the binary representation of \"x\". **Example**: \"trailing_zeros(2) -> 1\" @@ -5458,6 +6178,7 @@ popdisplay(d::Display) ("Base","trailing_ones","trailing_ones(x::Integer) -> Integer + Number of ones trailing the binary representation of \"x\". **Example**: \"trailing_ones(3) -> 2\" @@ -5466,6 +6187,7 @@ popdisplay(d::Display) ("Base","isprime","isprime(x::Integer) -> Bool + Returns \"true\" if \"x\" is prime, and \"false\" otherwise. **Example**: @@ -5477,12 +6199,14 @@ popdisplay(d::Display) ("Base","primes","primes(n) + Returns a collection of the prime numbers <= \"n\". "), ("Base","isodd","isodd(x::Integer) -> Bool + Returns \"true\" if \"x\" is odd (that is, not divisible by 2), and \"false\" otherwise. @@ -5498,6 +6222,7 @@ popdisplay(d::Display) ("Base","iseven","iseven(x::Integer) -> Bool + Returns \"true\" is \"x\" is even (that is, divisible by 2), and \"false\" otherwise. @@ -5513,6 +6238,7 @@ popdisplay(d::Display) ("Base","precision","precision(num::FloatingPoint) + Get the precision of a floating point number, as defined by the effective number of bits in the mantissa. @@ -5520,17 +6246,21 @@ popdisplay(d::Display) ("Base","get_bigfloat_precision","get_bigfloat_precision() + Get the precision (in bits) currently used for BigFloat arithmetic. "), ("Base","set_bigfloat_precision","set_bigfloat_precision(x::Int64) + Set the precision (in bits) to be used to BigFloat arithmetic. "), -("Base","with_bigfloat_precision","with_bigfloat_precision(f::Function, precision::Integer) +("Base","with_bigfloat_precision","with_bigfloat_precision(f::Functio +n, precision::Integer) + Change the BigFloat arithmetic precision (in bits) for the duration of \"f\". It is logically equivalent to: @@ -5544,6 +6274,7 @@ popdisplay(d::Display) ("Base","srand","srand([rng], seed) + Seed the RNG with a \"seed\", which may be an unsigned integer or a vector of unsigned integers. \"seed\" can even be a filename, in which case the seed is read from a file. If the argument \"rng\" is @@ -5553,6 +6284,7 @@ popdisplay(d::Display) ("Base","MersenneTwister","MersenneTwister([seed]) + Create a \"MersenneTwister\" RNG object. Different RNG objects can have their own seeds, which may be useful for generating different streams of random numbers. @@ -5561,12 +6293,14 @@ popdisplay(d::Display) ("Base","rand","rand() -> Float64 + Generate a \"Float64\" random number uniformly in [0,1) "), ("Base","rand!","rand!([rng], A) + Populate the array A with random number generated from the specified RNG. @@ -5574,6 +6308,7 @@ popdisplay(d::Display) ("Base","rand","rand(rng::AbstractRNG[, dims...]) + Generate a random \"Float64\" number or array of the size specified by dims, using the specified RNG object. Currently, \"MersenneTwister\" is the only available Random Number Generator @@ -5583,11 +6318,14 @@ popdisplay(d::Display) ("Base","rand","rand(dims or [dims...]) + Generate a random \"Float64\" array of the size specified by dims "), -("Base","rand","rand(Int32|Uint32|Int64|Uint64|Int128|Uint128[, dims...]) +("Base","rand","rand(Int32|Uint32|Int64|Uint64|Int128|Uint128[, +dims...]) + Generate a random integer of the given type. Optionally, generate an array of random integers of the given type by specifying dims. @@ -5596,6 +6334,7 @@ popdisplay(d::Display) ("Base","rand","rand(r[, dims...]) + Generate a random integer from the inclusive interval specified by \"Range1 r\" (for example, \"1:n\"). Optionally, generate a random integer array. @@ -5604,6 +6343,7 @@ popdisplay(d::Display) ("Base","randbool","randbool([dims...]) + Generate a random boolean value. Optionally, generate an array of random boolean values. @@ -5611,6 +6351,7 @@ popdisplay(d::Display) ("Base","randbool!","randbool!(A) + Fill an array with random boolean values. A may be an \"Array\" or a \"BitArray\". @@ -5618,6 +6359,7 @@ popdisplay(d::Display) ("Base","randn","randn([rng], dims or [dims...]) + Generate a normally-distributed random number with mean 0 and standard deviation 1. Optionally generate an array of normally- distributed random numbers. @@ -5626,6 +6368,7 @@ popdisplay(d::Display) ("Base","randn!","randn!([rng], A::Array{Float64, N}) + Fill the array A with normally-distributed (mean 0, standard deviation 1) random numbers. Also see the rand function. @@ -5633,30 +6376,35 @@ popdisplay(d::Display) ("Base","ndims","ndims(A) -> Integer + Returns the number of dimensions of A "), ("Base","size","size(A) + Returns a tuple containing the dimensions of A "), ("Base","iseltype","iseltype(A, T) + Tests whether A or its elements are of type T "), ("Base","length","length(A) -> Integer + Returns the number of elements in A "), ("Base","countnz","countnz(A) + Counts the number of nonzero values in array A (dense or sparse). Note that this is not a constant-time operation. For sparse matrices, one should usually use \"nnz\", which returns the number @@ -5666,12 +6414,14 @@ popdisplay(d::Display) ("Base","conj!","conj!(A) + Convert an array to its complex conjugate in-place "), ("Base","stride","stride(A, k) + Returns the distance in memory (in number of elements) between adjacent elements in dimension k @@ -5679,12 +6429,14 @@ popdisplay(d::Display) ("Base","strides","strides(A) + Returns a tuple of the memory strides in each dimension "), ("Base","ind2sub","ind2sub(dims, index) -> subscripts + Returns a tuple of subscripts into an array with dimensions \"dims\", corresponding to the linear index \"index\" @@ -5695,6 +6447,7 @@ popdisplay(d::Display) ("Base","sub2ind","sub2ind(dims, i, j, k...) -> index + The inverse of \"ind2sub\", returns the linear index corresponding to the provided subscripts @@ -5702,6 +6455,7 @@ popdisplay(d::Display) ("Base","Array","Array(type, dims) + Construct an uninitialized dense array. \"dims\" may be a tuple or a series of integer arguments. @@ -5709,6 +6463,7 @@ popdisplay(d::Display) ("Base","getindex","getindex(type[, elements...]) + Construct a 1-d array of the specified type. This is usually called with the syntax \"Type[]\". Element values can be specified using \"Type[a,b,c,...]\". @@ -5717,6 +6472,7 @@ popdisplay(d::Display) ("Base","cell","cell(dims) + Construct an uninitialized cell array (heterogeneous array). \"dims\" can be either a tuple or a series of integer arguments. @@ -5724,42 +6480,49 @@ popdisplay(d::Display) ("Base","zeros","zeros(type, dims) + Create an array of all zeros of specified type "), ("Base","ones","ones(type, dims) + Create an array of all ones of specified type "), ("Base","trues","trues(dims) + Create a \"BitArray\" with all values set to true "), ("Base","falses","falses(dims) + Create a \"BitArray\" with all values set to false "), ("Base","fill","fill(v, dims) + Create an array filled with \"v\" "), ("Base","fill!","fill!(A, x) + Fill array \"A\" with value \"x\" "), ("Base","reshape","reshape(A, dims) + Create an array with the same data as the given array, but with different dimensions. An implementation for a particular type of array may choose whether the data is copied or shared. @@ -5768,6 +6531,7 @@ popdisplay(d::Display) ("Base","similar","similar(array, element_type, dims) + Create an uninitialized array of the same type as the given array, but with the specified element type and dimensions. The second and third arguments are both optional. The \"dims\" argument may be a @@ -5777,6 +6541,7 @@ popdisplay(d::Display) ("Base","reinterpret","reinterpret(type, A) + Change the type-interpretation of a block of memory. For example, \"reinterpret(Float32, uint32(7))\" interprets the 4 bytes corresponding to \"uint32(7)\" as a \"Float32\". For arrays, this @@ -5787,18 +6552,21 @@ popdisplay(d::Display) ("Base","eye","eye(n) + n-by-n identity matrix "), ("Base","eye","eye(m, n) + m-by-n identity matrix "), ("Base","eye","eye(A) + Constructs an identity matrix of the same dimensions and type as \"A\". @@ -5806,6 +6574,7 @@ popdisplay(d::Display) ("Base","linspace","linspace(start, stop, n) + Construct a vector of \"n\" linearly-spaced elements from \"start\" to \"stop\". See also: \"linrange()\" that constructs a range object. @@ -5814,6 +6583,7 @@ popdisplay(d::Display) ("Base","logspace","logspace(start, stop, n) + Construct a vector of \"n\" logarithmically-spaced numbers from \"10^start\" to \"10^stop\". @@ -5821,6 +6591,7 @@ popdisplay(d::Display) ("Base","broadcast","broadcast(f, As...) + Broadcasts the arrays \"As\" to a common size by expanding singleton dimensions, and returns an array of the results \"f(as...)\" for each position. @@ -5829,6 +6600,7 @@ popdisplay(d::Display) ("Base","broadcast!","broadcast!(f, dest, As...) + Like \"broadcast\", but store the result of \"broadcast(f, As...)\" in the \"dest\" array. Note that \"dest\" is only used to store the result, and does not supply arguments to \"f\" unless it is also @@ -5839,6 +6611,7 @@ popdisplay(d::Display) ("Base","bitbroadcast","bitbroadcast(f, As...) + Like \"broadcast\", but allocates a \"BitArray\" to store the result, rather then an \"Array\". @@ -5846,6 +6619,7 @@ popdisplay(d::Display) ("Base","broadcast_function","broadcast_function(f) + Returns a function \"broadcast_f\" such that \"broadcast_function(f)(As...) === broadcast(f, As...)\". Most useful in the form \"const broadcast_f = broadcast_function(f)\". @@ -5854,12 +6628,14 @@ popdisplay(d::Display) ("Base","broadcast!_function","broadcast!_function(f) + Like \"broadcast_function\", but for \"broadcast!\". "), ("Base","getindex","getindex(A, inds...) + Returns a subset of array \"A\" as specified by \"inds\", where each \"ind\" may be an \"Int\", a \"Range\", or a \"Vector\". @@ -5867,6 +6643,7 @@ popdisplay(d::Display) ("Base","sub","sub(A, inds...) + Returns a SubArray, which stores the input \"A\" and \"inds\" rather than computing the result immediately. Calling \"getindex\" on a SubArray computes the indices on the fly. @@ -5875,6 +6652,7 @@ popdisplay(d::Display) ("Base","parent","parent(A) + Returns the \"parent array\" of an array view type (e.g., SubArray), or the array itself if it is not a view @@ -5882,6 +6660,7 @@ popdisplay(d::Display) ("Base","parentindexes","parentindexes(A) + From an array view \"A\", returns the corresponding indexes in the parent @@ -5889,6 +6668,7 @@ popdisplay(d::Display) ("Base","slicedim","slicedim(A, d, i) + Return all the data of \"A\" where the index for dimension \"d\" equals \"i\". Equivalent to \"A[:,:,...,i,:,:,...]\" where \"i\" is in position \"d\". @@ -5897,6 +6677,7 @@ popdisplay(d::Display) ("Base","slice","slice(A, inds...) + Create a view of the given indexes of array \"A\", dropping dimensions indexed with scalars. @@ -5904,6 +6685,7 @@ popdisplay(d::Display) ("Base","setindex!","setindex!(A, X, inds...) + Store values from array \"X\" within some subset of \"A\" as specified by \"inds\". @@ -5911,6 +6693,7 @@ popdisplay(d::Display) ("Base","broadcast_getindex","broadcast_getindex(A, inds...) + Broadcasts the \"inds\" arrays to a common size like \"broadcast\", and returns an array of the results \"A[ks...]\", where \"ks\" goes over the positions in the broadcast. @@ -5919,6 +6702,7 @@ popdisplay(d::Display) ("Base","broadcast_setindex!","broadcast_setindex!(A, X, inds...) + Broadcasts the \"X\" and \"inds\" arrays to a common size and stores the value from each position in \"X\" at the indices given by the same positions in \"inds\". @@ -5927,24 +6711,28 @@ popdisplay(d::Display) ("Base","cat","cat(dim, A...) + Concatenate the input arrays along the specified dimension "), ("Base","vcat","vcat(A...) + Concatenate along dimension 1 "), ("Base","hcat","hcat(A...) + Concatenate along dimension 2 "), ("Base","hvcat","hvcat(rows::(Int...), values...) + Horizontal and vertical concatenation in one call. This function is called for block matrix syntax. The first argument specifies the number of arguments to concatenate in each block row. For example, @@ -5957,24 +6745,28 @@ popdisplay(d::Display) ("Base","flipdim","flipdim(A, d) + Reverse \"A\" in dimension \"d\". "), ("Base","flipud","flipud(A) + Equivalent to \"flipdim(A,1)\". "), ("Base","fliplr","fliplr(A) + Equivalent to \"flipdim(A,2)\". "), ("Base","circshift","circshift(A, shifts) + Circularly shift the data in an array. The second argument is a vector giving the amount to shift in each dimension. @@ -5982,6 +6774,7 @@ popdisplay(d::Display) ("Base","find","find(A) + Return a vector of the linear indexes of the non-zeros in \"A\" (determined by \"A[i]!=0\"). A common use of this is to convert a boolean array to an array of indexes of the \"true\" elements. @@ -5990,6 +6783,7 @@ popdisplay(d::Display) ("Base","find","find(f, A) + Return a vector of the linear indexes of \"A\" where \"f\" returns true. @@ -5997,6 +6791,7 @@ popdisplay(d::Display) ("Base","findn","findn(A) + Return a vector of indexes for each dimension giving the locations of the non-zeros in \"A\" (determined by \"A[i]!=0\"). @@ -6004,6 +6799,7 @@ popdisplay(d::Display) ("Base","findnz","findnz(A) + Return a tuple \"(I, J, V)\" where \"I\" and \"J\" are the row and column indexes of the non-zero values in matrix \"A\", and \"V\" is a vector of the non-zero values. @@ -6012,6 +6808,7 @@ popdisplay(d::Display) ("Base","findfirst","findfirst(A) + Return the index of the first non-zero value in \"A\" (determined by \"A[i]!=0\"). @@ -6019,12 +6816,14 @@ popdisplay(d::Display) ("Base","findfirst","findfirst(A, v) + Return the index of the first element equal to \"v\" in \"A\". "), ("Base","findfirst","findfirst(predicate, A) + Return the index of the first element of \"A\" for which \"predicate\" returns true. @@ -6032,6 +6831,7 @@ popdisplay(d::Display) ("Base","findnext","findnext(A, i) + Find the next index >= \"i\" of a non-zero element of \"A\", or \"0\" if not found. @@ -6039,6 +6839,7 @@ popdisplay(d::Display) ("Base","findnext","findnext(predicate, A, i) + Find the next index >= \"i\" of an element of \"A\" for which \"predicate\" returns true, or \"0\" if not found. @@ -6046,6 +6847,7 @@ popdisplay(d::Display) ("Base","findnext","findnext(A, v, i) + Find the next index >= \"i\" of an element of \"A\" equal to \"v\" (using \"==\"), or \"0\" if not found. @@ -6053,6 +6855,7 @@ popdisplay(d::Display) ("Base","permutedims","permutedims(A, perm) + Permute the dimensions of array \"A\". \"perm\" is a vector specifying a permutation of length \"ndims(A)\". This is a generalization of transpose for multi-dimensional arrays. Transpose @@ -6062,6 +6865,7 @@ popdisplay(d::Display) ("Base","ipermutedims","ipermutedims(A, perm) + Like \"permutedims()\", except the inverse of the given permutation is applied. @@ -6069,18 +6873,21 @@ popdisplay(d::Display) ("Base","squeeze","squeeze(A, dims) + Remove the dimensions specified by \"dims\" from array \"A\" "), ("Base","vec","vec(Array) -> Vector + Vectorize an array using column-major convention. "), ("Base","promote_shape","promote_shape(s1, s2) + Check two array shapes for compatibility, allowing trailing singleton dimensions, and return whichever shape has more dimensions. @@ -6089,6 +6896,7 @@ popdisplay(d::Display) ("Base","checkbounds","checkbounds(array, indexes...) + Throw an error if the specified indexes are not in bounds for the given array. @@ -6096,6 +6904,7 @@ popdisplay(d::Display) ("Base","randsubseq","randsubseq(A, p) -> Vector + Return a vector consisting of a random subsequence of the given array \"A\", where each element of \"A\" is included (in order) with independent probability \"p\". (Complexity is linear in @@ -6107,6 +6916,7 @@ popdisplay(d::Display) ("Base","randsubseq!","randsubseq!(S, A, p) + Like \"randsubseq\", but the results are stored in \"S\" (which is resized as needed). @@ -6114,12 +6924,14 @@ popdisplay(d::Display) ("Base","cumprod","cumprod(A[, dim]) + Cumulative product along a dimension. "), ("Base","cumprod!","cumprod!(B, A[, dim]) + Cumulative product of \"A\" along a dimension, storing the result in \"B\". @@ -6127,12 +6939,14 @@ popdisplay(d::Display) ("Base","cumsum","cumsum(A[, dim]) + Cumulative sum along a dimension. "), ("Base","cumsum!","cumsum!(B, A[, dim]) + Cumulative sum of \"A\" along a dimension, storing the result in \"B\". @@ -6140,6 +6954,7 @@ popdisplay(d::Display) ("Base","cumsum_kbn","cumsum_kbn(A[, dim]) + Cumulative sum along a dimension, using the Kahan-Babuska-Neumaier compensated summation algorithm for additional accuracy. @@ -6147,24 +6962,28 @@ popdisplay(d::Display) ("Base","cummin","cummin(A[, dim]) + Cumulative minimum along a dimension. "), ("Base","cummax","cummax(A[, dim]) + Cumulative maximum along a dimension. "), ("Base","diff","diff(A[, dim]) + Finite difference operator of matrix or vector. "), ("Base","gradient","gradient(F[, h]) + Compute differences along vector \"F\", using \"h\" as the spacing between points. The default spacing is one. @@ -6172,24 +6991,28 @@ popdisplay(d::Display) ("Base","rot180","rot180(A) + Rotate matrix \"A\" 180 degrees. "), ("Base","rotl90","rotl90(A) + Rotate matrix \"A\" left 90 degrees. "), ("Base","rotr90","rotr90(A) + Rotate matrix \"A\" right 90 degrees. "), ("Base","reducedim","reducedim(f, A, dims, initial) + Reduce 2-argument function \"f\" along dimensions of \"A\". \"dims\" is a vector specifying the dimensions to reduce, and \"initial\" is the initial value to use in the reductions. @@ -6202,6 +7025,7 @@ popdisplay(d::Display) ("Base","mapslices","mapslices(f, A, dims) + Transform the given dimensions of array \"A\" using function \"f\". \"f\" is called on each slice of \"A\" of the form \"A[...,:,...,:,...]\". \"dims\" is an integer vector specifying @@ -6214,6 +7038,7 @@ popdisplay(d::Display) ("Base","sum_kbn","sum_kbn(A) + Returns the sum of all array elements, using the Kahan-Babuska- Neumaier compensated summation algorithm for additional accuracy. @@ -6221,6 +7046,7 @@ popdisplay(d::Display) ("Base","cartesianmap","cartesianmap(f, dims) + Given a \"dims\" tuple of integers \"(m, n, ...)\", call \"f\" on all combinations of integers in the ranges \"1:m\", \"1:n\", etc. @@ -6236,42 +7062,49 @@ popdisplay(d::Display) ("Base","bitpack","bitpack(A::AbstractArray{T, N}) -> BitArray + Converts a numeric array to a packed boolean array "), ("Base","bitunpack","bitunpack(B::BitArray{N}) -> Array{Bool,N} + Converts a packed boolean array to an array of booleans "), ("Base","flipbits!","flipbits!(B::BitArray{N}) -> BitArray{N} + Performs a bitwise not operation on B. See *~ operator*. "), ("Base","rol","rol(B::BitArray{1}, i::Integer) -> BitArray{1} + Left rotation operator. "), ("Base","ror","ror(B::BitArray{1}, i::Integer) -> BitArray{1} + Right rotation operator. "), ("Base","nthperm","nthperm(v, k) + Compute the kth lexicographic permutation of a vector. "), ("Base","nthperm","nthperm(p) + Return the \"k\" that generated permutation \"p\". Note that \"nthperm(nthperm([1:n], k)) == k\" for \"1 <= k <= factorial(n)\". @@ -6279,30 +7112,35 @@ popdisplay(d::Display) ("Base","nthperm!","nthperm!(v, k) + In-place version of \"nthperm()\". "), ("Base","randperm","randperm(n) + Construct a random permutation of the given length. "), ("Base","invperm","invperm(v) + Return the inverse permutation of v. "), ("Base","isperm","isperm(v) -> Bool + Returns true if v is a valid permutation. "), ("Base","permute!","permute!(v, p) + Permute vector \"v\" in-place, according to permutation \"p\". No checking is done to verify that \"p\" is a permutation. @@ -6313,42 +7151,49 @@ popdisplay(d::Display) ("Base","ipermute!","ipermute!(v, p) + Like permute!, but the inverse of the given permutation is applied. "), ("Base","randcycle","randcycle(n) + Construct a random cyclic permutation of the given length. "), ("Base","shuffle","shuffle(v) + Return a randomly permuted copy of \"v\". "), ("Base","shuffle!","shuffle!(v) + In-place version of \"shuffle()\". "), ("Base","reverse","reverse(v[, start=1[, stop=length(v)]]) + Return a copy of \"v\" reversed from start to stop. "), ("Base","reverse!","reverse!(v[, start=1[, stop=length(v)]]) -> v + In-place version of \"reverse()\". "), ("Base","combinations","combinations(arr, n) + Generate all combinations of \"n\" elements from an indexable object. Because the number of combinations can be very large, this function returns an iterator object. Use @@ -6358,6 +7203,7 @@ popdisplay(d::Display) ("Base","permutations","permutations(arr) + Generate all permutations of an indexable object. Because the number of permutations can be very large, this function returns an iterator object. Use \"collect(permutations(a,n))\" to get an array @@ -6367,6 +7213,7 @@ popdisplay(d::Display) ("Base","partitions","partitions(n) + Generate all integer arrays that sum to \"n\". Because the number of partitions can be very large, this function returns an iterator object. Use \"collect(partitions(n))\" to get an array of all @@ -6377,6 +7224,7 @@ popdisplay(d::Display) ("Base","partitions","partitions(n, m) + Generate all arrays of \"m\" integers that sum to \"n\". Because the number of partitions can be very large, this function returns an iterator object. Use \"collect(partitions(n,m))\" to get an @@ -6387,6 +7235,7 @@ popdisplay(d::Display) ("Base","partitions","partitions(array) + Generate all set partitions of the elements of an array, represented as arrays of arrays. Because the number of partitions can be very large, this function returns an iterator object. Use @@ -6398,6 +7247,7 @@ popdisplay(d::Display) ("Base","partitions","partitions(array, m) + Generate all set partitions of the elements of an array into exactly m subsets, represented as arrays of arrays. Because the number of partitions can be very large, this function returns an @@ -6410,6 +7260,7 @@ popdisplay(d::Display) ("Base","mean","mean(v[, region]) + Compute the mean of whole array \"v\", or optionally along the dimensions in \"region\". Note: Julia does not ignore \"NaN\" values in the computation. For applications requiring the handling @@ -6419,6 +7270,7 @@ popdisplay(d::Display) ("Base","mean!","mean!(r, v) + Compute the mean of \"v\" over the singleton dimensions of \"r\", and write results to \"r\". @@ -6426,6 +7278,7 @@ popdisplay(d::Display) ("Base","std","std(v[, region]) + Compute the sample standard deviation of a vector or array \"v\", optionally along dimensions in \"region\". The algorithm returns an estimator of the generative distribution's standard deviation under @@ -6440,6 +7293,7 @@ popdisplay(d::Display) ("Base","stdm","stdm(v, m) + Compute the sample standard deviation of a vector \"v\" with known mean \"m\". Note: Julia does not ignore \"NaN\" values in the computation. @@ -6448,6 +7302,7 @@ popdisplay(d::Display) ("Base","var","var(v[, region]) + Compute the sample variance of a vector or array \"v\", optionally along dimensions in \"region\". The algorithm will return an estimator of the generative distribution's variance under the @@ -6462,6 +7317,7 @@ popdisplay(d::Display) ("Base","varm","varm(v, m) + Compute the sample variance of a vector \"v\" with known mean \"m\". Note: Julia does not ignore \"NaN\" values in the computation. @@ -6470,6 +7326,7 @@ popdisplay(d::Display) ("Base","median","median(v; checknan::Bool=true) + Compute the median of a vector \"v\". If keyword argument \"checknan\" is true (the default), an error is raised for data containing NaN values. Note: Julia does not ignore \"NaN\" values @@ -6480,12 +7337,14 @@ popdisplay(d::Display) ("Base","median!","median!(v; checknan::Bool=true) + Like \"median\", but may overwrite the input vector. "), ("Base","hist","hist(v[, n]) -> e, counts + Compute the histogram of \"v\", optionally using approximately \"n\" bins. The return values are a range \"e\", which correspond to the edges of the bins, and \"counts\" containing the number of @@ -6496,6 +7355,7 @@ popdisplay(d::Display) ("Base","hist","hist(v, e) -> e, counts + Compute the histogram of \"v\" using a vector/range \"e\" as the edges for the bins. The result will be a vector of length \"length(e) - 1\", such that the element at location \"i\" @@ -6506,6 +7366,7 @@ popdisplay(d::Display) ("Base","hist!","hist!(counts, v, e) -> e, counts + Compute the histogram of \"v\", using a vector/range \"e\" as the edges for the bins. This function writes the resultant counts to a pre-allocated array \"counts\". @@ -6514,6 +7375,7 @@ popdisplay(d::Display) ("Base","hist2d","hist2d(M, e1, e2) -> (edge1, edge2, counts) + Compute a \"2d histogram\" of a set of N points specified by N-by-2 matrix \"M\". Arguments \"e1\" and \"e2\" are bins for each dimension, specified either as integer bin counts or vectors of bin @@ -6527,6 +7389,7 @@ popdisplay(d::Display) ("Base","hist2d!","hist2d!(counts, M, e1, e2) -> (e1, e2, counts) + Compute a \"2d histogram\" with respect to the bins delimited by the edges given in \"e1\" and \"e2\". This function writes the results to a pre-allocated array \"counts\". @@ -6535,6 +7398,7 @@ popdisplay(d::Display) ("Base","histrange","histrange(v, n) + Compute *nice* bin ranges for the edges of a histogram of \"v\", using approximately \"n\" bins. The resulting step sizes will be 1, 2 or 5 multiplied by a power of 10. Note: Julia does not ignore @@ -6544,6 +7408,7 @@ popdisplay(d::Display) ("Base","midpoints","midpoints(e) + Compute the midpoints of the bins with edges \"e\". The result is a vector/range of length \"length(e) - 1\". Note: Julia does not ignore \"NaN\" values in the computation. @@ -6552,6 +7417,7 @@ popdisplay(d::Display) ("Base","quantile","quantile(v, p) + Compute the quantiles of a vector \"v\" at a specified set of probability values \"p\". Note: Julia does not ignore \"NaN\" values in the computation. @@ -6560,6 +7426,7 @@ popdisplay(d::Display) ("Base","quantile","quantile(v, p) + Compute the quantile of a vector \"v\" at the probability \"p\". Note: Julia does not ignore \"NaN\" values in the computation. @@ -6567,12 +7434,14 @@ popdisplay(d::Display) ("Base","quantile!","quantile!(v, p) + Like \"quantile\", but overwrites the input vector. "), ("Base","cov","cov(v1[, v2][, vardim=1, corrected=true, mean=nothing]) + Compute the Pearson covariance between the vector(s) in \"v1\" and \"v2\". Here, \"v1\" and \"v2\" can be either vectors or matrices. @@ -6605,6 +7474,7 @@ popdisplay(d::Display) ("Base","cor","cor(v1[, v2][, vardim=1, mean=nothing]) + Compute the Pearson correlation between the vector(s) in \"v1\" and \"v2\". @@ -6616,6 +7486,7 @@ popdisplay(d::Display) ("Base","fft","fft(A[, dims]) + Performs a multidimensional FFT of the array \"A\". The optional \"dims\" argument specifies an iterable subset of dimensions (e.g. an integer, range, tuple, or array) to transform along. Most @@ -6638,6 +7509,7 @@ popdisplay(d::Display) ("Base","fft!","fft!(A[, dims]) + Same as \"fft()\", but operates in-place on \"A\", which must be an array of complex floating-point numbers. @@ -6645,6 +7517,7 @@ popdisplay(d::Display) ("Base","ifft","ifft(A[, dims]) + Multidimensional inverse FFT. A one-dimensional inverse FFT computes @@ -6662,12 +7535,14 @@ popdisplay(d::Display) ("Base","ifft!","ifft!(A[, dims]) + Same as \"ifft()\", but operates in-place on \"A\". "), ("Base","bfft","bfft(A[, dims]) + Similar to \"ifft()\", but computes an unnormalized inverse (backward) transform, which must be divided by the product of the sizes of the transformed dimensions in order to obtain the inverse. @@ -6682,12 +7557,14 @@ popdisplay(d::Display) ("Base","bfft!","bfft!(A[, dims]) + Same as \"bfft()\", but operates in-place on \"A\". "), ("Base","plan_fft","plan_fft(A[, dims[, flags[, timelimit]]]) + Pre-plan an optimized FFT along given dimensions (\"dims\") of arrays matching the shape and type of \"A\". (The first two arguments have the same meaning as for \"fft()\".) Returns a @@ -6713,6 +7590,7 @@ popdisplay(d::Display) ("Base","plan_ifft","plan_ifft(A[, dims[, flags[, timelimit]]]) + Same as \"plan_fft()\", but produces a plan that performs inverse transforms \"ifft()\". @@ -6720,6 +7598,7 @@ popdisplay(d::Display) ("Base","plan_bfft","plan_bfft(A[, dims[, flags[, timelimit]]]) + Same as \"plan_fft()\", but produces a plan that performs an unnormalized backwards transform \"bfft()\". @@ -6727,24 +7606,28 @@ popdisplay(d::Display) ("Base","plan_fft!","plan_fft!(A[, dims[, flags[, timelimit]]]) + Same as \"plan_fft()\", but operates in-place on \"A\". "), ("Base","plan_ifft!","plan_ifft!(A[, dims[, flags[, timelimit]]]) + Same as \"plan_ifft()\", but operates in-place on \"A\". "), ("Base","plan_bfft!","plan_bfft!(A[, dims[, flags[, timelimit]]]) + Same as \"plan_bfft()\", but operates in-place on \"A\". "), ("Base","rfft","rfft(A[, dims]) + Multidimensional FFT of a real array A, exploiting the fact that the transform has conjugate symmetry in order to save roughly half the computational time and storage costs compared with \"fft()\". @@ -6761,6 +7644,7 @@ popdisplay(d::Display) ("Base","irfft","irfft(A, d[, dims]) + Inverse of \"rfft()\": for a complex array \"A\", gives the corresponding real array whose FFT yields \"A\" in the first half. As for \"rfft()\", \"dims\" is an optional subset of dimensions to @@ -6776,6 +7660,7 @@ popdisplay(d::Display) ("Base","brfft","brfft(A, d[, dims]) + Similar to \"irfft()\" but computes an unnormalized inverse transform (similar to \"bfft()\"), which must be divided by the product of the sizes of the transformed dimensions (of the real @@ -6785,6 +7670,7 @@ popdisplay(d::Display) ("Base","plan_rfft","plan_rfft(A[, dims[, flags[, timelimit]]]) + Pre-plan an optimized real-input FFT, similar to \"plan_fft()\" except for \"rfft()\" instead of \"fft()\". The first two arguments, and the size of the transformed result, are the same as @@ -6794,6 +7680,7 @@ popdisplay(d::Display) ("Base","plan_brfft","plan_brfft(A, d[, dims[, flags[, timelimit]]]) + Pre-plan an optimized real-input unnormalized transform, similar to \"plan_rfft()\" except for \"brfft()\" instead of \"rfft()\". The first two arguments and the size of the transformed result, are the @@ -6803,6 +7690,7 @@ popdisplay(d::Display) ("Base","plan_irfft","plan_irfft(A, d[, dims[, flags[, timelimit]]]) + Pre-plan an optimized inverse real-input FFT, similar to \"plan_rfft()\" except for \"irfft()\" and \"brfft()\", respectively. The first three arguments have the same meaning as @@ -6812,6 +7700,7 @@ popdisplay(d::Display) ("Base","dct","dct(A[, dims]) + Performs a multidimensional type-II discrete cosine transform (DCT) of the array \"A\", using the unitary normalization of the DCT. The optional \"dims\" argument specifies an iterable subset of @@ -6824,6 +7713,7 @@ popdisplay(d::Display) ("Base","dct!","dct!(A[, dims]) + Same as \"dct!()\", except that it operates in-place on \"A\", which must be an array of real or complex floating-point values. @@ -6831,6 +7721,7 @@ popdisplay(d::Display) ("Base","idct","idct(A[, dims]) + Computes the multidimensional inverse discrete cosine transform (DCT) of the array \"A\" (technically, a type-III DCT with the unitary normalization). The optional \"dims\" argument specifies an @@ -6844,12 +7735,14 @@ popdisplay(d::Display) ("Base","idct!","idct!(A[, dims]) + Same as \"idct!()\", but operates in-place on \"A\". "), ("Base","plan_dct","plan_dct(A[, dims[, flags[, timelimit]]]) + Pre-plan an optimized discrete cosine transform (DCT), similar to \"plan_fft()\" except producing a function that computes \"dct()\". The first two arguments have the same meaning as for \"dct()\". @@ -6858,12 +7751,14 @@ popdisplay(d::Display) ("Base","plan_dct!","plan_dct!(A[, dims[, flags[, timelimit]]]) + Same as \"plan_dct()\", but operates in-place on \"A\". "), ("Base","plan_idct","plan_idct(A[, dims[, flags[, timelimit]]]) + Pre-plan an optimized inverse discrete cosine transform (DCT), similar to \"plan_fft()\" except producing a function that computes \"idct()\". The first two arguments have the same meaning as for @@ -6873,18 +7768,21 @@ popdisplay(d::Display) ("Base","plan_idct!","plan_idct!(A[, dims[, flags[, timelimit]]]) + Same as \"plan_idct()\", but operates in-place on \"A\". "), ("Base","fftshift","fftshift(x) + Swap the first and second halves of each dimension of \"x\". "), ("Base","fftshift","fftshift(x, dim) + Swap the first and second halves of the given dimension of array \"x\". @@ -6892,12 +7790,14 @@ popdisplay(d::Display) ("Base","ifftshift","ifftshift(x[, dim]) + Undoes the effect of \"fftshift\". "), ("Base","filt","filt(b, a, x[, si]) + Apply filter described by vectors \"a\" and \"b\" to vector \"x\", with an optional initial filter state vector \"si\" (defaults to zeros). @@ -6906,6 +7806,7 @@ popdisplay(d::Display) ("Base","filt!","filt!(out, b, a, x[, si]) + Same as \"filt()\" but writes the result into the \"out\" argument, which may alias the input \"x\" to modify it in-place. @@ -6913,6 +7814,7 @@ popdisplay(d::Display) ("Base","deconv","deconv(b, a) + Construct vector \"c\" such that \"b = conv(a,c) + r\". Equivalent to polynomial division. @@ -6920,12 +7822,14 @@ popdisplay(d::Display) ("Base","conv","conv(u, v) + Convolution of two vectors. Uses FFT algorithm. "), ("Base","conv2","conv2(u, v, A) + 2-D convolution of the matrix \"A\" with the 2-D separable kernel generated by the vectors \"u\" and \"v\". Uses 2-D FFT algorithm @@ -6933,6 +7837,7 @@ popdisplay(d::Display) ("Base","conv2","conv2(B, A) + 2-D convolution of the matrix \"B\" with the matrix \"A\". Uses 2-D FFT algorithm @@ -6940,12 +7845,14 @@ popdisplay(d::Display) ("Base","xcorr","xcorr(u, v) + Compute the cross-correlation of two vectors. "), ("Base.FFTW","r2r","r2r(A, kind[, dims]) + Performs a multidimensional real-input/real-output (r2r) transform of type \"kind\" of the array \"A\", as defined in the FFTW manual. \"kind\" specifies either a discrete cosine transform of various @@ -6971,12 +7878,15 @@ popdisplay(d::Display) ("Base.FFTW","r2r!","r2r!(A, kind[, dims]) + Same as \"r2r()\", but operates in-place on \"A\", which must be an array of real or complex floating-point numbers. "), -("Base.FFTW","plan_r2r","plan_r2r(A, kind[, dims[, flags[, timelimit]]]) +("Base.FFTW","plan_r2r","plan_r2r(A, kind[, dims[, flags[, +timelimit]]]) + Pre-plan an optimized r2r transform, similar to \"Base.plan_fft()\" except that the transforms (and the first three arguments) @@ -6984,13 +7894,17 @@ popdisplay(d::Display) "), -("Base.FFTW","plan_r2r!","plan_r2r!(A, kind[, dims[, flags[, timelimit]]]) +("Base.FFTW","plan_r2r!","plan_r2r!(A, kind[, dims[, flags[, +timelimit]]]) + Similar to \"Base.plan_fft()\", but corresponds to \"r2r!()\". "), -("Base","quadgk","quadgk(f, a, b, c...; reltol=sqrt(eps), abstol=0, maxevals=10^7, order=7, norm=vecnorm) +("Base","quadgk","quadgk(f, a, b, c...; reltol=sqrt(eps), abstol=0, +maxevals=10^7, order=7, norm=vecnorm) + Numerically integrate the function \"f(x)\" from \"a\" to \"b\", and optionally over additional intervals \"b\" to \"c\" and so on. @@ -7047,7 +7961,9 @@ popdisplay(d::Display) "), -("Base","addprocs","addprocs(n; cman::ClusterManager=LocalManager()) -> List of process identifiers +("Base","addprocs","addprocs(n; cman::ClusterManager=LocalManager()) +-> List of process identifiers + \"addprocs(4)\" will add 4 processes on the local machine. This can be used to take advantage of multiple cores. @@ -7062,7 +7978,9 @@ popdisplay(d::Display) "), -("Base","addprocs","addprocs(machines; tunnel=false, dir=JULIA_HOME, sshflags::Cmd=``) -> List of process identifiers +("Base","addprocs","addprocs(machines; tunnel=false, dir=JULIA_HOME, +sshflags::Cmd=``) -> List of process identifiers + Add processes on remote machines via SSH. Requires julia to be installed in the same location on each node, or to be available via @@ -7089,12 +8007,14 @@ popdisplay(d::Display) ("Base","nprocs","nprocs() + Get the number of available processes. "), ("Base","nworkers","nworkers() + Get the number of available worker processes. This is one less than nprocs(). Equal to nprocs() if nprocs() == 1. @@ -7102,24 +8022,28 @@ popdisplay(d::Display) ("Base","procs","procs() + Returns a list of all process identifiers. "), ("Base","workers","workers() + Returns a list of all worker process identifiers. "), ("Base","rmprocs","rmprocs(pids...) + Removes the specified workers. "), ("Base","interrupt","interrupt([pids...]) + Interrupt the current executing task on the specified workers. This is equivalent to pressing Ctrl-C on the local machine. If no arguments are given, all workers are interrupted. @@ -7128,12 +8052,14 @@ popdisplay(d::Display) ("Base","myid","myid() + Get the id of the current process. "), ("Base","pmap","pmap(f, lsts...; err_retry=true, err_stop=false) + Transform collections \"lsts\" by applying \"f\" to each element in parallel. If \"nprocs() > 1\", the calling process will be dedicated to assigning tasks. All other available processes will be @@ -7148,6 +8074,7 @@ popdisplay(d::Display) ("Base","remotecall","remotecall(id, func, args...) + Call a function asynchronously on the given arguments on the specified process. Returns a \"RemoteRef\". @@ -7155,6 +8082,7 @@ popdisplay(d::Display) ("Base","wait","wait([x]) + Block the current task until some event occurs, depending on the type of the argument: @@ -7186,24 +8114,28 @@ popdisplay(d::Display) ("Base","fetch","fetch(RemoteRef) + Wait for and get the value of a remote reference. "), ("Base","remotecall_wait","remotecall_wait(id, func, args...) + Perform \"wait(remotecall(...))\" in one message. "), ("Base","remotecall_fetch","remotecall_fetch(id, func, args...) + Perform \"fetch(remotecall(...))\" in one message. "), ("Base","put!","put!(RemoteRef, value) + Store a value to a remote reference. Implements \"shared queue of length 1\" semantics: if a value is already present, blocks until the value is removed with \"take!\". Returns its first argument. @@ -7212,6 +8144,7 @@ popdisplay(d::Display) ("Base","take!","take!(RemoteRef) + Fetch the value of a remote reference, removing it so that the reference is empty again. @@ -7219,6 +8152,7 @@ popdisplay(d::Display) ("Base","isready","isready(r::RemoteRef) + Determine whether a \"RemoteRef\" has a value stored to it. Note that this function can cause race conditions, since by the time you receive its result it may no longer be true. It is recommended that @@ -7238,17 +8172,21 @@ popdisplay(d::Display) ("Base","RemoteRef","RemoteRef() + Make an uninitialized remote reference on the local machine. "), ("Base","RemoteRef","RemoteRef(n) + Make an uninitialized remote reference on process \"n\". "), -("Base","timedwait","timedwait(testcb::Function, secs::Float64; pollint::Float64=0.1) +("Base","timedwait","timedwait(testcb::Function, secs::Float64; +pollint::Float64=0.1) + Waits till \"testcb\" returns \"true\" or for \"secs`\" seconds, whichever is earlier. \"testcb\" is polled every \"pollint\" @@ -7258,6 +8196,7 @@ popdisplay(d::Display) ("Base","@spawn","@spawn() + Execute an expression on an automatically-chosen process, returning a \"RemoteRef\" to the result. @@ -7265,6 +8204,7 @@ popdisplay(d::Display) ("Base","@spawnat","@spawnat() + Accepts two arguments, \"p\" and an expression, and runs the expression asynchronously on process \"p\", returning a \"RemoteRef\" to the result. @@ -7273,18 +8213,21 @@ popdisplay(d::Display) ("Base","@fetch","@fetch() + Equivalent to \"fetch(@spawn expr)\". "), ("Base","@fetchfrom","@fetchfrom() + Equivalent to \"fetch(@spawnat p expr)\". "), ("Base","@async","@async() + Schedule an expression to run on the local machine, also adding it to the set of items that the nearest enclosing \"@sync\" waits for. @@ -7292,6 +8235,7 @@ popdisplay(d::Display) ("Base","@sync","@sync() + Wait until all dynamically-enclosed uses of \"@async\", \"@spawn\", \"@spawnat\" and \"@parallel\" are complete. @@ -7299,6 +8243,7 @@ popdisplay(d::Display) ("Base","@parallel","@parallel() + A parallel for loop of the form @parallel [reducer] for var = range @@ -7323,6 +8268,7 @@ popdisplay(d::Display) ("Base","DArray","DArray(init, dims[, procs, dist]) + Construct a distributed array. The parameter \"init\" is a function that accepts a tuple of index ranges. This function should allocate a local chunk of the distributed array and initialize it for the @@ -7344,6 +8290,7 @@ popdisplay(d::Display) ("Base","dzeros","dzeros(dims, ...) + Construct a distributed array of zeros. Trailing arguments are the same as those accepted by \"DArray()\". @@ -7351,6 +8298,7 @@ popdisplay(d::Display) ("Base","dones","dones(dims, ...) + Construct a distributed array of ones. Trailing arguments are the same as those accepted by \"DArray()\". @@ -7358,6 +8306,7 @@ popdisplay(d::Display) ("Base","dfill","dfill(x, dims, ...) + Construct a distributed array filled with value \"x\". Trailing arguments are the same as those accepted by \"DArray()\". @@ -7365,6 +8314,7 @@ popdisplay(d::Display) ("Base","drand","drand(dims, ...) + Construct a distributed uniform random array. Trailing arguments are the same as those accepted by \"DArray()\". @@ -7372,6 +8322,7 @@ popdisplay(d::Display) ("Base","drandn","drandn(dims, ...) + Construct a distributed normal random array. Trailing arguments are the same as those accepted by \"DArray()\". @@ -7379,12 +8330,14 @@ popdisplay(d::Display) ("Base","distribute","distribute(a) + Convert a local array to distributed. "), ("Base","localpart","localpart(d) + Get the local piece of a distributed array. Returns an empty array if no local part exists on the calling process. @@ -7392,6 +8345,7 @@ popdisplay(d::Display) ("Base","localindexes","localindexes(d) + A tuple describing the indexes owned by the local process. Returns a tuple with empty ranges if no local part exists on the calling process. @@ -7400,11 +8354,14 @@ popdisplay(d::Display) ("Base","procs","procs(d) + Get the vector of processes storing pieces of \"d\". "), -("Base","SharedArray","SharedArray(T::Type, dims::NTuple; init=false, pids=Int[]) +("Base","SharedArray","SharedArray(T::Type, dims::NTuple; init=false, +pids=Int[]) + Construct a SharedArray of a bitstype \"T\" and size \"dims\" across the processes specified by \"pids\" - all of which have to @@ -7420,18 +8377,21 @@ popdisplay(d::Display) ("Base","procs","procs(S::SharedArray) + Get the vector of processes that have mapped the shared array "), ("Base","sdata","sdata(S::SharedArray) + Returns the actual \"Array\" object backing \"S\" "), ("Base","indexpids","indexpids(S::SharedArray) + Returns the index of the current worker into the \"pids\" vector, i.e., the list of workers mapping the SharedArray @@ -7439,6 +8399,7 @@ popdisplay(d::Display) ("Base","run","run(command) + Run a command object, constructed with backticks. Throws an error if anything goes wrong, including the process exiting with a non- zero status. @@ -7447,6 +8408,7 @@ popdisplay(d::Display) ("Base","spawn","spawn(command) + Run a command object asynchronously, returning the resulting \"Process\" object. @@ -7454,6 +8416,7 @@ popdisplay(d::Display) ("Base","DevNull","DevNull + Used in a stream redirect to discard all data written to it. Essentially equivalent to /dev/null on Unix or NUL on Windows. Usage: \"run(`cat test.txt` |> DevNull)\" @@ -7462,6 +8425,7 @@ popdisplay(d::Display) ("Base","success","success(command) + Run a command object, constructed with backticks, and tell whether it was successful (exited with a code of 0). An exception is raised if the process cannot be started. @@ -7470,18 +8434,21 @@ popdisplay(d::Display) ("Base","process_running","process_running(p::Process) + Determine whether a process is currently running. "), ("Base","process_exited","process_exited(p::Process) + Determine whether a process has exited. "), ("Base","kill","kill(p::Process, signum=SIGTERM) + Send a signal to a process. The default is to terminate the process. @@ -7489,6 +8456,7 @@ popdisplay(d::Display) ("Base","open","open(command, mode::String=\"r\", stdio=DevNull) + Start running \"command\" asynchronously, and return a tuple \"(stream,process)\". If \"mode\" is \"\"r\"\", then \"stream\" reads from the process's standard output and \"stdio\" optionally @@ -7499,7 +8467,9 @@ popdisplay(d::Display) "), -("Base","open","open(f::Function, command, mode::String=\"r\", stdio=DevNull) +("Base","open","open(f::Function, command, mode::String=\"r\", +stdio=DevNull) + Similar to \"open(command, mode, stdio)\", but calls \"f(stream)\" on the resulting read or write stream, then closes the stream and @@ -7510,6 +8480,7 @@ popdisplay(d::Display) ("Base","readandwrite","readandwrite(command) + Starts running a command asynchronously, and returns a tuple (stdout,stdin,process) of the output stream and input stream of the process, and the process object itself. @@ -7518,6 +8489,7 @@ popdisplay(d::Display) ("Base","ignorestatus","ignorestatus(command) + Mark a command object so that running it will not throw an error if the result code is non-zero. @@ -7525,6 +8497,7 @@ popdisplay(d::Display) ("Base","detach","detach(command) + Mark a command object so that it will be run in a new process group, allowing it to outlive the julia process, and not have Ctrl-C interrupts passed to it. @@ -7533,6 +8506,7 @@ popdisplay(d::Display) ("Base","setenv","setenv(command, env; dir=working_dir) + Set environment variables to use when running the given command. \"env\" is either a dictionary mapping strings to strings, or an array of strings of the form \"\"var=val\"\". @@ -7543,6 +8517,7 @@ popdisplay(d::Display) "), ("Base","|>","|>(command, command) + |>(command, filename) |>(filename, command) @@ -7561,6 +8536,7 @@ popdisplay(d::Display) ("Base",">>",">>(command, filename) + Redirect standard output of a process, appending to the destination file. @@ -7568,18 +8544,21 @@ popdisplay(d::Display) ("Base",".>",".>(command, filename) + Redirect the standard error stream of a process. "), ("Base","gethostname","gethostname() -> String + Get the local machine's host name. "), ("Base","getipaddr","getipaddr() -> String + Get the IP address of the local machine, as a string of the form \"x.x.x.x\". @@ -7587,18 +8566,21 @@ popdisplay(d::Display) ("Base","pwd","pwd() -> String + Get the current working directory. "), ("Base","cd","cd(dir::String) + Set the current working directory. "), ("Base","cd","cd(f[, dir]) + Temporarily changes the current working directory (HOME if not specified) and applies function f before returning. @@ -7606,6 +8588,7 @@ popdisplay(d::Display) ("Base","mkdir","mkdir(path[, mode]) + Make a new directory with name \"path\" and permissions \"mode\". \"mode\" defaults to 0o777, modified by the current file creation mask. @@ -7614,6 +8597,7 @@ popdisplay(d::Display) ("Base","mkpath","mkpath(path[, mode]) + Create all directories in the given \"path\", with permissions \"mode\". \"mode\" defaults to 0o777, modified by the current file creation mask. @@ -7622,21 +8606,24 @@ popdisplay(d::Display) ("Base","symlink","symlink(target, link) + Creates a symbolic link to \"target\" with the name \"link\". - Note: This function raises an error under operating systems that do not - support soft symbolic links, such as Windows XP. + Note: This function raises an error under operating systems that + do not support soft symbolic links, such as Windows XP. "), ("Base","getpid","getpid() -> Int32 + Get julia's process ID. "), ("Base","time","time([t::TmStruct]) + Get the system time in seconds since the epoch, with fairly high (typically, microsecond) resolution. When passed a \"TmStruct\", converts it to a number of seconds since the epoch. @@ -7645,6 +8632,7 @@ popdisplay(d::Display) ("Base","time_ns","time_ns() + Get the time in nanoseconds. The time corresponding to 0 is undefined, and wraps every 5.8 years. @@ -7652,6 +8640,7 @@ popdisplay(d::Display) ("Base","strftime","strftime([format], time) + Convert time, given as a number of seconds since the epoch or a \"TmStruct\", to a formatted string using the given format. Supported formats are the same as those in the standard C library. @@ -7660,6 +8649,7 @@ popdisplay(d::Display) ("Base","strptime","strptime([format], timestr) + Parse a formatted time string into a \"TmStruct\" giving the seconds, minute, hour, date, etc. Supported formats are the same as those in the standard C library. On some platforms, timezones will @@ -7673,6 +8663,7 @@ popdisplay(d::Display) ("Base","TmStruct","TmStruct([seconds]) + Convert a number of seconds since the epoch to broken-down format, with fields \"sec\", \"min\", \"hour\", \"mday\", \"month\", \"year\", \"wday\", \"yday\", and \"isdst\". @@ -7681,6 +8672,7 @@ popdisplay(d::Display) ("Base","tic","tic() + Set a timer to be read by the next call to \"toc()\" or \"toq()\". The macro call \"@time expr\" can also be used to time evaluation. @@ -7688,12 +8680,14 @@ popdisplay(d::Display) ("Base","toc","toc() + Print and return the time elapsed since the last \"tic()\". "), ("Base","toq","toq() + Return, but do not print, the time elapsed since the last \"tic()\". @@ -7701,6 +8695,7 @@ popdisplay(d::Display) ("Base","@time","@time() + A macro to execute an expression, printing the time it took to execute and the total number of bytes its execution caused to be allocated, before returning the value of the expression. @@ -7709,6 +8704,7 @@ popdisplay(d::Display) ("Base","@elapsed","@elapsed() + A macro to evaluate an expression, discarding the resulting value, instead returning the number of seconds it took to execute as a floating-point number. @@ -7717,6 +8713,7 @@ popdisplay(d::Display) ("Base","@allocated","@allocated() + A macro to evaluate an expression, discarding the resulting value, instead returning the total number of bytes allocated during evaluation of the expression. @@ -7725,6 +8722,7 @@ popdisplay(d::Display) ("Base","EnvHash","EnvHash() -> EnvHash + A singleton of this type provides a hash table interface to environment variables. @@ -7732,6 +8730,7 @@ popdisplay(d::Display) ("Base","ENV","ENV + Reference to the singleton \"EnvHash\", providing a dictionary interface to system environment variables. @@ -7739,6 +8738,7 @@ popdisplay(d::Display) ("Base","@unix","@unix() + Given \"@unix? a : b\", do \"a\" on Unix systems (including Linux and OS X) and \"b\" elsewhere. See documentation for Handling Platform Variations in the Calling C and Fortran Code section of @@ -7748,6 +8748,7 @@ popdisplay(d::Display) ("Base","@osx","@osx() + Given \"@osx? a : b\", do \"a\" on OS X and \"b\" elsewhere. See documentation for Handling Platform Variations in the Calling C and Fortran Code section of the manual. @@ -7756,6 +8757,7 @@ popdisplay(d::Display) ("Base","@linux","@linux() + Given \"@linux? a : b\", do \"a\" on Linux and \"b\" elsewhere. See documentation for Handling Platform Variations in the Calling C and Fortran Code section of the manual. @@ -7764,13 +8766,16 @@ popdisplay(d::Display) ("Base","@windows","@windows() + Given \"@windows? a : b\", do \"a\" on Windows and \"b\" elsewhere. See documentation for Handling Platform Variations in the Calling C and Fortran Code section of the manual. "), -("Base","ccall","ccall((symbol, library) or fptr, RetType, (ArgType1, ...), ArgVar1, ...) +("Base","ccall","ccall((symbol, library) or fptr, RetType, (ArgType1, +...), ArgVar1, ...) + Call function in C-exported shared library, specified by \"(function name, library)\" tuple, where each component is a @@ -7784,6 +8789,7 @@ popdisplay(d::Display) ("Base","cglobal","cglobal((symbol, library) or ptr[, Type=Void]) + Obtain a pointer to a global variable in a C-exported shared library, specified exactly as in \"ccall\". Returns a \"Ptr{Type}\", defaulting to \"Ptr{Void}\" if no Type argument is @@ -7792,7 +8798,9 @@ popdisplay(d::Display) "), -("Base","cfunction","cfunction(fun::Function, RetType::Type, (ArgTypes...)) +("Base","cfunction","cfunction(fun::Function, RetType::Type, +(ArgTypes...)) + Generate C-callable function pointer from Julia function. Type annotation of the return value in the callback function is a must @@ -7813,6 +8821,7 @@ popdisplay(d::Display) ("Base","dlopen","dlopen(libfile::String[, flags::Integer]) + Load a shared library, returning an opaque handle. The optional flags argument is a bitwise-or of zero or more of @@ -7831,6 +8840,7 @@ popdisplay(d::Display) ("Base","dlopen_e","dlopen_e(libfile::String[, flags::Integer]) + Similar to \"dlopen\", except returns a NULL pointer instead of raising errors. @@ -7838,6 +8848,7 @@ popdisplay(d::Display) ("Base","RTLD_DEEPBIND","RTLD_DEEPBIND + Enum constant for dlopen. See your platform man page for details, if applicable. @@ -7845,6 +8856,7 @@ popdisplay(d::Display) ("Base","RTLD_FIRST","RTLD_FIRST + Enum constant for dlopen. See your platform man page for details, if applicable. @@ -7852,6 +8864,7 @@ popdisplay(d::Display) ("Base","RTLD_GLOBAL","RTLD_GLOBAL + Enum constant for dlopen. See your platform man page for details, if applicable. @@ -7859,6 +8872,7 @@ popdisplay(d::Display) ("Base","RTLD_LAZY","RTLD_LAZY + Enum constant for dlopen. See your platform man page for details, if applicable. @@ -7866,6 +8880,7 @@ popdisplay(d::Display) ("Base","RTLD_LOCAL","RTLD_LOCAL + Enum constant for dlopen. See your platform man page for details, if applicable. @@ -7873,6 +8888,7 @@ popdisplay(d::Display) ("Base","RTLD_NODELETE","RTLD_NODELETE + Enum constant for dlopen. See your platform man page for details, if applicable. @@ -7880,6 +8896,7 @@ popdisplay(d::Display) ("Base","RTLD_NOLOAD","RTLD_NOLOAD + Enum constant for dlopen. See your platform man page for details, if applicable. @@ -7887,6 +8904,7 @@ popdisplay(d::Display) ("Base","RTLD_NOW","RTLD_NOW + Enum constant for dlopen. See your platform man page for details, if applicable. @@ -7894,6 +8912,7 @@ popdisplay(d::Display) ("Base","dlsym","dlsym(handle, sym) + Look up a symbol from a shared library handle, return callable function pointer on success. @@ -7901,6 +8920,7 @@ popdisplay(d::Display) ("Base","dlsym_e","dlsym_e(handle, sym) + Look up a symbol from a shared library handle, silently return NULL pointer on lookup failure. @@ -7908,12 +8928,14 @@ popdisplay(d::Display) ("Base","dlclose","dlclose(handle) + Close shared library referenced by handle. "), ("Base","find_library","find_library(names, locations) + Searches for the first library in \"names\" in the paths in the \"locations\" list, \"DL_LOAD_PATH\", or system library paths (in that order) which can successfully be dlopen'd. On success, the @@ -7926,6 +8948,7 @@ popdisplay(d::Display) ("Base","DL_LOAD_PATH","DL_LOAD_PATH + When calling \"dlopen\", the paths in this list will be searched first, in order, before searching the system locations for a valid library handle. @@ -7934,30 +8957,35 @@ popdisplay(d::Display) ("Base","c_malloc","c_malloc(size::Integer) -> Ptr{Void} + Call \"malloc\" from the C standard library. "), ("Base","c_calloc","c_calloc(num::Integer, size::Integer) -> Ptr{Void} + Call \"calloc\" from the C standard library. "), ("Base","c_realloc","c_realloc(addr::Ptr, size::Integer) -> Ptr{Void} + Call \"realloc\" from the C standard library. "), ("Base","c_free","c_free(addr::Ptr) + Call \"free\" from the C standard library. "), ("Base","unsafe_load","unsafe_load(p::Ptr{T}, i::Integer) + Load a value of type \"T\" from the address of the ith element (1-indexed) starting at \"p\". This is equivalent to the C expression \"p[i-1]\". @@ -7966,6 +8994,7 @@ popdisplay(d::Display) ("Base","unsafe_store!","unsafe_store!(p::Ptr{T}, x, i::Integer) + Store a value of type \"T\" to the address of the ith element (1-indexed) starting at \"p\". This is equivalent to the C expression \"p[i-1] = x\". @@ -7974,13 +9003,16 @@ popdisplay(d::Display) ("Base","unsafe_copy!","unsafe_copy!(dest::Ptr{T}, src::Ptr{T}, N) + Copy \"N\" elements from a source pointer to a destination, with no checking. The size of an element is determined by the type of the pointers. "), -("Base","unsafe_copy!","unsafe_copy!(dest::Array, do, src::Array, so, N) +("Base","unsafe_copy!","unsafe_copy!(dest::Array, do, src::Array, so, +N) + Copy \"N\" elements from a source array to a destination, starting at offset \"so\" in the source and \"do\" in the destination @@ -7990,6 +9022,7 @@ popdisplay(d::Display) ("Base","copy!","copy!(dest, src) + Copy all elements from collection \"src\" to array \"dest\". Returns \"dest\". @@ -7997,6 +9030,7 @@ popdisplay(d::Display) ("Base","copy!","copy!(dest, do, src, so, N) + Copy \"N\" elements from collection \"src\" starting at offset \"so\", to array \"dest\" starting at offset \"do\". Returns \"dest\". @@ -8005,6 +9039,7 @@ popdisplay(d::Display) ("Base","pointer","pointer(a[, index]) + Get the native address of an array or string element. Be careful to ensure that a julia reference to \"a\" exists as long as this pointer will be used. @@ -8013,12 +9048,14 @@ popdisplay(d::Display) ("Base","pointer","pointer(type, int) + Convert an integer to a pointer of the specified element type. "), ("Base","pointer_to_array","pointer_to_array(p, dims[, own]) + Wrap a native pointer as a Julia Array object. The pointer element type determines the array element type. \"own\" optionally specifies whether Julia should take ownership of the memory, @@ -8029,6 +9066,7 @@ popdisplay(d::Display) ("Base","pointer_from_objref","pointer_from_objref(obj) + Get the memory address of a Julia object as a \"Ptr\". The existence of the resulting \"Ptr\" will not protect the object from garbage collection, so you must ensure that the object remains @@ -8038,6 +9076,7 @@ popdisplay(d::Display) ("Base","unsafe_pointer_to_objref","unsafe_pointer_to_objref(p::Ptr) + Convert a \"Ptr\" to an object reference. Assumes the pointer refers to a valid heap-allocated Julia object. If this is not the case, undefined behavior results, hence this function is considered @@ -8047,6 +9086,7 @@ popdisplay(d::Display) ("Base","disable_sigint","disable_sigint(f::Function) + Disable Ctrl-C handler during execution of a function, for calling external code that is not interrupt safe. Intended to be called using \"do\" block syntax as follows: @@ -8060,6 +9100,7 @@ popdisplay(d::Display) ("Base","reenable_sigint","reenable_sigint(f::Function) + Re-enable Ctrl-C handler during execution of a function. Temporarily reverses the effect of \"disable_sigint\". @@ -8067,6 +9108,7 @@ popdisplay(d::Display) ("Base","errno","errno([code]) + Get the value of the C library's \"errno\". If an argument is specified, it is used to set the value of \"errno\". @@ -8079,6 +9121,7 @@ popdisplay(d::Display) ("Base","systemerror","systemerror(sysfunc, iftrue) + Raises a \"SystemError\" for \"errno\" with the descriptive string \"sysfunc\" if \"bool\" is true @@ -8086,126 +9129,147 @@ popdisplay(d::Display) ("Base","strerror","strerror(n) + Convert a system call error code to a descriptive string "), ("Base","Cchar","Cchar + Equivalent to the native \"char\" c-type "), ("Base","Cuchar","Cuchar + Equivalent to the native \"unsigned char\" c-type (Uint8) "), ("Base","Cshort","Cshort + Equivalent to the native \"signed short\" c-type (Int16) "), ("Base","Cushort","Cushort + Equivalent to the native \"unsigned short\" c-type (Uint16) "), ("Base","Cint","Cint + Equivalent to the native \"signed int\" c-type (Int32) "), ("Base","Cuint","Cuint + Equivalent to the native \"unsigned int\" c-type (Uint32) "), ("Base","Clong","Clong + Equivalent to the native \"signed long\" c-type "), ("Base","Culong","Culong + Equivalent to the native \"unsigned long\" c-type "), ("Base","Clonglong","Clonglong + Equivalent to the native \"signed long long\" c-type (Int64) "), ("Base","Culonglong","Culonglong + Equivalent to the native \"unsigned long long\" c-type (Uint64) "), ("Base","Csize_t","Csize_t + Equivalent to the native \"size_t\" c-type (Uint) "), ("Base","Cssize_t","Cssize_t + Equivalent to the native \"ssize_t\" c-type "), ("Base","Cptrdiff_t","Cptrdiff_t + Equivalent to the native \"ptrdiff_t\" c-type (Int) "), ("Base","Coff_t","Coff_t + Equivalent to the native \"off_t\" c-type "), ("Base","Cwchar_t","Cwchar_t + Equivalent to the native \"wchar_t\" c-type (Int32) "), ("Base","Cfloat","Cfloat + Equivalent to the native \"float\" c-type (Float32) "), ("Base","Cdouble","Cdouble + Equivalent to the native \"double\" c-type (Float64) "), ("Base","error","error(message::String) + Raise an error with the given message "), ("Base","throw","throw(e) + Throw an object as an exception "), ("Base","rethrow","rethrow([e]) + Throw an object without changing the current exception backtrace. The default argument is the current exception (if called within a \"catch\" block). @@ -8214,12 +9278,14 @@ popdisplay(d::Display) ("Base","backtrace","backtrace() + Get a backtrace object for the current program point. "), ("Base","catch_backtrace","catch_backtrace() + Get the backtrace of the current exception, for use within \"catch\" blocks. @@ -8227,6 +9293,7 @@ popdisplay(d::Display) ("Base","assert","assert(cond[, text]) + Raise an error if \"cond\" is false. Also available as the macro \"@assert expr\". @@ -8234,6 +9301,7 @@ popdisplay(d::Display) ("Base","@assert","@assert() + Raise an error if \"cond\" is false. Preferred syntax for writings assertions. @@ -8241,12 +9309,14 @@ popdisplay(d::Display) ("Base","ArgumentError","ArgumentError + The parameters given to a function call are not valid. "), ("Base","BoundsError","BoundsError + An indexing operation into an array tried to access an out-of- bounds element. @@ -8254,12 +9324,14 @@ popdisplay(d::Display) ("Base","EOFError","EOFError + No more data was available to read from a file or stream. "), ("Base","ErrorException","ErrorException + Generic error type. The error message, in the *.msg* field, may provide more specific details. @@ -8267,6 +9339,7 @@ popdisplay(d::Display) ("Base","KeyError","KeyError + An indexing operation into an \"Associative\" (\"Dict\") or \"Set\" like object tried to access or delete a non-existent element. @@ -8274,6 +9347,7 @@ popdisplay(d::Display) ("Base","LoadError","LoadError + An error occurred while *including*, *requiring*, or *using* a file. The error specifics should be available in the *.error* field. @@ -8282,6 +9356,7 @@ popdisplay(d::Display) ("Base","MethodError","MethodError + A method with the required type signature does not exist in the given generic function. @@ -8289,6 +9364,7 @@ popdisplay(d::Display) ("Base","ParseError","ParseError + The expression passed to the *parse* function could not be interpreted as a valid Julia expression. @@ -8296,6 +9372,7 @@ popdisplay(d::Display) ("Base","ProcessExitedException","ProcessExitedException + After a client Julia process has exited, further attempts to reference the dead child will throw this exception. @@ -8303,6 +9380,7 @@ popdisplay(d::Display) ("Base","SystemError","SystemError + A system call failed with an error code (in the \"errno\" global variable). @@ -8310,6 +9388,7 @@ popdisplay(d::Display) ("Base","TypeError","TypeError + A type assertion failure, or calling an intrinsic function with an incorrect argument type. @@ -8317,6 +9396,7 @@ popdisplay(d::Display) ("Base","Task","Task(func) + Create a \"Task\" (i.e. thread, or coroutine) to execute the given function (which must be callable with no arguments). The task exits when this function returns. @@ -8325,6 +9405,7 @@ popdisplay(d::Display) ("Base","yieldto","yieldto(task, args...) + Switch to the given task. The first time a task is switched to, the task's function is called with no arguments. On subsequent switches, \"args\" are returned from the task's last call to @@ -8335,18 +9416,21 @@ popdisplay(d::Display) ("Base","current_task","current_task() + Get the currently running Task. "), ("Base","istaskdone","istaskdone(task) -> Bool + Tell whether a task has exited. "), ("Base","consume","consume(task, values...) + Receive the next value passed to \"produce\" by the specified task. Additional arguments may be passed, to be returned from the last \"produce\" call in the producer. @@ -8355,6 +9439,7 @@ popdisplay(d::Display) ("Base","produce","produce(value) + Send the given value to the last \"consume\" call, switching to the consumer task. If the next \"consume\" call passes any values, they are returned by \"produce\". @@ -8363,6 +9448,7 @@ popdisplay(d::Display) ("Base","yield","yield() + Switch to the scheduler to allow another scheduled task to run. A task that calls this function is still runnable, and will be restarted immediately if there are no other runnable tasks. @@ -8371,6 +9457,7 @@ popdisplay(d::Display) ("Base","task_local_storage","task_local_storage(symbol) + Look up the value of a symbol in the current task's task-local storage. @@ -8378,6 +9465,7 @@ popdisplay(d::Display) ("Base","task_local_storage","task_local_storage(symbol, value) + Assign a value to a symbol in the current task's task-local storage. @@ -8385,6 +9473,7 @@ popdisplay(d::Display) ("Base","task_local_storage","task_local_storage(body, symbol, value) + Call the function \"body\" with a modified task-local storage, in which \"value\" is assigned to \"symbol\"; the previous value of \"symbol\", or lack thereof, is restored afterwards. Useful for @@ -8394,6 +9483,7 @@ popdisplay(d::Display) ("Base","Condition","Condition() + Create an edge-triggered event source that tasks can wait for. Tasks that call \"wait\" on a \"Condition\" are suspended and queued. Tasks are woken up when \"notify\" is later called on the @@ -8405,7 +9495,9 @@ popdisplay(d::Display) "), -("Base","notify","notify(condition, val=nothing; all=true, error=false) +("Base","notify","notify(condition, val=nothing; all=true, +error=false) + Wake up tasks waiting for a condition, passing them \"val\". If \"all\" is true (the default), all waiting tasks are woken, @@ -8416,6 +9508,7 @@ popdisplay(d::Display) ("Base","schedule","schedule(t::Task, [val]; error=false) + Add a task to the scheduler's queue. This causes the task to run constantly when the system is otherwise idle, unless the task performs a blocking operation such as \"wait\". @@ -8429,12 +9522,14 @@ popdisplay(d::Display) ("Base","@schedule","@schedule() + Wrap an expression in a Task and add it to the scheduler's queue. "), ("Base","@task","@task() + Wrap an expression in a Task executing it, and return the Task. This only creates a task, and does not run it. @@ -8442,6 +9537,7 @@ popdisplay(d::Display) ("Base","sleep","sleep(seconds) + Block the current task for a specified number of seconds. The minimum sleep time is 1 millisecond or input of \"0.001\". @@ -8449,6 +9545,7 @@ popdisplay(d::Display) ("Base","Timer","Timer(f::Function) + Create a timer to call the given callback function. The callback is passed one argument, the timer object itself. The timer can be started and stopped with \"start_timer\" and \"stop_timer\". @@ -8457,6 +9554,7 @@ popdisplay(d::Display) ("Base","start_timer","start_timer(t::Timer, delay, repeat) + Start invoking the callback for a \"Timer\" after the specified initial delay, and then repeating with the given interval. Times are in seconds. If \"repeat\" is \"0\", the timer is only triggered @@ -8466,24 +9564,28 @@ popdisplay(d::Display) ("Base","stop_timer","stop_timer(t::Timer) + Stop invoking the callback for a timer. "), ("Base","module_name","module_name(m::Module) -> Symbol + Get the name of a module as a symbol. "), ("Base","module_parent","module_parent(m::Module) -> Module + Get a module's enclosing module. \"Main\" is its own parent. "), ("Base","current_module","current_module() -> Module + Get the *dynamically* current module, which is the module code is currently being read from. In general, this is not the same as the module containing the call to this function. @@ -8492,6 +9594,7 @@ popdisplay(d::Display) ("Base","fullname","fullname(m::Module) + Get the fully-qualified name of a module as a tuple of symbols. For example, \"fullname(Base.Pkg)\" gives \"(:Base,:Pkg)\", and \"fullname(Main)\" gives \"()\". @@ -8500,6 +9603,7 @@ popdisplay(d::Display) ("Base","names","names(x::Module[, all=false[, imported=false]]) + Get an array of the names exported by a module, with optionally more module globals according to the additional parameters. @@ -8507,12 +9611,14 @@ popdisplay(d::Display) ("Base","names","names(x::DataType) + Get an array of the fields of a data type. "), ("Base","isconst","isconst([m::Module], s::Symbol) -> Bool + Determine whether a global is declared \"const\" in a given module. The default module argument is \"current_module()\". @@ -8520,17 +9626,21 @@ popdisplay(d::Display) ("Base","isgeneric","isgeneric(f::Function) -> Bool + Determine whether a function is generic. "), ("Base","function_name","function_name(f::Function) -> Symbol + Get the name of a generic function as a symbol, or \":anonymous\". "), -("Base","function_module","function_module(f::Function, types) -> Module +("Base","function_module","function_module(f::Function, types) -> +Module + Determine the module containing a given definition of a generic function. @@ -8539,6 +9649,7 @@ popdisplay(d::Display) ("Base","functionloc","functionloc(f::Function, types) + Returns a tuple \"(filename,line)\" giving the location of a method definition. @@ -8546,6 +9657,7 @@ popdisplay(d::Display) ("Base","functionlocs","functionlocs(f::Function, types) + Returns an array of the results of \"functionloc\" for all matching definitions. @@ -8553,12 +9665,14 @@ popdisplay(d::Display) ("Base","gc","gc() + Perform garbage collection. This should not generally be used. "), ("Base","gc_disable","gc_disable() + Disable garbage collection. This should be used only with extreme caution, as it can cause memory use to grow without bound. @@ -8566,12 +9680,14 @@ popdisplay(d::Display) ("Base","gc_enable","gc_enable() + Re-enable garbage collection after calling \"gc_disable\". "), ("Base","macroexpand","macroexpand(x) + Takes the expression x and returns an equivalent expression with all macros removed (expanded). @@ -8579,6 +9695,7 @@ popdisplay(d::Display) ("Base","expand","expand(x) + Takes the expression x and returns an equivalent expression in lowered form @@ -8586,6 +9703,7 @@ popdisplay(d::Display) ("Base","code_lowered","code_lowered(f, types) + Returns an array of lowered ASTs for the methods matching the given generic function and type signature. @@ -8593,6 +9711,7 @@ popdisplay(d::Display) ("Base","@code_lowered","@code_lowered() + Evaluates the arguments to the function call, determines their types, and calls the \"code_lowered\" function on the resulting expression @@ -8601,6 +9720,7 @@ popdisplay(d::Display) ("Base","code_typed","code_typed(f, types) + Returns an array of lowered and type-inferred ASTs for the methods matching the given generic function and type signature. @@ -8608,6 +9728,7 @@ popdisplay(d::Display) ("Base","@code_typed","@code_typed() + Evaluates the arguments to the function call, determines their types, and calls the \"code_typed\" function on the resulting expression @@ -8616,6 +9737,7 @@ popdisplay(d::Display) ("Base","code_llvm","code_llvm(f, types) + Prints the LLVM bitcodes generated for running the method matching the given generic function and type signature to STDOUT. @@ -8623,6 +9745,7 @@ popdisplay(d::Display) ("Base","@code_llvm","@code_llvm() + Evaluates the arguments to the function call, determines their types, and calls the \"code_llvm\" function on the resulting expression @@ -8631,6 +9754,7 @@ popdisplay(d::Display) ("Base","code_native","code_native(f, types) + Prints the native assembly instructions generated for running the method matching the given generic function and type signature to STDOUT. @@ -8639,6 +9763,7 @@ popdisplay(d::Display) ("Base","@code_native","@code_native() + Evaluates the arguments to the function call, determines their types, and calls the \"code_native\" function on the resulting expression @@ -8647,6 +9772,7 @@ popdisplay(d::Display) ("Base","precompile","precompile(f, args::(Any..., )) + Compile the given function *f* for the argument tuple (of types) *args*, but do not execute it. @@ -8654,6 +9780,7 @@ popdisplay(d::Display) ("Base.Collections","PriorityQueue{K,V}","PriorityQueue{K,V}([ord]) + Construct a new PriorityQueue, with keys of type K and values/priorites of type V. If an order is not given, the priority queue is min-ordered using the default comparison for V. @@ -8662,6 +9789,7 @@ popdisplay(d::Display) ("Base.Collections","enqueue!","enqueue!(pq, k, v) + Insert the a key \"k\" into a priority queue \"pq\" with priority \"v\". @@ -8669,12 +9797,14 @@ popdisplay(d::Display) ("Base.Collections","dequeue!","dequeue!(pq) + Remove and return the lowest priority key from a priority queue. "), ("Base.Collections","peek","peek(pq) + Return the lowest priority key from a priority queue without removing that key from the queue. @@ -8682,6 +9812,7 @@ popdisplay(d::Display) ("Base.Collections","heapify","heapify(v[, ord]) + Return a new vector in binary heap order, optionally using the given ordering. @@ -8689,12 +9820,14 @@ popdisplay(d::Display) ("Base.Collections","heapify!","heapify!(v[, ord]) + In-place heapify. "), ("Base.Collections","isheap","isheap(v[, ord]) + Return true iff an array is heap-ordered according to the given order. @@ -8702,6 +9835,7 @@ popdisplay(d::Display) ("Base.Collections","heappush!","heappush!(v, x[, ord]) + Given a binary heap-ordered array, push a new element \"x\", preserving the heap property. For efficiency, this function does not check that the array is indeed heap-ordered. @@ -8710,6 +9844,7 @@ popdisplay(d::Display) ("Base.Collections","heappop!","heappop!(v[, ord]) + Given a binary heap-ordered array, remove and return the lowest ordered element. For efficiency, this function does not check that the array is indeed heap-ordered. @@ -8718,6 +9853,7 @@ popdisplay(d::Display) ("Base","OS_NAME","OS_NAME + A symbol representing the name of the operating system. Possible values are \":Linux\", \":Darwin\" (OS X), or \":Windows\". @@ -8725,12 +9861,14 @@ popdisplay(d::Display) ("Base","ARGS","ARGS + An array of the command line arguments passed to Julia, as strings. "), ("Base","C_NULL","C_NULL + The C null pointer constant, sometimes used when calling external code. @@ -8738,24 +9876,28 @@ popdisplay(d::Display) ("Base","CPU_CORES","CPU_CORES + The number of CPU cores in the system. "), ("Base","WORD_SIZE","WORD_SIZE + Standard word size on the current machine, in bits. "), ("Base","VERSION","VERSION + An object describing which version of Julia is in use. "), ("Base","LOAD_PATH","LOAD_PATH + An array of paths (as strings) where the \"require\" function looks for code. @@ -8763,6 +9905,7 @@ popdisplay(d::Display) ("Base","isblockdev","isblockdev(path) -> Bool + Returns \"true\" if \"path\" is a block device, \"false\" otherwise. @@ -8770,6 +9913,7 @@ popdisplay(d::Display) ("Base","ischardev","ischardev(path) -> Bool + Returns \"true\" if \"path\" is a character device, \"false\" otherwise. @@ -8777,12 +9921,14 @@ popdisplay(d::Display) ("Base","isdir","isdir(path) -> Bool + Returns \"true\" if \"path\" is a directory, \"false\" otherwise. "), ("Base","isexecutable","isexecutable(path) -> Bool + Returns \"true\" if the current user has permission to execute \"path\", \"false\" otherwise. @@ -8790,12 +9936,14 @@ popdisplay(d::Display) ("Base","isfifo","isfifo(path) -> Bool + Returns \"true\" if \"path\" is a FIFO, \"false\" otherwise. "), ("Base","isfile","isfile(path) -> Bool + Returns \"true\" if \"path\" is a regular file, \"false\" otherwise. @@ -8803,6 +9951,7 @@ popdisplay(d::Display) ("Base","islink","islink(path) -> Bool + Returns \"true\" if \"path\" is a symbolic link, \"false\" otherwise. @@ -8810,6 +9959,7 @@ popdisplay(d::Display) ("Base","ispath","ispath(path) -> Bool + Returns \"true\" if \"path\" is a valid filesystem path, \"false\" otherwise. @@ -8817,6 +9967,7 @@ popdisplay(d::Display) ("Base","isreadable","isreadable(path) -> Bool + Returns \"true\" if the current user has permission to read \"path\", \"false\" otherwise. @@ -8824,6 +9975,7 @@ popdisplay(d::Display) ("Base","issetgid","issetgid(path) -> Bool + Returns \"true\" if \"path\" has the setgid flag set, \"false\" otherwise. @@ -8831,6 +9983,7 @@ popdisplay(d::Display) ("Base","issetuid","issetuid(path) -> Bool + Returns \"true\" if \"path\" has the setuid flag set, \"false\" otherwise. @@ -8838,12 +9991,14 @@ popdisplay(d::Display) ("Base","issocket","issocket(path) -> Bool + Returns \"true\" if \"path\" is a socket, \"false\" otherwise. "), ("Base","issticky","issticky(path) -> Bool + Returns \"true\" if \"path\" has the sticky bit set, \"false\" otherwise. @@ -8851,6 +10006,7 @@ popdisplay(d::Display) ("Base","iswritable","iswritable(path) -> Bool + Returns \"true\" if the current user has permission to write to \"path\", \"false\" otherwise. @@ -8858,24 +10014,28 @@ popdisplay(d::Display) ("Base","homedir","homedir() -> String + Return the current user's home directory. "), ("Base","dirname","dirname(path::String) -> String + Get the directory part of a path. "), ("Base","basename","basename(path::String) -> String + Get the file name part of a path. "), ("Base","@__FILE__","@__FILE__() -> String + \"@__FILE__\" expands to a string with the absolute path and file name of the script being run. Returns \"nothing\" if run from a REPL or an empty string if evaluated by \"julia -e \". @@ -8884,6 +10044,7 @@ popdisplay(d::Display) ("Base","isabspath","isabspath(path::String) -> Bool + Determines whether a path is absolute (begins at the root directory). @@ -8891,6 +10052,7 @@ popdisplay(d::Display) ("Base","isdirpath","isdirpath(path::String) -> Bool + Determines whether a path refers to a directory (for example, ends with a path separator). @@ -8898,6 +10060,7 @@ popdisplay(d::Display) ("Base","joinpath","joinpath(parts...) -> String + Join path components into a full path. If some argument is an absolute path, then prior components are dropped. @@ -8905,6 +10068,7 @@ popdisplay(d::Display) ("Base","abspath","abspath(path::String) -> String + Convert a path to an absolute path by adding the current directory if necessary. @@ -8912,12 +10076,14 @@ popdisplay(d::Display) ("Base","normpath","normpath(path::String) -> String + Normalize a path, removing \".\" and \"..\" entries. "), ("Base","realpath","realpath(path::String) -> String + Canonicalize a path by expanding symbolic links and removing \".\" and \"..\" entries. @@ -8925,6 +10091,7 @@ popdisplay(d::Display) ("Base","expanduser","expanduser(path::String) -> String + On Unix systems, replace a tilde character at the start of a path with the current user's home directory. @@ -8932,12 +10099,14 @@ popdisplay(d::Display) ("Base","splitdir","splitdir(path::String) -> (String, String) + Split a path into a tuple of the directory name and file name. "), ("Base","splitdrive","splitdrive(path::String) -> (String, String) + On Windows, split a path into the drive letter part and the path part. On Unix systems, the first component is always the empty string. @@ -8946,6 +10115,7 @@ popdisplay(d::Display) ("Base","splitext","splitext(path::String) -> (String, String) + If the last component of a path contains a dot, split the path into everything before the dot and everything including and after the dot. Otherwise, return a tuple of the argument unmodified and the @@ -8955,18 +10125,21 @@ popdisplay(d::Display) ("Base","tempname","tempname() + Generate a unique temporary filename. "), ("Base","tempdir","tempdir() + Obtain the path of a temporary directory. "), ("Base","mktemp","mktemp() + Returns \"(path, io)\", where \"path\" is the path of a new temporary file and \"io\" is an open file object for this path. @@ -8974,96 +10147,112 @@ popdisplay(d::Display) ("Base","mktempdir","mktempdir() + Create a temporary directory and return its path. "), ("Base.Graphics","Vec2","Vec2(x, y) + Creates a point in two dimensions "), ("Base.Graphics","BoundingBox","BoundingBox(xmin, xmax, ymin, ymax) + Creates a box in two dimensions with the given edges "), ("Base.Graphics","BoundingBox","BoundingBox(objs...) + Creates a box in two dimensions that encloses all objects "), ("Base.Graphics","width","width(obj) + Computes the width of an object "), ("Base.Graphics","height","height(obj) + Computes the height of an object "), ("Base.Graphics","xmin","xmin(obj) + Computes the minimum x-coordinate contained in an object "), ("Base.Graphics","xmax","xmax(obj) + Computes the maximum x-coordinate contained in an object "), ("Base.Graphics","ymin","ymin(obj) + Computes the minimum y-coordinate contained in an object "), ("Base.Graphics","ymax","ymax(obj) + Computes the maximum y-coordinate contained in an object "), ("Base.Graphics","diagonal","diagonal(obj) + Return the length of the diagonal of an object "), ("Base.Graphics","aspect_ratio","aspect_ratio(obj) + Compute the height/width of an object "), ("Base.Graphics","center","center(obj) + Return the point in the center of an object "), ("Base.Graphics","xrange","xrange(obj) + Returns a tuple \"(xmin(obj), xmax(obj))\" "), ("Base.Graphics","yrange","yrange(obj) + Returns a tuple \"(ymin(obj), ymax(obj))\" "), ("Base.Graphics","rotate","rotate(obj, angle, origin) -> newobj + Rotates an object around origin by the specified angle (radians), returning a new object of the same type. Because of type- constancy, this new object may not always be a strict geometric @@ -9075,6 +10264,7 @@ popdisplay(d::Display) ("Base.Graphics","shift","shift(obj, dx, dy) + Returns an object shifted horizontally and vertically by the indicated amounts @@ -9082,24 +10272,31 @@ popdisplay(d::Display) ("Base.Graphics","*","*(obj, s::Real) + Scale the width and height of a graphics object, keeping the center fixed "), -("Base.Graphics","+","+(bb1::BoundingBox, bb2::BoundingBox) -> BoundingBox +("Base.Graphics","+","+(bb1::BoundingBox, bb2::BoundingBox) -> +BoundingBox + Returns the smallest box containing both boxes "), -("Base.Graphics","&","&(bb1::BoundingBox, bb2::BoundingBox) -> BoundingBox +("Base.Graphics","&","&(bb1::BoundingBox, bb2::BoundingBox) -> +BoundingBox + Returns the intersection, the largest box contained in both boxes "), -("Base.Graphics","deform","deform(bb::BoundingBox, dxmin, dxmax, dymin, dymax) +("Base.Graphics","deform","deform(bb::BoundingBox, dxmin, dxmax, +dymin, dymax) + Returns a bounding box with all edges shifted by the indicated amounts @@ -9108,12 +10305,14 @@ popdisplay(d::Display) ("Base.Graphics","isinside","isinside(bb::BoundingBox, x, y) + True if the given point is inside the box "), ("Base.Graphics","isinside","isinside(bb::BoundingBox, point) + True if the given point is inside the box "), @@ -9121,12 +10320,14 @@ popdisplay(d::Display) ("Base","*","*(A, B) + Matrix multiplication "), ("Base","\\","\\(A, B) + Matrix division using a polyalgorithm. For input matrices \"A\" and \"B\", the result \"X\" is such that \"A*X == B\" when \"A\" is square. The solver that is used depends upon the structure of @@ -9143,6 +10344,7 @@ popdisplay(d::Display) ("Base","dot","dot(x, y) + Compute the dot product. For complex vectors, the first vector is conjugated. @@ -9150,18 +10352,21 @@ popdisplay(d::Display) ("Base","cross","cross(x, y) + Compute the cross product of two 3-vectors. "), ("Base","rref","rref(A) + Compute the reduced row echelon form of the matrix A. "), ("Base","factorize","factorize(A) + Compute a convenient factorization (including LU, Cholesky, Bunch- Kaufman, Triangular) of A, based upon the type of the input matrix. The return value can then be reused for efficient solving of @@ -9172,6 +10377,7 @@ popdisplay(d::Display) ("Base","factorize!","factorize!(A) + \"factorize!\" is the same as \"factorize()\", but saves space by overwriting the input \"A\", instead of creating a copy. @@ -9179,12 +10385,14 @@ popdisplay(d::Display) ("Base","lu","lu(A) -> L, U, p + Compute the LU factorization of \"A\", such that \"A[p,:] = L*U\". "), ("Base","lufact","lufact(A[, pivot=true]) -> F + Compute the LU factorization of \"A\". The return type of \"F\" depends on the type of \"A\". In most cases, if \"A\" is a subtype \"S\" of AbstractMatrix with an element type \"T`\" supporting @@ -9234,6 +10442,7 @@ popdisplay(d::Display) ("Base","lufact!","lufact!(A) -> LU + \"lufact!\" is the same as \"lufact()\", but saves space by overwriting the input A, instead of creating a copy. For sparse \"A\" the \"nzval\" field is not overwritten but the index fields, @@ -9244,13 +10453,16 @@ popdisplay(d::Display) ("Base","chol","chol(A[, LU]) -> F + Compute the Cholesky factorization of a symmetric positive definite matrix \"A\" and return the matrix \"F\". If \"LU\" is \":L\" (Lower), \"A = L*L'\". If \"LU\" is \":U\" (Upper), \"A = R'*R\". "), -("Base","cholfact","cholfact(A, [LU,][pivot=false,][tol=-1.0]) -> Cholesky +("Base","cholfact","cholfact(A, [LU,][pivot=false,][tol=-1.0]) -> +Cholesky + Compute the Cholesky factorization of a dense symmetric positive (semi)definite matrix \"A\" and return either a \"Cholesky\" if @@ -9270,6 +10482,7 @@ popdisplay(d::Display) ("Base","cholfact","cholfact(A[, ll]) -> CholmodFactor + Compute the sparse Cholesky factorization of a sparse matrix \"A\". If \"A\" is Hermitian its Cholesky factor is determined. If \"A\" is not Hermitian the Cholesky factor of \"A*A'\" is determined. A @@ -9285,7 +10498,9 @@ popdisplay(d::Display) "), -("Base","cholfact!","cholfact!(A, [LU,][pivot=false,][tol=-1.0]) -> Cholesky +("Base","cholfact!","cholfact!(A, [LU,][pivot=false,][tol=-1.0]) -> +Cholesky + \"cholfact!\" is the same as \"cholfact()\", but saves space by overwriting the input \"A\", instead of creating a copy. @@ -9294,6 +10509,7 @@ popdisplay(d::Display) ("Base","ldltfact","ldltfact(A) -> LDLtFactorization + Compute a factorization of a positive definite matrix \"A\" such that \"A=L*Diagonal(d)*L'\" where \"L\" is a unit lower triangular matrix and \"d\" is a vector with non-negative elements. @@ -9302,6 +10518,7 @@ popdisplay(d::Display) ("Base","qr","qr(A, [pivot=false,][thin=true]) -> Q, R, [p] + Compute the (pivoted) QR factorization of \"A\" such that either \"A = Q*R\" or \"A[:,p] = Q*R\". Also see \"qrfact\". The default is to compute a thin factorization. Note that \"R\" is not extended @@ -9311,6 +10528,7 @@ popdisplay(d::Display) ("Base","qrfact","qrfact(A[, pivot=false]) -> F + Computes the QR factorization of \"A\". The return type of \"F\" depends on the element type of \"A\" and whether pivoting is specified (with \"pivot=true\"). @@ -9351,13 +10569,13 @@ popdisplay(d::Display) \"Q\" matrix can be converted into a regular matrix with \"full()\" which has a named argument \"thin\". - Note: \"qrfact\" returns multiple types because LAPACK uses several - representations that minimize the memory storage requirements of - products of Householder elementary reflectors, so that the \"Q\" - and \"R\" matrices can be stored compactly rather as two separate - dense matrices.The data contained in \"QR\" or \"QRPivoted\" can - be used to construct the \"QRPackedQ\" type, which is a compact - representation of the rotation matrix: + Note: \"qrfact\" returns multiple types because LAPACK uses + several representations that minimize the memory storage + requirements of products of Householder elementary reflectors, so + that the \"Q\" and \"R\" matrices can be stored compactly rather + as two separate dense matrices.The data contained in \"QR\" or + \"QRPivoted\" can be used to construct the \"QRPackedQ\" type, + which is a compact representation of the rotation matrix: Q = \\prod_{i=1}^{\\min(m,n)} (I - \\tau_i v_i v_i^T) @@ -9375,19 +10593,21 @@ popdisplay(d::Display) representation [Bischof1987]. (The LAPACK documentation uses \"V\" in lieu of \"Y\".) - [Bischof1987] C Bischof and C Van Loan, The WY representation for - products of Householder matrices, SIAM J Sci Stat - Comput 8 (1987), s2-s13. doi:10.1137/0908009 + [Bischof1987] C Bischof and C Van Loan, The WY + representation for products of Householder matrices, + SIAM J Sci Stat Comput 8 (1987), s2-s13. + doi:10.1137/0908009 - [Schreiber1989] R Schreiber and C Van Loan, A storage-efficient WY - representation for products of Householder - transformations, SIAM J Sci Stat Comput 10 (1989), - 53-57. doi:10.1137/0910005 + [Schreiber1989] R Schreiber and C Van Loan, A + storage-efficient WY representation for products of + Householder transformations, SIAM J Sci Stat Comput + 10 (1989), 53-57. doi:10.1137/0910005 "), ("Base","qrfact!","qrfact!(A[, pivot=false]) + \"qrfact!\" is the same as \"qrfact()\", but saves space by overwriting the input \"A\", instead of creating a copy. @@ -9395,6 +10615,7 @@ popdisplay(d::Display) ("Base","bkfact","bkfact(A) -> BunchKaufman + Compute the Bunch-Kaufman [Bunch1977] factorization of a real symmetric or complex Hermitian matrix \"A\" and return a \"BunchKaufman\" object. The following functions are available for @@ -9405,6 +10626,7 @@ popdisplay(d::Display) ("Base","bkfact!","bkfact!(A) -> BunchKaufman + \"bkfact!\" is the same as \"bkfact()\", but saves space by overwriting the input \"A\", instead of creating a copy. @@ -9412,6 +10634,7 @@ popdisplay(d::Display) ("Base","sqrtm","sqrtm(A) + Compute the matrix square root of \"A\". If \"B = sqrtm(A)\", then \"B*B == A\" within roundoff error. @@ -9425,7 +10648,9 @@ popdisplay(d::Display) "), -("Base","eig","eig(A,[irange,][vl,][vu,][permute=true,][scale=true]) -> D, V +("Base","eig","eig(A,[irange,][vl,][vu,][permute=true,][scale=true]) +-> D, V + Compute eigenvalues and eigenvectors of \"A\". See \"eigfact()\" for details on the \"balance\" keyword argument. @@ -9447,6 +10672,7 @@ popdisplay(d::Display) ("Base","eig","eig(A, B) -> D, V + Computes generalized eigenvalues and vectors of \"A\" with respect to \"B\". @@ -9458,6 +10684,7 @@ popdisplay(d::Display) ("Base","eigvals","eigvals(A,[irange,][vl,][vu]) + Returns the eigenvalues of \"A\". If \"A\" is \"Symmetric()\", \"Hermitian()\" or \"SymTridiagonal()\", it is possible to calculate only a subset of the eigenvalues by specifying either a @@ -9476,18 +10703,21 @@ popdisplay(d::Display) ("Base","eigmax","eigmax(A) + Returns the largest eigenvalue of \"A\". "), ("Base","eigmin","eigmin(A) + Returns the smallest eigenvalue of \"A\". "), ("Base","eigvecs","eigvecs(A, [eigvals,][permute=true,][scale=true]) + Returns the eigenvectors of \"A\". The \"permute\" and \"scale\" keywords are the same as for \"eigfact()\". @@ -9497,7 +10727,9 @@ popdisplay(d::Display) "), -("Base","eigfact","eigfact(A,[il,][iu,][vl,][vu,][permute=true,][scale=true]) +("Base","eigfact","eigfact(A,[il,][iu,][vl,][vu,][permute=true,][scal +e=true]) + Compute the eigenvalue decomposition of \"A\" and return an \"Eigen\" object. If \"F\" is the factorization object, the @@ -9522,6 +10754,7 @@ popdisplay(d::Display) ("Base","eigfact","eigfact(A, B) + Compute the generalized eigenvalue decomposition of \"A\" and \"B\" and return an \"GeneralizedEigen\" object. If \"F\" is the factorization object, the eigenvalues can be accessed with @@ -9531,6 +10764,7 @@ popdisplay(d::Display) ("Base","eigfact!","eigfact!(A[, B]) + \"eigfact!\" is the same as \"eigfact()\", but saves space by overwriting the input A (and B), instead of creating a copy. @@ -9538,6 +10772,7 @@ popdisplay(d::Display) ("Base","hessfact","hessfact(A) + Compute the Hessenberg decomposition of \"A\" and return a \"Hessenberg\" object. If \"F\" is the factorization object, the unitary matrix can be accessed with \"F[:Q]\" and the Hessenberg @@ -9549,6 +10784,7 @@ popdisplay(d::Display) ("Base","hessfact!","hessfact!(A) + \"hessfact!\" is the same as \"hessfact()\", but saves space by overwriting the input A, instead of creating a copy. @@ -9556,6 +10792,7 @@ popdisplay(d::Display) ("Base","schurfact","schurfact(A) -> Schur + Computes the Schur factorization of the matrix \"A\". The (quasi) triangular Schur factor can be obtained from the \"Schur\" object \"F\" with either \"F[:Schur]\" or \"F[:T]\" and the @@ -9568,6 +10805,7 @@ popdisplay(d::Display) ("Base","schurfact!","schurfact!(A) + Computer the Schur factorization of \"A\", overwriting \"A\" in the process. See \"schurfact()\" @@ -9575,12 +10813,14 @@ popdisplay(d::Display) ("Base","schur","schur(A) -> Schur[:T], Schur[:Z], Schur[:values] + See \"schurfact()\" "), ("Base","schurfact","schurfact(A, B) -> GeneralizedSchur + Computes the Generalized Schur (or QZ) factorization of the matrices \"A\" and \"B\". The (quasi) triangular Schur factors can be obtained from the \"Schur\" object \"F\" with \"F[:S]\" and @@ -9593,7 +10833,9 @@ popdisplay(d::Display) "), -("Base","schur","schur(A, B) -> GeneralizedSchur[:S], GeneralizedSchur[:T], GeneralizedSchur[:Q], GeneralizedSchur[:Z] +("Base","schur","schur(A, B) -> GeneralizedSchur[:S], +GeneralizedSchur[:T], GeneralizedSchur[:Q], GeneralizedSchur[:Z] + See \"schurfact()\" @@ -9601,6 +10843,7 @@ popdisplay(d::Display) ("Base","svdfact","svdfact(A[, thin=true]) -> SVD + Compute the Singular Value Decomposition (SVD) of \"A\" and return an \"SVD\" object. \"U\", \"S\", \"V\" and \"Vt\" can be obtained from the factorization \"F\" with \"F[:U]\", \"F[:S]\", \"F[:V]\" @@ -9613,6 +10856,7 @@ popdisplay(d::Display) ("Base","svdfact!","svdfact!(A[, thin=true]) -> SVD + \"svdfact!\" is the same as \"svdfact()\", but saves space by overwriting the input A, instead of creating a copy. If \"thin\" is \"true\", an economy mode decomposition is returned. The default is @@ -9622,6 +10866,7 @@ popdisplay(d::Display) ("Base","svd","svd(A[, thin=true]) -> U, S, V + Wrapper around \"svdfact\" extracting all parts the factorization to a tuple. Direct use of \"svdfact\" is therefore generally more efficient. Computes the SVD of A, returning \"U\", vector \"S\", @@ -9633,12 +10878,14 @@ popdisplay(d::Display) ("Base","svdvals","svdvals(A) + Returns the singular values of \"A\". "), ("Base","svdvals!","svdvals!(A) + Returns the singular values of \"A\", while saving space by overwriting the input. @@ -9646,6 +10893,7 @@ popdisplay(d::Display) ("Base","svdfact","svdfact(A, B) -> GeneralizedSVD + Compute the generalized SVD of \"A\" and \"B\", returning a \"GeneralizedSVD\" Factorization object \"F\", such that \"A = F[:U]*F[:D1]*F[:R0]*F[:Q]'\" and \"B = @@ -9655,6 +10903,7 @@ popdisplay(d::Display) ("Base","svd","svd(A, B) -> U, V, Q, D1, D2, R0 + Wrapper around \"svdfact\" extracting all parts the factorization to a tuple. Direct use of \"svdfact\" is therefore generally more efficient. The function returns the generalized SVD of \"A\" and @@ -9665,6 +10914,7 @@ popdisplay(d::Display) ("Base","svdvals","svdvals(A, B) + Return only the singular values from the generalized singular value decomposition of \"A\" and \"B\". @@ -9672,30 +10922,35 @@ popdisplay(d::Display) ("Base","triu","triu(M) + Upper triangle of a matrix. "), ("Base","triu!","triu!(M) + Upper triangle of a matrix, overwriting \"M\" in the process. "), ("Base","tril","tril(M) + Lower triangle of a matrix. "), ("Base","tril!","tril!(M) + Lower triangle of a matrix, overwriting \"M\" in the process. "), ("Base","diagind","diagind(M[, k]) + A \"Range\" giving the indices of the \"k\"-th diagonal of the matrix \"M\". @@ -9703,6 +10958,7 @@ popdisplay(d::Display) ("Base","diag","diag(M[, k]) + The \"k\"-th diagonal of a matrix, as a vector. Use \"diagm\" to construct a diagonal matrix. @@ -9710,6 +10966,7 @@ popdisplay(d::Display) ("Base","diagm","diagm(v[, k]) + Construct a diagonal matrix and place \"v\" on the \"k\"-th diagonal. @@ -9717,10 +10974,12 @@ popdisplay(d::Display) ("Base","scale","scale(A, b) + "), ("Base","scale","scale(b, A) + Scale an array \"A\" by a scalar \"b\", returning a new array. If \"A\" is a matrix and \"b\" is a vector, then \"scale(A,b)\" @@ -9736,10 +10995,12 @@ popdisplay(d::Display) ("Base","scale!","scale!(A, b) + "), ("Base","scale!","scale!(b, A) + Scale an array \"A\" by a scalar \"b\", similar to \"scale()\" but overwriting \"A\" in-place. @@ -9753,6 +11014,7 @@ popdisplay(d::Display) ("Base","Tridiagonal","Tridiagonal(dl, d, du) + Construct a tridiagonal matrix from the lower diagonal, diagonal, and upper diagonal, respectively. The result is of type \"Tridiagonal\" and provides efficient specialized linear solvers, @@ -9762,6 +11024,7 @@ popdisplay(d::Display) ("Base","Bidiagonal","Bidiagonal(dv, ev, isupper) + Constructs an upper (\"isupper=true\") or lower (\"isupper=false\") bidiagonal matrix using the given diagonal (\"dv\") and off- diagonal (\"ev\") vectors. The result is of type \"Bidiagonal\" @@ -9772,6 +11035,7 @@ popdisplay(d::Display) ("Base","SymTridiagonal","SymTridiagonal(d, du) + Construct a real symmetric tridiagonal matrix from the diagonal and upper diagonal, respectively. The result is of type \"SymTridiagonal\" and provides efficient specialized eigensolvers, @@ -9781,6 +11045,7 @@ popdisplay(d::Display) ("Base","Woodbury","Woodbury(A, U, C, V) + Construct a matrix in a form suitable for applying the Woodbury matrix identity. @@ -9788,12 +11053,14 @@ popdisplay(d::Display) ("Base","rank","rank(M) + Compute the rank of a matrix. "), ("Base","norm","norm(A[, p]) + Compute the \"p\"-norm of a vector or the operator norm of a matrix \"A\", defaulting to the \"p=2\"-norm. @@ -9810,6 +11077,7 @@ popdisplay(d::Display) ("Base","vecnorm","vecnorm(A[, p]) + For any iterable container \"A\" (including arrays of any dimension) of numbers, compute the \"p\"-norm (defaulting to \"p=2\") as if \"A\" were a vector of the corresponding length. @@ -9821,6 +11089,7 @@ popdisplay(d::Display) ("Base","cond","cond(M[, p]) + Condition number of the matrix \"M\", computed using the operator \"p\"-norm. Valid values for \"p\" are \"1\", \"2\" (default), or \"Inf\". @@ -9829,6 +11098,7 @@ popdisplay(d::Display) ("Base","condskeel","condskeel(M[, x, p]) + \\kappa_S(M, p) & = \\left\\Vert \\left\\vert M \\right\\vert \\left\\vert M^{-1} \\right\\vert \\right\\Vert_p \\\\ \\kappa_S(M, x, p) & = \\left\\Vert \\left\\vert M \\right\\vert @@ -9848,18 +11118,21 @@ popdisplay(d::Display) ("Base","trace","trace(M) + Matrix trace "), ("Base","det","det(M) + Matrix determinant "), ("Base","logdet","logdet(M) + Log of matrix determinant. Equivalent to \"log(det(M))\", but may provide increased accuracy and/or speed. @@ -9867,24 +11140,28 @@ popdisplay(d::Display) ("Base","inv","inv(M) + Matrix inverse "), ("Base","pinv","pinv(M) + Moore-Penrose pseudoinverse "), ("Base","null","null(M) + Basis for nullspace of \"M\". "), ("Base","repmat","repmat(A, n, m) + Construct a matrix by repeating the given matrix \"n\" times in dimension 1 and \"m\" times in dimension 2. @@ -9892,6 +11169,7 @@ popdisplay(d::Display) ("Base","repeat","repeat(A, inner = Int[], outer = Int[]) + Construct an array by repeating the entries of \"A\". The i-th element of \"inner\" specifies the number of times that the individual entries of the i-th dimension of \"A\" should be @@ -9903,12 +11181,14 @@ popdisplay(d::Display) ("Base","kron","kron(A, B) + Kronecker tensor product of two vectors or two matrices. "), ("Base","blkdiag","blkdiag(A...) + Concatenate matrices block-diagonally. Currently only implemented for sparse matrices. @@ -9916,6 +11196,7 @@ popdisplay(d::Display) ("Base","linreg","linreg(x, y) -> [a; b] + Linear Regression. Returns \"a\" and \"b\" such that \"a+b*x\" is the closest line to the given points \"(x,y)\". In other words, this function determines parameters \"[a, b]\" that minimize the @@ -9934,18 +11215,21 @@ popdisplay(d::Display) ("Base","linreg","linreg(x, y, w) + Weighted least-squares linear regression. "), ("Base","expm","expm(A) + Matrix exponential. "), ("Base","lyap","lyap(A, C) + Computes the solution \"X\" to the continuous Lyapunov equation \"AX + XA' + C = 0\", where no eigenvalue of \"A\" has a zero real part and no two eigenvalues are negative complex conjugates of each @@ -9955,6 +11239,7 @@ popdisplay(d::Display) ("Base","sylvester","sylvester(A, B, C) + Computes the solution \"X\" to the Sylvester equation \"AX + XB + C = 0\", where \"A\", \"B\" and \"C\" have compatible dimensions and \"A\" and \"-B\" have no eigenvalues with equal real part. @@ -9963,18 +11248,21 @@ popdisplay(d::Display) ("Base","issym","issym(A) -> Bool + Test whether a matrix is symmetric. "), ("Base","isposdef","isposdef(A) -> Bool + Test whether a matrix is positive definite. "), ("Base","isposdef!","isposdef!(A) -> Bool + Test whether a matrix is positive definite, overwriting \"A\" in the processes. @@ -9982,35 +11270,43 @@ popdisplay(d::Display) ("Base","istril","istril(A) -> Bool + Test whether a matrix is lower triangular. "), ("Base","istriu","istriu(A) -> Bool + Test whether a matrix is upper triangular. "), ("Base","ishermitian","ishermitian(A) -> Bool + Test whether a matrix is Hermitian. "), ("Base","transpose","transpose(A) + The transposition operator (\".'\"). "), ("Base","ctranspose","ctranspose(A) + The conjugate transposition operator (\"'\"). "), -("Base","eigs","eigs(A[, B], ; nev=6, which=\"LM\", tol=0.0, maxiter=1000, sigma=nothing, ritzvec=true, v0=zeros((0, ))) -> (d[, v], nconv, niter, nmult, resid) +("Base","eigs","eigs(A[, B], ; nev=6, which=\"LM\", tol=0.0, +maxiter=1000, sigma=nothing, ritzvec=true, v0=zeros((0, ))) -> (d[, +v], nconv, niter, nmult, resid) + \"eigs\" computes eigenvalues \"d\" of \"A\" using Lanczos or Arnoldi iterations for real symmetric or general nonsymmetric @@ -10023,7 +11319,8 @@ popdisplay(d::Display) problems and \"nev+2 <= ncv <= n\" for other problems; default is \"ncv = max(20,2*nev+1)\". - * \"which\": type of eigenvalues to compute. See the note below. + * \"which\": type of eigenvalues to compute. See the note + below. +-----------+-----------------------------------------------------------------------------------------------------------------------------+ | \\\"which\\\" | type of eigenvalues | @@ -10053,8 +11350,8 @@ popdisplay(d::Display) (forward) iterations. Otherwise, find eigenvalues close to \"sigma\" using shift and invert iterations. - * \"ritzvec\": Returns the Ritz vectors \"v\" (eigenvectors) if - \"true\" + * \"ritzvec\": Returns the Ritz vectors \"v\" (eigenvectors) + if \"true\" * \"v0\": starting vector from which to start the iterations @@ -10064,11 +11361,11 @@ popdisplay(d::Display) \"niter\" and the number of matrix vector multiplications \"nmult\", as well as the final residual vector \"resid\". - Note: The \"sigma\" and \"which\" keywords interact: the description of - eigenvalues searched for by \"which\" do _not_ necessarily refer - to the eigenvalues of \"A\", but rather the linear operator - constructed by the specification of the iteration mode implied by - \"sigma\". + Note: The \"sigma\" and \"which\" keywords interact: the + description of eigenvalues searched for by \"which\" do _not_ + necessarily refer to the eigenvalues of \"A\", but rather the + linear operator constructed by the specification of the iteration + mode implied by \"sigma\". +-----------------+------------------------------------+------------------------------------+ | \\\"sigma\\\" | iteration mode | \\\"which\\\" refers to eigenvalues of | @@ -10082,6 +11379,7 @@ popdisplay(d::Display) ("Base","peakflops","peakflops(n; parallel=false) + \"peakflops\" computes the peak flop rate of the computer by using BLAS double precision \"gemm!()\". By default, if no arguments are specified, it multiplies a matrix of size \"n x n\", where \"n = @@ -10099,6 +11397,7 @@ popdisplay(d::Display) ("Base.LinAlg.BLAS","dot","dot(n, X, incx, Y, incy) + Dot product of two vectors consisting of \"n\" elements of array \"X\" with stride \"incx\" and \"n\" elements of array \"Y\" with stride \"incy\". @@ -10107,18 +11406,21 @@ popdisplay(d::Display) ("Base.LinAlg.BLAS","dotu","dotu(n, X, incx, Y, incy) + Dot function for two complex vectors. "), ("Base.LinAlg.BLAS","dotc","dotc(n, X, incx, U, incy) + Dot function for two complex vectors conjugating the first vector. "), ("Base.LinAlg.BLAS","blascopy!","blascopy!(n, X, incx, Y, incy) + Copy \"n\" elements of array \"X\" with stride \"incx\" to array \"Y\" with stride \"incy\". Returns \"Y\". @@ -10126,6 +11428,7 @@ popdisplay(d::Display) ("Base.LinAlg.BLAS","nrm2","nrm2(n, X, incx) + 2-norm of a vector consisting of \"n\" elements of array \"X\" with stride \"incx\". @@ -10133,6 +11436,7 @@ popdisplay(d::Display) ("Base.LinAlg.BLAS","asum","asum(n, X, incx) + sum of the absolute values of the first \"n\" elements of array \"X\" with stride \"incx\". @@ -10140,24 +11444,28 @@ popdisplay(d::Display) ("Base.LinAlg.BLAS","axpy!","axpy!(n, a, X, incx, Y, incy) + Overwrite \"Y\" with \"a*X + Y\". Returns \"Y\". "), ("Base.LinAlg.BLAS","scal!","scal!(n, a, X, incx) + Overwrite \"X\" with \"a*X\". Returns \"X\". "), ("Base.LinAlg.BLAS","scal","scal(n, a, X, incx) + Returns \"a*X\". "), ("Base.LinAlg.BLAS","syrk!","syrk!(uplo, trans, alpha, A, beta, C) + Rank-k update of the symmetric matrix \"C\" as \"alpha*A*A.' + beta*C\" or \"alpha*A.'*A + beta*C\" according to whether \"trans\" is 'N' or 'T'. When \"uplo\" is 'U' the upper triangle of \"C\" is @@ -10167,6 +11475,7 @@ popdisplay(d::Display) ("Base.LinAlg.BLAS","syrk","syrk(uplo, trans, alpha, A) + Returns either the upper triangle or the lower triangle, according to \"uplo\" ('U' or 'L'), of \"alpha*A*A.'\" or \"alpha*A.'*A\", according to \"trans\" ('N' or 'T'). @@ -10175,6 +11484,7 @@ popdisplay(d::Display) ("Base.LinAlg.BLAS","herk!","herk!(uplo, trans, alpha, A, beta, C) + Methods for complex arrays only. Rank-k update of the Hermitian matrix \"C\" as \"alpha*A*A' + beta*C\" or \"alpha*A'*A + beta*C\" according to whether \"trans\" is 'N' or 'T'. When \"uplo\" is 'U' @@ -10185,6 +11495,7 @@ popdisplay(d::Display) ("Base.LinAlg.BLAS","herk","herk(uplo, trans, alpha, A) + Methods for complex arrays only. Returns either the upper triangle or the lower triangle, according to \"uplo\" ('U' or 'L'), of \"alpha*A*A'\" or \"alpha*A'*A\", according to \"trans\" ('N' or @@ -10192,7 +11503,9 @@ popdisplay(d::Display) "), -("Base.LinAlg.BLAS","gbmv!","gbmv!(trans, m, kl, ku, alpha, A, x, beta, y) +("Base.LinAlg.BLAS","gbmv!","gbmv!(trans, m, kl, ku, alpha, A, x, +beta, y) + Update vector \"y\" as \"alpha*A*x + beta*y\" or \"alpha*A'*x + beta*y\" according to \"trans\" ('N' or 'T'). The matrix \"A\" is @@ -10202,7 +11515,9 @@ popdisplay(d::Display) "), -("Base.LinAlg.BLAS","gbmv","gbmv(trans, m, kl, ku, alpha, A, x, beta, y) +("Base.LinAlg.BLAS","gbmv","gbmv(trans, m, kl, ku, alpha, A, x, beta, +y) + Returns \"alpha*A*x\" or \"alpha*A'*x\" according to \"trans\" ('N' or 'T'). The matrix \"A\" is a general band matrix of dimension @@ -10213,6 +11528,7 @@ popdisplay(d::Display) ("Base.LinAlg.BLAS","sbmv!","sbmv!(uplo, k, alpha, A, x, beta, y) + Update vector \"y\" as \"alpha*A*x + beta*y\" where \"A\" is a a symmetric band matrix of order \"size(A,2)\" with \"k\" super- diagonals stored in the argument \"A\". The storage layout for @@ -10225,6 +11541,7 @@ popdisplay(d::Display) ("Base.LinAlg.BLAS","sbmv","sbmv(uplo, k, alpha, A, x) + Returns \"alpha*A*x\" where \"A\" is a symmetric band matrix of order \"size(A,2)\" with \"k\" super-diagonals stored in the argument \"A\". @@ -10233,6 +11550,7 @@ popdisplay(d::Display) ("Base.LinAlg.BLAS","sbmv","sbmv(uplo, k, A, x) + Returns \"A*x\" where \"A\" is a symmetric band matrix of order \"size(A,2)\" with \"k\" super-diagonals stored in the argument \"A\". @@ -10241,6 +11559,7 @@ popdisplay(d::Display) ("Base.LinAlg.BLAS","gemm!","gemm!(tA, tB, alpha, A, B, beta, C) + Update \"C\" as \"alpha*A*B + beta*C\" or the other three variants according to \"tA\" (transpose \"A\") and \"tB\". Returns the updated \"C\". @@ -10249,6 +11568,7 @@ popdisplay(d::Display) ("Base.LinAlg.BLAS","gemm","gemm(tA, tB, alpha, A, B) + Returns \"alpha*A*B\" or the other three variants according to \"tA\" (transpose \"A\") and \"tB\". @@ -10256,6 +11576,7 @@ popdisplay(d::Display) ("Base.LinAlg.BLAS","gemm","gemm(tA, tB, A, B) + Returns \"A*B\" or the other three variants according to \"tA\" (transpose \"A\") and \"tB\". @@ -10263,6 +11584,7 @@ popdisplay(d::Display) ("Base.LinAlg.BLAS","gemv!","gemv!(tA, alpha, A, x, beta, y) + Update the vector \"y\" as \"alpha*A*x + beta*x\" or \"alpha*A'x + beta*x\" according to \"tA\" (transpose \"A\"). Returns the updated \"y\". @@ -10271,6 +11593,7 @@ popdisplay(d::Display) ("Base.LinAlg.BLAS","gemv","gemv(tA, alpha, A, x) + Returns \"alpha*A*x\" or \"alpha*A'x\" according to \"tA\" (transpose \"A\"). @@ -10278,12 +11601,14 @@ popdisplay(d::Display) ("Base.LinAlg.BLAS","gemv","gemv(tA, A, x) + Returns \"A*x\" or \"A'x\" according to \"tA\" (transpose \"A\"). "), ("Base.LinAlg.BLAS","symm!","symm!(side, ul, alpha, A, B, beta, C) + Update \"C\" as \"alpha*A*B + beta*C\" or \"alpha*B*A + beta*C\" according to \"side\". \"A\" is assumed to be symmetric. Only the \"ul\" triangle of \"A\" is used. Returns the updated \"C\". @@ -10292,6 +11617,7 @@ popdisplay(d::Display) ("Base.LinAlg.BLAS","symm","symm(side, ul, alpha, A, B) + Returns \"alpha*A*B\" or \"alpha*B*A\" according to \"side\". \"A\" is assumed to be symmetric. Only the \"ul\" triangle of \"A\" is used. @@ -10300,6 +11626,7 @@ popdisplay(d::Display) ("Base.LinAlg.BLAS","symm","symm(side, ul, A, B) + Returns \"A*B\" or \"B*A\" according to \"side\". \"A\" is assumed to be symmetric. Only the \"ul\" triangle of \"A\" is used. @@ -10307,6 +11634,7 @@ popdisplay(d::Display) ("Base.LinAlg.BLAS","symm","symm(tA, tB, alpha, A, B) + Returns \"alpha*A*B\" or the other three variants according to \"tA\" (transpose \"A\") and \"tB\". @@ -10314,6 +11642,7 @@ popdisplay(d::Display) ("Base.LinAlg.BLAS","symv!","symv!(ul, alpha, A, x, beta, y) + Update the vector \"y\" as \"alpha*A*y + beta*y\". \"A\" is assumed to be symmetric. Only the \"ul\" triangle of \"A\" is used. Returns the updated \"y\". @@ -10322,6 +11651,7 @@ popdisplay(d::Display) ("Base.LinAlg.BLAS","symv","symv(ul, alpha, A, x) + Returns \"alpha*A*x\". \"A\" is assumed to be symmetric. Only the \"ul\" triangle of \"A\" is used. @@ -10329,6 +11659,7 @@ popdisplay(d::Display) ("Base.LinAlg.BLAS","symv","symv(ul, A, x) + Returns \"A*x\". \"A\" is assumed to be symmetric. Only the \"ul\" triangle of \"A\" is used. @@ -10336,6 +11667,7 @@ popdisplay(d::Display) ("Base.LinAlg.BLAS","trmm!","trmm!(side, ul, tA, dA, alpha, A, B) + Update \"B\" as \"alpha*A*B\" or one of the other three variants determined by \"side\" (A on left or right) and \"tA\" (transpose A). Only the \"ul\" triangle of \"A\" is used. \"dA\" indicates if @@ -10346,6 +11678,7 @@ popdisplay(d::Display) ("Base.LinAlg.BLAS","trmm","trmm(side, ul, tA, dA, alpha, A, B) + Returns \"alpha*A*B\" or one of the other three variants determined by \"side\" (A on left or right) and \"tA\" (transpose A). Only the \"ul\" triangle of \"A\" is used. \"dA\" indicates if \"A\" is @@ -10355,6 +11688,7 @@ popdisplay(d::Display) ("Base.LinAlg.BLAS","trsm!","trsm!(side, ul, tA, dA, alpha, A, B) + Overwrite \"B\" with the solution to \"A*X = alpha*B\" or one of the other three variants determined by \"side\" (A on left or right of \"X\") and \"tA\" (transpose A). Only the \"ul\" triangle of @@ -10365,6 +11699,7 @@ popdisplay(d::Display) ("Base.LinAlg.BLAS","trsm","trsm(side, ul, tA, dA, alpha, A, B) + Returns the solution to \"A*X = alpha*B\" or one of the other three variants determined by \"side\" (A on left or right of \"X\") and \"tA\" (transpose A). Only the \"ul\" triangle of \"A\" is used. @@ -10375,6 +11710,7 @@ popdisplay(d::Display) ("Base.LinAlg.BLAS","trmv!","trmv!(side, ul, tA, dA, alpha, A, b) + Update \"b\" as \"alpha*A*b\" or one of the other three variants determined by \"side\" (A on left or right) and \"tA\" (transpose A). Only the \"ul\" triangle of \"A\" is used. \"dA\" indicates if @@ -10385,6 +11721,7 @@ popdisplay(d::Display) ("Base.LinAlg.BLAS","trmv","trmv(side, ul, tA, dA, alpha, A, b) + Returns \"alpha*A*b\" or one of the other three variants determined by \"side\" (A on left or right) and \"tA\" (transpose A). Only the \"ul\" triangle of \"A\" is used. \"dA\" indicates if \"A\" is @@ -10394,6 +11731,7 @@ popdisplay(d::Display) ("Base.LinAlg.BLAS","trsv!","trsv!(side, ul, tA, dA, alpha, A, b) + Overwrite \"b\" with the solution to \"A*X = alpha*b\" or one of the other three variants determined by \"side\" (A on left or right of \"X\") and \"tA\" (transpose A). Only the \"ul\" triangle of @@ -10404,6 +11742,7 @@ popdisplay(d::Display) ("Base.LinAlg.BLAS","trsv","trsv(side, ul, tA, dA, alpha, A, b) + Returns the solution to \"A*X = alpha*b\" or one of the other three variants determined by \"side\" (A on left or right of \"X\") and \"tA\" (transpose A). Only the \"ul\" triangle of \"A\" is used. @@ -10414,12 +11753,14 @@ popdisplay(d::Display) ("Base.LinAlg.BLAS","blas_set_num_threads","blas_set_num_threads(n) + Set the number of threads the BLAS library should use. "), ("Base.Pkg","dir","dir() -> String + Returns the absolute path of the package directory. This defaults to \"joinpath(homedir(),\".julia\")\" on all platforms (i.e. \"~/.julia\" in UNIX shell syntax). If the \"JULIA_PKGDIR\" @@ -10431,6 +11772,7 @@ popdisplay(d::Display) ("Base.Pkg","dir","dir(names...) -> String + Equivalent to \"normpath(Pkg.dir(),names...)\" – i.e. it appends path components to the package directory and normalizes the resulting path. In particular, \"Pkg.dir(pkg)\" returns the path to @@ -10440,6 +11782,7 @@ popdisplay(d::Display) ("Base.Pkg","init","init() + Initialize \"Pkg.dir()\" as a package directory. This will be done automatically when the \"JULIA_PKGDIR\" is not set and \"Pkg.dir()\" uses its default value. @@ -10448,6 +11791,7 @@ popdisplay(d::Display) ("Base.Pkg","resolve","resolve() + Determines an optimal, consistent set of package versions to install or upgrade to. The optimal set of package versions is based on the contents of \"Pkg.dir(\"REQUIRE\")\" and the state of @@ -10458,6 +11802,7 @@ popdisplay(d::Display) ("Base.Pkg","edit","edit() + Opens \"Pkg.dir(\"REQUIRE\")\" in the editor specified by the \"VISUAL\" or \"EDITOR\" environment variables; when the editor command returns, it runs \"Pkg.resolve()\" to determine and install @@ -10467,6 +11812,7 @@ popdisplay(d::Display) ("Base.Pkg","add","add(pkg, vers...) + Add a requirement entry for \"pkg\" to \"Pkg.dir(\"REQUIRE\")\" and call \"Pkg.resolve()\". If \"vers\" are given, they must be \"VersionNumber\" objects and they specify acceptable version @@ -10476,6 +11822,7 @@ popdisplay(d::Display) ("Base.Pkg","rm","rm(pkg) + Remove all requirement entries for \"pkg\" from \"Pkg.dir(\"REQUIRE\")\" and call \"Pkg.resolve()\". @@ -10483,6 +11830,7 @@ popdisplay(d::Display) ("Base.Pkg","clone","clone(url[, pkg]) + Clone a package directly from the git URL \"url\". The package does not need to be a registered in \"Pkg.dir(\"METADATA\")\". The package repo is cloned by the name \"pkg\" if provided; if not @@ -10492,6 +11840,7 @@ popdisplay(d::Display) ("Base.Pkg","clone","clone(pkg) + If \"pkg\" has a URL registered in \"Pkg.dir(\"METADATA\")\", clone it from that URL on the default branch. The package does not need to have any registered versions. @@ -10500,17 +11849,21 @@ popdisplay(d::Display) ("Base.Pkg","available","available() -> Vector{ASCIIString} + Returns the names of available packages. "), ("Base.Pkg","available","available(pkg) -> Vector{VersionNumber} + Returns the version numbers available for package \"pkg\". "), -("Base.Pkg","installed","installed() -> Dict{ASCIIString,VersionNumber} +("Base.Pkg","installed","installed() -> +Dict{ASCIIString,VersionNumber} + Returns a dictionary mapping installed package names to the installed version number of each package. @@ -10519,6 +11872,7 @@ popdisplay(d::Display) ("Base.Pkg","installed","installed(pkg) -> Nothing | VersionNumber + If \"pkg\" is installed, return the installed version number, otherwise return \"nothing\". @@ -10526,6 +11880,7 @@ popdisplay(d::Display) ("Base.Pkg","status","status() + Prints out a summary of what packages are installed and what version and state they're in. @@ -10533,6 +11888,7 @@ popdisplay(d::Display) ("Base.Pkg","update","update() + Update package the metadata repo – kept in \"Pkg.dir(\"METADATA\")\" – then update any fixed packages that can safely be pulled from their origin; then call \"Pkg.resolve()\" to @@ -10542,6 +11898,7 @@ popdisplay(d::Display) ("Base.Pkg","checkout","checkout(pkg[, branch=\"master\"]) + Checkout the \"Pkg.dir(pkg)\" repo to the branch \"branch\". Defaults to checking out the \"master\" branch. To go back to using the newest compatible released version, use \"Pkg.free(pkg)\" @@ -10550,6 +11907,7 @@ popdisplay(d::Display) ("Base.Pkg","pin","pin(pkg) + Pin \"pkg\" at the current version. To go back to using the newest compatible released version, use \"Pkg.free(pkg)\" @@ -10557,12 +11915,14 @@ popdisplay(d::Display) ("Base.Pkg","pin","pin(pkg, version) + Pin \"pkg\" at registered version \"version\". "), ("Base.Pkg","free","free(pkg) + Free the package \"pkg\" to be managed by the package manager again. It calls \"Pkg.resolve()\" to determine optimal package versions after. This is an inverse for both \"Pkg.checkout\" and @@ -10572,6 +11932,7 @@ popdisplay(d::Display) ("Base.Pkg","build","build() + Run the build scripts for all installed packages in depth-first recursive order. @@ -10579,6 +11940,7 @@ popdisplay(d::Display) ("Base.Pkg","build","build(pkgs...) + Run the build script in \"deps/build.jl\" for each package in \"pkgs\" and all of their dependencies in depth-first recursive order. This is called automatically by \"Pkg.resolve()\" on all @@ -10588,6 +11950,7 @@ popdisplay(d::Display) ("Base.Pkg","generate","generate(pkg, license) + Generate a new package named \"pkg\" with one of these license keys: \"\"MIT\"\" or \"\"BSD\"\". If you want to make a package with a different license, you can edit it afterwards. Generate @@ -10599,6 +11962,7 @@ popdisplay(d::Display) ("Base.Pkg","register","register(pkg[, url]) + Register \"pkg\" at the git URL \"url\", defaulting to the configured origin URL of the git repo \"Pkg.dir(pkg)\". @@ -10606,6 +11970,7 @@ popdisplay(d::Display) ("Base.Pkg","tag","tag(pkg[, ver[, commit]]) + Tag \"commit\" as version \"ver\" of package \"pkg\" and create a version entry in \"METADATA\". If not provided, \"commit\" defaults to the current commit of the \"pkg\" repo. If \"ver\" is one of the @@ -10617,6 +11982,7 @@ popdisplay(d::Display) ("Base.Pkg","publish","publish() + For each new package version tagged in \"METADATA\" not already published, make sure that the tagged package commits have been pushed to the repo at the registered URL for the package and if @@ -10626,6 +11992,7 @@ popdisplay(d::Display) ("Base.Pkg","test","test() + Run the tests for all installed packages ensuring that each package's test dependencies are installed for the duration of the test. A package is tested by running its \"test/runtests.jl\" file @@ -10635,6 +12002,7 @@ popdisplay(d::Display) ("Base.Pkg","test","test(pkgs...) + Run the tests for each package in \"pkgs\" ensuring that each package's test dependencies are installed for the duration of the test. A package is tested by running its \"test/runtests.jl\" file @@ -10644,6 +12012,7 @@ popdisplay(d::Display) ("Base","@profile","@profile() + \"@profile \" runs your expression while taking periodic backtraces. These are appended to an internal buffer of backtraces. @@ -10652,11 +12021,14 @@ popdisplay(d::Display) ("Base.Profile","clear","clear() + Clear any existing backtraces from the internal buffer. "), -("Base.Profile","print","print([io::IO = STDOUT], [data::Vector]; format = :tree, C = false, combine = true, cols = tty_cols()) +("Base.Profile","print","print([io::IO = STDOUT], [data::Vector]; +format = :tree, C = false, combine = true, cols = tty_cols()) + Prints profiling results to \"io\" (by default, \"STDOUT\"). If you do not supply a \"data\" vector, the internal buffer of accumulated @@ -10667,7 +12039,9 @@ popdisplay(d::Display) "), -("Base.Profile","print","print([io::IO = STDOUT], data::Vector, lidict::Dict; format = :tree, combine = true, cols = tty_cols()) +("Base.Profile","print","print([io::IO = STDOUT], data::Vector, +lidict::Dict; format = :tree, combine = true, cols = tty_cols()) + Prints profiling results to \"io\". This variant is used to examine results exported by a previous call to \"Profile.retrieve()\". @@ -10678,6 +12052,7 @@ popdisplay(d::Display) ("Base.Profile","init","init(; n::Integer, delay::Float64) + Configure the \"delay\" between backtraces (measured in seconds), and the number \"n\" of instruction pointers that may be stored. Each instruction pointer corresponds to a single line of code; @@ -10690,6 +12065,7 @@ popdisplay(d::Display) ("Base.Profile","fetch","fetch() -> data + Returns a reference to the internal buffer of backtraces. Note that subsequent operations, like \"Profile.clear()\", can affect \"data\" unless you first make a copy. Note that the values in @@ -10702,6 +12078,7 @@ popdisplay(d::Display) ("Base.Profile","retrieve","retrieve() -> data, lidict + \"Exports\" profiling results in a portable format, returning the set of all backtraces (\"data\") and a dictionary that maps the (session-specific) instruction pointers in \"data\" to \"LineInfo\" @@ -10712,7 +12089,9 @@ popdisplay(d::Display) "), -("Base","sort!","sort!(v, [alg=,] [by=,] [lt=,] [rev=false]) +("Base","sort!","sort!(v, [alg=,] [by=,] +[lt=,] [rev=false]) + Sort the vector \"v\" in place. \"QuickSort\" is used by default for numeric arrays while \"MergeSort\" is used for other arrays. @@ -10729,20 +12108,26 @@ popdisplay(d::Display) "), -("Base","sort","sort(v, [alg=,] [by=,] [lt=,] [rev=false]) +("Base","sort","sort(v, [alg=,] [by=,] +[lt=,] [rev=false]) + Variant of \"sort!\" that returns a sorted copy of \"v\" leaving \"v\" itself unmodified. "), -("Base","sort","sort(A, dim, [alg=,] [by=,] [lt=,] [rev=false]) +("Base","sort","sort(A, dim, [alg=,] [by=,] +[lt=,] [rev=false]) + Sort a multidimensional array \"A\" along the given dimension. "), -("Base","sortperm","sortperm(v, [alg=,] [by=,] [lt=,] [rev=false]) +("Base","sortperm","sortperm(v, [alg=,] [by=,] +[lt=,] [rev=false]) + Return a permutation vector of indices of \"v\" that puts it in sorted order. Specify \"alg\" to choose a particular sorting @@ -10757,19 +12142,25 @@ popdisplay(d::Display) "), -("Base","sortrows","sortrows(A, [alg=,] [by=,] [lt=,] [rev=false]) +("Base","sortrows","sortrows(A, [alg=,] [by=,] +[lt=,] [rev=false]) + Sort the rows of matrix \"A\" lexicographically. "), -("Base","sortcols","sortcols(A, [alg=,] [by=,] [lt=,] [rev=false]) +("Base","sortcols","sortcols(A, [alg=,] [by=,] +[lt=,] [rev=false]) + Sort the columns of matrix \"A\" lexicographically. "), -("Base","issorted","issorted(v, [by=,] [lt=,] [rev=false]) +("Base","issorted","issorted(v, [by=,] [lt=,] +[rev=false]) + Test whether a vector is in sorted order. The \"by\", \"lt\" and \"rev\" keywords modify what order is considered to be sorted just @@ -10777,7 +12168,9 @@ popdisplay(d::Display) "), -("Base","searchsorted","searchsorted(a, x, [by=,] [lt=,] [rev=false]) +("Base","searchsorted","searchsorted(a, x, [by=,] +[lt=,] [rev=false]) + Returns the range of indices of \"a\" which compare as equal to \"x\" according to the order specified by the \"by\", \"lt\" and @@ -10787,7 +12180,9 @@ popdisplay(d::Display) "), -("Base","searchsortedfirst","searchsortedfirst(a, x, [by=,] [lt=,] [rev=false]) +("Base","searchsortedfirst","searchsortedfirst(a, x, [by=,] +[lt=,] [rev=false]) + Returns the index of the first value in \"a\" greater than or equal to \"x\", according to the specified order. Returns \"length(a)+1\" @@ -10795,7 +12190,9 @@ popdisplay(d::Display) "), -("Base","searchsortedlast","searchsortedlast(a, x, [by=,] [lt=,] [rev=false]) +("Base","searchsortedlast","searchsortedlast(a, x, [by=,] +[lt=,] [rev=false]) + Returns the index of the last value in \"a\" less than or equal to \"x\", according to the specified order. Returns \"0\" if \"x\" is @@ -10803,7 +12200,9 @@ popdisplay(d::Display) "), -("Base","select!","select!(v, k, [by=,] [lt=,] [rev=false]) +("Base","select!","select!(v, k, [by=,] [lt=,] +[rev=false]) + Partially sort the vector \"v\" in place, according to the order specified by \"by\", \"lt\" and \"rev\" so that the value at index @@ -10817,7 +12216,9 @@ popdisplay(d::Display) "), -("Base","select","select(v, k, [by=,] [lt=,] [rev=false]) +("Base","select","select(v, k, [by=,] [lt=,] +[rev=false]) + Variant of \"select!\" which copies \"v\" before partially sorting it, thereby returning the same thing as \"select!\" but leaving @@ -10827,6 +12228,7 @@ popdisplay(d::Display) ("Base","sparse","sparse(I, J, V[, m, n, combine]) + Create a sparse matrix \"S\" of dimensions \"m x n\" such that \"S[I[k], J[k]] = V[k]\". The \"combine\" function is used to combine duplicates. If \"m\" and \"n\" are not specified, they are @@ -10837,6 +12239,7 @@ popdisplay(d::Display) ("Base","sparsevec","sparsevec(I, V[, m, combine]) + Create a sparse matrix \"S\" of size \"m x 1\" such that \"S[I[k]] = V[k]\". Duplicates are combined using the \"combine\" function, which defaults to \"+\" if it is not provided. In julia, sparse @@ -10849,6 +12252,7 @@ popdisplay(d::Display) ("Base","sparsevec","sparsevec(D::Dict[, m]) + Create a sparse matrix of size \"m x 1\" where the row values are keys from the dictionary, and the nonzero values are the values from the dictionary. @@ -10857,18 +12261,21 @@ popdisplay(d::Display) ("Base","issparse","issparse(S) + Returns \"true\" if \"S\" is sparse, and \"false\" otherwise. "), ("Base","sparse","sparse(A) + Convert a dense matrix \"A\" into a sparse matrix. "), ("Base","sparsevec","sparsevec(A) + Convert a dense vector \"A\" into a sparse matrix of size \"m x 1\". In julia, sparse vectors are really just sparse matrices with one column. @@ -10877,24 +12284,28 @@ popdisplay(d::Display) ("Base","full","full(S) + Convert a sparse matrix \"S\" into a dense matrix. "), ("Base","nnz","nnz(A) + Returns the number of stored (filled) elements in a sparse matrix. "), ("Base","spzeros","spzeros(m, n) + Create an empty sparse matrix of size \"m x n\". "), ("Base","spones","spones(S) + Create a sparse matrix with the same structure as that of \"S\", but with every nonzero element having the value \"1.0\". @@ -10902,6 +12313,7 @@ popdisplay(d::Display) ("Base","speye","speye(type, m[, n]) + Create a sparse identity matrix of specified type of size \"m x m\". In case \"n\" is supplied, create a sparse identity matrix of size \"m x n\". @@ -10910,6 +12322,7 @@ popdisplay(d::Display) ("Base","spdiagm","spdiagm(B, d[, m, n]) + Construct a sparse diagonal matrix. \"B\" is a tuple of vectors containing the diagonals and \"d\" is a tuple containing the positions of the diagonals. In the case the input contains only one @@ -10922,6 +12335,7 @@ popdisplay(d::Display) ("Base","sprand","sprand(m, n, p[, rng]) + Create a random \"m\" by \"n\" sparse matrix, in which the probability of any element being nonzero is independently given by \"p\" (and hence the mean density of nonzeros is also exactly @@ -10933,6 +12347,7 @@ popdisplay(d::Display) ("Base","sprandn","sprandn(m, n, p) + Create a random \"m\" by \"n\" sparse matrix with the specified (independent) probability \"p\" of any entry being nonzero, where nonzero values are sampled from the normal distribution. @@ -10941,6 +12356,7 @@ popdisplay(d::Display) ("Base","sprandbool","sprandbool(m, n, p) + Create a random \"m\" by \"n\" sparse boolean matrix with the specified (independent) probability \"p\" of any entry being \"true\". @@ -10949,6 +12365,7 @@ popdisplay(d::Display) ("Base","etree","etree(A[, post]) + Compute the elimination tree of a symmetric sparse matrix \"A\" from \"triu(A)\" and, optionally, its post-ordering permutation. @@ -10956,6 +12373,7 @@ popdisplay(d::Display) ("Base","symperm","symperm(A, p) + Return the symmetric permutation of A, which is \"A[p,p]\". A should be symmetric and sparse, where only the upper triangular part of the matrix is stored. This algorithm ignores the lower @@ -10966,6 +12384,7 @@ popdisplay(d::Display) ("Base","nonzeros","nonzeros(A) + Return a vector of the structural nonzero values in sparse matrix \"A\". This includes zeros that are explicitly stored in the sparse matrix. The returned vector points directly to the internal nonzero @@ -10976,6 +12395,7 @@ popdisplay(d::Display) ("Base.Test","@test","@test(ex) + Test the expression \"ex\" and calls the current handler to handle the result. @@ -10983,6 +12403,7 @@ popdisplay(d::Display) ("Base.Test","@test_throws","@test_throws(extype, ex) + Test that the expression \"ex\" throws an exception of type \"extype\" and calls the current handler to handle the result. @@ -10990,6 +12411,7 @@ popdisplay(d::Display) ("Base.Test","@test_approx_eq","@test_approx_eq(a, b) + Test two floating point numbers \"a\" and \"b\" for equality taking in account small numerical errors. @@ -10997,6 +12419,7 @@ popdisplay(d::Display) ("Base.Test","@test_approx_eq_eps","@test_approx_eq_eps(a, b, tol) + Test two floating point numbers \"a\" and \"b\" for equality taking in account a margin of tolerance given by \"tol\". @@ -11004,6 +12427,7 @@ popdisplay(d::Display) ("Base.Test","with_handler","with_handler(f, handler) + Run the function \"f\" using the \"handler\" as the handler. "), diff --git a/doc/juliadoc b/doc/juliadoc index 91ca0bf6cfbd5..bab3c6ba9e613 160000 --- a/doc/juliadoc +++ b/doc/juliadoc @@ -1 +1 @@ -Subproject commit 91ca0bf6cfbd5a06b202accd54928fb7e059a854 +Subproject commit bab3c6ba9e613da94001e1d71f994143814a1422 diff --git a/doc/manual/strings.rst b/doc/manual/strings.rst index 82ea959a3ad32..3e2c4e78012a3 100644 --- a/doc/manual/strings.rst +++ b/doc/manual/strings.rst @@ -239,9 +239,11 @@ Using an index less than 1 or greater than ``end`` raises an error: julia> str[0] ERROR: BoundsError() + in getindex at /Users/sabae/src/julia/usr/lib/julia/sys.dylib (repeats 2 times) julia> str[end+1] ERROR: BoundsError() + in getindex at /Users/sabae/src/julia/usr/lib/julia/sys.dylib (repeats 2 times) You can also extract a substring using range indexing: