use of valueOf() and isNaN()

main.js

-// comptage d'instances
 let instancesCreated = 0;
 let instancesDestroyed = 0;
 
-// classe de base pour toutes les expressions
 class Expression {
   constructor() {
     instancesCreated++;
   }
   
-  // méthode d'affichage
   toString() {
     return "";
   }
   
-  // méthode de dérivation 
+
   derive(variableName) {
     return new Nombre(0);
   }
   
-  // méthode de simplification
   simplify() {
     return this;
   }
   
+  valueOf() {
+    return NaN; 
+  }
+  
+
   destroy() {
     instancesDestroyed++;
   }
 }
 
-// classe représentant un nombre constant
 class Nombre extends Expression {
   constructor(value) {
     super();
@@ -39,18 +39,20 @@ class Nombre extends Expression {
     return this.value.toString();
   }
   
-  // dérivée d'un nb cst = 0
+  // dérivée d'un nombre constant est toujours 0
   derive(variableName) {
     return new Nombre(0);
   }
   
-  // nb est déjà simplifié
   simplify() {
     return this;
   }
+  
+  valueOf() {
+    return this.value;
+  }
 }
 
-// classe représentant une variable
 class Variable extends Expression {
   constructor(name) {
     super();
@@ -61,7 +63,7 @@ class Variable extends Expression {
     return this.name;
   }
   
-  // dérivée d'une var est 1 si c'est la variable par rapport à laquelle
+  // la dérivée d'une variable est 1 si c'est la variable par rapport à laquelle
   // on dérive, 0 sinon
   derive(variableName) {
     return this.name === variableName ? new Nombre(1) : new Nombre(0);
@@ -70,9 +72,12 @@ class Variable extends Expression {
   simplify() {
     return this;
   }
+  
+  valueOf() {
+    return NaN;
+  }
 }
 
-// classe de base pour toutes les opérations
 class Operation extends Expression {
   constructor(leftOperand, rightOperand) {
     super();
@@ -98,27 +103,37 @@ class Addition extends Operation {
     );
   }
   
-  // simplification addition
   simplify() {
     const leftSimplified = this.leftOperand.simplify();
     const rightSimplified = this.rightOperand.simplify();
     
-    // si les deux opérandes sont des nombres, on peut calculer le résultat
-    if (leftSimplified instanceof Nombre && rightSimplified instanceof Nombre) {
-      return new Nombre(leftSimplified.value + rightSimplified.value);
+    // si les deux opérandes peuvent être évalués numériquement, on calcule le résultat
+    if (!isNaN(leftSimplified.valueOf()) && !isNaN(rightSimplified.valueOf())) {
+      return new Nombre(leftSimplified.valueOf() + rightSimplified.valueOf());
     }
     
     // si l'un des opérandes est 0, on retourne l'autre
-    if (leftSimplified instanceof Nombre && leftSimplified.value === 0) {
+    if (!isNaN(leftSimplified.valueOf()) && leftSimplified.valueOf() === 0) {
       return rightSimplified;
     }
-    if (rightSimplified instanceof Nombre && rightSimplified.value === 0) {
+    if (!isNaN(rightSimplified.valueOf()) && rightSimplified.valueOf() === 0) {
       return leftSimplified;
     }
     
     // sinon, on crée une nouvelle addition avec les opérandes simplifiés
     return new Addition(leftSimplified, rightSimplified);
   }
+  
+  // une addition peut être évaluée si ses deux opérandes peuvent l'être
+  valueOf() {
+    const leftValue = this.leftOperand.valueOf();
+    const rightValue = this.rightOperand.valueOf();
+    
+    if (isNaN(leftValue) || isNaN(rightValue)) {
+      return NaN;
+    }
+    return leftValue + rightValue;
+  }
 }
 
 class Multiplication extends Operation {
@@ -141,34 +156,49 @@ class Multiplication extends Operation {
     );
   }
   
+  // simplification d'une multiplication
   simplify() {
     const leftSimplified = this.leftOperand.simplify();
     const rightSimplified = this.rightOperand.simplify();
     
-    // si les deux opérandes sont des nombres, on peut calculer le résultat
-    if (leftSimplified instanceof Nombre && rightSimplified instanceof Nombre) {
-      return new Nombre(leftSimplified.value * rightSimplified.value);
+    // si les deux opérandes peuvent être évalués numériquement, on calcule le résultat
+    if (!isNaN(leftSimplified.valueOf()) && !isNaN(rightSimplified.valueOf())) {
+      return new Nombre(leftSimplified.valueOf() * rightSimplified.valueOf());
     }
     
     // si l'un des opérandes est 0, le résultat est 0
-    if ((leftSimplified instanceof Nombre && leftSimplified.value === 0) ||
-        (rightSimplified instanceof Nombre && rightSimplified.value === 0)) {
+    if ((!isNaN(leftSimplified.valueOf()) && leftSimplified.valueOf() === 0) ||
+        (!isNaN(rightSimplified.valueOf()) && rightSimplified.valueOf() === 0)) {
       return new Nombre(0);
     }
     
     // si l'un des opérandes est 1, on retourne l'autre
-    if (leftSimplified instanceof Nombre && leftSimplified.value === 1) {
+    if (!isNaN(leftSimplified.valueOf()) && leftSimplified.valueOf() === 1) {
       return rightSimplified;
     }
-    if (rightSimplified instanceof Nombre && rightSimplified.value === 1) {
+    if (!isNaN(rightSimplified.valueOf()) && rightSimplified.valueOf() === 1) {
       return leftSimplified;
     }
     
     // sinon, on crée une nouvelle multiplication avec les opérandes simplifiés
     return new Multiplication(leftSimplified, rightSimplified);
   }
+  
+  // multiplication peut être évaluée si ses deux opérandes peuvent l'être
+  valueOf() {
+    const leftValue = this.leftOperand.valueOf();
+    const rightValue = this.rightOperand.valueOf();
+    
+    if (isNaN(leftValue) || isNaN(rightValue)) {
+      return NaN;
+    }
+    
+    return leftValue * rightValue;
+  }
 }
 
+
+
 function test() {
   const x = new Variable("x");
   const y = new Variable("y");
@@ -198,7 +228,16 @@ function test() {
   // simplification de la dérivée par rapport à y
   const simplifiedDerivedY = derivedY.simplify();
   console.log("Dérivée simplifiée par rapport à y:", simplifiedDerivedY.toString());
-
+  
+  
+  // Tests de valueOf()
+  console.log("\nTests de valueOf():");
+  console.log("Valeur de 2:", deux.valueOf());
+  console.log("Valeur de x:", x.valueOf());
+  console.log("Valeur de 2+3:", new Addition(deux, trois).valueOf());
+  console.log("Valeur de 2*3:", new Multiplication(deux, trois).valueOf());
+  console.log("Valeur de x+y:", new Addition(x, y).valueOf());
 }
 
+// Exécution du test
 test();
\ No newline at end of file