math-exercises 2.2.17 → 2.2.19

package/lib/exercises/math/geometry/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/geometry/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/geometry/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAE1B,cAAc,0BAA0B,CAAC"}

package/lib/exercises/math/geometry/index.js

@@ -22,3 +22,5 @@ __exportStar(require("./thales"), exports);
 __exportStar(require("./vectors"), exports);
 __exportStar(require("./convexity"), exports);
 __exportStar(require("./volumes"), exports);
+// export * from "./triangles";
+__exportStar(require("./euclidianConstructions"), exports);

package/lib/exercises/math/geometry/triangles/index.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/geometry/triangles/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/triangles/index.ts"],"names":[],"mappings":""}

package/lib/exercises/math/geometry/triangles/index.js

@@ -0,0 +1,2 @@
+"use strict";
+// export * from './traceMedianInTriangle'

package/lib/exercises/math/geometry/triangles/traceMedianInTriangle.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=traceMedianInTriangle.d.ts.map

package/lib/exercises/math/geometry/triangles/traceMedianInTriangle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traceMedianInTriangle.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/triangles/traceMedianInTriangle.ts"],"names":[],"mappings":""}

package/lib/exercises/math/geometry/triangles/traceMedianInTriangle.js

@@ -0,0 +1,55 @@
+"use strict";
+// import {
+//   Exercise,
+//   Proposition,
+//   QCMGenerator,
+//   Question,
+//   QuestionGenerator,
+//   VEA,
+//   GGBVEA,
+//   addValidProp,
+//   shuffleProps,
+//   tryToAddWrongProp,
+// } from '../../../../exercises/exercise';
+// import { getDistinctQuestions } from '../../../../exercises/utils/getDistinctQuestions';
+// type Identifiers = {
+// };
+// const getTraceMedianInTriangleQuestion: QuestionGenerator<Identifiers>  = ()=>{
+//   const question: Question<Identifiers> = {
+//     answer,
+//     instruction: ``,
+//     keys: [],
+//     answerFormat: 'tex',
+//     identifiers : {}
+//   };
+//   return question;
+// }
+// const getPropositions: QCMGenerator<Identifiers> = (n, { answer }) => {
+//   const propositions: Proposition[] = [];
+//   addValidProp(propositions, answer);
+//   while (propositions.length < n) {
+//     throw Error("QCM not implemented")
+//   }
+//   return shuffleProps(propositions, n);
+// };
+// const isAnswerValid: VEA<Identifiers> = (ans, {answer})=>{
+//   throw Error("VEA not implemented")
+// }
+// const isGGBAnswerValid: GGBVEA<Identifiers> = (ans, {ggbAnswer}) => {
+//   throw Error("GGBVea not implemented")
+// }
+// export const traceMedianInTriangle: Exercise<Identifiers> = {
+//   id: 'traceMedianInTriangle',
+//   connector: "",
+//   label: "",
+//   levels: [],
+//   isSingleStep: true,
+//   sections: [],
+//   generator: (nb: number) => getDistinctQuestions(getTraceMedianInTriangleQuestion, nb),
+//   qcmTimer: 60,
+//   freeTimer: 60,
+//   getPropositions,
+//   isAnswerValid,
+//   isGGBAnswerValid,
+//   subject: "Mathématiques"
+// };

package/lib/exercises/math/geometry/vectors/scalarProductViaCos.js

@@ -8,7 +8,7 @@ const remarkableValues_1 = require("../../../../math/trigonometry/remarkableValu
 const randint_1 = require("../../../../math/utils/random/randint");
 const numberNode_1 = require("../../../../tree/nodes/numbers/numberNode");
 const multiplyNode_1 = require("../../../../tree/nodes/operators/multiplyNode");
-const randomLetter_1 = require("../../../../utils/randomLetter");
+const randomLetter_1 = require("../../../../utils/strings/randomLetter");
 const shuffle_1 = require("../../../../utils/shuffle");
 //|u| |v| cos(u,v)
 const getScalarProductViaCosQuestion = () => {

package/lib/exercises/math/geometry/vectors/vectorCoordinatesFromTwoPoints.js

@@ -6,7 +6,7 @@ const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQ
 const randint_1 = require("../../../../math/utils/random/randint");
 const substractNode_1 = require("../../../../tree/nodes/operators/substractNode");
 const alignTex_1 = require("../../../../utils/alignTex");
-const randomLetter_1 = require("../../../../utils/randomLetter");
+const randomLetter_1 = require("../../../../utils/strings/randomLetter");
 const getVectorCoordinatesFromTwoPointsQuestion = () => {
     const A = [(0, randint_1.randint)(-9, 9), (0, randint_1.randint)(-9, 9)];
     const B = [(0, randint_1.randint)(-9, 9), (0, randint_1.randint)(-9, 9)];

package/lib/exercises/math/percent/htToTTC.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"htToTTC.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/htToTTC.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAgCF,eAAO,MAAM,OAAO,EAAE,QAAQ,CAAC,WAAW,CAazC,CAAC"}
+{"version":3,"file":"htToTTC.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/htToTTC.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAWlC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA6CF,eAAO,MAAM,OAAO,EAAE,QAAQ,CAAC,WAAW,CAczC,CAAC"}

package/lib/exercises/math/percent/htToTTC.js

@@ -6,6 +6,7 @@ const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQues
 const randfloat_1 = require("../../../math/utils/random/randfloat");
 const randint_1 = require("../../../math/utils/random/randint");
 const round_1 = require("../../../math/utils/round");
+const numberParser_1 = require("../../../tree/parsers/numberParser");
 const coinFlip_1 = require("../../../utils/coinFlip");
 const random_1 = require("../../../utils/random");
 const getHtToTtcQuestion = () => {
@@ -18,6 +19,19 @@ const getHtToTtcQuestion = () => {
         keys: [],
         answerFormat: "tex",
         identifiers: { TVA, ht },
+        hint: `Pour augmenter un prix de $t\\%$, on le multiplie par $1 + \\frac{t}{100}$.`,
+        correction: `Pour augmenter $${ht.frenchify()}$ de $${TVA.frenchify()}\\%$, on le multiplie par :
+    
+$$
+1 + \\frac{${TVA.frenchify()}}{100} = ${(0, round_1.round)(1 + TVA / 100, 3).frenchify()}
+$$ 
+
+Le prix TTC est donc : 
+
+$$
+${ht.frenchify()} \\times ${(0, round_1.round)(1 + TVA / 100, 3).frenchify()} = ${answer}
+$$
+`,
     };
     return question;
 };
@@ -32,7 +46,7 @@ const getPropositions = (n, { answer, TVA, ht }) => {
     return (0, exercise_1.shuffleProps)(propositions, n);
 };
 const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
+    return (0, numberParser_1.numberParser)(ans) === answer;
 };
 exports.htToTTC = {
     id: "htToTTC",
@@ -47,4 +61,5 @@ exports.htToTTC = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/percent/ttcToHT.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ttcToHT.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/ttcToHT.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAuCF,eAAO,MAAM,OAAO,EAAE,QAAQ,CAAC,WAAW,CAazC,CAAC"}
+{"version":3,"file":"ttcToHT.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/ttcToHT.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAuDF,eAAO,MAAM,OAAO,EAAE,QAAQ,CAAC,WAAW,CAczC,CAAC"}

package/lib/exercises/math/percent/ttcToHT.js

@@ -6,6 +6,7 @@ const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQues
 const randfloat_1 = require("../../../math/utils/random/randfloat");
 const randint_1 = require("../../../math/utils/random/randint");
 const round_1 = require("../../../math/utils/round");
+const numberParser_1 = require("../../../tree/parsers/numberParser");
 const coinFlip_1 = require("../../../utils/coinFlip");
 const random_1 = require("../../../utils/random");
 const getTtcToHtQuestion = () => {
@@ -18,6 +19,19 @@ const getTtcToHtQuestion = () => {
         keys: [],
         answerFormat: "tex",
         identifiers: { TTC, TVA },
+        hint: `Pour retrouver le prix HT d'un objet après une hausse de $t\\%$, on divise le prix TTC par $1 + \\frac{t}{100}$.`,
+        correction: `Pour retrouver le prix HT après une hausse de  $${TVA.frenchify()}\\%$, on divise le prix TTC par :
+    
+$$
+1 + \\frac{${TVA.frenchify()}}{100} = ${(0, round_1.round)(1 + TVA / 100, 3).frenchify()}
+$$ 
+
+Le prix HT est donc : 
+
+$$
+${TTC.frenchify()} \\div ${(0, round_1.round)(1 + TVA / 100, 3).frenchify()} \\approx ${answer}
+$$
+`,
     };
     return question;
 };
@@ -32,7 +46,7 @@ const getPropositions = (n, { answer, TTC, TVA }) => {
     return (0, exercise_1.shuffleProps)(propositions, n);
 };
 const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
+    return (0, numberParser_1.numberParser)(ans) === answer;
 };
 exports.ttcToHT = {
     id: "ttcToHT",
@@ -47,4 +61,5 @@ exports.ttcToHT = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/probaStat/stats1var/averageList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"averageList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/averageList.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AA4CF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAa7C,CAAC"}
+{"version":3,"file":"averageList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/averageList.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAmEF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAc7C,CAAC"}

package/lib/exercises/math/probaStat/stats1var/averageList.js

@@ -6,6 +6,8 @@ const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQ
 const randfloat_1 = require("../../../../math/utils/random/randfloat");
 const randint_1 = require("../../../../math/utils/random/randint");
 const round_1 = require("../../../../math/utils/round");
+const addNode_1 = require("../../../../tree/nodes/operators/addNode");
+const operatorComposition_1 = require("../../../../tree/utilities/operatorComposition");
 const average_1 = require("../../../../utils/average");
 const getAverageListQuestion = () => {
     let randomValues = [];
@@ -13,7 +15,9 @@ const getAverageListQuestion = () => {
     for (let i = 0; i < length; i++)
         randomValues.push((0, randint_1.randint)(1, 20));
     const sortedValues = randomValues.sort((a, b) => a - b);
+    const avg = (0, average_1.average)(sortedValues);
     const answer = (0, round_1.round)((0, average_1.average)(sortedValues), 2).frenchify();
+    const hasRounded = avg.frenchify() !== answer;
     const question = {
         answer,
         instruction: `On considère la liste suivante : $${randomValues.join(";\\ ")}.$
@@ -21,6 +25,22 @@ const getAverageListQuestion = () => {
         keys: [],
         answerFormat: "tex",
         identifiers: { sortedValues },
+        hint: "La moyenne d'une liste de valeurs est la somme de ses valeurs divisé par le nombre de valeurs.",
+        correction: `
+On additionne toutes les valeurs :
+
+$$
+${(0, operatorComposition_1.operatorComposition)(addNode_1.AddNode, sortedValues.map((e) => e.toTree())).toTex()} = ${sortedValues.reduce((acc, curr) => acc + curr)}
+$$
+
+puis on divise par le nombre de valeurs : 
+
+$$
+${sortedValues.reduce((acc, curr) => acc + curr)}\\div ${sortedValues.length} ${hasRounded ? "\\approx" : "="} ${answer}
+$$
+
+La moyenne ${hasRounded ? "arrondie au centième" : ""} est donc $${answer}$.
+    `,
     };
     return question;
 };
@@ -49,4 +69,5 @@ exports.averageList = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/probaStat/stats1var/etendueList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"etendueList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/etendueList.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAIlC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AA2CF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAa7C,CAAC"}
+{"version":3,"file":"etendueList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/etendueList.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAIlC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAmDF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAc7C,CAAC"}

package/lib/exercises/math/probaStat/stats1var/etendueList.js

@@ -18,6 +18,14 @@ const getEtendueListQuestion = () => {
         keys: [],
         answerFormat: "tex",
         identifiers: { sortedValues },
+        hint: "L'étendue d'une liste de valeurs est la différence entre la valeur maximale et la valeur minimale.",
+        correction: `
+On calcule la différence entre la valeur maximale et la valeur minimale : 
+
+$$
+${sortedValues[sortedValues.length - 1]} - ${sortedValues[0]} = ${answer}
+$$
+    `,
     };
     return question;
 };
@@ -46,4 +54,5 @@ exports.etendueList = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    hasHintAndCorrection: true,
 };

package/lib/exercises/pc/calibrationCurveOfSolution.js

@@ -7,7 +7,7 @@ const randint_1 = require("../../math/utils/random/randint");
 const molecule_1 = require("../../pc/constants/molecularChemistry/molecule");
 const arrayEqual_1 = require("../../utils/arrayEqual");
 const random_1 = require("../../utils/random");
-const requiresApostropheBefore_1 = require("../../utils/requiresApostropheBefore");
+const requiresApostropheBefore_1 = require("../../utils/strings/requiresApostropheBefore");
 const getPointFromGGB_1 = require("../utils/geogebra/getPointFromGGB");
 const isGGBPoint_1 = require("../utils/geogebra/isGGBPoint");
 const toolBarConstructor_1 = require("../utils/geogebra/toolBarConstructor");

package/lib/exercises/pc/chemicalElements/atomicStructureOfNucleus.js

@@ -7,7 +7,7 @@ const randint_1 = require("../../../math/utils/random/randint");
 const round_1 = require("../../../math/utils/round");
 const atome_1 = require("../../../pc/constants/molecularChemistry/atome");
 const random_1 = require("../../../utils/random");
-const requiresApostropheBefore_1 = require("../../../utils/requiresApostropheBefore");
+const requiresApostropheBefore_1 = require("../../../utils/strings/requiresApostropheBefore");
 const getAtomicStructureOfNucleusQuestion = () => {
     const atom = (0, random_1.random)(atome_1.atomes.slice(0, 50));
     const mass = (0, round_1.round)(atom.masseAtomique, 0);

package/lib/exercises/pc/chemicalElements/calculateProtonsNumberFromMass.js

@@ -8,7 +8,7 @@ const round_1 = require("../../../math/utils/round");
 const atoms_1 = require("../../../pc/constants/molecularChemistry/atoms");
 const atome_1 = require("../../../pc/constants/molecularChemistry/atome");
 const random_1 = require("../../../utils/random");
-const requiresApostropheBefore_1 = require("../../../utils/requiresApostropheBefore");
+const requiresApostropheBefore_1 = require("../../../utils/strings/requiresApostropheBefore");
 const randint_1 = require("../../../math/utils/random/randint");
 const getCalculateProtonsNumberFromMassQuestion = () => {
     const atom = (0, random_1.random)(atome_1.atomes.slice(0, 50));

package/lib/exercises/pc/chemicalElements/findAtomEntitiesNumberFromMass.js

@@ -10,7 +10,7 @@ const atoms_1 = require("../../../pc/constants/molecularChemistry/atoms");
 const measure_1 = require("../../../pc/measure/measure");
 const atome_1 = require("../../../pc/constants/molecularChemistry/atome");
 const random_1 = require("../../../utils/random");
-const requiresApostropheBefore_1 = require("../../../utils/requiresApostropheBefore");
+const requiresApostropheBefore_1 = require("../../../utils/strings/requiresApostropheBefore");
 const massUnits_1 = require("../../../pc/units/massUnits");
 const getFindAtomEntitiesNumberFromMassQuestion = () => {
     const atom = (0, random_1.random)(atome_1.atomes.slice(5, 30));

package/lib/exercises/pc/chemicalElements/findAtomicStructureElement.js

@@ -7,7 +7,7 @@ const randint_1 = require("../../../math/utils/random/randint");
 const round_1 = require("../../../math/utils/round");
 const atome_1 = require("../../../pc/constants/molecularChemistry/atome");
 const random_1 = require("../../../utils/random");
-const requiresApostropheBefore_1 = require("../../../utils/requiresApostropheBefore");
+const requiresApostropheBefore_1 = require("../../../utils/strings/requiresApostropheBefore");
 const possibleElements = [
     "proton",
     "neutron",

package/lib/exercises/pc/chemicalElements/findValenceElectronsNumberFromElectronicConfiguration.js

@@ -8,7 +8,7 @@ const getElectronicConfigurationFromShells_1 = require("../../../exercises/utils
 const randint_1 = require("../../../math/utils/random/randint");
 const atome_1 = require("../../../pc/constants/molecularChemistry/atome");
 const random_1 = require("../../../utils/random");
-const requiresApostropheBefore_1 = require("../../../utils/requiresApostropheBefore");
+const requiresApostropheBefore_1 = require("../../../utils/strings/requiresApostropheBefore");
 const getFindValenceElectronsNumberFromElectronicConfigurationQuestion = () => {
     const atom = (0, random_1.random)((0, getAtoms_1.getAtoms)(3));
     const configurationTex = (0, getElectronicConfigurationFromShells_1.getElectronicConfigurationFromShells)(atom.electronsShells);

package/lib/exercises/pc/chemicalElements/findValenceElectronsNumberFromTable.js

@@ -7,7 +7,7 @@ const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQues
 const randint_1 = require("../../../math/utils/random/randint");
 const atome_1 = require("../../../pc/constants/molecularChemistry/atome");
 const random_1 = require("../../../utils/random");
-const requiresApostropheBefore_1 = require("../../../utils/requiresApostropheBefore");
+const requiresApostropheBefore_1 = require("../../../utils/strings/requiresApostropheBefore");
 const getFindValenceElectronsNumberFromTableQuestion = () => {
     const atom = (0, random_1.random)((0, getAtoms_1.getAtoms)(3));
     const instruction = `

package/lib/exercises/pc/chemicalElements/identifyRightElectronicConfiguration.js

@@ -7,7 +7,7 @@ const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQues
 const getElectronicConfigurationFromShells_1 = require("../../../exercises/utils/getElectronicConfigurationFromShells");
 const atome_1 = require("../../../pc/constants/molecularChemistry/atome");
 const random_1 = require("../../../utils/random");
-const requiresApostropheBefore_1 = require("../../../utils/requiresApostropheBefore");
+const requiresApostropheBefore_1 = require("../../../utils/strings/requiresApostropheBefore");
 const getIdentifyRightElectronicConfigurationQuestion = () => {
     const atom = (0, random_1.random)((0, getAtoms_1.getAtoms)(3).slice(2));
     const question = {

package/lib/exercises/pc/chemicalElements/massOrVolumeProportion.js

@@ -7,7 +7,7 @@ const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQues
 const random_1 = require("../../../utils/random");
 const molecule_1 = require("../../../pc/constants/molecularChemistry/molecule");
 const randfloat_1 = require("../../../math/utils/random/randfloat");
-const requiresApostropheBefore_1 = require("../../../utils/requiresApostropheBefore");
+const requiresApostropheBefore_1 = require("../../../utils/strings/requiresApostropheBefore");
 const coinFlip_1 = require("../../../utils/coinFlip");
 const round_1 = require("../../../math/utils/round");
 const getMassOrVolumeProportionQuestion = () => {

package/lib/exercises/pc/chemicalReactions/calculateCombustionEnergy.js

@@ -6,7 +6,7 @@ const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQues
 const randint_1 = require("../../../math/utils/random/randint");
 const round_1 = require("../../../math/utils/round");
 const random_1 = require("../../../utils/random");
-const requiresApostropheBefore_1 = require("../../../utils/requiresApostropheBefore");
+const requiresApostropheBefore_1 = require("../../../utils/strings/requiresApostropheBefore");
 const combustibles = [
     { name: "bois", value: 15 },
     { name: "éthanol", value: 29 },

package/lib/exercises/pc/dosage/beerLambertRandomValue.js

@@ -6,7 +6,7 @@ const exercise_1 = require("../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
 const round_1 = require("../../../math/utils/round");
 const random_1 = require("../../../utils/random");
-const requiresApostropheBefore_1 = require("../../../utils/requiresApostropheBefore");
+const requiresApostropheBefore_1 = require("../../../utils/strings/requiresApostropheBefore");
 const randfloat_1 = require("../../../math/utils/random/randfloat");
 const randint_1 = require("../../../math/utils/random/randint");
 const molecule_1 = require("../../../pc/constants/molecularChemistry/molecule");

package/lib/exercises/pc/energy/energyTransfer.js

@@ -6,7 +6,7 @@ const exercise_1 = require("../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
 const randfloat_1 = require("../../../math/utils/random/randfloat");
 const round_1 = require("../../../math/utils/round");
-const requiresApostropheBefore_1 = require("../../../utils/requiresApostropheBefore");
+const requiresApostropheBefore_1 = require("../../../utils/strings/requiresApostropheBefore");
 const substances = [
     { name: "eau", latentHeat: 334 }, // kJ/kg for melting ice
     { name: "fer", latentHeat: 276 }, // kJ/kg for melting iron

package/lib/exercises/pc/identifyAtomicMassOrAtomicNb.js

@@ -7,7 +7,7 @@ const randint_1 = require("../../math/utils/random/randint");
 const round_1 = require("../../math/utils/round");
 const coinFlip_1 = require("../../utils/coinFlip");
 const random_1 = require("../../utils/random");
-const requiresApostropheBefore_1 = require("../../utils/requiresApostropheBefore");
+const requiresApostropheBefore_1 = require("../../utils/strings/requiresApostropheBefore");
 const getAtoms_1 = require("../utils/getAtoms");
 const getIdentifyAtomicMassOrAtomicNbQuestion = () => {
     const exo = generateExercise();

package/lib/exercises/pc/mole/molarMass.js

@@ -7,7 +7,7 @@ const randfloat_1 = require("../../../math/utils/random/randfloat");
 const round_1 = require("../../../math/utils/round");
 const molecule_1 = require("../../../pc/constants/molecularChemistry/molecule");
 const random_1 = require("../../../utils/random");
-const requiresApostropheBefore_1 = require("../../../utils/requiresApostropheBefore");
+const requiresApostropheBefore_1 = require("../../../utils/strings/requiresApostropheBefore");
 const getMolarMassQuestion = () => {
     const molecule = (0, random_1.random)(molecule_1.molecules.slice(0, 50).filter((m) => m.atoms.length > 1));
     const article = (0, requiresApostropheBefore_1.requiresApostropheBefore)(molecule.name) ? "de l'" : "du ";

package/lib/exercises/pc/mole/moleculeCountFromMassAndAvogadro.js

@@ -9,7 +9,7 @@ const molecule_1 = require("../../../pc/constants/molecularChemistry/molecule");
 const random_1 = require("../../../utils/random");
 const randint_1 = require("../../../math/utils/random/randint");
 const atoms_1 = require("../../../pc/constants/molecularChemistry/atoms");
-const requiresApostropheBefore_1 = require("../../../utils/requiresApostropheBefore");
+const requiresApostropheBefore_1 = require("../../../utils/strings/requiresApostropheBefore");
 const getMoleculeCountFromMassAndAvogadroQuestion = () => {
     const molecule = (0, random_1.random)(molecule_1.molecules);
     const sampleMass = (0, randfloat_1.randfloat)(0.1, 2, 2); // Sample mass in grams

package/lib/exercises/pc/motion/motionReference.js

@@ -5,7 +5,7 @@ const exercise_1 = require("../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
 const randint_1 = require("../../../math/utils/random/randint");
 const coinFlip_1 = require("../../../utils/coinFlip");
-const requiresApostropheBefore_1 = require("../../../utils/requiresApostropheBefore");
+const requiresApostropheBefore_1 = require("../../../utils/strings/requiresApostropheBefore");
 const situations = [
     {
         object1: "avion de chasse",

package/lib/exercises/utils/geogebra/toolBarConstructor.d.ts

@@ -5,5 +5,6 @@ export declare const toolBarConstructor: (options: {
     orthogonal?: boolean;
     intersect?: boolean;
     vector?: boolean;
+    circleTwoPoints?: boolean;
 }) => string;
 //# sourceMappingURL=toolBarConstructor.d.ts.map

package/lib/exercises/utils/geogebra/toolBarConstructor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toolBarConstructor.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geogebra/toolBarConstructor.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,YAAa;IAC1C,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,WASA,CAAC"}
+{"version":3,"file":"toolBarConstructor.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geogebra/toolBarConstructor.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,YAAa;IAC1C,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B,WAUA,CAAC"}

package/lib/exercises/utils/geogebra/toolBarConstructor.js

@@ -15,6 +15,8 @@ const toolBarConstructor = (options) => {
         customToolBar += "||5";
     if (options.vector)
         customToolBar += "||7";
+    if (options.circleTwoPoints)
+        customToolBar += "||10";
     return customToolBar;
 };
 exports.toolBarConstructor = toolBarConstructor;

package/lib/exercises/utils/geometry/randomSegmentName.d.ts

@@ -0,0 +1,2 @@
+export declare const randomSegmentName: () => string;
+//# sourceMappingURL=randomSegmentName.d.ts.map

package/lib/exercises/utils/geometry/randomSegmentName.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"randomSegmentName.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geometry/randomSegmentName.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,iBAAiB,cAI7B,CAAC"}

package/lib/exercises/utils/geometry/randomSegmentName.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomSegmentName = void 0;
+const randomLetter_1 = require("../../../utils/strings/randomLetter");
+const randomSegmentName = () => {
+    const A = (0, randomLetter_1.randomLetter)(true);
+    const B = (0, randomLetter_1.randomLetter)(true, [A]);
+    return `${A}${B}`;
+};
+exports.randomSegmentName = randomSegmentName;

package/lib/geogebra/geogebraConstructor.js

@@ -18,7 +18,7 @@ class GeogebraConstructor {
         this.yAxis = options?.yAxis;
     }
     getAdaptedCoords({ xMin, xMax, yMin, yMax, zMin, zMax, forceShowAxes, }) {
-        const showAxes = forceShowAxes ?? this.hideAxes ? false : true;
+        const showAxes = forceShowAxes ?? (this.hideAxes ? false : true);
         const xDelta = xMax - xMin;
         const yDelta = yMax - yMin;
         if (this.is3D && zMin !== undefined && zMax !== undefined) {

package/lib/index.d.ts

@@ -149,6 +149,10 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     nbIds: any;
     nbValue: number;
     pow: number;
+}> | import("./exercises/exercise").Exercise<{
+    type: number;
+    a: number;
+    b: number;
 }> | import("./exercises/exercise").Exercise<{
     dec: number;
     pow: number;
@@ -808,6 +812,9 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
 }> | import("./exercises/exercise").Exercise<{
     x: number;
     y: number;
+}> | import("./exercises/exercise").Exercise<{
+    x: number;
+    y: number;
 }> | import("./exercises/exercise").Exercise<{
     coin: boolean;
     radius: number;
@@ -957,6 +964,9 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     width: number;
     height: number;
     angle: number;
+}> | import("./exercises/exercise").Exercise<{
+    A: number[];
+    B: number[];
 }> | import("./exercises/exercise").Exercise<{
     coeffs: number[];
     to: string;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAaA,OAAO,yBAAyB,CAAC;AAEjC,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAaA,OAAO,yBAAyB,CAAC;AAEjC,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}

package/lib/math/geometry/line.d.ts

@@ -10,7 +10,7 @@ export declare class Line {
     b: AlgebraicNode | undefined;
     constructor(pointA: Point, pointB: Point);
     getParallele(point: Point): Line;
-    includes(point: Point): boolean;
+    includes(point: Point, allowApprox?: boolean): boolean;
     getRandomPoint(name?: string): Point;
     getEquation: (u: Vector, a: Point) => EqualNode;
     getCartesianEquation(): EqualNode;

package/lib/math/geometry/line.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/line.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAQjE,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC,qBAAa,IAAI;IACf,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;IACd,UAAU,EAAE,OAAO,CAAC;IACpB,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;gBACjB,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK;IAkBxC,YAAY,CAAC,KAAK,EAAE,KAAK;IASzB,QAAQ,CAAC,KAAK,EAAE,KAAK;IAarB,cAAc,CAAC,IAAI,CAAC,EAAE,MAAM;IAa5B,WAAW,MAAO,MAAM,KAAK,KAAK,KAAG,SAAS,CAmB5C;IAEF,oBAAoB,IAAI,SAAS;CAsBlC"}
+{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/line.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAQjE,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC,qBAAa,IAAI;IACf,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;IACd,UAAU,EAAE,OAAO,CAAC;IACpB,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;gBACjB,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK;IAkBxC,YAAY,CAAC,KAAK,EAAE,KAAK;IASzB,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,GAAE,OAAe;IAgBnD,cAAc,CAAC,IAAI,CAAC,EAAE,MAAM;IAa5B,WAAW,MAAO,MAAM,KAAK,KAAK,KAAG,SAAS,CAmB5C;IAEF,oBAAoB,IAAI,SAAS;CAsBlC"}

package/lib/math/geometry/line.js

@@ -47,11 +47,20 @@ class Line {
         const secondPoint = new point_1.Point("D", x, y);
         return new Line(point, secondPoint);
     }
-    includes(point) {
+    includes(point, allowApprox = false) {
         if (this.isVertical) {
-            return point.x.equals(this.pointA.x);
+            if (allowApprox) {
+            }
+            else
+                return point.x.equals(this.pointA.x);
         }
-        return (new substractNode_1.SubstractNode(point.y, new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(this.a, point.x), this.b)).evaluate({}) === 0);
+        const evaluation = new substractNode_1.SubstractNode(point.y, new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(this.a, point.x), this.b)).evaluate({});
+        console.log("eval", evaluation);
+        if (allowApprox) {
+            return Math.abs(evaluation) < 0.0000001;
+        }
+        else
+            return evaluation === 0;
     }
     //! caution: simplify ne gère pas bien ici
     getRandomPoint(name) {

package/lib/math/geometry/point.d.ts

@@ -3,6 +3,7 @@ import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
 export declare abstract class PointConstructor {
     static random(name: string): Point;
     static randomDifferent(names: string[]): Point[];
+    static fromGGBCommand(str: string): Point;
 }
 export declare class Point {
     name: string;

package/lib/math/geometry/point.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/point.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAY,MAAM,uBAAuB,CAAC;AAI1D,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAI/D,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK;IAMlC,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE;CAevC;AAED,qBAAa,KAAK;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBACL,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa;IAM5D,KAAK,IAAI,MAAM;IAGf,aAAa;;;;;;;;;;IAQb,eAAe,IAAI,MAAM;IAGzB,QAAQ,IAAI,MAAM;IAIlB,UAAU,IAAI,MAAM;IAMpB,UAAU,IAAI,MAAM;IAMpB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,KAAK;IAiBrC,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM;IAM5B,MAAM,CAAC,CAAC,EAAE,KAAK,GAAG,OAAO;IAGzB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK;IAM5B,YAAY;CAKb"}
+{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/point.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAY,MAAM,uBAAuB,CAAC;AAI1D,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAI/D,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK;IAMlC,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE;IAetC,MAAM,CAAC,cAAc,CAAC,GAAG,EAAE,MAAM;CAclC;AAED,qBAAa,KAAK;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBACL,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa;IAM5D,KAAK,IAAI,MAAM;IAGf,aAAa;;;;;;;;;;IAQb,eAAe,IAAI,MAAM;IAGzB,QAAQ,IAAI,MAAM;IAIlB,UAAU,IAAI,MAAM;IAMpB,UAAU,IAAI,MAAM;IAMpB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,KAAK;IAiBrC,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM;IAM5B,MAAM,CAAC,CAAC,EAAE,KAAK,GAAG,OAAO;IAGzB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK;IAM5B,YAAY;CAKb"}