Swarm

Complexity

Total Complexity

20

Size/Duplication

Total Lines	64
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	4
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	_update_velocieties()	0	3	2
A	initialize()	0	4	2
A	do_single_iteration()	0	8	3
A	__init__()	0	8	2
A	_update_best_particle()	0	5	3
A	_post_process_run_stages()	0	11	3
A	_post_process_not_run_stages()	0	8	3
A	post_processing()	0	7	2

"""Represents swarm."""

import numpy as np

The import numpy could not be resolved.

from grortir.main.pso.particle import Particle


class Swarm(object):
    """Class which represent swarm."""

    def __init__(self, process, stages, number_of_particles):
        self.stages = stages
        self.process = process
        self.number_of_particles = number_of_particles
        self.particles = [Particle(stages, self.process, i) for i in
                          range(number_of_particles)]
        self.best_particle_quality = np.inf
        self.best_particle = self.particles[0]

    def initialize(self):
        """Initialize all particles in swarm."""
        for particle in self.particles:
            particle.initialize()

    def do_single_iteration(self):
        """Iterate one time."""
        for particle in self.particles:
            particle.update_values()
        self._update_best_particle()
        self._update_velocieties()
        for particle in self.particles:
            particle.move()

    def _update_best_particle(self):

This method should have a docstring.

        for particle in self.particles:
            if particle.best_quality < self.best_particle_quality:
                self.best_particle = particle
                self.best_particle_quality = particle.best_quality

    def _update_velocieties(self):

This method should have a docstring.

        for particle in self.particles:
            particle.update_velocities(self.best_particle)

    def post_processing(self):
        """Method which should be done after all iterations."""
        # calculate output:
        if self.best_particle_quality == np.inf:
            self._post_process_not_run_stages()
        else:
            self._post_process_run_stages(self.best_particle.best_positions)

    def _post_process_run_stages(self, best_control_params):

This method should have a docstring.

        for stage in self.stages:
            current_output = stage.get_output_of_stage(
                stage.input_vector, best_control_params[stage])
            successors = self.process.successors(stage)
            for successor in successors:
                successor.input_vector = current_output
            stage.final_output = current_output
            stage.final_cost = stage.get_cost()
            stage.final_quality = stage.get_quality(
                stage.input_vector, best_control_params[stage])

    def _post_process_not_run_stages(self):

This method should have a docstring.

        for stage in self.stages:
            successors = self.process.successors(stage)
            for successor in successors:
                successor.input_vector = None
            stage.final_output = None
            stage.final_cost = None
            stage.final_quality = None