Fix some spelling and format

Author: Azzaare

src/CompositionalNetworks.jl

@@ -39,9 +39,9 @@ export regularization
 export show_layers
 export symbols
 export transformation_layer
-export weigths
-export weigths!
-export weigths_bias
+export weights
+export weights!
+export weights_bias
 
 # Include utils
 include("utils.jl")

src/composition.jl

@@ -43,11 +43,11 @@ Output the composition as a layered collection of `Symbol`s.
 symbols(c::Composition) = c.symbols
 
 """
-    compose(icn, weigths=nothing)
-Return a function composed by some of the operations of a given ICN. Can be applied to any vector of variables. If `weigths` are given, will assign to `icn`.
+    compose(icn, weights=nothing)
+Return a function composed by some of the operations of a given ICN. Can be applied to any vector of variables. If `weights` are given, will assign to `icn`.
 """
-function compose(icn::ICN, weigths::BitVector = BitVector())
-    !isempty(weigths) && weigths!(icn, weigths)
+function compose(icn::ICN, weights::BitVector = BitVector())
+    !isempty(weights) && weights!(icn, weights)
     composition, symbols = _compose(icn)
     return Composition(composition, symbols)
 end

src/icn.jl

@@ -14,7 +14,7 @@ mutable struct ICN
     arithmetic::Layer
     aggregation::Layer
     comparison::Layer
-    weigths::BitVector
+    weights::BitVector
 
     function ICN(;
         param = Vector{Symbol}(),
@@ -23,7 +23,7 @@ mutable struct ICN
         ag_layer = aggregation_layer(),
         co_layer = comparison_layer(param),
     )
-        w = generate_weigths([tr_layer, ar_layer, ag_layer, co_layer])
+        w = generate_weights([tr_layer, ar_layer, ag_layer, co_layer])
         return new(tr_layer, ar_layer, ag_layer, co_layer, w)
     end
 end
@@ -42,40 +42,40 @@ Base.length(icn::ICN) = sum(length, layers(icn))
 
 """
     nbits(icn)
-Return the expected number of bits of a viable weigth of an ICN.
+Return the expected number of bits of a viable weight of an ICN.
 """
 nbits(icn) = mapreduce(l -> exclu(l) ? nbits_exclu(l) : length(l), +, layers(icn))
 
 """
-    weigths(icn)
-Access the current set of weigths of an ICN.
+    weights(icn)
+Access the current set of weights of an ICN.
 """
-weigths(icn) = icn.weigths
+weights(icn) = icn.weights
 
-function is_viable(icn::ICN, weigths)
+function is_viable(icn::ICN, weights)
     _start = 0
     _end = 0
 
     for layer in layers(icn)
         _start = _end + 1
         _end += exclu(layer) ? nbits_exclu(layer) : length(layer)
 
-        w = @view weigths[_start:_end]
+        w = @view weights[_start:_end]
 
         !is_viable(layer, w) && return false
     end
     return true
 end
-is_viable(icn::ICN) = is_viable(icn, weigths(icn))
+is_viable(icn::ICN) = is_viable(icn, weights(icn))
 
 """
-    weigths!(icn, weigths)
-Set the weigths of an ICN with a `BitVector`.
+    weights!(icn, weights)
+Set the weights of an ICN with a `BitVector`.
 """
-function weigths!(icn, weigths)
-    length(weigths) == nbits(icn) || @warn icn weigths nbits(icn)
-    @assert length(weigths) == nbits(icn)
-    return icn.weigths = weigths
+function weights!(icn, weights)
+    length(weights) == nbits(icn) || @warn icn weights nbits(icn)
+    @assert length(weights) == nbits(icn)
+    return icn.weights = weights
 end
 
 """
@@ -84,11 +84,11 @@ Return a formated string with each layers in the icn.
 """
 show_layers(icn) = map(show_layer, layers(icn))
 
-generate_weigths(icn::ICN) = generate_weigths(layers(icn))
+generate_weights(icn::ICN) = generate_weights(layers(icn))
 
 """
     regularization(icn)
-Return the regularization value of an ICN weigths, which is proportional to the normalized number of operations selected in the icn layers.
+Return the regularization value of an ICN weights, which is proportional to the normalized number of operations selected in the icn layers.
 """
 function regularization(icn)
     Σmax = 0
@@ -100,7 +100,7 @@ function regularization(icn)
         _start = _end + 1
         _end += exclu(layer) ? nbits_exclu(layer) : l
         if !exclu(layer)
-            Σop += selected_size(layer, @view weigths(icn)[_start:_end])
+            Σop += selected_size(layer, @view weights(icn)[_start:_end])
             Σmax += length(layer)
         end
     end
@@ -132,14 +132,14 @@ function _compose(icn::ICN)
         _end += exclu(layer) ? nbits_exclu(layer) : length(layer)
 
         if exclu(layer)
-            f_id = as_int(@view weigths(icn)[_start:_end])
+            f_id = as_int(@view weights(icn)[_start:_end])
             s = symbol(layer, f_id + 1)
             push!(funcs, [functions(layer)[s]])
             push!(symbols, [s])
         else
             layer_funcs = Vector{Function}()
             layer_symbs = Vector{Symbol}()
-            for (f_id, b) in enumerate(@view weigths(icn)[_start:_end])
+            for (f_id, b) in enumerate(@view weights(icn)[_start:_end])
                 if b
                     s = symbol(layer, f_id)
                     push!(layer_funcs, functions(layer)[s])

src/layer.jl

@@ -45,23 +45,23 @@ Return a string that contains the elements in a layer.
 show_layer(layer) = layer |> functions |> keys |> string
 
 """
-    selected_size(layer, layer_weigths)
-Return the number of operations selected by `layer_weigths` in `layer`.
+    selected_size(layer, layer_weights)
+Return the number of operations selected by `layer_weights` in `layer`.
 """
-selected_size(layer, layer_weigths) = exclu(layer) ? 1 : sum(layer_weigths)
+selected_size(layer, layer_weights) = exclu(layer) ? 1 : sum(layer_weights)
 
 """
     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.
+Assert if a pair of layer/icn and weights compose a viable pattern. If no weights are given with an icn, it will check the current internal value.
 """
 is_viable(layer::Layer, w) = exclu(layer) ? as_int(w) < length(layer) : any(w)
 
 """
     generate_inclusive_operations(predicate, bits)
     generate_exclusive_operation(max_op_number)
-Generates the operations (weigths) of a layer with inclusive/exclusive operations.
+Generates the operations (weights) of a layer with inclusive/exclusive operations.
 """
 function generate_inclusive_operations(predicate, bits)
     ind = falses(bits)
@@ -78,11 +78,11 @@ function generate_exclusive_operation(max_op_number)
 end
 
 """
-    generate_weigths(layers)
-    generate_weigths(icn)
-Generate the weigths of a collection of layers or of an ICN.
+    generate_weights(layers)
+    generate_weights(icn)
+Generate the weights of a collection of layers or of an ICN.
 """
