void Fern::rule1(int i)
{
if (i == 0)
;
else
{
rule2(i-1);
turnleft();
glPushMatrix();
glPushMatrix();
rule1(i-1);
glPopMatrix();
turnright();
rule1(i-1);
glPopMatrix();
turnright();
rule2(i - 1);
glPushMatrix();
turnright();
rule2(i - 1);
rule1(i - 1);
glPopMatrix();
turnleft();
rule1(i - 1);
}
}
void Simple_Tree::rule2(int i)
{
if (i == 0)
drawline();
else
{
rule2(i - 1);
rule2(i - 1);
}
}
void Fern::rule2(int i)
{
if (i == 0)
drawline();
else
{
rule2(i - 1);
rule2(i - 1);
}
}
void Sierpinski::rule1(int i)
{
if (i == 0)
drawline();
else{
rule2(i - 1);
turnright();
rule1(i - 1);
turnright();
rule2(i - 1);
}
}
void _3DTree2::rule1(int i)
{
if (i == 0)
drawellipse(5,0,5,2);
else
{
glScaled(.6, .6, .6);
rule2(i - 1);
glPushMatrix();
turnleft();
rule1(i - 1);
glPopMatrix();
rollleft();
rollleft();
rollleft();
rollleft();
glPushMatrix();
turnleft();
rule1(i - 1);
glPopMatrix();
rollleft();
rollleft();
rollleft();
rollleft();
glPushMatrix();
turnleft();
rule1(i - 1);
glPopMatrix();
}
}
virtual void SetUp() {
fuzzy = new Fuzzy(1);
//Fuzzy Sets - Input 0 - Velocidade
FuzzySet* velocidadeBaixa = new FuzzySet(0.0, 0.0, 30, 60);
FuzzySet* velocidadeMedia = new FuzzySet(30, 60, 60, 90);
FuzzySet* velocidadeAlta = new FuzzySet(60, 90, 100, 100);
//Index 0 - Input - Velocidade
fuzzy->addFuzzySet(0, 0, velocidadeBaixa); //Set 0
fuzzy->addFuzzySet(0, 1, velocidadeMedia); //Set 1
fuzzy->addFuzzySet(0, 2, velocidadeAlta); //Set 2
//Fuzzy Sets - Output - Consumo
FuzzySet* consumoAlto = new FuzzySet(0.0, 0.0, 3, 6);
FuzzySet* consumoMedio = new FuzzySet(3, 6, 6, 9);
FuzzySet* consumoBaixo = new FuzzySet(6, 9, 10, 10);
//Index 2 - Output
fuzzy->addFuzzySet(2, 0,consumoAlto);
fuzzy->addFuzzySet(2, 1, consumoMedio);
fuzzy->addFuzzySet(2, 2, consumoBaixo);
//Rules Base
FuzzyRule rule1(velocidadeMedia, consumoBaixo);
FuzzyRule rule2(velocidadeBaixa, consumoMedio);
FuzzyRule rule3(velocidadeAlta, consumoAlto);
fuzzy->addRule(rule1);
fuzzy->addRule(rule2);
fuzzy->addRule(rule3);
}
void AIElementGroupSwarm::step(Real evt)
{
//LogManager::getSingleton().logMessage("Swarm step.");
int i;
Vector3 v1,v2,v3,mVel;
for (i=0; i!=nodes.size(); i++)
{
AIElement* n = nodes[i];
v1=rule1(n);
v2=rule2(n);
v3=rule3(n);
mVel=n->getVelocity();
mVel+=v1+v2+v3;
//LogManager::getSingleton().logMessage(StringConverter::toString(nodes.size()));
// LogManager::getSingleton().logMessage(StringConverter::toString(v2));
// LogManager::getSingleton().logMessage(StringConverter::toString(v3));
//boundPosition(nodes[i]);
//tend_to_pos(nodes[i]);
//n->setPosition(n->getPosition()+mVel/(100000)*evt);
n->setVelocity(mVel*0.0001);
tendToPos(getPos());
n->sendCommand1(StringConverter::toString(GOTO_NPC));
n->sendCommand2(StringConverter::toString(n->getPosition()));
}
}
void
MonthDayRuleTest::test_lifecycle_valid()
{
const String ruleName("MyRule");
const Month refMonth(12);
const DayOfMonth refDayOfMonth(31);
//test: MontDayRule::MonthDayRule();
MonthDayRule rule1;
rule1.setRuleName(ruleName);
CPPUNIT_ASSERT(1 == rule1.getMonth().getValue());
CPPUNIT_ASSERT(1 == rule1.getDayOfMonth().getValue());
//test: MontDayRule::MonthDayRule(const MonthDayRule& other);
MonthDayRule rule2 (rule1);
CPPUNIT_ASSERT(1 == rule2.getMonth().getValue());
CPPUNIT_ASSERT(1 == rule2.getDayOfMonth().getValue());
CPPUNIT_ASSERT(ruleName == rule2.getRuleName());
//test: MontDayRule::MonthDayRule(const String& ruleName, const Month& month, const DayOfMonth& dayOfMonth);
MonthDayRule rule3 ("Rule3", refMonth, refDayOfMonth);
CPPUNIT_ASSERT(refMonth == rule3.getMonth());
CPPUNIT_ASSERT(refDayOfMonth == rule3.getDayOfMonth());
//test: MontDayRule::MonthDayRule(const String& ruleName, MonthOfYear::eMonthOfYear month, const DayOfMonth& dayOfMonth);
MonthDayRule rule4("Rule4", MonthOfYear::December, refDayOfMonth);
CPPUNIT_ASSERT(refMonth == rule3.getMonth());
CPPUNIT_ASSERT(refDayOfMonth == rule3.getDayOfMonth());
}
void Flock::update(const Scene & scene){
for(std::vector<Boid * >::iterator it = boids.begin(); it != boids.end(); ++it) {
int index = it - boids.begin();
Vector v = rule1(index) + rule2(index) + rule3(index);
v = v * damping;
Boid * boid = *it;
v = v + boid->getVelocity();
if(v.getLength() > maxSpeed){
v = v * (maxSpeed/v.getLength());
}
Point p = boid->getCenter();
double wind = 0.12;
Vector windVector;
if(p.x> 900 ){
windVector = Vector(-wind,0);
} else if(p.x< 150 ){
windVector = Vector(wind,0);
} else if(p.y> 350 ){
windVector = Vector(0,-wind);
} else if(p.y< 150 ){
windVector = Vector(0,wind);
}
boid->setVelocity(v + windVector);
boid->setCenter(boid->getCenter() + boid->getVelocity());
}
}
void _3DTree4::rule2(int i)
{
if (i == 0)
drawcylinder();
else
{
rule2(i - 1);
}
}
void BoidFlock::update() {
for (unsigned i = 0; i < boidCount; i++) {
Boid *b = boids[i];
vec3 v1 = rule1(b);
vec3 v2 = rule2(b);
vec3 v3 = rule3(b);
vec3 pos = boundPosition(b);
b->incVelocity((v1 + v2 + v3 + pos) / 100.0f);
limitSpeed(b);
b->update();
}
}
void run(int *board,int h,int w)
{
int i,j;
statusList=initializeList(&statusList);
for(i=0;i<h;i++)
{
for(j=0;j<w;j++)
{
rule1(board,i,j,h,w);
rule2(board,i,j,h,w);
}
}
applyChanges(board,w);
}
void Simple_Tree::rule1(int i)
{
if (i == 0)
drawline();
else
{
rule2(i - 1);
glPushMatrix();
turnleft();
rule1(i - 1);
glPopMatrix();
turnright();
rule1(i - 1);
}
}
bool funcEND(ParserParam ¶m, Token *tok){
switch(param.stack.back()){
case 1:
shift(param,tok,2);
break;
case 2:
param.isAccept = true;
break;
case 3:
if(!rule2(param)) return false;
break;
case 4:
if(!rule1(param)) return false;
break;
case 7:
if(!rule3(param)) return false;
break;
case 8:
if(!rule4(param)) return false;
break;
case 12:
if(!rule5(param)) return false;
break;
case 14:
if(!rule6(param)) return false;
break;
case 25:
if(!rule15(param)) return false;
break;
case 30:
if(!rule17(param)) return false;
break;
case 31:
if(!rule18(param)) return false;
break;
case 33:
if(!rule19(param)) return false;
break;
case 34:
if(!rule20(param)) return false;
break;
default:
return false;
break;
}
return true;
}
void
MonthWeekDayRuleTest::test_lifecycle_valid()
{
const String ruleName("MyRule");
const MonthOfYear::eMonthOfYear refMonth = MonthOfYear::January;
const MonthWeek::eMonthWeek refWeekOfMonth = MonthWeek::First ;
const WeekDay::eWeekDay refWeekDay = WeekDay::Sunday;
//test: MontDayRule::MonthDayRule();
MonthWeekDayRule rule1;
rule1.setRuleName(ruleName);
CPPUNIT_ASSERT(refMonth == rule1.getMonth().monthOfYear());
CPPUNIT_ASSERT(refWeekOfMonth == rule1.getMonthWeek());
CPPUNIT_ASSERT(refWeekDay == rule1.getWeekDay());
//test: MontDayRule::MonthDayRule(const MonthDayRule& other);
MonthWeekDayRule rule2 (rule1);
CPPUNIT_ASSERT(refMonth == rule2.getMonth().monthOfYear());
CPPUNIT_ASSERT(refWeekOfMonth == rule2.getMonthWeek());
CPPUNIT_ASSERT(refWeekDay == rule2.getWeekDay());
CPPUNIT_ASSERT(ruleName == rule2.getRuleName());
//test: MonthWeekDayRule::MonthWeekDayRule(const String& ruleName, const Month& month, MonthWeek::eMonthWeek weekInMonth, WeekDay::eWeekDay dayOfWeek);
MonthWeekDayRule rule3 ("Rule3", Month(1), refWeekOfMonth, refWeekDay);
CPPUNIT_ASSERT(refMonth == rule3.getMonth().monthOfYear());
CPPUNIT_ASSERT(refWeekOfMonth == rule3.getMonthWeek());
CPPUNIT_ASSERT(refWeekDay == rule3.getWeekDay());
//test: MonthWeekDayRule::MonthWeekDayRule(const String& ruleName, MonthOfYear::eMonthOfYear month, WeekOfMonth::eWeekOfMonth weekInMonth, WeekDay::eWeekDay dayOfWeek);
MonthWeekDayRule rule4("Rule4", refMonth, refWeekOfMonth, refWeekDay);
CPPUNIT_ASSERT(refMonth == rule4.getMonth().monthOfYear());
CPPUNIT_ASSERT(refWeekOfMonth == rule4.getMonthWeek());
CPPUNIT_ASSERT(refWeekDay == rule4.getWeekDay());
}
bool funcNUM(ParserParam ¶m, Token *tok){
switch(param.stack.back()){
case 3:
if(!rule2(param)) return false;
break;
case 4:
if(!rule1(param)) return false;
break;
case 7:
if(!rule3(param)) return false;
break;
case 8:
if(!rule4(param)) return false;
break;
case 12:
if(!rule5(param)) return false;
break;
case 14:
if(!rule6(param)) return false;
break;
case 19:
if(!rule67(param)) return false;
break;
case 22:
shift(param,tok,23);
break;
case 25:
if(!rule15(param)) return false;
break;
case 27:
shift(param,tok,99);
break;
case 28:
shift(param,tok,99);
break;
case 30:
if(!rule17(param)) return false;
break;
case 31:
if(!rule18(param)) return false;
break;
case 33:
if(!rule19(param)) return false;
break;
case 34:
if(!rule20(param)) return false;
break;
case 37:
shift(param,tok,99);
break;
case 39:
if(!rule25(param)) return false;
break;
case 41:
if(!rule26(param)) return false;
break;
case 42:
shift(param,tok,99);
break;
case 44:
if(!rule27(param)) return false;
break;
case 46:
if(!rule28(param)) return false;
break;
case 48:
shift(param,tok,99);
break;
case 50:
shift(param,tok,99);
break;
case 52:
shift(param,tok,99);
break;
case 53:
if(!rule29(param)) return false;
break;
case 55:
shift(param,tok,99);
break;
case 57:
shift(param,tok,99);
break;
case 58:
if(!rule30(param)) return false;
break;
case 59:
if(!rule31(param)) return false;
break;
case 60:
shift(param,tok,99);
break;
case 62:
if(!rule32(param)) return false;
break;
case 63:
shift(param,tok,99);
break;
case 65:
if(!rule33(param)) return false;
break;
case 67:
shift(param,tok,99);
break;
case 70:
shift(param,tok,99);
break;
case 73:
shift(param,tok,99);
break;
case 76:
shift(param,tok,99);
break;
case 79:
shift(param,tok,99);
break;
case 81:
shift(param,tok,99);
break;
case 84:
shift(param,tok,99);
break;
case 87:
shift(param,tok,99);
break;
case 89:
shift(param,tok,99);
break;
case 93:
shift(param,tok,99);
break;
case 96:
shift(param,tok,99);
break;
case 100:
if(!rule54(param)) return false;
break;
case 101:
if(!rule55(param)) return false;
break;
case 102:
if(!rule56(param)) return false;
break;
case 103:
if(!rule57(param)) return false;
break;
case 104:
if(!rule58(param)) return false;
break;
case 105:
if(!rule59(param)) return false;
break;
case 106:
if(!rule60(param)) return false;
break;
case 107:
if(!rule61(param)) return false;
break;
case 108:
if(!rule62(param)) return false;
break;
case 109:
if(!rule63(param)) return false;
break;
case 110:
if(!rule64(param)) return false;
break;
case 111:
if(!rule65(param)) return false;
break;
case 112:
if(!rule66(param)) return false;
break;
default:
return false;
break;
}
return true;
}
bool funcSEMI(ParserParam ¶m, Token *tok){
switch(param.stack.back()){
case 3:
if(!rule2(param)) return false;
break;
case 4:
if(!rule1(param)) return false;
break;
case 6:
shift(param,tok,7);
break;
case 7:
if(!rule3(param)) return false;
break;
case 8:
if(!rule4(param)) return false;
break;
case 12:
if(!rule5(param)) return false;
break;
case 14:
if(!rule6(param)) return false;
break;
case 24:
shift(param,tok,25);
break;
case 25:
if(!rule15(param)) return false;
break;
case 27:
shift(param,tok,39);
break;
case 28:
shift(param,tok,39);
break;
case 30:
if(!rule17(param)) return false;
break;
case 31:
if(!rule18(param)) return false;
break;
case 33:
if(!rule19(param)) return false;
break;
case 34:
if(!rule20(param)) return false;
break;
case 37:
shift(param,tok,39);
break;
case 39:
if(!rule25(param)) return false;
break;
case 40:
shift(param,tok,41);
break;
case 41:
if(!rule26(param)) return false;
break;
case 43:
shift(param,tok,44);
break;
case 44:
if(!rule27(param)) return false;
break;
case 45:
shift(param,tok,46);
break;
case 46:
if(!rule28(param)) return false;
break;
case 50:
shift(param,tok,39);
break;
case 52:
shift(param,tok,39);
break;
case 53:
if(!rule29(param)) return false;
break;
case 57:
shift(param,tok,39);
break;
case 58:
if(!rule30(param)) return false;
break;
case 59:
if(!rule31(param)) return false;
break;
case 61:
shift(param,tok,62);
break;
case 62:
if(!rule32(param)) return false;
break;
case 64:
shift(param,tok,65);
break;
case 65:
if(!rule33(param)) return false;
break;
case 66:
if(!rule35(param)) return false;
break;
case 68:
if(!rule34(param)) return false;
break;
case 69:
if(!rule37(param)) return false;
break;
case 71:
if(!rule36(param)) return false;
break;
case 72:
if(!rule39(param)) return false;
break;
case 74:
if(!rule38(param)) return false;
break;
case 75:
if(!rule41(param)) return false;
break;
case 77:
if(!rule40(param)) return false;
break;
case 78:
if(!rule44(param)) return false;
break;
case 80:
if(!rule42(param)) return false;
break;
case 82:
if(!rule43(param)) return false;
break;
case 83:
if(!rule46(param)) return false;
break;
case 85:
if(!rule45(param)) return false;
break;
case 86:
if(!rule47(param)) return false;
break;
case 88:
if(!rule48(param)) return false;
break;
case 91:
if(!rule49(param)) return false;
break;
case 92:
if(!rule50(param)) return false;
break;
case 95:
if(!rule51(param)) return false;
break;
case 98:
if(!rule52(param)) return false;
break;
case 99:
if(!rule53(param)) return false;
break;
case 113:
if(!rule68(param)) return false;
break;
default:
return false;
break;
}
return true;
}
bool funcREAD(ParserParam ¶m, Token *tok){
switch(param.stack.back()){
case 3:
if(!rule2(param)) return false;
break;
case 4:
if(!rule1(param)) return false;
break;
case 7:
if(!rule3(param)) return false;
break;
case 8:
if(!rule4(param)) return false;
break;
case 12:
if(!rule5(param)) return false;
break;
case 14:
if(!rule6(param)) return false;
break;
case 25:
if(!rule15(param)) return false;
break;
case 27:
shift(param,tok,63);
break;
case 28:
shift(param,tok,63);
break;
case 30:
if(!rule17(param)) return false;
break;
case 31:
if(!rule18(param)) return false;
break;
case 33:
if(!rule19(param)) return false;
break;
case 34:
if(!rule20(param)) return false;
break;
case 37:
shift(param,tok,63);
break;
case 39:
if(!rule25(param)) return false;
break;
case 41:
if(!rule26(param)) return false;
break;
case 44:
if(!rule27(param)) return false;
break;
case 46:
if(!rule28(param)) return false;
break;
case 50:
shift(param,tok,63);
break;
case 52:
shift(param,tok,63);
break;
case 53:
if(!rule29(param)) return false;
break;
case 57:
shift(param,tok,63);
break;
case 58:
if(!rule30(param)) return false;
break;
case 59:
if(!rule31(param)) return false;
break;
case 62:
if(!rule32(param)) return false;
break;
case 65:
if(!rule33(param)) return false;
break;
default:
return false;
break;
}
return true;
}
TEST_F(FuzzyTest, testarFuzzificationComDuasEntradas){
Fuzzy* fuzzy2 = new Fuzzy(2);
//Fuzzy Sets - Input 0 - Velocidade
FuzzySet* velocidadeBaixa = new FuzzySet(0.0, 0.0, 30, 60);
FuzzySet* velocidadeMedia = new FuzzySet(30, 60, 60, 90);
FuzzySet* velocidadeAlta = new FuzzySet(60, 90, 100, 100);
//Index 0 - Input - Velocidade
fuzzy2->addFuzzySet(0, 0, velocidadeBaixa); //Set 0
fuzzy2->addFuzzySet(0, 1, velocidadeMedia); //Set 1
fuzzy2->addFuzzySet(0, 2, velocidadeAlta); //Set 2
//Fuzzy Sets - Input 1 - Distância
FuzzySet* distanciaPequena = new FuzzySet(0.0, 0.0, 15, 30);
FuzzySet* distanciaMedia = new FuzzySet(15, 30, 30, 45);
FuzzySet* distanciaGrande = new FuzzySet(30, 45, 100, 100);
//Index 1 - Input - Distância
fuzzy2->addFuzzySet(1, 0, distanciaPequena); //Set 0
fuzzy2->addFuzzySet(1, 1, distanciaMedia); //Set 1
fuzzy2->addFuzzySet(1, 2, distanciaGrande); //Set 2
//Fuzzy Sets - Output - Consumo
FuzzySet* frearPouco = new FuzzySet(0.0, 0.0, 3, 6);
FuzzySet* frearMedio = new FuzzySet(3, 6, 6, 9);
FuzzySet* frearMuito = new FuzzySet(6, 9, 10, 10);
//Index 2 - Output
fuzzy2->addFuzzySet(2, 0,frearPouco);
fuzzy2->addFuzzySet(2, 1, frearMedio);
fuzzy2->addFuzzySet(2, 2, frearMuito);
//Rules Base
FuzzyRule rule1(velocidadeBaixa, distanciaPequena, frearMuito);
FuzzyRule rule2(velocidadeBaixa, distanciaMedia, frearMedio);
FuzzyRule rule3(velocidadeAlta, distanciaGrande, frearPouco);
fuzzy2->addRule(rule1);
fuzzy2->addRule(rule2);
fuzzy2->addRule(rule3);
/****************************/
//Definindo o valor crisp da Velocidade
fuzzy2->setInputs(0, 60);
//Definindo o valor crisp da Distancia
fuzzy2->setInputs(1, 30);
//Fuzzificando
fuzzy2->fuzzify(0);
fuzzy2->fuzzify(1);
EXPECT_FLOAT_EQ(0, fuzzy2->getFuzzification(1, 0));
EXPECT_FLOAT_EQ(1, fuzzy2->getFuzzification(1, 1));
EXPECT_FLOAT_EQ(0, fuzzy2->getFuzzification(1, 2));
/********/
/****************************/
fuzzy2->setInputs(1, 37);
fuzzy2->fuzzify(1);
EXPECT_FLOAT_EQ(0, fuzzy2->getFuzzification(1, 0));
EXPECT_FLOAT_EQ(0.5333333, fuzzy2->getFuzzification(1, 1));
EXPECT_FLOAT_EQ(0.46666664, fuzzy2->getFuzzification(1, 2));
/***************************/
fuzzy2->setInputs(0, 50);
fuzzy2->setInputs(1, 29);
fuzzy2->fuzzify(0);
fuzzy2->fuzzify(1);
fuzzy2->evaluate();
float freio = fuzzy2->desfuzzify();
EXPECT_FLOAT_EQ(6.1111112, freio);
}
void _3DTree4::rule1(int i)
{
if (i == 0)
drawellipse(2, 0, 2, 1);
else
{
glScaled(.9, .9, .9);
rule2(i - 1);
rule2(i - 1);
glPushMatrix();
turnleft();
rule1(i - 1);
glPopMatrix();
rollleft();
rollleft();
glPushMatrix();
turnleft();
rule1(i - 1);
glPopMatrix();
rollleft();
rollleft();
glPushMatrix();
turnleft();
rule1(i - 1);
glPopMatrix();
rollleft();
rollleft();
glPushMatrix();
turnleft();
rule1(i - 1);
glPopMatrix();
rollleft();
rollleft();
glPushMatrix();
turnleft();
rule1(i - 1);
glPopMatrix();
rollleft();
rollleft();
glPushMatrix();
turnleft();
rule1(i - 1);
glPopMatrix();
rule2(i - 1);
glPushMatrix();
turnleft();
rule1(i - 1);
glPopMatrix();
rollleft();
rollleft();
glPushMatrix();
turnleft();
rule1(i - 1);
glPopMatrix();
rollleft();
rollleft();
glPushMatrix();
turnleft();
rule1(i - 1);
glPopMatrix();
rollleft();
rollleft();
glPushMatrix();
turnleft();
rule1(i - 1);
glPopMatrix();
rollleft();
rollleft();
glPushMatrix();
turnleft();
rule1(i - 1);
glPopMatrix();
rollleft();
rollleft();
glPushMatrix();
turnleft();
rule1(i - 1);
glPopMatrix();
}
}
