math-exercises 3.0.45 → 3.0.46

package/lib/exercises/math/calcul/arithmetics/pgcdCalcul.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pgcdCalcul.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/arithmetics/pgcdCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAqCF,eAAO,MAAM,UAAU,EAAE,QAAQ,CAAC,WAAW,CAa5C,CAAC"}
+{"version":3,"file":"pgcdCalcul.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/arithmetics/pgcdCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAgDF,eAAO,MAAM,UAAU,EAAE,QAAQ,CAAC,WAAW,CAe5C,CAAC"}

package/lib/exercises/math/calcul/arithmetics/pgcdCalcul.js

@@ -4,16 +4,25 @@ import { gcd } from "../../../../math/utils/arithmetic/gcd.js";
 import { isPrime } from "../../../../math/utils/arithmetic/isPrime.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { doWhile } from "../../../../utils/doWhile.js";
+const getInstruction = (identifiers) => {
+    const { a, b } = identifiers;
+    return `Quel est le PGCD de $${a}$ et $${b}$ ?`;
+};
+const getAnswer = (identifiers) => {
+    const { a, b } = identifiers;
+    const pgcd = gcd(a, b);
+    return pgcd + "";
+};
 const getPgcdCalculQuestion = () => {
     const a = doWhile(() => randint(30, 150), (x) => isPrime(x));
     const b = doWhile(() => randint(30, 150), (x) => x === a || gcd(a, x) === 1);
-    const pgcd = gcd(a, b);
+    const identifiers = { a, b };
     const question = {
-        answer: pgcd + "",
-        instruction: `Donner le PGCD de $${a}$ et $${b}$`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: [],
         answerFormat: "tex",
-        identifiers: { a, b },
+        identifiers,
     };
     return question;
 };
@@ -42,4 +51,6 @@ export const pgcdCalcul = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
 };

package/lib/exercises/math/calculLitteral/equation/firstDegreeEquationIntType1.js

@@ -8,6 +8,7 @@ import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
 import { FractionNode } from "../../../../tree/nodes/operators/fractionNode.js";
 import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
 import { alignTex } from "../../../../utils/latex/alignTex.js";
+//ax = b
 const getAnswer = (identifiers) => {
     const { a, b, x } = identifiers;
     const answer = new EqualNode(new VariableNode("x"), x.toTree()).toTex();

package/lib/exercises/math/calculLitteral/equation/firstDegreeEquationIntType2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"firstDegreeEquationIntType2.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/firstDegreeEquationIntType2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA8HF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAkB7D,CAAC"}
+{"version":3,"file":"firstDegreeEquationIntType2.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/firstDegreeEquationIntType2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA+HF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAkB7D,CAAC"}

package/lib/exercises/math/calculLitteral/equation/firstDegreeEquationIntType2.js

@@ -8,6 +8,7 @@ import { FractionNode } from "../../../../tree/nodes/operators/fractionNode.js";
 import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
 import { alignTex } from "../../../../utils/latex/alignTex.js";
+//ax +b = c
 const getInstruction = (identifiers) => {
     const { a, b, c, x } = identifiers;
     const equation = new EqualNode(new AddNode(new MultiplyNode(a.toTree(), new VariableNode("x")), b.toTree()).simplify({ forbidFactorize: true }), c.toTree());

package/lib/exercises/math/calculLitteral/equation/firstDegreeEquationIntType3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"firstDegreeEquationIntType3.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/firstDegreeEquationIntType3.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAkHF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAgB7D,CAAC"}
+{"version":3,"file":"firstDegreeEquationIntType3.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/firstDegreeEquationIntType3.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAoHF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAgB7D,CAAC"}

package/lib/exercises/math/calculLitteral/equation/firstDegreeEquationIntType3.js

@@ -7,6 +7,7 @@ import { AddNode } from "../../../../tree/nodes/operators/addNode.js";
 import { FractionNode } from "../../../../tree/nodes/operators/fractionNode.js";
 import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+//ax+b = cx+d
 const getInstruction = (identifiers) => {
     const { a, b, c, d, x } = identifiers;
     const equation = new EqualNode(new AddNode(new MultiplyNode(a.toTree(), new VariableNode("x")), b.toTree()).simplify({ forbidFactorize: true }), new AddNode(new MultiplyNode(c.toTree(), new VariableNode("x")), d.toTree()).simplify({ forbidFactorize: true }));

package/lib/exercises/math/conversion/lengthConversion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lengthConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/lengthConversion.ts"],"names":[],"mappings":"AAWA,OAAO,EACL,QAAQ,EAaT,MAAM,mBAAmB,CAAC;AAI3B,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,0BAA0B,EAAE,MAAM,CAAC;IACnC,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AACF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB,CAAC;AAwHF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkB3D,CAAC"}
+{"version":3,"file":"lengthConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/lengthConversion.ts"],"names":[],"mappings":"AAWA,OAAO,EACL,QAAQ,EAaT,MAAM,mBAAmB,CAAC;AAG3B,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,0BAA0B,EAAE,MAAM,CAAC;IACnC,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AACF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB,CAAC;AAuHF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgB3D,CAAC"}

package/lib/exercises/math/conversion/lengthConversion.js

@@ -32,8 +32,8 @@ const getAnswer = (identifiers, options) => {
     return answer;
 };
 const getLengthConversion = (options) => {
-    if (options && !validateOptions(options).valid)
-        throw Error("options invalides, gen lengthConversion");
+    // if (options && !validateOptions(options).valid)
+    //   throw Error("options invalides, gen lengthConversion");
     const availableUnitsIndexes = units
         .map((e, i) => i)
         .filter((i) => !options?.units?.length || options.units.includes(units[i]));
@@ -82,7 +82,7 @@ const options = [
     },
 ];
 const validateOptions = (opts) => {
-    if (opts.units.length < 2)
+    if (!opts?.units?.length || opts?.units.length < 2)
         return {
             message: "Vous devez choisir au moins deux unités.",
             valid: false,
@@ -96,8 +96,6 @@ export const lengthConversion = {
     id: "lengthConversion",
     connector: "=",
     label: "Conversion de longueurs",
-    levels: ["6ème", "5ème", "CAP", "2ndPro"],
-    sections: ["Conversions"],
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getLengthConversion(opts), nb),
     qcmTimer: 60,

package/lib/exercises/math/dataRepresentations/barChartReading.d.ts

@@ -1,7 +1,94 @@
 import { Exercise } from "../../../exercises/exercise.js";
 type Identifiers = {
-    a: number;
+    labels: string[];
+    data: number[];
+    itemAsked: number;
 };
 export declare const barChartReading: Exercise<Identifiers>;
 export {};
+/***Final version */
+/**
+ *
+ *   const newspapers = [
+    { name: "Le Figaro", sales: 320000 },
+    { name: "Les Échos", sales: 130000 },
+    { name: "La Croix", sales: 90000 },
+    { name: "L'Équipe", sales: 210000 },
+    { name: "Le Monde", sales: 330000 },
+    { name: "Le Parisien", sales: 270000 },
+    { name: "Libération", sales: 70000 },
+    { name: "L'Humanité", sales: 30000 },
+  ];
+
+  const width = 600,
+    height = 400,
+    margin = { top: 20, right: 30, bottom: 100, left: 60 };
+  const d3n = new D3Node();
+  const d3 = d3n.d3;
+
+  const svg = d3n.createSVG(width, height);
+
+  const xScale = d3
+    .scaleBand()
+    .domain(newspapers.map((d) => d.name))
+    .range([margin.left, width - margin.right])
+    .padding(0.1);
+
+  const yScale = d3
+    .scaleLinear()
+    .domain([0, d3.max(newspapers, (d: any) => d.sales)])
+    .nice()
+    .range([height - margin.bottom, margin.top]);
+
+  svg
+    .append("g")
+    .attr("transform", `translate(0,${height - margin.bottom})`)
+    .call(d3.axisBottom(xScale).tickSize(0))
+    .selectAll("text")
+    .style("text-anchor", "end")
+    .attr("transform", "rotate(-30)");
+
+  svg
+    .append("g")
+    .attr("transform", `translate(${margin.left},0)`)
+    .call(
+      d3
+        .axisLeft(yScale)
+        .ticks(5)
+        .tickFormat((d: any) =>
+          d.toString().replace(/\B(?=(\d{3})+(?!\d))/g, " "),
+        ),
+    );
+
+  svg
+    .append("text")
+    .attr("x", margin.left)
+    .attr("y", margin.top)
+    .attr("text-anchor", "start")
+    .style("font-size", "14px")
+    .style("font-weight", "bold")
+    .text("Nombre d’exemplaires vendus");
+
+  svg
+    .selectAll(".bar")
+    .data(newspapers)
+    .enter()
+    .append("rect")
+    .attr("class", "bar")
+    .attr("x", (d: any) => xScale(d.name))
+    .attr("y", (d: any) => yScale(d.sales))
+    .attr("width", xScale.bandwidth())
+    .attr("height", (d: any) => height - margin.bottom - yScale(d.sales))
+    .attr("fill", "steelblue");
+
+  const svgString = d3n.svgString();
+  return `BBteeeezfst :
+
+  ofzie
+  should read this
+${svgString}
+  should read this
+zef
+`;
+ */
 //# sourceMappingURL=barChartReading.d.ts.map

package/lib/exercises/math/dataRepresentations/barChartReading.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"barChartReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/barChartReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAsIF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAejD,CAAC"}
+{"version":3,"file":"barChartReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/barChartReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAqHF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAgBjD,CAAC;;AAgFF,oBAAoB;AACpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmFG"}

package/lib/exercises/math/dataRepresentations/barChartReading.js

@@ -1,107 +1,92 @@
-import { addValidProp, shuffleProps, } from "../../../exercises/exercise.js";
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
 import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
-//@ts-ignore
-import { D3Node } from "d3-node";
-const getPropositions = (n, { answer }) => {
+import { randint } from "../../../math/utils/random/randint.js";
+import { GeogebraConstructor } from "../../../geogebra/geogebraConstructor.js";
+import { valueParser } from "../../../tree/parsers/valueParser.js";
+import { random } from "../../../utils/alea/random.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
     const propositions = [];
+    const { labels, data, itemAsked } = identifiers;
     addValidProp(propositions, answer);
     while (propositions.length < n) {
-        throw Error("QCM not implemented");
+        tryToAddWrongProp(propositions, random(data).frenchify());
     }
     return shuffleProps(propositions, n);
 };
 const getAnswer = (identifiers) => {
-    return "";
+    const { labels, data, itemAsked } = identifiers;
+    return data[itemAsked].frenchify();
 };
 const getInstruction = (identifiers) => {
-    const newspapers = [
-        { name: "Le Figaro", sales: 320000 },
-        { name: "Les Échos", sales: 130000 },
-        { name: "La Croix", sales: 90000 },
-        { name: "L'Équipe", sales: 210000 },
-        { name: "Le Monde", sales: 330000 },
-        { name: "Le Parisien", sales: 270000 },
-        { name: "Libération", sales: 70000 },
-        { name: "L'Humanité", sales: 30000 },
-    ];
-    const width = 600, height = 400, margin = { top: 20, right: 30, bottom: 100, left: 60 };
-    const d3n = new D3Node();
-    const d3 = d3n.d3;
-    const svg = d3n.createSVG(width, height);
-    const xScale = d3
-        .scaleBand()
-        .domain(newspapers.map((d) => d.name))
-        .range([margin.left, width - margin.right])
-        .padding(0.1);
-    const yScale = d3
-        .scaleLinear()
-        .domain([0, d3.max(newspapers, (d) => d.sales)])
-        .nice()
-        .range([height - margin.bottom, margin.top]);
-    svg
-        .append("g")
-        .attr("transform", `translate(0,${height - margin.bottom})`)
-        .call(d3.axisBottom(xScale).tickSize(0))
-        .selectAll("text")
-        .style("text-anchor", "end")
-        .attr("transform", "rotate(-30)");
-    svg
-        .append("g")
-        .attr("transform", `translate(${margin.left},0)`)
-        .call(d3
-        .axisLeft(yScale)
-        .ticks(5)
-        .tickFormat((d) => d.toString().replace(/\B(?=(\d{3})+(?!\d))/g, " ")));
-    svg
-        .append("text")
-        .attr("x", margin.left)
-        .attr("y", margin.top)
-        .attr("text-anchor", "start")
-        .style("font-size", "14px")
-        .style("font-weight", "bold")
-        .text("Nombre d’exemplaires vendus");
-    svg
-        .selectAll(".bar")
-        .data(newspapers)
-        .enter()
-        .append("rect")
-        .attr("class", "bar")
-        .attr("x", (d) => xScale(d.name))
-        .attr("y", (d) => yScale(d.sales))
-        .attr("width", xScale.bandwidth())
-        .attr("height", (d) => height - margin.bottom - yScale(d.sales))
-        .attr("fill", "steelblue");
-    const svgString = d3n.svgString();
-    return `BBteeeezfst : 
+    const { labels, data, itemAsked } = identifiers;
+    return `Un producteur trie sa récolte de pommes selon leur diamètre. Le diagramme en bâtons ci-dessous représente ses résultats.
 
-  ofzie
-  should read this
-${svgString}
-  should read this
-zef
+Combien de pommes de $${labels[itemAsked]}$ cm de diamètre le producteur a-t-il récoltées ?
 `;
 };
-const getHint = (identifiers) => {
-    return "";
-};
-const getCorrection = (identifiers) => {
-    return "";
-};
+// const getHint: GetHint<Identifiers> = (identifiers) => {
+//   return "";
+// };
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
+//   return "";
+// };
 const getKeys = (identifiers) => {
     return [];
 };
 const isAnswerValid = (ans, { answer }) => {
     try {
-        throw Error("VEA not implemented");
+        const parsed = valueParser(ans);
+        if (parsed === false)
+            return false;
+        const ansNb = answer.unfrenchify();
+        return Math.abs(parsed - ansNb) < 20;
     }
     catch (err) {
         return handleVEAError(err);
     }
 };
+const getGGBOptions = (identifiers) => {
+    const { labels, data } = identifiers;
+    const commands = [
+        `B = BarChart({1,2,3,4,5}, {${data.join(",")}}, 0.5)`,
+        ...labels.map((l, i) => `Text("\\footnotesize ${l}", (${i + 1}, 0), true, true, 0, -1)`),
+        `Text("\\footnotesize Diamètre\\ (en \\ cm)", (3, -100), true, true, 0, -1)`,
+        `ShowLabel(B,false)`,
+        `SetColor(B, "#FE0045AB")`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        gridDistance: [10000, 50],
+        fontSize: 16,
+        lockedAxesRatio: 1 / 250,
+        xAxis: {
+            // hideNumbers: true,
+            showPositive: true,
+            hidden: true,
+        },
+        yAxis: {
+            showPositive: true,
+            label: "$\\footnotesize Nombre\\ de\\ pommes$",
+            steps: 100,
+        },
+    });
+    return ggb.getOptions({
+        coords: [-1, 6, -100, 1000],
+    });
+};
 const getBarChartReadingQuestion = (ops) => {
+    const data = [];
+    const labels = ["11", "12", "13", "15", "16"];
+    for (let i = 0; i < labels.length; i++) {
+        data.push(50 *
+            randint(1, 20, data.map((d) => d / 50)));
+    }
+    const itemAsked = randint(0, 5);
     const identifiers = {
-        a: Math.random(),
+        labels,
+        data,
+        itemAsked,
     };
     const question = {
         answer: getAnswer(identifiers),
@@ -109,14 +94,15 @@ const getBarChartReadingQuestion = (ops) => {
         keys: getKeys(identifiers),
         answerFormat: "tex",
         identifiers,
-        hint: getHint(identifiers),
-        correction: getCorrection(identifiers),
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
     };
     return question;
 };
 export const barChartReading = {
     id: "barChartReading",
-    label: "",
+    label: "Lecture d'un diagramme en bâtons",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getBarChartReadingQuestion(opts), nb),
     qcmTimer: 60,
@@ -125,9 +111,10 @@ export const barChartReading = {
     isAnswerValid,
     subject: "Mathématiques",
     getInstruction,
-    getHint,
-    getCorrection,
+    // getHint,
+    // getCorrection,
     getAnswer,
+    hasGeogebra: true,
 };
 // !signtable
 //  const options = { svg: true };
@@ -196,3 +183,88 @@ export const barChartReading = {
 //       text,
 //     ),
 //   );
+/***Final version */
+/**
+ *
+ *   const newspapers = [
+    { name: "Le Figaro", sales: 320000 },
+    { name: "Les Échos", sales: 130000 },
+    { name: "La Croix", sales: 90000 },
+    { name: "L'Équipe", sales: 210000 },
+    { name: "Le Monde", sales: 330000 },
+    { name: "Le Parisien", sales: 270000 },
+    { name: "Libération", sales: 70000 },
+    { name: "L'Humanité", sales: 30000 },
+  ];
+
+  const width = 600,
+    height = 400,
+    margin = { top: 20, right: 30, bottom: 100, left: 60 };
+  const d3n = new D3Node();
+  const d3 = d3n.d3;
+
+  const svg = d3n.createSVG(width, height);
+
+  const xScale = d3
+    .scaleBand()
+    .domain(newspapers.map((d) => d.name))
+    .range([margin.left, width - margin.right])
+    .padding(0.1);
+
+  const yScale = d3
+    .scaleLinear()
+    .domain([0, d3.max(newspapers, (d: any) => d.sales)])
+    .nice()
+    .range([height - margin.bottom, margin.top]);
+
+  svg
+    .append("g")
+    .attr("transform", `translate(0,${height - margin.bottom})`)
+    .call(d3.axisBottom(xScale).tickSize(0))
+    .selectAll("text")
+    .style("text-anchor", "end")
+    .attr("transform", "rotate(-30)");
+
+  svg
+    .append("g")
+    .attr("transform", `translate(${margin.left},0)`)
+    .call(
+      d3
+        .axisLeft(yScale)
+        .ticks(5)
+        .tickFormat((d: any) =>
+          d.toString().replace(/\B(?=(\d{3})+(?!\d))/g, " "),
+        ),
+    );
+
+  svg
+    .append("text")
+    .attr("x", margin.left)
+    .attr("y", margin.top)
+    .attr("text-anchor", "start")
+    .style("font-size", "14px")
+    .style("font-weight", "bold")
+    .text("Nombre d’exemplaires vendus");
+
+  svg
+    .selectAll(".bar")
+    .data(newspapers)
+    .enter()
+    .append("rect")
+    .attr("class", "bar")
+    .attr("x", (d: any) => xScale(d.name))
+    .attr("y", (d: any) => yScale(d.sales))
+    .attr("width", xScale.bandwidth())
+    .attr("height", (d: any) => height - margin.bottom - yScale(d.sales))
+    .attr("fill", "steelblue");
+
+  const svgString = d3n.svgString();
+  return `BBteeeezfst :
+
+  ofzie
+  should read this
+${svgString}
+  should read this
+zef
+`;
+ */

package/lib/exercises/math/dataRepresentations/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./tableReading.js";
+export * from "./barChartReading.js";
 export * from "./functionGraphReading.js";
 export * from "./pieChartReading.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAElC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sBAAsB,CAAC"}

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

@@ -1,5 +1,5 @@
 export * from "./tableReading.js";
-// export * from "./barChartReading.js";
+export * from "./barChartReading.js";
 export * from "./functionGraphReading.js";
 export * from "./pieChartReading.js";
 // export * from "./testGen.js";

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

@@ -20,7 +20,7 @@ const getVectorLinearCombinationQuestion = () => {
         y: v.y.simplify().evaluate(),
     };
     const instruction = `Soient deux vecteurs $${u.toTexWithCoords()}$ et $${v.toTexWithCoords()}$. 
-  Calculer les coordonnées du vecteur $${getAddVectorTex(getMultiplyVectorTex(a, u), getMultiplyVectorTex(b, v))}$`;
+  Calculer les coordonnées du vecteur $${getAddVectorTex(getMultiplyVectorTex(a, u), getMultiplyVectorTex(b, v))}$.`;
     const aUPlusBv = calculateLinearCombination(a, b, u, v);
     const correctAnswer = new Vector("au+bv", aUPlusBv.x, aUPlusBv.y);
     const question = {

package/lib/exercises/math/limits/sequenceGeometricLimit.d.ts

@@ -1,7 +1,8 @@
 import { Exercise } from "../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../tree/nodes/nodeConstructor.js";
 type Identifiers = {
-    reason: string;
-    firstTerm: string;
+    reason: NodeIdentifiers;
+    firstTerm: NodeIdentifiers;
 };
 export declare const sequenceGeometricLimit: Exercise<Identifiers>;
 export {};

package/lib/exercises/math/limits/sequenceGeometricLimit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sequenceGeometricLimit.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/limits/sequenceGeometricLimit.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAIrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA6CF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}
+{"version":3,"file":"sequenceGeometricLimit.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/limits/sequenceGeometricLimit.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAE7C,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,eAAe,CAAC;IACxB,SAAS,EAAE,eAAe,CAAC;CAC5B,CAAC;AA6DF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}

package/lib/exercises/math/limits/sequenceGeometricLimit.js

@@ -1,22 +1,34 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
-import { GeometricSequenceConstructor } from "../../../math/sequences/geometricSequence.js";
+import { GeometricSequence, GeometricSequenceConstructor, } from "../../../math/sequences/geometricSequence.js";
+import { reifyAlgebraic, } from "../../../tree/nodes/nodeConstructor.js";
+const getInstruction = (identifiers) => {
+    const { reason, firstTerm } = identifiers;
+    const sequence = new GeometricSequence(reifyAlgebraic(firstTerm), reifyAlgebraic(reason));
+    return `Déterminer la limite de la suite $u$ définie par : 
+  
+$$
+u_n = ${sequence.toTree().toTex()}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { reason, firstTerm } = identifiers;
+    const sequence = new GeometricSequence(reifyAlgebraic(firstTerm), reifyAlgebraic(reason));
+    const answer = sequence.getLimit();
+    return answer.toTex();
+};
 const getSequenceGeometricLimitQuestion = () => {
     const sequence = GeometricSequenceConstructor.randomWithLimit();
-    const answer = sequence.getLimit();
-    if (!answer)
-        throw Error("received geometric sequence with no limit");
+    const identifiers = {
+        reason: sequence.reason.toIdentifiers(),
+        firstTerm: sequence.firstTerm.toIdentifiers(),
+    };
     const question = {
-        answer: answer,
-        instruction: `Déterminer la limite de la suite $u$ définie par : $u_n = ${sequence
-            .toTree()
-            .toTex()}$.`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: ["infty"],
         answerFormat: "tex",
-        identifiers: {
-            reason: sequence.reason.toTree().toTex(),
-            firstTerm: sequence.firstTerm.toTree().toTex(),
-        },
+        identifiers,
     };
     return question;
 };
@@ -26,8 +38,8 @@ const getPropositions = (n, { answer, reason, firstTerm }) => {
     tryToAddWrongProp(propositions, "+\\infty");
     tryToAddWrongProp(propositions, "-\\infty");
     tryToAddWrongProp(propositions, "0");
-    tryToAddWrongProp(propositions, reason + "");
-    tryToAddWrongProp(propositions, firstTerm + "");
+    tryToAddWrongProp(propositions, reifyAlgebraic(reason).toTex());
+    tryToAddWrongProp(propositions, reifyAlgebraic(firstTerm).toTex());
     return shuffleProps(propositions, n);
 };
 const isAnswerValid = (ans, { answer }) => {
@@ -37,13 +49,13 @@ export const sequenceGeometricLimit = {
     id: "sequenceGeometricLimit",
     connector: "=",
     label: "Limite d'une suite géométrique",
-    levels: ["TermSpé", "MathComp"],
     isSingleStep: true,
-    sections: ["Limites", "Suites"],
     generator: (nb) => getDistinctQuestions(getSequenceGeometricLimitQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"valuePercent.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/valuePercent.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAyCF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAc9C,CAAC"}
+{"version":3,"file":"valuePercent.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/valuePercent.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA4DF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAgB9C,CAAC"}

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

@@ -3,22 +3,38 @@ import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuesti
 import { DecimalConstructor } from "../../../math/numbers/decimals/decimal.js";
 import { randint } from "../../../math/utils/random/randint.js";
 import { round } from "../../../math/utils/round.js";
+const getInstruction = (identifiers) => {
+    const { percent, nb } = identifiers;
+    return `Calculer $${percent}\\%$ de $${nb}$.`;
+};
+const getAnswer = (identifiers) => {
+    const { percent, nb } = identifiers;
+    const ans = round((percent * nb) / 100, 2).frenchify();
+    return ans;
+};
+const getHint = (identifiers) => {
+    return `Pour calculer $x\\%$ d'un nombre, on le multiplie par $\\frac{x}{100}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { percent, nb } = identifiers;
+    return `Pour calculer $${percent}\\%$ de $${nb}$, on multiplie $${nb}$ par $\\frac{${percent}}{100}$ : 
+    
+$$
+${nb}\\times \\frac{${percent}}{100} = ${getAnswer(identifiers)}
+$$`;
+};
 const getValuePercentQuestion = () => {
     const percent = randint(1, 100);
     const nb = randint(1, 100);
-    const ans = round((percent * nb) / 100, 2).frenchify();
+    const identifiers = { percent, nb };
     const question = {
-        answer: ans + "",
-        instruction: `Calculer $${percent}\\%$ de $${nb}$.`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: [],
         answerFormat: "tex",
-        identifiers: { percent, nb },
-        hint: `Pour calculer $x\\%$ d'un nombre, on le multiplie par $\\frac{x}{100}$.`,
-        correction: `Pour calculer $${percent}\\%$ de $${nb}$, on multiplie $${nb}$ par $\\frac{${percent}}{100}$ : 
-    
-$
-${nb}\\times \\frac{${percent}}{100} = ${ans}
-$`,
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -37,9 +53,7 @@ export const valuePercent = {
     id: "valuePercent",
     connector: "=",
     label: "Appliquer un pourcentage",
-    levels: ["3ème", "2ndPro", "2nde", "1reESM", "1rePro"],
     isSingleStep: true,
-    sections: ["Pourcentages"],
     generator: (nb) => getDistinctQuestions(getValuePercentQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -47,4 +61,8 @@ export const valuePercent = {
     isAnswerValid,
     subject: "Mathématiques",
     hasHintAndCorrection: true,
+    getAnswer,
+    getInstruction,
+    getCorrection,
+    getHint,
 };

package/lib/exercises/math/spaceGeometry/vectors/spaceVectorCoordinatesFromPoints.d.ts

@@ -1,5 +1,12 @@
 import { Exercise } from "../../../../exercises/exercise.js";
-type Identifiers = {};
+type Identifiers = {
+    ax: number;
+    ay: number;
+    az: number;
+    bx: number;
+    by: number;
+    bz: number;
+};
 export declare const spaceVectorCoordinatesFromPoints: Exercise<Identifiers>;
 export {};
 //# sourceMappingURL=spaceVectorCoordinatesFromPoints.d.ts.map

package/lib/exercises/math/spaceGeometry/vectors/spaceVectorCoordinatesFromPoints.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spaceVectorCoordinatesFromPoints.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/vectors/spaceVectorCoordinatesFromPoints.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG,EAAE,CAAC;AAqEtB,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAgBlE,CAAC"}
+{"version":3,"file":"spaceVectorCoordinatesFromPoints.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/vectors/spaceVectorCoordinatesFromPoints.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAuGF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAkBlE,CAAC"}

package/lib/exercises/math/spaceGeometry/vectors/spaceVectorCoordinatesFromPoints.js

@@ -4,37 +4,69 @@ import { SpacePointConstructor } from "../../../../math/geometry/spacePoint.js";
 import { SpaceVectorConstructor, } from "../../../../math/geometry/spaceVector.js";
 import { SubstractNode } from "../../../../tree/nodes/operators/substractNode.js";
 import { alignTex } from "../../../../utils/latex/alignTex.js";
-const getSpaceVectorCoordinatesFromPointsQuestion = () => {
-    const points = SpacePointConstructor.randomDifferent(["A", "B"]);
+const getInstruction = (identifiers) => {
+    const { ax, ay, az, bx, by, bz } = identifiers;
+    const points = [
+        SpacePointConstructor.fromScalars([ax, ay, az], "A"),
+        SpacePointConstructor.fromScalars([bx, by, bz], "B"),
+    ];
+    const vector = SpaceVectorConstructor.fromPoints(points[0], points[1]);
+    return `Soit deux points de l'espace $${points[0].toTexWithCoords()}$ et $${points[1].toTexWithCoords()}$. 
+  
+Quelles sont les coordonnées du vecteur $\\overrightarrow{AB}$ ?`;
+};
+const getAnswer = (identifiers) => {
+    const { ax, ay, az, bx, by, bz } = identifiers;
+    const points = [
+        SpacePointConstructor.fromScalars([ax, ay, az], "A"),
+        SpacePointConstructor.fromScalars([bx, by, bz], "B"),
+    ];
     const vector = SpaceVectorConstructor.fromPoints(points[0], points[1]);
     const answer = vector.toInlineCoordsTex();
-    const question = {
-        answer,
-        instruction: `Soit deux points $${points[0].toTexWithCoords()}$ et $${points[1].toTexWithCoords()}$. Quelles sont les coordonnées du vecteur $\\overrightarrow{AB}$ ?`,
-        keys: ["semicolon"],
-        answerFormat: "tex",
-        identifiers: {
-            ax: points[0].x.evaluate({}),
-            ay: points[0].y.evaluate({}),
-            az: points[0].z.evaluate({}),
-            bx: points[1].x.evaluate({}),
-            by: points[1].y.evaluate({}),
-            bz: points[1].z.evaluate({}),
-        },
-        hint: `Soient deux points $M(x_M;y_M;z_M)$ et $N(x_N;y_N;z_N)$, alors le vecteur $\\overrightarrow{MN}$ a pour coordonnées :
+    return answer;
+};
+const getHint = (identifiers) => {
+    return `Soient deux points $M(x_M;y_M;z_M)$ et $N(x_N;y_N;z_N)$, alors le vecteur $\\overrightarrow{MN}$ a pour coordonnées :
     
 $$
 \\overrightarrow{MN} \\begin{pmatrix} x_N - x_M \\\\ y_N - y_M \\\\ z_N - z_M \\end{pmatrix}
-$$`,
-        correction: `Les coordonnées du vecteur $\\overrightarrow{AB}$ sont : 
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { ax, ay, az, bx, by, bz } = identifiers;
+    const points = [
+        SpacePointConstructor.fromScalars([ax, ay, az]),
+        SpacePointConstructor.fromScalars([bx, by, bz]),
+    ];
+    const vector = SpaceVectorConstructor.fromPoints(points[0], points[1]);
+    return `Les coordonnées du vecteur $\\overrightarrow{AB}$ sont : 
 
 ${alignTex([
-            [
-                `\\begin{pmatrix} ${new SubstractNode(points[1].x, points[0].x).toTex()} \\\\ ${new SubstractNode(points[1].y, points[0].y).toTex()} \\\\ ${new SubstractNode(points[1].z, points[0].z).toTex()} \\end{pmatrix}`,
-                "=",
-                vector.toCoordsTex(),
-            ],
-        ])}`,
+        [
+            `\\begin{pmatrix} ${new SubstractNode(points[1].x, points[0].x).toTex()} \\\\ ${new SubstractNode(points[1].y, points[0].y).toTex()} \\\\ ${new SubstractNode(points[1].z, points[0].z).toTex()} \\end{pmatrix}`,
+            "=",
+            vector.toCoordsTex(),
+        ],
+    ])}`;
+};
+const getSpaceVectorCoordinatesFromPointsQuestion = () => {
+    const points = SpacePointConstructor.randomDifferent(["A", "B"]);
+    const identifiers = {
+        ax: points[0].x.evaluate({}),
+        ay: points[0].y.evaluate({}),
+        az: points[0].z.evaluate({}),
+        bx: points[1].x.evaluate({}),
+        by: points[1].y.evaluate({}),
+        bz: points[1].z.evaluate({}),
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["semicolon"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -53,9 +85,7 @@ export const spaceVectorCoordinatesFromPoints = {
     id: "spaceVectorCoordinatesFromPoints",
     connector: "=",
     label: "Déterminer les coordonnées d'un vecteur à partir de deux points (dans l'espace)",
-    levels: [],
     isSingleStep: true,
-    sections: [],
     generator: (nb) => getDistinctQuestions(getSpaceVectorCoordinatesFromPointsQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -63,4 +93,8 @@ export const spaceVectorCoordinatesFromPoints = {
     isAnswerValid,
     subject: "Mathématiques",
     hasHintAndCorrection: true,
+    getAnswer,
+    getInstruction,
+    getCorrection,
+    getHint,
 };

package/lib/exercises/math/spaceGeometry/vectors/spaceVectorLinearCombinationCoords.d.ts

@@ -1,5 +1,14 @@
 import { Exercise } from "../../../../exercises/exercise.js";
-type Identifiers = {};
+type Identifiers = {
+    a: number;
+    b: number;
+    ux: number;
+    uy: number;
+    uz: number;
+    vx: number;
+    vy: number;
+    vz: number;
+};
 export declare const spaceVectorLinearCombinationCoords: Exercise<Identifiers>;
 export {};
 //# sourceMappingURL=spaceVectorLinearCombinationCoords.d.ts.map

package/lib/exercises/math/spaceGeometry/vectors/spaceVectorLinearCombinationCoords.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spaceVectorLinearCombinationCoords.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/vectors/spaceVectorLinearCombinationCoords.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG,EAAE,CAAC;AA2DtB,eAAO,MAAM,kCAAkC,EAAE,QAAQ,CAAC,WAAW,CAepE,CAAC"}
+{"version":3,"file":"spaceVectorLinearCombinationCoords.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/vectors/spaceVectorLinearCombinationCoords.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA4EF,eAAO,MAAM,kCAAkC,EAAE,QAAQ,CAAC,WAAW,CAepE,CAAC"}

package/lib/exercises/math/spaceGeometry/vectors/spaceVectorLinearCombinationCoords.js

@@ -6,29 +6,44 @@ import { randint } from "../../../../math/utils/random/randint.js";
 import { AddNode } from "../../../../tree/nodes/operators/addNode.js";
 import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
 // coords de au + bv en 3D
-const getSpaceVectorLinearCombinationCoordsQuestion = () => {
-    const a = randint(-10, 11, [0]);
-    const b = randint(-10, 11, [0]);
-    const [u, v] = SpaceVectorConstructor.randomDifferents(["u", "v"], false);
+const getInstruction = (identifiers) => {
+    const { a, b, ux, uy, uz, vx, vy, vz } = identifiers;
+    const u = SpaceVectorConstructor.fromScalars([ux, uy, uz], "u");
+    const v = SpaceVectorConstructor.fromScalars([vx, vy, vz], "v");
+    return `Soit deux vecteurs de l'espace $${u.toTexWithCoords()}$ et $${v.toTexWithCoords()}$. 
+  
+Calculer les coordonnées du vecteur $${new AddNode(new MultiplyNode(a.toTree(), u.toTex().toTree()), new MultiplyNode(b.toTree(), v.toTex().toTree())).toTex()}$.`;
+};
+const getAnswer = (identifiers) => {
+    const { a, b, ux, uy, uz, vx, vy, vz } = identifiers;
+    const u = SpaceVectorConstructor.fromScalars([ux, uy, uz], "u");
+    const v = SpaceVectorConstructor.fromScalars([vx, vy, vz], "v");
     const answer = u
         .times(a.toTree())
         .add(v.times(b.toTree()))
         .toInlineCoordsTex();
+    return answer;
+};
+const getSpaceVectorLinearCombinationCoordsQuestion = () => {
+    const a = randint(-10, 11, [0]);
+    const b = randint(-10, 11, [0]);
+    const [u, v] = SpaceVectorConstructor.randomDifferents(["u", "v"], false);
+    const identifiers = {
+        a,
+        b,
+        ux: u.x.evaluate({}),
+        uy: u.y.evaluate({}),
+        uz: u.z.evaluate({}),
+        vx: v.x.evaluate({}),
+        vy: v.y.evaluate({}),
+        vz: v.z.evaluate({}),
+    };
     const question = {
-        answer,
-        instruction: `Soit deux vecteurs $${u.toTexWithCoords()}$ et $${v.toTexWithCoords()}$. Calculer les coordonnées du vecteur $${new AddNode(new MultiplyNode(a.toTree(), u.toTex().toTree()), new MultiplyNode(b.toTree(), v.toTex().toTree())).toTex()}$`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: ["semicolon"],
         answerFormat: "tex",
-        identifiers: {
-            a,
-            b,
-            ux: u.x.evaluate({}),
-            uy: u.y.evaluate({}),
-            uz: u.z.evaluate({}),
-            vx: v.x.evaluate({}),
-            vy: v.y.evaluate({}),
-            vz: v.z.evaluate({}),
-        },
+        identifiers,
     };
     return question;
 };
@@ -46,14 +61,14 @@ const isAnswerValid = (ans, { answer }) => {
 export const spaceVectorLinearCombinationCoords = {
     id: "spaceVectorLinearCombinationCoords",
     connector: "=",
-    label: "Calcul des coordonnées du vecteur $a\\overrightarrow{u} + b\\overrightarrow{v}$ (dans l'espace)",
-    levels: [],
+    label: "Calculer les coordonnées du vecteur $a\\overrightarrow{u} + b\\overrightarrow{v}$ (dans l'espace)",
     isSingleStep: true,
-    sections: [],
     generator: (nb) => getDistinctQuestions(getSpaceVectorLinearCombinationCoordsQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
 };

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

@@ -23,7 +23,7 @@ const getConcentrationReadingQuestion = () => {
         instruction: `On trace la courbe d'étalonnage ci-dessous. L'absorbance d'ue solution est $A = ${absorbtion}$. Quelle est la concentration en espèce colorée de cette solution ?`,
         keys: [],
         answerFormat: "tex",
-        identifiers: {},
+        identifiers: { absorbtion, concentration },
         ggbOptions: ggb.getOptions({
             coords: [-1, concentration + 2, -1, absorbtion + 2],
         }),

package/lib/index.d.ts

@@ -1339,8 +1339,8 @@ declare const mathExercises: (Exercise<{
     numCoeffs: number[];
     denumCoeffs: number[];
 }, {}> | Exercise<{
-    reason: string;
-    firstTerm: string;
+    reason: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    firstTerm: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, {}> | Exercise<{
     coeffs: number[];
 }, {}> | Exercise<{
@@ -1756,7 +1756,23 @@ declare const mathExercises: (Exercise<{
     x: number;
     y: number;
     z: number;
-}, {}> | Exercise<{}, {}> | Exercise<{}, {}> | Exercise<{
+}, {}> | Exercise<{
+    ax: number;
+    ay: number;
+    az: number;
+    bx: number;
+    by: number;
+    bz: number;
+}, {}> | Exercise<{
+    a: number;
+    b: number;
+    ux: number;
+    uy: number;
+    uz: number;
+    vx: number;
+    vy: number;
+    vz: number;
+}, {}> | Exercise<{
     l: number;
     L: number;
     h: number;
@@ -1914,6 +1930,10 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     values: number[][];
     caseAsked: number;
+}, {}> | Exercise<{
+    labels: string[];
+    data: number[];
+    itemAsked: number;
 }, {}> | Exercise<{
     isAskingX: boolean;
     xValue?: number;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

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

@@ -5,7 +5,7 @@ export declare abstract class SpaceVectorConstructor {
     static fromPoints(origin: SpacePoint, end: SpacePoint): SpaceVector;
     static random(name: string, allowNull?: boolean): SpaceVector;
     static randomDifferents(names: string[], allowNull?: boolean): SpaceVector[];
-    static fromScalars(arr: number[]): SpaceVector;
+    static fromScalars(arr: number[], name?: string): SpaceVector;
 }
 export declare class SpaceVector {
     name: string;

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

@@ -1 +1 @@
-{"version":3,"file":"spaceVector.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/spaceVector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAElE,OAAO,EAAE,IAAI,EAAY,MAAM,0BAA0B,CAAC;AAY1D,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,8BAAsB,sBAAsB;IAC1C,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,GAAG,WAAW;IAQnE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,UAAQ,GAAG,WAAW;IAY3D,MAAM,CAAC,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,SAAS,UAAQ,GAAG,WAAW,EAAE;IAW1E,MAAM,CAAC,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE;CAWjC;AAED,qBAAa,WAAW;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBAEf,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa;IAQlB,SAAS;IAGT,kBAAkB;IAGlB,KAAK,IAAI,MAAM;IAIf,WAAW,IAAI,MAAM;IAGrB,iBAAiB,IAAI,MAAM;IAK3B,eAAe,IAAI,MAAM;IAMzB,eAAe,CAAC,CAAC,EAAE,WAAW,GAAG,WAAW;IAiB5C,UAAU,CAAC,CAAC,EAAE,WAAW,GAAG,OAAO;IAMnC,UAAU,CAAC,CAAC,EAAE,WAAW,GAAG,OAAO;IAGnC,WAAW,CAAC,CAAC,EAAE,WAAW,GAAG,aAAa;IAI1C,KAAK,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAQrC,aAAa,CAAC,CAAC,EAAE,WAAW,GAAG,IAAI;IAInC,GAAG,CAAC,CAAC,EAAE,WAAW,GAAG,WAAW;IAShC,OAAO,IAAI,aAAa;IAYxB,WAAW,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,CAAC,EAAE,MAAM;IAQjD,MAAM,CAAC,CAAC,EAAE,WAAW;CAGtB"}
+{"version":3,"file":"spaceVector.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/spaceVector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAElE,OAAO,EAAE,IAAI,EAAY,MAAM,0BAA0B,CAAC;AAY1D,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,8BAAsB,sBAAsB;IAC1C,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,GAAG,WAAW;IAQnE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,UAAQ,GAAG,WAAW;IAY3D,MAAM,CAAC,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,SAAS,UAAQ,GAAG,WAAW,EAAE;IAW1E,MAAM,CAAC,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,CAAC,EAAE,MAAM;CAWhD;AAED,qBAAa,WAAW;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBAEf,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa;IAQlB,SAAS;IAGT,kBAAkB;IAGlB,KAAK,IAAI,MAAM;IAIf,WAAW,IAAI,MAAM;IAGrB,iBAAiB,IAAI,MAAM;IAK3B,eAAe,IAAI,MAAM;IAMzB,eAAe,CAAC,CAAC,EAAE,WAAW,GAAG,WAAW;IAiB5C,UAAU,CAAC,CAAC,EAAE,WAAW,GAAG,OAAO;IAMnC,UAAU,CAAC,CAAC,EAAE,WAAW,GAAG,OAAO;IAGnC,WAAW,CAAC,CAAC,EAAE,WAAW,GAAG,aAAa;IAI1C,KAAK,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAQrC,aAAa,CAAC,CAAC,EAAE,WAAW,GAAG,IAAI;IAInC,GAAG,CAAC,CAAC,EAAE,WAAW,GAAG,WAAW;IAShC,OAAO,IAAI,aAAa;IAYxB,WAAW,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,CAAC,EAAE,MAAM;IAQjD,MAAM,CAAC,CAAC,EAAE,WAAW;CAGtB"}

package/lib/math/geometry/spaceVector.js

@@ -32,11 +32,11 @@ export class SpaceVectorConstructor {
         }
         return res;
     }
-    static fromScalars(arr) {
+    static fromScalars(arr, name) {
         if (arr.length !== 3) {
             throw new Error("array must have 3 elements");
         }
-        return new SpaceVector("P", new NumberNode(arr[0]), new NumberNode(arr[1]), new NumberNode(arr[2]));
+        return new SpaceVector(name ?? "P", new NumberNode(arr[0]), new NumberNode(arr[1]), new NumberNode(arr[2]));
     }
 }
 export class SpaceVector {

package/lib/math/sequences/geometricSequence.d.ts

@@ -1,14 +1,16 @@
+import { AlgebraicNode } from "../../tree/nodes/algebraicNode.js";
+import { NumberNode } from "../../tree/nodes/numbers/numberNode.js";
 import { MultiplyNode } from "../../tree/nodes/operators/multiplyNode.js";
-import { Nombre, NumberType } from "../numbers/nombre.js";
+import { NumberType } from "../numbers/nombre.js";
 export declare abstract class GeometricSequenceConstructor {
     static random(reasonType?: NumberType): GeometricSequence;
     static randomWithLimit(reasonType?: NumberType): GeometricSequence;
 }
 export declare class GeometricSequence {
-    firstTerm: Nombre;
-    reason: Nombre;
-    constructor(firstTerm: Nombre, reason: Nombre);
-    getLimit(): string | null;
+    firstTerm: AlgebraicNode;
+    reason: AlgebraicNode;
+    constructor(firstTerm: AlgebraicNode, reason: AlgebraicNode);
+    getLimit(): AlgebraicNode | import("../../tree/nodes/numbers/constantNode.js").ConstantNode | NumberNode;
     toTree(): MultiplyNode;
 }
 //# sourceMappingURL=geometricSequence.d.ts.map

package/lib/math/sequences/geometricSequence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometricSequence.d.ts","sourceRoot":"","sources":["../../../src/math/sequences/geometricSequence.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,4CAA4C,CAAC;AAO1E,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAI1D,8BAAsB,4BAA4B;IAChD,MAAM,CAAC,MAAM,CAAC,UAAU,GAAE,UAA+B;IAoBzD,MAAM,CAAC,eAAe,CAAC,UAAU,CAAC,EAAE,UAAU;CA2B/C;AAED,qBAAa,iBAAiB;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;gBAEH,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAK7C,QAAQ;IAOR,MAAM;CASP"}
+{"version":3,"file":"geometricSequence.d.ts","sourceRoot":"","sources":["../../../src/math/sequences/geometricSequence.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAKlE,OAAO,EAAE,UAAU,EAAE,MAAM,wCAAwC,CAAC;AACpE,OAAO,EAAE,YAAY,EAAE,MAAM,4CAA4C,CAAC;AAK1E,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAKlD,8BAAsB,4BAA4B;IAChD,MAAM,CAAC,MAAM,CAAC,UAAU,GAAE,UAA+B;IAoBzD,MAAM,CAAC,eAAe,CAAC,UAAU,CAAC,EAAE,UAAU;CAuB/C;AAED,qBAAa,iBAAiB;IAC5B,SAAS,EAAE,aAAa,CAAC;IACzB,MAAM,EAAE,aAAa,CAAC;gBAEV,SAAS,EAAE,aAAa,EAAE,MAAM,EAAE,aAAa;IAK3D,QAAQ;IAYR,MAAM;CASP"}

package/lib/math/sequences/geometricSequence.js

@@ -1,12 +1,12 @@
+import { MinusInfinityNode, PlusInfinityNode, } from "../../tree/nodes/numbers/infiniteNode.js";
 import { MultiplyNode } from "../../tree/nodes/operators/multiplyNode.js";
 import { PowerNode } from "../../tree/nodes/operators/powerNode.js";
 import { VariableNode } from "../../tree/nodes/variables/variableNode.js";
 import { coinFlip } from "../../utils/alea/coinFlip.js";
 import { random } from "../../utils/alea/random.js";
-import { DecimalConstructor } from "../numbers/decimals/decimal.js";
-import { Integer } from "../numbers/integer/integer.js";
 import { NumberType } from "../numbers/nombre.js";
 import { RationalConstructor } from "../numbers/rationals/rational.js";
+import { randfloat } from "../utils/random/randfloat.js";
 import { randint } from "../utils/random/randint.js";
 export class GeometricSequenceConstructor {
     static random(reasonType = NumberType.Integer) {
@@ -15,18 +15,18 @@ export class GeometricSequenceConstructor {
             random([NumberType.Decimal, NumberType.Integer, NumberType.Rational]);
         switch (type) {
             case NumberType.Decimal:
-                reason = DecimalConstructor.random(-9, 10);
+                reason = randfloat(-9, 10, 2).toTree();
                 break;
             case NumberType.Integer:
-                reason = new Integer(randint(-9, 10, [0, 1]));
+                reason = randint(-9, 10, [0, 1]).toTree();
                 break;
             case NumberType.Rational:
-                reason = RationalConstructor.randomIrreductible();
+                reason = RationalConstructor.randomIrreductible().toTree();
                 break;
             case NumberType.Real:
                 throw Error("real geometric reason not supported yet");
         }
-        return new GeometricSequence(new Integer(randint(-9, 10, [0, 1])), reason);
+        return new GeometricSequence(randint(-9, 10, [0, 1]).toTree(), reason);
     }
     static randomWithLimit(reasonType) {
         let reason;
@@ -34,21 +34,20 @@ export class GeometricSequenceConstructor {
             random([NumberType.Decimal, NumberType.Integer, NumberType.Rational]);
         switch (type) {
             case NumberType.Decimal:
-                const precision = randint(1, 4);
                 reason = coinFlip()
-                    ? DecimalConstructor.fromParts(coinFlip() ? "0" : "-0", DecimalConstructor.randomFracPart(precision))
-                    : DecimalConstructor.random(1, 10);
+                    ? randfloat(-0.9999, 1, 2).toTree()
+                    : randfloat(1.01, 10, 2).toTree();
                 break;
             case NumberType.Integer:
-                reason = new Integer(randint(2, 10, [0, 1]));
+                reason = randint(2, 10, [0, 1]).toTree();
                 break;
             case NumberType.Rational:
-                reason = RationalConstructor.randomIrreductible();
+                reason = RationalConstructor.randomIrreductible().toTree();
                 break;
             case NumberType.Real:
                 throw Error("real geometric reason not supported yet");
         }
-        return new GeometricSequence(new Integer(randint(-9, 10, [0, 1])), reason);
+        return new GeometricSequence(randint(-9, 10, [0, 1]).toTree(), reason);
     }
 }
 export class GeometricSequence {
@@ -59,16 +58,21 @@ export class GeometricSequence {
         this.reason = reason;
     }
     getLimit() {
-        if (this.reason.value <= -1)
-            return null;
-        if (this.reason.value === 1)
-            return this.firstTerm + "";
-        if (this.reason.value > 1)
-            return this.firstTerm.value > 0 ? "+\\infty" : "-\\infty";
-        return "0";
+        if (!this.reason.isNumeric)
+            throw new Error("unimplemented geometric limit");
+        const reason = this.reason.evaluate();
+        if (reason <= -1)
+            throw new Error("no limit");
+        if (reason === 1)
+            return this.firstTerm;
+        if (reason > 1) {
+            const ev = this.firstTerm.evaluate();
+            return ev > 0 ? PlusInfinityNode : MinusInfinityNode;
+        }
+        return (0).toTree();
     }
     toTree() {
-        return new MultiplyNode(this.firstTerm.toTree(), new PowerNode(this.reason.toTree(), new VariableNode("n")), {
+        return new MultiplyNode(this.firstTerm, new PowerNode(this.reason, new VariableNode("n")), {
             forceTimesSign: true,
         });
     }

package/lib/playground.js

@@ -4,6 +4,6 @@ export const playground = () => {
     // const tex = "3\\%";
     // console.log(parseAlgebraic(tex).simplify({}).toTex());
     const x = multiply(3, substract("x", 9));
-    console.log(x.simplify().toTex());
-    console.log(x.equals(x.simplify()));
+    // console.log(x.simplify().toTex());
+    // console.log(x.equals(x.simplify()));
 };

package/lib/tests/questionTest.js

@@ -29,7 +29,7 @@ export const questionTest = (exo, question) => {
             throw new Error(`exo ${exo.id} has hint or correction but not hasHintAndCorr`);
         }
     }
-    if (!question.identifiers)
+    if (!question.identifiers || !Object.keys(question.identifiers).length)
         throw new Error(`exo ${exo.id} has no identifiers`);
     const dotDecimalPattern = /\d+\.\d+/;
     if (question.studentGgbOptions?.coords?.length) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "math-exercises",
   "type": "module",
-  "version": "3.0.45",
+  "version": "3.0.46",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [