Quick start

OptFrame is a C++ framework to solve challenging optimization problems, specially by means of metaheuristic techniques. It has no external dependencies, except a C++ compiler compatible with C++17 (or C++20).

After installing OptFrame (or just cloning it), user can start building a solution to the problem at hand.

Welcome Message

A useful abstraction was introduced since OptFrame 4.1, called OptFrame Functional Core (FCore). The idea of FCore is to provide a simplified access to OptFrame programming classes, by means of closures and lambdas. This way, a project that typically had 8 to 10 files is reduced to a single file (all included in headers!).

The first test on FCore is to see if it’s correctly compiling. So let’s just include its main header, and print its welcome() message:

File 'mytest.cpp' located in 'demo/01_QuickstartWelcome/'

// file: 'mytest.cpp'
#include <OptFCore/FCore.hpp>
#include <iostream>
int
main()
{
   std::cout << optframe::FCore::welcome() << std::endl;
   return 0;
}

Build with make

One way to compile it locally is just copy src/ folder inside your project and see the results (using GCC C++ compiler):

g++ --std=c++20 mytest.cpp -o fcore_mytest
./fcore_mytest
# Welcome to OptFrame Functional Core (FCore) - version 4.1-dev

If a local copy of OptFrame is being used in other folder (via git clone), one needs to pass its location via flag -I to the compiler (considering relative location of ./optframe/src/):

File 'makefile' located in 'demo/01_QuickstartWelcome/'

all: demo_quickstart_welcome 

demo_quickstart_welcome:	
	g++ --std=c++20 -I../../include mytest.cpp -o demo_welcome
	# Expects: Welcome to OptFrame Functional Core (FCore) - version 4.1-dev
	./demo_welcome
	

build_with_bazel:
	bazel build ... --cxxopt=-std=c++17

Build with bazel

If one wants to build in Windows or any other system, easiest manner is to use Bazel. Just create a WORKSPACE.bazel file that points to remote OptFrame git repository:

File 'WORKSPACE.bazel' located in 'demo/01_QuickstartWelcome/'

load('@bazel_tools//tools/build_defs/repo:git.bzl', 'git_repository')
git_repository(
    name='OptFrame',
    remote='https://github.com/optframe/optframe.git',
    branch='master'
)

And use the following BUILD.bazel file (with dependency to @OptFrame):

File 'BUILD.bazel' located in 'demo/01_QuickstartWelcome/'

load("@rules_cc//cc:defs.bzl", "cc_library", "cc_binary")
cc_binary(
    name = "demo_welcome",
    srcs = ["mytest.cpp"],
    deps=["@OptFrame//include:OptFCore"],
    copts = select({
        "@bazel_tools//src/conditions:windows": ["/std:c++17"],
        "@bazel_tools//src/conditions:darwin": ["--std=c++17"],
        "//conditions:default": ["--std=c++17"],
    }),
)

Just invoke bazel build system (assuming MinGW C/C++ toolchain on Windows or just remove option --compiler for Linux):

bazel build --compiler=mingw-gcc ...
bazel run :demo_welcome
# Welcome to OptFrame Functional Core (FCore) - version 4.1-dev

A deeper explanation of OptFrame theoretical foundations can be found on Concepts section, so we will move fast here!

First Example: 0-1 Knapsack Problem and Simulated Annealing

Let’s consider a classic problem: the 0-1 Knapsack Problem (KP).

By: Dake CC BY-SA 2.5

Given a set of items \(I\), the KP consists in selecting some items \(S \subseteq I\), such that the sum of weights \(w_i\) (for each selected item) do not exceed knapsack capacity \(Q\), and profit \(p_i\) of the selected items is maximized.

$$maximize\; \sum_{i \in S} p_i$$ $$\sum_{i \in S} w_i \leq Q$$ $$S \subseteq I$$

Solution and Evaluation Types

Users must first define a Representation, which is a data structure that represents an element in the Solution Space for the KP. A natural candidate here is an array of booleans, since we need to decide if we are going to carry each item or not. In C++, an interesting approach is to use stl containers, such as a std::vector<int>.

User also needs to specify the data type for the Objective Space, in general a numeric type. In this case, we will simply choose an Evaluation<int> (just ignore the Evaluation container for now…).

We declare a XESolution pair that aggregates both spaces as a single type ESolutionKP (meaning an evaluated solution for the knapsack problem):

// SPDX-License-Identifier:  MIT OR LGPL-3.0-or-later
// Copyright (C) 2007-2022 - OptFrame developers
// https://github.com/optframe/optframe

// OptFrame Demo 0-1 Knapsack Problem + Simulated Annealing
// File: KP-fcore-ex.hpp
#pragma once

// C++
#include <algorithm>
#include <functional>
#include <iostream>
#include <utility>
#include <vector>
//
#include <OptFCore/FCore.hpp>
#include <OptFrame/Core.hpp>
#include <OptFrame/Heuristics/Heuristics.hpp>  // many metaheuristics here...
#include <OptFrame/Scanner++/Scanner.hpp>
#include <OptFrame/Util/Matrix.hpp>
#include <OptFrame/printable/printable.hpp>

using namespace std;        // NOLINT
using namespace optframe;   // NOLINT
using namespace scannerpp;  // NOLINT

// namespace para o problema da mochila
// namespace KP_fcore {

// Solução para o problema da mochila, e elemento de avaliação

// ================================
//    Definição do 'ESolution'
// Par: (Representação, Avaliação)
// ================================

using ESolutionKP = std::pair<std::vector<bool>,  // (representation)
                              Evaluation<int>     // (objective value)
                              >;

Hint

As long as fields first and second are provided on XESolution concept, any class can be used instead of std::pair, as demonstrated on Explicit XESolution section.

Warning

Since OptFrame v4, any data structure can be used as a solution representation, as long as it implements operator<<. OptFrame Classic (<= v3) required a templated class named Solution<R,ADS>, passing both a representation type R and auxiliary data structure type ADS. This is no longer mandatory, but still widely used on the available examples.

Problem Context

Users will need to store general problem information (such as profits and weights of items), so a ProblemContext can be introduced. For easy interoperability with file and string inputs (on Linux/Windows), we use Scanner class to process problem data (some details of ‘load’ function will only be discussed in a later moment):

class ProblemContext {
 public:
  int n{0};       // numero de itens
  int Q{-1};      // capacidade máxima da mochila
  vector<int> p;  // lucro 'p' de cada item
  vector<int> w;  // peso 'w' de cada item
  //
  // leitor de dados "estilo Java" (Scanner)
  void load(Scanner& scanner) {
    n = *scanner.nextInt();  // leitura do numero de itens na mochila
    Q = *scanner.nextInt();  // leitura da capacidade da mochila
    p = vector<int>(n);      // realoca espaço
    w = vector<int>(n);      // realoca espaço
    //
    cout << "n=" << n << " Q=" << Q << endl;
    //
    // leitura do lucro do item i
    for (int i = 0; i < n; i++) {
      p[i] =
          *scanner.nextInt();  // '*' é usado pq saída do 'nextInt' é 'optional'
      cout << "p[" << i << "]=" << p[i] << " ";
    }
    cout << endl;
    //
    // leitura do peso do item i
    for (int i = 0; i < n; i++) {
      w[i] =
          *scanner.nextInt();  // '*' é usado pq saída do 'nextInt' é 'optional'
      cout << "w[" << i << "]=" << w[i] << " ";
    }
    cout << endl;
  }
};
// Instanciar um problema da mochila pKP
// ProblemContext pKP; // NOLINT

Hint

ProblemContext is a user-defined class that can have any desired format. A ‘load’ function is just a suggestion, but not at all necessary. The object pKP is declared in global scope just to simplify the example, but it could be embedded in any other component if user desires.

Random Constructive

We need to have some initial solution for the search process, so we just proceed in a random manner. For simplicity, we allow infeasible solutions to be generated (as if capacity was infinite).

std::vector<bool> frandom(sref<ProblemContext> pKP) {
  vector<bool> v(pKP->n, false);  // começa sem nenhum item escolhido
  for (unsigned i = 0; i < v.size(); i++)
    v[i] = rand() % 2;  // sorteia se leva item ou não (resultado 0 ou 1)
  // retorna solução
  return v;
}

// Gerador de solução inicial (método construtivo)
// FConstructive<std::vector<bool>, ProblemContext> randomConstructive{pKP,
// frandom};

Hint

User can also define many advanced constructive techniques in a similar manner, such as greedy and greedy randomized approaches.

Evaluator

