当前位置: 首页>>代码示例>>C++>>正文


C++ FuzzyOutput类代码示例

本文整理汇总了C++中FuzzyOutput的典型用法代码示例。如果您正苦于以下问题:C++ FuzzyOutput类的具体用法?C++ FuzzyOutput怎么用?C++ FuzzyOutput使用的例子?那么, 这里精选的类代码示例或许可以为您提供帮助。


在下文中一共展示了FuzzyOutput类的8个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。

示例1: TEST

TEST(FuzzyOutput, setCrispInputAndGetCrispInput){
  FuzzyOutput* fuzzyOutput = new FuzzyOutput(1);

  fuzzyOutput->setCrispInput(10.190);

  EXPECT_FLOAT_EQ(10.190, fuzzyOutput->getCrispInput());  
}
开发者ID:CamiloJr,项目名称:eFLL,代码行数:7,代码来源:FuzzyTest.cpp

示例2: main

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

    FuzzySet* t1 = new FuzzySet(0, 0, 0, 2);
    // FuzzySet* t2 = new FuzzySet(-1.5, 7.5, 7.5, 16.5);  // Antes
    FuzzySet* t2 = new FuzzySet(1.5, 7.5, 7.5, 16.5);  // después
    FuzzySet* t3 = new FuzzySet(3.5, 12.5, 12.5, 21.5);
    FuzzySet* t4 = new FuzzySet(9.5, 18.5, 18.5, 27.5);
    FuzzySet* t5 = new FuzzySet(14.5, 23.5, 23.5, 32.5);
    // FuzzySet* t6 = new FuzzySet(24.5, 37, 37, 37); // Antes
    FuzzySet* t6 = new FuzzySet(24.5, 37, 39, 39); // después - La temperatura puedes ser major que 37 grados

    FuzzySet* mbaja = new FuzzySet(0, 0, 0, 212);
    FuzzySet* baja = new FuzzySet(0, 212, 212, 425);
    FuzzySet* media = new FuzzySet(212, 425, 425, 638);
    FuzzySet* alta = new FuzzySet(425, 637, 637, 850);
    // FuzzySet* malta = new FuzzySet(637, 850, 850, 850); // Antes
    FuzzySet* malta = new FuzzySet(637, 850, 900, 900); // después - Las puertas analogicas de Arduino varian de 0 a 1024

    FuzzySet* v10 = new FuzzySet(0, 0, 0, 10);
    FuzzySet* v9 = new FuzzySet(0, 10, 10, 20);
    FuzzySet* v8 = new FuzzySet(10, 20, 20, 30);
    FuzzySet* v7 = new FuzzySet(20, 30, 30, 40);
    FuzzySet* v6 = new FuzzySet(30, 40, 40, 50);
    FuzzySet* v5 = new FuzzySet(40, 50, 50, 60); 
    FuzzySet* v4 = new FuzzySet(50, 60, 60, 70); 
    FuzzySet* v3 = new FuzzySet(60, 70, 70, 80);
    FuzzySet* v2 = new FuzzySet(70, 80, 80, 90);
    FuzzySet* v1 = new FuzzySet(80, 90, 90, 100);
    FuzzySet* v0 = new FuzzySet(90, 100, 100, 100);

    // FuzzyInput
    FuzzyInput* temperatura = new FuzzyInput(1);
    temperatura->addFuzzySet(t1);
    temperatura->addFuzzySet(t2);
    temperatura->addFuzzySet(t3);
    temperatura->addFuzzySet(t4);
    temperatura->addFuzzySet(t5);
    temperatura->addFuzzySet(t6);
    fuzzy->addFuzzyInput(temperatura);

    // FuzzyInput
    FuzzyInput* luminosidad = new FuzzyInput(2);
    luminosidad->addFuzzySet(mbaja);
    luminosidad->addFuzzySet(baja);
    luminosidad->addFuzzySet(media);
    luminosidad->addFuzzySet(alta);
    luminosidad->addFuzzySet(malta);
    fuzzy->addFuzzyInput(luminosidad);

    // FuzzyOutput
    FuzzyOutput* voltaje = new FuzzyOutput(1);
    voltaje->addFuzzySet(v10);  
    voltaje->addFuzzySet(v9);  
    voltaje->addFuzzySet(v8);  
    voltaje->addFuzzySet(v7); 
    voltaje->addFuzzySet(v6);  
    voltaje->addFuzzySet(v5);  
    voltaje->addFuzzySet(v4);  
    voltaje->addFuzzySet(v3); 
    voltaje->addFuzzySet(v2);  
    voltaje->addFuzzySet(v1);  
    voltaje->addFuzzySet(v0);
    fuzzy->addFuzzyOutput(voltaje);

    // Building FuzzyRule1
    FuzzyRuleAntecedent* iftemperaturat1Andluminosidadmbaja = new FuzzyRuleAntecedent();
    iftemperaturat1Andluminosidadmbaja->joinWithAND(t1, mbaja);
    FuzzyRuleConsequent* thenvoltajev0 = new FuzzyRuleConsequent();
    thenvoltajev0->addOutput(v0);
    FuzzyRule* fuzzyRule1 = new FuzzyRule(1, iftemperaturat1Andluminosidadmbaja, thenvoltajev0);
    fuzzy->addFuzzyRule(fuzzyRule1);

    // Building FuzzyRule2
    FuzzyRuleAntecedent* iftemperaturat1Andluminosidadbaja = new FuzzyRuleAntecedent();
    iftemperaturat1Andluminosidadbaja->joinWithAND(t1, baja);
    // FuzzyRuleConsequent* thenvoltajev0 = new FuzzyRuleConsequent();
    //thenvoltajev0->addOutput(v0);
    FuzzyRule* fuzzyRule2 = new FuzzyRule(2, iftemperaturat1Andluminosidadbaja, thenvoltajev0);
    fuzzy->addFuzzyRule(fuzzyRule2);

    // Building FuzzyRule3
    FuzzyRuleAntecedent* iftemperaturat1Andluminosidadmedia = new FuzzyRuleAntecedent();
    iftemperaturat1Andluminosidadmedia->joinWithAND(t1, media);
    //FuzzyRuleConsequent* thenvoltajev0 = new FuzzyRuleConsequent();
    //thenvoltajev0->addOutput(v0);
    FuzzyRule* fuzzyRule3 = new FuzzyRule(3, iftemperaturat1Andluminosidadmedia, thenvoltajev0);
    fuzzy->addFuzzyRule(fuzzyRule3);

    // Building FuzzyRule4
    FuzzyRuleAntecedent* iftemperaturat1Andluminosidadalta = new FuzzyRuleAntecedent();
    iftemperaturat1Andluminosidadalta->joinWithAND(t1, alta);
    //FuzzyRuleConsequent* thenvoltajev0 = new FuzzyRuleConsequent();
    //thenvoltajev0->addOutput(v0);
    FuzzyRule* fuzzyRule4 = new FuzzyRule(4, iftemperaturat1Andluminosidadalta, thenvoltajev0);
    fuzzy->addFuzzyRule(fuzzyRule4);

    // Building FuzzyRule5
    FuzzyRuleAntecedent* iftemperaturat1Andluminosidadmalta = new FuzzyRuleAntecedent();
    iftemperaturat1Andluminosidadmalta->joinWithAND(t1, malta);