-function generate_weigths(layers)
+function generate_weights(layers)
     bitvecs = map(
         l ->
             exclu(l) ? generate_exclusive_operation(length(l)) :

src/layers/comparison.jl

@@ -24,7 +24,7 @@ co_param_minus_val(x; param, dom_size = 0, nvars = 0) = max(0.0, param - x)
 
 """
     co_euclidian_param(x; param, dom_size)
-Compute an euclidian norm with domain size `dom_size`, weigthed by `param`, of a scalar.
+Compute an euclidian norm with domain size `dom_size`, weighted by `param`, of a scalar.
 """
 function co_euclidian_param(x; param, dom_size, nvars = 0)
     return x == param ? 0.0 : (1.0 + abs(x - param) / dom_size)

src/learn.jl

@@ -21,11 +21,11 @@ function learn_compose(
     parameters...,
 )
     icn = ICN(; parameters...)
-    _, weigths =
+    _, weights =
         optimize!(icn, solutions, non_sltns, dom_size, metric, optimizer; parameters...)
     compositions = Dictionary{Composition,Int}()
 
-    for (bv, occurences) in pairs(weigths)
+    for (bv, occurences) in pairs(weights)
         set!(compositions, compose(deepcopy(icn), bv), occurences)
     end
 

src/metrics.jl

@@ -15,7 +15,7 @@ minkowski(x, X, p) = mapreduce(Distances.minkowski(x, y, p), min, X)
 manhattan(x, X) = mapreduce(y -> Distances.cityblock(x, y), min, X)
 
 """
-    weigths_bias(x)
+    weights_bias(x)
 A metric that bias `x` towards operations with a lower bit. Do not affect the main metric.
 """
-weigths_bias(x) = sum(p -> p[1] * log2(1.0 + p[2]), enumerate(x)) / length(x)^4
+weights_bias(x) = sum(p -> p[1] * log2(1.0 + p[2]), enumerate(x)) / length(x)^4

test/Aqua.jl

@@ -5,9 +5,9 @@
     # TODO: Fix the broken tests and remove the `broken = true` flag
     Aqua.test_all(
         CompositionalNetworks;
-        ambiguities=(broken=true,),
-        deps_compat=false,
-        piracies=(broken=false,),
+        ambiguities = (broken = true,),
+        deps_compat = false,
+        piracies = (broken = false,),
     )
 
     @testset "Ambiguities: CompositionalNetworks" begin
@@ -21,7 +21,7 @@
     @testset "Dependencies compatibility (no extras)" begin
         Aqua.test_deps_compat(
             CompositionalNetworks;
-            check_extras=false,            # ignore = [:Random]
+            check_extras = false,            # ignore = [:Random]
         )
     end
 end

test/genetic.jl

@@ -1,6 +1,6 @@
 """
     generate_population(icn, pop_size
-Generate a pôpulation of weigths (individuals) for the genetic algorithm weigthing `icn`.
+Generate a pôpulation of weights (individuals) for the genetic algorithm weighting `icn`.
 """
 function generate_population(icn, pop_size)
     population = Vector{BitVector}()
@@ -10,7 +10,7 @@ end
 
 """
     _optimize!(icn, X, X_sols; metric = hamming, pop_size = 200)
-Optimize and set the weigths of an ICN with a given set of configuration `X` and solutions `X_sols`.
+Optimize and set the weights of an ICN with a given set of configuration `X` and solutions `X_sols`.
 """
 function _optimize!(
     icn,
@@ -20,8 +20,8 @@ function _optimize!(
     metric,
     pop_size,
     iterations;
-    samples=nothing,
-    memoize=false,
+    samples = nothing,
+    memoize = false,
     parameters...,
 )
     inplace = zeros(dom_size, max_icn_length())
@@ -32,32 +32,32 @@ function _optimize!(
         f = composition(compo)
         S = Iterators.flatten((solutions, _non_sltns))
         σ = sum(
-            x -> abs(f(x; X=inplace, dom_size, parameters...) - metric(x, solutions)),
+            x -> abs(f(x; X = inplace, dom_size, parameters...) - metric(x, solutions)),
             S,
         )
-        return σ + regularization(icn) + weigths_bias(w)
+        return σ + regularization(icn) + weights_bias(w)
     end
 
     _fitness = memoize ? (@memoize Dict memoize_fitness(w) = fitness(w)) : fitness
 
     _icn_ga = GA(;
-        populationSize=pop_size,
-        crossoverRate=0.8,
-        epsilon=0.05,
-        selection=tournament(2),
-        crossover=SPX,
-        mutation=flip,
-        mutationRate=1.0,
+        populationSize = pop_size,
+        crossoverRate = 0.8,
+        epsilon = 0.05,
+        selection = tournament(2),
+        crossover = SPX,
+        mutation = flip,
+        mutationRate = 1.0,
     )
 
     pop = generate_population(icn, pop_size)
     r = Evolutionary.optimize(_fitness, pop, _icn_ga, Evolutionary.Options(; iterations))
-    return weigths!(icn, Evolutionary.minimizer(r))
+    return weights!(icn, Evolutionary.minimizer(r))
 end
 
 """
     optimize!(icn, X, X_sols, global_iter, local_iter; metric=hamming, popSize=100)
-Optimize and set the weigths of an ICN with a given set of configuration `X` and solutions `X_sols`. The best weigths among `global_iter` will be set.
+Optimize and set the weights of an ICN with a given set of configuration `X` and solutions `X_sols`. The best weights among `global_iter` will be set.
 """
 function optimize!(
     icn,
@@ -68,15 +68,15 @@ function optimize!(
     dom_size,
     metric,
     pop_size;
-    sampler=nothing,
-    memoize=false,
+    sampler = nothing,
+    memoize = false,
     parameters...,
 )
     results = Dictionary{BitVector,Int}()
     aux_results = Vector{BitVector}(undef, global_iter)
     nt = Base.Threads.nthreads()
 
-    @info """Starting optimization of weigths$(nt > 1 ? " (multithreaded)" : "")"""
+    @info """Starting optimization of weights$(nt > 1 ? " (multithreaded)" : "")"""
     samples = isnothing(sampler) ? nothing : sampler(length(solutions) + length(non_sltns))
     @qthreads for i = 1:global_iter
         @info "Iteration $i"
@@ -93,11 +93,11 @@ function optimize!(
             memoize,
             parameters...,
         )
-        aux_results[i] = weigths(aux_icn)
+        aux_results[i] = weights(aux_icn)
     end
     foreach(bv -> incsert!(results, bv), aux_results)
     best = rand(findall(x -> x == maximum(results), results))
-    weigths!(icn, best)
+    weights!(icn, best)
     return best, results
 end
 
@@ -110,11 +110,11 @@ struct GeneticOptimizer <: AbstractOptimizer
 end
 
 function GeneticOptimizer(;
-    global_iter=Threads.nthreads(),
-    local_iter=64,
-    memoize=false,
-    pop_size=64,
-    sampler=nothing,
+    global_iter = Threads.nthreads(),
+    local_iter = 64,
+    memoize = false,
+    pop_size = 64,
+    sampler = nothing,
 )
     return GeneticOptimizer(global_iter, local_iter, memoize, pop_size, sampler)
 end