math-exercises 3.0.23 → 3.0.24

package/lib/exercises/math/calculLitteral/distributivity/secondIdentity.js

@@ -39,7 +39,7 @@ const getHint = (identifiers) => {
 
 $$
 (a-b)^2 = a^2 - 2ab+b^2
-$$ 
+$$
 
 en prenant $a=${aMonom.toTex()}$ et $b=${bPositive}$`;
 };

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

@@ -6,4 +6,108 @@ type Identifiers = {
 };
 export declare const functionGraphReading: Exercise<Identifiers>;
 export {};
+/***SVG */
+/**
+
+  const width = 600;
+  const height = 300;
+  const margin = { top: 20, right: 20, bottom: 40, left: 50 };
+  const d3n = new D3Node();
+  const d3 = d3n.d3;
+
+  const svg = d3n.createSVG(width, height);
+
+  const xScale = d3
+    .scaleLinear()
+    .domain([0, 60])
+    .range([margin.left, width - margin.right]);
+
+  const yScale = d3
+    .scaleLinear()
+    .domain([0, 8000])
+    .range([height - margin.bottom, margin.top]);
+
+  const xAxis = d3.axisBottom(xScale).ticks(30).tickValues(d3.range(0, 61, 2));
+  const yAxis = d3
+    .axisLeft(yScale)
+    .ticks(16)
+    .tickValues(d3.range(0, 8500, 500));
+
+  svg
+    .append("g")
+    .attr("transform", `translate(0,${height - margin.bottom})`)
+    .call(xAxis);
+
+  svg.append("g").attr("transform", `translate(${margin.left},0)`).call(yAxis);
+
+  // Gridlines
+  const gridlinesX = d3
+    .axisBottom(xScale)
+    .tickSize(-height + margin.top + margin.bottom)
+    .tickFormat(() => "")
+    .tickValues(d3.range(0, 61, 2));
+  const gridlinesY = d3
+    .axisLeft(yScale)
+    .tickSize(-width + margin.left + margin.right)
+    .tickFormat(() => "")
+    .tickValues(d3.range(0, 8500, 500));
+
+  svg
+    .append("g")
+    .attr("class", "grid")
+    .attr("transform", `translate(0,${height - margin.bottom})`)
+    .call(gridlinesX);
+
+  svg
+    .append("g")
+    .attr("class", "grid")
+    .attr("transform", `translate(${margin.left},0)`)
+    .call(gridlinesY);
+
+  // Line
+  const line = d3
+    .line()
+    .x((d: any) => xScale(d))
+    .y((d: any) => yScale(d * a + b));
+
+  svg
+    .append("path")
+    .datum(d3.range(0, 61))
+    .attr("fill", "none")
+    .attr("stroke", "blue")
+    .attr("stroke-width", 1)
+    .attr("d", line);
+
+  // KaTeX math expression
+  const latexString = katex.renderToString("(d_1)", { throwOnError: false });
+
+  svg
+    .append("foreignObject")
+    .attr("x", xScale(18))
+    .attr("y", yScale(4500))
+    .attr("width", 50)
+    .attr("height", 30)
+    .html(
+      `<div style='font-size: 16px; font-weight: bold'>${latexString}</div>`,
+    );
+
+  // Labels
+  svg
+    .append("text")
+    .attr("x", width / 2)
+    .attr("y", height - 5)
+    .attr("text-anchor", "middle")
+    .attr("font-weight", "bold")
+    .text("Nombre de participants");
+
+  svg
+    .append("text")
+    .attr("x", margin.left)
+    .attr("y", margin.top - 5)
+    .attr("text-anchor", "middle")
+    .attr("font-weight", "bold")
+    .text("Coût en €");
+${d3n.svgString()}
+
+*/
 //# sourceMappingURL=functionGraphReading.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"functionGraphReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/functionGraphReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAoLF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAiBtD,CAAC"}
+{"version":3,"file":"functionGraphReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/functionGraphReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAqFF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAiBtD,CAAC;;AAEF,UAAU;AACV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsGE"}

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

@@ -4,8 +4,6 @@ import { GeogebraConstructor } from "../../../geogebra/geogebraConstructor.js";
 import { Affine } from "../../../math/polynomials/affine.js";
 import { randint } from "../../../math/utils/random/randint.js";
 import { round } from "../../../math/utils/round.js";
-import { D3Node } from "d3-node";
-import katex from "katex";
 const getPropositions = (n, { answer }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -20,116 +18,38 @@ const getAnswer = (identifiers) => {
 };
 const getInstruction = (identifiers) => {
     const { yValue, a, b } = identifiers;
-    const width = 600;
-    const height = 300;
-    const margin = { top: 20, right: 20, bottom: 40, left: 50 };
-    const d3n = new D3Node();
-    const d3 = d3n.d3;
-    const svg = d3n.createSVG(width, height);
-    const xScale = d3
-        .scaleLinear()
-        .domain([0, 60])
-        .range([margin.left, width - margin.right]);
-    const yScale = d3
-        .scaleLinear()
-        .domain([0, 8000])
-        .range([height - margin.bottom, margin.top]);
-    const xAxis = d3.axisBottom(xScale).ticks(30).tickValues(d3.range(0, 61, 2));
-    const yAxis = d3
-        .axisLeft(yScale)
-        .ticks(16)
-        .tickValues(d3.range(0, 8500, 500));
-    svg
-        .append("g")
-        .attr("transform", `translate(0,${height - margin.bottom})`)
-        .call(xAxis);
-    svg.append("g").attr("transform", `translate(${margin.left},0)`).call(yAxis);
-    // Gridlines
-    const gridlinesX = d3
-        .axisBottom(xScale)
-        .tickSize(-height + margin.top + margin.bottom)
-        .tickFormat(() => "")
-        .tickValues(d3.range(0, 61, 2));
-    const gridlinesY = d3
-        .axisLeft(yScale)
-        .tickSize(-width + margin.left + margin.right)
-        .tickFormat(() => "")
-        .tickValues(d3.range(0, 8500, 500));
-    svg
-        .append("g")
-        .attr("class", "grid")
-        .attr("transform", `translate(0,${height - margin.bottom})`)
-        .call(gridlinesX);
-    svg
-        .append("g")
-        .attr("class", "grid")
-        .attr("transform", `translate(${margin.left},0)`)
-        .call(gridlinesY);
-    // Line
-    const line = d3
-        .line()
-        .x((d) => xScale(d))
-        .y((d) => yScale(d * a + b));
-    svg
-        .append("path")
-        .datum(d3.range(0, 61))
-        .attr("fill", "none")
-        .attr("stroke", "blue")
-        .attr("stroke-width", 1)
-        .attr("d", line);
-    // KaTeX math expression
-    const latexString = katex.renderToString("(d_1)", { throwOnError: false });
-    svg
-        .append("foreignObject")
-        .attr("x", xScale(18))
-        .attr("y", yScale(4500))
-        .attr("width", 50)
-        .attr("height", 30)
-        .html(`<div style='font-size: 16px; font-weight: bold'>${latexString}</div>`);
-    // Labels
-    svg
-        .append("text")
-        .attr("x", width / 2)
-        .attr("y", height - 5)
-        .attr("text-anchor", "middle")
-        .attr("font-weight", "bold")
-        .text("Nombre de participants");
-    svg
-        .append("text")
-        .attr("x", margin.left)
-        .attr("y", margin.top - 5)
-        .attr("text-anchor", "middle")
-        .attr("font-weight", "bold")
-        .text("Coût en €");
     return `La droite $(d_1)$ modélise l'évolution du coût total d'un voyage scolaire en fonction du nombre de participants.
     
-Si le coût total du voyage est de $${yValue}€$, quel est le nombre de participants ?
-
-${d3n.svgString()}`;
+Si le coût total du voyage est de $${yValue}€$, quel est le nombre de participants ?`;
 };
 // const getHint: GetHint<Identifiers> = (identifiers) => {};
 // const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
 const getGGBOptions = (identifiers) => {
     const { a, b, yValue } = identifiers;
     const affine = new Affine(a, b);
+    const xValue = (yValue - b) / a;
     const ggb = new GeogebraConstructor({
-        commands: [`Function(${a}*x+${b}, 0, 10000)`],
-        forbidShiftDragZoom: true,
+        commands: [
+            `Function(${a}*x+${b}, 0, 10000)`,
+            `Text("\\tiny Nombre \\ de \\ participants", (x(Corner(2)), -200), true, true, -1, -1)`,
+            `Text("\\tiny Coût \\ en \\ €", (-5, y(Corner(4))), true, true)`,
+        ],
+        forbidShiftDragZoom: false,
         gridDistance: [2, 500],
         lockedAxesRatio: 2 / 500,
         xAxis: {
-            label: "Nombre de participants",
+            // label: "$\\math{\\tiny \\text{Nb. de \\\\ participants}}$",
             steps: 2,
             showPositive: true,
         },
         yAxis: {
-            label: "Coût en €",
+            // label: "y",
             steps: 500,
             showPositive: true,
         },
     });
     return ggb.getOptions({
-        coords: [-5, 65, -5, 8500],
+        coords: [-5, xValue + 10, -500, yValue + 500],
     });
 };
 const getKeys = (identifiers) => {
@@ -139,9 +59,10 @@ const isAnswerValid = (ans, { answer }) => {
     throw Error("VEA not implemented");
 };
 const getFunctionGraphReadingQuestion = (opts) => {
-    const a = randint(50, 300);
-    const b = randint(0, 300);
-    const yValue = 500 * randint(1, 16);
+    const b = randint(0, 2000);
+    const randPoint = [2 * randint(5, 20), 3000 + 500 * randint(1, 7)];
+    const yValue = randPoint[1];
+    const a = (yValue - b) / randPoint[0];
     const identifiers = { a, b, yValue };
     const question = {
         answer: getAnswer(identifiers),
@@ -172,3 +93,107 @@ export const functionGraphReading = {
     getGGBOptions,
     hasGeogebra: true,
 };
+/***SVG */
+/**
+
+  const width = 600;
+  const height = 300;
+  const margin = { top: 20, right: 20, bottom: 40, left: 50 };
+  const d3n = new D3Node();
+  const d3 = d3n.d3;
+
+  const svg = d3n.createSVG(width, height);
+
+  const xScale = d3
+    .scaleLinear()
+    .domain([0, 60])
+    .range([margin.left, width - margin.right]);
+
+  const yScale = d3
+    .scaleLinear()
+    .domain([0, 8000])
+    .range([height - margin.bottom, margin.top]);
+
+  const xAxis = d3.axisBottom(xScale).ticks(30).tickValues(d3.range(0, 61, 2));
+  const yAxis = d3
+    .axisLeft(yScale)
+    .ticks(16)
+    .tickValues(d3.range(0, 8500, 500));
+
+  svg
+    .append("g")
+    .attr("transform", `translate(0,${height - margin.bottom})`)
+    .call(xAxis);
+
+  svg.append("g").attr("transform", `translate(${margin.left},0)`).call(yAxis);
+
+  // Gridlines
+  const gridlinesX = d3
+    .axisBottom(xScale)
+    .tickSize(-height + margin.top + margin.bottom)
+    .tickFormat(() => "")
+    .tickValues(d3.range(0, 61, 2));
+  const gridlinesY = d3
+    .axisLeft(yScale)
+    .tickSize(-width + margin.left + margin.right)
+    .tickFormat(() => "")
+    .tickValues(d3.range(0, 8500, 500));
+
+  svg
+    .append("g")
+    .attr("class", "grid")
+    .attr("transform", `translate(0,${height - margin.bottom})`)
+    .call(gridlinesX);
+
+  svg
+    .append("g")
+    .attr("class", "grid")
+    .attr("transform", `translate(${margin.left},0)`)
+    .call(gridlinesY);
+
+  // Line
+  const line = d3
+    .line()
+    .x((d: any) => xScale(d))
+    .y((d: any) => yScale(d * a + b));
+
+  svg
+    .append("path")
+    .datum(d3.range(0, 61))
+    .attr("fill", "none")
+    .attr("stroke", "blue")
+    .attr("stroke-width", 1)
+    .attr("d", line);
+
+  // KaTeX math expression
+  const latexString = katex.renderToString("(d_1)", { throwOnError: false });
+
+  svg
+    .append("foreignObject")
+    .attr("x", xScale(18))
+    .attr("y", yScale(4500))
+    .attr("width", 50)
+    .attr("height", 30)
+    .html(
+      `<div style='font-size: 16px; font-weight: bold'>${latexString}</div>`,
+    );
+
+  // Labels
+  svg
+    .append("text")
+    .attr("x", width / 2)
+    .attr("y", height - 5)
+    .attr("text-anchor", "middle")
+    .attr("font-weight", "bold")
+    .text("Nombre de participants");
+
+  svg
+    .append("text")
+    .attr("x", margin.left)
+    .attr("y", margin.top - 5)
+    .attr("text-anchor", "middle")
+    .attr("font-weight", "bold")
+    .text("Coût en €");
+${d3n.svgString()}
+
+*/

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

@@ -1,2 +1,3 @@
 export * from "./tableReading.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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAGlC,cAAc,sBAAsB,CAAC"}

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

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

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

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Identifiers = {
+    points: number[][];
+    labels: string[];
+};
+export declare const pieChartReading: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=pieChartReading.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pieChartReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/pieChartReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAuBrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;IACnB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAoLF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAiBjD,CAAC"}

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

@@ -0,0 +1,171 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { blueExtraDark, colorWithOpacity, greenDark, orange, pinkDark, purpleDark, red, } from "../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../geogebra/geogebraConstructor.js";
+import { Angle } from "../../../math/geometry/angle.js";
+import { Point } from "../../../math/geometry/point.js";
+import { randfloat } from "../../../math/utils/random/randfloat.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { round } from "../../../math/utils/round.js";
+import { percentParser } from "../../../tree/parsers/percentParser.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+import { getLetter } from "../../../utils/strings/getLetter.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { points } = identifiers;
+    const pointsObj = points.map((p, i) => new Point(getLetter(i, true), p[0], p[1]));
+    const angle = new Angle([pointsObj[1], new Point("O", 0, 0), pointsObj[0]]);
+    const angleValue = angle.evaluate();
+    tryToAddWrongProp(propositions, angleValue.frenchify() + "\\%");
+    tryToAddWrongProp(propositions, `${round(100 / points.length, 1)}\\%`);
+    tryToAddWrongProp(propositions, round((angleValue * 100) / 180, 2).frenchify() + "\\%");
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, randfloat(8, 80, 2).frenchify() + "\\%");
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { points } = identifiers;
+    const pointsObj = points.map((p, i) => new Point(getLetter(i, true), p[0], p[1]));
+    const angle = new Angle([pointsObj[1], new Point("O", 0, 0), pointsObj[0]]);
+    const angleValue = angle.evaluate();
+    return round((angleValue * 100) / 360, 2).frenchify() + "\\%";
+};
+const getInstruction = (identifiers) => {
+    return `Ci-dessous est donnée la répartition des communications effectuées par des lycéens avec leur téléphone portable. 
+  
+Quelle proportion des communications effectuées, les communications audio représentent-elles ?
+  
+Arrondir au centième.`;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getGGBOptions = (identifiers) => {
+    const { points, labels } = identifiers;
+    const pointsObj = points.map((p, i) => new Point(getLetter(i, true), p[0], p[1]));
+    // const reversedPoints = pointsObj.reverse();
+    const colors = [greenDark, orange, pinkDark, purpleDark, red];
+    const angle = new Angle([pointsObj[1], new Point("O", 0, 0), pointsObj[0]]);
+    const getMidPoint = (nextPoint, prevPoint) => {
+        const [xA, yA] = prevPoint;
+        const angleA = Math.atan2(yA, xA);
+        const [xB, yB] = nextPoint;
+        const angleB = Math.atan2(yB, xB);
+        // const angleM = (angleA + angleB) / 2;
+        const angleM = angleA +
+            Math.atan2(Math.sin(angleB - angleA), Math.cos(angleB - angleA)) / 2;
+        return [1.2 * Math.cos(angleM), 1.2 * Math.sin(angleM)];
+        return [
+            (1.2 * (xA + xB)) / Math.sqrt((xA + xB) ** 2 + (yA + yB) ** 2 + 0.1),
+            (1.2 * (yA + yB)) / Math.sqrt((xA + xB) ** 2 + (yA + yB) ** 2 + 0.1),
+        ];
+    };
+    const ggb = new GeogebraConstructor({
+        commands: [
+            `C = Circle((0,0), 1)`,
+            `SetLineThickness(C, 1)`,
+            // ...pointsObj.flatMap((p) => p.toGGBCommand()),
+            ...pointsObj.flatMap((p, i) => [
+                `C_${i} = CircularSector((0,0), ${pointsObj[(i + 1 + pointsObj.length) % pointsObj.length].toMathString()}, ${p.toMathString()})`,
+                `SetColor(C_${i}, "${colorWithOpacity(colors[i], 80)}")`,
+                `SetLineThickness(C_${i}, 0)`,
+                // `SetCaption(C_${i}, "$\\tiny \\text{${labels[i]}}$")`,
+                // `ShowLabel(C_${i}, true)`,
+                // `Text("$\\tiny \\text{${labels[i]
+                //   .split(" ")
+                //   .join("\\\\")}}$", (${getMidPoint(
+                //   points[(i + 1 + points.length) % points.length],
+                //   points[i],
+                // ).join(",")}), true, true, 1, 0)`,
+                `Text("$\\tiny \\text{${labels[i]
+                    .split(" ")
+                    .join("\\\\")}}$", (${getMidPoint(points[(i + 1 + points.length) % points.length], points[i]).join(",")}), true, true, 0, 0)`,
+            ]),
+            ...angle.toCommands({
+                showValue: points[1][0] === 1 ? false : true,
+                pointsAreNotBuilt: true,
+                thickness: 1,
+                color: blueExtraDark,
+            }),
+        ],
+        hideAxes: true,
+        hideGrid: true,
+        forbidShiftDragZoom: true,
+    });
+    return ggb.getOptions({
+        coords: [-1.4, 1.4, -1.4, 1.4],
+    });
+};
+const getKeys = (identifiers) => {
+    return ["percent"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = percentParser(ans, true);
+        return parsed === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getPieChartReadingQuestion = (opts) => {
+    const labels = [
+        "communications audio",
+        "communications vidéo",
+        "messagerie électronique",
+        "autre",
+        "messages SMS",
+    ];
+    const getPointFromPrev = (prevPoint, degAngle) => {
+        const radAngle = -(degAngle * Math.PI) / 180;
+        return [
+            round(prevPoint[0] * Math.cos(radAngle) - prevPoint[1] * Math.sin(radAngle), 6),
+            round(prevPoint[0] * Math.sin(radAngle) + prevPoint[1] * Math.cos(radAngle), 6),
+        ];
+    };
+    const angles = [5 * randint(6, 30)];
+    for (let i = 0; i < labels.length - 1; i++) {
+        const remaining = 360 - angles.reduce((acc, curr) => acc + curr);
+        if (i === labels.length - 1)
+            angles.push(remaining);
+        else
+            angles.push(randint(30, Math.min(100, remaining - 30)));
+    }
+    const points = [[0, 1]];
+    for (let i = 0; i < angles.length - 1; i++) {
+        points.push(getPointFromPrev(points[i], angles[i]));
+    }
+    const identifiers = {
+        labels,
+        points,
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+    return question;
+};
+export const pieChartReading = {
+    id: "pieChartReading",
+    label: "Convertir un angle en pourcentage dans un diagramme circulaire",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPieChartReadingQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    // getHint,
+    // getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+};

package/lib/exercises/math/derivation/derivative/constanteDerivative.js

@@ -12,10 +12,10 @@ const getAnswer = () => "0";
 const getInstruction = (identifiers) => {
     const tex = identifiers.tex;
     return `Déterminer la fonction dérivée $f'$ de la fonction $f$ définie par : 
-  
+
 $$
 f(x) = ${tex}
-$$.`;
+$$`;
 };
 export const getConstanteDerivative = () => {
     const c = NombreConstructor.random();

package/lib/exercises/math/geometry/euclidian/pythagoreOrThales.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pythagoreOrThales.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidian/pythagoreOrThales.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAkBtC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,OAAO,CAAC;IACxB,eAAe,EAAE,OAAO,CAAC;IAEzB,iBAAiB,EAAE,gBAAgB,EAAE,CAAC;IACtC,OAAO,EAAE,MAAM,EAAE,CAAC;CAQnB,CAAC;AA+MF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAkBnD,CAAC"}
+{"version":3,"file":"pythagoreOrThales.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidian/pythagoreOrThales.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAkBtC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,OAAO,CAAC;IACxB,eAAe,EAAE,OAAO,CAAC;IAEzB,iBAAiB,EAAE,gBAAgB,EAAE,CAAC;IACtC,OAAO,EAAE,MAAM,EAAE,CAAC;CAQnB,CAAC;AA+MF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAqBnD,CAAC"}

package/lib/exercises/math/geometry/euclidian/pythagoreOrThales.js

@@ -191,6 +191,9 @@ export const pythagoreOrThales = {
     getGGBOptions,
     hasGeogebra: true,
     answerType: "QCU",
+    pdfOptions: {
+        shouldSpreadPropositions: true,
+    },
 };
 const getSubTriangle = ({ triangle, insidePointsNames, ratio, isPapillon, }) => {
     const [A, B, C] = triangle.points;

package/lib/exercises/math/geometry/quadrilaterals/quadrilateralRecognition.js

@@ -149,9 +149,10 @@ const getGGBOptions = (identifiers) => {
                 shapeObject.drawSidesDecoration();
     }
     const cmds = shapeObject.toGGBCommands();
+    shapeObject.points;
     const ggb = new GeogebraConstructor({ hideAxes: true, hideGrid: true });
     ggb.commands = cmds;
-    return ggb.getOptions({ coords: [-10, 10, -10, 10] });
+    return ggb.getOptions({ coords: ggb.getCoordsForPoints(shapeObject.points) });
 };
 const getKeys = (identifiers) => {
     return [];

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

@@ -31,7 +31,7 @@ const getAverageListQuestion = () => {
         keys: [],
         answerFormat: "tex",
         identifiers,
-        hint: "La moyenne d'une liste de valeurs est la somme de ses valeurs divisé par le nombre de valeurs.",
+        hint: "La moyenne d'une liste de valeurs est la somme des valeurs divisée par le nombre de valeurs.",
         correction: `
 On additionne toutes les valeurs :
 

package/lib/exercises/math/probaStat/stats1var/choseReasoningForIndicator.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    indicatorAsked: string;
+    values: number[];
+};
+export declare const choseReasoningForIndicator: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=choseReasoningForIndicator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"choseReasoningForIndicator.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/choseReasoningForIndicator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAuHF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAgB5D,CAAC"}

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

@@ -0,0 +1,105 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { AddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { operatorComposition } from "../../../../tree/utilities/operatorComposition.js";
+import { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { average } from "../../../../utils/average.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    const { values, indicatorAsked } = identifiers;
+    const avg = average(values);
+    const max = Math.max(...values);
+    tryToAddWrongProp(propositions, `La ${indicatorAsked} est $${avg}$ car $\\frac{${operatorComposition(AddNode, values.map((v) => v.toTree())).toTex()}}{${values.length}} = ${avg}$`, "raw");
+    tryToAddWrongProp(propositions, `La ${indicatorAsked} est $${avg}$ car c'est la moitié de $${max}$.`, "raw");
+    tryToAddWrongProp(propositions, `La ${indicatorAsked} est $${avg}$ car la valeur $${avg}$ est au milieu de la série.`, "raw");
+    tryToAddWrongProp(propositions, `La ${indicatorAsked} est $${avg}$ car il y a dans la série autant de valeurs inférieures à $${avg}$ que de valeurs supérieures à $${avg}$.`, "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { values, indicatorAsked } = identifiers;
+    const avg = average(values);
+    return indicatorAsked === "moyenne"
+        ? `La moyenne est $${avg}$ car $\\frac{${operatorComposition(AddNode, values.map((v) => v.toTree())).toTex()}}{${values.length}} = ${avg}$`
+        : `La médiane est $${avg}$ car il y a dans la série autant de valeurs inférieures à $${avg}$ que de valeurs supérieures à $${avg}$.`;
+};
+const getInstruction = (identifiers) => {
+    const { values, indicatorAsked } = identifiers;
+    const avg = average(values);
+    return `Voici une série de valeurs : 
+  
+$$
+${values.join("\\ ; \\ ")}
+$$
+
+La ${indicatorAsked} de cette série est $${avg}$. 
+
+Quelle est la justification correcte ?`;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        throw Error("VEA not implemented");
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getChoseReasoningForIndicatorQuestion = (ops) => {
+    const max = 2 * randint(5, 20);
+    const x = max / 2;
+    let otherValues = [];
+    const miserablyDo = () => {
+        const b = randint(x + 1, 2 * x);
+        const c = randint(x + 1, 2 * x);
+        let remaining = 4 * x - b - c;
+        const d = randint(0, Math.min(remaining + 1, x));
+        remaining -= d;
+        const e = randint(0, Math.min(remaining + 1, x));
+        remaining -= e;
+        const f = remaining;
+        otherValues = [max, b, c, d, e, f];
+    };
+    do {
+        miserablyDo();
+    } while (otherValues[otherValues.length - 1] >= x);
+    const shuffled = shuffle(otherValues);
+    shuffled.splice(3, 0, x);
+    const identifiers = {
+        values: shuffled,
+        indicatorAsked: random(["moyenne", "médiane"]),
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const choseReasoningForIndicator = {
+    id: "choseReasoningForIndicator",
+    label: "Trouver le bon raisonnement pour déterminer une moyenne/une médiane",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getChoseReasoningForIndicatorQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    // getHint,
+    // getCorrection,
+    getAnswer,
+    answerType: "QCU",
+};

package/lib/exercises/math/probaStat/stats1var/index.d.ts

@@ -12,4 +12,5 @@ export * from "./standardDeviationList.js";
 export * from "./standardDeviationTable.js";
 export * from "./interquartilesList.js";
 export * from "./interquartilesTable.js";
+export * from "./choseReasoningForIndicator.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,sCAAsC,CAAC;AACrD,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,sCAAsC,CAAC;AACrD,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,iCAAiC,CAAC"}

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

@@ -12,3 +12,4 @@ export * from "./standardDeviationList.js";
 export * from "./standardDeviationTable.js";
 export * from "./interquartilesList.js";
 export * from "./interquartilesTable.js";
+export * from "./choseReasoningForIndicator.js";

package/lib/exercises/math/spaceGeometry/basis/spaceCoordinatesInPrism.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spaceCoordinatesInPrism.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/basis/spaceCoordinatesInPrism.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AA0IF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAiBzD,CAAC"}
+{"version":3,"file":"spaceCoordinatesInPrism.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/basis/spaceCoordinatesInPrism.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAyKF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAiBzD,CAAC"}

package/lib/exercises/math/spaceGeometry/basis/spaceCoordinatesInPrism.js

@@ -4,6 +4,7 @@ import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js
 import { SpacePoint } from "../../../../math/geometry/spacePoint.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
 const getPoints = (identifiers) => {
     const { l, L, h } = identifiers;
     const zeroTree = (0).toTree();
@@ -47,7 +48,9 @@ Les coordonnées du point $${givenPoints[1]}$ sont $${points
         .find((p) => p.name === givenPoints[1])
         .toCoords()}$.
 
-Quelles sont les coordonnées du point $${askedPoint}$ ?`;
+Quelles sont les coordonnées du point $${askedPoint}$ ?
+
+*On pourra tourner la fenêtre graphique.*`;
 };
 // const getHint : GetHint<Identifiers> = (identifiers)=>{
 // }
@@ -56,15 +59,16 @@ Quelles sont les coordonnées du point $${askedPoint}$ ?`;
 const getGGBOptions = (identifiers) => {
     const { askedPoint, givenPoints, L, l, h } = identifiers;
     const points = getPoints(identifiers);
+    const shownPoints = points.filter((p) => [askedPoint, ...givenPoints].includes(p.name));
     const commands = [
-        ...points.flatMap((p) => p.toGGBCommand({ color: "black", size: 2 })),
+        ...shownPoints.flatMap((p) => p.toGGBCommand({ color: "black", size: 2 })),
         `P = Prism(${points
             .slice(0, 5)
-            .map((p) => p.name)
+            .map((p) => p.toMathString())
             .join(",")})`,
-        `SetVisibleInView(J, -1, false)`,
-        `SetVisibleInView(K, -1, false)`,
-        `SetVisibleInView(I, -1, false)`,
+        // `SetVisibleInView(J, -1, false)`,
+        // `SetVisibleInView(K, -1, false)`,
+        // `SetVisibleInView(I, -1, false)`,
         `SetColor(P, "#20000000")`,
         `SetLineThickness(P, 1)`,
     ];
@@ -99,13 +103,35 @@ const getSpaceCoordinatesInPrismQuestion = (opts) => {
     const l = randint(2, 10);
     const L = randint(2, 10);
     const h = randint(2, 10);
+    const points = getPoints({ L, l, h });
     const letters = ["A", "B", "C", "D", "E", "F", "G", "H"];
-    const askedPoint = random(letters, ["A"]);
-    const givenPointOne = random(letters, ["A", askedPoint]);
-    const givenPointTwo = random(letters, ["A", askedPoint, givenPointOne]);
+    const shuffled = shuffle(points.slice(1));
+    const givenPointOne = shuffled[0];
+    const pointOneCoords = givenPointOne.getEvaluatedCoords();
+    let givenPointTwo;
+    for (let i = 1; i < shuffled.length; i++) {
+        const p = shuffled[i];
+        const coords = p.getEvaluatedCoords();
+        if (coords[0] + pointOneCoords[0] === 0 ||
+            coords[1] + pointOneCoords[0] === 0 ||
+            coords[2] + pointOneCoords[2] === 0)
+            continue;
+        const absDiffCoeffs = coords.map((c, i) => Math.abs(c - pointOneCoords[i]));
+        const validCoeffs = absDiffCoeffs.filter((e) => e !== 0);
+        if (validCoeffs.length < 2)
+            continue;
+        givenPointTwo = p;
+    }
+    const askedPoint = random(letters, [
+        "A",
+        givenPointOne.name,
+        givenPointTwo.name,
+    ]);
+    // const givenPointOne = random(letters, ["A", askedPoint]);
+    // const givenPointTwo = random(letters, ["A", askedPoint, givenPointOne]);
     const identifiers = {
         askedPoint,
-        givenPoints: [givenPointOne, givenPointTwo],
+        givenPoints: [givenPointOne.name, givenPointTwo.name],
         l,
         L,
         h,

package/lib/geogebra/colors.d.ts

@@ -22,4 +22,5 @@ export declare const purpleDark = "#522AAB";
 export declare const purples: string[];
 export declare const colors: string[];
 export declare const randomColor: () => string;
+export declare const colorWithOpacity: (color: string, opacity: number) => string;
 //# sourceMappingURL=colors.d.ts.map

package/lib/geogebra/colors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"colors.d.ts","sourceRoot":"","sources":["../../src/geogebra/colors.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,GAAG,YAAY,CAAC;AAC7B,eAAO,MAAM,QAAQ,YAAY,CAAC;AAClC,eAAO,MAAM,QAAQ,YAAY,CAAC;AAClC,eAAO,MAAM,SAAS,YAAY,CAAC;AACnC,eAAO,MAAM,IAAI,UAAuC,CAAC;AAEzD,eAAO,MAAM,UAAU,YAAY,CAAC;AACpC,eAAO,MAAM,MAAM,YAAY,CAAC;AAChC,eAAO,MAAM,WAAW,YAAY,CAAC;AACrC,eAAO,MAAM,OAAO,UAAoC,CAAC;AAEzD,eAAO,MAAM,UAAU,YAAY,CAAC;AACpC,eAAO,MAAM,SAAS,YAAY,CAAC;AACnC,eAAO,MAAM,SAAS,YAAY,CAAC;AACnC,eAAO,MAAM,MAAM,UAAqC,CAAC;AAEzD,eAAO,MAAM,SAAS,YAAY,CAAC;AACnC,eAAO,MAAM,QAAQ,YAAY,CAAC;AAClC,eAAO,MAAM,QAAQ,YAAY,CAAC;AAClC,eAAO,MAAM,aAAa,YAAY,CAAC;AACvC,eAAO,MAAM,KAAK,UAAiD,CAAC;AAEpE,eAAO,MAAM,WAAW,YAAY,CAAC;AACrC,eAAO,MAAM,UAAU,YAAY,CAAC;AACpC,eAAO,MAAM,UAAU,YAAY,CAAC;AACpC,eAAO,MAAM,OAAO,UAAwC,CAAC;AAC7D,eAAO,MAAM,MAAM,UAAyD,CAAC;AAE7E,eAAO,MAAM,WAAW,cAEvB,CAAC"}
+{"version":3,"file":"colors.d.ts","sourceRoot":"","sources":["../../src/geogebra/colors.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,GAAG,YAAY,CAAC;AAC7B,eAAO,MAAM,QAAQ,YAAY,CAAC;AAClC,eAAO,MAAM,QAAQ,YAAY,CAAC;AAClC,eAAO,MAAM,SAAS,YAAY,CAAC;AACnC,eAAO,MAAM,IAAI,UAAuC,CAAC;AAEzD,eAAO,MAAM,UAAU,YAAY,CAAC;AACpC,eAAO,MAAM,MAAM,YAAY,CAAC;AAChC,eAAO,MAAM,WAAW,YAAY,CAAC;AACrC,eAAO,MAAM,OAAO,UAAoC,CAAC;AAEzD,eAAO,MAAM,UAAU,YAAY,CAAC;AACpC,eAAO,MAAM,SAAS,YAAY,CAAC;AACnC,eAAO,MAAM,SAAS,YAAY,CAAC;AACnC,eAAO,MAAM,MAAM,UAAqC,CAAC;AAEzD,eAAO,MAAM,SAAS,YAAY,CAAC;AACnC,eAAO,MAAM,QAAQ,YAAY,CAAC;AAClC,eAAO,MAAM,QAAQ,YAAY,CAAC;AAClC,eAAO,MAAM,aAAa,YAAY,CAAC;AACvC,eAAO,MAAM,KAAK,UAAiD,CAAC;AAEpE,eAAO,MAAM,WAAW,YAAY,CAAC;AACrC,eAAO,MAAM,UAAU,YAAY,CAAC;AACpC,eAAO,MAAM,UAAU,YAAY,CAAC;AACpC,eAAO,MAAM,OAAO,UAAwC,CAAC;AAC7D,eAAO,MAAM,MAAM,UAAyD,CAAC;AAE7E,eAAO,MAAM,WAAW,cAEvB,CAAC;AAEF,eAAO,MAAM,gBAAgB,UAAW,MAAM,WAAW,MAAM,WAE9D,CAAC"}

package/lib/geogebra/colors.js

@@ -25,3 +25,6 @@ export const colors = [...reds, ...oranges, ...greens, ...blues, ...purples];
 export const randomColor = () => {
     return random(colors);
 };
+export const colorWithOpacity = (color, opacity) => {
+    return `#${opacity < 10 ? `0+${opacity}` : opacity}${color.substring(1)}`;
+};

package/lib/index.d.ts

@@ -1527,6 +1527,9 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     sortedValues: number[];
     effectifs: number[];
+}, {}> | Exercise<{
+    indicatorAsked: string;
+    values: number[];
 }, {}> | Exercise<{
     xValues: number[];
     yValues: number[];
@@ -1882,6 +1885,9 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     values: number[][];
     caseAsked: number;
+}, {}> | Exercise<{
+    points: number[][];
+    labels: string[];
 }, {}>)[];
 declare const pcExercises: (Exercise<{
     numbers: 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/latexTester.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"latexTester.d.ts","sourceRoot":"","sources":["../src/latexTester.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,UAAW,MAAM,2CAsJxC,CAAC"}
+{"version":3,"file":"latexTester.d.ts","sourceRoot":"","sources":["../src/latexTester.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,UAAW,MAAM,2CAgKxC,CAAC"}

package/lib/latexTester.js

@@ -23,7 +23,13 @@ export const latexTester = (latex, isDefaultInMathMode = false) => {
                 if (inDoubleDollarMode &&
                     nextNextChar !== undefined &&
                     nextNextChar !== "\n") {
-                    throw new Error(`Whitespace missing after double dollar, got char ${nextNextChar}`);
+                    throw new Error(`Whitespace missing after start double dollar, got char ${nextNextChar}`);
+                }
+                if (!inDoubleDollarMode &&
+                    nextNextChar !== undefined &&
+                    nextNextChar !== "\n" &&
+                    nextNextChar !== " ") {
+                    throw new Error(`Whitespace missing after end double dollar, got char ${nextNextChar}`);
                 }
                 i++;
             }

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

@@ -39,8 +39,10 @@ export declare class Angle {
     isRight(): boolean;
     toTex(): string;
     toCommands(opts?: {
+        pointsAreNotBuilt?: boolean;
         color?: string;
         showValue?: boolean;
+        thickness?: number;
     }): string[];
 }
 export {};

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

@@ -1 +1 @@
-{"version":3,"file":"angle.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/angle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAMlE,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACvE,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAI7C,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,gBAAgB;CAUrD;AACD,KAAK,UAAU,GAAG;IAChB,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,eAAe,CAAC,EAAE,aAAa,CAAC;CACjC,CAAC;AAEF,KAAK,qBAAqB,GAAG;IAC3B,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,eAAe,CAAC,EAAE,eAAe,CAAC;CACnC,CAAC;AACF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,KAAK,CAAC,EAAE,qBAAqB,CAAC;CAC/B,CAAC;AACF,qBAAa,KAAK;IAChB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB;;;OAGG;gBACS,MAAM,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC,EAAE,UAAU;IAkB/C,aAAa,IAAI,gBAAgB;IASjC,WAAW,CAAC,CAAC,EAAE,KAAK;IAIpB,MAAM,CAAC,CAAC,EAAE,KAAK;IAqBf,SAAS,CAAC,CAAC,EAAE,KAAK;IASlB,gBAAgB,CAAC,CAAC,EAAE,KAAK;IAwCzB,MAAM;IAMN,eAAe,CAAC,CAAC,EAAE,KAAK;IAsCxB,gBAAgB,CAAC,CAAC,EAAE,KAAK;IAoBzB,QAAQ,CAAC,QAAQ,UAAQ;IAiBzB,YAAY,CAAC,QAAQ,UAAQ;IAW7B,OAAO;IAIP,KAAK;IAGL,UAAU,CAAC,IAAI,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE;CAgB1D"}
+{"version":3,"file":"angle.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/angle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAMlE,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACvE,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAK7C,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,gBAAgB;CAUrD;AACD,KAAK,UAAU,GAAG;IAChB,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,eAAe,CAAC,EAAE,aAAa,CAAC;CACjC,CAAC;AAEF,KAAK,qBAAqB,GAAG;IAC3B,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,eAAe,CAAC,EAAE,eAAe,CAAC;CACnC,CAAC;AACF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,KAAK,CAAC,EAAE,qBAAqB,CAAC;CAC/B,CAAC;AACF,qBAAa,KAAK;IAChB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB;;;OAGG;gBACS,MAAM,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC,EAAE,UAAU;IAkB/C,aAAa,IAAI,gBAAgB;IASjC,WAAW,CAAC,CAAC,EAAE,KAAK;IAIpB,MAAM,CAAC,CAAC,EAAE,KAAK;IAqBf,SAAS,CAAC,CAAC,EAAE,KAAK;IASlB,gBAAgB,CAAC,CAAC,EAAE,KAAK;IAwCzB,MAAM;IAMN,eAAe,CAAC,CAAC,EAAE,KAAK;IAsCxB,gBAAgB,CAAC,CAAC,EAAE,KAAK;IAoBzB,QAAQ,CAAC,QAAQ,UAAQ;IAiBzB,YAAY,CAAC,QAAQ,UAAQ;IAW7B,OAAO;IAIP,KAAK;IAGL,UAAU,CAAC,IAAI,CAAC,EAAE;QAChB,iBAAiB,CAAC,EAAE,OAAO,CAAC;QAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB;CA0BF"}

package/lib/math/geometry/angle.js

@@ -196,14 +196,21 @@ export class Angle {
     }
     toCommands(opts) {
         const name = `angle_{${this.points[0].name}${this.points[1].name}${this.points[2].name}}`;
-        const cmds = [
-            `${name} = Angle(${this.points[0].name},${this.points[1].name},${this.points[2].name}, xAxis)`,
-            `ShowLabel(${name}, ${opts?.showValue ? "true" : "false"})`,
-        ];
+        const cmds = [];
+        if (opts?.pointsAreNotBuilt) {
+            cmds.push(`${name} = Angle(${this.points[0].toMathString()},${this.points[1].toMathString()},${this.points[2].toMathString()}, xAxis)`);
+        }
+        else {
+            cmds.push(`${name} = Angle(${this.points[0].name},${this.points[1].name},${this.points[2].name}, xAxis)`);
+        }
+        cmds.push(`ShowLabel(${name}, ${opts?.showValue ? "true" : "false"})`);
         cmds.push(`SetCaption(${name}, "$\\footnotesize ${round(this.evaluate(), 1).frenchify() + "°"}$")`);
         if (opts?.color) {
             cmds.push(`SetColor(${name}, "${opts.color}")`);
         }
+        if (opts?.thickness !== undefined) {
+            cmds.push(`SetLineThickness(${name}, ${opts?.thickness})`);
+        }
         return cmds;
     }
 }

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

@@ -18,6 +18,7 @@ export declare class SpacePoint {
     constructor(name: string, x: AlgebraicNode, y: AlgebraicNode, z: AlgebraicNode);
     getCoords(): AlgebraicNode[];
     getEvaluatedCoords(): number[];
+    toMathString(): string;
     toTex(): string;
     toTexWithCoords(): string;
     toCoords(): string;

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

@@ -1 +1 @@
-{"version":3,"file":"spacePoint.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/spacePoint.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAGlE,OAAO,EAAE,kBAAkB,EAAE,MAAM,sDAAsD,CAAC;AAE1F,KAAK,SAAS,GAAG;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AACrE,8BAAsB,qBAAqB;IACzC,MAAM,CAAC,MAAM,CACX,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,SAAS,EACjB,KAAK,CAAC,EAAE,SAAS,EACjB,KAAK,CAAC,EAAE,SAAS,GAChB,UAAU;IAyBb,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE;IA4BtC,MAAM,CAAC,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,GAAE,MAAY;CAWrD;AAED,qBAAa,UAAU;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,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;IAIlB,KAAK,IAAI,MAAM;IAIf,eAAe,IAAI,MAAM;IAKzB,QAAQ,IAAI,MAAM;IAIlB,QAAQ,CAAC,CAAC,EAAE,UAAU,EAAE,IAAI,SAAM,GAAG,UAAU;IAkB/C,UAAU,CAAC,CAAC,EAAE,UAAU,GAAG,MAAM;IAIjC,MAAM,CAAC,CAAC,EAAE,UAAU,GAAG,OAAO;IAG9B,SAAS,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU;IAOtC,YAAY,CAAC,EACX,OAAc,EACd,SAAgB,EAChB,KAAK,EACL,IAAI,EACJ,KAAK,GACN,GAAE,kBAAuB;CAmB3B"}
+{"version":3,"file":"spacePoint.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/spacePoint.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAGlE,OAAO,EAAE,kBAAkB,EAAE,MAAM,sDAAsD,CAAC;AAE1F,KAAK,SAAS,GAAG;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AACrE,8BAAsB,qBAAqB;IACzC,MAAM,CAAC,MAAM,CACX,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,SAAS,EACjB,KAAK,CAAC,EAAE,SAAS,EACjB,KAAK,CAAC,EAAE,SAAS,GAChB,UAAU;IAyBb,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE;IA4BtC,MAAM,CAAC,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,GAAE,MAAY;CAWrD;AAED,qBAAa,UAAU;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,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,YAAY;IAGZ,KAAK,IAAI,MAAM;IAIf,eAAe,IAAI,MAAM;IAKzB,QAAQ,IAAI,MAAM;IAIlB,QAAQ,CAAC,CAAC,EAAE,UAAU,EAAE,IAAI,SAAM,GAAG,UAAU;IAkB/C,UAAU,CAAC,CAAC,EAAE,UAAU,GAAG,MAAM;IAIjC,MAAM,CAAC,CAAC,EAAE,UAAU,GAAG,OAAO;IAG9B,SAAS,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU;IAOtC,YAAY,CAAC,EACX,OAAc,EACd,SAAgB,EAChB,KAAK,EACL,IAAI,EACJ,KAAK,GACN,GAAE,kBAAuB;CAmB3B"}

package/lib/math/geometry/spacePoint.js

@@ -48,6 +48,9 @@ export class SpacePoint {
     getEvaluatedCoords() {
         return this.getCoords().map((e) => e.evaluate({}));
     }
+    toMathString() {
+        return `(${this.x.toMathString()}, ${this.y.toMathString()}, ${this.z.toMathString()})`;
+    }
     toTex() {
         return `${this.name}`;
     }

package/lib/utils/strings/getLetter.d.ts

@@ -0,0 +1,2 @@
+export declare const getLetter: (i: number, maj?: boolean) => string;
+//# sourceMappingURL=getLetter.d.ts.map

package/lib/utils/strings/getLetter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getLetter.d.ts","sourceRoot":"","sources":["../../../src/utils/strings/getLetter.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS,MAAO,MAAM,QAAQ,OAAO,WAEjD,CAAC"}

package/lib/utils/strings/getLetter.js

@@ -0,0 +1,3 @@
+export const getLetter = (i, maj) => {
+    return String.fromCharCode((maj ? 65 : 97) + i);
+};

package/package.json

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