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>;
+            using WeightedOperationsTypes = std::map<FuzzingOperationType, double>;
-            Q_DECLARE_METATYPE(OperationsTypes)
+            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,
+            std::pair<VariablesOperations, Weights>
-                                                    const OperationsPool &operationsPool)
+            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()),
+                std::transform(
-                               [](const auto &type) { return FuzzingOperationFactory::create(type); });
+                    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