5 réponses à ce sujet

[oumay]

bonsoir tous le monde, 
j'ai un petit problème que je n'arrive pas à le résoudre.  j'ai développé une méthode comme entrée une valeur d'angle (angle entre robot et son objectif) et comme sortie une valeur d'angle (angle appliqué par le robot pour se rapprocher de son objectif) 

la méthode est basée sur la théorie de logique flous. 
pour la variable de sortie j'ai définit les angles (univers de discours) comme suit: 

         angle.add("Négatif Grand", -PI/5);   
         angle.add("Négatif Moyen", -PI/10); 
         angle.add("Négatif Proche", -PI/20); 
         angle.add("Zéro", 0); 
         angle.add("Positif Petit", PI/20); 
         angle.add("Positif Moyen", PI/10); 
         angle.add("Positif Grand", PI/5); 

 

 

les règles sont comme suit : 

TO : angle entre robot et objectif 
angle : l'angle à appliqué par le robot pour s'orienter vers son objectif 

1- si TO =-1.6 alors angle is PG =PI/5 
2-si TO =-0.75 alors angle is PM = PI/10 
3- si TO =-0.25 alors angle is PP =PI/20 
4- si TO=0.0 alors angle is Z =0.0 
5- si TO=0.25 alors angle is NP =-PI/20 
6- si TO=0.75 alors angle is NM =-pi/10 
7- si TO=1.6 alors angle is NG =-pi/5 



exemple, si l'angle entre le robot et son objectif est -1.6 en radian ( input TO= -1.6 ) alors la règle n°1 va être dèclanché le robot doit appliqué un angle positif grand égal à  PI/5 

le problème est que la méthode me renvoi une valeur NaN (not a number)
les angles négatifs sont bien applicables tandis que les angles positifs me renvoi NaN. 

donc comment puisse je faire la congruence entre les angles pour éviter d'avoir un conflit. 

merci infiniment pour vos aides.

[Path]

Salut Ourmay,

 

Tes posts semblent très intéressant !! Mais faiblement compréhensibles. Il manque le contexte. On sent aussi une faible congruence entre ta volonté intrinsèquement affichée d'appliquer une théorie d'ingénierie et les technique d'application souvent liées à l'expérience.

 

Ta méthode qui renvoi NaN, c'est quel langage ? Tu peux donner le code ? Un petit schéma pour comprendre ton montage ? Une photo à la rigueur. Explique aussi la finalité de ton robot. Il y a des enjeux ? 

 

Sauf erreur, je ne vois pas de présentation. Si c'est le cas, hop, dis-nous qui tu es, d'où tu viens. Ce sera plus sympa de savoir à qui on s'adresse et ça nous permettra de mieux te guider. 

[Mike118]

 

Ta méthode qui renvoi NaN, c'est quel langage ? 

 

Java ? 

Sans remettre tout ce que dit path en question ( par ce qu'il a parfaitement raison de demander plus de précision + présentation ça serait plus simple pour tout le monde  )

Le problème c'est pas que tu essais d'utiliser PI sans qu'il soit compris comme étant un nombre ? d'où le NaN ? 

[oumay]

merci pour vos réponses.
pour le langage, j'utilise JAVA.
 
voici le code de la méthode 

/**
   	 * cette méthode représente le contrôleur flou d'angle d'orientation
   	 * @param a : représente la distance entre le robot et sa cible
   	 * @param b : représente l'angle entre le robot et sa cible
   	 * @return  : elle retourne vitesse de rotation et vitesse de translation du robot qu'il faut l'appliquer pour 
   	 * s'approcher de sa cible
   	 * @throws RulesParsingException
   	 * @throws NoRulesFiredException
   	 * @throws EvaluationException
   	 */
   public	double[] GSB(double a ,double b) throws 
   RulesParsingException, NoRulesFiredException, EvaluationException{
   	
   	// la partie floue fuzzification
   	  /*** la définition des variables linguistiques***/
   	  LinguisticVariable distance = new LinguisticVariable("distance"); 
   	  LinguisticVariable TO = new LinguisticVariable("TO"); 
   	  LinguisticVariable angle = new LinguisticVariable("angle");
   	  LinguisticVariable vitesse = new LinguisticVariable("vitesse");
   	  
   	  
   	  
   /*** l'univers de discours des variables linguistiques avec les fonctions d'appartenance
    * pour la variable d'entrée distance***/
   	 distance.add("Z", 0.0,0.0, 0.1, 3.5);
   	 distance.add("P", 0.1, 3.5, 3.5, 8.0);
   	 distance.add("M", 3.5, 8.0, 8.0, 13.0);
   	 distance.add("G", 8.0, 13.0, 13.0, 18.0);
   	 distance.add("TG",13.0, 18.0, Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY);
   	 
   	 
   	 
   	/*** l'univers de discours des variables linguistiques avec les fonctions d'appartenance
      * pour la variable d'entrée angle entre le robot et la cible***/
     	 TO.add("NG", -3.141592653589793, -3.141592653589793, -1.5, -0.75);
     	 TO.add("NM", -1.5, -0.75, -0.75, -0.25);
     	 TO.add("NP", -0.75, -0.25, -0.25, 0.0);
     	 TO.add("Z", -0.25, 0.0, 0.0, 0.25);
     	 TO.add("PP", 0.0, 0.25, 0.25, 0.75);
     	 TO.add("PM", 0.25, 0.75, 0.75, 1.5);
     	 TO.add("PG", 0.75, 1.5, 3.141592653589793, 3.141592653589793);
   	 
     	 
     	 
    /*** l'univers de discours des variables linguistiques avec les fonctions d'appartenance
          * pour la variable de sortie angle à appliquée par le robot pour s'approcher (s'orienter)
          * de cible***/
                
         
         angle.add("NG", -Math.PI/5, -Math.PI/5, -Math.PI/5, -Math.PI/5);
         angle.add("NM", -Math.PI/10, -Math.PI/10, -Math.PI/10, -Math.PI/10);
         angle.add("NP", -Math.PI/20, -Math.PI/20, -Math.PI/20, -Math.PI/20);
         angle.add("Z", 0, 0, 0, 0);
         angle.add("PP", Math.PI/20, Math.PI/20, Math.PI/20, Math.PI/20);
         
         angle.add("PM", Math.PI/10, Math.PI/10, Math.PI/10, Math.PI/10);
         angle.add("PG", Math.PI/5, Math.PI/5, Math.PI/5, Math.PI/5);
     	 
     	 
               
         
   /*** l'univers de discours des variables linguistiques avec les fonctions d'appartenance
          * pour la variable de sortie vitesse de translation du robot***/
         
         vitesse.add("Z", 0.0, 0.0, 0.0, 0.0);
         vitesse.add("F", 1.0, 1.0, 1.0, 1.0);
         vitesse.add("M", 1.8, 1.8, 1.8, 1.8);
         vitesse.add("G", 3.0, 3.0, 3.0, 3.0);
         vitesse.add("TG", 4.0, 4.0, 4.0, 4.0);
           	  
   	  /*** création de moteur d'inférence flou***/
   	  FuzzyEngine fuzzyEng = new FuzzyEngine();
   	  /*** enregistrement de tous les variables linguistiques ***/
   	  fuzzyEng.register(distance);
   	  fuzzyEng.register(TO);
   	  fuzzyEng.register(angle);
   	  fuzzyEng.register(vitesse);
   	

   	  /*** la définition des valeurs non-floues aux variables linguistiques ***/
   	  distance.setInputValue(a);// définir la valeur d'entrée pour la variable distance entre robot et cible
   	  TO.setInputValue(b);// définir la valeur d'entrée pour la variable angle d'orientation entre le robot et le cible
   	  
   	  /*** la fuzzification des variables linguistique selon leur valeur d'entrée***/
   		  
   		  /*** create a block of rules */
   		  /*creation de block de règles chaque règle est séparé par \n, 
   		   plus rapide si on va évaluer un block de règles à chaque fois*/
   		  FuzzyBlockOfRules fuzzyBlockOfRules = new FuzzyBlockOfRules(
   				  "if distance is Z and TO is NG then angle is PM and vitesse is Z\n"+
   				  "if distance is Z and TO is NM then angle is PP and vitesse is Z\n"+
   				  "if distance is Z and TO is NP then angle is Z and vitesse is Z\n"+
   				  "if distance is Z and TO is Z then angle is Z and vitesse is Z\n"+
   				  "if distance is Z and TO is PP then angle is Z and vitesse is Z\n"+
   				  "if distance is Z and TO is PM then angle is NP and vitesse is Z\n"+
   				  "if distance is Z and TO is PG then angle is NM and vitesse is Z\n"+
   				  "if distance is P and TO is NG then angle is PG and vitesse is F\n"+
   				  "if distance is P and TO is NM then angle is PG and vitesse is F\n"+
   				  "if distance is P and TO is NP then angle is PM and vitesse is F\n"+
   				  "if distance is P and TO is Z then angle is Z and vitesse is F\n"+
   				  "if distance is P and TO is PP then angle is NM and vitesse is F\n"+
   				  "if distance is P and TO is PM then angle is NG and vitesse is F\n"+
   				  "if distance is P and TO is PG then angle is NG and vitesse is F\n"+
   				  "if distance is M and TO is NG then angle is PM and vitesse is F\n"+
   				  "if distance is M and TO is NM then angle is PM and vitesse is F\n"+
   				  "if distance is M and TO is NP then angle is PP and vitesse is M\n"+
   				  "if distance is M and TO is Z then angle is Z and vitesse is M\n"+
   				  "if distance is M and TO is PP then angle is NM and vitesse is M\n"+
   				  "if distance is M and TO is PM then angle is NG and vitesse is F\n"+
   				  "if distance is M and TO is PG then angle is NG and vitesse is F\n"+
   				  "if distance is G and TO is NG then angle is PM and vitesse is F\n"+
   				  "if distance is G and TO is NM then angle is PP and vitesse is M\n"+
   				  "if distance is G and TO is NP then angle is PP and vitesse is G\n"+
   				  "if distance is G and TO is Z then angle is Z and vitesse is G\n"+
   				  "if distance is G and TO is PP then angle is NP and vitesse is G\n"+
   				  "if distance is G and TO is PM then angle is NP and vitesse is M\n"+
   				  "if distance is G and TO is PG then angle is NM and vitesse is F\n"+
   				  "if distance is TG and TO is NG then angle is PM and vitesse is F\n"+
   				  "if distance is TG and TO is NM then angle is PM and vitesse is M\n"+
   				  "if distance is TG and TO is NP then angle is PP and vitesse is G\n"+
   				  "if distance is TG and TO is Z then angle is Z and vitesse is TG\n"+
   				  "if distance is TG and TO is PP then angle is NP and vitesse is G\n"+
   				  "if distance is TG and TO is PM then angle is NM and vitesse is M\n"+
   				  "if distance is TG and TO is PG then angle is NM and vitesse is F\n"
   				  
   				  );
			  
			                                  //evaluateBlock ()
			  /***Register the block ***/
			  fuzzyEng.register(fuzzyBlockOfRules);// enregistre block of rules dans le fuzzy Engine
			  /***Parse the rules***/
			  fuzzyBlockOfRules.parseBlock();// throws RulesParsingException :
			                                 //Exception is thrown if any rule within block 
			                                 //generates a parsing error annalyse block of rules
			  /***Perform the evaluation***/
			  fuzzyBlockOfRules.evaluateBlock();/*throws EvaluationException : 
			                                    This exception is thrown if an error occurs 
			                                    during evaluation of a rule 
			                                    (most likely a MF name is wrong)*/ 
			  rule=fuzzyBlockOfRules.isRuleFired();
			  /*** obtenir le résultat***/
			  
			  
			  
			  double braccage = angle.defuzzify();// throws NoRulesFiredException: This exception 
			                                     //is thrown if no rules have 
			                                    //fired for this Linguistic Variable. 
			  double translation = vitesse.defuzzify();
             
			  
		/*** return l'angle d'orientation et de translation ***/
			
			  resultat[0]=braccage;
			 resultat[1]=translation;
			  return resultat;
		}
   

pour l'erreur

 

 

 Exception in thread "Timer-0" javax.media.j3d.BadTransformException: TransformGroup: non-affine transform

at javax.media.j3d.TransformGroup.setTransform(TransformGroup.java:118)

at simbad.sim.SimpleAgent.updatePosition(SimpleAgent.java:287)

at simbad.sim.Simulator.simulateOneStep(Simulator.java:250)

at simbad.sim.Simulator$1.run(Simulator.java:280)

at java.util.TimerThread.mainLoop(Timer.java:512)

at java.util.TimerThread.run(Timer.java:462)

 

vitesse de translation 1.0

vitesse de rotation NaN

 

et merci infiniment pour aide

[Path]

Je ne connais pas cette librairie.

Quand j'ai ce genre de problème, je fais des tests unitaire ou je procède par dichotomie.

Ici, cela revient à réduire les vitesses, les angles à un univers de 1 et vérifier que cela fonctionne. Ensuite j'ajoute des éléments à tes univers.

[oumay]

bonjour, 

 

merci path pour l'aide, j'ai fait des tests unitaires et j'ai constaté que le simulateur n'accepte que des angles division PI, pour cette raison il m'envoi NaN.