Skip to content

FIC_DK_P GA Solving
FIC_DK_P GA Solving
Commit 6dfc228f authored by Alexis Lebis's avatar Alexis Lebis
Browse files
Options

Merge branch 'determinisctic_rand' into 'master' 

GA implementation + Better mut + randomizig Profession generation + random generation

Closes #15

See merge request !5
parents 1f148554 0e8e9fca
Hide whitespace changes
Inline Side-by-side
Showing with 2077 additions and 119 deletions
.gitignore
View file @ 6dfc228f
correction/
build/
howto.pdf
.vscode/
\ No newline at end of file
.vscode/
.cmake/
README.md
View file @ 6dfc228f
......@@ -16,6 +16,8 @@ paradiseoPath> mkdir build && cd build && cmake ../ && make
2. Correctly link CEAO to your paradiseo install (Optional: **iff** you manually build Paradiseo)
Make sure that a folder cmake/module exists with a FindParadiseo.cmake file. It will be used to find your paradiseo install. Check e1124a07 for example.
Next, you need to locate your paradiseo install while invoking cmake, in order to have the library availables while building CEAO.
To do so, invoke cmake with the following option:
......
application/CMakeLists.txt
View file @ 6dfc228f
......@@ -15,7 +15,7 @@ ADD_EXECUTABLE(tryMutation tryMutation.cpp)
ADD_EXECUTABLE(tryCrossover tryCrossover.cpp)
ADD_EXECUTABLE(tryEval tryEval.cpp)
ADD_DEPENDENCIES(ceao lQueen lModel)
ADD_DEPENDENCIES(ceao lQueen lModel lEA lCstr)
ADD_DEPENDENCIES(ceao_competency lQueen lModel)
ADD_DEPENDENCIES(ceao_course lQueen lModel)
ADD_DEPENDENCIES(ceao_profession lQueen lModel)
......@@ -28,7 +28,7 @@ ADD_DEPENDENCIES(tryEval lQueen)
# 3) Link the librairies for your executable
TARGET_LINK_LIBRARIES(ceao ${PARADISEO_LIBRARIES} lQueen lModel)
TARGET_LINK_LIBRARIES(ceao ${PARADISEO_LIBRARIES} lQueen lModel lEA lCstr)
TARGET_LINK_LIBRARIES(ceao_competency ${PARADISEO_LIBRARIES} lQueen lModel)
TARGET_LINK_LIBRARIES(ceao_course ${PARADISEO_LIBRARIES} lQueen lModel)
TARGET_LINK_LIBRARIES(ceao_profession ${PARADISEO_LIBRARIES} lQueen lModel)
......
application/ceao_csdvp.cpp
View file @ 6dfc228f
......@@ -84,6 +84,10 @@ int main(int argc, char* argv[])
}
pb.set_cfg_courseByTFMin(4);
assert(pb.getQuantityCoursesToPick() == -1);//'cauz pb is not yet fully config
pb.set_cfg_pickedCoursesByTimeFrame(3);
pb.set_cfg_ectsMax(2);
try
......@@ -142,6 +146,8 @@ int main(int argc, char* argv[])
assert(pb.checkConfig());
std::cout << "CSDVP has been correctly configurated" << std::endl;
assert(pb.getQuantityCoursesToPick() == 3 * 6);//course to pick * number of timeframe max - min +1
assert(pb.timeFrames().at(0) == pb.cfg_minimalTimeFrame());
assert(pb.timeFrames().at(1) == pb.cfg_minimalTimeFrame()+1);
assert(pb.timeFrames().at(pb.timeFrames().size()-1) == pb.cfg_maximalTimeFrame());
......@@ -205,5 +211,14 @@ int main(int argc, char* argv[])
std::cout << "CSDVP HAS BEEN CORRECTLY GENERATED!" << std::endl;
for(int i = 0 ; i < pb.coursesSortedByTF().size(); i++)
{
std::cout << "TF#" << std::to_string(i) << std::endl;
for(int j = 0; j < pb.coursesSortedByTF().at(i).size(); j++)
{
std::cout << pb.coursesSortedByTF().at(i).at(j) << std::endl;
}
}
return EXIT_SUCCESS;
}
\ No newline at end of file
application/main.cpp
View file @ 6dfc228f
......@@ -5,115 +5,356 @@
#include <queenCrossover.h>
#include <queenEval.h>
#include <model/problem.h>
#include <model/profession.h>
#include <model/magnitude.h>
#include <model/tools.h>
#include <model/competency.h>
#include <model/ea/cursus.h>
#include <model/ea/initializer.h>
#include <model/ea/initConstraint.h>
#include <model/ea/mutation.h>
#include <model/ea/crossover.h>
#include <model/ea/evaluator.h>
#include <model/constraints/ectsConstraints.h>
#include <model/constraints/repetitionConstraints.h>
#include <model/constraints/professionConstraints.h>
#include <model/constraints/prerequisitesConstraints.h>
#include <model/exception/magnitudeException.h>
#include <model/exception/competencyEvolvingException.h>
void make_help(eoParser & _parser);
int main(int argc, char* argv[]){
/*** init ***/
eoParser parser(argc, argv); // for user-parameter reading
eoState state; // to keep all things allocate
// ================================ TEST ZONE ===========================================
Magnitude m = Magnitude::build(0.5);
Magnitude n = Magnitude::build(0.3);
Magnitude o = Magnitude::build(0.2);
o = m;
// ================================= CEAO ZONE ===================================
std::cout << "Magnitude" << o.value() << std::endl;
//GENERAL PARAMATERS
//eoValueParam<uint32_t>& _seedParam = parser.createParam(uint32_t(0), "seed", "Random number seed", 'S');
unsigned int _seedParam = parser.createParam((unsigned int)(0), "seed", "Random number seed", 'S').value();
std::string _outputFile = parser.createParam(std::string("/scratch"), "outputfile", "", '\0', "Representation", true).value();
eo::rng.reseed(_seedParam);
std::cout << "Magnitude" << m.value() << std::endl;
//PROBLEM PARAMETERS
unsigned int SEED = parser.createParam((unsigned int)(7777), "csdvpSeed", "Seed used for the CSDVP",'s',"Param").value();
unsigned int NBCOURSES = parser.createParam((unsigned int)(15), "nbCourses", "Nb of courses available in the cursus",'C',"Param").value();
unsigned int NBCOMP = parser.createParam((unsigned int)(10), "nbComp", "Nb of competencies available in the cursus",'c',"Param").value();
unsigned int MINTF = parser.createParam((unsigned int)(1), "minTF", "id of the first time frame",'t',"Param").value();
unsigned int MAXTF = parser.createParam((unsigned int)(6), "maxTF", "id of the last time frame",'T',"Param").value();
unsigned int MINECTS = parser.createParam((unsigned int)(1), "minECTS", "minimum number ECTS by course",'e',"Param").value();
unsigned int MAXECTS = parser.createParam((unsigned int)(5), "maxECTS", "maxmimum number ECTS by course",'E',"Param").value();
unsigned int MINCBYTF = parser.createParam((unsigned int)(3), "minCbyTF", "minimal course by time frame",'n',"Param").value();
unsigned int MAXCBYTF = parser.createParam((unsigned int)(8), "maxCbyTF", "maximal course by time frame",'N',"Param").value();
double MINMAGN = parser.createParam((double)(0.2), "minMagn", "miminal magnitude", 'm', "Param").value();
double MAXMAGN = parser.createParam((double)(0.75), "maxMagn", "maximal magnitude", 'M', "Param").value();
unsigned int MINCBYC = parser.createParam((unsigned int)(1), "minCbyC", "minimal competency by course",'r',"Param").value();
unsigned int MAXCBYC = parser.createParam((unsigned int)(5), "maxCbyC", "maximal competency by course",'R',"Param").value();
unsigned int MINPRE = parser.createParam((unsigned int)(0), "minPre", "minimal competency by course",'p',"Param").value();
unsigned int MAXPRE = parser.createParam((unsigned int)(3), "maxPre", "maximal competency by course",'P',"Param").value();
unsigned int CBYTF = parser.createParam((unsigned int)(2), "cbyTF", "course by time frame to pick",'A',"Param").value();
m += n;
//PROFESSION PARAMETERS
unsigned int JOB_SEED = parser.createParam((unsigned int)(7777), "jobSeed", "Seed used for the Profession", 'g', "Param").value();
unsigned int JOB_MINPRE = parser.createParam((unsigned int)(2), "jobMinPre" , "minimum competency prerequisite by a job", 'j', "Param").value();
unsigned int JOB_MAXPRE = parser.createParam((unsigned int)(4), "jobMaxPre" , "maximal competency prerequisite by a job", 'J', "Param").value();
double JOB_MINMAG = parser.createParam((double)(0.5), "jobMinMag" , "miminal magnitude for a job" , 'h', "Param").value();
double JOB_MAXMAG = parser.createParam((double)(0.95), "jobMaxMag" , "maxima magnitude for a job" , 'H', "Param").value();
std::cout << "New magnitude is " << m.value() << std::endl;
//EVOLUTION ENGINE PARAMETERS
unsigned int POPSIZE = parser.createParam((unsigned int)(100), "popSize", "Population size", 'P', "Evolution Engine").value();
double PMUT = parser.createParam((double)(0.5), "pMut", "mutation rate", 'x', "Evolution Engine").value();
double PCROSS = parser.createParam((double)(0.5), "pCross", "crossover rate", 'X', "Evolution Engine").value();
unsigned int NBGEN = parser.createParam((unsigned int)(100), "nbGen", "Number of generation",'G',"Param").value();
unsigned int SIZET = parser.createParam((unsigned int)(7), "sizeT", "Tournament Size",'F',"Param").value();
// ===== PB CONFIG ZONE =====
CSDVP pb;
Profession job;
pb.set_cfg_quantityCourses(NBCOURSES);
pb.set_cfg_quantityCompetencies(NBCOMP);
pb.set_cfg_minimalTimeFrames(MINTF);
pb.set_cfg_maximalTimeFrames(MAXTF); //Just "Licence"
pb.set_cfg_ectsMin(MINECTS);
pb.set_cfg_ectsMax(MAXECTS);
pb.set_cfg_courseByTFMin(MINCBYTF);
pb.set_cfg_courseByTFMax(MAXCBYTF);
pb.set_cfg_minimalMagnitude(MINMAGN);
pb.set_cfg_maximalMagnitude(MAXMAGN);
pb.set_cfg_minimalCompetencyByCourse(MINCBYC);
pb.set_cfg_maximalCompetencyByCourse(MAXCBYC);
pb.set_cfg_minimalPrerequisiteByCourse(MINPRE);
pb.set_cfg_maximalPrerequisiteByCourse(MAXPRE);
pb.set_cfg_pickedCoursesByTimeFrame(CBYTF);
try{
std::cout << "After addition mag is : " << (m + m).value() << std::endl;
}
catch(MagnitudeException & e)
{
std::cout << "\nEXCEPTION CATCH !\n";
std::cout << "Memory adr of m is : " << &m << std::endl;
std::cout << "Memory adr of e is : " << &e.getMagnitude() << std::endl;
e.getMagnitude().rebase();
std::cout << "REBASE! New magnitude value is" << e.getMagnitude().rebase() << std::endl;
std::cout << "Accessing magnitude value : " << e.getMagnitude().value() << std::endl;
std::cout << "magnitude value of M : " << m.value() << std::endl;
m = e.getMagnitude();
std::cout << "before end catch" << m.value() << std::endl;
}
CSDVP::generateProblem(pb, CSDVP::GenerationType::RANDOM, SEED);
assert(pb.checkConfig());
// std::cout << "CSDVP IS : \n" << pb << std::endl;
// for(int i = 0; i < pb.coursesCatalogue().size(); i++)
// std::cout << pb.coursesCatalogue().at(i) << std::endl;
job.setRequiredECTS(Profession::GenerationType::RANDOM);
job.set_cfg_minimalPrerequisites(JOB_MINPRE);
job.set_cfg_maximalPrerequisites(JOB_MAXPRE);
job.set_cfg_minimalMagnitude(JOB_MINMAG);
job.set_cfg_maximalMagnitude(JOB_MAXMAG);
std::cout << "Inspect m value:" << m.value() << std::endl;
Profession::generateProfession(job, Profession::GenerationType::RANDOM, pb, JOB_SEED);
assert(job.checkConfig());
// std::cout << "JOB IS : \n" << job << std::endl;
// ================================= END TEST ZONE =====================================
// job.setRequiredECTS(4 * 6);
// Competency tmpC = pb.competencyCatalogue().at(0);
// tmpC = Competency::buildTMP(0.8, tmpC.c_name());
// job.addPrerequisite(tmpC);
// tmpC = pb.competencyCatalogue().at(1);
// tmpC = Competency::buildTMP(0.8, tmpC.c_name());
// job.addPrerequisite(tmpC);
// tmpC = pb.competencyCatalogue().at(2);
// tmpC = Competency::buildTMP(0.8, tmpC.c_name());
// job.addPrerequisite(tmpC);
//Define a QUEEN -> 1 line
QUEEN s1;
//tmpC = Competency::build(0.5,"Wesh");
//job.addPrerequisite(tmpC);
//tmpC = pb.competencyCatalogue().at(8);
//job.addPrerequisite(tmpC);
// ===== END PB CONFIG =====
//Define an initializer -> 1 line
queenInit init(8,1);
ConstraintsECTS ctrECTS(pb, job);
ConstraintsRepetition ctrRep(pb, job);
ConstraintsProfession ctrJob(pb, job);
ConstraintsPrerequisites ctrPrq(pb, job);
//Define the evaluation function -> 1 line
queenEval eval;
//std::cout << "getQuantityCoursesToPick : " << std::to_string(pb.getQuantityCoursesToPick()) << std::endl;
//std::cout << "cfg_quantityCourses() : " << std::to_string(pb.cfg_quantityCourses()) << std::endl;
/**@todo make size of the pb accessible as well as size of an individu*/
//Define mutation -> 1 line
queenMutation mut;
// ======================== AG CONFIG ZONE ========================
//PROBLEM DEPENDANT OPERATOR
CursusInitConstraint init(pb);
CursusEval eval(ctrPrq, ctrRep, ctrJob, ctrECTS);
CursusCrossover cross(pb, ctrRep, init);
CursusMutation mut(pb, ctrRep);
//PROBLEM INDEPENDANT OPERATOR
eoGenContinue<Cursus> cont(NBGEN);
eoSGATransform<Cursus> transform(cross, PCROSS, mut, PMUT);
eoDetTournamentSelect<Cursus> selectOne(SIZET);
eoSelectPerc<Cursus> select(selectOne);
eoGenerationalReplacement<Cursus> replace;
//Define crossover -> 1 line
queenCrossover cross;
//POPULATION INITIALISATION
eoPop<Cursus> pop;
Cursus c1;
for(int i = 0; i < POPSIZE; i++){
init(c1);
eval(c1);
pop.push_back(c1);
}
//Define a generational continuator (put 100 generation for example) -> 1 line
eoGenContinue<QUEEN> cont(100);
// ======================== AG CONFIG ZONE END ========================
//Define the transformation object (it contains, the crossover, the crossover rate, the mutation and the mutation rate) -> 1 line
eoSGATransform<QUEEN> transform(cross, 0.1, mut, 0.1);
// ================================ TEST ZONE ===========================================
/*
std::cout << "MAGNITUDE TEST ZONE" << std::endl;
Magnitude m = Magnitude::build(0.5);
Magnitude n = Magnitude::build(0.3);
Magnitude o = Magnitude::build(0.2);
//Define a selection method that selects ONE individual by deterministic tournament(put the tournament size at 2 for example) -> 1 line
eoDetTournamentSelect<QUEEN> selectOne(2);
o = m;
//Define a "eoSelectPerc" with the tournament with default parameter (allow to select the good size of individuals) -> 1 line
eoSelectPerc<QUEEN> select(selectOne);
std::cout << "Magnitude" << o.value() << std::endl;
//Define a generational replacement strategy -> 1 line
eoGenerationalReplacement<QUEEN> replace;
std::cout << "Magnitude" << m.value() << std::endl;
//Define a pop of QUEEN -> 1 line
eoPop<QUEEN> pop;
m += n;
//Fill the pop with 100 initialized and evaluated QUEEN
//Use the initializer, the evaluation function and the push_back operator's vector -> A "for" included three insrtuctions
for(unsigned int i=0; i<100; i++){
init(s1);
eval(s1);
pop.push_back(s1);
}
//Print the pop -> 1 line
pop.printOn(std::cout);
std::cout << "New magnitude is " << m.value() << std::endl;
//HERE you can test whether you succeded in initializing the population by compiling and executing this part of the program.
//Print end of line (endl)
std::cout << std::endl;
try{
std::cout << "After addition mag is : " << (m + m).value() << std::endl;
}
catch(MagnitudeException & e)
{
std::cout << "\nEXCEPTION CATCH !\n";
std::cout << "Memory adr of m is : " << &m << std::endl;
std::cout << "Memory adr of e is : " << &e.getMagnitude() << std::endl;
e.getMagnitude().rebase();
std::cout << "REBASE! New magnitude value is" << e.getMagnitude().rebase() << std::endl;
std::cout << "Accessing magnitude value : " << e.getMagnitude().value() << std::endl;
std::cout << "magnitude value of M : " << m.value() << std::endl;
m = e.getMagnitude();
std::cout << "before end catch" << m.value() << std::endl;
}
std::cout << "Inspect m value:" << m.value() << std::endl;
std::cout << "END MAGNITUDE TEST\n\n\n" << std::endl;
*/
/*
std::cout << "CONSTRAINT TEST ZONE" << std::endl;
std::pair<bool,double> res;
for(int i = 0; i < pop.size(); i++){
res = ctrECTS.integrityCheck(pop[i]);
std::cout << "ECTS Metric" << std::to_string(res.second) << std::endl;
//res = ctrRep.integrityCheck(pop[i]);
//res = ctrJob.integrityCheck(pop[i]);
res = ctrPrq.integrityCheck(pop[i]);
std::cout << "IND#" << std::to_string(i) << "\nFirst: " << res.first << "\nSecond: " << std::to_string((double)res.second) << std::endl;
if(res.first)
{
std::cout << "*************** OK PREREQ !! ***********" << std::endl;
}
else
{
std::cout << "$$$$$$$$$$$$$$$$ NON OK PREREQ !! $$$$$$$$$$$$$$$$$$$" << std::endl;
}
for(int i = 0 ; i < pop[i].size(); i++)
{
std::cout << pb.coursesCatalogue().at(pop[i].at(i)) << std::endl;
}
}
*/
//MUTATION TEST
/*
std::cout << "MUTATION TEST ZONE" << std::endl;
pop[0].printOn(std::cout);
std::cout << std::endl;
for(int i=0; i<50; i++){
mut(pop[0]);
pop[0].printOn(std::cout);
std::cout << std::endl;
}
*/
/*Define an eoEasyEA with good parameter:
- continuator
- evaluation function
- eoSelectPerc
- transformation object
- replacement
*/
// -> 1 line
eoEasyEA<QUEEN> algo(cont,eval,select,transform,replace);
//CROSS TEST
/*
std::cout << "CROSSOVER TEST ZONE" << std::endl;
pop[0].printOn(std::cout);
std::cout << std::endl;
pop[1].printOn(std::cout);
std::cout << std::endl;
for(int i=0; i<50; i++){
cross(pop[0],pop[1]);
pop[0].printOn(std::cout);
std::cout << std::endl;
pop[1].printOn(std::cout);
std::cout << std::endl;
std::cout << std::endl;
}
*/
/*
for(int i = 0; i < pb.coursesCatalogue().size(); i++)
{
std::cout << pb.coursesCatalogue().at(i) << std::endl;
}
*/
// ======================== TEST ZONE END========================
//run the algorithm on the initialized population -> 1 line
algo(pop);
// ================================= RUN ZONE ===============================
std::cout << "===== CURRENT POP =====" << std::endl;
pop.best_element().printOn(std::cout);
std::cout << " fitness:" << pop.best_element().fitness() << std::endl;
std::cout << "Stats & metrics: \n" << std::endl;
std::pair<bool, double> resECTS = ctrECTS.integrityCheck(pop.best_element());
std::pair<bool, double> resRep = ctrRep.integrityCheck(pop.best_element());
std::pair<bool, double> resJob = ctrJob.integrityCheck(pop.best_element());
std::pair<bool, double> resPrq = ctrPrq.integrityCheck(pop.best_element());
std::cout << "ECTS: ";
if(resECTS.first)
std::cout << "succeed";
else
std::cout << "failed";
std::cout << " | value: " << resECTS.second << std::endl;
//Print the best element -> 1 line
pop.best_element().printOn(std::cout);
std::cout << "Repetition: ";
if(resRep.first)
std::cout << "succeed";
else
std::cout << "failed";
std::cout << " | value: " << resRep.second << std::endl;
//If the fitness value is equal to 0, the best solution is found. Else try again.
std::cout << "Job: ";
if(resJob.first)
std::cout << "succeed";
else
std::cout << "failed";
std::cout << " | value: " << resJob.second << std::endl;
std::cout << std::endl;
std::cout << "Prereq: ";
if(resPrq.first)
std::cout << "succeed";
else
std::cout << "failed";
std::cout << " | value: " << resPrq.second << std::endl;
std::cout << "\n==========" << std::endl;
// ---------- ALGO HERE
eoEasyEA<QUEEN> algo(cont,eval,select,transform,replace);
algo(pop);
// -------------------
std::cout << "\n===== BEST INDIVIDU =====" << std::endl;
pop.best_element().printOn(std::cout);
std::cout << " fitness:" << pop.best_element().fitness() << std::endl;
std::cout << "Stats & metrics: \n" << std::endl;
resECTS = ctrECTS.integrityCheck(pop.best_element());
resRep = ctrRep.integrityCheck(pop.best_element());
resJob = ctrJob.integrityCheck(pop.best_element());
resPrq = ctrPrq.integrityCheck(pop.best_element());
std::cout << "ECTS: ";
if(resECTS.first)
std::cout << "succeed";
else
std::cout << "failed";
std::cout << " | value: " << resECTS.second << std::endl;
std::cout << "Repetition: ";
if(resRep.first)
std::cout << "succeed";
else
std::cout << "failed";
std::cout << " | value: " << resRep.second << std::endl;
std::cout << "Job: ";
if(resJob.first)
std::cout << "succeed";
else
std::cout << "failed";
std::cout << " | value: " << resJob.second << std::endl;
std::cout << "Prereq: ";
if(resPrq.first)
std::cout << "succeed";
else
std::cout << "failed";
std::cout << " | value: " << resPrq.second << std::endl;
std::cout << "===============" << std::endl;
std::cout << "cpt: " << cross.cpt << std::endl;
// ================================= END RUN ZONE ===============================
return EXIT_SUCCESS;
}
cmake/module/FindParadiseo.cmake
View file @ 6dfc228f
......@@ -48,6 +48,7 @@ set(BUILD_DIR build)
# Path
set(PARADISEO_SRC_PATHS
/home/jerem/Softs/ParadisEO-2.0/
${PARADISEO_ROOT}
$ENV{PARADISEO_ROOT}
/usr/local/
......@@ -101,7 +102,8 @@ endif()
set(PARADISEO_FOUND true) # will be set to false if one of the required modules is not found
set(FIND_PARADISEO_LIB_PATHS
${PARADISEO_ROOT}/${BUILD_DIR}
/home/jerem/Softs/ParadisEO-2.0/build/
${PARADISEO_ROOT}/${BUILD_DIR}
$ENV{PARADISEO_ROOT}
/usr/local/
/usr/
......
src/model/CMakeLists.txt
View file @ 6dfc228f
......@@ -14,4 +14,6 @@ SET (EXERCICE_SOURCES
ADD_LIBRARY(lModel STATIC ${EXERCICE_SOURCES})
add_subdirectory(exception)
add_subdirectory(scale)
\ No newline at end of file
add_subdirectory(scale)
add_subdirectory(ea)
add_subdirectory(constraints)
\ No newline at end of file
src/model/competency.cpp
View file @ 6dfc228f
......@@ -2,11 +2,14 @@
#include "competency.h"
#include "magnitude.h"
#include "tools.h"
#include "exception/magnitudeException.h"
#include "exception/competencyEvolvingException.h"
#include "exception/idOverflowException.h"
int Competency::COMPETENCY_COUNTER = 0;
int Competency::COMPETENCY_TMP_COUNTER = ID_RANGE_FOR_OBJECT + 1;
// === FACTORY
......@@ -37,6 +40,24 @@ Competency Competency::build(double d = 0, std::string name)
}
}
Competency Competency::buildTMP(double d, std::string name)
{
int id = Competency::assignID4TMP();
if(name.empty())
name = "Competency#"+std::to_string(id);
try
{
Magnitude m = Magnitude::build(d);
return Competency(id, m, name);
}
catch(MagnitudeException & e)
{
e.getMagnitude().rebase();
throw CompetencyEvolvingException(new Competency(id, e.getMagnitude(), name));
}
}
// === CONSTRUCTOR
Competency::Competency(int id, Magnitude m, std::string s)
......@@ -49,9 +70,21 @@ Competency::Competency(int id, Magnitude m, std::string s)
int Competency::assignID()
{
if(Competency::COMPETENCY_COUNTER + 1 > ID_RANGE_FOR_OBJECT)
throw idOverflowException("assignID()@Competency.cpp");
return ++Competency::COMPETENCY_COUNTER;
}
int Competency::assignID4TMP()
{
if(Competency::COMPETENCY_TMP_COUNTER + 1 > ID_RANGE_FOR_TEMPORARY_OBJECT)
{
std::cout << "INFO: COMPETENCY_TMP_COUNTER was about to overflow: restored to ID_RANGE_OBJECT + 1" << std::endl;
COMPETENCY_TMP_COUNTER = ID_RANGE_FOR_OBJECT + 1;
}
return ++Competency::COMPETENCY_TMP_COUNTER;
}
// === FUNCTION
void Competency::evolveTowards(Magnitude & m)
......
src/model/competency.h
View file @ 6dfc228f
......@@ -24,10 +24,15 @@ class Competency
//STATIC
static int COMPETENCY_COUNTER;
static int COMPETENCY_TMP_COUNTER;
static int assignID();
static int assignID4TMP();//Called by the tmp builder
public:
static Competency build(Magnitude &, std::string s = "");
static Competency build(double, std::string = "");
///This builder should be used for TMP element
static Competency buildTMP(double, std::string);
Competency() = default;
// === FUNCTION
......
src/model/constraints/CMakeLists.txt 0 → 100644
View file @ 6dfc228f
INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/constraints)
include_directories(${PARADISEO_INCLUDE_DIR})
SET(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/lib)
SET (EXERCICE_SOURCES
ectsConstraints.cpp
repetitionConstraints.cpp
professionConstraints.cpp
prerequisitesConstraints.cpp
)
ADD_LIBRARY(lCstr STATIC ${EXERCICE_SOURCES})
\ No newline at end of file
src/model/constraints/ectsConstraints.cpp 0 → 100644
View file @ 6dfc228f
#include "ectsConstraints.h"
#include "model/course.h"
std::pair<bool, double> ConstraintsECTS::integrityCheck(Cursus indiv)
{
std::vector<Course> courses = this->_pb.coursesCatalogue();
int tmpECTS = 0;
//std::cout << "courses size : " << std::to_string(courses.size()) << std::endl;
//std::cout << "courses catl : " << std::to_string(this->_pb.cfg_quantityCourses()) << std::endl;
for(int i = 0; i < indiv.size(); i++)
{
tmpECTS += courses.at(indiv[i]).ects();
//std::cout << std::to_string(courses.at(indiv[i]).ects()) << " + ";
}
//std::cout << " = " << std::to_string(tmpECTS) << std::endl;
bool isCheckOK = false;
if(tmpECTS >= this->_job.requiredECTS())
isCheckOK = true;
//std::cout << "Required: " << std::to_string(this->_job.requiredECTS());
double metric;
if(tmpECTS > this->_job.requiredECTS())
metric = 1;
else
metric = (double)tmpECTS / this->_job.requiredECTS();
return std::pair<bool, double>(isCheckOK, metric);
}
\ No newline at end of file
src/model/constraints/ectsConstraints.h 0 → 100644
View file @ 6dfc228f
#ifndef SRC_MODEL_CONSTRAINTS_ECTS_CONSTRAINTS_H_
#define SRC_MODEL_CONSTRAINTS_ECTS_CONSTRAINTS_H_
#include <vector>
#include <utility>
#include <eo>
#include "model/problem.h"
#include "model/profession.h"
#include "model/ea/cursus.h"
/**
* This class is used to verify the constraints regarding ECTS
*/
class ConstraintsECTS
{
private:
CSDVP _pb; //Description of the pb
Profession _job;
public:
ConstraintsECTS(const CSDVP& csdvp, const Profession & p)
: _pb(csdvp), _job(p) {}
/** integrityCheck is used to investigate whether or not one individu (indiv) respects the constraints stated.
* Returns a std::pair. First is a boolean set to true when the individu passe the test and is ok with the constraints, false otherwise. Second is a metric inherent to the class caller which can be used during the fitness calcul.
* Metric here is : currentIndivECTS / expectedECTS
*/
std::pair<bool, double> integrityCheck(Cursus indiv);
};
#endif // SRC_MODEL_CONSTRAINTS_ECTS_CONSTRAINTS_H_
\ No newline at end of file
src/model/constraints/prerequisitesConstraints.cpp 0 → 100644
View file @ 6dfc228f
#include "prerequisitesConstraints.h"
#include <string>
#include <utility>
#include "model/course.h"
#include "model/competency.h"
#include "model/tools.h"
#include "model/exception/competencyEvolvingException.h"
std::pair<bool, double> ConstraintsPrerequisites::integrityCheck(Cursus indiv)
{
int currentTF = 0;
int notFound = 0;
int notRespected = 0;
int score = 0;
int nbPrereq = 0;
//Each comp availble at a specific TF. Decay can be applied between i and i+1
std::vector<std::vector<Competency>> compByTF(this->_pb.timeFrames().size());
Course currentCourse;
Competency currentCompetency;
std::pair<int, int> prereqFound; prereqFound.first = 0; prereqFound.second = 0;
std::pair<int, Competency> alreadyExists;
bool changedTF = false;
//std::cout << "=========START========" << std::endl;
for(int i = 0; i < indiv.size() ; i++)
{
if(currentTF != i / this->_pb.cfg_pickedCoursesByTimeFrame())
{
//std::cout << "I've changed of TF" << std::endl;
changedTF = true;
}
else
changedTF = false;
currentTF = i / this->_pb.cfg_pickedCoursesByTimeFrame();
//std::cout << "Current TF: " << std::to_string(currentTF) << std::endl;
//If changedTF is set to true, then we have changed of TF, we need to make available all the Comp in TF-1 here in TF, in addition to the new that'll be discovered in TF
for(int j = 0 ; changedTF && j < compByTF.at(currentTF-1).size(); j++)
{
// HERE, VARIABLE DECAY CAN BE APPLIED!!!!!!!!
compByTF.at(currentTF).push_back(compByTF.at(currentTF-1).at(j));
}
// Then, we explore the current TF for new Comp
currentCourse = this->_pb.coursesCatalogue().at(indiv.at(i));
//std::cout << "\t" << currentCourse << std::endl;
//std::cout << "\tPrereq: " << std::to_string(currentCourse.prerequisites().size()) << std::endl;
nbPrereq += currentCourse.prerequisites().size();
//Handling prereq
// Check if prerequisites exists in TF-1
if(currentTF > 0)
{
prereqFound = this->_prereqsInPreviousTF(compByTF.at(currentTF-1), currentCourse.prerequisites());
}
else
{
prereqFound = this->_prereqsInPreviousTF(std::vector<Competency>(0), currentCourse.prerequisites());
}
notFound += prereqFound.first;
notRespected += prereqFound.second;
// Handling teached comp
for(int j = 0; j < currentCourse.teachedCompetenciesWeighted().size() ; j++)
{
currentCompetency = currentCourse.teachedCompetenciesWeighted().at(j).first;
//Comp already exists in the array ?
alreadyExists = findInVector(compByTF.at(currentTF), currentCompetency);
if(alreadyExists.first >= 0) //Already Exists in the array
{
//std::cout << currentCompetency.c_name() << " already exists" <<std::endl;
try
{
compByTF.at(currentTF).at(alreadyExists.first).evolveTowards(currentCompetency.magnitude());
}
catch(CompetencyEvolvingException & e) //if CEE is thrown, then magnitude has been auto rebased
{
//Should has NTD here
//compToAnswer.at(posFound.first) = e.getCompetency();
//std::cout << "INFO:\n(during ConstraintsProfession)\n\n Compentecy evolution throw an exception. Auto rebase. New value is " << e.getCompetency() << std::endl;
//std::cout << "Comp rebased val is" << compByTF.at(currentTF).at(alreadyExists.first) << std::endl;
//std::cout << "exception.Rebased";
}
}
else
{
compByTF.at(currentTF).push_back(Competency::buildTMP(currentCompetency.c_magnitude().value(), currentCompetency.c_name()));
}
}
}
//std::cout << "==EXPLORING COMP BY TF" << std::endl;
for(int i = 0; i < compByTF.size(); i++)
{
//std::cout << "TF#" << std::to_string(i) << std::endl;
for(int j = 0; j < compByTF.at(i).size() ; j++)
{
//std::cout << compByTF.at(i).at(j) << std::endl;
}
}
bool isOK = ((notFound == 0) && (notRespected == 0));
/*
std::cout << "========== PREREQ CSTR RES ==========" << std::endl;
std::cout << "Not Found: " << std::to_string(notFound) << std::endl;
std::cout << "Not Respected: " << std::to_string(notRespected) << std::endl;
std::cout << "Nb Prereq: " << std::to_string(nbPrereq) << std::endl;
*/
double metric = 0;
if(nbPrereq > 0)
{
metric = 1.0 - ( (((double)2 * (double)notFound) + (double)notRespected ) / (2 * (double) nbPrereq) );
}
else //can't divide by 0
{
if(isOK)
metric = 1;
else
metric = 0;
}
//std::cout << "Metric: " << std::to_string(metric) << std::endl;
//std::cout << "====================" << std::endl;
return std::pair<bool, double>(isOK, metric);
}
std::pair<int, int> ConstraintsPrerequisites::_prereqsInPreviousTF(std::vector<Competency> cInTF, std::vector<Competency> prereqs)
{
int notFound = 0;
int notRespected = 0;
bool found = false;
if(cInTF.size() == 0) //if empty, we'll find nothing
return std::pair<int, int>(prereqs.size(), 0);
for(int i = 0; i < prereqs.size(); i++)
{
found = false;
//std::cout << "Looking for " << prereqs.at(i) << std::endl;
for(int j = 0 ; j < cInTF.size() && !found; j++)
{
//std::cout << "\n\t" << cInTF.at(j) << std::endl;
if(prereqs.at(i)==cInTF.at(j))
{
found = true;
if(prereqs.at(i).c_magnitude().value() > cInTF.at(j).c_magnitude().value())
notRespected++;
}
}
if(!found)
notFound++;
}
//std::cout << "NF: " << std::to_string(notFound) << " | NR: " << std::to_string(notRespected) << std::endl;
return std::pair<int, int>(notFound, notRespected);
}
src/model/constraints/prerequisitesConstraints.h 0 → 100644
View file @ 6dfc228f
#ifndef SRC_MODEL_CONSTRAINTS_PREREQUISITES_CONSTRAINTS_H_
#define SRC_MODEL_CONSTRAINTS_PREREQUISITES_CONSTRAINTS_H_
#include <vector>
#include <utility>
#include <eo>
#include "model/problem.h"
#include "model/profession.h"
#include "model/ea/cursus.h"
/**
* This class is used to verify constraints regarding the prerequisites of each courses of an individu (indiv).
* Each prerequisites of each courses must be respected. Note that the position of the courses in the indiv is important,
* since it represents how the courses are dispatched in the timeframes.
* Logically, a course see in TF t DO NOT CONTRIBUTE in the prerequisite for the courses in x < t
*/
class ConstraintsPrerequisites
{
private:
CSDVP _pb;
Profession _job;
/**
* Checks the prerequisites prereqs in the competencies cInTF (generally, the competencies from the previous TF).
* It returns a std::pair, where the first element indicates how many prerequisites HAS NOT BEEN FOUND.
* The second elements indicates how many prerequisites has not enought mastery (BUT EXISTS in cInTF!)
*/
std::pair<int,int> _prereqsInPreviousTF(std::vector<Competency> cInTF, std::vector<Competency> prereqs);
public:
ConstraintsPrerequisites(const CSDVP & csdvp, const Profession & job)
: _pb(csdvp), _job(job) {}
/** Integrity check is used to investigate wheteher or not one indiv respects the constraints represented by THIS.
* Returns a std::pair. First is a boolean set to true when the indiv passes the test and therefore is compilant with the constraint, false otherwise. Second is the associated metric, mostly usable during fitness calcul.
* @todo Decay competency magnitude
*/
std::pair<bool, double> integrityCheck(Cursus indiv);
};
#endif // SRC_MODEL_CONSTRAINTS_PREREQUISITES_CONSTRAINTS_H_
\ No newline at end of file
src/model/constraints/professionConstraints.cpp 0 → 100644
View file @ 6dfc228f
#include "professionConstraints.h"
#include <string>
#include <utility>
#include "model/course.h"
#include "model/competency.h"
#include "model/tools.h"
#include "model/exception/competencyEvolvingException.h"
std::pair<bool, double> ConstraintsProfession::integrityCheck(Cursus indiv)
{
std::vector<Competency> compToAnswer;
for(int i = 0 ; i < this->_job.prerequisites().size(); i++)
{
std::string name = this->_job.prerequisites().at(i).c_name();
compToAnswer.push_back(Competency::buildTMP(0, name)); //same name to exploit the Competency::operator== on name equality
}
Course current;
Competency currentComp;
std::pair<int, Competency> posFound;
for(int i = 0 ; i < indiv.size(); i++)
{
current = this->_pb.coursesCatalogue().at(indiv.at(i));
for(int j = 0 ; j < current.teachedCompetenciesWeighted().size() ; j++)
{
currentComp = current.teachedCompetenciesWeighted().at(j).first;
posFound = findInVector(compToAnswer, currentComp);
if(posFound.first != -1)
{
try
{
compToAnswer.at(posFound.first).evolveTowards(currentComp.magnitude());
}
catch(CompetencyEvolvingException & e) //if CEE is thrown, then magnitude has been auto rebased
{
//Should has NTD here
//compToAnswer.at(posFound.first) = e.getCompetency();
//std::cout << "INFO:\n(during ConstraintsProfession)\n\n Compentecy evolution throw an exception. Auto rebase. New value is " << e.getCompetency() << std::endl;
}
}
}
}
//Now that we have evolve all the tmp competency, we compate their mag to the requirement. We count how many is not met to define the metric
int score = 0;
for(int i = 0; i < this->_job.prerequisites().size(); i++)
{
if(compToAnswer.at(i).magnitude().value() < this->_job.prerequisites().at(i).c_magnitude().value())
score++;
}
//std::cout << "Score: " << std::to_string(score) << std::endl;
//std::cout << "Size: " << std::to_string(compToAnswer.size()) << std::endl;
bool res = score == 0;
return std::pair<bool, double>(res, 1 - ( (double)score / (double)compToAnswer.size()));
}
src/model/constraints/professionConstraints.h 0 → 100644
View file @ 6dfc228f
#ifndef SRC_MODEL_CONSTRAINTS_PROFESSION_CONSTRAINTS_H_
#define SRC_MODEL_CONSTRAINTS_PROFESSION_CONSTRAINTS_H_
#include <vector>
#include <utility>
#include <eo>
#include "model/problem.h"
#include "model/profession.h"
#include "model/ea/cursus.h"
/**
* This class is used to verify the constraints regarding the profession expected by the student
* It mostly consist in *version 1* to check if all the prerequisites have been answered.
*/
class ConstraintsProfession
{
private:
CSDVP _pb;
Profession _job;
public:
ConstraintsProfession(const CSDVP & csdvp, const Profession & job)
: _pb(csdvp), _job(job) {}
/** Integrity check is used to investigate wheteher or not one indiv respects the constraints represented by THIS.
* Returns a std::pair. First is a boolean set to true when the indiv passes the test and therefore is compilant with the constraint, false otherwise. Second is the associated metric, mostly usable during fitness calcul.
* @todo Decay competency magnitude
*/
std::pair<bool, double> integrityCheck(Cursus indiv);
};
#endif // SRC_MODEL_CONSTRAINTS_PROFESSION_CONSTRAINTS_H_
\ No newline at end of file
src/model/constraints/repetitionConstraints.cpp 0 → 100644
View file @ 6dfc228f
#include "repetitionConstraints.h"
#include "model/course.h"
std::pair<bool, double> ConstraintsRepetition::integrityCheck(Cursus indiv)
{
int nbOfRepetition = 0;
for(int i = 0; i < indiv.size(); i++)
{
for(int j = i+1; j < indiv.size(); j++)
{
if(indiv.at(i) == indiv.at(j))
nbOfRepetition++;
}
}
bool isOK = nbOfRepetition == 0;
double metric = 1 - ( ( (double) nbOfRepetition * 2) / (double)indiv.size() );
return std::pair<bool, double>(isOK, metric);
}
\ No newline at end of file
src/model/constraints/repetitionConstraints.h 0 → 100644
View file @ 6dfc228f
#ifndef SRC_MODEL_CONSTRAINTS_REPETITION_CONSTRAINTS_H_
#define SRC_MODEL_CONSTRAINTS_REPETITION_CONSTRAINTS_H_
#include <eo>
#include <utility>
#include "model/problem.h"
#include "model/profession.h"
#include "model/ea/cursus.h"
/** This class is used to verify the integrity of an individu regarding repetition of courses in the sol.
*/
class ConstraintsRepetition
{
private:
CSDVP _pb;
Profession _job;
public:
ConstraintsRepetition(const CSDVP & csdvp, const Profession & job)
: _pb(csdvp), _job(job) {}
/** Integrity check is used to investigate wheteher or not one indiv respects the constraints represented by THIS.
* Returns a std::pair. First is a boolean set to true when the indiv passes the test and therefore is compilant with the constraint, false otherwise. Second is the associated metric, mostly usable during fitness calcul.
*/
std::pair<bool, double> integrityCheck(Cursus indiv);
};
#endif //SRC_MODEL_CONSTRAINTS_REPETITION_CONSTRAINTS_H_
\ No newline at end of file
src/model/course.cpp
View file @ 6dfc228f
......@@ -11,8 +11,10 @@
#include "exception/courseECTSException.h"
#include "exception/courseTemporalFrameException.h"
#include "exception/notImplementedException.h"
#include "exception/idOverflowException.h"
int Course::COURSE_COUNTER = 0;
int Course::COURSE_TMP_COUNTER = ID_RANGE_FOR_OBJECT + 1;
// === FACTORY
Course Course::build(int ects, std::string name)
......@@ -27,6 +29,19 @@ Course Course::build(int ects, std::string name)
else
return Course(id, ects, name);
}
Course Course::buildTMP(int ects, std::string name)
{
int id = Course::assignID4TMP();
if(name.empty())
name = "Course#"+std::to_string(id);
if(ects < 0)
throw CourseECTSException(new Course(id, ects, name));
else
return Course(id, ects, name);
}
// === END FACTORY
// === CONSTRUCTOR
......@@ -217,8 +232,8 @@ bool Course::_duplicataProtection(std::vector<std::pair<Competency,double>> *tea
bool Course::_lazyEquality(const Course & c) const
{
return (this->_id == c.id() &&
this->_name.compare(c.name()) == 0 &&
return ( (this->_id == c.id() ||
this->_name.compare(c.name()) == 0 ) &&
this->_ects == c.ects()
);
}
......@@ -241,6 +256,19 @@ std::ostream& operator<<(std::ostream& Stream, const Course & c)
tf+=std::to_string(c.timeFrame().at(c.timeFrame().size()-1));
s+="\n\tTimeFrames: ["+tf+"]";
}
s+="\n\tRequirement: [";
for(int i = 0; i < c.prerequisites().size(); i++)
{
s+="" + c.prerequisites().at(i).c_name()+ "("+ std::to_string(c.prerequisites().at(i).c_magnitude().value()) + ") ; ";
}
s+="]";
s+="\n\tTeaches: [";
for(int i = 0 ; i < c.teachedCompetenciesWeighted().size(); i++)
{
s+= "" + c.teachedCompetenciesWeighted().at(i).first.c_name() + "("+ std::to_string(c.teachedCompetenciesWeighted().at(i).first.c_magnitude().value())+") ; ";
}
s+="]";
Stream << s;
return Stream;
}
......@@ -256,6 +284,39 @@ bool Course::operator==(const Course & c) const
/// Course counter
int Course::assignID()
{
if(Course::COURSE_COUNTER + 1 > ID_RANGE_FOR_OBJECT)
throw idOverflowException("assignID()@Course.cpp");
return ++Course::COURSE_COUNTER;
}
int Course::assignID4TMP()
{
if(Course::COURSE_TMP_COUNTER + 1 > ID_RANGE_FOR_TEMPORARY_OBJECT)
{
std::cout << "INFO: COURSE_TMP_COUNTER was about to overflow: restored to ID_RANGE_OBJECT + 1" << std::endl;
COURSE_TMP_COUNTER = ID_RANGE_FOR_OBJECT + 1;
}
return ++COURSE_TMP_COUNTER;
}
/** It produces a new vector, which is another view of courses in param, sorted by TF
* Duplicates the behaviour of CSDVP::_makeCoursesSortedByTF() except that it applies to any vector of courses
* size of timeFrames must be equal to the maximal TF value in courses.timeFrames !
*/
std::vector<std::vector<Course>> Course::organiseByTF(std::vector<Course> courses, std::vector<int> timeFrames)
{
std::vector<std::vector<Course>> coursesByTF(timeFrames.size());
int tmpIdx;
for(int i = 0; i < courses.size(); i++)
{
for(int j = 0; j < courses.at(i).timeFrame().size(); j++)
{
tmpIdx = courses.at(i).timeFrame().at(j) - timeFrames.at(0);
coursesByTF.at(tmpIdx).push_back(courses.at(i));
}
}
return coursesByTF;
}
// === END STATIC
\ No newline at end of file
src/model/course.h
View file @ 6dfc228f
......@@ -5,6 +5,7 @@
#include <utility>
#include "competency.h"
#include "model/exception/notImplementedException.h"
/**
* Represents a course in an academic structure.
......@@ -54,14 +55,20 @@ class Course
// Static
static int COURSE_COUNTER;
static int COURSE_TMP_COUNTER;
static int assignID();
static int assignID4TMP();
// Constructor
//Course();
Course(int id, int ects, std::string name);
public:
static Course build(int ects = 0, std::string name = "");
static Course buildTMP(int ects = 0, std::string name = "");
static std::vector<std::vector<Course>> organiseByTF(std::vector<Course> courses, std::vector<int> timeFrames);
/// Default constructor. Use Course::build instead !
Course() = default;
......@@ -70,6 +77,7 @@ class Course
const std::string name() const{return this->_name;};
const int ects() const{return this->_ects;}
const std::vector<Competency> prerequisites() const {return this->_prerequisites;}
std::vector<Competency>& unlocked_prerequisites() {return this->_prerequisites;}
const std::vector<int> timeFrame() const {return this->_temporalAvailability;}
const std::vector<std::pair<Competency, double>> teachedCompetenciesWeighted() const{return this->_weightedTeached;}
......
src/model/ea/CMakeLists.txt 0 → 100644
View file @ 6dfc228f
INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/ea)
include_directories(${PARADISEO_INCLUDE_DIR})
SET(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/lib)
SET (EXERCICE_SOURCES
evaluator.cpp
)
ADD_LIBRARY(lEA STATIC ${EXERCICE_SOURCES})
\ No newline at end of file
src/model/ea/crossover.h 0 → 100644
View file @ 6dfc228f
#ifndef SRC_MODEL_EA_CROSSOVER_H_
#define SRC_MODEL_EA_CROSSOVER_H_
#include <model/ea/initConstraint.h>
template <class EOT>
class crossCSDVP: public eoQuadOp<EOT>
{
public:
crossCSDVP(CSDVP& _pb, ConstraintsRepetition& _ctr, CursusInitConstraint& _init):pb(_pb),ctr(_ctr), init(_init), cpt(0){}
virtual bool operator()(EOT& _chrom1, EOT& _chrom2){
cpt++;
//Integrity Check BEFORE CROSS
std::pair<bool, double> ctrRes1= ctr.integrityCheck(_chrom1);
std::pair<bool, double> ctrRes2= ctr.integrityCheck(_chrom2);
assert(ctrRes1.first && ctrRes2.first);
//Cross by using tmp solution
EOT tmp;
tmp.resize(0);
for(int i=0; i<_chrom1.size(); i++)
tmp.push_back(_chrom1[i]);
cross(_chrom1,_chrom2);
cross(_chrom2, tmp);
//Integrity Check AFTER CROSS
ctrRes1= ctr.integrityCheck(_chrom1);
ctrRes2= ctr.integrityCheck(_chrom2);
assert(ctrRes1.first && ctrRes2.first);
return true;
}
//Cross modify _chrom1
void cross(EOT& _chrom1,const EOT& _chrom2){
bool needRepair=false;
bool errorFound=false;
unsigned int i, tmp;
const std::vector<int> TF = pb.timeFrames();
unsigned int nbTF=TF.size();
unsigned int sizeTF=_chrom1.size()/nbTF;
std::vector<Course> catalogue = pb.coursesCatalogue();
std::vector<int> courseID;
//Create a vector with all position
for(i=0; i<catalogue.size(); i++)
courseID.push_back(i);
//Define a cut point between time frames
unsigned int cut = eo::rng.random(nbTF-1)+1;
//copie right part from cut with chrom2, -1 if impossible
for(i=cut*sizeTF; i<_chrom1.size(); i++){
if(notin(_chrom1, _chrom2[i],i)){
_chrom1[i]=_chrom2[i];
}
else{
_chrom1[i]=-1;
needRepair=true;
}
}
//Repair
if(needRepair){
//search a course available in the TF for each -1 (impossible position of previous step)
coursenotin(courseID, _chrom1);
for(i=0; i<_chrom1.size(); i++){
if(_chrom1[i]==-1){
tmp=0;
while(!isInTF(catalogue[courseID[tmp]], (i/sizeTF)+pb.cfg_minimalTimeFrame()) && tmp < courseID.size()){
tmp++;
}
if(tmp<courseID.size()){
_chrom1[i]=courseID[tmp];
remove(courseID, _chrom1[i]);
}
else{
//no possibility
errorFound=true;
}
}
}
}
//If no possibility, reinit the sol
if(errorFound){
std::cout << "Impossibility in Cross > Reinit sol" << std::endl;
init(_chrom1);
}
}
//Return if a course can be in a TF
bool isInTF(Course& _c, int _TF){
bool res=false;
std::vector<int> tf=_c.timeFrame();
for(int i=0; i<tf.size(); i++)
if(_TF=tf[i])
res=true;
return res;
}
//remove an _id from a vector
void remove(std::vector<int>& _chrom, int _id){
int i=0;
while(_chrom[i]!= _id)
i++;
_chrom[i]=_chrom[_chrom.size()-1];
_chrom.pop_back();
}
//return if a id is not in the left side of a sol (side depend of _size)
bool notin(EOT& _chrom, int _id, int _size){
bool res=true;
int i=0;
while(res && i<_size){
if(_chrom[i]==_id)
res=false;
i++;
}
return res;
}
//_CourseID subastraction from _chrom
void coursenotin(std::vector<int>& _courseID, std::vector<int>& _chrom){
int tmp;
for (int i=0; i<_chrom.size(); i++){
tmp=0;
while(tmp<_courseID.size() && _chrom[i]!=_courseID[tmp])
tmp++;
if(tmp<=_courseID.size()){
_courseID[tmp]=_courseID[_courseID.size()-1];
_courseID.pop_back();
}
}
}
int cpt;
private:
CSDVP pb;
ConstraintsRepetition ctr;
CursusInitConstraint init;
};
typedef crossCSDVP<Cursus> CursusCrossover;
#endif // SRC_MODEL_EA_CROSSOVER_H_
src/model/ea/cursus.h 0 → 100644
View file @ 6dfc228f
#ifndef SRC_MODEL_EA_CURSUS_H_
#define SRC_MODEL_EA_CURSUS_H_
#include <eoInt.h>
#include <eoScalarFitness.h>
/**
* Represents a cursus of a student. It is equivalent to an individu in a EA.
* Here, it is defined as an eoVector of int: eoInt with a "eoMinimizingFitness" template. Each int represents a course.
* In version 1.1, the representation is based on the course's position in the vector. Older version dealing with the course's ID **IS** deprecated
* @version 1
*/
typedef eoInt<eoMinimizingFitness> Cursus;
#endif // SRC_MODEL_EA_CURSUS_H_
src/model/ea/evaluator.cpp 0 → 100644
View file @ 6dfc228f
#include "evaluator.h"
void CursusEval::operator()(Cursus & _cursus){
double fit=0.0;
int pCE, pCP, pCR, pCPR;
pCE=1;
pCR=1;
pCP=1;
pCPR=1;
std::pair<bool, double> resCE;
std::pair<bool, double> resCP;
std::pair<bool, double> resCR;
std::pair<bool, double> resCPR;
resCE=ce.integrityCheck(_cursus);
resCP=cp.integrityCheck(_cursus);
resCR=cr.integrityCheck(_cursus);
resCPR=cpr.integrityCheck(_cursus);
/*
std::cout << "EVAL: ";
std::cout << resCE.first << " " << resCE.second << std::endl;
std::cout << resCP.first << " " << resCP.second << std::endl;
std::cout << resCR.first << " " << resCR.second << std::endl;
std::cout << resCPR.first << " " << resCPR.second << std::endl;
std::cout << std::endl << std::endl;
*/
double sum=pCE*resCE.second + pCR*resCR.second + pCP*resCP.second + pCPR*resCPR.second;
fit=1.0/(1+sum)*100;
_cursus.fitness(fit);
}
src/model/ea/evaluator.h 0 → 100644
View file @ 6dfc228f
#ifndef SRC_MODEL_EA_EVALUATOR_H_
#define SRC_MODEL_EA_EVALUATOR_H_
#include <eoEvalFunc.h>
#include "cursus.h"
#include <model/constraints/ectsConstraints.h>
#include <model/constraints/repetitionConstraints.h>
#include <model/constraints/professionConstraints.h>
#include <model/constraints/prerequisitesConstraints.h>
class CursusEval : public eoEvalFunc<Cursus>
{
public:
CursusEval(ConstraintsPrerequisites& _cpr, ConstraintsRepetition& _cr, ConstraintsProfession& _cp, ConstraintsECTS& _ce):cpr(_cpr), cr(_cr), cp(_cp), ce(_ce){}
void operator()(Cursus & _cursus);
private:
ConstraintsPrerequisites cpr;
ConstraintsRepetition cr;
ConstraintsProfession cp;
ConstraintsECTS ce;
};
#endif // SRC_MODEL_EA_EVALUATOR_H_
src/model/ea/initConstraint.h 0 → 100644
View file @ 6dfc228f
#ifndef SRC_MODEL_EA_INITCONSTRAINT_H_
#define SRC_MODEL_EA_INITCONSTRAINT_H_
#include<queue>
#include<vector>
#include<cassert>
#include<algorithm>
#include<random>
#include<functional>
#include <eoInit.h>
#include "model/problem.h"
#include "cursus.h"
template <class EOT>
class eoInitConstraintCSDVP: public eoInit<EOT>
{
public:
typedef typename EOT::AtomType AtomType;
eoInitConstraintCSDVP(CSDVP& _pb): pb(_pb){
std::vector<int> tmp;
chromSize=pb.getQuantityCoursesToPick();
maxVal=pb.coursesCatalogue().size();
seed=pb.seed();
TF = pb.timeFrames();
nbTF=TF.size();
sizeTF=chromSize/nbTF;
catalogue = pb.coursesCatalogue();
possibleIDbyTF.resize(nbTF);
for(int i=0; i<maxVal; i++){
tmp=catalogue[i].timeFrame();
for(int j=0; j<tmp.size(); j++){
possibleIDbyTF[tmp[j]-pb.cfg_minimalTimeFrame()].push_back(i);
}
}
// for(int i=0; i<possibleIDbyTF.size(); i++){
// std::cout << "Possible course in TF " << i+pb.cfg_minimalTimeFrame() << ": ";
// for(int j=0; j<possibleIDbyTF[i].size(); j++){
// std::cout << possibleIDbyTF[i][j] << " ";
// }
// std::cout << std::endl;
// }
}
virtual void operator()(EOT& chrom){
int cpt=0;
//std::cout << "Enter init" << std::endl;
unsigned int r=eo::rng.random(possibleIDbyTF[0].size());
chrom.resize(0);
chrom.push_back(possibleIDbyTF[0][r]);
//std::cout << "push " << possibleIDbyTF[0][r] << std::endl;
for(int i = 1; i < chromSize; i++){
cpt=0;
r=eo::rng.random(possibleIDbyTF[i/sizeTF].size());
while(!notin(chrom, possibleIDbyTF[i/sizeTF][r], i) && cpt<maxVal){
r=eo::rng.random(possibleIDbyTF[i/sizeTF].size());
cpt++;
}
if(cpt<maxVal){
//std::cout << i << " " << r << " ";
chrom.push_back(possibleIDbyTF[i/sizeTF][r]);
//std::cout << "push " << possibleIDbyTF[i/sizeTF][r] << std::endl;
}
else{
r=eo::rng.random(maxVal);
while(!notin(chrom, r, i))
r=eo::rng.random(maxVal);
chrom.push_back(r);
std::cout << "push with error " << r << std::endl;
}
}
chrom.invalidate();
// chrom.printOn(std::cout);
//std::cout << std::endl;
//std::cout << "End init" << std::endl;
}
bool notin(EOT& _chrom, int _id, int _size){
bool res=true;
int i=0;
while(res && i<_size){
if(_chrom[i]==_id)
res=false;
i++;
}
return res;
}
private :
std::vector< std::vector<int> > possibleIDbyTF;
std::vector<Course> catalogue;
std::vector<int> TF;
unsigned int nbTF;
unsigned int sizeTF;
CSDVP pb;
unsigned chromSize;
unsigned maxVal;
UF_random_generator<unsigned int> gen;
int seed;
};
typedef eoInitConstraintCSDVP<Cursus> CursusInitConstraint;
#endif // SRC_MODEL_EA_INITIALIZER_H_
src/model/ea/initConstraint.h~ 0 → 100644
View file @ 6dfc228f
#ifndef SRC_MODEL_EA_INITIALIZER_H_
#define SRC_MODEL_EA_INITIALIZER_H_
#include<queue>
#include<vector>
#include<cassert>
#include<algorithm>
#include<random>
#include<functional>
#include <eoInit.h>
#include "model/problem.h"
#include "cursus.h"
template <class EOT>
class eoInitCSDVP: public eoInit<EOT>
{
public:
typedef typename EOT::AtomType AtomType;
eoInitCSDVP(unsigned _chromSize, unsigned _maxVal, int _seed)
: chromSize(_chromSize), maxVal(_maxVal), seed(_seed)
{}
virtual void operator()(EOT& chrom)
{
chrom.resize(0);
for(int i = 0; i < maxVal; i++)
chrom.push_back(i);
std::random_shuffle(chrom.begin(), chrom.end());
chrom.resize(chromSize);
chrom.invalidate();
}
private :
unsigned chromSize;
unsigned maxVal;
UF_random_generator<unsigned int> gen;
int seed;
};
typedef eoInitCSDVP<Cursus> CursusInit;
#endif // SRC_MODEL_EA_INITIALIZER_H_
src/model/ea/initializer.h 0 → 100644
View file @ 6dfc228f
#ifndef SRC_MODEL_EA_INITIALIZER_H_
#define SRC_MODEL_EA_INITIALIZER_H_
#include<queue>
#include<vector>
#include<cassert>
#include<algorithm>
#include<random>
#include<functional>
#include <eoInit.h>
#include "model/problem.h"
#include "cursus.h"
template <class EOT>
class eoInitCSDVP: public eoInit<EOT>
{
public:
typedef typename EOT::AtomType AtomType;
eoInitCSDVP(unsigned _chromSize, unsigned _maxVal, int _seed)
: chromSize(_chromSize), maxVal(_maxVal), seed(_seed)
{}
virtual void operator()(EOT& chrom)
{
chrom.resize(0);
for(int i = 0; i < maxVal; i++)
chrom.push_back(i);
std::random_shuffle(chrom.begin(), chrom.end());
chrom.resize(chromSize);
chrom.invalidate();
}
private :
unsigned chromSize;
unsigned maxVal;
UF_random_generator<unsigned int> gen;
int seed;
};
typedef eoInitCSDVP<Cursus> CursusInit;
#endif // SRC_MODEL_EA_INITIALIZER_H_
src/model/ea/mutation.h 0 → 100644
View file @ 6dfc228f
#ifndef SRC_MODEL_EA_MUTATION_H_
#define SRC_MODEL_EA_MUTATION_H_
#include <algorithm>
#include <eoSwapMutation.h>
#include <eoShiftMutation.h>
#include "cursus.h"
#include "model/course.h"
#include "model/competency.h"
#include "model/tools.h"
#include "model/magnitude.h"
#include "model/constraints/repetitionConstraints.h"
#include "model/exception/competencyEvolvingException.h"
template <class EOT>
class mutCSDVP: public eoMonOp<EOT>
{
public:
mutCSDVP(CSDVP& _pb, ConstraintsRepetition& _ctr):pb(_pb),ctr(_ctr){}
//_CourseID subastraction from _chrom
void notin(std::vector<int>& _courseID, std::vector<int>& _chrom){
int tmp;
for (int i=0; i<_chrom.size(); i++){
tmp=0;
while(tmp<_courseID.size() && _chrom[i]!=_courseID[tmp])
tmp++;
if(tmp<=_courseID.size()){
_courseID[tmp]=_courseID[_courseID.size()-1];
_courseID.pop_back();
}
}
}
/** @version 1.0
* @author Jérem
*/
// virtual bool operator()(EOT& _chrom){
// bool res=false;
// std::pair<bool, double> ctrRes= ctr.integrityCheck(_chrom);
// //Integrity Check AFTER CROSS
// assert(ctrRes.first);
// //_chrom.printOn(std::cout);
// //std::cout << std::endl;
// //On cherche une mutation
// unsigned int i;
// const std::vector<int> TF = pb.timeFrames();
// unsigned int nbTF=TF.size();
// unsigned int sizeTF=_chrom.size()/nbTF;
// const std::vector<Course> catalogue = pb.coursesCatalogue();
// //std::cout << "Catalogue Size: " << catalogue.size() << ", nbTF: " << nbTF << ", sizeTF: " << sizeTF << std::endl;
// //std::cout << "TF min: " << pb.cfg_courseByTFMin() << std::endl;
// std::vector<int> courseID;
// std::vector<int> TFavailabilities;
// for(i=0; i<catalogue.size(); i++)
// courseID.push_back(i);
// //on garde que les cours pas encore choisi
// notin(courseID,_chrom);
// /*
// //std::cout << "id des cours dispos: ";
// for(int i=0; i<courseID.size(); i++)
// std::cout << courseID[i] << " ";
// std::cout << std::endl;
// */
// //on en prend un au hasard dedans
// unsigned int newCourse=eo::rng.random(courseID.size());
// //std::cout << "newCourse: " << courseID[newCourse] << std::endl;
// //on regarde les time frame dispo pour ce cours
// TFavailabilities=catalogue[courseID[newCourse]].timeFrame();
// //on tape au hazard dans une de ces time frame
// unsigned int replaceTF=eo::rng.random(TFavailabilities.size());
// unsigned int oldCourse=eo::rng.random(sizeTF);
// //std::cout << "Try to Replace " << _chrom[((TFavailabilities[replaceTF]-pb.cfg_minimalTimeFrame())*sizeTF) + oldCourse] << " by " << courseID[newCourse] << " in TF: " << TFavailabilities[replaceTF] << std::endl;
// _chrom[((TFavailabilities[replaceTF]-pb.cfg_minimalTimeFrame())*sizeTF) + oldCourse]=courseID[newCourse];
// //std::cout << std::endl << std::endl;
// ctrRes= ctr.integrityCheck(_chrom);
// res=true;
// _chrom.invalidate();
// return res;
// }
/**
* This mutation choose a course randomly, then replace it with a course available in the current TF.
* The course selection is made as follow :
* Select a course (at random) where its prerequisite are respected by the previous assignation
* Otherwise, pick the least constrained course in 60% of cases, otherwise random
* Note that even if the select course's prerequisite may be respected, the _chrom is not guaranteed to be a solution, since the previous
* assignement of course could be wrong.
* @author Alex
* @version 2.0
* @todo optimize + define a global variable for random
*/
virtual bool operator()(EOT& _chrom)
{
// CFG
unsigned int cmptAlert = 0;
unsigned int tresholdAlert = 10;
unsigned int tresholdAbort = 100;
// -----
bool success=false;
std::pair<bool, double> ctrRes= ctr.integrityCheck(_chrom);
//Integrity Check AFTER CROSS
assert(ctrRes.first);
// Mutation set up
unsigned int i;
const std::vector<int> TF = pb.timeFrames();
unsigned int nbTF=TF.size();
unsigned int sizeTF=_chrom.size()/nbTF;
const std::vector<Course> catalogue = pb.coursesCatalogue();
std::vector<int> courseID;
std::vector<Course> availableC;
std::vector<std::vector<Course>> sortedC;
std::vector<int> availableTF;
std::vector<Course> coursesOfTF;
std::vector<Competency> statesOfComp;
int rngTF = 0;
int rngCourseToSwap;
int tfPositionOfRngCourse;
std::vector<Course> gfiCourse; //go for it courses : they pass the prereq
Course fbBestCourse; //fb : Fallback
// //we repeat here because mutation may fail if bad pick happens;
// do
// {
for(i=0; i<catalogue.size(); i++)
courseID.push_back(i);
//Keeping only not taken courses
notin(courseID,_chrom);
//Filling availables courses
for(i = 0; i < courseID.size(); i++)
availableC.push_back(catalogue.at(courseID.at(i)));
// Sorting courses by TF
sortedC = Course::organiseByTF(availableC, pb.timeFrames());
for(i = 0; i < sortedC.size(); i++)
if(sortedC.at(i).size() > 0)
availableTF.push_back(i);
//Defining which course should be mutated (i.e. swapped with another non taken)
rngCourseToSwap = eo::rng.random(_chrom.size());
tfPositionOfRngCourse = rngCourseToSwap / sizeTF;
coursesOfTF = sortedC.at(tfPositionOfRngCourse);
if(coursesOfTF.size() == 0) //No mutation is possible !
{
std::random_shuffle(courseID.begin(), courseID.end());
_chrom[rngCourseToSwap] = courseID.at(0);
_chrom.invalidate();
return false; //No mutation is possible !
}
//Defining the status of competencies mastery until the specified TF
statesOfComp = _getCompStatusAtTF(pb.coursesCatalogue(), _chrom, tfPositionOfRngCourse, sizeTF);
//Taking the best course OR the one with the less of prereq
gfiCourse = _getOKCourse(coursesOfTF, statesOfComp);
if(gfiCourse.size() > 0)
{
std::random_shuffle(gfiCourse.begin(), gfiCourse.end());
_chrom[rngCourseToSwap] = pb.mapCourseToPosition(gfiCourse.at(0));
}
else //least constraint courses in 60% of the cases, otherwise full rand
{
if(eo::rng.random(100) > 60)
{
fbBestCourse = coursesOfTF.at(0);
for(i = 1; i < coursesOfTF.size(); i++)
{
if(fbBestCourse.prerequisites().size() > coursesOfTF.at(i).prerequisites().size())
fbBestCourse = coursesOfTF.at(i);
}
_chrom[rngCourseToSwap] = pb.mapCourseToPosition(fbBestCourse);
}
else
{
std::random_shuffle(coursesOfTF.begin(), coursesOfTF.end());
_chrom[rngCourseToSwap] = pb.mapCourseToPosition(coursesOfTF.at(0));
}
}
// if(!success)
// {
// cmptAlert++;
// if(cmptAlert % tresholdAlert == 0)
// std::cout << "INFO! Several mutation do not success currently" << std::endl;
// if(cmptAlert >= tresholdAbort)
// {
// std::cout << "WARNING! Max mutation reroll reached. We crash the program." << std::endl;
// assert(false);
// }
// }
// } while (!success);
_chrom.invalidate();
return false;
}
/** _getCompStatusAtTF returns the status of the magnitude of all the competencies sawn in all the timeframes below TF.
*/
std::vector<Competency> _getCompStatusAtTF(const std::vector<Course>& catalogue, std::vector<int>& _chrom, int TF, int nbCbyTF)
{
std::vector<Competency> compStatus;
std::vector<Competency> prereqs;
Course tmpCourse = Course::buildTMP();
Course currentCourse;
Competency tmpComp;
bool addStatus = false;
int pos=0;
for(int i = 0; i < _chrom.size() && (i / nbCbyTF < TF); i++)
{
currentCourse = catalogue.at(_chrom.at(i));
for(int j = 0; j < currentCourse.teachedCompetenciesWeighted().size(); j++)
{
tmpComp = currentCourse.teachedCompetenciesWeighted().at(j).first;
addStatus = tmpCourse.addPrerequisite(tmpComp);
if(!addStatus) // comp already exist, then lets evolve it instead
{
prereqs = tmpCourse.prerequisites();
std::pair<int, Competency> fiv= findInVector(prereqs, tmpComp);
pos = fiv.first;
try
{
Magnitude mag = currentCourse.teachedCompetenciesWeighted().at(j).first.c_magnitude();
tmpCourse.unlocked_prerequisites().at(pos).evolveTowards(mag);
}
catch(CompetencyEvolvingException & e)
{
//Should has NTD here
//auto rebased
}
}
}
}
compStatus = tmpCourse.prerequisites();
return compStatus;
}
std::vector<Course> _getOKCourse(std::vector<Course> availableC, std::vector<Competency> state)
{
std::vector<Course> res;
bool stop = false;
bool found = false;
bool isPrereqOK = true;
unsigned int j = 0;
unsigned int itState = 0;
Competency checkCmp;
for(int i = 0; i < availableC.size(); i++)
{
isPrereqOK = true;
for(j = 0; j < availableC.at(i).prerequisites().size() && isPrereqOK; j++)
{
checkCmp = availableC.at(i).prerequisites().at(j);
stop = false;
found = false;
for(itState = 0; itState < state.size() && !stop; itState++)
{
if(checkCmp == state.at(itState))
{
if(checkCmp.c_magnitude().value() > state.at(itState).c_magnitude().value())
{ stop = true; found = false; }
else
{ stop = true; found = true; }
}
}
if(found)
isPrereqOK = true;
else
isPrereqOK = false;
}
if(isPrereqOK)
res.push_back(availableC.at(i));
}
return res;
}
private:
CSDVP pb;
ConstraintsRepetition ctr;
};
typedef mutCSDVP<Cursus> CursusMutation;
#endif // SRC_MODEL_EA_MUTATION_H_
src/model/exception/JobOverlappingBoundariesException.h 0 → 100644
View file @ 6dfc228f
#ifndef SRC_MODEL_EXCEPTION_JOB_OVERLAPING_BOUNDARIES_EXCEPTION_H_
#define SRC_MODEL_EXCEPTION_JOB_OVERLAPING_BOUNDARIES_EXCEPTION_H_
#include <exception>
#include <iostream>
#include <string>
#include "../profession.h"
class JobOverlappingBoundariesException : public std::exception
{
private:
Profession * _job;
std::string _msg;
public:
JobOverlappingBoundariesException(Profession * pb) throw()
: _job(pb)
{
this->_msg = "Boundaries of the Profession (aka Job) (id:"+std::to_string(pb->id())+") are overlaping.";
}
~JobOverlappingBoundariesException() throw()
{ delete(this->_job); }
virtual const char* what() const throw()
{return this->_msg.c_str();}
Profession & getCSDVP() {return *(this->_job);}
};
#endif // SRC_MODEL_EXCEPTION_JOB_OVERLAPING_BOUNDARIES_EXCEPTION_H_
\ No newline at end of file
src/model/exception/idOverflowException.h 0 → 100644
View file @ 6dfc228f
#ifndef SRD_MODEL_EXCEPTION_ID_OVERFLOW_EXCEPTION_H_
#define SRD_MODEL_EXCEPTION_ID_OVERFLOW_EXCEPTION_H_
#include <exception>
#include <string>
class idOverflowException : public std::exception
{
private:
std::string _msg;
public:
idOverflowException(std::string buildInfo) throw()
{
this->_msg = "The id of an object has overflow the maximal value. Where: "+buildInfo;
}
virtual const char* what() const throw()
{
return this->_msg.c_str();
}
};
#endif //SRD_MODEL_EXCEPTION_ID_OVERFLOW_EXCEPTION_H_
\ No newline at end of file
src/model/exception/magnitudeException.h
View file @ 6dfc228f
......@@ -27,11 +27,12 @@ class MagnitudeException : public std::exception
virtual ~MagnitudeException() throw()
{
//this->_triedValue must not be freed by ~this !
delete(this->_triedValue);
}
Magnitude & getMagnitude() const {return *(this->_triedValue);}
};
#endif // SRC_EXCEPTION_MAGNITUDE_EXCEPTION_H_
\ No newline at end of file
src/model/parcours.h deleted 100644 → 0
View file @ 1f148554
#ifndef SRC_MODEL_PARCOURS_H_
#define SRC_MODEL_PARCOURS_H_
/**
* Represents a cursus of a student. It is equivalent to an individu in a EA.
*/
#endif // SRC_MODEL_PARCOURS_H_
\ No newline at end of file
src/model/problem.cpp
View file @ 6dfc228f
......@@ -66,6 +66,8 @@ int CSDVP::CSDVP_COUNTER = 0;
{this->_minimalPrerequisiteByCourse = nb;}
void CSDVP::set_cfg_maximalPrerequisiteByCourse(int nb)
{this->_maximalPrerequisiteByCourse = nb;}
void CSDVP::set_cfg_pickedCoursesByTimeFrame(int nb)
{this->_pickedCoursesByTimeFrame = nb;}
void CSDVP::set_cfg_minimalMagnitude(double m)
{
this->_minimalMagnitude = Magnitude::build(m);
......@@ -128,7 +130,8 @@ int CSDVP::CSDVP_COUNTER = 0;
this->_maximalCompetencyByCourse < 0 ||
this->_minimalCompetencyByCourse < 0 ||
this->_minimalPrerequisiteByCourse < 0 ||
this->_maximalPrerequisiteByCourse < 0 )
this->_maximalPrerequisiteByCourse < 0 ||
this->_pickedCoursesByTimeFrame < 1 )
{
this->_isConfig = false;
return this->_isConfig;
......@@ -153,10 +156,37 @@ int CSDVP::CSDVP_COUNTER = 0;
throw CSDVPBadlyConfiguratedException("this->_minimalCompetencyByCourse >= this->_quantityAvailableCompetencies");
if(this->_quantityAvailableCompetencies < this->_maximalCompetencyByCourse)
throw CSDVPBadlyConfiguratedException("this->_quantityAvailableCompetencies < this->_maximalCompetencyByCourse");
if(this->_pickedCoursesByTimeFrame > this->_minimalCoursesByTimeFrame)
throw CSDVPBadlyConfiguratedException("this->_pickedCoursesByTimeFrame > this->_minimalCoursesByTimeFrame");
if(this->_pickedCoursesByTimeFrame * ( (this->_maximalTimeFrame - this->_minimalTimeFrame) + 1) > this->_quantityAvailableCourses)
throw CSDVPBadlyConfiguratedException("this->_pickedCoursesByTimeFrame * ( (this->_maximalTimeFrame - this->_minimalTimeFrame) + 1) > this->_quantityAvailableCourses");
this->_isConfig = true;
return this->_isConfig;
}
void CSDVP::_makeCoursesSortedByTF()
{
//Init the vector of the size of the time frames
for(int i = 0; i < this->_timeFrames.size(); i++)
this->_coursesSortedByTF.push_back(std::vector<Course>());
int tmpIdx;
for(int i = 0; i < this->_availableCourses.size(); i++)
{
for(int j = 0; j < this->_availableCourses.at(i).timeFrame().size(); j++)
{
tmpIdx = this->_availableCourses.at(i).timeFrame().at(j) - this->_minimalTimeFrame;
this->_coursesSortedByTF.at(tmpIdx).push_back(this->_availableCourses.at(i));
}
}
}
int CSDVP::mapCourseToPosition(const Course & c)
{
for(int i = 0; i < this->coursesCatalogue().size(); i++)
if(c == this->coursesCatalogue().at(i))
return i;
return -1;
}
// === END FUNC
// === STATIC
......@@ -181,6 +211,7 @@ int CSDVP::CSDVP_COUNTER = 0;
}
}
/// [x;y[ ?
int CSDVP::_randomizeIn(const int min, const int max)
{
return min + ( rand() % (max - min + 1) );
......@@ -225,32 +256,76 @@ int CSDVP::CSDVP_COUNTER = 0;
std::vector<Course> tmpCourses;
for(int i = 0; i < pb._quantityAvailableCourses; i++)
{
tmpCourses.push_back(Course::build(CSDVP::_randomizeIn(pb.cfg_minimalTimeFrame(), pb.cfg_maximalTimeFrame())));
tmpCourses.push_back(Course::build(CSDVP::_randomizeIn(pb.cfg_ectsMin(), pb.cfg_ectsMax())));
}
/* We obtain how many courses n by semester s
* then we create an idxCourses vector of size n * s
* then we shuffle it
* then we distribute the course accordingly. If a course already exists, we repick one randomly until it's ok
*/
std::vector<int> idxCourses;
std::vector<int> nbCoursesByTF;
for(int i = 0 ; i < pb.timeFrames().size(); i++)
nbCoursesByTF.push_back(CSDVP::_randomizeIn(pb._minimalCoursesByTimeFrame, pb._maximalCoursesByTimeFrame));
int idxCoursesCounter = 0;
for(int i = 0; i < nbCoursesByTF.size(); i++)
{
for(int j = 0; j < nbCoursesByTF.at(i); j++)
{
idxCourses.push_back(idxCoursesCounter % pb._quantityAvailableCourses);
idxCoursesCounter++;
}
}
std::random_shuffle(idxCourses.begin(), idxCourses.end());
bool insertRez;
int rndIdx;
idxCoursesCounter = 0;
for(int i = 0; i < pb.timeFrames().size(); i++)
{
int nbCoursesInThisTF = CSDVP::_randomizeIn(pb._minimalCoursesByTimeFrame, pb._maximalCoursesByTimeFrame);
int courseIdx;
std::cout << "In the TF "+std::to_string(i)+" I plan " << std::to_string(nbCoursesInThisTF) << " courses." << std::endl;
for(int j = 0; j < nbCoursesInThisTF; j++)
for(int j = 0; j < nbCoursesByTF.at(i); j++)
{
insertRez = true;
courseIdx = CSDVP::_randomizeIn(0,tmpCourses.size()-1);
insertRez = tmpCourses.at(courseIdx).addTemporalFrame(pb.timeFrames().at(i));
if(!insertRez) //If a duplicata has been prevented, we do not count the attempt
j--;
int cc = idxCourses.at(idxCoursesCounter);
insertRez = tmpCourses.at(idxCourses.at(idxCoursesCounter)).addTemporalFrame(pb.timeFrames().at(i));
while(!insertRez)//if duplicataProtection (i.e. course already in this semester)
{
rndIdx = CSDVP::_randomizeIn(0, pb._quantityAvailableCourses);
insertRez = tmpCourses.at(rndIdx).addTemporalFrame(pb.timeFrames().at(i));
}
idxCoursesCounter++;
}
}
// // OLD WAY
// bool insertRez;
// for(int i = 0; i < pb.timeFrames().size(); i++)
// {
// int nbCoursesInThisTF = CSDVP::_randomizeIn(pb._minimalCoursesByTimeFrame, pb._maximalCoursesByTimeFrame);
// int courseIdx;
// std::cout << "In the TF "+std::to_string(i)+" I plan " << std::to_string(nbCoursesInThisTF) << " courses." << std::endl;
// for(int j = 0; j < nbCoursesInThisTF; j++)
// {
// insertRez = true;
// courseIdx = CSDVP::_randomizeIn(0,tmpCourses.size()-1);
// insertRez = tmpCourses.at(courseIdx).addTemporalFrame(pb.timeFrames().at(i));
// if(!insertRez) //If a duplicata has been prevented, we do not count the attempt
// j--;
// }
// }
for(int i = 0; i < tmpCourses.size(); i++)
if(tmpCourses.at(i).timeFrame().size() > 0)
pb.addCourseToCatalogue(tmpCourses.at(i));
//From here, coursesCatalogue can still be < to minCourseTF * nbTF (due to the fact that a same course can belongs to )
pb._makeCoursesSortedByTF();
/* COMPETENCY CREATION
* We create _quantityAvailableCompetency competencies. For each comp, we randomly define it's magnitude.
*/
......@@ -288,7 +363,9 @@ int CSDVP::CSDVP_COUNTER = 0;
{
tmpComp = queue.front();
queue.pop();queue.push(tmpComp);
teachedComp = std::pair<Competency,double>(tmpComp, 1.0);
magVal = pb.cfg_magnitudeMin().value() + ( (double)rand()/RAND_MAX) * ( pb.cfg_magnitudeMax().value() - pb.cfg_magnitudeMin().value()) ;
Competency cpt = Competency::build(magVal,tmpComp.c_name());
teachedComp = std::pair<Competency,double>(cpt, 1.0);
pb.unlocked_coursesCatalogue().at(i).addTeachedComp(teachedComp);
}
}
......@@ -307,8 +384,12 @@ int CSDVP::CSDVP_COUNTER = 0;
for(int j = 0; j < x; j++)
{
tmpComp = queue.front();
queue.pop(); queue.push(tmpComp);
pb.unlocked_coursesCatalogue().at(i).addPrerequisite(tmpComp);
queue.pop();
//we change mag value for prereq
magVal = pb.cfg_magnitudeMin().value() + ( (double)rand()/RAND_MAX) * ( pb.cfg_magnitudeMax().value() - pb.cfg_magnitudeMin().value()) ;
Competency cpt = Competency::build(magVal,tmpComp.c_name());
pb.unlocked_coursesCatalogue().at(i).addPrerequisite(cpt);
queue.push(tmpComp);
}
}
......
src/model/problem.h
View file @ 6dfc228f
......@@ -44,15 +44,18 @@ class CSDVP
int _minimalPrerequisiteByCourse;
int _maximalPrerequisiteByCourse;
int _pickedCoursesByTimeFrame;
Magnitude _minimalMagnitude;
Magnitude _maximalMagnitude;
// ---------- END CONFIGURATION ATTRIBUTES ----------
// ---------- PROBLEM SPECIFIC ATTRIBUTES ----------
// Theses attributes represent the CSDVP
std::vector<int> _timeFrames;
std::vector<int> _timeFrames; // Time frames stocks the VALUE, not the index
std::vector<Course> _availableCourses;
std::vector<Competency> _availableCompentecies;
std::vector<std::vector<Course>> _coursesSortedByTF; //sorted by standard index. e.g. TF[4;6] -> [0]=4; [1]=5 ; [2] = 6
std::vector<Competency> _availableCompentecies; //The competency's magnitude should not be used here.
///@todo implements a decay politics
//DecayPolitics
......@@ -75,6 +78,9 @@ class CSDVP
static double _randomizeIn(const double min, const double max);
// --------- END GENERATION RELATED FUNCTION ---------
/// It sources _coursesSortedByTF, which is another view of _availableCourses, sorted by TF
void _makeCoursesSortedByTF();
public:
// --------- GENERATION RELATED FUNCTION ---------
/// allows a random attribution of pb's attributes
......@@ -90,7 +96,9 @@ class CSDVP
// === CONSTRUCTOR
CSDVP();
/// Generate an instance of the CSDVP iff isConfig is true. Thus, seed != -1;
/**Generate an instance of the CSDVP iff isConfig is true. Thus, seed != -1;
* @developper each kind of generation must sources correctly the main arrays (_availableCours/comp) TF and _sortedCoursesByTF
*/
static void generateProblem(CSDVP & csdvp, CSDVP::GenerationType type, int seed= -1 );
// === GETTER
......@@ -108,15 +116,30 @@ class CSDVP
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 int cfg_pickedCoursesByTimeFrame() const {return this->_pickedCoursesByTimeFrame;}
const Magnitude & cfg_magnitudeMin() const{return this->_minimalMagnitude;}
const Magnitude & cfg_magnitudeMax() const{return this->_maximalMagnitude;}
const std::vector<int> & timeFrames() const{return this->_timeFrames;}
const std::vector<Course> & coursesCatalogue() const{return this->_availableCourses;}
/**CompetencyCatalogue should be used to know which competency exists in the current pb. However, it should not
* be used to know the magnitude of each comp in the pb, since these mag changes accordingly to the courses (and if it is teached or a prereq)
*/
const std::vector<Competency> & competencyCatalogue() const{return this->_availableCompentecies;}
const std::vector<std::vector<Course>> & coursesSortedByTF() const {return this->_coursesSortedByTF;}
std::vector<int> & unlocked_timeFrames(){return this->_timeFrames;}
std::vector<Course> & unlocked_coursesCatalogue(){return this->_availableCourses;}
std::vector<Competency> & unlocked_competenciesCatalogue(){return this->_availableCompentecies;}
const int getQuantityCoursesToPick() const{
if(this->_isConfig)
return this->_timeFrames.size() * this->_pickedCoursesByTimeFrame;
return -1;//if not config
}
/** Maps a course into its position inside the this->courseCatalogue().
* returns the index of the course within the coursesCatalogue [0;size[ ; otherwise return -1 if the course is not found.
*/
int mapCourseToPosition(const Course & c);
///@todo getDecayPolitic
// === MUTATOR
......@@ -137,6 +160,7 @@ class CSDVP
void set_cfg_maximalCompetencyByCourse(int nb);
void set_cfg_minimalPrerequisiteByCourse(int nb);
void set_cfg_maximalPrerequisiteByCourse(int nb);
void set_cfg_pickedCoursesByTimeFrame(int nb);
void setTimeFrames(std::vector<int> & v);
void setCoursesCatalogue(std::vector<Course> &);
......
src/model/profession.cpp
View file @ 6dfc228f
......@@ -2,10 +2,13 @@
#include <vector>
#include <utility>
#include <algorithm>
#include <cassert>
#include "profession.h"
#include "competency.h"
#include "exception/JobOverlappingBoundariesException.h"
int Profession::PROFESSION_COUNTER = 0;
// === FACTORY
......@@ -54,6 +57,32 @@ int Profession::PROFESSION_COUNTER = 0;
return *old;
}
void Profession::setRequiredECTS(int nb)
{
assert(nb >= 0);
this->_requiredECTS = nb;
}
void Profession::setRequiredECTS(Profession::GenerationType type)
{
if(type == Profession::GenerationType::RANDOM)
this->_isECTSRandom = true;
}
void Profession::set_cfg_minimalPrerequisites(int nb)
{this->_minimalPrerequisites = nb;}
void Profession::set_cfg_maximalPrerequisites(int nb)
{this->_maximalPrerequisites = nb;}
void Profession::set_cfg_minimalMagnitude(double mag)
{
this->_minimalMagnitude = Magnitude::build(mag);
}
void Profession::set_cfg_maximalMagnitude(double mag)
{
this->_maximalMagnitude = Magnitude::build(mag);
}
// ADDER
/** Adds a new competency to the prerequisites of a profession. It is protected against duplicata: it can't have twice the same competency.
*
......@@ -81,10 +110,127 @@ int Profession::PROFESSION_COUNTER = 0;
// === OPERATOR
std::ostream & operator<<(std::ostream & Stream, const Profession & p)
{
std::string s = "Profession\n\tid:"+std::to_string(p.id())+"\n\tname:"+p.name()+"\n\t#Prereq:"+std::to_string(p.prerequisites().size());
Stream << s;
std::string s = "Profession\n\tid:"+std::to_string(p.id())+"\n\tName:"+p.name()+"\n\tECTS: " + std::to_string(p.requiredECTS()) +"\n\t#Prereq:"+std::to_string(p.prerequisites().size())+"\n\t===Details:===\n\t";
Stream << s ;
for(int i = 0; i < p.prerequisites().size(); i++)
Stream << "("<< i<< "th) " << p.prerequisites().at(i) << "\n\t";
Stream << "==========" << std::endl;
return Stream;
}
bool Profession::checkConfig()
{
if( !this->_isECTSRandom && this->_requiredECTS <= 0)
{
this->_isConfig = false;
std::cout << "INFO: Profession lacks ECTS config" << std::endl;
return false;
}
if(this->_name.empty())
{
this->_isConfig = false;
std::cout << "INFO: Profession lacks name config" << std::endl;
return false;
}
if( this->_minimalPrerequisites < 0 ||
this->_maximalPrerequisites < 0 ||
this->_minimalMagnitude.value() < 0 ||
this->_maximalMagnitude.value() < 0 )
{
std::cout << "INFO: Config attributes not yet config" << std::endl;
this->_isConfig = false;
return false;
}
//verifying overlapping range
if( this->_minimalPrerequisites > this->_maximalPrerequisites ||
this->_minimalMagnitude.value() > this->_maximalMagnitude.value())
{
throw JobOverlappingBoundariesException(this);
}
this->_isConfig = true;
return true;
}
void Profession::_randomlyGenerate(Profession & job, CSDVP & pb)
{
srand(job.seed());
job.unlocked_prerequisites().clear();
int howManyPrereq = job.cfg_minimalPrerequisites() + ( rand() % ( job.cfg_maximalPrerequisites() - job.cfg_minimalPrerequisites() + 1) );
std::vector<Competency> tmpComp = pb.competencyCatalogue();
Competency ctmp;
double magVal;
std::random_shuffle(tmpComp.begin(), tmpComp.end());
int i;
for(i = 0; i < tmpComp.size() && i < howManyPrereq; i++)
{
magVal = job.cfg_minimalMagnitude().value() + ( (double)rand()/RAND_MAX) * ( job.cfg_maximalMagnitude().value() - job.cfg_minimalMagnitude().value()) ;
ctmp = Competency::buildTMP(magVal,tmpComp.at(i).name());
job.addPrerequisite(ctmp);
}
if(i != howManyPrereq) //Warning need to check if still in range because not enought courses
{
if(i < job.cfg_minimalPrerequisites() || i > job.cfg_maximalPrerequisites())
{
//considering as a fail during generation
assert(i < job.cfg_minimalPrerequisites() || i > job.cfg_maximalPrerequisites());
}
}
// If ECTS is set to be random, then calculating it
if(!job._isECTSRandom)
return;
// Formula of ECTS calcul is : SIGMA_{i=0}^{maxTF}(SIGMA_{j=0}^{nbCourseAvg}(rand(pb.minECTS,pb.maxECTS)))
int ects= 0;
// ects = pb.timeFrames().size() * 30; //30 is the default european value
for(i = 0; i < pb.timeFrames().size(); i++)
{
for(int j = 0; j < pb.cfg_pickedCoursesByTimeFrame(); j++)
{
if( (rand() % 100) > 35) //Take the average in 100-35 % of the cases
ects += ( pb.cfg_ectsMin() + rand() % (pb.cfg_ectsMax() - pb.cfg_ectsMin() +1) );
else
ects += ( pb.cfg_ectsMin() + rand() % ( (pb.cfg_ectsMax() -1) - pb.cfg_ectsMin() +1) );
}
}
job.setRequiredECTS(ects);
}
// === STATIC
int Profession::assignID(){return ++Profession::PROFESSION_COUNTER;}
\ No newline at end of file
int Profession::assignID(){return ++Profession::PROFESSION_COUNTER;}
// ---------- GENERATION FUNCTIONS ----------
void Profession::generateProfession(Profession & job, Profession::GenerationType type, CSDVP & csdvp, int seed)
{
job._seed = seed;
if( !job.checkConfig() || !csdvp.checkConfig())
{
std::cout << "Can't generate a profession with non configurated problem and profession !" << std::endl;
return;
}
switch (type)
{
case Profession::GenerationType::RANDOM:
_randomlyGenerate(job, csdvp);
break;
default:
break;
}
}
\ No newline at end of file
src/model/profession.h
View file @ 6dfc228f
......@@ -4,6 +4,7 @@
#include <vector>
#include "competency.h"
#include "problem.h"
/**
* A profession is a job sought by a student.
......@@ -13,9 +14,27 @@
class Profession
{
private:
std::vector<Competency> _prerequisites;
// ---------- CONFIGURATION ATTRIBUTES ---------
std::string _name;
int _requiredECTS = -1;
int _minimalPrerequisites = -1;
int _maximalPrerequisites = -1;
Magnitude _minimalMagnitude;
Magnitude _maximalMagnitude;
// ---------- END CONFIGURATIONS ATTRIBUTES ----------
// ---------- PROFESSION SPECIFIC ATTRIBUTES ----------
std::vector<Competency> _prerequisites;
// ---------- END PROFESSION SPECIFIC ATTRIBUTES
int _id;
int _seed;
/// Use to determine if Profession has been config by the user.
bool _isConfig;
bool _isECTSRandom =false;
// === FUNC
/** _duplicataProtection returns true if the value (2nd param) searched into (1st param) is found*/
......@@ -24,29 +43,57 @@ class Profession
// Static
static int PROFESSION_COUNTER;
static int assignID();
static void _randomlyGenerate(Profession & job, CSDVP & pb);
public:
enum GenerationType
{
RANDOM
//PRESET
};
Profession();
Profession(std::string name);
Profession(std::vector<Competency> & p, std::string n = "");
/** Generates the profession configuration. ECTS still needs to be filled before calling this function.
* Nonetheless, progession _prerequisites are taken randomly in the problem
*/
static void generateProfession(Profession & job, Profession::GenerationType type, CSDVP & csdvp, int seed = 0);
/**Checks the configuration of a profession, mostly before performing a generation.*/
bool checkConfig();
// === GETTER
const int id() const{return this->_id;}
const int seed() const{return this->_seed;}
const int requiredECTS() const{return this->_requiredECTS;}
const std::string name() const{return this->_name;}
const std::vector<Competency> & prerequisites() const{return this->_prerequisites;}
/// return a modifiable reference to _prerequisite;
std::vector<Competency> & unlocked_prerequisites(){return this->_prerequisites;}
const int cfg_minimalPrerequisites() const{return this->_minimalPrerequisites;}
const int cfg_maximalPrerequisites() const{return this->_maximalPrerequisites;}
const Magnitude cfg_minimalMagnitude() const{return this->_minimalMagnitude;}
const Magnitude cfg_maximalMagnitude() const{return this->_maximalMagnitude;}
// === MUTATOR
// SETTER
/// Set name of the profession. If name empty, creates a default name based on ID
void setName(std::string name);
/// Set the prerequisites of a profession. The old prereq is returned.
std::vector<Competency> & setPrerequisites(std::vector<Competency> & v);
void setRequiredECTS(int ects);
void setRequiredECTS(Profession::GenerationType type);
// ADDER
bool addPrerequisite(Competency &);
void set_cfg_minimalPrerequisites(int nb);
void set_cfg_maximalPrerequisites(int nb);
void set_cfg_minimalMagnitude(double mag);
void set_cfg_maximalMagnitude(double mag);
};
// === OPERATOR
......
src/model/tools.h
View file @ 6dfc228f
#ifndef SRC_MODEL_TOOLS_H_
#define SRC_MODEL_TOOLS_H
#define SRC_MODEL_TOOLS_H_
#include <vector>
#include <utility>
#include <algorithm>
#include <queue>
#include <random>
#include <limits>
static const int ID_RANGE_FOR_OBJECT = 10000;
static const int ID_RANGE_FOR_TEMPORARY_OBJECT = std::numeric_limits<int>::max();
template<typename T>
/** Searches into vec the element findMe. The class T must have T() defined ( T()=default; is OK) */
......@@ -38,4 +44,38 @@ static bool duplicataFlag(std::vector<T> & toProtect, T & toAdd)
}
template<typename T>
static std::pair<bool,T> getElementById(const std::vector<T> & elem, int idToFind)
{
for(int i = 0; i < elem.size(); i++)
{
if(elem.at(i).id() == idToFind)
return std::pair<bool,T>(true, elem.at(i));
}
return std::pair<bool, T>(false, T());
}
///Not working properly yet, just for debug
// static std::queue<int> RNG_QUEUE;
// /**Init a queue of size s from 0 to s, then shuffle it*/
// static void initRandomSuite(const unsigned int s)
// {
// RNG_QUEUE = std::queue<int>();
// std::vector<int> tmp (s);
// for(int i = 0; i < s; i++)
// tmp.push_back(i);
// // std::random_device rng;
// // std::mt19937 urng(rng());
// std::random_shuffle(tmp.begin(), tmp.end());
// for(int i = 0; i < tmp.size(); i++)
// RNG_QUEUE.push(tmp.at(i));
// }
// static int getNextRandom()
// {
// int tmp = RNG_QUEUE.front();
// RNG_QUEUE.pop();
// return tmp;
// }
#endif // SRC_MODEL_TOOLS_H_
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment