// Test that uniform_int<> can be used with std::random_shuffle
// Author: Jos Hickson
void test_random_shuffle()
{
typedef boost::uniform_int<> distribution_type;
typedef boost::variate_generator<boost::mt19937 &, distribution_type> generator_type;
boost::mt19937 engine1(1234);
boost::mt19937 engine2(1234);
rand_for_random_shuffle<boost::mt19937> referenceRand(engine1);
distribution_type dist(0,10);
generator_type testRand(engine2, dist);
std::vector<int> referenceVec;
for (int i = 0; i < 200; ++i)
{
referenceVec.push_back(i);
}
std::vector<int> testVec(referenceVec);
std::random_shuffle(referenceVec.begin(), referenceVec.end(), referenceRand);
std::random_shuffle(testVec.begin(), testVec.end(), testRand);
typedef std::vector<int>::iterator iter_type;
iter_type theEnd(referenceVec.end());
for (iter_type referenceIter(referenceVec.begin()), testIter(testVec.begin());
referenceIter != theEnd;
++referenceIter, ++testIter)
{
BOOST_CHECK_EQUAL(*referenceIter, *testIter);
}
}
int main(int argc, char *argv[])
{
int i1=atoi(argv[1]);//player 1
int i2=atoi(argv[2]);//player 2
int N,i,j;
N=42;
srand(time(NULL));
char** maze=malloc(N*sizeof(char*));
int** Maze=malloc(N*sizeof(int*));
for(i=0;i<N;i++){
maze[i]=malloc(N*sizeof(char));
Maze[i]=malloc(N*sizeof(int));
}
generateMaze2(maze,N); //generates random maze
get_intMaze2(Maze,maze,N); //creates the corresponding integer maze
printmaze2(maze,N,0,0,0,'U');
int score_U,score_E;
score_U=score_E=0;
int count=0; //count is the number of elements in the maze other than U and E
int ux,uy,ex,ey;
for(i=0;i<N;i++)
{
for(j=0;j<N;j++)
{
if(maze[i][j]=='U')
{
ux=i;
uy=j;
}
else if(maze[i][j]=='E')
{
ex=i;
ey=j;
}
else count++;
}
}
if(count!=(N*N -2))//to check if E and U are at same positions
{
ux=ex; //If U and E are at same position U can't be seen in the maze.So,it assigns the position of E to U.
uy=ey;
}
switch(i1){
case 1:Initialise1(Maze);
case 2:Initialise2(Maze);
case 3:Initialise3(Maze);
}
switch(i2){
case 1:Initialise1(Maze);
case 2:Initialise2(Maze);
case 3:Initialise3(Maze);
}
engine2(Maze,maze,N,score_U,score_E,ux,uy,ex,ey,i1,i2);
}
int main()
{
boost::mt19937 engine1(1234);
boost::mt19937 engine2(1234);
boost::uniform_int<> dist(100,200);
for (int i=0; i<20; i++)
{
std::cout << dist(engine1) << " is equal to " << dist(engine2) << std::endl;
}
}
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
srand(time(NULL));
DataSet sample("../sample_datasets/wine");
DataSet sample2("../sample_datasets/winequality_white");
std::string attributeNames[] = {"kolor", "kwaskowatość"};
std::list<std::string> attributes(attributeNames, attributeNames + sizeof(attributeNames) / sizeof(attributeNames[0]));
DataSet test(attributes);
//kolor: 0 żółty 1.2 1 zielony 2
for(int i = 0; i < 256; ++i)
{
if(i % 4 == 0)
{
//słodkie zielone jabłko: kolor [1.0 1.5] kwaskowatość[0.1;0.4]
std::vector<float> attrs(2);
attrs[0] = randFloat(1.0f, 1.5f);
attrs[1] = randFloat(.1f, .4f);
test.addInstance(DataSet::DataInstance(attrs, 0));
}
if(i % 4 == 1)
{
//banan: kolor [0.5;1.1] kwaskowatość[0.0 0.1]
std::vector<float> attrs(2);
attrs[0] = randFloat(.5f, 1.1f);
attrs[1] = randFloat(0.0f, 0.1f);
test.addInstance(DataSet::DataInstance(attrs, 1));
}
if(i % 4 == 2)
{
//kiwi: kolor [1.5;2.0] kwaskowatość[0.3;0.8]
std::vector<float> attrs(2);
attrs[0] = randFloat(1.5f, 2.0f);
attrs[1] = randFloat(.3f, .8f);
test.addInstance(DataSet::DataInstance(attrs, 2));
}
if(i % 4 == 3)
{
//ananas: kolor [0.0;0.8] kwaskowatość[0.3 0.9]
std::vector<float> attrs(2);
attrs[0] = randFloat(0.0f, 0.8f);
attrs[1] = randFloat(.3f, .9f);
test.addInstance(DataSet::DataInstance(attrs, 3));
}
}
DataSet trainingData, testData;
// test.getTrainingAndTestSets(0.1, trainingData, testData);
// sample.getTrainingAndTestSets(0.1, trainingData, testData);
sample2.getTrainingAndTestSets(0.1, trainingData, testData);
// RuleBase testRuleBase;
// {//jabłko
// FuzzySetContainer premises;
// premises.insert(TriangularFuzzySet(1.0, 1.25, 1.5), 0);
// premises.insert(TriangularFuzzySet(1.0, 1.25, 1.5), 1);
// testRuleBase.addRule(RuleBase::Rule(premises, TriangularFuzzySet(-0.1,0,0.1)));
// }
// {//banan
// FuzzySetContainer premises;
// premises.insert(TriangularFuzzySet(0.5, 1.0, 1.1), 0);
// premises.insert(TriangularFuzzySet(0.0, 0.05, 0.1), 1);
// testRuleBase.addRule(RuleBase::Rule(premises, TriangularFuzzySet(0.9,1,1.1)));
// }
// {//kiwi
// FuzzySetContainer premises;
// premises.insert(TriangularFuzzySet(1.5, 1.75, 2.0), 0);
// premises.insert(TriangularFuzzySet(0.3, 0.5, 0.8), 1);
// testRuleBase.addRule(RuleBase::Rule(premises, TriangularFuzzySet(1.9,2,2.1)));
// }
// {//ananas
// FuzzySetContainer premises;
// premises.insert(TriangularFuzzySet(0.0, 0.6, 0.8), 0);
// premises.insert(TriangularFuzzySet(0.3, 0.6, 0.9), 1);
// testRuleBase.addRule(RuleBase::Rule(premises, TriangularFuzzySet(2.9,3,3.1)));
// }
float perf;
// FuzzyInferenceEngine engine(testRuleBase);
// engine.init();
// perf = engine.testPerformance(trainingData);
// std::cout<<"Performance on training data: "<<perf*100.0f<<'%'<<std::endl;
// perf = engine.testPerformance(testData);
// std::cout<<"Performance on test data: "<<perf*100.0f<<'%'<<std::endl;
FuzzyRuleBaseCreator creator(trainingData);
for(int i = 0; i < trainingData.getNumberOfAttributes(); ++i)
{
creator.setRegularPartitionForAttribute(i, 4);
creator.setFunctionClassForAttribute(i, TriangularFuzzySet());
}
creator.setFunctionClassForClass(TriangularFuzzySet());
creator.setRegularPartitionForClass(4);
RuleBase learnedBase;
creator.learnRules(learnedBase);
FuzzyInferenceEngine engine2(learnedBase);
engine2.init();
perf = engine2.testPerformance(trainingData);
std::cout<<"Performance on training data: "<<perf*100.0f<<'%'<<std::endl;
perf = engine2.testPerformance(testData);
std::cout<<"Performance on test data: "<<perf*100.0f<<'%'<<std::endl;
QTimer::singleShot(0, &a, SLOT(quit()));
return a.exec();
}
/******************************************************************
*ux,uy coordinates of U
*ex,ey coordinates of E
*engine2 controls game play ,calls bot, changes position of bot and
* makes the new maze ready for the next player.
*done =0 till R is not visited
* 1 if R is reached(Game over)
************************************************************************/
void engine2(int** Maze,char** maze,int N,int score_U,int score_E,int ux,int uy,int ex,int ey, int bot_num1, int bot_num2){
int done=0;
int p;
switch(bot_num1){ //calls the respective bots
case(1): p=bot1(Maze,maze,N,score_U,score_E,ux,uy,ex,ey);
break;
case(2): p=bot2(Maze,maze,N,score_U,score_E,ux,uy,ex,ey);
break;
case(3): p=bot3(Maze,maze,N,score_U,score_E,ux,uy,ex,ey);
break;
}
//making changes in maze by moving U to the new position
if(ux==ex && uy==ey)
maze[ux][uy]='E';//case when U and E overlap
else
maze[ux][uy]='.';
if(p==0)
ux--;
else if(p==1)
uy++;
else if(p==2)
ux++;
else
uy--;
score_U += Maze[ux][uy];
Maze[ux][uy]=0;
if(maze[ux][uy]=='R') //check if the game is over
done=1;
maze[ux][uy]='U';
printmaze2(maze,N,score_U,score_E,done,'U');
if(done==0)//if the game is not done calls next player
{
switch(bot_num2){
case(1): p=bot1(Maze,maze,N,score_U,score_E,ex,ey,ux,uy);
break;
case(2): p=bot2(Maze,maze,N,score_U,score_E,ex,ey,ux,uy);
break;
case(3): p=bot3(Maze,maze,N,score_U,score_E,ex,ey,ux,uy);
break;
}
//making changes in maze by moving E to the new position
if(ex==ux && ey== uy)
maze[ex][ey]='U';
else
maze[ex][ey]='.';
if(p==0) ex--;
else if(p==1)ey++;
else if(p==2)ex++;
else ey--;
score_E += Maze[ex][ey];
Maze[ex][ey]=0;
if(maze[ex][ey]=='R')
done=1;
maze[ex][ey]='E';
printmaze2(maze,N,score_U,score_E,done,'E');
if(done!=1)//continue the game if its not done
engine2(Maze,maze,N,score_U,score_E,ux,uy,ex,ey,bot_num1,bot_num2);
}
}
