# macop.algorithms.Algorithm

Abstract Algorithm class used as basic algorithm implementation with some specific initialization

Classes

`Algorithm`(_initalizer, _evaluator, …[, …]) | Algorithm class used as basic algorithm

class `macop.algorithms.Algorithm.``Algorithm`(_initalizer, _evaluator, _operators, _policy, _validator, _maximise=True, _parent=None)

  Algorithm class used as basic algorithm

  `initalizer`

    {function} – basic function strategy to initialize solution

  `evaluator`

    {function} – basic function in order to obtained fitness (mono or multiple objectives)

  `operators`

    {[Operator]} – list of operator to use when launching algorithm

  `policy`

    {Policy} – Policy class implementation strategy to select operators

  `validator`

    {function} – basic function to check if solution is valid or not under some constraints

  `maximise`

    {bool} – specify kind of optimization problem

  `currentSolution`

    {Solution} – current solution managed for current evaluation

  `bestSolution`

    {Solution} – best solution found so far during running algorithm

  `callbacks`

    {[Callback]} – list of Callback class implementation to do some instructions every number of evaluations and load when initializing algorithm

  `parent`

    {Algorithm} – parent algorithm reference in case of inner Algorithm instance (optional)

  `addCallback`(_callback)

    Add new callback to algorithm specifying usefull parameters

    Parameters

      _callback – {Callback} – specific Callback instance

  `end`()

    Display end message into run method

  `evaluate`(_solution)

    Evaluate a solution using evaluator passed when intialize algorithm

    Parameters

      solution – {Solution} – solution to evaluate

    Returns

      fitness score of solution which is not already evaluated or changed

    Note

    if multi-objective problem this method can be updated using array of evaluator

  `getGlobalEvaluation`()

    Get the global number of evaluation (if inner algorithm)

    Returns

      {int} – current global number of evaluation

  `getGlobalMaxEvaluation`()

    Get the global max number of evaluation (if inner algorithm)

    Returns

      {int} – current global max number of evaluation

  `increaseEvaluation`()

    Increase number of evaluation once a solution is evaluated

  `initRun`()

    Initialize the current solution and best solution

  `isBetter`(_solution)

    Check if solution is better than best found

    Parameters

      solution – {Solution} – solution to compare with best one

    Returns

      {bool} – True if better

  `progress`()

    Log progress and apply callbacks if necessary

  `resume`()

    Resume algorithm using Callback instances

  `run`(_evaluations)

    Run the specific algorithm following number of evaluations to find optima

  `stop`()

    Global stopping criteria (check for inner algorithm too)

  `update`(_solution)

    Apply update function to solution using specific policy Check if solution is valid after modification and returns it

    Parameters

      solution – {Solution} – solution to update using current policy

    Returns

      {Solution} – updated solution obtained by the selected operator