Now it’s time to define an evaluation (or objective) function. According to the goal of maximizing the profits, we iterate over selected items to accumulate profit and weights. As discussed in constructive section, we allow accumulated weight to surpass knapsack capacity, for infeasible configurations. To discourage that, we introduce negative penalization whenever capacity is exceeded (assuming weight -1000000):

// ===========================
//    Função de avaliação
// ===========================

// função de avaliação da mochila
Evaluation<int> fevaluate(sref<ProblemContext> pKP,
                          const std::vector<bool>& s) {
  int f = 0;
  int somaPeso = 0;
  for (int i = 0; i < pKP->n; i++)
    if (s[i])  // se elemento foi escolhido
    {
      f += pKP->p[i];         // acumula lucro do elemento i
      somaPeso += pKP->w[i];  // acumula peso do elemento i
    }
  // verifica capacidade excedida
  if (somaPeso >= pKP->Q)
    f -= 1000000 *
         (somaPeso - pKP->Q);  // punição proporcional ao excesso de peso
  //
  return Evaluation<int>{f};
}

// Evaluate (false -> maximização)
// FEvaluator<ESolutionKP, MAXIMIZE> evalKP{fevaluate};

We have defined fevaluate function to create an Evaluator object named evalKP, in a MAXIMIZE direction.

Hint

User can choose MINIMIZE if dealing with a minimization problem. For multi-objective problems and Pareto optimization, user should visit Multi-Objective section.

Neighborhood Structure

In order to improve a given solution, several metaheuristics employ Local Search Optimization techniques based on the concept of Neighborhood Structure. Every neighborhood is related to a move operator, which is required (on FCore) to have an undo operation (capable of reverting the effects of the move).

We create a BitFlip move, that changes the true/false selection of a given item \(k\). In this case, the move structure (representation of the move) is just an int, that represents the flipped item.

Note the makeMoveBitFlip move generator based on FCore library.

// MoveBitFlip (moveData = 'int' (k))
using MoveBitFlip = FMove<int, ESolutionKP>;

// vizinhança: operador de "movimento" que faz "bit flip" (0 -> 1; 1 -> 0) na
// posição k
int fApplyFlip(const int& k, ESolutionKP& se) {
  // se.first[k] = 1 - se.first[k]; // inverte elemento 'k'
  se.first[k] = !se.first[k];  // inverte elemento 'k'
  return k;                    // movimento reverso
}

uptr<Move<ESolutionKP>> makeMoveBitFlip(int k) {
  return uptr<Move<ESolutionKP>>(new MoveBitFlip{k, fApplyFlip});
}

The definition of the move can be done using inheritance, if one finds easier (which is what we will adopt).

//
class MoveBitFlip : public Move<ESolutionKP> {
 public:
  int k;  // MoveBitFlip (moveData = 'int' (k))

  explicit MoveBitFlip(int _k) : k{_k} {}

  uptr<Move<ESolutionKP>> apply(ESolutionKP& se) override {
    se.first[k] = !se.first[k];                          // reverts element 'k'
    return uptr<Move<ESolutionKP>>(new MoveBitFlip{k});  // returns reverse move
  }
};

uptr<Move<ESolutionKP>> makeMoveBitFlip(int k) {
  return uptr<Move<ESolutionKP>>(new MoveBitFlip{k});
}

Now, it’s time to define a neighborhood generator for the move. OptFrame has three main types of neighborhoods: NS, NSSeq and NSEnum.

In this example, we will use NS, since it only requires the generation of random moves:

// gerador de movimentos aleatórios do tipo BitFlip
uptr<Move<ESolutionKP>> fRandomFlip(sref<ProblemContext> pKP,
                                    const ESolutionKP& se) {
  int k = ::rand() % pKP->n;  // sorteia um item entre [0..n-1]
  // cria um "movimento" de flip, na posição k, com operação 'fApplyFlip'
  return uptr<Move<ESolutionKP>>(makeMoveBitFlip(k));
}

// Estrutura de Vizinhança para BitFlip (NS)
// FNS<ESolutionKP> nsFlip{fRandomFlip};

// ================== EVERYTHING TOGETHER ====================

class OptFrameDemoKP {
 public:
  FConstructive<std::vector<bool>, ProblemContext> randomConstructive;
  FEvaluator<ESolutionKP, MAXIMIZE, ProblemContext> evalKP;
  FNS<ESolutionKP, ProblemContext> nsFlip;

