Internals

Layer

A structure to store a LittleDict of operations that can be selected during the learning phase of an ICN. If the layer is exclusive, only one operation can be selected at a time.

length(layer)

Return the number of operations in a layer.

Base.length(icn)

Return the total number of operations of an ICN.

_compose(icn)

Internal function called by compose and show_composition.

ag_count_positive(x)

Count the number of strictly positive elements of x.

ag_sum(x)

Aggregate through + a vector into a single scalar.

ar_prod(x)

Reduce k = length(x) vectors through product to a single vector.

ar_sum(x)

Reduce k = length(x) vectors through sum to a single vector.

as_bitvector(n::Int, max_n::Int = n)

Convert an Int to a BitVector of minimal size (relatively to max_n).

as_int(v::AbstractVector)

Convert a BitVector into an Int.

co_abs_diff_val_param(x; param)

Return the absolute difference between x and param.

co_abs_diff_val_vars(x; nvars)

Return the absolute difference between x and the number of variables nvars.

co_euclidian(x; dom_size)

Compute an euclidian norm with domain size dom_size of a scalar.

co_euclidian_param(x; param, dom_size)

Compute an euclidian norm with domain size dom_size, weigthed by param, of a scalar.

co_identity(x)

Identity function. Already defined in Julia as identity, specialized for scalars in the comparison layer.

co_param_minus_val(x; param)

Return the difference param - x if positive, 0.0 otherwise.

co_val_minus_param(x; param)

Return the difference x - param if positive, 0.0 otherwise.

co_val_minus_vars(x; nvars)

Return the difference x - nvars if positive, 0.0 otherwise, where nvars denotes the numbers of variables.

co_vars_minus_val(x; nvars)

Return the difference nvars - x if positive, 0.0 otherwise, where nvars denotes the numbers of variables.

exclu(layer)

Return true if the layer has mutually exclusive operations.

functions(layer)

Access the operations of a layer. The container is ordered.

generate(c::Composition, name, lang)

Generates the code of c in a specific language lang.

generate_inclusive_operations(predicate, bits)
generate_exclusive_operation(max_op_number)

Generates the operations (weigths) of a layer with inclusive/exclusive operations.

generate_weigths(layers)
generate_weigths(icn)

Generate the weigths of a collection of layers or of an ICN.

is_viable(layer, w)
is_viable(icn)
is_viable(icn, w)

Assert if a pair of layer/icn and weigths compose a viable pattern. If no weigths are given with an icn, it will check the current internal value.

layers(icn)

Return the ordered layers of an ICN.

map_tr!(f, x, X, param)

Return an anonymous function that applies f to all elements of x and store the result in X, with a parameter param (which is set to nothing for function with no parameter).

nbits_exclu(layer)

Convert the length of an exclusive layer into a number of bits.

reduce_symbols(symbols, sep)

Produce a formatted string that separates the symbols by sep. Used internally for show_composition.

selected_size(layer, layer_weigths)

Return the number of operations selected by layer_weigths in layer.

show_layer(layer)

Return a string that contains the elements in a layer.

symbol(layer, i)

Return the i-th symbols of the operations in a given layer.

tr_contiguous_vals_minus(i, x)
tr_contiguous_vals_minus(x)
tr_contiguous_vals_minus(x, X::AbstractVector)

Return the difference x[i] - x[i + 1] if positive, 0.0 otherwise. Extended method to vector with sig (x) are generated. When X is provided, the result is computed without allocations.

tr_contiguous_vals_minus_rev(i, x)
tr_contiguous_vals_minus_rev(x)
tr_contiguous_vals_minus_rev(x, X::AbstractVector)

Return the difference x[i + 1] - x[i] if positive, 0.0 otherwise. Extended method to vector with sig (x) are generated. When X is provided, the result is computed without allocations.

tr_count_bounding_param(i, x; param)
tr_count_bounding_param(x; param)
tr_count_bounding_param(x, X::AbstractVector; param)

Count the number of elements bounded (not strictly) by x[i] and x[i] + param. An extended method to vector with sig (x, param) is generated. When X is provided, the result is computed without allocations.

tr_count_eq(i, x)
tr_count_eq(x)
tr_count_eq(x, X::AbstractVector)

Count the number of elements equal to x[i]. Extended method to vector with sig (x) are generated. When X is provided, the result is computed without allocations.

tr_count_eq_left(i, x)
tr_count_eq_left(x)
tr_count_eq_left(x, X::AbstractVector)

Count the number of elements to the left of and equal to x[i]. Extended method to vector with sig (x) are generated. When X is provided, the result is computed without allocations.

tr_count_eq_param(i, x; param)
tr_count_eq_param(x; param)
tr_count_eq_param(x, X::AbstractVector; param)

Count the number of elements equal to x[i] + param. Extended method to vector with sig (x, param) are generated. When X is provided, the result is computed without allocations.

tr_count_eq_right(i, x)
tr_count_eq_right(x)
tr_count_eq_right(x, X::AbstractVector)

Count the number of elements to the right of and equal to x[i]. Extended method to vector with sig (x) are generated. When X is provided, the result is computed without allocations.

tr_count_g_left(i, x)
tr_count_g_left(x)
tr_count_g_left(x, X::AbstractVector)

Count the number of elements to the left of and greater than x[i]. Extended method to vector with sig (x) are generated. When X is provided, the result is computed without allocations.

tr_count_g_param(i, x; param)
tr_count_g_param(x; param)
tr_count_g_param(x, X::AbstractVector; param)

Count the number of elements greater than x[i] + param. Extended method to vector with sig (x, param) are generated. When X is provided, the result is computed without allocations.

tr_count_g_right(i, x)
tr_count_g_right(x)
tr_count_g_right(x, X::AbstractVector)

Count the number of elements to the right of and greater than x[i]. Extended method to vector with sig (x) are generated.

tr_count_greater(i, x)
tr_count_greater(x)
tr_count_greater(x, X::AbstractVector)

Count the number of elements greater than x[i]. Extended method to vector with sig (x) are generated. When X is provided, the result is computed without allocations.

tr_count_l_left(i, x)
tr_count_l_left(x)
tr_count_l_left(x, X::AbstractVector)

Count the number of elements to the left of and lesser than x[i]. Extended method to vector with sig (x) are generated. When X is provided, the result is computed without allocations.

tr_count_l_param(i, x; param)
tr_count_l_param(x; param)
tr_count_l_param(x, X::AbstractVector; param)

Count the number of elements lesser than x[i] + param. Extended method to vector with sig (x, param) are generated. When X is provided, the result is computed without allocations.

tr_count_l_right(i, x)
tr_count_l_right(x)
tr_count_l_right(x, X::AbstractVector)

Count the number of elements to the right of and lesser than x[i]. Extended method to vector with sig (x) are generated. When X is provided, the result is computed without allocations.

tr_count_lesser(i, x)
tr_count_lesser(x)
tr_count_lesser(x, X::AbstractVector)

Count the number of elements lesser than x[i]. Extended method to vector with sig (x) are generated. When X is provided, the result is computed without allocations.

tr_identity(i, x)
tr_identity(x)
tr_identity(x, X::AbstractVector)

Identity function. Already defined in Julia as identity, specialized for vectors. When X is provided, the result is computed without allocations.

tr_in(tr, X, x, param)

Application of an operation from the transformation layer. Used to generate more efficient code for all compositions.

tr_param_minus_val(i, x; param)
tr_param_minus_val(x; param)
tr_param_minus_val(x, X::AbstractVector; param)

Return the difference param - x[i] if positive, 0.0 otherwise. Extended method to vector with sig (x, param) are generated. When X is provided, the result is computed without allocations.

tr_val_minus_param(i, x; param)
tr_val_minus_param(x; param)
tr_val_minus_param(x, X::AbstractVector; param)

Return the difference x[i] - param if positive, 0.0 otherwise. Extended method to vector with sig (x, param) are generated. When X is provided, the result is computed without allocations.