Example #1
0
TEST(FuzzyRuleAntecedent, joinSingle){
  FuzzyRuleAntecedent* fuzzyRuleAntecedent = new FuzzyRuleAntecedent();

  FuzzySet* fuzzySet = new FuzzySet(0, 10, 10, 20);

  bool result = fuzzyRuleAntecedent->joinSingle(fuzzySet);

  EXPECT_TRUE(result);
}
Example #2
0
TEST(Fuzzy, setInputAndFuzzifyAndDefuzzify08){
  Fuzzy* fuzzy = new Fuzzy();

  FuzzyInput* age = new FuzzyInput(1);

  FuzzySet* months = new FuzzySet(-360, -6, 5, 1200);
  age->addFuzzySet(months);

  fuzzy->addFuzzyInput(age);

  FuzzyOutput* quality = new FuzzyOutput(1);

  FuzzySet* avaliation = new FuzzySet(0, 1, 1, 1);
  quality->addFuzzySet(avaliation);

  fuzzy->addFuzzyOutput(quality);

  //-------------------- Montando as regras Fuzzy
  FuzzyRuleAntecedent* ifMonths = new FuzzyRuleAntecedent();
  ifMonths->joinSingle(months);

  FuzzyRuleConsequent* thenAvaliation = new FuzzyRuleConsequent();
  thenAvaliation->addOutput(avaliation);
  
  // Instanciando um objeto FuzzyRule
  FuzzyRule* fuzzyRule01 = new FuzzyRule(1, ifMonths, thenAvaliation);
  fuzzy->addFuzzyRule(fuzzyRule01);

  fuzzy->setInput(1, 50);

  fuzzy->fuzzify();
  // cout << "Pertinência (months): " << months->getPertinence() << endl;

  // cout << "Pertinência (avaliation): " << avaliation->getPertinence() << endl;

  float fuzzyAntecedentEvaluate = ifMonths->evaluate();

  // cout << "Entrada: " << dist << ", Saida: " << output << endl;

  EXPECT_EQ(months->getPertinence(), fuzzyAntecedentEvaluate);
}
Example #3
0
TEST(Fuzzy, addFuzzyRule){
  Fuzzy* fuzzy = new Fuzzy();

  FuzzyRuleAntecedent* seTemperatureLowOrpressureSmall = new FuzzyRuleAntecedent();
  FuzzySet* temperatureLow = new FuzzySet(0, 10, 10, 20);
  temperatureLow->setPertinence(0.5);
  FuzzySet* pressureSmall = new FuzzySet(0, 10, 10, 20);
  pressureSmall->setPertinence(0.5);
  seTemperatureLowOrpressureSmall->joinWithOR(temperatureLow, pressureSmall);

  FuzzyRuleAntecedent* andRiskMinimum = new FuzzyRuleAntecedent();
  FuzzySet* riskMinimum = new FuzzySet(0, 10, 10, 20);
  riskMinimum->setPertinence(0.7);
  andRiskMinimum->joinSingle(riskMinimum);

  FuzzyRuleAntecedent* seTemperatureLowOrpressureSmallandRiskMinimum = new FuzzyRuleAntecedent();
  seTemperatureLowOrpressureSmallandRiskMinimum->joinWithAND(seTemperatureLowOrpressureSmall, andRiskMinimum);

  FuzzyRuleConsequent* thenDangerLow = new FuzzyRuleConsequent();

  FuzzySet* dangerLow = new FuzzySet(0, 10, 10, 20);

  thenDangerLow->addOutput(dangerLow);

  FuzzyRule* fuzzyRule = new FuzzyRule(1, seTemperatureLowOrpressureSmallandRiskMinimum, thenDangerLow);
  
  bool result = fuzzy->addFuzzyRule(fuzzyRule);

  EXPECT_TRUE(result);
}
int main(int argc, char *argv[]) {
	Fuzzy* fuzzy = new Fuzzy();

	// FuzzyInput
	FuzzyInput* distance = new FuzzyInput(1);

	FuzzySet* close = new FuzzySet(0, 20, 20, 40);
	distance->addFuzzySet(close);
	FuzzySet* safe = new FuzzySet(30, 50, 50, 70);
	distance->addFuzzySet(safe);
	FuzzySet* distante = new FuzzySet(60, 80, 100, 100);
	distance->addFuzzySet(distante);

	fuzzy->addFuzzyInput(distance);

	// FuzzyInput
	FuzzyInput* inputSpeed = new FuzzyInput(2);

	FuzzySet* stoped = new FuzzySet(0, 0, 0, 0);
	inputSpeed->addFuzzySet(stoped);
	FuzzySet* slow = new FuzzySet(1, 10, 10, 20);
	inputSpeed->addFuzzySet(slow);
	FuzzySet* normal = new FuzzySet(15, 30, 30, 50);
	inputSpeed->addFuzzySet(normal);
	FuzzySet* quick = new FuzzySet(45, 60, 70, 70);
	inputSpeed->addFuzzySet(quick);

	fuzzy->addFuzzyInput(inputSpeed);

	// FuzzyInput
	FuzzyInput* temperature = new FuzzyInput(3);

	FuzzySet* cold = new FuzzySet(-30, -30, -20, -10);
	temperature->addFuzzySet(cold);
	FuzzySet* good = new FuzzySet(-15, 0, 0, 15);
	temperature->addFuzzySet(good);
	FuzzySet* hot = new FuzzySet(10, 20, 30, 30);
	temperature->addFuzzySet(hot);

	fuzzy->addFuzzyInput(temperature);

	// FuzzyOutput
	FuzzyOutput* risk = new FuzzyOutput(1);

	FuzzySet* minimum = new FuzzySet(0, 20, 20, 40);
	risk->addFuzzySet(minimum);
	FuzzySet* average = new FuzzySet(30, 50, 50, 70);
	risk->addFuzzySet(average);
	FuzzySet* maximum = new FuzzySet(60, 80, 80, 100);
	risk->addFuzzySet(maximum);

	fuzzy->addFuzzyOutput(risk);

	// FuzzyOutput
	// adicionando speed como output também
	FuzzyOutput* outputSpeed = new FuzzyOutput(2);

	FuzzySet* stopedOut = new FuzzySet(0, 0, 0, 0);
	outputSpeed->addFuzzySet(stopedOut);
	FuzzySet* slowOut = new FuzzySet(1, 10, 10, 20);
	outputSpeed->addFuzzySet(slowOut);
	FuzzySet* normalOut = new FuzzySet(15, 30, 30, 50);
	outputSpeed->addFuzzySet(normalOut);
	FuzzySet* quickOut = new FuzzySet(45, 60, 70, 70);
	outputSpeed->addFuzzySet(quickOut);

	fuzzy->addFuzzyOutput(outputSpeed);

	// Building FuzzyRule
	FuzzyRuleAntecedent* distanceCloseAndSpeedQuick = new FuzzyRuleAntecedent();
	distanceCloseAndSpeedQuick->joinWithAND(close, quick);
	FuzzyRuleAntecedent* temperatureCold = new FuzzyRuleAntecedent();
	temperatureCold->joinSingle(cold);
	FuzzyRuleAntecedent* ifDistanceCloseAndSpeedQuickOrTemperatureCold = new FuzzyRuleAntecedent();
	ifDistanceCloseAndSpeedQuickOrTemperatureCold->joinWithOR(distanceCloseAndSpeedQuick, temperatureCold);

	FuzzyRuleConsequent* thenRisMaximumAndSpeedSlow = new FuzzyRuleConsequent();
	thenRisMaximumAndSpeedSlow->addOutput(maximum);
	thenRisMaximumAndSpeedSlow->addOutput(slowOut);

	FuzzyRule* fuzzyRule1 = new FuzzyRule(1, ifDistanceCloseAndSpeedQuickOrTemperatureCold, thenRisMaximumAndSpeedSlow);
	fuzzy->addFuzzyRule(fuzzyRule1);

	// Building FuzzyRule
	FuzzyRuleAntecedent* distanceSafeAndSpeedNormal = new FuzzyRuleAntecedent();
	distanceSafeAndSpeedNormal->joinWithAND(safe, normal);
	FuzzyRuleAntecedent* ifDistanceSafeAndSpeedNormalOrTemperatureGood = new FuzzyRuleAntecedent();
	ifDistanceSafeAndSpeedNormalOrTemperatureGood->joinWithOR(distanceSafeAndSpeedNormal, good);

	FuzzyRuleConsequent* thenRiskAverageAndSpeedNormal = new FuzzyRuleConsequent();
	thenRiskAverageAndSpeedNormal->addOutput(average);
	thenRiskAverageAndSpeedNormal->addOutput(normalOut);

	FuzzyRule* fuzzyRule2 = new FuzzyRule(2, ifDistanceSafeAndSpeedNormalOrTemperatureGood, thenRiskAverageAndSpeedNormal);
	fuzzy->addFuzzyRule(fuzzyRule2);

	// Building FuzzyRule
	FuzzyRuleAntecedent* distanceDistanteAndSpeedSlow = new FuzzyRuleAntecedent();
	distanceDistanteAndSpeedSlow->joinWithAND(distante, slow);
	FuzzyRuleAntecedent* ifDistanceDistanteAndSpeedSlowOrTemperatureHot = new FuzzyRuleAntecedent();
	ifDistanceDistanteAndSpeedSlowOrTemperatureHot->joinWithOR(distanceDistanteAndSpeedSlow, hot);

	FuzzyRuleConsequent* thenRiskMinimumSpeedQuick = new FuzzyRuleConsequent();
	thenRiskMinimumSpeedQuick->addOutput(minimum);
	thenRiskMinimumSpeedQuick->addOutput(quickOut);

	FuzzyRule* fuzzyRule3 = new FuzzyRule(3, ifDistanceDistanteAndSpeedSlowOrTemperatureHot, thenRiskMinimumSpeedQuick);
	fuzzy->addFuzzyRule(fuzzyRule3);

	fuzzy->setInput(1, 10);
	fuzzy->setInput(2, 30);
	fuzzy->setInput(3, -15);

	fuzzy->fuzzify();

	pwOut << "Distância: " << close->getPertinence() << ", " << safe->getPertinence() << ", " << distante->getPertinence() << '\n';
	pwOut << "Velocidade: " << stoped->getPertinence() << ", " << slow->getPertinence() << ", " << normal->getPertinence() << ", " << quick->getPertinence() << '\n';
	pwOut << "Temperatura: " << cold->getPertinence() << ", " << good->getPertinence() << ", " << hot->getPertinence() << '\n';

	pwOut << "regra1: " << fuzzyRule1->isFired() << ", regra2: " << fuzzyRule2->isFired() << ", regra3: " << fuzzyRule3->isFired() << '\n';

	float output1 = fuzzy->defuzzify(1);
	float output2 = fuzzy->defuzzify(2);

	pwOut << "Saída Risco: " << output1 << ", Saída Velocidade: " << output2 << '\n';

	return 0;
}
Example #5
0
int main(int argc, char *argv[]) {
    Fuzzy* fuzzy = new Fuzzy();

    ///////////////////////////////////////////////////////////////////////////////
    FuzzySet* ErroAltoNegativo = new FuzzySet(-101.0, -101.0, -100.0, -50.0);
    FuzzySet* ErroMedioNegativo = new FuzzySet(-100.0, -50.0, -50.0, 0.0);
    FuzzySet* ErroBaixonegativo = new FuzzySet(-50.0, 0.0, 0.0, 0.0);
    FuzzySet* ErroBaixoPositivo = new FuzzySet(0.0, 0.0, 0.0, 50.0);
    FuzzySet* ErroMedioPositivo = new FuzzySet(0.0, 50.0, 50.0, 100.0);
    FuzzySet* ErroAltoPositivo = new FuzzySet(50.0, 100.0, 101.0, 101.0);

    // Criando o FuzzyInput Erro
    FuzzyInput* Erro = new FuzzyInput(1);
    // Criando os FuzzySet que compoem o FuzzyInput distancia 
    Erro->addFuzzySet(ErroAltoNegativo); // Adicionando o FuzzySet small em Erro
    Erro->addFuzzySet(ErroMedioNegativo); // Adicionando o FuzzySet small em Erro
    Erro->addFuzzySet(ErroBaixonegativo); // Adicionando o FuzzySet small em Erro
    Erro->addFuzzySet(ErroBaixoPositivo); // Adicionando o FuzzySet small em Erro
    Erro->addFuzzySet(ErroMedioPositivo); // Adicionando o FuzzySet small em Erro
    Erro->addFuzzySet(ErroAltoPositivo); // Adicionando o FuzzySet small em Erro

    fuzzy->addFuzzyInput(Erro); // Adicionando o FuzzyInput no objeto Fuzzy  
    ///////////////////////////////////////////////////////////////////////////////

    ///////////////////////////////////////////////////////////////////////////////

    FuzzySet* DerroAltoNegativo = new FuzzySet(-101.0, -101.0, -100.0, -50.0);
    FuzzySet* DerroMedioNegativo = new FuzzySet(-100.0, -50.0, -50.0, 0.0);
    FuzzySet* DerroBaixonegativo = new FuzzySet(-50.0, 0.0, 0.0, 0.0);
    FuzzySet* DerroBaixoPositivo = new FuzzySet(0.0, 0.0, 0.0, 50.0);
    FuzzySet* DerroMedioPositivo = new FuzzySet(0.0, 50.0, 50.0, 100.0);
    FuzzySet* DerroAltoPositivo = new FuzzySet(50.0, 100.0, 101.0, 101.0);

    // Criando o FuzzyInput Derivada do Erro
    FuzzyInput* DErro = new FuzzyInput(2);
    // Criando os FuzzySet que compoem o FuzzyInput distancia 
    DErro->addFuzzySet(DerroAltoNegativo); // Adicionando o FuzzySet small em DErro
    DErro->addFuzzySet(DerroMedioNegativo); // Adicionando o FuzzySet small em DErro
    DErro->addFuzzySet(DerroBaixonegativo); // Adicionando o FuzzySet small em DErro
    DErro->addFuzzySet(DerroBaixoPositivo); // Adicionando o FuzzySet small em DErro
    DErro->addFuzzySet(DerroMedioPositivo); // Adicionando o FuzzySet small em DErro
    DErro->addFuzzySet(DerroAltoPositivo); // Adicionando o FuzzySet small em DErro

    fuzzy->addFuzzyInput(DErro); // Adicionando o FuzzyInput no objeto Fuzzy 
    //////////////////////////////////////////////////////////////////////////////////


    //////////////////////////////////////////////////////////////////////////////////    
    // Criando o FuzzyOutput Velocidade
    FuzzyOutput* Velocidade = new FuzzyOutput(1);

    FuzzySet* OutAltoNegativo = new FuzzySet(-101.0, -101.0, -100.0, -50.0);
    FuzzySet* OutMedioNegativo = new FuzzySet(-100.0, -50.0, -50.0, 0.0);
    FuzzySet* OutBaixonegativo = new FuzzySet(-50.0, 0.0, 0.0, 0.0);
    FuzzySet* OutBaixoPositivo = new FuzzySet(0.0, 0.0, 0.0, 50.0);
    FuzzySet* OutMedioPositivo = new FuzzySet(0.0, 50.0, 50.0, 100.0);
    FuzzySet* OutAltoPositivo = new FuzzySet(50.0, 100.0, 101.0, 101.0);


    // Criando os FuzzySet que compoem o FuzzyOutput velocidade 
    Velocidade->addFuzzySet(OutAltoNegativo);  // Adicionando o FuzzySet slow em velocity
    Velocidade->addFuzzySet(OutMedioNegativo);  // Adicionando o FuzzySet slow em velocity
    Velocidade->addFuzzySet(OutBaixonegativo);  // Adicionando o FuzzySet slow em velocity
    Velocidade->addFuzzySet(OutBaixoPositivo);  // Adicionando o FuzzySet slow em velocity
    Velocidade->addFuzzySet(OutMedioPositivo);  // Adicionando o FuzzySet slow em velocity
    Velocidade->addFuzzySet(OutAltoPositivo);  // Adicionando o FuzzySet slow em velocity

    fuzzy->addFuzzyOutput(Velocidade); // Adicionando o FuzzyOutput no objeto Fuzzy   
    //////////////////////////////////////////////////////////////////////////////////

    FuzzyRuleAntecedent* IfErroAltoNegativoAndDerroAltoNegativo = new FuzzyRuleAntecedent();
    IfErroAltoNegativoAndDerroAltoNegativo->joinWithAND(ErroAltoNegativo,DerroAltoNegativo);

    FuzzyRuleAntecedent* IfErroAltoNegativoAndDerroMedioNegativo = new FuzzyRuleAntecedent();
    IfErroAltoNegativoAndDerroMedioNegativo->joinWithAND(ErroAltoNegativo,DerroMedioNegativo);

    FuzzyRuleAntecedent* IfErroAltoNegativoAndDerroBaixonegativo = new FuzzyRuleAntecedent();
    IfErroAltoNegativoAndDerroBaixonegativo->joinWithAND(ErroAltoNegativo,DerroBaixonegativo);

    FuzzyRuleAntecedent* IfErroAltoNegativoAndDerroBaixoPositivo = new FuzzyRuleAntecedent();
    IfErroAltoNegativoAndDerroBaixoPositivo->joinWithAND(ErroAltoNegativo,DerroBaixoPositivo);

    FuzzyRuleAntecedent* IfErroAltoNegativoAndDerroMedioPositivo = new FuzzyRuleAntecedent(); 
    IfErroAltoNegativoAndDerroMedioPositivo->joinWithAND(ErroAltoNegativo,DerroMedioPositivo);

    FuzzyRuleAntecedent* IfErroAltoNegativoAndDerroAltoPositivo = new FuzzyRuleAntecedent(); 
    IfErroAltoNegativoAndDerroAltoPositivo->joinWithAND(ErroAltoNegativo,DerroAltoPositivo);

    FuzzyRuleAntecedent* IfErroMedioNegativoAndDerroAltoNegativo = new FuzzyRuleAntecedent(); 
    IfErroMedioNegativoAndDerroAltoNegativo->joinWithAND(ErroMedioNegativo,DerroAltoNegativo);

    FuzzyRuleAntecedent* IfErroMedioNegativoAndDerroMedioNegativo = new FuzzyRuleAntecedent(); 
    IfErroMedioNegativoAndDerroMedioNegativo->joinWithAND(ErroMedioNegativo,DerroMedioNegativo);

    FuzzyRuleAntecedent* IfErroMedioNegativoAndDerroBaixonegativo = new FuzzyRuleAntecedent(); 
    IfErroMedioNegativoAndDerroBaixonegativo->joinWithAND(ErroMedioNegativo,DerroBaixonegativo);

    FuzzyRuleAntecedent* IfErroMedioNegativoAndDerroBaixoPositivo = new FuzzyRuleAntecedent(); 
    IfErroMedioNegativoAndDerroBaixoPositivo->joinWithAND(ErroMedioNegativo,DerroBaixoPositivo);

    FuzzyRuleAntecedent* IfErroMedioNegativoAndDerroMedioPositivo = new FuzzyRuleAntecedent(); 
    IfErroMedioNegativoAndDerroMedioPositivo->joinWithAND(ErroMedioNegativo,DerroMedioPositivo);

    FuzzyRuleAntecedent* IfErroMedioNegativoAndDerroAltoPositivo = new FuzzyRuleAntecedent(); 
    IfErroMedioNegativoAndDerroAltoPositivo->joinWithAND(ErroMedioNegativo,DerroAltoPositivo);

    FuzzyRuleAntecedent* IfErroBaixonegativoAndDerroAltoNegativo = new FuzzyRuleAntecedent(); 
    IfErroBaixonegativoAndDerroAltoNegativo->joinWithAND(ErroBaixonegativo,DerroAltoNegativo);

    FuzzyRuleAntecedent* IfErroBaixonegativoAndDerroMedioNegativo = new FuzzyRuleAntecedent();
    IfErroBaixonegativoAndDerroMedioNegativo->joinWithAND(ErroBaixonegativo,DerroMedioNegativo);

    FuzzyRuleAntecedent* IfErroBaixonegativoAndDerroBaixonegativo = new FuzzyRuleAntecedent(); 
    IfErroBaixonegativoAndDerroBaixonegativo->joinWithAND(ErroBaixonegativo,DerroBaixonegativo);

    FuzzyRuleAntecedent* IfErroBaixonegativoAndDerroBaixoPositivo = new FuzzyRuleAntecedent(); 
    IfErroBaixonegativoAndDerroBaixoPositivo->joinWithAND(ErroBaixonegativo,DerroBaixoPositivo);

    FuzzyRuleAntecedent* IfErroBaixonegativoAndDerroMedioPositivo = new FuzzyRuleAntecedent(); 
    IfErroBaixonegativoAndDerroMedioPositivo->joinWithAND(ErroBaixonegativo,DerroMedioPositivo);

    FuzzyRuleAntecedent* IfErroBaixonegativoAndDerroAltoPositivo = new FuzzyRuleAntecedent(); 
    IfErroBaixonegativoAndDerroAltoPositivo->joinWithAND(ErroBaixonegativo,DerroAltoPositivo);

    FuzzyRuleAntecedent* IfErroBaixoPositivoAndDerroAltoNegativo = new FuzzyRuleAntecedent(); 
    IfErroBaixoPositivoAndDerroAltoNegativo->joinWithAND(ErroBaixoPositivo,DerroAltoNegativo);

    FuzzyRuleAntecedent* IfErroBaixoPositivoAndDerroMedioNegativo = new FuzzyRuleAntecedent(); 
    IfErroBaixoPositivoAndDerroMedioNegativo->joinWithAND(ErroBaixoPositivo,DerroMedioNegativo);

    FuzzyRuleAntecedent* IfErroBaixoPositivoAndDerroBaixonegativo = new FuzzyRuleAntecedent(); 
    IfErroBaixoPositivoAndDerroBaixonegativo->joinWithAND(ErroBaixoPositivo,DerroBaixonegativo);

    FuzzyRuleAntecedent* IfErroBaixoPositivoAndDerroBaixoPositivo = new FuzzyRuleAntecedent(); 
    IfErroBaixoPositivoAndDerroBaixoPositivo->joinWithAND(ErroBaixoPositivo,DerroBaixoPositivo);

    FuzzyRuleAntecedent* IfErroBaixoPositivoAndDerroMedioPositivo = new FuzzyRuleAntecedent();
    IfErroBaixoPositivoAndDerroMedioPositivo->joinWithAND(ErroBaixoPositivo,DerroMedioPositivo);

    FuzzyRuleAntecedent* IfErroBaixoPositivoAndDerroAltoPositivo = new FuzzyRuleAntecedent(); 
    IfErroBaixoPositivoAndDerroAltoPositivo->joinWithAND(ErroBaixoPositivo,DerroAltoPositivo);

    FuzzyRuleAntecedent* IfErroMedioPositivoAndDerroAltoNegativo = new FuzzyRuleAntecedent(); 
    IfErroMedioPositivoAndDerroAltoNegativo->joinWithAND(ErroMedioPositivo,DerroAltoNegativo);

    FuzzyRuleAntecedent* IfErroMedioPositivoAndDerroMedioNegativo = new FuzzyRuleAntecedent(); 
    IfErroMedioPositivoAndDerroMedioNegativo->joinWithAND(ErroMedioPositivo,DerroMedioNegativo);

    FuzzyRuleAntecedent* IfErroMedioPositivoAndDerroBaixonegativo = new FuzzyRuleAntecedent();
    IfErroMedioPositivoAndDerroBaixonegativo->joinWithAND(ErroMedioPositivo,DerroBaixonegativo);

    FuzzyRuleAntecedent* IfErroMedioPositivoAndDerroBaixoPositivo = new FuzzyRuleAntecedent(); 
    IfErroMedioPositivoAndDerroBaixoPositivo->joinWithAND(ErroMedioPositivo,DerroBaixoPositivo);

    FuzzyRuleAntecedent* IfErroMedioPositivoAndDerroMedioPositivo = new FuzzyRuleAntecedent();
    IfErroMedioPositivoAndDerroMedioPositivo->joinWithAND(ErroMedioPositivo,DerroMedioPositivo);

    FuzzyRuleAntecedent* IfErroMedioPositivoAndDerroAltoPositivo = new FuzzyRuleAntecedent(); 
    IfErroMedioPositivoAndDerroAltoPositivo->joinWithAND(ErroMedioPositivo,DerroAltoPositivo);

    FuzzyRuleAntecedent* IfErroAltoPositivoAndDerroAltoNegativo = new FuzzyRuleAntecedent(); 
    IfErroAltoPositivoAndDerroAltoNegativo->joinWithAND(ErroAltoPositivo,DerroAltoNegativo);

    FuzzyRuleAntecedent* IfErroAltoPositivoAndDerroMedioNegativo = new FuzzyRuleAntecedent();
    IfErroAltoPositivoAndDerroMedioNegativo->joinWithAND(ErroAltoPositivo,DerroMedioNegativo);

    FuzzyRuleAntecedent* IfErroAltoPositivoAndDerroBaixonegativo = new FuzzyRuleAntecedent(); 
    IfErroAltoPositivoAndDerroBaixonegativo->joinWithAND(ErroAltoPositivo,DerroBaixonegativo);

    FuzzyRuleAntecedent* IfErroAltoPositivoAndDerroBaixoPositivo = new FuzzyRuleAntecedent();
    IfErroAltoPositivoAndDerroBaixoPositivo->joinWithAND(ErroAltoPositivo,DerroBaixoPositivo);

    FuzzyRuleAntecedent* IfErroAltoPositivoAndDerroMedioPositivo = new FuzzyRuleAntecedent();
    IfErroAltoPositivoAndDerroMedioPositivo->joinWithAND(ErroAltoPositivo,DerroMedioPositivo);

    FuzzyRuleAntecedent* IfErroAltoPositivoAndDerroAltoPositivo = new FuzzyRuleAntecedent(); 
    IfErroAltoPositivoAndDerroAltoPositivo->joinWithAND(ErroAltoPositivo,DerroAltoPositivo);


    FuzzyRuleConsequent* ThenOutAltoPositivo = new FuzzyRuleConsequent(); 
    ThenOutAltoPositivo->addOutput(OutAltoPositivo);

    FuzzyRuleConsequent* ThenOutMedioPositivo = new FuzzyRuleConsequent();
    ThenOutMedioPositivo->addOutput(OutMedioPositivo);

    FuzzyRuleConsequent* ThenOutBaixoPositivo = new FuzzyRuleConsequent();
    ThenOutBaixoPositivo->addOutput(OutBaixoPositivo);

    FuzzyRuleConsequent* ThenOutBaixonegativo = new FuzzyRuleConsequent();
    ThenOutBaixonegativo->addOutput(OutBaixonegativo);

    FuzzyRuleConsequent* ThenOutMedioNegativo = new FuzzyRuleConsequent();
    ThenOutMedioNegativo->addOutput(OutMedioNegativo);

    FuzzyRuleConsequent* ThenOutAltoNegativo = new FuzzyRuleConsequent();
    ThenOutAltoNegativo->addOutput(OutAltoNegativo);


    FuzzyRule* fuzzyRule01 = new FuzzyRule(1, IfErroAltoNegativoAndDerroAltoNegativo, ThenOutAltoPositivo);
    fuzzy->addFuzzyRule(fuzzyRule01);

    FuzzyRule* fuzzyRule02 = new FuzzyRule(2, IfErroAltoNegativoAndDerroMedioNegativo, ThenOutAltoPositivo);
    fuzzy->addFuzzyRule(fuzzyRule02);

    FuzzyRule* fuzzyRule03 = new FuzzyRule(3, IfErroAltoNegativoAndDerroBaixonegativo, ThenOutAltoPositivo);
    fuzzy->addFuzzyRule(fuzzyRule03);

    FuzzyRule* fuzzyRule04 = new FuzzyRule(4, IfErroAltoNegativoAndDerroBaixoPositivo, ThenOutMedioPositivo);
    fuzzy->addFuzzyRule(fuzzyRule04);

    FuzzyRule* fuzzyRule05 = new FuzzyRule(5, IfErroAltoNegativoAndDerroMedioPositivo, ThenOutMedioPositivo);
    fuzzy->addFuzzyRule(fuzzyRule05);

    FuzzyRule* fuzzyRule06 = new FuzzyRule(6, IfErroAltoNegativoAndDerroAltoPositivo, ThenOutBaixoPositivo);
    fuzzy->addFuzzyRule(fuzzyRule06);

    FuzzyRule* fuzzyRule07 = new FuzzyRule(7, IfErroMedioNegativoAndDerroAltoNegativo, ThenOutAltoPositivo); 
    fuzzy->addFuzzyRule(fuzzyRule07);

    FuzzyRule* fuzzyRule08 = new FuzzyRule(8, IfErroMedioNegativoAndDerroMedioNegativo, ThenOutAltoPositivo); //++++
    fuzzy->addFuzzyRule(fuzzyRule08);

    FuzzyRule* fuzzyRule09 = new FuzzyRule(9, IfErroMedioNegativoAndDerroBaixonegativo, ThenOutMedioPositivo); //++++
    fuzzy->addFuzzyRule(fuzzyRule09);

    FuzzyRule* fuzzyRule10 = new FuzzyRule(10, IfErroMedioNegativoAndDerroBaixoPositivo, ThenOutBaixoPositivo);
    fuzzy->addFuzzyRule(fuzzyRule10);

    FuzzyRule* fuzzyRule11 = new FuzzyRule(11, IfErroMedioNegativoAndDerroMedioPositivo, ThenOutBaixoPositivo);
    fuzzy->addFuzzyRule(fuzzyRule11);

    FuzzyRule* fuzzyRule12 = new FuzzyRule(12, IfErroMedioNegativoAndDerroAltoPositivo, ThenOutBaixoPositivo);
    fuzzy->addFuzzyRule(fuzzyRule12);

    FuzzyRule* fuzzyRule13 = new FuzzyRule(13, IfErroBaixonegativoAndDerroAltoNegativo, ThenOutMedioPositivo);
    fuzzy->addFuzzyRule(fuzzyRule13);

    FuzzyRule* fuzzyRule14 = new FuzzyRule(14, IfErroBaixonegativoAndDerroMedioNegativo, ThenOutMedioPositivo); //++++
    fuzzy->addFuzzyRule(fuzzyRule14);

    FuzzyRule* fuzzyRule15 = new FuzzyRule(15, IfErroBaixonegativoAndDerroBaixonegativo, ThenOutBaixoPositivo); //++++
    fuzzy->addFuzzyRule(fuzzyRule15);

    FuzzyRule* fuzzyRule16 = new FuzzyRule(16, IfErroBaixonegativoAndDerroBaixoPositivo, ThenOutBaixoPositivo);
    fuzzy->addFuzzyRule(fuzzyRule16);

    FuzzyRule* fuzzyRule17 = new FuzzyRule(17, IfErroBaixonegativoAndDerroMedioPositivo, ThenOutBaixonegativo);
    fuzzy->addFuzzyRule(fuzzyRule17);

    FuzzyRule* fuzzyRule18 = new FuzzyRule(18, IfErroBaixonegativoAndDerroAltoPositivo, ThenOutBaixonegativo);
    fuzzy->addFuzzyRule(fuzzyRule18);

    FuzzyRule* fuzzyRule19 = new FuzzyRule(19, IfErroBaixoPositivoAndDerroAltoNegativo, ThenOutBaixoPositivo);
    fuzzy->addFuzzyRule(fuzzyRule19);

    FuzzyRule* fuzzyRule20 = new FuzzyRule(20, IfErroBaixoPositivoAndDerroMedioNegativo, ThenOutBaixoPositivo);
    fuzzy->addFuzzyRule(fuzzyRule20);

    FuzzyRule* fuzzyRule21 = new FuzzyRule(21, IfErroBaixoPositivoAndDerroBaixonegativo, ThenOutBaixonegativo);
    fuzzy->addFuzzyRule(fuzzyRule21);

    FuzzyRule* fuzzyRule22 = new FuzzyRule(22, IfErroBaixoPositivoAndDerroBaixoPositivo, ThenOutBaixonegativo); //----
    fuzzy->addFuzzyRule(fuzzyRule22);

    FuzzyRule* fuzzyRule23 = new FuzzyRule(23, IfErroBaixoPositivoAndDerroMedioPositivo, ThenOutMedioNegativo); //----
    fuzzy->addFuzzyRule(fuzzyRule23);

    FuzzyRule* fuzzyRule24 = new FuzzyRule(24, IfErroBaixoPositivoAndDerroAltoPositivo, ThenOutMedioNegativo);
    fuzzy->addFuzzyRule(fuzzyRule24);

    FuzzyRule* fuzzyRule25 = new FuzzyRule(25, IfErroMedioPositivoAndDerroAltoNegativo, ThenOutBaixonegativo);
    fuzzy->addFuzzyRule(fuzzyRule25);

    FuzzyRule* fuzzyRule26 = new FuzzyRule(26, IfErroMedioPositivoAndDerroMedioNegativo, ThenOutBaixonegativo);
    fuzzy->addFuzzyRule(fuzzyRule26);

    FuzzyRule* fuzzyRule27 = new FuzzyRule(27, IfErroMedioPositivoAndDerroBaixonegativo, ThenOutBaixonegativo);
    fuzzy->addFuzzyRule(fuzzyRule27);

    FuzzyRule* fuzzyRule28 = new FuzzyRule(28, IfErroMedioPositivoAndDerroBaixoPositivo, ThenOutMedioNegativo); //----
    fuzzy->addFuzzyRule(fuzzyRule28);

    FuzzyRule* fuzzyRule29 = new FuzzyRule(29, IfErroMedioPositivoAndDerroMedioPositivo, ThenOutAltoNegativo); //----
    fuzzy->addFuzzyRule(fuzzyRule29);

    FuzzyRule* fuzzyRule30 = new FuzzyRule(30, IfErroMedioPositivoAndDerroAltoPositivo, ThenOutAltoNegativo);
    fuzzy->addFuzzyRule(fuzzyRule30);

    FuzzyRule* fuzzyRule31 = new FuzzyRule(31, IfErroAltoPositivoAndDerroAltoNegativo, ThenOutBaixonegativo);
    fuzzy->addFuzzyRule(fuzzyRule31);

    FuzzyRule* fuzzyRule32 = new FuzzyRule(32, IfErroAltoPositivoAndDerroMedioNegativo, ThenOutMedioNegativo);
    fuzzy->addFuzzyRule(fuzzyRule32);

    FuzzyRule* fuzzyRule33 = new FuzzyRule(33, IfErroAltoPositivoAndDerroBaixonegativo, ThenOutMedioNegativo);
    fuzzy->addFuzzyRule(fuzzyRule33);

    FuzzyRule* fuzzyRule34 = new FuzzyRule(34, IfErroAltoPositivoAndDerroBaixoPositivo, ThenOutAltoNegativo); 
    fuzzy->addFuzzyRule(fuzzyRule34);

    FuzzyRule* fuzzyRule35 = new FuzzyRule(35, IfErroAltoPositivoAndDerroMedioPositivo, ThenOutAltoNegativo); 
    fuzzy->addFuzzyRule(fuzzyRule35);

    FuzzyRule* fuzzyRule36 = new FuzzyRule(36, IfErroAltoPositivoAndDerroAltoPositivo, ThenOutAltoNegativo); 
    fuzzy->addFuzzyRule(fuzzyRule36);

    fuzzy->setInput(1, 0);
    fuzzy->setInput(2, 0);
    fuzzy->fuzzify();
    
    float outputPitch = fuzzy->defuzzify(1);
    
    std::cout << "Erro: " << ErroAltoNegativo->getPertinence() << ", " << ErroMedioNegativo->getPertinence() << ", " << ErroBaixonegativo->getPertinence() << ", " << ErroBaixoPositivo->getPertinence() << ", " << ErroMedioPositivo->getPertinence() << ", " << ErroAltoPositivo->getPertinence() << std::endl;
    std::cout << "DErro: " << DerroAltoNegativo->getPertinence() << ", " << DerroMedioNegativo->getPertinence() << ", " << DerroBaixonegativo->getPertinence() << ", " << DerroBaixoPositivo->getPertinence() << ", " << DerroMedioPositivo->getPertinence() << ", " << DerroAltoPositivo->getPertinence() << std::endl;
    std::cout << "velocidade: " << OutAltoNegativo->getPertinence() << ", " << OutMedioNegativo->getPertinence() << ", " << OutBaixonegativo->getPertinence() << ", " << OutBaixoPositivo->getPertinence() << ", " << OutMedioPositivo->getPertinence() << ", " << OutAltoPositivo->getPertinence() << std::endl;

    std::cout << "Output: " << outputPitch << std::endl;

    std::cout << "regras 1-15 : " << fuzzy->isFiredRule(1) << ", " << fuzzy->isFiredRule(2) << ", " << fuzzy->isFiredRule(3) << ", " << fuzzy->isFiredRule(4) << ", " << fuzzy->isFiredRule(5) << ", " << fuzzy->isFiredRule(6) << ", " << fuzzy->isFiredRule(7) << ", " << fuzzy->isFiredRule(8) << ", " << fuzzy->isFiredRule(9) << ", " << fuzzy->isFiredRule(10) << ", " << fuzzy->isFiredRule(11) << ", " << fuzzy->isFiredRule(12) << ", " << fuzzy->isFiredRule(13) << ", " << fuzzy->isFiredRule(14) << ", " << fuzzy->isFiredRule(15) << std::endl;
    std::cout << "regras 16-30 : " << fuzzy->isFiredRule(16) << ", " << fuzzy->isFiredRule(17) << ", " << fuzzy->isFiredRule(18) << ", " << fuzzy->isFiredRule(19) << ", " << fuzzy->isFiredRule(20) << ", " << fuzzy->isFiredRule(21) << ", " << fuzzy->isFiredRule(22) << ", " << fuzzy->isFiredRule(23) << ", " << fuzzy->isFiredRule(24) << ", " << fuzzy->isFiredRule(25) << ", " << fuzzy->isFiredRule(26) << ", " << fuzzy->isFiredRule(27) << ", " << fuzzy->isFiredRule(28) << ", " << fuzzy->isFiredRule(29) << ", " << fuzzy->isFiredRule(30) << std::endl;
    std::cout << "regras 31-36 : " << fuzzy->isFiredRule(31) << ", " << fuzzy->isFiredRule(32) << ", " << fuzzy->isFiredRule(33) << ", " << fuzzy->isFiredRule(34) << ", " << fuzzy->isFiredRule(35) << ", " << fuzzy->isFiredRule(36) << std::endl;

    std::cout << "\n" << std::endl;

    fuzzy->setInput(1, -100);
    fuzzy->setInput(2, -100);
    fuzzy->fuzzify();
    
    outputPitch = fuzzy->defuzzify(1);
    
    std::cout << "Erro: " << ErroAltoNegativo->getPertinence() << ", " << ErroMedioNegativo->getPertinence() << ", " << ErroBaixonegativo->getPertinence() << ", " << ErroBaixoPositivo->getPertinence() << ", " << ErroMedioPositivo->getPertinence() << ", " << ErroAltoPositivo->getPertinence() << std::endl;
    std::cout << "DErro: " << DerroAltoNegativo->getPertinence() << ", " << DerroMedioNegativo->getPertinence() << ", " << DerroBaixonegativo->getPertinence() << ", " << DerroBaixoPositivo->getPertinence() << ", " << DerroMedioPositivo->getPertinence() << ", " << DerroAltoPositivo->getPertinence() << std::endl;
    std::cout << "velocidade: " << OutAltoNegativo->getPertinence() << ", " << OutMedioNegativo->getPertinence() << ", " << OutBaixonegativo->getPertinence() << ", " << OutBaixoPositivo->getPertinence() << ", " << OutMedioPositivo->getPertinence() << ", " << OutAltoPositivo->getPertinence() << std::endl;

    std::cout << "Output: " << outputPitch << std::endl;

    std::cout << "regras 1-15 : " << fuzzy->isFiredRule(1) << ", " << fuzzy->isFiredRule(2) << ", " << fuzzy->isFiredRule(3) << ", " << fuzzy->isFiredRule(4) << ", " << fuzzy->isFiredRule(5) << ", " << fuzzy->isFiredRule(6) << ", " << fuzzy->isFiredRule(7) << ", " << fuzzy->isFiredRule(8) << ", " << fuzzy->isFiredRule(9) << ", " << fuzzy->isFiredRule(10) << ", " << fuzzy->isFiredRule(11) << ", " << fuzzy->isFiredRule(12) << ", " << fuzzy->isFiredRule(13) << ", " << fuzzy->isFiredRule(14) << ", " << fuzzy->isFiredRule(15) << std::endl;
    std::cout << "regras 16-30 : " << fuzzy->isFiredRule(16) << ", " << fuzzy->isFiredRule(17) << ", " << fuzzy->isFiredRule(18) << ", " << fuzzy->isFiredRule(19) << ", " << fuzzy->isFiredRule(20) << ", " << fuzzy->isFiredRule(21) << ", " << fuzzy->isFiredRule(22) << ", " << fuzzy->isFiredRule(23) << ", " << fuzzy->isFiredRule(24) << ", " << fuzzy->isFiredRule(25) << ", " << fuzzy->isFiredRule(26) << ", " << fuzzy->isFiredRule(27) << ", " << fuzzy->isFiredRule(28) << ", " << fuzzy->isFiredRule(29) << ", " << fuzzy->isFiredRule(30) << std::endl;
    std::cout << "regras 31-36 : " << fuzzy->isFiredRule(31) << ", " << fuzzy->isFiredRule(32) << ", " << fuzzy->isFiredRule(33) << ", " << fuzzy->isFiredRule(34) << ", " << fuzzy->isFiredRule(35) << ", " << fuzzy->isFiredRule(36) << std::endl;

    return 0;
}
Example #6
0
int main(int argc, char *argv[]) {
	// Instanciando um objeto da biblioteca
	Fuzzy* fuzzy = new Fuzzy();

	// Criando o FuzzyInput distancia
	FuzzyInput* distance = new FuzzyInput(1);
	// Criando os FuzzySet que compoem o FuzzyInput distancia 
	FuzzySet* small = new FuzzySet(0, 20, 20, 40); // Distancia pequena
	distance->addFuzzySet(small); // Adicionando o FuzzySet small em distance
	FuzzySet* safe = new FuzzySet(30, 50, 50, 70); // Distancia segura
	distance->addFuzzySet(safe); // Adicionando o FuzzySet safe em distance
	FuzzySet* big = new FuzzySet(60, 80, 80, 80); // Distancia grande
	distance->addFuzzySet(big); // Adicionando o FuzzySet big em distance

	fuzzy->addFuzzyInput(distance); // Adicionando o FuzzyInput no objeto Fuzzy

	// Criando o FuzzyOutput velocidade
	FuzzyOutput* velocity = new FuzzyOutput(1);
	// Criando os FuzzySet que compoem o FuzzyOutput velocidade 
	FuzzySet* slow = new FuzzySet(0, 10, 10, 20); // Velocidade lenta
	velocity->addFuzzySet(slow); // Adicionando o FuzzySet slow em velocity
	FuzzySet* average = new FuzzySet(10, 20, 30, 40); // Velocidade normal
	velocity->addFuzzySet(average); // Adicionando o FuzzySet average em velocity
	FuzzySet* fast = new FuzzySet(30, 40, 40, 50); // Velocidade alta
	velocity->addFuzzySet(fast); // Adicionando o FuzzySet fast em velocity

	fuzzy->addFuzzyOutput(velocity); // Adicionando o FuzzyOutput no objeto Fuzzy

	//-------------------- Montando as regras Fuzzy
	// FuzzyRule "SE distancia = pequena ENTAO velocidade = lenta"
	FuzzyRuleAntecedent* ifDistanceSmall = new FuzzyRuleAntecedent(); // Instanciando um Antecedente para a expresso
	ifDistanceSmall->joinSingle(small); // Adicionando o FuzzySet correspondente ao objeto Antecedente
	FuzzyRuleConsequent* thenVelocitySlow = new FuzzyRuleConsequent(); // Instancinado um Consequente para a expressao
	thenVelocitySlow->addOutput(slow);// Adicionando o FuzzySet correspondente ao objeto Consequente
	// Instanciando um objeto FuzzyRule
	FuzzyRule* fuzzyRule01 = new FuzzyRule(1, ifDistanceSmall, thenVelocitySlow); // Passando o Antecedente e o Consequente da expressao
	fuzzy->addFuzzyRule(fuzzyRule01); // Adicionando o FuzzyRule ao objeto Fuzzy

	// FuzzyRule "SE distancia = segura ENTAO velocidade = normal"
	FuzzyRuleAntecedent* ifDistanceSafe = new FuzzyRuleAntecedent(); // Instanciando um Antecedente para a expresso
	ifDistanceSafe->joinSingle(safe); // Adicionando o FuzzySet correspondente ao objeto Antecedente
	FuzzyRuleConsequent* thenVelocityAverage = new FuzzyRuleConsequent(); // Instancinado um Consequente para a expressao
	thenVelocityAverage->addOutput(average);// Adicionando o FuzzySet correspondente ao objeto Consequente
	// Instanciando um objeto FuzzyRule
	FuzzyRule* fuzzyRule02 = new FuzzyRule(2, ifDistanceSafe, thenVelocityAverage); // Passando o Antecedente e o Consequente da expressao
	fuzzy->addFuzzyRule(fuzzyRule02); // Adicionando o FuzzyRule ao objeto Fuzzy

	// FuzzyRule "SE distancia = grande ENTAO velocidade = alta"
	FuzzyRuleAntecedent* ifDistanceBig = new FuzzyRuleAntecedent(); // Instanciando um Antecedente para a expresso
	ifDistanceBig->joinSingle(big); // Adicionando o FuzzySet correspondente ao objeto Antecedente
	FuzzyRuleConsequent* thenVelocityFast = new FuzzyRuleConsequent(); // Instancinado um Consequente para a expressao
	thenVelocityFast->addOutput(fast);// Adicionando o FuzzySet correspondente ao objeto Consequente
	// Instanciando um objeto FuzzyRule
	FuzzyRule* fuzzyRule03 = new FuzzyRule(3, ifDistanceBig, thenVelocityFast); // Passando o Antecedente e o Consequente da expressao
	fuzzy->addFuzzyRule(fuzzyRule03); // Adicionando o FuzzyRule ao objeto Fuzzy

	for(int dist = 0; dist < 100; dist++){
		fuzzy->setInput(1, dist);

		fuzzy->fuzzify();

		float output = fuzzy->defuzzify(1);
		cout << "Entrada: " << dist << ", Saida: " << output << endl;
	}
	return 0;
}
/*
 *  Class written by taking the online eFLL library example as model.
 *  The values of the fuzzy sets were determined by doing some physical
 *  experiments.
 */
FuzzyController::FuzzyController()
{
  _fuzzy = new Fuzzy();

  // Input RPM
  FuzzySet*         low_RPM = new FuzzySet(                RPM_MIN,                 RPM_MIN, RPM_ZERO - 2 * RPM_STEP, RPM_ZERO -     RPM_STEP);
  FuzzySet*  little_low_RPM = new FuzzySet(RPM_ZERO - 2 * RPM_STEP, RPM_ZERO -     RPM_STEP, RPM_ZERO -     RPM_STEP,                RPM_ZERO);
  FuzzySet*       right_RPM = new FuzzySet(RPM_ZERO -     RPM_STEP,                RPM_ZERO,                RPM_ZERO, RPM_ZERO +     RPM_STEP);
  FuzzySet* little_high_RPM = new FuzzySet(               RPM_ZERO, RPM_ZERO +     RPM_STEP, RPM_ZERO +     RPM_STEP, RPM_ZERO + 2 * RPM_STEP);
  FuzzySet*        high_RPM = new FuzzySet(RPM_ZERO +     RPM_STEP, RPM_ZERO + 2 * RPM_STEP,                 RPM_MAX,                 RPM_MAX);
  
  FuzzyInput* RPM = new FuzzyInput(1);
  RPM->addFuzzySet(        low_RPM);
  RPM->addFuzzySet( little_low_RPM);
  RPM->addFuzzySet(      right_RPM);
  RPM->addFuzzySet(little_high_RPM);
  RPM->addFuzzySet(       high_RPM);
  
  _fuzzy->addFuzzyInput(RPM);

  // Output PWM
  FuzzySet*         low_PWM = new FuzzySet(                PWM_MIN,                 PWM_MIN, PWM_ZERO - 2 * PWM_STEP, PWM_ZERO -     PWM_STEP);
  FuzzySet*  little_low_PWM = new FuzzySet(PWM_ZERO - 2 * PWM_STEP, PWM_ZERO -     PWM_STEP, PWM_ZERO -     PWM_STEP,                PWM_ZERO);
  FuzzySet*       right_PWM = new FuzzySet(PWM_ZERO -     PWM_STEP,                PWM_ZERO,                PWM_ZERO, PWM_ZERO +     PWM_STEP);
  FuzzySet* little_high_PWM = new FuzzySet(               PWM_ZERO, PWM_ZERO +     PWM_STEP, PWM_ZERO +     PWM_STEP, PWM_ZERO + 2 * PWM_STEP);
  FuzzySet*        high_PWM = new FuzzySet(PWM_ZERO +     PWM_STEP, PWM_ZERO + 2 * PWM_STEP,                 PWM_MAX,                 PWM_MAX);
  
  FuzzyOutput* PWM = new FuzzyOutput(1);
  PWM->addFuzzySet(       high_PWM);
  PWM->addFuzzySet(little_high_PWM);
  PWM->addFuzzySet(      right_PWM);
  PWM->addFuzzySet( little_low_PWM);
  PWM->addFuzzySet(        low_PWM);
  
  _fuzzy->addFuzzyOutput(PWM);

  // Build the rules
  // 1. If         low_RPM then        high_PWM
  // 2. If  little_low_RPM then little_high_PWM
  // 3. If       right_RPM then       right_PWM
  // 4. If little_high_RPM then  little_low_PWM
  // 5. It        high_RPM then         low_PWM

  // Rule no. 1
  FuzzyRuleAntecedent* ifRPMLow = new FuzzyRuleAntecedent();
  ifRPMLow->joinSingle(low_RPM);
  
  FuzzyRuleConsequent* thenPWMHigh = new FuzzyRuleConsequent();
  thenPWMHigh->addOutput(high_PWM);
  
  FuzzyRule* fuzzyRule1 = new FuzzyRule(1, ifRPMLow, thenPWMHigh);  
  _fuzzy->addFuzzyRule(fuzzyRule1);


  // Rule no. 2
  FuzzyRuleAntecedent* ifRPMLittleLow = new FuzzyRuleAntecedent();
  ifRPMLittleLow->joinSingle(little_low_RPM);
  
  FuzzyRuleConsequent* thenPWMLittleHigh = new FuzzyRuleConsequent();
  thenPWMLittleHigh->addOutput(little_high_PWM);
  
  FuzzyRule* fuzzyRule2 = new FuzzyRule(2, ifRPMLittleLow, thenPWMLittleHigh);  
  _fuzzy->addFuzzyRule(fuzzyRule2);


  // Rule no. 3
  FuzzyRuleAntecedent* ifRPMRight = new FuzzyRuleAntecedent();
  ifRPMRight->joinSingle(right_RPM);
  
  FuzzyRuleConsequent* thenPWMRight = new FuzzyRuleConsequent();
  thenPWMRight->addOutput(right_PWM);
  
  FuzzyRule* fuzzyRule3 = new FuzzyRule(3, ifRPMRight, thenPWMRight);  
  _fuzzy->addFuzzyRule(fuzzyRule3);


  // Rule no. 4
  FuzzyRuleAntecedent* ifRPMLittleHigh = new FuzzyRuleAntecedent();
  ifRPMLittleHigh->joinSingle(little_high_RPM);
  
  FuzzyRuleConsequent* thenPWMLittleLow = new FuzzyRuleConsequent();
  thenPWMLittleLow->addOutput(little_low_PWM);
  
  FuzzyRule* fuzzyRule4 = new FuzzyRule(4, ifRPMLittleHigh, thenPWMLittleLow);  
  _fuzzy->addFuzzyRule(fuzzyRule4);


  // Rule no. 5
  FuzzyRuleAntecedent* ifRPMHigh = new FuzzyRuleAntecedent();
  ifRPMHigh->joinSingle(high_RPM);
  
  FuzzyRuleConsequent* thenPWMLow = new FuzzyRuleConsequent();
  thenPWMLow->addOutput(low_PWM);
  
  FuzzyRule* fuzzyRule5 = new FuzzyRule(5, ifRPMHigh, thenPWMLow);  
  _fuzzy->addFuzzyRule(fuzzyRule5);
}
Example #8
0
int main(int argc, char *argv[])
{
    // Set a seed to rand
    srand((unsigned)time(0));

    // Instantiating a Fuzzy object
    Fuzzy *fuzzy = new Fuzzy();

    // Instantiating a FuzzyInput object
    FuzzyInput *distance = new FuzzyInput(1);
    // Instantiating a FuzzySet object
    FuzzySet *small = new FuzzySet(0, 20, 20, 40);
    // Including the FuzzySet into FuzzyInput
    distance->addFuzzySet(small);
    // Instantiating a FuzzySet object
    FuzzySet *safe = new FuzzySet(30, 50, 50, 70);
    // Including the FuzzySet into FuzzyInput
    distance->addFuzzySet(safe);
    // Instantiating a FuzzySet object
    FuzzySet *big = new FuzzySet(60, 80, 80, 80);
    // Including the FuzzySet into FuzzyInput
    distance->addFuzzySet(big);
    // Including the FuzzyInput into Fuzzy
    fuzzy->addFuzzyInput(distance);

    // Instantiating a FuzzyOutput objects
    FuzzyOutput *speed = new FuzzyOutput(1);
    // Instantiating a FuzzySet object
    FuzzySet *slow = new FuzzySet(0, 10, 10, 20);
    // Including the FuzzySet into FuzzyOutput
    speed->addFuzzySet(slow);
    // Instantiating a FuzzySet object
    FuzzySet *average = new FuzzySet(10, 20, 30, 40);
    // Including the FuzzySet into FuzzyOutput
    speed->addFuzzySet(average);
    // Instantiating a FuzzySet object
    FuzzySet *fast = new FuzzySet(30, 40, 40, 50);
    // Including the FuzzySet into FuzzyOutput
    speed->addFuzzySet(fast);
    // Including the FuzzyOutput into Fuzzy
    fuzzy->addFuzzyOutput(speed);

    // Building FuzzyRule "IF distance = small THEN speed = slow"
    // Instantiating a FuzzyRuleAntecedent objects
    FuzzyRuleAntecedent *ifDistanceSmall = new FuzzyRuleAntecedent();
    // Creating a FuzzyRuleAntecedent with just a single FuzzySet
    ifDistanceSmall->joinSingle(small);
    // Instantiating a FuzzyRuleConsequent objects
    FuzzyRuleConsequent *thenSpeedSlow = new FuzzyRuleConsequent();
    // Including a FuzzySet to this FuzzyRuleConsequent
    thenSpeedSlow->addOutput(slow);
    // Instantiating a FuzzyRule objects
    FuzzyRule *fuzzyRule01 = new FuzzyRule(1, ifDistanceSmall, thenSpeedSlow);
    // Including the FuzzyRule into Fuzzy
    fuzzy->addFuzzyRule(fuzzyRule01);

    // Building FuzzyRule "IF distance = safe THEN speed = average"
    // Instantiating a FuzzyRuleAntecedent objects
    FuzzyRuleAntecedent *ifDistanceSafe = new FuzzyRuleAntecedent();
    // Creating a FuzzyRuleAntecedent with just a single FuzzySet
    ifDistanceSafe->joinSingle(safe);
    // Instantiating a FuzzyRuleConsequent objects
    FuzzyRuleConsequent *thenSpeedAverage = new FuzzyRuleConsequent();
    // Including a FuzzySet to this FuzzyRuleConsequent
    thenSpeedAverage->addOutput(average);
    // Instantiating a FuzzyRule objects
    FuzzyRule *fuzzyRule02 = new FuzzyRule(2, ifDistanceSafe, thenSpeedAverage);
    // Including the FuzzyRule into Fuzzy
    fuzzy->addFuzzyRule(fuzzyRule02);

    // Building FuzzyRule "IF distance = big THEN speed = high"
    // Instantiating a FuzzyRuleAntecedent objects
    FuzzyRuleAntecedent *ifDistanceBig = new FuzzyRuleAntecedent();
    // Creating a FuzzyRuleAntecedent with just a single FuzzySet
    ifDistanceBig->joinSingle(big);
    // Instantiating a FuzzyRuleConsequent objects
    FuzzyRuleConsequent *thenSpeedFast = new FuzzyRuleConsequent();
    // Including a FuzzySet to this FuzzyRuleConsequent
    thenSpeedFast->addOutput(fast);
    // Instantiating a FuzzyRule objects
    FuzzyRule *fuzzyRule03 = new FuzzyRule(3, ifDistanceBig, thenSpeedFast);
    // Including the FuzzyRule into Fuzzy
    fuzzy->addFuzzyRule(fuzzyRule03);

    // get a random value
    int input = random(0, 100);
    // Printing something
    cout << "\n\n\nEntrance: \n\t\t\tDistance: " << input << endl;
    // Set the random value as an input
    fuzzy->setInput(1, input);
    // Running the Fuzzification
    fuzzy->fuzzify();
    // Running the Defuzzification
    float output = fuzzy->defuzzify(1);
    // Printing something
    cout << "Result: \n\t\t\tSpeed: " << output << endl;
    return 0;
}
Example #9
0
TEST(Fuzzy, setInputAndFuzzifyAndDefuzzify07){
  Fuzzy* fuzzy = new Fuzzy();

  // FuzzyInput
  FuzzyInput* distance = new FuzzyInput(1);

  FuzzySet* close = new FuzzySet(0, 20, 20, 40);
  distance->addFuzzySet(close);
  FuzzySet* safe = new FuzzySet(30, 50, 50, 70);
  distance->addFuzzySet(safe);
  FuzzySet* distante = new FuzzySet(60, 80, 100, 100);
  distance->addFuzzySet(distante);

  fuzzy->addFuzzyInput(distance);

  // FuzzyInput
  FuzzyInput* temperature = new FuzzyInput(2);

  FuzzySet* cold = new FuzzySet(-30, -30, -20, -10);
  temperature->addFuzzySet(cold);
  FuzzySet* good = new FuzzySet(-15, 0, 0, 15);
  temperature->addFuzzySet(good);
  FuzzySet* hot = new FuzzySet(10, 20, 30, 30);
  temperature->addFuzzySet(hot);

  fuzzy->addFuzzyInput(temperature);

  // FuzzyOutput
  FuzzyOutput* risk = new FuzzyOutput(1);

  FuzzySet* minimum = new FuzzySet(0, 20, 20, 40);
  risk->addFuzzySet(minimum);
  FuzzySet* average = new FuzzySet(30, 50, 50, 70);
  risk->addFuzzySet(average);
  FuzzySet* maximum = new FuzzySet(60, 80, 80, 100);
  risk->addFuzzySet(maximum);

  fuzzy->addFuzzyOutput(risk);

  // Building FuzzyRule
  FuzzyRuleAntecedent* ifDistanceCloseAndTemperatureCold = new FuzzyRuleAntecedent();
  ifDistanceCloseAndTemperatureCold->joinWithAND(close, cold);

  FuzzyRuleConsequent* thenRiskMinimum1 = new FuzzyRuleConsequent();
  thenRiskMinimum1->addOutput(minimum);

  FuzzyRule* fuzzyRule1 = new FuzzyRule(1, ifDistanceCloseAndTemperatureCold, thenRiskMinimum1);
  fuzzy->addFuzzyRule(fuzzyRule1);

  // Building FuzzyRule
  FuzzyRuleAntecedent* ifDistanceCloseAndTemperatureGood = new FuzzyRuleAntecedent();
  ifDistanceCloseAndTemperatureGood->joinWithAND(close, good);

  FuzzyRuleConsequent* thenRiskMinimum2 = new FuzzyRuleConsequent();
  thenRiskMinimum2->addOutput(minimum);

  FuzzyRule* fuzzyRule2 = new FuzzyRule(2, ifDistanceCloseAndTemperatureGood, thenRiskMinimum2);
  fuzzy->addFuzzyRule(fuzzyRule2);

  // Building FuzzyRule
  FuzzyRuleAntecedent* ifDistanceSafeAndTemperatureCold = new FuzzyRuleAntecedent();
  ifDistanceSafeAndTemperatureCold->joinWithAND(safe, cold);

  FuzzyRuleConsequent* thenRiskMinimum3 = new FuzzyRuleConsequent();
  thenRiskMinimum3->addOutput(minimum);

  FuzzyRule* fuzzyRule3 = new FuzzyRule(3, ifDistanceSafeAndTemperatureCold, thenRiskMinimum3);
  fuzzy->addFuzzyRule(fuzzyRule3);

  fuzzy->setInput(1, 10);
  fuzzy->setInput(2, -5);

  fuzzy->fuzzify();

  float output = fuzzy->defuzzify(1);

  EXPECT_EQ(20.0, output);
}
Example #10
0
TEST(Fuzzy, setInputAndFuzzifyAndDefuzzify06){
  Fuzzy* fuzzy = new Fuzzy();

  // FuzzyInput
  FuzzyInput* distance = new FuzzyInput(1);

  FuzzySet* close = new FuzzySet(0, 20, 20, 40);
  distance->addFuzzySet(close);
  FuzzySet* safe = new FuzzySet(30, 50, 50, 70);
  distance->addFuzzySet(safe);
  FuzzySet* distante = new FuzzySet(60, 80, 100, 100);
  distance->addFuzzySet(distante);

  fuzzy->addFuzzyInput(distance);

  // FuzzyInput
  FuzzyInput* inputSpeed = new FuzzyInput(2);

  FuzzySet* stoped = new FuzzySet(0, 0, 0, 0);
  inputSpeed->addFuzzySet(stoped);
  FuzzySet* slow = new FuzzySet(1, 10, 10, 20);
  inputSpeed->addFuzzySet(slow);
  FuzzySet* normal = new FuzzySet(15, 30, 30, 50);
  inputSpeed->addFuzzySet(normal);
  FuzzySet* quick = new FuzzySet(45, 60, 70, 70);
  inputSpeed->addFuzzySet(quick);

  fuzzy->addFuzzyInput(inputSpeed);

  // FuzzyInput
  FuzzyInput* temperature = new FuzzyInput(3);

  FuzzySet* cold = new FuzzySet(-30, -30, -20, -10);
  temperature->addFuzzySet(cold);
  FuzzySet* good = new FuzzySet(-15, 0, 0, 15);
  temperature->addFuzzySet(good);
  FuzzySet* hot = new FuzzySet(10, 20, 30, 30);
  temperature->addFuzzySet(hot);

  fuzzy->addFuzzyInput(temperature);

  // FuzzyOutput
  FuzzyOutput* risk = new FuzzyOutput(1);

  FuzzySet* minimum = new FuzzySet(0, 20, 20, 40);
  risk->addFuzzySet(minimum);
  FuzzySet* average = new FuzzySet(30, 50, 50, 70);
  risk->addFuzzySet(average);
  FuzzySet* maximum = new FuzzySet(60, 80, 80, 100);
  risk->addFuzzySet(maximum);

  fuzzy->addFuzzyOutput(risk);

  // FuzzyOutput
  // adicionando speed como output também
  FuzzyOutput* outputSpeed = new FuzzyOutput(2);

  FuzzySet* stopedOut = new FuzzySet(0, 0, 0, 0);
  outputSpeed->addFuzzySet(stopedOut);
  FuzzySet* slowOut = new FuzzySet(1, 10, 10, 20);
  outputSpeed->addFuzzySet(slowOut);
  FuzzySet* normalOut = new FuzzySet(15, 30, 30, 50);
  outputSpeed->addFuzzySet(normalOut);
  FuzzySet* quickOut = new FuzzySet(45, 60, 70, 70);
  outputSpeed->addFuzzySet(quickOut);

  fuzzy->addFuzzyOutput(outputSpeed);

  // Building FuzzyRule
  FuzzyRuleAntecedent* distanceCloseAndSpeedQuick = new FuzzyRuleAntecedent();
  distanceCloseAndSpeedQuick->joinWithAND(close, quick);
  FuzzyRuleAntecedent* temperatureCold = new FuzzyRuleAntecedent();
  temperatureCold->joinSingle(cold);
  FuzzyRuleAntecedent* ifDistanceCloseAndSpeedQuickOrTemperatureCold = new FuzzyRuleAntecedent();
  ifDistanceCloseAndSpeedQuickOrTemperatureCold->joinWithOR(distanceCloseAndSpeedQuick, temperatureCold);

  FuzzyRuleConsequent* thenRisMaximumAndSpeedSlow = new FuzzyRuleConsequent();
  thenRisMaximumAndSpeedSlow->addOutput(maximum);
  thenRisMaximumAndSpeedSlow->addOutput(slowOut);

  FuzzyRule* fuzzyRule1 = new FuzzyRule(1, ifDistanceCloseAndSpeedQuickOrTemperatureCold, thenRisMaximumAndSpeedSlow);
  fuzzy->addFuzzyRule(fuzzyRule1);

  // Building FuzzyRule
  FuzzyRuleAntecedent* distanceSafeAndSpeedNormal = new FuzzyRuleAntecedent();
  distanceSafeAndSpeedNormal->joinWithAND(safe, normal);
  FuzzyRuleAntecedent* ifDistanceSafeAndSpeedNormalOrTemperatureGood = new FuzzyRuleAntecedent();
  ifDistanceSafeAndSpeedNormalOrTemperatureGood->joinWithOR(distanceSafeAndSpeedNormal, good);

  FuzzyRuleConsequent* thenRiskAverageAndSpeedNormal = new FuzzyRuleConsequent();
  thenRiskAverageAndSpeedNormal->addOutput(average);
  thenRiskAverageAndSpeedNormal->addOutput(normalOut);

  FuzzyRule* fuzzyRule2 = new FuzzyRule(2, ifDistanceSafeAndSpeedNormalOrTemperatureGood, thenRiskAverageAndSpeedNormal);
  fuzzy->addFuzzyRule(fuzzyRule2);

  // Building FuzzyRule
  FuzzyRuleAntecedent* distanceDistanteAndSpeedSlow = new FuzzyRuleAntecedent();
  distanceDistanteAndSpeedSlow->joinWithAND(distante, slow);
  FuzzyRuleAntecedent* ifDistanceDistanteAndSpeedSlowOrTemperatureHot = new FuzzyRuleAntecedent();
  ifDistanceDistanteAndSpeedSlowOrTemperatureHot->joinWithOR(distanceDistanteAndSpeedSlow, hot);

  FuzzyRuleConsequent* thenRiskMinimumSpeedQuick = new FuzzyRuleConsequent();
  thenRiskMinimumSpeedQuick->addOutput(minimum);
  thenRiskMinimumSpeedQuick->addOutput(quickOut);

  FuzzyRule* fuzzyRule3 = new FuzzyRule(3, ifDistanceDistanteAndSpeedSlowOrTemperatureHot, thenRiskMinimumSpeedQuick);
  fuzzy->addFuzzyRule(fuzzyRule3);

  fuzzy->setInput(1, 10);
  fuzzy->setInput(2, 30);
  fuzzy->setInput(3, -15);

  fuzzy->fuzzify();

  float output1 = fuzzy->defuzzify(1);
  float output2 = fuzzy->defuzzify(2);

  EXPECT_EQ(80.0, output1);
  EXPECT_EQ(10.5, output2);
}
Example #11
0
TEST(Fuzzy, setInputAndFuzzifyAndDefuzzify05){
  Fuzzy* fuzzy = new Fuzzy();

  // FuzzyInput
  FuzzyInput* temperature = new FuzzyInput(1);

  FuzzySet* low = new FuzzySet(-20, -20, -20, -20);
  temperature->addFuzzySet(low);
  FuzzySet* mean = new FuzzySet(-10, -10, -10, -10);
  temperature->addFuzzySet(mean);
  FuzzySet* high = new FuzzySet(10, 10, 10, 10);
  temperature->addFuzzySet(high);

  fuzzy->addFuzzyInput(temperature);

  // FuzzyInput
  FuzzyInput* pressure = new FuzzyInput(2);

  FuzzySet* small = new FuzzySet(-20, -20, -20, -20);
  pressure->addFuzzySet(small);
  FuzzySet* normal = new FuzzySet(-10, -10, -10, -10);
  pressure->addFuzzySet(normal);
  FuzzySet* big = new FuzzySet(10, 10, 10, 10);
  pressure->addFuzzySet(big);

  fuzzy->addFuzzyInput(pressure);

  // FuzzyOutput
  FuzzyOutput* risk = new FuzzyOutput(1);

  FuzzySet* minimum = new FuzzySet(-20, -20, -20, -20);
  risk->addFuzzySet(minimum);
  FuzzySet* average = new FuzzySet(-10, -10, -10, -10);
  risk->addFuzzySet(average);
  FuzzySet* maximum = new FuzzySet(10, 10, 10, 10);
  risk->addFuzzySet(maximum);

  fuzzy->addFuzzyOutput(risk);

  // Building FuzzyRule
  FuzzyRuleAntecedent* ifTemperatureLowAndPressureSmall = new FuzzyRuleAntecedent();
  ifTemperatureLowAndPressureSmall->joinWithAND(low, small);
  FuzzyRuleConsequent* thenRiskMinimum = new FuzzyRuleConsequent();
  thenRiskMinimum->addOutput(minimum);

  FuzzyRule* fuzzyRule1 = new FuzzyRule(1, ifTemperatureLowAndPressureSmall, thenRiskMinimum);
  fuzzy->addFuzzyRule(fuzzyRule1);

  // Building FuzzyRule
  FuzzyRuleAntecedent* ifTemperatureMeanAndPressureNormal = new FuzzyRuleAntecedent();
  ifTemperatureMeanAndPressureNormal->joinWithAND(mean, normal);
  FuzzyRuleConsequent* theRiskAverage = new FuzzyRuleConsequent();
  theRiskAverage->addOutput(average);

  FuzzyRule* fuzzyRule2 = new FuzzyRule(2, ifTemperatureMeanAndPressureNormal, theRiskAverage);
  fuzzy->addFuzzyRule(fuzzyRule2);

  // Building FuzzyRule
  FuzzyRuleAntecedent* ifTemperatureHighAndPressureBig = new FuzzyRuleAntecedent();
  ifTemperatureHighAndPressureBig->joinWithAND(high, big);
  FuzzyRuleConsequent* thenRiskMaximum = new FuzzyRuleConsequent();
  thenRiskMaximum->addOutput(maximum);

  FuzzyRule* fuzzyRule3 = new FuzzyRule(3, ifTemperatureHighAndPressureBig, thenRiskMaximum);
  fuzzy->addFuzzyRule(fuzzyRule3);

  fuzzy->setInput(1, -20);
  fuzzy->setInput(2, -15);

  fuzzy->fuzzify();

  float output = fuzzy->defuzzify(1);

  EXPECT_EQ(output, 0.0);
}
Example #12
0
TEST(Fuzzy, setInputAndFuzzifyAndDefuzzify01){
  Fuzzy* fuzzy = new Fuzzy();

  // FuzzyInput
  FuzzyInput* temperature = new FuzzyInput(1);

  FuzzySet* low = new FuzzySet(0, 10, 10, 20);
  temperature->addFuzzySet(low);
  FuzzySet* mean = new FuzzySet(10, 20, 30, 40);
  temperature->addFuzzySet(mean);
  FuzzySet* high = new FuzzySet(30, 40, 40, 50);
  temperature->addFuzzySet(high);

  fuzzy->addFuzzyInput(temperature);

  // FuzzyOutput
  FuzzyOutput* climate = new FuzzyOutput(1);

  FuzzySet* cold = new FuzzySet(0, 10, 10, 20);
  climate->addFuzzySet(cold);
  FuzzySet* good = new FuzzySet(10, 20, 30, 40);
  climate->addFuzzySet(good);
  FuzzySet* hot = new FuzzySet(30, 40, 40, 50);
  climate->addFuzzySet(hot);

  fuzzy->addFuzzyOutput(climate);

  // Building FuzzyRule
  FuzzyRuleAntecedent* ifTemperatureLow = new FuzzyRuleAntecedent();
  ifTemperatureLow->joinSingle(low);
  FuzzyRuleConsequent* thenClimateCold = new FuzzyRuleConsequent();
  thenClimateCold->addOutput(cold);

  FuzzyRule* fuzzyRule1 = new FuzzyRule(1, ifTemperatureLow, thenClimateCold);
  fuzzy->addFuzzyRule(fuzzyRule1);

  // Building FuzzyRule
  FuzzyRuleAntecedent* ifTemperatureMean = new FuzzyRuleAntecedent();
  ifTemperatureMean->joinSingle(mean);
  FuzzyRuleConsequent* thenClimateGood = new FuzzyRuleConsequent();
  thenClimateGood->addOutput(good);

  FuzzyRule* fuzzyRule2 = new FuzzyRule(2, ifTemperatureMean, thenClimateGood);
  fuzzy->addFuzzyRule(fuzzyRule2);

  // Building FuzzyRule
  FuzzyRuleAntecedent* ifTemperatureHigh = new FuzzyRuleAntecedent();
  ifTemperatureHigh->joinSingle(low);
  FuzzyRuleConsequent* thenClimateHot = new FuzzyRuleConsequent();
  thenClimateHot->addOutput(cold);

  FuzzyRule* fuzzyRule3 = new FuzzyRule(3, ifTemperatureHigh, thenClimateHot);
  fuzzy->addFuzzyRule(fuzzyRule3);

  bool result1 = fuzzy->setInput(1, 15);

  bool result2 = fuzzy->fuzzify();

  float output = fuzzy->defuzzify(1);

  EXPECT_TRUE(result1);
  EXPECT_TRUE(result2);
  EXPECT_GT(output, 0.0);
}