  explicit OptFrameDemoKP(sref<ProblemContext> p)
      : randomConstructive{p, frandom},
        evalKP{FEvaluator<ESolutionKP, MAXIMIZE, ProblemContext>{p, fevaluate}},
        nsFlip{FNS<ESolutionKP, ProblemContext>{p, fRandomFlip}} {}
};

Hint

It is usually a good idea to start developing over the simplest neighborhood, which is NS. Most (non-deterministic) metaheuristics only requires a NS, as it only requires the generation of random moves. More advanced neighborhoods based on iterators, such as NSSeq and NSEnum are only required for advanced Local Search methods.

Time to Test!

At this point, you can already test many nice metaheuristics and solve your knapsack problem! We use the following code to load a problem instance (see Complete Example after):

std::cout << "======== Carregando Problema ========" << std::endl;
// semente pseudo-aleatória fixa em zero
srand(time(NULL));

std::string sinstance = "knapsack-example.txt";
File f{sinstance};

if (!f.isOpen()) {
  std::cerr << "Problema '" << sinstance << "' não encontrado no diretório!"
            << std::endl;
  return 1;
}

Scanner scanner{std::move(f)};

sref<ProblemContext> pKP{new ProblemContext{}};
pKP->load(scanner);
std::cout << "número de elementos na mochila:" << pKP->n << std::endl;

OptFrameDemoKP demo{pKP};

Hint

It is useful to test every FCore structure independently, so as to develop unit testing for them.

To test the constructive and evaluator:

std::cout << "======== Testa Construtivo Aleatório ========" << std::endl;
// invoca método 'generateSolution' do FCore 'FConstructive' para construtivo
// aleatório
std::vector<bool> sol = *demo.randomConstructive.generateSolution(0.0);
// imprime solução inicial
std::cout << sol << std::endl;
//
std::cout << "======== Testa Avaliador ========" << std::endl;
// avalia solução inicial e cria um par 'ESolution'
ESolutionKP esol(sol, demo.evalKP.evaluate(sol));
// imprime avaliação da solução inicial
esol.second.print();

Now we give an example with of the most well-known metaheuristics: the Simulated Annealing. It has few parameters, including: initial temperature T0, cooling factor alpha, and iterations per temperature iterT.

std::cout << "======== Executa Simulated Annealing ========" << std::endl;
// Especifica um gerador aleatório para o Simulated Annealing
RandGen rg;
//
// Cria objeto da classe 'InitialSearch' (parecido com 'construtivoAleatório')
BasicInitialSearch<ESolutionKP> initRand(demo.randomConstructive, demo.evalKP);
// Instancia um Simulated Annealing com alpha=98%, iterações na temp = 100,
// temperatura inicial = 99999
BasicSimulatedAnnealing<ESolutionKP> sa{
    demo.evalKP, initRand, demo.nsFlip, 0.98, 100, 99999, rg};
// executa o SA e coleta o 'status' de saída
// passa um 'Criterio de Parada' por tempo (= 10 segundos)
auto searchOut = sa.search(
    StopCriteria<ESolutionKP::second_type>{10.0});  // 10.0 seconds max
// pega melhor solução do método SA
ESolutionKP melhor = *searchOut.best;  //*sa.getBestSolution();
std::cout << "======== Imprime melhor solução do SA ========" << std::endl;
// imprime representação da melhor solução
cout << melhor.first << endl;
// imprime avaliação da melhor solução
melhor.second.print();

Complete Example

Warning

We present a complete example below. Note that some small differences may exist due to updates in tutorial, including language details. Feel free to check folder OptFrame/Examples for other examples on FCore and OptFrame Classic.

Example is divided in two files: KP-fcore-ex.hpp and mainKP-fcore-ex.cpp.

Hint

This example could be made in a single file, to be even simpler. However, we recommend users to have a clear separation for the header declaration of FCore components (on KP-fcore-ex.hpp) from the main() entrypoint (on mainKP-fcore-ex.cpp), since unit testing is much simpler when these are decoupled.

KP-fcore-ex.hpp

File 'KP-fcore-ex.hpp' located in 'demo/02_QuickstartKP_SA/'

// SPDX-License-Identifier:  MIT OR LGPL-3.0-or-later
// Copyright (C) 2007-2022 - OptFrame developers
// https://github.com/optframe/optframe

// OptFrame Demo 0-1 Knapsack Problem + Simulated Annealing
// File: KP-fcore-ex.hpp
#pragma once

