math-exercises 3.0.21 → 3.0.23

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

@@ -1,187 +1,205 @@
-// import {
-//   Exercise,
-//   Proposition,
-//   QCMGenerator,
-//   Question,
-//   QuestionGenerator,
-//   VEA,
-//   GGBVEA,
-//   addValidProp,
-//   shuffleProps,
-//   tryToAddWrongProp,
-//   GetAnswer,
-//   GetHint,
-//   GetCorrection,
-//   GetInstruction,
-//   GetKeys,
-//   GetGGBOptions,
-//   GetStudentGGBOptions,
-//   GetGGBAnswer,
-// } from "../../../../exercises/exercise.js";
-// import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
-// import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
-// import { Line, LineConstructor } from "../../../../math/geometry/line.js";
-// import {
-//   Point,
-//   PointConstructor,
-//   PointIdentifiers,
-// } from "../../../../math/geometry/point.js";
-// import {
-//   Segment,
-//   SegmentConstructor,
-//   SegmentIdentifiers,
-// } from "../../../../math/geometry/segment.js";
-// import {
-//   Triangle,
-//   TriangleConstructor,
-//   TriangleIdentifiers,
-// } from "../../../../math/geometry/triangle.js";
-// import { coinFlip } from "../../../../utils/alea/coinFlip.js";
-export {};
-// type Identifiers = {
-//   isAskingLength: boolean;
-//   triangleIdentifiers: TriangleIdentifiers;
-//   extraPoints: PointIdentifiers[];
-//   isSegmentHeight: boolean; // si hauteur alors configuration pythagore
-// };
-// const getPropositions: QCMGenerator<Identifiers> = (n, { answer }) => {
-//   const propositions: Proposition[] = [];
-//   addValidProp(propositions, answer, "raw");
-//   tryToAddWrongProp(propositions, "Le théorème de Thalès", "raw");
-//   tryToAddWrongProp(propositions, "La réciproque du théorème de Thalès", "raw");
-//   tryToAddWrongProp(propositions, "Le théorème de Pythagore", "raw");
-//   tryToAddWrongProp(
-//     propositions,
-//     "La réciproque du théorème de Pythagore",
-//     "raw",
-//   );
-//   return shuffleProps(propositions, n);
-// };
-// const getAnswer: GetAnswer<Identifiers> = (identifiers) => {
-//   const { isAskingLength, triangleIdentifiers, isSegmentHeight } = identifiers;
-//   return isSegmentHeight
-//     ? isAskingLength
-//       ? "Le théorème de Pythagore"
-//       : "La réciproque du théorème de Pythagore"
-//     : isAskingLength
-//     ? "Le théorème de Thalès"
-//     : "La réciproque du théorème de Thalès";
-// };
-// const getInstruction: GetInstruction<Identifiers> = (identifiers) => {
-//   const { isAskingLength, triangleIdentifiers, isSegmentHeight, extraPoints } = identifiers;
-//   const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
-//   const points = extraPoints.map((e) => PointConstructor.fromIdentifiers(e));
-//   let instruction = ``;
-//   if(isSegmentHeight){
-//     if(isAskingLength){
-//       instruction = `calculer la longueur $${triangle.sides[2].toInsideName()}$`
-//     } else {
-//       instruction = `prouver que le triangle $${triangle.points[1].name}${triangle.points[2].name}${points[0].name}$ est rectangle en $${points[0].name}$`
-//     }
-//   } else {
-//     if(isAskingLength){
-//       instruction = `calculer la longueur $${points[0].name}${points[1].name}$`
-//     } else {
-//       instruction = `prouver que les droites $${}$ et $${}$ sont parallèles`
-//     }
-//   }
-//   return `On donne la figure ci-dessous.
-// Pour ${instruction}, il faut utiliser... `;
-// };
-// // const getHint: GetHint<Identifiers> = (identifiers) => {};
-// // const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
-// const getGGBOptions: GetGGBOptions<Identifiers> = (identifiers) => {
-//   const { isAskingLength, triangleIdentifiers, extraPoints, isSegmentHeight } =
-//     identifiers;
-//   const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
-//   const points = extraPoints.map((e) => PointConstructor.fromIdentifiers(e));
-//   const commands = [
-//     ...triangle.commands,
-//     ...points.flatMap((p) => p.toGGBCommand()),
-//   ];
-//   if (isSegmentHeight) {
-//     commands.push(
-//       ...new Segment(triangle.points[1], points[0]).toGGBCommands(false),
-//     );
-//   } else {
-//     commands.push(...new Segment(points[0], points[1]).toGGBCommands(false));
-//   }
-//   const ggb = new GeogebraConstructor({
-//     commands,
-//     hideAxes: true,
-//     hideGrid: true,
-//   });
-//   return ggb.getOptions({
-//     coords: triangle.generateCoords(),
-//   });
-// };
-// const getKeys: GetKeys<Identifiers> = (identifiers) => {
-//   return [];
-// };
-// const isAnswerValid: VEA<Identifiers> = (ans, { answer }) => {
-//   throw Error("VEA not implemented");
-// };
-// const getPythagoreOrThalesQuestion: QuestionGenerator<Identifiers> = (opts) => {
-//   // const triangle = TriangleConstructor.randomNiceSides({});
-//   const A = new Point("A", 0, 0);
-//   const B = new Point("B", 4, 4);
-//   const C = new Point("C", 8, 0);
-//   const triangle = new Triangle([A, B, C]);
-//   const isSegmentHeight = coinFlip();
-//   const isAskingLength = coinFlip();
-//   let extraPoints: PointIdentifiers[] = [];
-//   if (isSegmentHeight) {
-//     const baseLine = LineConstructor.fromSegment(triangle.sides[1]);
-//     const height = baseLine.getPerpendicular(triangle.points[1]);
-//     extraPoints.push(height.intersect(baseLine, "H").toIdentifiers());
-//   } else {
-//     const baseLine = LineConstructor.fromSegment(triangle.sides[1]);
-//     const D = PointConstructor.onSegment(triangle.sides[2], "D", {
-//       spacing: 0.3,
-//     });
-//     const para = baseLine.getParallele(D);
-//     const E = para.intersect(
-//       LineConstructor.fromSegment(triangle.sides[0]),
-//       "E",
-//     );
-//     extraPoints.push(D.toIdentifiers());
-//     extraPoints.push(E.toIdentifiers());
-//   }
-//   const identifiers: Identifiers = {
-//     triangleIdentifiers: triangle.toIdentifiers(),
-//     // segmentIdentifiers: triangle.sides[0].toIdentifiers(),
-//     extraPoints,
-//     isAskingLength,
-//     isSegmentHeight,
-//   };
-//   const question: Question<Identifiers> = {
-//     answer: getAnswer(identifiers),
-//     instruction: getInstruction(identifiers),
-//     keys: getKeys(identifiers),
-//     answerFormat: "raw",
-//     identifiers,
-//     // hint: getHint(identifiers),
-//     // correction: getCorrection(identifiers),
-//     ggbOptions: getGGBOptions(identifiers),
-//   };
-//   return question;
-// };
-// export const pythagoreOrThales: Exercise<Identifiers> = {
-//   id: "pythagoreOrThales",
-//   label: "",
-//   isSingleStep: true,
-//   generator: (nb, opts) =>
-//     getDistinctQuestions(() => getPythagoreOrThalesQuestion(opts), nb),
-//   qcmTimer: 60,
-//   freeTimer: 60,
-//   getPropositions,
-//   isAnswerValid,
-//   subject: "Mathématiques",
-//   // getHint,
-//   // getCorrection,
-//   getInstruction,
-//   getAnswer,
-//   getGGBOptions,
-//   hasGeogebra: true,
-//   answerType: "QCU",
-// };
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Angle } from "../../../../math/geometry/angle.js";
+import { PointConstructor, } from "../../../../math/geometry/point.js";
+import { RightTriangleConstructor } from "../../../../math/geometry/rightTriangle.js";
+import { Segment, } from "../../../../math/geometry/segment.js";
+import { Triangle, TriangleConstructor, } from "../../../../math/geometry/triangle.js";
+import { VectorConstructor } from "../../../../math/geometry/vector.js";
+import { round } from "../../../../math/utils/round.js";
+import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Le théorème de Thalès", "raw");
+    tryToAddWrongProp(propositions, "La réciproque du théorème de Thalès", "raw");
+    tryToAddWrongProp(propositions, "Le théorème de Pythagore", "raw");
+    tryToAddWrongProp(propositions, "La réciproque du théorème de Pythagore", "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { isAskingLength, isSegmentHeight } = identifiers;
+    return isSegmentHeight
+        ? isAskingLength
+            ? "Le théorème de Pythagore"
+            : "La réciproque du théorème de Pythagore"
+        : isAskingLength
+            ? "Le théorème de Thalès"
+            : "La réciproque du théorème de Thalès";
+};
+const getInstruction = (identifiers) => {
+    const { isAskingLength, pointsIdentifiers, isSegmentHeight } = identifiers;
+    const points = pointsIdentifiers.map((p) => PointConstructor.fromIdentifiers(p));
+    let instruction = ``;
+    if (isSegmentHeight) {
+        if (isAskingLength) {
+            instruction = `calculer la longueur $${points[0].name}${points[1].name}$`;
+        }
+        else {
+            instruction = `prouver que le triangle $${points[1].name}${points[2].name}${points[3].name}$ est rectangle en $${points[3].name}$`;
+        }
+    }
+    else {
+        if (isAskingLength) {
+            instruction = `calculer la longueur $${points[1].name}${points[3].name}$`;
+        }
+        else {
+            instruction = `prouver que les droites $\\left(${points[1].name}${points[3].name}\\right)$ et $\\left(${points[0].name}${points[4].name}\\right)$ sont parallèles`;
+        }
+    }
+    return `On donne la figure ci-dessous${!isSegmentHeight && isAskingLength
+        ? `, où les droites $\\left(${points[1].name}${points[3].name}\\right)$ et $\\left(${points[0].name}${points[4].name}\\right)$ sont parallèles.`
+        : "."}
+
+Pour ${instruction}, il faut utiliser... `;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getGGBOptions = (identifiers) => {
+    const { isAskingLength, lengths, pointsIdentifiers, isSegmentHeight } = identifiers;
+    const points = pointsIdentifiers.map((p) => PointConstructor.fromIdentifiers(p));
+    let segments;
+    if (isSegmentHeight) {
+        const withoutA = points.slice(1);
+        segments = withoutA.map((p, i) => new Segment(p, withoutA[(i + 1) % 3], {
+            lengthNode: new NumberNode(lengths[i]),
+        }));
+        segments.push(new Segment(points[3], points[0], {
+            lengthNode: new NumberNode(lengths[3]),
+        }));
+        segments.push(new Segment(points[0], points[1]));
+    }
+    else {
+        segments = points.map((p, i) => new Segment(p, points[(i + 1) % points.length], {
+            lengthNode: new NumberNode(lengths[i]),
+        }));
+        segments.push(new Segment(points[1], points[3]));
+    }
+    const commands = [
+        ...points.flatMap((p) => p.toGGBCommand()),
+        ...segments.flatMap((s, i) => s.toGGBCommands(false, { color: "grey", thickness: 3 })),
+        ...segments
+            .slice(0, segments.length - 1)
+            .flatMap((s, i) => s.getFitCaptionCommands({ size: "scriptsize", color: "red" })),
+        ...(isAskingLength && isSegmentHeight
+            ? new Angle([points[1], points[3], points[0]]).toCommands()
+            : []),
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        hideAxes: true,
+        hideGrid: true,
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints(points),
+    });
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    throw Error("VEA not implemented");
+};
+const getPythagoreOrThalesQuestion = (opts) => {
+    const isSegmentHeight = coinFlip();
+    const isAskingLength = coinFlip();
+    let points;
+    let lengths;
+    const triangle = isSegmentHeight
+        ? RightTriangleConstructor.randomNiceSides({ names: ["D", "B", "C"] })
+        : TriangleConstructor.randomNiceSides({ minAngle: 40 });
+    const summitNames = triangle.points.map((p) => p.name);
+    if (isSegmentHeight) {
+        const triangle = RightTriangleConstructor.randomNiceSides({
+            names: ["D", "B", "C"],
+        });
+        const ratio = round(0.4 + Math.random() * 0.2, 1);
+        const triangleLengths = triangle.sides.map((s) => s.getLength());
+        const A = VectorConstructor.fromPoints(triangle.points[2], triangle.points[0])
+            .times(ratio.toTree())
+            .getEndPoint(triangle.points[0], "A");
+        points = [A, triangle.points[1], triangle.points[2], triangle.points[0]];
+        lengths = [
+            round(triangleLengths[0], 2),
+            round(triangleLengths[1], 2),
+            round(triangleLengths[2], 2),
+            round(A.distanceTo(triangle.points[0]), 2),
+        ];
+    }
+    else {
+        const triangle = TriangleConstructor.randomNiceSides({ minAngle: 40 });
+        const ratio = round(0.4 + Math.random() * 0.2, 1);
+        const dName = "D";
+        const eName = "E";
+        const subTriangle = getSubTriangle({
+            triangle,
+            insidePointsNames: [dName, eName],
+            ratio,
+            isPapillon: false,
+        });
+        const triangleLengths = triangle.sides.map((s) => s.getLength());
+        const subTriangleLengths = subTriangle.sides.map((s) => s.getLength());
+        points = [
+            triangle.points[0],
+            subTriangle.points[0],
+            triangle.points[1],
+            subTriangle.points[2],
+            triangle.points[2],
+        ];
+        lengths = [
+            round(triangleLengths[2] - subTriangleLengths[2], 2),
+            round(subTriangleLengths[2], 2),
+            round(subTriangleLengths[0], 2),
+            round(triangleLengths[0] - subTriangleLengths[0], 2),
+            round(triangleLengths[1], 2),
+        ];
+    }
+    const identifiers = {
+        lengths,
+        pointsIdentifiers: points.map((p) => p.toIdentifiers()),
+        isAskingLength,
+        isSegmentHeight,
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+    return question;
+};
+export const pythagoreOrThales = {
+    id: "pythagoreOrThales",
+    label: "Choisir entre Thalès, Pythagore et leurs réciproques",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPythagoreOrThalesQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    // getHint,
+    // getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    answerType: "QCU",
+};
+const getSubTriangle = ({ triangle, insidePointsNames, ratio, isPapillon, }) => {
+    const [A, B, C] = triangle.points;
+    const [dName, eName] = insidePointsNames;
+    const vecAB = VectorConstructor.fromPoints(A, B).times((1 - ratio).toTree());
+    const pointD = vecAB.getEndPoint(A, dName);
+    const vecCB = VectorConstructor.fromPoints(C, B).times((1 - ratio).toTree());
+    const pointE = vecCB.getEndPoint(C, eName);
+    return new Triangle([pointD, triangle.points[1], pointE], {
+        sidesLengths: triangle.sides.map((s) => round(s.getLength() * Math.abs(ratio), 2).toTree()),
+    });
+};

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

@@ -8,6 +8,7 @@ export * from "./convexity/index.js";
 export * from "./volumes/index.js";
 export * from "./euclidianConstructions/index.js";
 export * from "./shapes/index.js";
+export * from "./euclidian/index.js";
 export * from "./parametric/index.js";
 export * from "./quadrilaterals/index.js";
 export * from "./angles/index.js";

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/geometry/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AAEnC,cAAc,mCAAmC,CAAC;AAClD,cAAc,mBAAmB,CAAC;AAElC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/geometry/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AAEnC,cAAc,mCAAmC,CAAC;AAClD,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC"}

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

@@ -9,7 +9,7 @@ export * from "./volumes/index.js";
 // export * from "./triangles.js";
 export * from "./euclidianConstructions/index.js";
 export * from "./shapes/index.js";
-// export * from "./euclidian/index.js";
+export * from "./euclidian/index.js";
 export * from "./parametric/index.js";
 export * from "./quadrilaterals/index.js";
 export * from "./angles/index.js";

package/lib/exercises/math/geometry/thales/thalesCalcul.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"thalesCalcul.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/thales/thalesCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAqBT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAGL,mBAAmB,EACpB,MAAM,iCAAiC,CAAC;AAQzC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAqJF,KAAK,OAAO,GAAG;IACb,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AA8DF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAwBvD,CAAC"}
+{"version":3,"file":"thalesCalcul.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/thales/thalesCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAqBT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAGL,mBAAmB,EACpB,MAAM,iCAAiC,CAAC;AAQzC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAmJF,KAAK,OAAO,GAAG;IACb,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AA8DF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAwBvD,CAAC"}

package/lib/exercises/math/geometry/thales/thalesCalcul.js

@@ -83,7 +83,7 @@ const getGGBOptions = (identifiers) => {
     const seg = new Segment(points[0], points[1]);
     const commands = [
         ...triangle.commands,
-        ...points.flatMap((p) => p.toGGBCommand({ style: 0, color: "#444444", size: 4 })),
+        ...points.flatMap((p) => p.toGGBCommand({ color: "#444444", size: 4 })),
         ...seg.toGGBCommands(false),
     ];
     if (identifiers.isPapillon) {

package/lib/exercises/math/primitive/polynomialPrimitive.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"polynomialPrimitive.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/polynomialPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAER,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAGJ,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,iBAAiB,CAAC,WAAW,CAiBjE,CAAC;AAEF,eAAO,MAAM,kCAAkC,EAAE,YAAY,CAAC,WAAW,CAexE,CAAC;AAEF,eAAO,MAAM,gCAAgC,EAAE,GAAG,CAAC,WAAW,CAa7D,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAarD,CAAC"}
+{"version":3,"file":"polynomialPrimitive.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/polynomialPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAIR,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAGJ,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAiBF,eAAO,MAAM,sBAAsB,EAAE,iBAAiB,CAAC,WAAW,CAcjE,CAAC;AAEF,eAAO,MAAM,kCAAkC,EAAE,YAAY,CAAC,WAAW,CAexE,CAAC;AAEF,eAAO,MAAM,gCAAgC,EAAE,GAAG,CAAC,WAAW,CA8B7D,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAWrD,CAAC"}

package/lib/exercises/math/primitive/polynomialPrimitive.js

@@ -2,19 +2,34 @@ import { addValidProp, tryToAddWrongProp, } from "../../../exercises/exercise.js
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
 import { Polynomial, PolynomialConstructor, } from "../../../math/polynomials/polynomial.js";
 import { randint } from "../../../math/utils/random/randint.js";
+import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
 import { shuffle } from "../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getInstruction = (identifiers) => {
+    const polynomial = new Polynomial(identifiers.coeffs);
+    return `Déterminer la forme générale des primitives de la fonction polynomiale $f$ définie par : 
+
+$$
+f(x) = ${polynomial.toTex()}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const polynomial = new Polynomial(identifiers.coeffs);
+    const integralPolynomial = polynomial.integrateToNode();
+    const answer = `${integralPolynomial.toTex()}`;
+    return answer;
+};
 export const getPolynomialPrimitive = () => {
     const degree = randint(1, 4);
     const polynomial = PolynomialConstructor.randomWithOrder(degree);
-    const integralPolynomial = polynomial.integrateToNode();
-    const answer = `${integralPolynomial.toTex()}`;
+    const identifiers = { coeffs: polynomial.coefficients };
     const question = {
-        instruction: `Déterminer la forme générale des primitives de la fonction polynomiale $f$ définie par $f(x) = ${polynomial.toTex()}$.`,
+        instruction: getInstruction(identifiers),
         startStatement: `F(x)`,
-        answer,
+        answer: getAnswer(identifiers),
         keys: ["x", "C"],
         answerFormat: "tex",
-        identifiers: { coeffs: polynomial.coefficients },
+        identifiers,
     };
     return question;
 };
@@ -28,22 +43,38 @@ export const getPolynomialPrimitivePropositions = (n, { answer, coeffs }) => {
     }
     return shuffle(propositions);
 };
-export const isPolynomialPrimitiveAnswerValid = (ans, { coeffs }) => {
-    const opts = {
-        allowFractionToDecimal: true,
-        forbidPowerToProduct: true,
-    };
-    const polynomial = new Polynomial(coeffs);
-    const integralPolynomial = polynomial.integrateToNode(opts);
-    const texs = integralPolynomial.toAllValidTexs(opts);
-    return texs.includes(ans);
+export const isPolynomialPrimitiveAnswerValid = (ans, { coeffs, answer }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        // console.log(
+        //   parsed
+        //     .simplify({
+        //       towardsDistribute: true,
+        //       forbidFactorize: true,
+        //       decimalToFractions: true,
+        //       forceDistributeFractions: true,
+        //       forceIsolateMonomCoeffs: true,
+        //     })
+        //     .toTex(),
+        // );
+        return (parsed
+            .simplify({
+            towardsDistribute: true,
+            forbidFactorize: true,
+            forceDistributeFractions: true,
+        })
+            .toTex() === answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
 };
 export const polynomialPrimitive = {
     id: "polynomialPrimitive",
     connector: "=",
     label: "Primitive d'une fonction polynomiale",
-    levels: ["TermSpé", "MathComp"],
-    sections: ["Primitives"],
     isSingleStep: false,
     generator: (nb) => getDistinctQuestions(getPolynomialPrimitive, nb),
     qcmTimer: 60,

package/lib/exercises/math/probaStat/probaFromTableWithContext.js

@@ -46,9 +46,9 @@ const getAnswer = (identifiers) => {
 };
 const getProbaFromTableWithContextQuestion = () => {
     const aCapB = randint(1, 20);
-    const aCapBBarre = randint(1, 20);
-    const aBarreCapB = randint(1, 20);
-    const aBarreCapBBarre = randint(1, 20);
+    const aCapBBarre = randint(1, 20, [aCapB]);
+    const aBarreCapB = randint(1, 20, [aCapB, aCapBBarre]);
+    const aBarreCapBBarre = randint(1, 20, [aCapB, aCapBBarre, aBarreCapB]);
     const total = aBarreCapB + aBarreCapBBarre + aCapB + aCapBBarre;
     const aTotal = aCapB + aCapBBarre;
     const bTotal = aCapB + aBarreCapB;

package/lib/exercises/math/spaceGeometry/basis/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./spaceCoordinatesInPrism.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/basis/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC"}

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

@@ -0,0 +1 @@
+export * from "./spaceCoordinatesInPrism.js";

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

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    l: number;
+    L: number;
+    h: number;
+    askedPoint: string;
+    givenPoints: string[];
+};
+export declare const spaceCoordinatesInPrism: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=spaceCoordinatesInPrism.d.ts.map

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

@@ -0,0 +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"}