//.........这里部分代码省略.........
开发者ID:Ronnasayd,项目名称:eFLL,代码行数:101,代码来源:GeneralTest.cpp

示例3: main

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);

//.........这里部分代码省略.........
开发者ID:Fishpipes,项目名称:FuzzyLogicLib,代码行数:101,代码来源:GeneralTest.cpp

示例4: main

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;
}
开发者ID:EduardoPfeifer,项目名称:eFLL,代码行数:66,代码来源:sample01.cpp

示例5: Fuzzy

/*
 *  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);  
//.........这里部分代码省略.........
开发者ID:AlexBondor,项目名称:wilkie-wf32,代码行数:101,代码来源:FuzzyController.cpp

示例6: main

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;
}
开发者ID:zerokol,项目名称:eFLL,代码行数:98,代码来源:general_simple_sample.cpp

示例7: main

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();
//.........这里部分代码省略.........
开发者ID:DavidZemon,项目名称:eFLL,代码行数:101,代码来源:general_advanced_sample.cpp

示例8: test

void test()
{
	float m;

	left.reset();
	right.reset();

	// if obstructionAhead is far then left = fast, right = fast
	m = obstructionAhead.is(Distance::FAR);
	left.addMembership(Speed::MEDIUM, m);
	right.addMembership(Speed::MEDIUM, m);

	m = obstructionAhead.is(Distance::CLOSE);
	left.addMembership(Speed::SLOW, m);
	right.addMembership(Speed::SLOW, m);

	// if obstructionAhead is close and betterDirection is left then left = slow, right = fast
	m = betterDirection.is(Direction::LEFT);
	left.addMembership(Speed::SLOW, m);
	right.addMembership(Speed::FAST, m);

	m = betterDirection.is(Direction::RIGHT);
	left.addMembership(Speed::FAST, m);
	right.addMembership(Speed::SLOW, m);

	printf("Left=%d, Right=%d\n",
			left.getCrispValue(),
			right.getCrispValue());
}
开发者ID:tnaran,项目名称:fuzzygen,代码行数:29,代码来源:fuzzy_test.cpp


注:本文中的FuzzyOutput类示例由纯净天空整理自Github/MSDocs等开源代码及文档管理平台,相关代码片段筛选自各路编程大神贡献的开源项目,源码版权归原作者所有,传播和使用请参考对应项目的License;未经允许,请勿转载。