// C++
#include <algorithm>
#include <functional>
#include <iostream>
#include <utility>
#include <vector>
//
#include <OptFCore/FCore.hpp>
#include <OptFrame/Core.hpp>
#include <OptFrame/Heuristics/Heuristics.hpp>  // many metaheuristics here...
#include <OptFrame/Scanner++/Scanner.hpp>
#include <OptFrame/Util/Matrix.hpp>
#include <OptFrame/printable/printable.hpp>

using namespace std;        // NOLINT
using namespace optframe;   // NOLINT
using namespace scannerpp;  // NOLINT

// namespace para o problema da mochila
// namespace KP_fcore {

// Solução para o problema da mochila, e elemento de avaliação

// ================================
//    Definição do 'ESolution'
// Par: (Representação, Avaliação)
// ================================

using ESolutionKP = std::pair<std::vector<bool>,  // (representation)
                              Evaluation<int>     // (objective value)
                              >;
class ProblemContext {
 public:
  int n{0};       // numero de itens
  int Q{-1};      // capacidade máxima da mochila
  vector<int> p;  // lucro 'p' de cada item
  vector<int> w;  // peso 'w' de cada item
  //
  // leitor de dados "estilo Java" (Scanner)
  void load(Scanner& scanner) {
    n = *scanner.nextInt();  // leitura do numero de itens na mochila
    Q = *scanner.nextInt();  // leitura da capacidade da mochila
    p = vector<int>(n);      // realoca espaço
    w = vector<int>(n);      // realoca espaço
    //
    cout << "n=" << n << " Q=" << Q << endl;
    //
    // leitura do lucro do item i
    for (int i = 0; i < n; i++) {
      p[i] =
          *scanner.nextInt();  // '*' é usado pq saída do 'nextInt' é 'optional'
      cout << "p[" << i << "]=" << p[i] << " ";
    }
    cout << endl;
    //
    // leitura do peso do item i
    for (int i = 0; i < n; i++) {
      w[i] =
          *scanner.nextInt();  // '*' é usado pq saída do 'nextInt' é 'optional'
      cout << "w[" << i << "]=" << w[i] << " ";
    }
    cout << endl;
  }
};
// Instanciar um problema da mochila pKP
// ProblemContext pKP; // NOLINT

std::vector<bool> frandom(sref<ProblemContext> pKP) {
  vector<bool> v(pKP->n, false);  // começa sem nenhum item escolhido
  for (unsigned i = 0; i < v.size(); i++)
    v[i] = rand() % 2;  // sorteia se leva item ou não (resultado 0 ou 1)
  // retorna solução
  return v;
}

// Gerador de solução inicial (método construtivo)
// FConstructive<std::vector<bool>, ProblemContext> randomConstructive{pKP,
// frandom};

// ===========================
//    Função de avaliação
// ===========================

// função de avaliação da mochila
Evaluation<int> fevaluate(sref<ProblemContext> pKP,
                          const std::vector<bool>& s) {
  int f = 0;
  int somaPeso = 0;
  for (int i = 0; i < pKP->n; i++)
    if (s[i])  // se elemento foi escolhido
    {
      f += pKP->p[i];         // acumula lucro do elemento i
      somaPeso += pKP->w[i];  // acumula peso do elemento i
    }
  // verifica capacidade excedida
  if (somaPeso >= pKP->Q)
    f -= 1000000 *
         (somaPeso - pKP->Q);  // punição proporcional ao excesso de peso
  //
  return Evaluation<int>{f};
}

// Evaluate (false -> maximização)
// FEvaluator<ESolutionKP, MAXIMIZE> evalKP{fevaluate};
//
class MoveBitFlip : public Move<ESolutionKP> {
 public:
  int k;  // MoveBitFlip (moveData = 'int' (k))

  explicit MoveBitFlip(int _k) : k{_k} {}

  uptr<Move<ESolutionKP>> apply(ESolutionKP& se) override {
    se.first[k] = !se.first[k];                          // reverts element 'k'
    return uptr<Move<ESolutionKP>>(new MoveBitFlip{k});  // returns reverse move
  }
};

uptr<Move<ESolutionKP>> makeMoveBitFlip(int k) {
  return uptr<Move<ESolutionKP>>(new MoveBitFlip{k});
}
// gerador de movimentos aleatórios do tipo BitFlip
uptr<Move<ESolutionKP>> fRandomFlip(sref<ProblemContext> pKP,
                                    const ESolutionKP& se) {
  int k = ::rand() % pKP->n;  // sorteia um item entre [0..n-1]
  // cria um "movimento" de flip, na posição k, com operação 'fApplyFlip'
  return uptr<Move<ESolutionKP>>(makeMoveBitFlip(k));
}

// Estrutura de Vizinhança para BitFlip (NS)
// FNS<ESolutionKP> nsFlip{fRandomFlip};

// ================== EVERYTHING TOGETHER ====================

class OptFrameDemoKP {
 public:
  FConstructive<std::vector<bool>, ProblemContext> randomConstructive;
  FEvaluator<ESolutionKP, MAXIMIZE, ProblemContext> evalKP;
  FNS<ESolutionKP, ProblemContext> nsFlip;

  explicit OptFrameDemoKP(sref<ProblemContext> p)
      : randomConstructive{p, frandom},
        evalKP{FEvaluator<ESolutionKP, MAXIMIZE, ProblemContext>{p, fevaluate}},
        nsFlip{FNS<ESolutionKP, ProblemContext>{p, fRandomFlip}} {}
};

mainKP-fcore-ex.cpp

File 'mainKP-fcore-ex.cpp' located in 'demo/02_QuickstartKP_SA/'

// mainKP-fcore-ex.cpp

// C++
#include <iostream>

//
#include "KP-fcore-ex.hpp"  // implementação da mochila

// import everything on main()
using namespace std;        // NOLINT
using namespace optframe;   // NOLINT
using namespace scannerpp;  // NOLINT
// using namespace KP_fcore;

int main(int argc, char** argv) {std::cout << "======== Carregando Problema ========" << std::endl;
// semente pseudo-aleatória fixa em zero
srand(time(NULL));

std::string sinstance = "knapsack-example.txt";
File f{sinstance};

if (!f.isOpen()) {
  std::cerr << "Problema '" << sinstance << "' não encontrado no diretório!"
            << std::endl;
  return 1;
}

Scanner scanner{std::move(f)};

sref<ProblemContext> pKP{new ProblemContext{}};
pKP->load(scanner);
std::cout << "número de elementos na mochila:" << pKP->n << std::endl;

OptFrameDemoKP demo{pKP};
std::cout << "======== Testa Construtivo Aleatório ========" << std::endl;
// invoca método 'generateSolution' do FCore 'FConstructive' para construtivo
// aleatório
std::vector<bool> sol = *demo.randomConstructive.generateSolution(0.0);
// imprime solução inicial
std::cout << sol << std::endl;
//
std::cout << "======== Testa Avaliador ========" << std::endl;
// avalia solução inicial e cria um par 'ESolution'
ESolutionKP esol(sol, demo.evalKP.evaluate(sol));
// imprime avaliação da solução inicial
esol.second.print();

std::cout << "======== Executa Simulated Annealing ========" << std::endl;
// Especifica um gerador aleatório para o Simulated Annealing
RandGen rg;
//
// Cria objeto da classe 'InitialSearch' (parecido com 'construtivoAleatório')
BasicInitialSearch<ESolutionKP> initRand(demo.randomConstructive, demo.evalKP);
// Instancia um Simulated Annealing com alpha=98%, iterações na temp = 100,
// temperatura inicial = 99999
BasicSimulatedAnnealing<ESolutionKP> sa{
    demo.evalKP, initRand, demo.nsFlip, 0.98, 100, 99999, rg};
// executa o SA e coleta o 'status' de saída
// passa um 'Criterio de Parada' por tempo (= 10 segundos)
auto searchOut = sa.search(
    StopCriteria<ESolutionKP::second_type>{10.0});  // 10.0 seconds max
// pega melhor solução do método SA
ESolutionKP melhor = *searchOut.best;  //*sa.getBestSolution();
std::cout << "======== Imprime melhor solução do SA ========" << std::endl;
// imprime representação da melhor solução
cout << melhor.first << endl;
// imprime avaliação da melhor solução
melhor.second.print();


std::cout << "======== Fim da Execução ========" << std::endl;
return 0;
} // main

knapsack-example.txt

File 'knapsack-example.txt' located in 'demo/02_QuickstartKP_SA/'

5
10
1 1 1 5 5
1 2 3 7 8

To compile it (generates binary app_KP):

g++ -g -O3 --std=c++20 -I../../include  mainKP-fcore-ex.cpp -o app_KP