Reference of auxilliaries

@allocdiff

A macro to evaluate an expression, discarding the resulting value, instead returning the difference in the number of bytes allocated after vs. before evaluation of the expression (which is not guaranteed to be the peak, but allows to capture allocations done in third-party libraries that don't use Julia's GC, contrary to @allocated). In order to provide consistent results, Julia's GC is disabled while the expression is evaluated. Note that on *nix systems, the value is only accurate up to the kibibyte.

keepcol!(A::Union{<:Matrix,<:SparseMatrixCSC}, m::AbstractVector{Bool})

Only keep the columns in the matrix A that are true in the vector m (which must have the same length as size(A, 2)). The output is logically the same as A[:, m]; however, note that the data underlying A is mutated: this function does not create a copy. The function returns the new matrix; the old one should no longer be used (it might become invalid, as the sparse matrix struct is immutable).

issubset_sorted(a, b)

Equivalent to issubset(a, b), but assumes that both a and b are sorted vectors.

unique_outer_groupings(grouping::AbstractVector{<:IntMonomial}[, result::Set])

Computes a set of all unique groupings that are produced via groupings * groupings'. For purely complex-valued groupings, this is the full list; as soon as we have a real variable present, it is smaller. Returns a set of FastKey-wrapped monomial indices, a boolean indicating whether the grouping is effectively real-valued, and the number of (real-valued) equalities that arise from this grouping (which should be multiplied by 2 if the groupings are to be multiplied by a complex-valued constraint). If present, the data will be appended to the result parameter.

chordal_cliques!(graphs::Graphs.SimpleGraph; alg::CliqueTrees.EliminationAlgorithm=CliqueTrees.MF())

Make the given graph chordal, and then calculate its maximal cliques.

chordal_cliques(graph::Graphs.SimpleGraph; alg::CliqueTrees.EliminationAlgorithm=CliqueTrees.MF())

Non-mutating version of chordal_cliques!

sort_along!(v::AbstractVector, along::AbstractVector...; lo=1, hi=length(v),
    o=Base.Order.Forward, relevant=1)

This helper function sorts the vector v as sort! would do, but at the same time puts all vectors in along in the same order as v. Therefore, sort_along!(v, a, b, c) is equivalent to

p = sortperm(v)
permute!.((v, a, b, c), (p,))

but does not require any new intermediate allocations. Note that by increasing relevant (to at most 1 + length(along)), additional vectors in along can be taken into account when breaking ties in v.

FastVec{V}(undef, n::Integer; buffer::Integer=n)

Creates a new FastVec, which is a vector of elements of type V. The elements are initially undefined; there are n items. The vector has a capacity of size buffer; while it can hold arbitrarily many, pushing to the vector is fast as long as the capacity is not exceeded.

sizehint!(v::FastVec, len::Integer)

Changes the size of the internal buffer that is kept available to quickly manage pushing into the vector. If len is smaller than the actual length of this vector, this is a no-op.

resize!(v::FastVec, n::Integer)

Ensures that the internal buffer can hold at least n items (meaning that larger buffers will not be shrunk, but smaller ones will be increased to exactly n) and sets the length of the vector to n.

empty!(v::FastVec)

Clears the vector without freeing the internal buffer.

prepare_push!(v::FastVec, new_items::Integer)

Prepares pushing (or appending) at last new_items in the future, in one or multiple calls. This ensures that the internal buffer is large enough to hold all the new items that will be pushed without allocations in between.

push!(v::FastVec, el)

Adds el to the end of v, increasing the length of v by one. If there is not enough space, grows v. Note that if you made sure beforehand that the capacity of v is sufficient for the addition of this element, consider calling unsafe_push! instead, which avoids the length check.

unsafe_push!(v::FastVec, el)

Adds el to the end of v, increasing the length of v by one. This function assumes that the internal buffer of v holds enough space to add at least one element; if this is not the case, it will lead to memory corruption. Call push! instead if you cannot guarantee the necessary buffer size.

insert!(v::FastVec, index::Integer, el)

Insert an el into v at the given index. index is the index of item in the resulting v. Note that if you made sure beforehand that the capacity of v is sufficient for the addition of this element, consider calling unsafe_insert! instead, which avoids the length check.

unsafe_insert!(v::FastVec, index::Integer, el)

Insert an el into v at the given index. index is the index of item in the resulting v. This function assumes that the internal buffer of v holds enough space to add at least one element; if this is not the case, it will lead to memory corruption. Call insert! instead if you cannot guarantee the necessary buffer size.

append!(v::FastVec, els)

Appends all items in els to the end of v, increasing the length of v by length(els). If there is not enough space, grows v. Note that if you made sure beforehand that the capacity of v is sufficient for the addition of these elements, consider calling unsafe_append! instead, which avoids the length check.

unsafe_append!(v::FastVec, els)

Appends all items in els to the end of v, increasing the length of v by length(els). This function assumes that the internal buffer of v holds enough space to add at least all elements in els; if this is not the case, it will lead to memory corruption. Call append! instead if you cannot guarantee the necessary buffer size.

prepend!(v::FastVec, els)

Prepends all items in els to the beginning of v, increasing the length v by length(els). If there is not enough space, grows v. Note that if you made sure beforehand that the capacity of v is sufficient for the addition of these elements, consider calling unsafe_prepend! instead, which avoids the length check.

unsafe_prepend!(v::FastVec, els::AbstractVector)

Prepends all items in els to the beginning of v, increasing the length v by length(els). This function assumes that the internal buffer of v holds enough space to add at least all elements in els; if this is not the case, it will lead to memory corruption. Call prepend! instead if you cannot guarantee the necessary buffer size.

splice!(v::FastVec, index::Integer, [replacement]) -> item

Remove the item at the given index, and return the removed item. Subsequent items are shifted left to fill the resulting gap. If specified, replacement values from an ordered collection will be spliced in place of the removed item. No unsafe version of this function exists. To insert replacement before an index n without removing any items, use splice!(collection, n:n-1, replacement).

similar(v::FastVec)

Creates a FastVec of the same type and length as v. All the common variants to supply different element types or lengths are also available; when changing the length, you might additionally specify the keyword argument buffer that also allows to change the internal buffer size.

copyto!(dest::FastVec, doffs::Integer, src::FastVec, soffs::Integer, n::Integer)
copyto!(dest::Array, doffs::Integer, src::FastVec, soffs::Integer, n::Integer)
copyto!(dest::FastVec, doffs::Integer, src::Array, soffs::Integer, n::Integer)

Implements the standard copyto! operation between FastVecs and also mixed with source or destination as an array.

deleteat!(a::FastVec, i)

Remove the item at the given i and return the modified a. Subsequent items are shifted to fill the resulting gap. The internal buffer size is not modified. The index must be either an integer or a unit range.

finish!(v::FastVec)

Returns the Vector representation that internally underlies the FastVec instance. This function should only be called when no further operations on the FastVec itself are carried out.