From cdc63f3b12b7bdd2b83e0b847777e13f12027489 Mon Sep 17 00:00:00 2001 From: Stefan Karpinski Date: Tue, 19 Mar 2013 16:09:37 -0400 Subject: [PATCH 1/2] Pkg: finally reproduce and fix long-standing Pkg.update() bug. This is the isless issue that people have periodically encountered. --- base/pkg.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/base/pkg.jl b/base/pkg.jl index c0406487b286c..6a81ac1db022a 100644 --- a/base/pkg.jl +++ b/base/pkg.jl @@ -321,7 +321,7 @@ function _resolve() if have[pkg] != want[pkg] oldver = Metadata.version(pkg,have[pkg]) newver = Metadata.version(pkg,want[pkg]) - up = oldver <= newver ? "Up" : "Down" + up = !is(oldver,VersionNumber) || !is(newver,VersionNumber) || oldver <= newver ? "Up" : "Down" info("$(up)grading $pkg: v$oldver => v$newver") cd(pkg) do run(`git checkout -q $(want[pkg])`) From 69edec172ef0644d909edf5f95e2846da5d3d761 Mon Sep 17 00:00:00 2001 From: Stefan Karpinski Date: Tue, 19 Mar 2013 17:13:24 -0400 Subject: [PATCH 2/2] update helpdb.jl --- doc/helpdb.jl | 1874 +++++++++++++++++++++++++------------------------ 1 file changed, 960 insertions(+), 914 deletions(-) diff --git a/doc/helpdb.jl b/doc/helpdb.jl index 8b89a3604126b..b2fde64c019d1 100644 --- a/doc/helpdb.jl +++ b/doc/helpdb.jl @@ -2590,7 +2590,9 @@ ("Data Formats","Base","base","base(b, n[, pad]) Convert an integer to a string in the given base, optionally - specifying a number of digits to pad to. + specifying a number of digits to pad to. The base \"b\" can be + specified as either an integer, or as a \"Uint8\" array of + character values to use as digit symbols. "), @@ -3530,1637 +3532,1718 @@ "), -("Sparse Matrices","Base","sparse","sparse(I, J, V[, m, n, combine]) +("Combinatorics","Base","nthperm","nthperm(v, k) - 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 - set to \"max(I)\" and \"max(J)\" respectively. If the \"combine\" - function is not supplied, duplicates are added by default. + Compute the kth lexicographic permutation of a vector. "), -("Sparse Matrices","Base","sparsevec","sparsevec(I, V[, m, combine]) +("Combinatorics","Base","nthperm!","nthperm!(v, k) - 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 - vectors are really just sparse matrices with one column. Given - Julia's Compressed Sparse Columns (CSC) storage format, a sparse - column matrix with one column is sparse, whereas a sparse row - matrix with one row ends up being dense. + In-place version of \"nthperm()\". "), -("Sparse Matrices","Base","sparsevec","sparsevec(D::Dict[, m]) +("Combinatorics","Base","randperm","randperm(n) - 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. + Construct a random permutation of the given length. "), -("Sparse Matrices","Base","issparse","issparse(S) +("Combinatorics","Base","invperm","invperm(v) - Returns \"true\" if \"S\" is sparse, and \"false\" otherwise. + Return the inverse permutation of v. "), -("Sparse Matrices","Base","sparse","sparse(A) +("Combinatorics","Base","isperm","isperm(v) -> Bool - Convert a dense matrix \"A\" into a sparse matrix. + Returns true if v is a valid permutation. "), -("Sparse Matrices","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. - -"), +("Combinatorics","Base","permute!","permute!(v, p) -("Sparse Matrices","Base","dense","dense(S) + Permute vector \"v\" in-place, according to permutation \"p\". No + checking is done to verify that \"p\" is a permutation. - Convert a sparse matrix \"S\" into a dense matrix. + To return a new permutation, use \"v[p]\". Note that this is + generally faster than \"permute!(v,p)\" for large vectors. "), -("Sparse Matrices","Base","full","full(S) +("Combinatorics","Base","ipermute!","ipermute!(v, p) - Convert a sparse matrix \"S\" into a dense matrix. + Like permute!, but the inverse of the given permutation is applied. "), -("Sparse Matrices","Base","spzeros","spzeros(m, n) +("Combinatorics","Base","randcycle","randcycle(n) - Create an empty sparse matrix of size \"m x n\". + Construct a random cyclic permutation of the given length. "), -("Sparse Matrices","Base","speye","speye(type, m[, n]) +("Combinatorics","Base","shuffle","shuffle(v) - 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\". + Randomly rearrange the elements of a vector. "), -("Sparse Matrices","Base","spones","spones(S) +("Combinatorics","Base","shuffle!","shuffle!(v) - Create a sparse matrix with the same structure as that of \"S\", - but with every nonzero element having the value \"1.0\". + In-place version of \"shuffle()\". "), -("Sparse Matrices","Base","sprand","sprand(m, n, density[, rng]) +("Combinatorics","Base","reverse","reverse(v) - Create a random sparse matrix with the specified density. Nonzeros - are sampled from the distribution specified by \"rng\". The uniform - distribution is used in case \"rng\" is not specified. + Reverse vector \"v\". "), -("Sparse Matrices","Base","sprandn","sprandn(m, n, density) +("Combinatorics","Base","reverse!","reverse!(v) -> v - Create a random sparse matrix of specified density with nonzeros - sampled from the normal distribution. + In-place version of \"reverse()\". "), -("Sparse Matrices","Base","sprandbool","sprandbool(m, n, density) +("Combinatorics","Base","combinations","combinations(array, n) - Create a random sparse boolean matrix with the specified density. + Generate all combinations of \"n\" elements from a given array. + Because the number of combinations can be very large, this function + runs inside a Task to produce values on demand. Write \"c = @task + combinations(a,n)\", then iterate \"c\" or call \"consume\" on it. "), -("Linear Algebra","Base","*","*(A, B) +("Combinatorics","Base","integer_partitions","integer_partitions(n, m) - Matrix multiplication + Generate all arrays of \"m\" integers that sum to \"n\". Because + the number of partitions can be very large, this function runs + inside a Task to produce values on demand. Write \"c = @task + integer_partitions(n,m)\", then iterate \"c\" or call \"consume\" + on it. "), -("Linear Algebra","Base","\\","\\(A, B) +("Combinatorics","Base","partitions","partitions(array) - Matrix division using a polyalgorithm. For input matrices \"A\" and - \"B\", the result \"X\" is such that \"A*X == B\". For rectangular - \"A\", QR factorization is used. For triangular \"A\", a triangular - solve is performed. For square \"A\", Cholesky factorization is - tried if the input is symmetric with a heavy diagonal. LU - factorization is used in case Cholesky factorization fails or for - general square inputs. If \"size(A,1) > size(A,2)\", the result is - a least squares solution of \"A*X+eps=B\" using the singular value - decomposition. \"A\" does not need to have full rank. + 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 runs inside a Task to produce + values on demand. Write \"c = @task partitions(a)\", then iterate + \"c\" or call \"consume\" on it. "), -("Linear Algebra","Base","dot","dot(x, y) +("Statistics","Base","mean","mean(v[, region]) - Compute the dot product + Compute the mean of whole array \"v\", or optionally along the + dimensions in \"region\". "), -("Linear Algebra","Base","cross","cross(x, y) +("Statistics","Base","std","std(v[, region]) - Compute the cross product of two 3-vectors + 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 + the assumption that each entry of \"v\" is an IID draw from that + generative distribution. This computation is equivalent to + calculating \"sqrt(sum((v - mean(v)).^2) / (length(v) - 1))\". "), -("Linear Algebra","Base","norm","norm(a) +("Statistics","Base","stdm","stdm(v, m) - Compute the norm of a \"Vector\" or a \"Matrix\" + Compute the sample standard deviation of a vector \"v\" with known + mean \"m\". "), -("Linear Algebra","Base","factors","factors(F) +("Statistics","Base","var","var(v[, region]) - Return the factors of a factorization \"F\". For example, in the - case of an LU decomposition, factors(LU) -> L, U, P + 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 + assumption that each entry of \"v\" is an IID draw from that + generative distribution. This computation is equivalent to + calculating \"sum((v - mean(v)).^2) / (length(v) - 1)\". "), -("Linear Algebra","Base","lu","lu(A) -> L, U, P +("Statistics","Base","varm","varm(v, m) - Compute the LU factorization of \"A\", such that \"A[P,:] = L*U\". + Compute the sample variance of a vector \"v\" with known mean + \"m\". "), -("Linear Algebra","Base","lufact","lufact(A) -> LUDense +("Statistics","Base","median","median(v) - Compute the LU factorization of \"A\" and return a \"LUDense\" - object. \"factors(lufact(A))\" returns the triangular matrices - containing the factorization. The following functions are available - for \"LUDense\" objects: \"size\", \"factors\", \"\\\", \"inv\", - \"det\". + Compute the median of a vector \"v\". "), -("Linear Algebra","Base","lufact!","lufact!(A) -> LUDense +("Statistics","Base","hist","hist(v[, n]) - \"lufact!\" is the same as \"lufact\" but saves space by - overwriting the input A, instead of creating a copy. + Compute the histogram of \"v\", optionally using \"n\" bins. "), -("Linear Algebra","Base","chol","chol(A[, LU]) -> F +("Statistics","Base","hist","hist(v, e) - Compute 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\". + Compute the histogram of \"v\" using a vector \"e\" as the edges + for the bins. "), -("Linear Algebra","Base","cholfact","cholfact(A[, LU]) -> CholeskyDense +("Statistics","Base","quantile","quantile(v, p) - Compute the Cholesky factorization of a symmetric positive-definite - matrix \"A\" and return a \"CholeskyDense\" object. \"LU\" may be - 'L' for using the lower part or 'U' for the upper part. The default - is to use 'U'. \"factors(cholfact(A))\" returns the triangular - matrix containing the factorization. The following functions are - available for \"CholeskyDense\" objects: \"size\", \"factors\", - \"\\\", \"inv\", \"det\". A \"LAPACK.PosDefException\" error is - thrown in case the matrix is not positive definite. + Compute the quantiles of a vector \"v\" at a specified set of + probability values \"p\". "), -("Linear Algebra","Base","cholpfact","cholpfact(A[, LU]) -> CholeskyPivotedDense +("Statistics","Base","quantile","quantile(v) - Compute the pivoted Cholesky factorization of a symmetric positive - semi-definite matrix \"A\" and return a \"CholeskyDensePivoted\" - object. \"LU\" may be 'L' for using the lower part or 'U' for the - upper part. The default is to use 'U'. \"factors(cholpfact(A))\" - returns the triangular matrix containing the factorization. The - following functions are available for \"CholeskyDensePivoted\" - objects: \"size\", \"factors\", \"\\\", \"inv\", \"det\". A - \"LAPACK.RankDeficientException\" error is thrown in case the - matrix is rank deficient. + Compute the quantiles of a vector \"v\" at the probability values + \"[.0, .2, .4, .6, .8, 1.0]\". "), -("Linear Algebra","Base","cholpfact!","cholpfact!(A[, LU]) -> CholeskyPivotedDense +("Statistics","Base","cov","cov(v1[, v2]) - \"cholpfact!\" is the same as \"cholpfact\" but saves space by - overwriting the input A, instead of creating a copy. + Compute the Pearson covariance between two vectors \"v1\" and + \"v2\". If called with a single element \"v\", then computes + covariance of columns of \"v\". "), -("Linear Algebra","Base","qr","qr(A) -> Q, R +("Statistics","Base","cor","cor(v1[, v2]) - Compute the QR factorization of \"A\" such that \"A = Q*R\". Also - see \"qrd\". + Compute the Pearson correlation between two vectors \"v1\" and + \"v2\". If called with a single element \"v\", then computes + correlation of columns of \"v\". "), -("Linear Algebra","Base","qrfact","qrfact(A) +("Signal Processing","Base","fft","fft(A[, dims]) - Compute the QR factorization of \"A\" and return a \"QRDense\" - object. \"factors(qrfact(A))\" returns \"Q\" and \"R\". The - following functions are available for \"QRDense\" objects: - \"size\", \"factors\", \"qmulQR\", \"qTmulQR\", \"\\\". + 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 + efficient if the size of \"A\" along the transformed dimensions is + a product of small primes; see \"nextprod()\". See also + \"plan_fft()\" for even greater efficiency. + + A one-dimensional FFT computes the one-dimensional discrete Fourier + transform (DFT) as defined by \\operatorname{DFT}[k] = + \\sum_{n=1}^{\\operatorname{length}(A)} \\exp\\left(-i\\frac{2\\pi + (n-1)(k-1)}{\\operatorname{length}(A)} \\right) A[n]. A + multidimensional FFT simply performs this operation along each + transformed dimension of \"A\". "), -("Linear Algebra","Base","qrfact!","qrfact!(A) +("Signal Processing","Base","fft!","fft!(A[, dims]) - \"qrfact!\" is the same as \"qrfact\" but saves space by - overwriting the input A, instead of creating a copy. + Same as \"fft()\", but operates in-place on \"A\", which must be an + array of complex floating-point numbers. "), -("Linear Algebra","Base","qrp","qrp(A) -> Q, R, P +("Signal Processing","Base","ifft","ifft(A[, dims]) - Compute the QR factorization of \"A\" with pivoting, such that - \"A*I[:,P] = Q*R\", where \"I\" is the identity matrix. Also see - \"qrpfact\". + Multidimensional inverse FFT. + + A one-dimensional backward FFT computes \\operatorname{BDFT}[k] = + \\sum_{n=1}^{\\operatorname{length}(A)} \\exp\\left(+i\\frac{2\\pi + (n-1)(k-1)}{\\operatorname{length}(A)} \\right) A[n]. A + multidimensional backward FFT simply performs this operation along + each transformed dimension of \"A\". The inverse FFT computes the + same thing divided by the product of the transformed dimensions. "), -("Linear Algebra","Base","qrpfact","qrpfact(A) -> QRPivotedDense +("Signal Processing","Base","ifft!","ifft!(A[, dims]) - Compute the QR factorization of \"A\" with pivoting and return a - \"QRDensePivoted\" object. \"factors(qrpfact(A))\" returns \"Q\" - and \"R\". The following functions are available for - \"QRDensePivoted\" objects: \"size\", \"factors\", \"qmulQR\", - \"qTmulQR\", \"\\\". + Same as \"ifft()\", but operates in-place on \"A\". "), -("Linear Algebra","Base","qrpfact!","qrpfact!(A) -> QRPivotedDense +("Signal Processing","Base","bfft","bfft(A[, dims]) - \"qrpfact!\" is the same as \"qrpfact\" but saves space by - overwriting the input A, instead of creating a copy. + 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. + (This is slightly more efficient than \"ifft()\" because it omits a + scaling step, which in some applications can be combined with other + computational steps elsewhere.) "), -("Linear Algebra","Base","qmulQR","qmulQR(QR, A) +("Signal Processing","Base","bfft!","bfft!(A[, dims]) - Perform \"Q*A\" efficiently, where Q is a an orthogonal matrix - defined as the product of k elementary reflectors from the QR - decomposition. + Same as \"bfft()\", but operates in-place on \"A\". "), -("Linear Algebra","Base","qTmulQR","qTmulQR(QR, A) - - Perform \"Q'*A\" efficiently, where Q is a an orthogonal matrix - defined as the product of k elementary reflectors from the QR - decomposition. +("Signal Processing","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 + function \"plan(A)\" that computes \"fft(A, dims)\" quickly. -("Linear Algebra","Base","sqrtm","sqrtm(A) + The \"flags\" argument is a bitwise-or of FFTW planner flags, + defaulting to \"FFTW.ESTIMATE\". e.g. passing \"FFTW.MEASURE\" or + \"FFTW.PATIENT\" will instead spend several seconds (or more) + benchmarking different possible FFT algorithms and picking the + fastest one; see the FFTW manual for more information on planner + flags. The optional \"timelimit\" argument specifies a rough upper + bound on the allowed planning time, in seconds. Passing + \"FFTW.MEASURE\" or \"FFTW.PATIENT\" may cause the input array + \"A\" to be overwritten with zeros during plan creation. - Compute the matrix square root of \"A\". If \"B = sqrtm(A)\", then - \"B*B == A\" within roundoff error. + \"plan_fft!()\" is the same as \"plan_fft()\" but creates a plan + that operates in-place on its argument (which must be an array of + complex floating-point numbers). \"plan_ifft()\" and so on are + similar but produce plans that perform the equivalent of the + inverse transforms \"ifft()\" and so on. "), -("Linear Algebra","Base","eig","eig(A) -> D, V +("Signal Processing","Base","plan_ifft","plan_ifft(A[, dims[, flags[, timelimit]]]) - Compute eigenvalues and eigenvectors of A + Same as \"plan_fft()\", but produces a plan that performs inverse + transforms \"ifft()\". "), -("Linear Algebra","Base","eigvals","eigvals(A) +("Signal Processing","Base","plan_bfft","plan_bfft(A[, dims[, flags[, timelimit]]]) - Returns the eigenvalues of \"A\". + Same as \"plan_fft()\", but produces a plan that performs an + unnormalized backwards transform \"bfft()\". "), -("Linear Algebra","Base","svdfact","svdfact(A[, thin]) -> SVDDense +("Signal Processing","Base","plan_fft!","plan_fft!(A[, dims[, flags[, timelimit]]]) - Compute the Singular Value Decomposition (SVD) of \"A\" and return - an \"SVDDense\" object. \"factors(svdfact(A))\" returns \"U\", - \"S\", and \"Vt\", such that \"A = U*diagm(S)*Vt\". If \"thin\" is - \"true\", an economy mode decomposition is returned. + Same as \"plan_fft()\", but operates in-place on \"A\". "), -("Linear Algebra","Base","svdfact!","svdfact!(A[, thin]) -> SVDDense +("Signal Processing","Base","plan_ifft!","plan_ifft!(A[, dims[, flags[, timelimit]]]) - \"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. + Same as \"plan_ifft()\", but operates in-place on \"A\". "), -("Linear Algebra","Base","svd","svd(A[, thin]) -> U, S, V +("Signal Processing","Base","plan_bfft!","plan_bfft!(A[, dims[, flags[, timelimit]]]) - Compute the SVD of A, returning \"U\", vector \"S\", and \"V\" such - that \"A == U*diagm(S)*V'\". If \"thin\" is \"true\", an economy - mode decomposition is returned. + Same as \"plan_bfft()\", but operates in-place on \"A\". "), -("Linear Algebra","Base","svdt","svdt(A[, thin]) -> U, S, Vt +("Signal Processing","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()\". + If \"A\" has size \"(n_1, ..., n_d)\", the result has size + \"(floor(n_1/2)+1, ..., n_d)\". - Compute the SVD of A, returning \"U\", vector \"S\", and \"Vt\" - such that \"A = U*diagm(S)*Vt\". If \"thin\" is \"true\", an - economy mode decomposition is returned. + The optional \"dims\" argument specifies an iterable subset of one + or more dimensions of \"A\" to transform, similar to \"fft()\". + Instead of (roughly) halving the first dimension of \"A\" in the + result, the \"dims[1]\" dimension is (roughly) halved in the same + way. "), -("Linear Algebra","Base","svdvals","svdvals(A) +("Signal Processing","Base","irfft","irfft(A, d[, dims]) - Returns the singular values of \"A\". + 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 + transform, defaulting to \"1:ndims(A)\". + + \"d\" is the length of the transformed real array along the + \"dims[1]\" dimension, which must satisfy \"d == + floor(size(A,dims[1])/2)+1\". (This parameter cannot be inferred + from \"size(A)\" due to the possibility of rounding by the + \"floor\" function here.) "), -("Linear Algebra","Base","svdvals!","svdvals!(A) +("Signal Processing","Base","brfft","brfft(A, d[, dims]) - Returns the singular values of \"A\", while saving space by - overwriting the input. + 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 + output array) in order to obtain the inverse transform. "), -("Linear Algebra","Base","svdfact","svdfact(A, B) -> GSVDDense +("Signal Processing","Base","plan_rfft","plan_rfft(A[, dims[, flags[, timelimit]]]) - Compute the generalized SVD of \"A\" and \"B\", returning a - \"GSVDDense\" Factorization object. \"factors(svdfact(A,b))\" - returns \"U\", \"V\", \"Q\", \"D1\", \"D2\", and \"R0\" such that - \"A = U*D1*R0*Q'\" and \"B = V*D2*R0*Q'\". + 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 + for \"rfft()\". "), -("Linear Algebra","Base","svd","svd(A, B) -> U, V, Q, D1, D2, R0 +("Signal Processing","Base","plan_irfft","plan_irfft(A, d[, dims[, flags[, timelimit]]]) - Compute the generalized SVD of \"A\" and \"B\", returning \"U\", - \"V\", \"Q\", \"D1\", \"D2\", and \"R0\" such that \"A = - U*D1*R0*Q'\" and \"B = V*D2*R0*Q'\". + 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 + for \"irfft()\". "), -("Linear Algebra","Base","svdvals","svdvals(A, B) +("Signal Processing","Base","dct","dct(A[, dims]) - Return only the singular values from the generalized singular value - decomposition of \"A\" and \"B\". + 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 + dimensions (e.g. an integer, range, tuple, or array) to transform + along. Most efficient if the size of \"A\" along the transformed + dimensions is a product of small primes; see \"nextprod()\". See + also \"plan_dct()\" for even greater efficiency. "), -("Linear Algebra","Base","triu","triu(M) +("Signal Processing","Base","dct!","dct!(A[, dims]) - Upper triangle of a matrix + Same as \"dct!()\", except that it operates in-place on \"A\", + which must be an array of real or complex floating-point values. "), -("Linear Algebra","Base","tril","tril(M) +("Signal Processing","Base","idct","idct(A[, dims]) - Lower triangle of a matrix + 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 + iterable subset of dimensions (e.g. an integer, range, tuple, or + array) to transform along. Most efficient if the size of \"A\" + along the transformed dimensions is a product of small primes; see + \"nextprod()\". See also \"plan_idct()\" for even greater + efficiency. "), -("Linear Algebra","Base","diag","diag(M[, k]) +("Signal Processing","Base","idct!","idct!(A[, dims]) - The \"k\"-th diagonal of a matrix, as a vector + Same as \"idct!()\", but operates in-place on \"A\". "), -("Linear Algebra","Base","diagm","diagm(v[, k]) +("Signal Processing","Base","plan_dct","plan_dct(A[, dims[, flags[, timelimit]]]) - Construct a diagonal matrix and place \"v\" on the \"k\"-th - diagonal + 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()\". "), -("Linear Algebra","Base","diagmm","diagmm(matrix, vector) +("Signal Processing","Base","plan_dct!","plan_dct!(A[, dims[, flags[, timelimit]]]) - Multiply matrices, interpreting the vector argument as a diagonal - matrix. The arguments may occur in the other order to multiply with - the diagonal matrix on the left. + Same as \"plan_dct()\", but operates in-place on \"A\". "), -("Linear Algebra","Base","Tridiagonal","Tridiagonal(dl, d, du) +("Signal Processing","Base","plan_idct","plan_idct(A[, dims[, flags[, timelimit]]]) - Construct a tridiagonal matrix from the lower diagonal, diagonal, - and upper diagonal + 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 + \"idct()\". "), -("Linear Algebra","Base","Woodbury","Woodbury(A, U, C, V) +("Signal Processing","Base","plan_idct!","plan_idct!(A[, dims[, flags[, timelimit]]]) - Construct a matrix in a form suitable for applying the Woodbury - matrix identity + Same as \"plan_idct()\", but operates in-place on \"A\". "), -("Linear Algebra","Base","rank","rank(M) +("Signal Processing","Base","FFTW","FFTW.r2r(A, kind[, dims]) - Compute the rank of a matrix + 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 + types (\"FFTW.REDFT00\", \"FFTW.REDFT01\", \"FFTW.REDFT10\", or + \"FFTW.REDFT11\"), a discrete sine transform of various types + (\"FFTW.RODFT00\", \"FFTW.RODFT01\", \"FFTW.RODFT10\", or + \"FFTW.RODFT11\"), a real-input DFT with halfcomplex-format output + (\"FFTW.R2HC\" and its inverse \"FFTW.HC2R\"), or a discrete + Hartley transform (\"FFTW.DHT\"). The \"kind\" argument may be an + array or tuple in order to specify different transform types along + the different dimensions of \"A\"; \"kind[end]\" is used for any + unspecified dimensions. See the FFTW manual for precise + definitions of these transform types, at + **. + + The optional \"dims\" argument specifies an iterable subset of + dimensions (e.g. an integer, range, tuple, or array) to transform + along. \"kind[i]\" is then the transform type for \"dims[i]\", with + \"kind[end]\" being used for \"i > length(kind)\". + + See also \"FFTW.plan_r2r()\" to pre-plan optimized r2r transforms. "), -("Linear Algebra","Base","norm","norm(A[, p]) +("Signal Processing","Base","FFTW","FFTW.r2r!(A, kind[, dims]) - Compute the \"p\"-norm of a vector or a matrix. \"p\" is \"2\" by - default, if not provided. If \"A\" is a vector, \"norm(A, p)\" - computes the \"p\"-norm. \"norm(A, Inf)\" returns the largest value - in \"abs(A)\", whereas \"norm(A, -Inf)\" returns the smallest. If - \"A\" is a matrix, valid values for \"p\" are \"1\", \"2\", or - \"Inf\". In order to compute the Frobenius norm, use \"normfro\". + \"FFTW.r2r!()\" is the same as \"FFTW.r2r()\", but operates in- + place on \"A\", which must be an array of real or complex floating- + point numbers. "), -("Linear Algebra","Base","normfro","normfro(A) +("Signal Processing","Base","FFTW","FFTW.plan_r2r(A, kind[, dims[, flags[, timelimit]]]) - Compute the Frobenius norm of a matrix \"A\". + Pre-plan an optimized r2r transform, similar to \"plan_fft()\" + except that the transforms (and the first three arguments) + correspond to \"FFTW.r2r()\" and \"FFTW.r2r!()\", respectively. "), -("Linear Algebra","Base","cond","cond(M[, p]) +("Signal Processing","Base","FFTW","FFTW.plan_r2r!(A, kind[, dims[, flags[, timelimit]]]) - Matrix condition number, computed using the p-norm. \"p\" is 2 by - default, if not provided. Valid values for \"p\" are \"1\", \"2\", - or \"Inf\". + Similar to \"plan_fft()\", but corresponds to \"FFTW.r2r!()\". "), -("Linear Algebra","Base","trace","trace(M) +("Signal Processing","Base","fftshift","fftshift(x) - Matrix trace + Swap the first and second halves of each dimension of \"x\". "), -("Linear Algebra","Base","det","det(M) +("Signal Processing","Base","fftshift","fftshift(x, dim) - Matrix determinant + Swap the first and second halves of the given dimension of array + \"x\". "), -("Linear Algebra","Base","inv","inv(M) +("Signal Processing","Base","ifftshift","ifftshift(x[, dim]) - Matrix inverse + Undoes the effect of \"fftshift\". "), -("Linear Algebra","Base","pinv","pinv(M) +("Signal Processing","Base","filt","filt(b, a, x) - Moore-Penrose inverse + Apply filter described by vectors \"a\" and \"b\" to vector \"x\". "), -("Linear Algebra","Base","null","null(M) +("Signal Processing","Base","deconv","deconv(b, a) - Basis for null space of M. + Construct vector \"c\" such that \"b = conv(a,c) + r\". Equivalent + to polynomial division. "), -("Linear Algebra","Base","repmat","repmat(A, n, m) +("Signal Processing","Base","conv","conv(u, v) - Construct a matrix by repeating the given matrix \"n\" times in - dimension 1 and \"m\" times in dimension 2. + Convolution of two vectors. Uses FFT algorithm. "), -("Linear Algebra","Base","kron","kron(A, B) +("Signal Processing","Base","xcorr","xcorr(u, v) - Kronecker tensor product of two vectors or two matrices. + Compute the cross-correlation of two vectors. "), -("Linear Algebra","Base","linreg","linreg(x, y) +("Parallel Computing","Base","addprocs_local","addprocs_local(n) - Determine parameters \"[a, b]\" that minimize the squared error - between \"y\" and \"a+b*x\". + Add processes on the local machine. Can be used to take advantage + of multiple cores. "), -("Linear Algebra","Base","linreg","linreg(x, y, w) +("Parallel Computing","Base","addprocs_ssh","addprocs_ssh({\"host1\", \"host2\", ...}) - Weighted least-squares linear regression. + Add processes on remote machines via SSH. Requires julia to be + installed in the same location on each node, or to be available via + a shared file system. "), -("Linear Algebra","Base","expm","expm(A) +("Parallel Computing","Base","addprocs_sge","addprocs_sge(n) - Matrix exponential. + Add processes via the Sun/Oracle Grid Engine batch queue, using + \"qsub\". "), -("Linear Algebra","Base","issym","issym(A) +("Parallel Computing","Base","nprocs","nprocs() - Test whether a matrix is symmetric. + Get the number of available processors. "), -("Linear Algebra","Base","isposdef","isposdef(A) +("Parallel Computing","Base","myid","myid() - Test whether a matrix is positive-definite. + Get the id of the current processor. "), -("Linear Algebra","Base","istril","istril(A) +("Parallel Computing","Base","pmap","pmap(f, c) - Test whether a matrix is lower-triangular. + Transform collection \"c\" by applying \"f\" to each element in + parallel. "), -("Linear Algebra","Base","istriu","istriu(A) +("Parallel Computing","Base","remote_call","remote_call(id, func, args...) - Test whether a matrix is upper-triangular. + Call a function asynchronously on the given arguments on the + specified processor. Returns a \"RemoteRef\". "), -("Linear Algebra","Base","ishermitian","ishermitian(A) +("Parallel Computing","Base","wait","wait(RemoteRef) - Test whether a matrix is hermitian. + Wait for a value to become available for the specified remote + reference. "), -("Linear Algebra","Base","transpose","transpose(A) +("Parallel Computing","Base","fetch","fetch(RemoteRef) - The transpose operator (.'). + Wait for and get the value of a remote reference. "), -("Linear Algebra","Base","ctranspose","ctranspose(A) +("Parallel Computing","Base","remote_call_wait","remote_call_wait(id, func, args...) - The conjugate transpose operator ('). + Perform \"wait(remote_call(...))\" in one message. "), -("Combinatorics","Base","nthperm","nthperm(v, k) +("Parallel Computing","Base","remote_call_fetch","remote_call_fetch(id, func, args...) - Compute the kth lexicographic permutation of a vector. + Perform \"fetch(remote_call(...))\" in one message. "), -("Combinatorics","Base","nthperm!","nthperm!(v, k) +("Parallel Computing","Base","put","put(RemoteRef, value) - In-place version of \"nthperm()\". + 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\". "), -("Combinatorics","Base","randperm","randperm(n) +("Parallel Computing","Base","take","take(RemoteRef) - Construct a random permutation of the given length. + Fetch the value of a remote reference, removing it so that the + reference is empty again. "), -("Combinatorics","Base","invperm","invperm(v) +("Parallel Computing","Base","RemoteRef","RemoteRef() - Return the inverse permutation of v. + Make an uninitialized remote reference on the local machine. "), -("Combinatorics","Base","isperm","isperm(v) -> Bool +("Parallel Computing","Base","RemoteRef","RemoteRef(n) - Returns true if v is a valid permutation. + Make an uninitialized remote reference on processor \"n\". "), -("Combinatorics","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. +("Distributed Arrays","Base","DArray","DArray(init, dims[, procs, dist]) - To return a new permutation, use \"v[p]\". Note that this is - generally faster than \"permute!(v,p)\" for large vectors. + Construct a distributed array. \"init\" is a function accepting a + tuple of index ranges. This function should return a chunk of the + distributed array for the specified indexes. \"dims\" is the + overall size of the distributed array. \"procs\" optionally + specifies a vector of processor IDs to use. \"dist\" is an integer + vector specifying how many chunks the distributed array should be + divided into in each dimension. "), -("Combinatorics","Base","ipermute!","ipermute!(v, p) +("Distributed Arrays","Base","dzeros","dzeros(dims, ...) - Like permute!, but the inverse of the given permutation is applied. + Construct a distributed array of zeros. Trailing arguments are the + same as those accepted by \"darray\". "), -("Combinatorics","Base","randcycle","randcycle(n) +("Distributed Arrays","Base","dones","dones(dims, ...) - Construct a random cyclic permutation of the given length. + Construct a distributed array of ones. Trailing arguments are the + same as those accepted by \"darray\". "), -("Combinatorics","Base","shuffle","shuffle(v) +("Distributed Arrays","Base","dfill","dfill(x, dims, ...) - Randomly rearrange the elements of a vector. + Construct a distributed array filled with value \"x\". Trailing + arguments are the same as those accepted by \"darray\". "), -("Combinatorics","Base","shuffle!","shuffle!(v) +("Distributed Arrays","Base","drand","drand(dims, ...) - In-place version of \"shuffle()\". + Construct a distributed uniform random array. Trailing arguments + are the same as those accepted by \"darray\". "), -("Combinatorics","Base","reverse","reverse(v) +("Distributed Arrays","Base","drandn","drandn(dims, ...) - Reverse vector \"v\". + Construct a distributed normal random array. Trailing arguments are + the same as those accepted by \"darray\". "), -("Combinatorics","Base","reverse!","reverse!(v) -> v +("Distributed Arrays","Base","distribute","distribute(a) - In-place version of \"reverse()\". + Convert a local array to distributed "), -("Combinatorics","Base","combinations","combinations(array, n) +("Distributed Arrays","Base","localize","localize(d) - Generate all combinations of \"n\" elements from a given array. - Because the number of combinations can be very large, this function - runs inside a Task to produce values on demand. Write \"c = @task - combinations(a,n)\", then iterate \"c\" or call \"consume\" on it. + Get the local piece of a distributed array "), -("Combinatorics","Base","integer_partitions","integer_partitions(n, m) +("Distributed Arrays","Base","myindexes","myindexes(d) - Generate all arrays of \"m\" integers that sum to \"n\". Because - the number of partitions can be very large, this function runs - inside a Task to produce values on demand. Write \"c = @task - integer_partitions(n,m)\", then iterate \"c\" or call \"consume\" - on it. + A tuple describing the indexes owned by the local processor "), -("Combinatorics","Base","partitions","partitions(array) +("Distributed Arrays","Base","procs","procs(d) - 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 runs inside a Task to produce - values on demand. Write \"c = @task partitions(a)\", then iterate - \"c\" or call \"consume\" on it. + Get the vector of processors storing pieces of \"d\" "), -("Statistics","Base","mean","mean(v[, region]) +("System","Base","run","run(command) - Compute the mean of whole array \"v\", or optionally along the - dimensions in \"region\". + Run a command object, constructed with backticks. Throws an error + if anything goes wrong, including the process exiting with a non- + zero status. "), -("Statistics","Base","std","std(v[, region]) +("System","Base","spawn","spawn(command) - 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 - the assumption that each entry of \"v\" is an IID draw from that - generative distribution. This computation is equivalent to - calculating \"sqrt(sum((v - mean(v)).^2) / (length(v) - 1))\". + Run a command object asynchronously, returning the resulting + \"Process\" object. "), -("Statistics","Base","stdm","stdm(v, m) +("System","Base","success","success(command) - Compute the sample standard deviation of a vector \"v\" with known - mean \"m\". + Run a command object, constructed with backticks, and tell whether + it was successful (exited with a code of 0). "), -("Statistics","Base","var","var(v[, region]) +("System","Base","readsfrom","readsfrom(command) - 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 - assumption that each entry of \"v\" is an IID draw from that - generative distribution. This computation is equivalent to - calculating \"sum((v - mean(v)).^2) / (length(v) - 1)\". + Starts running a command asynchronously, and returns a tuple + (stream,process). The first value is a stream reading from the + process' standard output. "), -("Statistics","Base","varm","varm(v, m) +("System","Base","writesto","writesto(command) - Compute the sample variance of a vector \"v\" with known mean - \"m\". + Starts running a command asynchronously, and returns a tuple + (stream,process). The first value is a stream writing to the + process' standard input. "), -("Statistics","Base","median","median(v) +("System","Base","readandwrite","readandwrite(command) - Compute the median of a vector \"v\". + 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. "), -("Statistics","Base","hist","hist(v[, n]) +("System","Base",">",">() - Compute the histogram of \"v\", optionally using \"n\" bins. + Redirect standard output of a process. + + **Example**: \"run(`ls` > \"out.log\")\" "), -("Statistics","Base","hist","hist(v, e) +("System","Base","<","<() - Compute the histogram of \"v\" using a vector \"e\" as the edges - for the bins. + Redirect standard input of a process. "), -("Statistics","Base","quantile","quantile(v, p) +("System","Base",">>",">>() - Compute the quantiles of a vector \"v\" at a specified set of - probability values \"p\". + Redirect standard output of a process, appending to the destination + file. "), -("Statistics","Base","quantile","quantile(v) +("System","Base",".>",".>() - Compute the quantiles of a vector \"v\" at the probability values - \"[.0, .2, .4, .6, .8, 1.0]\". + Redirect the standard error stream of a process. "), -("Statistics","Base","cov","cov(v1[, v2]) +("System","Base","gethostname","gethostname() -> String - Compute the Pearson covariance between two vectors \"v1\" and - \"v2\". If called with a single element \"v\", then computes - covariance of columns of \"v\". + Get the local machine's host name. "), -("Statistics","Base","cor","cor(v1[, v2]) +("System","Base","getipaddr","getipaddr() -> String - Compute the Pearson correlation between two vectors \"v1\" and - \"v2\". If called with a single element \"v\", then computes - correlation of columns of \"v\". + Get the IP address of the local machine, as a string of the form + \"x.x.x.x\". "), -("Signal Processing","Base","fft","fft(A[, dims]) +("System","Base","pwd","pwd() -> String - 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 - efficient if the size of \"A\" along the transformed dimensions is - a product of small primes; see \"nextprod()\". See also - \"plan_fft()\" for even greater efficiency. + Get the current working directory. - A one-dimensional FFT computes the one-dimensional discrete Fourier - transform (DFT) as defined by \\operatorname{DFT}[k] = - \\sum_{n=1}^{\\operatorname{length}(A)} \\exp\\left(-i\\frac{2\\pi - (n-1)(k-1)}{\\operatorname{length}(A)} \\right) A[n]. A - multidimensional FFT simply performs this operation along each - transformed dimension of \"A\". +"), + +("System","Base","cd","cd(dir::String) + + Set the current working directory. Returns the new current + directory. "), -("Signal Processing","Base","fft!","fft!(A[, dims]) +("System","Base","cd","cd(f[, \"dir\"]) - Same as \"fft()\", but operates in-place on \"A\", which must be an - array of complex floating-point numbers. + Temporarily changes the current working directory (HOME if not + specified) and applies function f before returning. "), -("Signal Processing","Base","ifft","ifft(A[, dims]) +("System","Base","mkdir","mkdir(path[, mode]) - Multidimensional inverse FFT. + Make a new directory with name \"path\" and permissions \"mode\". + \"mode\" defaults to 0o777, modified by the current file creation + mask. - A one-dimensional backward FFT computes \\operatorname{BDFT}[k] = - \\sum_{n=1}^{\\operatorname{length}(A)} \\exp\\left(+i\\frac{2\\pi - (n-1)(k-1)}{\\operatorname{length}(A)} \\right) A[n]. A - multidimensional backward FFT simply performs this operation along - each transformed dimension of \"A\". The inverse FFT computes the - same thing divided by the product of the transformed dimensions. +"), + +("System","Base","rmdir","rmdir(path) + + Remove the directory named \"path\". "), -("Signal Processing","Base","ifft!","ifft!(A[, dims]) +("System","Base","getpid","getpid() -> Int32 - Same as \"ifft()\", but operates in-place on \"A\". + Get julia's process ID. "), -("Signal Processing","Base","bfft","bfft(A[, dims]) +("System","Base","time","time() - 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. - (This is slightly more efficient than \"ifft()\" because it omits a - scaling step, which in some applications can be combined with other - computational steps elsewhere.) + Get the system time in seconds since the epoch, with fairly high + (typically, microsecond) resolution. "), -("Signal Processing","Base","bfft!","bfft!(A[, dims]) +("System","Base","time_ns","time_ns() - Same as \"bfft()\", but operates in-place on \"A\". + Get the time in nanoseconds. The time corresponding to 0 is + undefined, and wraps every 5.8 years. "), -("Signal Processing","Base","plan_fft","plan_fft(A[, dims[, flags[, timelimit]]]) +("System","Base","tic","tic() - 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 - function \"plan(A)\" that computes \"fft(A, dims)\" quickly. + 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. - The \"flags\" argument is a bitwise-or of FFTW planner flags, - defaulting to \"FFTW.ESTIMATE\". e.g. passing \"FFTW.MEASURE\" or - \"FFTW.PATIENT\" will instead spend several seconds (or more) - benchmarking different possible FFT algorithms and picking the - fastest one; see the FFTW manual for more information on planner - flags. The optional \"timelimit\" argument specifies a rough upper - bound on the allowed planning time, in seconds. Passing - \"FFTW.MEASURE\" or \"FFTW.PATIENT\" may cause the input array - \"A\" to be overwritten with zeros during plan creation. +"), - \"plan_fft!()\" is the same as \"plan_fft()\" but creates a plan - that operates in-place on its argument (which must be an array of - complex floating-point numbers). \"plan_ifft()\" and so on are - similar but produce plans that perform the equivalent of the - inverse transforms \"ifft()\" and so on. +("System","Base","toc","toc() + + Print and return the time elapsed since the last \"tic()\". "), -("Signal Processing","Base","plan_ifft","plan_ifft(A[, dims[, flags[, timelimit]]]) +("System","Base","toq","toq() - Same as \"plan_fft()\", but produces a plan that performs inverse - transforms \"ifft()\". + Return, but do not print, the time elapsed since the last + \"tic()\". "), -("Signal Processing","Base","plan_bfft","plan_bfft(A[, dims[, flags[, timelimit]]]) +("System","Base","EnvHash","EnvHash() -> EnvHash - Same as \"plan_fft()\", but produces a plan that performs an - unnormalized backwards transform \"bfft()\". + A singleton of this type provides a hash table interface to + environment variables. "), -("Signal Processing","Base","plan_fft!","plan_fft!(A[, dims[, flags[, timelimit]]]) +("System","Base","ENV","ENV - Same as \"plan_fft()\", but operates in-place on \"A\". + Reference to the singleton \"EnvHash\", providing a dictionary + interface to system environment variables. "), -("Signal Processing","Base","plan_ifft!","plan_ifft!(A[, dims[, flags[, timelimit]]]) +("C Interface","Base","ccall","ccall((symbol, library) or fptr, RetType, (ArgType1, ...), ArgVar1, ...) - Same as \"plan_ifft()\", but operates in-place on \"A\". + Call function in C-exported shared library, specified by (function + name, library) tuple (String or :Symbol). Alternatively, ccall may + be used to call a function pointer returned by dlsym, but note that + this usage is generally discouraged to facilitate future static + compilation. "), -("Signal Processing","Base","plan_bfft!","plan_bfft!(A[, dims[, flags[, timelimit]]]) +("C Interface","Base","cfunction","cfunction(fun::Function, RetType::Type, (ArgTypes...)) - Same as \"plan_bfft()\", but operates in-place on \"A\". + Generate C-callable function pointer from Julia function. "), -("Signal Processing","Base","rfft","rfft(A[, dims]) +("C Interface","Base","dlopen","dlopen(libfile::String[, flags::Integer]) - 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()\". - If \"A\" has size \"(n_1, ..., n_d)\", the result has size - \"(floor(n_1/2)+1, ..., n_d)\". + Load a shared library, returning an opaque handle. - The optional \"dims\" argument specifies an iterable subset of one - or more dimensions of \"A\" to transform, similar to \"fft()\". - Instead of (roughly) halving the first dimension of \"A\" in the - result, the \"dims[1]\" dimension is (roughly) halved in the same - way. + The optional flags argument is a bitwise-or of zero or more of + RTLD_LOCAL, RTLD_GLOBAL, RTLD_LAZY, RTLD_NOW, RTLD_NODELETE, + RTLD_NOLOAD, RTLD_DEEPBIND, and RTLD_FIRST. These are converted to + the corresponding flags of the POSIX (and/or GNU libc and/or MacOS) + dlopen command, if possible, or are ignored if the specified + functionality is not available on the current platform. The + default is RTLD_LAZY|RTLD_DEEPBIND|RTLD_LOCAL. An important usage + of these flags, on POSIX platforms, is to specify + RTLD_LAZY|RTLD_DEEPBIND|RTLD_GLOBAL in order for the library's + symbols to be available for usage in other shared libraries, in + situations where there are dependencies between shared libraries. "), -("Signal Processing","Base","irfft","irfft(A, d[, dims]) +("C Interface","Base","dlsym","dlsym(handle, sym) - 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 - transform, defaulting to \"1:ndims(A)\". + Look up a symbol from a shared library handle, return callable + function pointer on success. - \"d\" is the length of the transformed real array along the - \"dims[1]\" dimension, which must satisfy \"d == - floor(size(A,dims[1])/2)+1\". (This parameter cannot be inferred - from \"size(A)\" due to the possibility of rounding by the - \"floor\" function here.) +"), + +("C Interface","Base","dlsym_e","dlsym_e(handle, sym) + + Look up a symbol from a shared library handle, silently return NULL + pointer on lookup failure. + +"), + +("C Interface","Base","dlclose","dlclose(handle) + + Close shared library referenced by handle. + +"), + +("C Interface","Base","c_free","c_free(addr::Ptr) + + Call free() from C standard library. + +"), + +("C Interface","Base","unsafe_ref","unsafe_ref(p::Ptr{T}, i::Integer) + + Dereference the pointer \"p[i]\" or \"*p\", returning a copy of + type T. "), -("Signal Processing","Base","brfft","brfft(A, d[, dims]) +("C Interface","Base","unsafe_assign","unsafe_assign(p::Ptr{T}, x, i::Integer) - 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 - output array) in order to obtain the inverse transform. + Assign to the pointer \"p[i] = x\" or \"*p = x\", making a copy of + object x into the memory at p. "), -("Signal Processing","Base","plan_rfft","plan_rfft(A[, dims[, flags[, timelimit]]]) +("C Interface","Base","pointer","pointer(a[, index]) - 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 - for \"rfft()\". + Get the native address of an array element. Be careful to ensure + that a julia reference to \"a\" exists as long as this pointer will + be used. "), -("Signal Processing","Base","plan_irfft","plan_irfft(A, d[, dims[, flags[, timelimit]]]) +("C Interface","Base","pointer","pointer(type, int) - 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 - for \"irfft()\". + Convert an integer to a pointer of the specified element type. "), -("Signal Processing","Base","dct","dct(A[, dims]) +("C Interface","Base","pointer_to_array","pointer_to_array(p, dims[, own]) - 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 - dimensions (e.g. an integer, range, tuple, or array) to transform - along. Most efficient if the size of \"A\" along the transformed - dimensions is a product of small primes; see \"nextprod()\". See - also \"plan_dct()\" for even greater efficiency. + 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, + calling \"free\" on the pointer when the array is no longer + referenced. "), -("Signal Processing","Base","dct!","dct!(A[, dims]) +("Errors","Base","error","error(message::String) - Same as \"dct!()\", except that it operates in-place on \"A\", - which must be an array of real or complex floating-point values. + Raise an error with the given message "), -("Signal Processing","Base","idct","idct(A[, dims]) +("Errors","Base","throw","throw(e) - 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 - iterable subset of dimensions (e.g. an integer, range, tuple, or - array) to transform along. Most efficient if the size of \"A\" - along the transformed dimensions is a product of small primes; see - \"nextprod()\". See also \"plan_idct()\" for even greater - efficiency. + Throw an object as an exception "), -("Signal Processing","Base","idct!","idct!(A[, dims]) +("Errors","Base","errno","errno() - Same as \"idct!()\", but operates in-place on \"A\". + Get the value of the C library's \"errno\" "), -("Signal Processing","Base","plan_dct","plan_dct(A[, dims[, flags[, timelimit]]]) +("Errors","Base","strerror","strerror(n) - 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()\". + Convert a system call error code to a descriptive string "), -("Signal Processing","Base","plan_dct!","plan_dct!(A[, dims[, flags[, timelimit]]]) +("Errors","Base","assert","assert(cond) - Same as \"plan_dct()\", but operates in-place on \"A\". + Raise an error if \"cond\" is false. Also available as the macro + \"@assert expr\". "), -("Signal Processing","Base","plan_idct","plan_idct(A[, dims[, flags[, timelimit]]]) +("Tasks","Base","Task","Task(func) - 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 - \"idct()\". + Create a \"Task\" (i.e. thread, or coroutine) to execute the given + function. The task exits when this function returns. "), -("Signal Processing","Base","plan_idct!","plan_idct!(A[, dims[, flags[, timelimit]]]) +("Tasks","Base","yieldto","yieldto(task, args...) - Same as \"plan_idct()\", but operates in-place on \"A\". + Switch to the given task. The first time a task is switched to, the + task's function is called with \"args\". On subsequent switches, + \"args\" are returned from the task's last call to \"yieldto\". "), -("Signal Processing","Base","FFTW","FFTW.r2r(A, kind[, dims]) +("Tasks","Base","current_task","current_task() - 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 - types (\"FFTW.REDFT00\", \"FFTW.REDFT01\", \"FFTW.REDFT10\", or - \"FFTW.REDFT11\"), a discrete sine transform of various types - (\"FFTW.RODFT00\", \"FFTW.RODFT01\", \"FFTW.RODFT10\", or - \"FFTW.RODFT11\"), a real-input DFT with halfcomplex-format output - (\"FFTW.R2HC\" and its inverse \"FFTW.HC2R\"), or a discrete - Hartley transform (\"FFTW.DHT\"). The \"kind\" argument may be an - array or tuple in order to specify different transform types along - the different dimensions of \"A\"; \"kind[end]\" is used for any - unspecified dimensions. See the FFTW manual for precise - definitions of these transform types, at - **. + Get the currently running Task. - The optional \"dims\" argument specifies an iterable subset of - dimensions (e.g. an integer, range, tuple, or array) to transform - along. \"kind[i]\" is then the transform type for \"dims[i]\", with - \"kind[end]\" being used for \"i > length(kind)\". +"), - See also \"FFTW.plan_r2r()\" to pre-plan optimized r2r transforms. +("Tasks","Base","istaskdone","istaskdone(task) + + Tell whether a task has exited. "), -("Signal Processing","Base","FFTW","FFTW.r2r!(A, kind[, dims]) +("Tasks","Base","consume","consume(task) - \"FFTW.r2r!()\" is the same as \"FFTW.r2r()\", but operates in- - place on \"A\", which must be an array of real or complex floating- - point numbers. + Receive the next value passed to \"produce\" by the specified task. "), -("Signal Processing","Base","FFTW","FFTW.plan_r2r(A, kind[, dims[, flags[, timelimit]]]) +("Tasks","Base","produce","produce(value) - Pre-plan an optimized r2r transform, similar to \"plan_fft()\" - except that the transforms (and the first three arguments) - correspond to \"FFTW.r2r()\" and \"FFTW.r2r!()\", respectively. + Send the given value to the last \"consume\" call, switching to the + consumer task. "), -("Signal Processing","Base","FFTW","FFTW.plan_r2r!(A, kind[, dims[, flags[, timelimit]]]) +("Tasks","Base","make_scheduled","make_scheduled(task) - Similar to \"plan_fft()\", but corresponds to \"FFTW.r2r!()\". + Register a task with the main event loop, so it will automatically + run when possible. "), -("Signal Processing","Base","fftshift","fftshift(x) +("Tasks","Base","yield","yield() - Swap the first and second halves of each dimension of \"x\". + For scheduled tasks, switch back to the scheduler to allow another + scheduled task to run. "), -("Signal Processing","Base","fftshift","fftshift(x, dim) +("Tasks","Base","tls","tls(symbol) - Swap the first and second halves of the given dimension of array - \"x\". + Look up the value of a symbol in the current task's task-local + storage. "), -("Signal Processing","Base","ifftshift","ifftshift(x[, dim]) +("Tasks","Base","tls","tls(symbol, value) - Undoes the effect of \"fftshift\". + Assign a value to a symbol in the current task's task-local + storage. "), -("Signal Processing","Base","filt","filt(b, a, x) +("Constants","Base","OS_NAME","OS_NAME - Apply filter described by vectors \"a\" and \"b\" to vector \"x\". + A symbol representing the name of the operating system. Possible + values are \":Linux\", \":Darwin\" (OS X), or \":Windows\". "), -("Signal Processing","Base","deconv","deconv(b, a) +("Constants","Base","ARGS","ARGS - Construct vector \"c\" such that \"b = conv(a,c) + r\". Equivalent - to polynomial division. + An array of the command line arguments passed to Julia, as strings. "), -("Signal Processing","Base","conv","conv(u, v) +("Constants","Base","C_NULL","C_NULL - Convolution of two vectors. Uses FFT algorithm. + The C null pointer constant, sometimes used when calling external + code. "), -("Signal Processing","Base","xcorr","xcorr(u, v) +("Constants","Base","CPU_CORES","CPU_CORES - Compute the cross-correlation of two vectors. + The number of CPU cores in the system. "), -("Parallel Computing","Base","addprocs_local","addprocs_local(n) +("Constants","Base","WORD_SIZE","WORD_SIZE - Add processes on the local machine. Can be used to take advantage - of multiple cores. + Standard word size on the current machine, in bits. "), -("Parallel Computing","Base","addprocs_ssh","addprocs_ssh({\"host1\", \"host2\", ...}) +("Constants","Base","VERSION","VERSION - Add processes on remote machines via SSH. Requires julia to be - installed in the same location on each node, or to be available via - a shared file system. + An object describing which version of Julia is in use. "), -("Parallel Computing","Base","addprocs_sge","addprocs_sge(n) +("Constants","Base","LOAD_PATH","LOAD_PATH - Add processes via the Sun/Oracle Grid Engine batch queue, using - \"qsub\". + An array of paths (as strings) where the \"require\" function looks + for code. "), -("Parallel Computing","Base","nprocs","nprocs() +("Filesystem","Base","isblockdev","isblockdev(path) -> Bool - Get the number of available processors. + Returns \"true\" if \"path\" is a block device, \"false\" + otherwise. "), -("Parallel Computing","Base","myid","myid() +("Filesystem","Base","ischardev","ischardev(path) -> Bool - Get the id of the current processor. + Returns \"true\" if \"path\" is a character device, \"false\" + otherwise. "), -("Parallel Computing","Base","pmap","pmap(f, c) +("Filesystem","Base","isdir","isdir(path) -> Bool - Transform collection \"c\" by applying \"f\" to each element in - parallel. + Returns \"true\" if \"path\" is a directory, \"false\" otherwise. "), -("Parallel Computing","Base","remote_call","remote_call(id, func, args...) +("Filesystem","Base","isexecutable","isexecutable(path) -> Bool - Call a function asynchronously on the given arguments on the - specified processor. Returns a \"RemoteRef\". + Returns \"true\" if the current user has permission to execute + \"path\", \"false\" otherwise. "), -("Parallel Computing","Base","wait","wait(RemoteRef) +("Filesystem","Base","isfifo","isfifo(path) -> Bool - Wait for a value to become available for the specified remote - reference. + Returns \"true\" if \"path\" is a FIFO, \"false\" otherwise. "), -("Parallel Computing","Base","fetch","fetch(RemoteRef) +("Filesystem","Base","isfile","isfile(path) -> Bool - Wait for and get the value of a remote reference. + Returns \"true\" if \"path\" is a regular file, \"false\" + otherwise. "), -("Parallel Computing","Base","remote_call_wait","remote_call_wait(id, func, args...) +("Filesystem","Base","islink","islink(path) -> Bool - Perform \"wait(remote_call(...))\" in one message. + Returns \"true\" if \"path\" is a symbolic link, \"false\" + otherwise. "), -("Parallel Computing","Base","remote_call_fetch","remote_call_fetch(id, func, args...) +("Filesystem","Base","ispath","ispath(path) -> Bool - Perform \"fetch(remote_call(...))\" in one message. + Returns \"true\" if \"path\" is a valid filesystem path, \"false\" + otherwise. "), -("Parallel Computing","Base","put","put(RemoteRef, value) +("Filesystem","Base","isreadable","isreadable(path) -> Bool - 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 \"true\" if the current user has permission to read + \"path\", \"false\" otherwise. "), -("Parallel Computing","Base","take","take(RemoteRef) +("Filesystem","Base","issetgid","issetgid(path) -> Bool - Fetch the value of a remote reference, removing it so that the - reference is empty again. + Returns \"true\" if \"path\" has the setgid flag set, \"false\" + otherwise. "), -("Parallel Computing","Base","RemoteRef","RemoteRef() +("Filesystem","Base","issetuid","issetuid(path) -> Bool - Make an uninitialized remote reference on the local machine. + Returns \"true\" if \"path\" has the setuid flag set, \"false\" + otherwise. "), -("Parallel Computing","Base","RemoteRef","RemoteRef(n) +("Filesystem","Base","issocket","issocket(path) -> Bool - Make an uninitialized remote reference on processor \"n\". + Returns \"true\" if \"path\" is a socket, \"false\" otherwise. "), -("Distributed Arrays","Base","DArray","DArray(init, dims[, procs, dist]) +("Filesystem","Base","issticky","issticky(path) -> Bool - Construct a distributed array. \"init\" is a function accepting a - tuple of index ranges. This function should return a chunk of the - distributed array for the specified indexes. \"dims\" is the - overall size of the distributed array. \"procs\" optionally - specifies a vector of processor IDs to use. \"dist\" is an integer - vector specifying how many chunks the distributed array should be - divided into in each dimension. + Returns \"true\" if \"path\" has the sticky bit set, \"false\" + otherwise. "), -("Distributed Arrays","Base","dzeros","dzeros(dims, ...) +("Filesystem","Base","iswriteable","iswriteable(path) -> Bool - Construct a distributed array of zeros. Trailing arguments are the - same as those accepted by \"darray\". + Returns \"true\" if the current user has permission to write to + \"path\", \"false\" otherwise. "), -("Distributed Arrays","Base","dones","dones(dims, ...) - Construct a distributed array of ones. Trailing arguments are the - same as those accepted by \"darray\". +("Linear Algebra","","*","*(A, B) + + Matrix multiplication "), -("Distributed Arrays","Base","dfill","dfill(x, dims, ...) +("Linear Algebra","","\\","\\(A, B) - Construct a distributed array filled with value \"x\". Trailing - arguments are the same as those accepted by \"darray\". + 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 + \"A\". A direct solver is used for upper- or lower triangular + \"A\". For Hermitian \"A\" (equivalent to symmetric \"A\" for non- + complex \"A\") the BunchKaufman factorization is used. Otherwise + an LU factorization is used. For rectangular \"A\" the result is + the minimum-norm least squares solution computed by reducing \"A\" + to bidiagonal form and solving the bidiagonal least squares + problem. For sparse, square \"A\" the LU factorization (from + UMFPACK) is used. "), -("Distributed Arrays","Base","drand","drand(dims, ...) +("Linear Algebra","","dot","dot(x, y) - Construct a distributed uniform random array. Trailing arguments - are the same as those accepted by \"darray\". + Compute the dot product "), -("Distributed Arrays","Base","drandn","drandn(dims, ...) +("Linear Algebra","","cross","cross(x, y) - Construct a distributed normal random array. Trailing arguments are - the same as those accepted by \"darray\". + Compute the cross product of two 3-vectors "), -("Distributed Arrays","Base","distribute","distribute(a) +("Linear Algebra","","norm","norm(a) - Convert a local array to distributed + Compute the norm of a \"Vector\" or a \"Matrix\" "), -("Distributed Arrays","Base","localize","localize(d) +("Linear Algebra","","lu","lu(A) -> L, U, P - Get the local piece of a distributed array + Compute the LU factorization of \"A\", such that \"P*A = L*U\". "), -("Distributed Arrays","Base","myindexes","myindexes(d) +("Linear Algebra","","lufact","lufact(A) -> LUDense - A tuple describing the indexes owned by the local processor + Compute the LU factorization of \"A\", returning an \"LUDense\" + object for dense \"A\" or an \"UmfpackLU\" object for sparse \"A\". + The individual components of the factorization \"F\" can be accesed + by indexing: \"F[:L]\", \"F[:U]\", and \"F[:P]\" (permutation + matrix) or \"F[:p]\" (permutation vector). An \"UmfpackLU\" object + has additional components \"F[:q]\" (the left permutation vector) + and \"Rs\" the vector of scaling factors. The following functions + are available for both \"LUDense\" and \"UmfpackLU\" objects: + \"size\", \"\\\" and \"det\". For \"LUDense\" there is also an + \"inv\" method. The sparse LU factorization is such that \"L*U\" + is equal to``diagmm(Rs,A)[p,q]``. "), -("Distributed Arrays","Base","procs","procs(d) +("Linear Algebra","","lufact!","lufact!(A) -> LUDense - Get the vector of processors storing pieces of \"d\" + \"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, + \"colptr\" and \"rowval\" are decremented in place, converting from + 1-based indices to 0-based indices. "), -("System","Base","run","run(command) +("Linear Algebra","","chol","chol(A[, LU]) -> F - Run a command object, constructed with backticks. Throws an error - if anything goes wrong, including the process exiting with a non- - zero status. + Compute 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\". "), -("System","Base","spawn","spawn(command) +("Linear Algebra","","cholfact","cholfact(A[, LU]) -> CholeskyDense - Run a command object asynchronously, returning the resulting - \"Process\" object. + Compute the Cholesky factorization of a dense symmetric positive- + definite matrix \"A\" and return a \"CholeskyDense\" object. \"LU\" + may be 'L' for using the lower part or 'U' for the upper part. The + default is to use 'U'. The triangular matrix can be obtained from + the factorization \"F\" with: \"F[:L]\" and \"F[:U]\". The + following functions are available for \"CholeskyDense\" objects: + \"size\", \"\\\", \"inv\", \"det\". A \"LAPACK.PosDefException\" + error is thrown in case the matrix is not positive definite. "), -("System","Base","success","success(command) +("Linear Algebra","","cholfact","cholfact(A[, ll]) -> CholmodFactor - Run a command object, constructed with backticks, and tell whether - it was successful (exited with a code of 0). + 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 + fill-reducing permutation is used. Methods for \"size\", + \"solve\", \"\\\", \"findn_nzs\", \"diag\", \"det\" and \"logdet\". + One of the solve methods includes an integer argument that can be + used to solve systems involving parts of the factorization only. + The optional boolean argument, \"ll\" determines whether the + factorization returned is of the \"A[p,p] = L*L'\" form, where + \"L\" is lower triangular or \"A[p,p] = diagmm(L,D)*L'\" form where + \"L\" is unit lower triangular and \"D\" is a non-negative vector. + The default is LDL. "), -("System","Base","readsfrom","readsfrom(command) +("Linear Algebra","","cholpfact","cholpfact(A[, LU]) -> CholeskyPivotedDense - Starts running a command asynchronously, and returns a tuple - (stream,process). The first value is a stream reading from the - process' standard output. + Compute the pivoted Cholesky factorization of a symmetric positive + semi-definite matrix \"A\" and return a \"CholeskyDensePivoted\" + object. \"LU\" may be 'L' for using the lower part or 'U' for the + upper part. The default is to use 'U'. The triangular factors + containted in the factorization \"F\" can be obtained with + \"F[:L]\" and \"F[:U]\", whereas the permutation can be obtained + with \"F[:P]\" or \"F[:p]\". The following functions are available + for \"CholeskyDensePivoted\" objects: \"size\", \"\\\", \"inv\", + \"det\". A \"LAPACK.RankDeficientException\" error is thrown in + case the matrix is rank deficient. "), -("System","Base","writesto","writesto(command) +("Linear Algebra","","cholpfact!","cholpfact!(A[, LU]) -> CholeskyPivotedDense - Starts running a command asynchronously, and returns a tuple - (stream,process). The first value is a stream writing to the - process' standard input. + \"cholpfact!\" is the same as \"cholpfact\" but saves space by + overwriting the input A, instead of creating a copy. "), -("System","Base","readandwrite","readandwrite(command) +("Linear Algebra","","qr","qr(A) -> Q, R - 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. + Compute the QR factorization of \"A\" such that \"A = Q*R\". Also + see \"qrfact\". "), -("System","Base",">",">() +("Linear Algebra","","qrfact","qrfact(A) - Redirect standard output of a process. + Compute the QR factorization of \"A\" and return a \"QRDense\" + object. The coomponents of the factorization \"F\" can be accessed + as follows: the orthogonal matrix \"Q\" can be extracted with + \"F[:Q]\" and the triangular matrix \"R\" with \"F[:R]\". The + following functions are available for \"QRDense\" objects: + \"size\", \"\\\". When \"Q\" is extracted, the resulting type is + the \"QRDenseQ\" object, and has the \"*\" operator overloaded to + support efficient multiplication by \"Q\" and \"Q'\". - **Example**: \"run(`ls` > \"out.log\")\" +"), + +("Linear Algebra","","qrfact!","qrfact!(A) + + \"qrfact!\" is the same as \"qrfact\" but saves space by + overwriting the input A, instead of creating a copy. "), -("System","Base","<","<() +("Linear Algebra","","qrp","qrp(A) -> Q, R, P - Redirect standard input of a process. + Compute the QR factorization of \"A\" with pivoting, such that + \"A*P = Q*R\", Also see \"qrpfact\". "), -("System","Base",">>",">>() +("Linear Algebra","","qrpfact","qrpfact(A) -> QRPivotedDense - Redirect standard output of a process, appending to the destination - file. + Compute the QR factorization of \"A\" with pivoting and return a + \"QRDensePivoted\" object. The components of the factorization + \"F\" can be accessed as follows: the orthogonal matrix \"Q\" can + be extracted with \"F[:Q]\", the triangular matrix \"R\" with + \"F[:R]\", and the permutation with \"F[:P]\" or \"F[:p]\". The + following functions are available for \"QRDensePivoted\" objects: + \"size\", \"\\\". When \"Q\" is extracted, the resulting type is + the \"QRDenseQ\" object, and has the \"*\" operator overloaded to + support efficient multiplication by \"Q\" and \"Q'\". A + \"QRDenseQ\" matrix can be converted into a regular matrix with + \"full\". "), -("System","Base",".>",".>() +("Linear Algebra","","qrpfact!","qrpfact!(A) -> QRPivotedDense - Redirect the standard error stream of a process. + \"qrpfact!\" is the same as \"qrpfact\" but saves space by + overwriting the input A, instead of creating a copy. "), -("System","Base","gethostname","gethostname() -> String +("Linear Algebra","","sqrtm","sqrtm(A) - Get the local machine's host name. + Compute the matrix square root of \"A\". If \"B = sqrtm(A)\", then + \"B*B == A\" within roundoff error. "), -("System","Base","getipaddr","getipaddr() -> String +("Linear Algebra","","eig","eig(A) -> D, V - Get the IP address of the local machine, as a string of the form - \"x.x.x.x\". + Compute eigenvalues and eigenvectors of A "), -("System","Base","pwd","pwd() -> String +("Linear Algebra","","eigvals","eigvals(A) - Get the current working directory. + Returns the eigenvalues of \"A\". "), -("System","Base","cd","cd(dir::String) +("Linear Algebra","","eigfact","eigfact(A) - Set the current working directory. Returns the new current - directory. + Compute the eigenvalue decomposition of \"A\" and return an + \"EigenDense\" object. If \"F\" is the factorization object, the + eigenvalues can be accessed with \"F[:values]\" and the + eigenvectors with \"F[:vectors]\". The following functions are + available for \"EigenDense\" objects: \"inv\", \"det\". "), -("System","Base","cd","cd(f[, \"dir\"]) +("Linear Algebra","","eigfact!","eigfact!(A) - Temporarily changes the current working directory (HOME if not - specified) and applies function f before returning. + \"eigfact!\" is the same as \"eigfact\" but saves space by + overwriting the input A, instead of creating a copy. "), -("System","Base","mkdir","mkdir(path[, mode]) +("Linear Algebra","","hessfact","hessfact(A) - Make a new directory with name \"path\" and permissions \"mode\". - \"mode\" defaults to 0o777, modified by the current file creation - mask. + Compute the Hessenberg decomposition of \"A\" and return a + \"HessenbergDense\" object. If \"F\" is the factorization object, + the unitary matrix can be accessed with \"F[:Q]\" and the + Hessenberg matrix with \"F[:H]\". When \"Q\" is extracted, the + resulting type is the \"HessenbergDenseQ\" object, and may be + converted to a regular matrix with \"full\". "), -("System","Base","rmdir","rmdir(path) +("Linear Algebra","","hessfact!","hessfact!(A) - Remove the directory named \"path\". + \"hessfact!\" is the same as \"hessfact\" but saves space by + overwriting the input A, instead of creating a copy. "), -("System","Base","getpid","getpid() -> Int32 +("Linear Algebra","","svdfact","svdfact(A[, thin]) -> SVDDense - Get julia's process ID. + Compute the Singular Value Decomposition (SVD) of \"A\" and return + an \"SVDDense\" object. \"U\", \"S\", \"V\" and \"Vt\" can be + obtained from the factorization \"F\" with \"F[:U]\", \"F[:S]\", + \"F[:V]\" and \"F[:Vt]\", such that \"A = U*diagm(S)*Vt\". If + \"thin\" is \"true\", an economy mode decomposition is returned. + The algorithm produces \"Vt\" and hence \"Vt\" is more efficient to + extract than \"V\". "), -("System","Base","time","time() +("Linear Algebra","","svdfact!","svdfact!(A[, thin]) -> SVDDense - Get the system time in seconds since the epoch, with fairly high - (typically, microsecond) resolution. + \"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. "), -("System","Base","time_ns","time_ns() +("Linear Algebra","","svd","svd(A[, thin]) -> U, S, V - Get the time in nanoseconds. The time corresponding to 0 is - undefined, and wraps every 5.8 years. + Compute the SVD of A, returning \"U\", vector \"S\", and \"V\" such + that \"A == U*diagm(S)*V'\". If \"thin\" is \"true\", an economy + mode decomposition is returned. "), -("System","Base","tic","tic() +("Linear Algebra","","svdvals","svdvals(A) - 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. + Returns the singular values of \"A\". "), -("System","Base","toc","toc() +("Linear Algebra","","svdvals!","svdvals!(A) - Print and return the time elapsed since the last \"tic()\". + Returns the singular values of \"A\", while saving space by + overwriting the input. "), -("System","Base","toq","toq() +("Linear Algebra","","svdfact","svdfact(A, B) -> GSVDDense - Return, but do not print, the time elapsed since the last - \"tic()\". + Compute the generalized SVD of \"A\" and \"B\", returning a + \"GSVDDense\" Factorization object, such that \"A = U*D1*R0*Q'\" + and \"B = V*D2*R0*Q'\". "), -("System","Base","EnvHash","EnvHash() -> EnvHash +("Linear Algebra","","svd","svd(A, B) -> U, V, Q, D1, D2, R0 - A singleton of this type provides a hash table interface to - environment variables. + Compute the generalized SVD of \"A\" and \"B\", returning \"U\", + \"V\", \"Q\", \"D1\", \"D2\", and \"R0\" such that \"A = + U*D1*R0*Q'\" and \"B = V*D2*R0*Q'\". "), -("System","Base","ENV","ENV +("Linear Algebra","","svdvals","svdvals(A, B) - Reference to the singleton \"EnvHash\", providing a dictionary - interface to system environment variables. + Return only the singular values from the generalized singular value + decomposition of \"A\" and \"B\". "), -("C Interface","Base","ccall","ccall((symbol, library) or fptr, RetType, (ArgType1, ...), ArgVar1, ...) +("Linear Algebra","","triu","triu(M) - Call function in C-exported shared library, specified by (function - name, library) tuple (String or :Symbol). Alternatively, ccall may - be used to call a function pointer returned by dlsym, but note that - this usage is generally discouraged to facilitate future static - compilation. + Upper triangle of a matrix "), -("C Interface","Base","cfunction","cfunction(fun::Function, RetType::Type, (ArgTypes...)) +("Linear Algebra","","tril","tril(M) - Generate C-callable function pointer from Julia function. + Lower triangle of a matrix "), -("C Interface","Base","dlopen","dlopen(libfile::String[, flags::Integer]) +("Linear Algebra","","diag","diag(M[, k]) - Load a shared library, returning an opaque handle. + The \"k\"-th diagonal of a matrix, as a vector - The optional flags argument is a bitwise-or of zero or more of - RTLD_LOCAL, RTLD_GLOBAL, RTLD_LAZY, RTLD_NOW, RTLD_NODELETE, - RTLD_NOLOAD, RTLD_DEEPBIND, and RTLD_FIRST. These are converted to - the corresponding flags of the POSIX (and/or GNU libc and/or MacOS) - dlopen command, if possible, or are ignored if the specified - functionality is not available on the current platform. The - default is RTLD_LAZY|RTLD_DEEPBIND|RTLD_LOCAL. An important usage - of these flags, on POSIX platforms, is to specify - RTLD_LAZY|RTLD_DEEPBIND|RTLD_GLOBAL in order for the library's - symbols to be available for usage in other shared libraries, in - situations where there are dependencies between shared libraries. +"), + +("Linear Algebra","","diagm","diagm(v[, k]) + + Construct a diagonal matrix and place \"v\" on the \"k\"-th + diagonal "), -("C Interface","Base","dlsym","dlsym(handle, sym) +("Linear Algebra","","diagmm","diagmm(matrix, vector) - Look up a symbol from a shared library handle, return callable - function pointer on success. + Multiply matrices, interpreting the vector argument as a diagonal + matrix. The arguments may occur in the other order to multiply with + the diagonal matrix on the left. "), -("C Interface","Base","dlsym_e","dlsym_e(handle, sym) +("Linear Algebra","","Tridiagonal","Tridiagonal(dl, d, du) - Look up a symbol from a shared library handle, silently return NULL - pointer on lookup failure. + Construct a tridiagonal matrix from the lower diagonal, diagonal, + and upper diagonal "), -("C Interface","Base","dlclose","dlclose(handle) +("Linear Algebra","","Woodbury","Woodbury(A, U, C, V) - Close shared library referenced by handle. + Construct a matrix in a form suitable for applying the Woodbury + matrix identity "), -("C Interface","Base","c_free","c_free(addr::Ptr) +("Linear Algebra","","rank","rank(M) - Call free() from C standard library. + Compute the rank of a matrix "), -("C Interface","Base","unsafe_ref","unsafe_ref(p::Ptr{T}, i::Integer) +("Linear Algebra","","norm","norm(A[, p]) - Dereference the pointer \"p[i]\" or \"*p\", returning a copy of - type T. + Compute the \"p\"-norm of a vector or a matrix. \"p\" is \"2\" by + default, if not provided. If \"A\" is a vector, \"norm(A, p)\" + computes the \"p\"-norm. \"norm(A, Inf)\" returns the largest value + in \"abs(A)\", whereas \"norm(A, -Inf)\" returns the smallest. If + \"A\" is a matrix, valid values for \"p\" are \"1\", \"2\", or + \"Inf\". In order to compute the Frobenius norm, use \"normfro\". "), -("C Interface","Base","unsafe_assign","unsafe_assign(p::Ptr{T}, x, i::Integer) +("Linear Algebra","","normfro","normfro(A) - Assign to the pointer \"p[i] = x\" or \"*p = x\", making a copy of - object x into the memory at p. + Compute the Frobenius norm of a matrix \"A\". "), -("C Interface","Base","pointer","pointer(a[, index]) +("Linear Algebra","","cond","cond(M[, p]) - Get the native address of an array element. Be careful to ensure - that a julia reference to \"a\" exists as long as this pointer will - be used. + Matrix condition number, computed using the p-norm. \"p\" is 2 by + default, if not provided. Valid values for \"p\" are \"1\", \"2\", + or \"Inf\". "), -("C Interface","Base","pointer","pointer(type, int) +("Linear Algebra","","trace","trace(M) - Convert an integer to a pointer of the specified element type. + Matrix trace "), -("C Interface","Base","pointer_to_array","pointer_to_array(p, dims[, own]) +("Linear Algebra","","det","det(M) - 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, - calling \"free\" on the pointer when the array is no longer - referenced. + Matrix determinant "), -("Errors","Base","error","error(message::String) +("Linear Algebra","","inv","inv(M) - Raise an error with the given message + Matrix inverse "), -("Errors","Base","throw","throw(e) +("Linear Algebra","","pinv","pinv(M) - Throw an object as an exception + Moore-Penrose inverse "), -("Errors","Base","errno","errno() +("Linear Algebra","","null","null(M) - Get the value of the C library's \"errno\" + Basis for null space of M. "), -("Errors","Base","strerror","strerror(n) +("Linear Algebra","","repmat","repmat(A, n, m) - Convert a system call error code to a descriptive string + Construct a matrix by repeating the given matrix \"n\" times in + dimension 1 and \"m\" times in dimension 2. "), -("Errors","Base","assert","assert(cond) +("Linear Algebra","","kron","kron(A, B) - Raise an error if \"cond\" is false. Also available as the macro - \"@assert expr\". + Kronecker tensor product of two vectors or two matrices. "), -("Tasks","Base","Task","Task(func) +("Linear Algebra","","linreg","linreg(x, y) - Create a \"Task\" (i.e. thread, or coroutine) to execute the given - function. The task exits when this function returns. + Determine parameters \"[a, b]\" that minimize the squared error + between \"y\" and \"a+b*x\". "), -("Tasks","Base","yieldto","yieldto(task, args...) +("Linear Algebra","","linreg","linreg(x, y, w) - Switch to the given task. The first time a task is switched to, the - task's function is called with \"args\". On subsequent switches, - \"args\" are returned from the task's last call to \"yieldto\". + Weighted least-squares linear regression. "), -("Tasks","Base","current_task","current_task() +("Linear Algebra","","expm","expm(A) - Get the currently running Task. + Matrix exponential. "), -("Tasks","Base","istaskdone","istaskdone(task) +("Linear Algebra","","issym","issym(A) - Tell whether a task has exited. + Test whether a matrix is symmetric. "), -("Tasks","Base","consume","consume(task) +("Linear Algebra","","isposdef","isposdef(A) - Receive the next value passed to \"produce\" by the specified task. + Test whether a matrix is positive-definite. "), -("Tasks","Base","produce","produce(value) +("Linear Algebra","","istril","istril(A) - Send the given value to the last \"consume\" call, switching to the - consumer task. + Test whether a matrix is lower-triangular. "), -("Tasks","Base","make_scheduled","make_scheduled(task) +("Linear Algebra","","istriu","istriu(A) - Register a task with the main event loop, so it will automatically - run when possible. + Test whether a matrix is upper-triangular. "), -("Tasks","Base","yield","yield() +("Linear Algebra","","ishermitian","ishermitian(A) - For scheduled tasks, switch back to the scheduler to allow another - scheduled task to run. + Test whether a matrix is hermitian. "), -("Tasks","Base","tls","tls(symbol) +("Linear Algebra","","transpose","transpose(A) - Look up the value of a symbol in the current task's task-local - storage. + The transpose operator (.'). "), -("Tasks","Base","tls","tls(symbol, value) +("Linear Algebra","","ctranspose","ctranspose(A) - Assign a value to a symbol in the current task's task-local - storage. + The conjugate transpose operator ('). "), -("BLAS","BLAS","copy!","copy!(n, X, incx, Y, incy) +("BLAS Functions","","copy!","copy!(n, X, incx, Y, incy) Copy \"n\" elements of array \"X\" with stride \"incx\" to array \"Y\" with stride \"incy\". Returns \"Y\". "), -("BLAS","BLAS","dot","dot(n, X, incx, Y, incy) +("BLAS Functions","","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 @@ -5169,20 +5252,20 @@ "), -("BLAS","BLAS","nrm2","nrm2(n, X, incx) +("BLAS Functions","","nrm2","nrm2(n, X, incx) 2-norm of a vector consisting of \"n\" elements of array \"X\" with stride \"incx\". "), -("BLAS","BLAS","axpy!","axpy!(n, a, X, incx, Y, incy) +("BLAS Functions","","axpy!","axpy!(n, a, X, incx, Y, incy) Overwrite \"Y\" with \"a*X + Y\". Returns \"Y\". "), -("BLAS","BLAS","syrk!","syrk!(uplo, trans, alpha, A, beta, C) +("BLAS Functions","","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\" @@ -5191,7 +5274,7 @@ "), -("BLAS","BLAS","syrk","syrk(uplo, trans, alpha, A) +("BLAS Functions","","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\", @@ -5199,7 +5282,7 @@ "), -("BLAS","BLAS","herk!","herk!(uplo, trans, alpha, A, beta, C) +("BLAS Functions","","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\" @@ -5209,7 +5292,7 @@ "), -("BLAS","BLAS","herk","herk(uplo, trans, alpha, A) +("BLAS Functions","","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 @@ -5218,7 +5301,7 @@ "), -("BLAS","BLAS","gbmv!","gbmv!(trans, m, kl, ku, alpha, A, x, beta, y) +("BLAS Functions","","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 @@ -5228,7 +5311,7 @@ "), -("BLAS","BLAS","gbmv","gbmv(trans, m, kl, ku, alpha, A, x, beta, y) +("BLAS Functions","","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 @@ -5237,7 +5320,7 @@ "), -("BLAS","BLAS","sbmv!","sbmv!(uplo, k, alpha, A, x, beta, y) +("BLAS Functions","","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- @@ -5249,7 +5332,7 @@ "), -("BLAS","BLAS","sbmv","sbmv(uplo, k, alpha, A, x) +("BLAS Functions","","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 @@ -5257,7 +5340,7 @@ "), -("BLAS","BLAS","gemm!","gemm!(tA, tB, alpha, A, B, beta, C) +("BLAS Functions","","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 @@ -5265,154 +5348,13 @@ "), -("BLAS","BLAS","gemm","gemm(tA, tB, alpha, A, B) +("BLAS Functions","","gemm","gemm(tA, tB, alpha, A, B) Returns \"alpha*A*B\" or the other three variants according to \"tA\" (transpose \"A\") and \"tB\". "), -("Constants","Base","OS_NAME","OS_NAME - - A symbol representing the name of the operating system. Possible - values are \":Linux\", \":Darwin\" (OS X), or \":Windows\". - -"), - -("Constants","Base","ARGS","ARGS - - An array of the command line arguments passed to Julia, as strings. - -"), - -("Constants","Base","C_NULL","C_NULL - - The C null pointer constant, sometimes used when calling external - code. - -"), - -("Constants","Base","CPU_CORES","CPU_CORES - - The number of CPU cores in the system. - -"), - -("Constants","Base","WORD_SIZE","WORD_SIZE - - Standard word size on the current machine, in bits. - -"), - -("Constants","Base","VERSION","VERSION - - An object describing which version of Julia is in use. - -"), - -("Constants","Base","LOAD_PATH","LOAD_PATH - - An array of paths (as strings) where the \"require\" function looks - for code. - -"), - -("Filesystem","Base","isblockdev","isblockdev(path) -> Bool - - Returns \"true\" if \"path\" is a block device, \"false\" - otherwise. - -"), - -("Filesystem","Base","ischardev","ischardev(path) -> Bool - - Returns \"true\" if \"path\" is a character device, \"false\" - otherwise. - -"), - -("Filesystem","Base","isdir","isdir(path) -> Bool - - Returns \"true\" if \"path\" is a directory, \"false\" otherwise. - -"), - -("Filesystem","Base","isexecutable","isexecutable(path) -> Bool - - Returns \"true\" if the current user has permission to execute - \"path\", \"false\" otherwise. - -"), - -("Filesystem","Base","isfifo","isfifo(path) -> Bool - - Returns \"true\" if \"path\" is a FIFO, \"false\" otherwise. - -"), - -("Filesystem","Base","isfile","isfile(path) -> Bool - - Returns \"true\" if \"path\" is a regular file, \"false\" - otherwise. - -"), - -("Filesystem","Base","islink","islink(path) -> Bool - - Returns \"true\" if \"path\" is a symbolic link, \"false\" - otherwise. - -"), - -("Filesystem","Base","ispath","ispath(path) -> Bool - - Returns \"true\" if \"path\" is a valid filesystem path, \"false\" - otherwise. - -"), - -("Filesystem","Base","isreadable","isreadable(path) -> Bool - - Returns \"true\" if the current user has permission to read - \"path\", \"false\" otherwise. - -"), - -("Filesystem","Base","issetgid","issetgid(path) -> Bool - - Returns \"true\" if \"path\" has the setgid flag set, \"false\" - otherwise. - -"), - -("Filesystem","Base","issetuid","issetuid(path) -> Bool - - Returns \"true\" if \"path\" has the setuid flag set, \"false\" - otherwise. - -"), - -("Filesystem","Base","issocket","issocket(path) -> Bool - - Returns \"true\" if \"path\" is a socket, \"false\" otherwise. - -"), - -("Filesystem","Base","issticky","issticky(path) -> Bool - - Returns \"true\" if \"path\" has the sticky bit set, \"false\" - otherwise. - -"), - -("Filesystem","Base","iswriteable","iswriteable(path) -> Bool - - Returns \"true\" if the current user has permission to write to - \"path\", \"false\" otherwise. - -"), - - ("Punctuation","","punctuation","punctuation +-----------+---------------------------------------------------------------------------------------------+ @@ -5569,5 +5511,109 @@ "), +("Sparse Matrices","","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 + set to \"max(I)\" and \"max(J)\" respectively. If the \"combine\" + function is not supplied, duplicates are added by default. + +"), + +("Sparse Matrices","","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 + vectors are really just sparse matrices with one column. Given + Julia's Compressed Sparse Columns (CSC) storage format, a sparse + column matrix with one column is sparse, whereas a sparse row + matrix with one row ends up being dense. + +"), + +("Sparse Matrices","","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. + +"), + +("Sparse Matrices","","issparse","issparse(S) + + Returns \"true\" if \"S\" is sparse, and \"false\" otherwise. + +"), + +("Sparse Matrices","","sparse","sparse(A) + + Convert a dense matrix \"A\" into a sparse matrix. + +"), + +("Sparse Matrices","","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. + +"), + +("Sparse Matrices","","dense","dense(S) + + Convert a sparse matrix \"S\" into a dense matrix. + +"), + +("Sparse Matrices","","full","full(S) + + Convert a sparse matrix \"S\" into a dense matrix. + +"), + +("Sparse Matrices","","spzeros","spzeros(m, n) + + Create an empty sparse matrix of size \"m x n\". + +"), + +("Sparse Matrices","","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\". + +"), + +("Sparse Matrices","","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\". + +"), + +("Sparse Matrices","","sprand","sprand(m, n, density[, rng]) + + Create a random sparse matrix with the specified density. Nonzeros + are sampled from the distribution specified by \"rng\". The uniform + distribution is used in case \"rng\" is not specified. + +"), + +("Sparse Matrices","","sprandn","sprandn(m, n, density) + + Create a random sparse matrix of specified density with nonzeros + sampled from the normal distribution. + +"), + +("Sparse Matrices","","sprandbool","sprandbool(m, n, density) + + Create a random sparse boolean matrix with the specified density. + +"), + }