Internals

CompositionalNetworks.LayerType
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.

Base.lengthMethod
length(layer)

Return the number of operations in a layer.

Base.lengthMethod
Base.length(icn)

Return the total number of operations of an ICN.

CompositionalNetworks.is_viableMethod
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.

CompositionalNetworks.map_tr!Method
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).

CompositionalNetworks.tr_contiguous_vals_minusMethod
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.

CompositionalNetworks.tr_contiguous_vals_minus_revMethod
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.

CompositionalNetworks.tr_count_bounding_paramMethod
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.

CompositionalNetworks.tr_count_eqMethod
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.

CompositionalNetworks.tr_count_eq_leftMethod
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.

CompositionalNetworks.tr_count_eq_paramMethod
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.

CompositionalNetworks.tr_count_eq_rightMethod
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.

CompositionalNetworks.tr_count_g_leftMethod
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.

CompositionalNetworks.tr_count_g_paramMethod
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.

CompositionalNetworks.tr_count_g_rightMethod
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.

CompositionalNetworks.tr_count_greaterMethod
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.

CompositionalNetworks.tr_count_l_leftMethod
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.

CompositionalNetworks.tr_count_l_paramMethod
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.

CompositionalNetworks.tr_count_l_rightMethod
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.

CompositionalNetworks.tr_count_lesserMethod
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.

CompositionalNetworks.tr_identityMethod
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.

CompositionalNetworks.tr_param_minus_valMethod
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.

CompositionalNetworks.tr_val_minus_paramMethod
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.