GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1216:0083fced54a2

Adds weights to operations (2)...

Alexandre Leroux -

r1216:0083fced54a2

parent child

Context file:

r1216:0083fced54a2

Collapse all files

plugins/amda/tests/FuzzingOperations.h +2 -2

                  static std::unique_ptr<IFuzzingOperation> create(FuzzingOperationType type);
              };
-             using OperationsTypes = std::set<FuzzingOperationType>;
-             Q_DECLARE_METATYPE(OperationsTypes)
+             using WeightedOperationsTypes = std::map<FuzzingOperationType, double>;
+             Q_DECLARE_METATYPE(WeightedOperationsTypes)
              #endif // SCIQLOP_FUZZINGOPERATIONS_H

plugins/amda/tests/TestAmdaFuzzing.cpp +27 -14

              // /////// //
              using VariableId = int;
+             using Weight = double;
+             using Weights = std::vector<Weight>;
              using VariableOperation = std::pair<VariableId, std::shared_ptr<IFuzzingOperation> >;
              using VariablesOperations = std::vector<VariableOperation>;
-             using OperationsPool = std::set<std::shared_ptr<IFuzzingOperation> >;
+             using WeightedOperationsPool = std::map<std::shared_ptr<IFuzzingOperation>, Weight>;
              using VariablesPool = std::map<VariableId, std::shared_ptr<Variable> >;
              // ///////// //
              const auto NB_MAX_OPERATIONS_DEFAULT_VALUE = 100;
              const auto NB_MAX_VARIABLES_DEFAULT_VALUE = 1;
              const auto AVAILABLE_OPERATIONS_DEFAULT_VALUE
-                 = QVariant::fromValue(OperationsTypes{FuzzingOperationType::CREATE});
+                 = QVariant::fromValue(WeightedOperationsTypes{{FuzzingOperationType::CREATE, 1.}});
              // /////// //
              // Methods //
              /// Goes through the variables pool and operations pool to determine the set of {variable/operation}
              /// pairs that are valid (i.e. operation that can be executed on variable)
-             VariablesOperations availableOperations(const VariablesPool &variablesPool,
-                                                     const OperationsPool &operationsPool)
+             std::pair<VariablesOperations, Weights>
+             availableOperations(const VariablesPool &variablesPool,
+                                 const WeightedOperationsPool &operationsPool)
              {
                  VariablesOperations result{};
+                 Weights weights{};
                  for (const auto &variablesPoolEntry : variablesPool) {
                      auto variableId = variablesPoolEntry.first;
                      auto variable = variablesPoolEntry.second;
-                     for (const auto &operation : operationsPool) {
+                     for (const auto &operationsPoolEntry : operationsPool) {
+                         auto operation = operationsPoolEntry.first;
+                         auto weight = operationsPoolEntry.second;
                          // A pair is valid if the current operation can be executed on the current variable
                          if (operation->canExecute(variable)) {
                              result.push_back({variableId, operation});
+                             weights.push_back(weight);
                          }
                      }
                  }
-                 return result;
+                 return {result, weights};
              }
-             OperationsPool createOperationsPool(const OperationsTypes &types)
+             WeightedOperationsPool createOperationsPool(const WeightedOperationsTypes &types)
              {
-                 OperationsPool result{};
+                 WeightedOperationsPool result{};
-                 std::transform(types.cbegin(), types.cend(), std::inserter(result, result.end()),
-                                [](const auto &type) { return FuzzingOperationFactory::create(type); });
+                 std::transform(
+                     types.cbegin(), types.cend(), std::inserter(result, result.end()), [](const auto &type) {
+                         return std::make_pair(FuzzingOperationFactory::create(type.first), type.second);
+                     });
                  return result;
              }
                      auto canExecute = true;
                      for (auto i = 0; i < nbMaxOperations() && canExecute; ++i) {
                          // Retrieves all operations that can be executed in the current context
-                         auto variableOperations = availableOperations(m_VariablesPool, operationsPool());
+                         VariablesOperations variableOperations{};
+                         Weights weights{};
+                         std::tie(variableOperations, weights)
+                             = availableOperations(m_VariablesPool, operationsPool());
                          canExecute = !variableOperations.empty();
                          if (canExecute) {
                              // Of the operations available, chooses a random operation and executes it
                              auto variableOperation
-                                 = RandomGenerator::instance().randomChoice(variableOperations);
+                                 = RandomGenerator::instance().randomChoice(variableOperations, weights);
                              auto variableId = variableOperation.first;
                              auto variable = m_VariablesPool.at(variableId);
                      return result;
                  }
-                 OperationsPool operationsPool() const
+                 WeightedOperationsPool operationsPool() const
                  {
                      static auto result = createOperationsPool(
                          m_Properties.value(AVAILABLE_OPERATIONS_PROPERTY, AVAILABLE_OPERATIONS_DEFAULT_VALUE)
-                             .value<OperationsTypes>());
+                             .value<WeightedOperationsTypes>());
                      return result;
                  }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages