problem random generation is ok (test in ceao_csdv.cpp).

application/ceao_csdvp.cpp

@@ -132,6 +132,12 @@ int main(int argc, char* argv[])
 
     std::cout << pb << std::endl;
 
+    pb.set_cfg_minimalCompetencyByCourse(1);
+    pb.set_cfg_maximalCompetencyByCourse(5);
+
+    pb.set_cfg_minimalPrerequisiteByCourse(0);
+    pb.set_cfg_maximalPrerequisiteByCourse(2);
+
     CSDVP::generateProblem(pb, CSDVP::GenerationType::RANDOM, 7777);
     assert(pb.checkConfig());
         std::cout << "CSDVP has been correctly configurated" << std::endl;
@@ -169,5 +175,35 @@ int main(int argc, char* argv[])
     }
     std::cout << "TF Integrity is OK!" << std::endl;
 
+    assert(pb.competencyCatalogue().size() == pb.cfg_quantityCompetencies());
+
+    // for(int i = 0; i < pb.coursesCatalogue().size(); i++)
+    // {
+    //     std::cout << pb.coursesCatalogue().at(i).name() << "\n\tPrereq: " + std::to_string(pb.coursesCatalogue().at(i).prerequisites().size()) << std::endl;
+    //     if(pb.coursesCatalogue().at(i).prerequisites().size() > 0)
+    //         std::cout << "Competency 0" << pb.coursesCatalogue().at(i).prerequisites().at(0) << std::endl;  
+    //     std::cout << "\n\tTeach: "+ std::to_string(pb.coursesCatalogue().at(i).teachedCompetenciesWeighted().size()) << std::endl;
+    // }
+
+    for(int i = 0; i < pb.competencyCatalogue().size() ; i++)
+    {
+        assert(pb.competencyCatalogue().at(i).c_magnitude().value() >= pb.cfg_magnitudeMin().value());
+        assert(pb.competencyCatalogue().at(i).c_magnitude().value() <= pb.cfg_magnitudeMax().value());
+    }
+        std::cout << "Magnitudes OK" << std::endl;
+
+    //CHECK QTE COMP IN RANGE OK
+    for(int i = 0 ; i < pb.coursesCatalogue().size(); i++)
+    {
+        assert(pb.coursesCatalogue().at(i).prerequisites().size() >= pb.cfg_prerequisiteByCourseMin());
+        assert(pb.coursesCatalogue().at(i).prerequisites().size() <= pb.cfg_prerequisiteByCourseMax());
+        assert(pb.coursesCatalogue().at(i).teachedCompetenciesWeighted().size() >= pb.cfg_competencyByCourseMin());
+        assert(pb.coursesCatalogue().at(i).teachedCompetenciesWeighted().size() <= pb.cfg_competencyByCourseMax());
+    }
+    std::cout << "Courses prerequistes ok!" << std::endl;
+    std::cout << "Courses teached comp ok!" << std::endl;
+
+    std::cout << "CSDVP HAS BEEN CORRECTLY GENERATED!" << std::endl;
+
     return EXIT_SUCCESS;
 }
\ No newline at end of file

src/model/problem.cpp

@@ -3,6 +3,8 @@
 #include <vector>
 #include <algorithm>
 #include <cstdlib>
+#include <queue>
+#include <cassert>
 
 #include "problem.h"
 #include "tools.h"
@@ -33,6 +35,8 @@ int CSDVP::CSDVP_COUNTER = 0;
         this->_maximalECTSValue = -1;
         this->_minimalCoursesByTimeFrame = -1;
         this->_maximalCoursesByTimeFrame = -1;
+        this->_minimalCompetencyByCourse = -1;
+        this->_maximalCompetencyByCourse = -1;
     }
 // === END CONSTRUCTOR
 
@@ -54,6 +58,14 @@ int CSDVP::CSDVP_COUNTER = 0;
             {this->_minimalCoursesByTimeFrame = nb;}
         void CSDVP::set_cfg_courseByTFMax(int nb)
             {this->_maximalCoursesByTimeFrame = nb;}
+        void CSDVP::set_cfg_minimalCompetencyByCourse(int nb)
+            {this->_minimalCompetencyByCourse = nb;}
+        void CSDVP::set_cfg_maximalCompetencyByCourse(int nb)
+            {this->_maximalCompetencyByCourse = nb;}
+        void CSDVP::set_cfg_minimalPrerequisiteByCourse(int nb)
+            {this->_minimalPrerequisiteByCourse = nb;}
+        void CSDVP::set_cfg_maximalPrerequisiteByCourse(int nb)
+            {this->_maximalPrerequisiteByCourse = nb;}
         void CSDVP::set_cfg_minimalMagnitude(double m)
         {
             this->_minimalMagnitude = Magnitude::build(m);
@@ -112,7 +124,11 @@ int CSDVP::CSDVP_COUNTER = 0;
             this->_minimalCoursesByTimeFrame < 0    ||
             this->_maximalCoursesByTimeFrame < 0    ||
             this->_minimalMagnitude.value() < 0     ||
-            this->_maximalMagnitude.value() < 0     )
+            this->_maximalMagnitude.value() < 0     ||
+            this->_maximalCompetencyByCourse < 0    ||
+            this->_minimalCompetencyByCourse < 0    ||
+            this->_minimalPrerequisiteByCourse < 0  ||
+            this->_maximalPrerequisiteByCourse < 0  )
         {
             this->_isConfig = false;
             return this->_isConfig;
@@ -127,11 +143,16 @@ int CSDVP::CSDVP_COUNTER = 0;
             throw CSDVPOverlapingBoundariesException(this);
         }
 
-        // verify if the has enough courses
+        // verify if the pb has enough courses
         if( this->_minimalCoursesByTimeFrame >= this->_quantityAvailableCourses)
             throw CSDVPBadlyConfiguratedException("this->_minimalCoursesByTimeFrame > this->_quantityAvailableCourses");
         if(this->_quantityAvailableCourses < this->_maximalCoursesByTimeFrame)
             throw CSDVPBadlyConfiguratedException("this->_quantityAvailableCourses < this->_maximalCoursesByTimeFrame");
+        // IDEM from competency
+        if(this->_minimalCompetencyByCourse >= this->_quantityAvailableCompetencies)
+            throw CSDVPBadlyConfiguratedException("this->_minimalCompetencyByCourse >= this->_quantityAvailableCompetencies");
+        if(this->_quantityAvailableCompetencies < this->_maximalCompetencyByCourse)
+            throw CSDVPBadlyConfiguratedException("this->_quantityAvailableCompetencies < this->_maximalCompetencyByCourse");
 
         this->_isConfig = true;
         return this->_isConfig;
@@ -150,7 +171,6 @@ int CSDVP::CSDVP_COUNTER = 0;
         if(! csdvp.checkConfig() ) //if csdvp is not configurated, aborting generation
             return; //aborting pb generation
 
-        std::cout << "generateProblem TODO" << std::endl;
         switch (type)
         {
         case CSDVP::GenerationType::RANDOM:
@@ -230,6 +250,67 @@ int CSDVP::CSDVP_COUNTER = 0;
         for(int i = 0; i < tmpCourses.size(); i++)
             if(tmpCourses.at(i).timeFrame().size() > 0)
                 pb.addCourseToCatalogue(tmpCourses.at(i));
+        
+        /* COMPETENCY CREATION
+         * We create _quantityAvailableCompetency competencies. For each comp, we randomly define it's magnitude.
+         */
+        double magVal;
+        for(int i = 0; i < pb.cfg_quantityCompetencies(); i++)
+        {
+
+            magVal = pb.cfg_magnitudeMin().value() + ( (double)rand()/RAND_MAX) * ( pb.cfg_magnitudeMax().value() - pb.cfg_magnitudeMin().value()) ;
+            assert(magVal >= pb.cfg_magnitudeMin().value());
+            assert(magVal <= pb.cfg_magnitudeMax().value());
+            
+            Competency c = Competency::build(magVal);
+            pb.addCompetencyToCatalogue(c);
+            assert(c == pb.competencyCatalogue().at(pb.competencyCatalogue().size()-1));
+        }
+        /* COMPETENCY ASSIGNATION FOR TEACHED
+         * For each course c, we roll x, the nb of competencies associated to c.
+         * To assign a competency to c exhaustively, we create a tmp competency vector v, where the competencies are randomly sorted, then create a queue from it.
+         * Then, it is equal to take the firsts x competencies from the queue (and put them at the end of the queue) for c.
+         */ 
+        std::vector<Competency> randomVec(pb.competencyCatalogue());
+        std::random_shuffle(randomVec.begin(), randomVec.end());
+        std::queue<Competency> queue;
+        for(int i = 0 ; i < randomVec.size(); i++)
+            queue.push(randomVec.at(i));
+        
+        int x;
+        Competency tmpComp;
+        std::pair<Competency, double> teachedComp;
+
+        for(int i = 0; i < pb.coursesCatalogue().size(); i++)
+        {
+            x = _randomizeIn(pb.cfg_competencyByCourseMin(), pb.cfg_competencyByCourseMax());
+            for(int j = 0; j < x; j++)
+            {
+                tmpComp = queue.front();
+                queue.pop();queue.push(tmpComp);
+                teachedComp = std::pair<Competency,double>(tmpComp, 1.0);
+                pb.unlocked_coursesCatalogue().at(i).addTeachedComp(teachedComp);
+            }
+        }
+
+        /* COMPETENCY ASSIGNATION FOR PREREQ
+         * IDEM AS ABOVE
+         */
+        std::random_shuffle(randomVec.begin(), randomVec.end());
+        queue = std::queue<Competency>();
+        for(int i = 0 ; i < randomVec.size(); i++)
+            queue.push(randomVec.at(i));
+        
+        for(int i = 0; i < pb.coursesCatalogue().size(); i++)
+        {
+            x = _randomizeIn(pb.cfg_prerequisiteByCourseMin(), pb.cfg_prerequisiteByCourseMax());
+            for(int j = 0; j < x; j++)
+            {
+                tmpComp = queue.front();
+                queue.pop(); queue.push(tmpComp);
+                pb.unlocked_coursesCatalogue().at(i).addPrerequisite(tmpComp);
+            }
+        }
 
     }
     // --------- END GENERATION RELATED FUNCTIONS ---------
@@ -242,7 +323,7 @@ int CSDVP::CSDVP_COUNTER = 0;
         std::string s = "--------------\n| Problem n°"+std::to_string(c.id())+"|\n---------------\n| Configuration:";
         s+= "\n\tseed: "+std::to_string(c.seed())+"\n\tNb comp: "+std::to_string(c.cfg_quantityCompetencies())+"\n\tNb courses: "+std::to_string(c.cfg_quantityCourses())+"\n\tMin TimeF: "+std::to_string(c.cfg_minimalTimeFrame())+"\n\tMax TimeF: "+std::to_string(c.cfg_maximalTimeFrame());
         s+= "\n\tECTS Min: "+std::to_string(c.cfg_ectsMin())+"\n\tECTS Max: "+std::to_string(c.cfg_ectsMax())+"\n\tCourse by TF min: "+std::to_string(c.cfg_courseByTFMin())+"\n\tCourse by TF max: "+std::to_string(c.cfg_courseByTFMax());
-        s+="\n\tMagnitude min: "+std::to_string(c.cfg_magnitudeMax().value())+"\n\tMagnitude max: "+std::to_string(c.cfg_magnitudeMax().value());
+        s+="\n\tMagnitude min: "+std::to_string(c.cfg_magnitudeMin().value())+"\n\tMagnitude max: "+std::to_string(c.cfg_magnitudeMax().value());
 
         Stream << s;
         return Stream;

src/model/problem.h

@@ -38,6 +38,12 @@ class CSDVP
         int _minimalCoursesByTimeFrame;
         int _maximalCoursesByTimeFrame;
 
+        int _minimalCompetencyByCourse;
+        int _maximalCompetencyByCourse;
+
+        int _minimalPrerequisiteByCourse;
+        int _maximalPrerequisiteByCourse;
+
         Magnitude _minimalMagnitude;
         Magnitude _maximalMagnitude;
         // ---------- END CONFIGURATION ATTRIBUTES ----------
@@ -98,6 +104,10 @@ class CSDVP
         const int cfg_ectsMin() const{return this->_minimalECTSValue;}
         const int cfg_courseByTFMax() const{return this->_maximalCoursesByTimeFrame;}
         const int cfg_courseByTFMin() const{return this->_minimalCoursesByTimeFrame;}
+        const int cfg_competencyByCourseMin() const {return this->_minimalCompetencyByCourse;}
+        const int cfg_competencyByCourseMax() const {return this->_maximalCompetencyByCourse;}
+        const int cfg_prerequisiteByCourseMin() const {return this->_minimalPrerequisiteByCourse;}
+        const int cfg_prerequisiteByCourseMax() const {return this->_maximalPrerequisiteByCourse;}
         const Magnitude & cfg_magnitudeMin() const{return this->_minimalMagnitude;}
         const Magnitude & cfg_magnitudeMax() const{return this->_maximalMagnitude;}
 
@@ -123,6 +133,10 @@ class CSDVP
             void set_cfg_courseByTFMin(int nb);
             void set_cfg_minimalMagnitude(double mag);
             void set_cfg_maximalMagnitude(double mag);
+            void set_cfg_minimalCompetencyByCourse(int nb);
+            void set_cfg_maximalCompetencyByCourse(int nb);
+            void set_cfg_minimalPrerequisiteByCourse(int nb);
+            void set_cfg_maximalPrerequisiteByCourse(int nb);
 
             void setTimeFrames(std::vector<int> & v);
             void setCoursesCatalogue(std::vector<Course> &);