math-exercises 3.0.201 → 3.0.203

package/lib/exercises/math/geometry/angles/anglesUsingIsParallel.js

@@ -9,10 +9,45 @@ import { randfloat } from "../../../../math/utils/random/randfloat.js";
 import { round } from "../../../../math/utils/round.js";
 import { PiNode } from "../../../../tree/nodes/numbers/piNode.js";
 import { add } from "../../../../tree/nodes/operators/addNode.js";
-import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
-import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { FractionNode } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply, MultiplyNode, } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract, SubstractNode, } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+class MyLine extends Line {
+    pointA;
+    pointB;
+    isVertical;
+    a;
+    b;
+    name;
+    unformatedName;
+    ggbName;
+    constructor(pointA, pointB, name) {
+        super(new Point("A", 0, 0), new Point("B", 1, 1), "L");
+        this.pointA = pointA;
+        this.pointB = pointB;
+        this.unformatedName = name ?? `${pointA.name}${pointB.name}`;
+        this.name = name ?? `\\left(${pointA.name}${pointB.name}\\right)`;
+        this.ggbName = name ?? `line${pointA.name}${pointB.name}`;
+        this.isVertical = pointA.x.equals(pointB.x);
+        if (this.isVertical) {
+            this.a = undefined;
+            this.b = undefined;
+        }
+        else {
+            this.a = new FractionNode(new SubstractNode(this.pointB.y, this.pointA.y), new SubstractNode(this.pointB.x, this.pointA.x))
+                .evaluate()
+                .toTree();
+            this.b = new SubstractNode(this.pointA.y, new MultiplyNode(this.a, this.pointA.x))
+                .evaluate()
+                .toTree();
+        }
+    }
+}
 const createVector = (from, to, name, precision = 5) => {
     return new Vector(name, round(substract(to.x, from.x).evaluate(), precision).toTree(), round(substract(to.y, from.y).evaluate(), precision).toTree());
 };
@@ -26,9 +61,16 @@ const degreesToRadians = (angleInDegrees, precision) => {
     const oneOver180 = 0.00555555555555555;
     return round(multiply(multiply(angleInDegrees, PiNode), oneOver180).evaluate(), precision);
 };
+const rotateVector = (vec, angle, name) => {
+    //x' = cos(t)*x -sin(t)*y
+    //y' = sin(t)*x + cos(t)*y
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    return new Vector(name, substract(multiply(cos, vec.x), multiply(sin, vec.y)).evaluate().toTree(), add(multiply(sin, vec.x), multiply(cos, vec.y)).evaluate().toTree());
+};
 const rotatePoint = (target, angle, center, name, precision = 2) => {
     const vSrc = createVector(center, target, "vSrc", precision);
-    const vRotated = vSrc.rotate(angle, "vRotated");
+    const vRotated = rotateVector(vSrc, angle, "vRotated");
     return createPoint(add(center.x, vRotated.x).evaluate(), add(center.y, vRotated.y).evaluate(), name, precision);
 };
 const buildLines = (cAngleInDegreesTop, cAngleInDegreesBottom) => {
@@ -49,12 +91,12 @@ const buildLines = (cAngleInDegreesTop, cAngleInDegreesBottom) => {
     ].map((angleInDegrees) => degreesToRadians(angleInDegrees, precision));
     //build top line
     const heightAvgTopLine = 2;
-    const lineTop = new Line(new Point("A", (-4 + randfloat(-1, 1, 1)).toTree(), (heightAvgTopLine + randfloat(-1, 1, 1)).toTree()), new Point("B", (4 + randfloat(-1, 1, 1)).toTree(), (heightAvgTopLine + randfloat(-1, 1, 1)).toTree()), "d_1");
+    const lineTop = new MyLine(new Point("A", (-4 + randfloat(-1, 1, 1)).toTree(), (heightAvgTopLine + randfloat(-1, 1, 1)).toTree()), new Point("B", (4 + randfloat(-1, 1, 1)).toTree(), (heightAvgTopLine + randfloat(-1, 1, 1)).toTree()), "d1");
     //build secant line
     const pointSTop = midPoint(lineTop.pointA, lineTop.pointB, "C", 5);
-    const lineSecant = new Line(pointSTop, rotatePoint(lineTop.pointA, PiNode.value - cAngleTop, pointSTop, "D", 5), "s");
+    const lineSecant = new MyLine(pointSTop, rotatePoint(lineTop.pointA, PiNode.value - cAngleTop, pointSTop, "D", 5), "s");
     //build bottom line
-    const lineBottom = new Line(lineSecant.pointB, rotatePoint(lineSecant.pointA, cAngleBottom, lineSecant.pointB, "E", 5), "d_2");
+    const lineBottom = new MyLine(lineSecant.pointB, rotatePoint(lineSecant.pointA, cAngleBottom, lineSecant.pointB, "E", 5), "d2");
     return {
         lineTop,
         lineSecant,
@@ -85,7 +127,7 @@ class IntersectionConstructor {
         const arrPointRotated = arrPointSrc.map((p) => {
             return rotatePoint(p, rotationAngle, rotationCenter, p.name, precision);
         });
-        return new Intersection(arrPointRotated[0], new Line(arrPointRotated[1], arrPointRotated[2], intersectionSrc.lineH.name), new Line(arrPointRotated[3], arrPointRotated[4], intersectionSrc.lineV.name));
+        return new Intersection(arrPointRotated[0], new MyLine(arrPointRotated[1], arrPointRotated[2], intersectionSrc.lineH.name), new MyLine(arrPointRotated[3], arrPointRotated[4], intersectionSrc.lineV.name));
     }
 }
 class Intersection {
@@ -100,9 +142,9 @@ class Intersection {
     static createLineBothSideOfPoint(lineBase, pointCenter, lineIntersector, wrtAxis) {
         switch (wrtAxis) {
             case "x":
-                return new Line(lineBase.intersect(lineIntersector.translate(-1, 0), pointCenter.name + "_xm"), lineBase.intersect(lineIntersector.translate(+1, 0), pointCenter.name + "_xM"), lineBase.name);
+                return new MyLine(lineBase.intersect(lineIntersector.translate(-1, 0), pointCenter.name + "xm"), lineBase.intersect(lineIntersector.translate(+1, 0), pointCenter.name + "xM"), lineBase.name);
             case "y":
-                return new Line(lineBase.intersect(lineIntersector.translate(0, -1), pointCenter.name + "_ym"), lineBase.intersect(lineIntersector.translate(0, +1), pointCenter.name + "_yM"), lineBase.name);
+                return new MyLine(lineBase.intersect(lineIntersector.translate(0, -1), pointCenter.name + "ym"), lineBase.intersect(lineIntersector.translate(0, +1), pointCenter.name + "yM"), lineBase.name);
         }
     }
     getAngle(angleIndex) {
@@ -177,7 +219,6 @@ const getCorrection = (identifiers) => {
                 return `alternes-internes`;
             case "correspondants":
                 return `correspondants`;
-                break;
             case "alternes-externes":
                 return `alternes-externes`;
             case "autres":
@@ -222,13 +263,17 @@ const getGGBOptions = (identifiers, opts) => {
         arrIntersectionIds[0].lineV, //secant
     ]
         .map((lIds) => LineConstructor.fromIdentifiers(lIds))
+        .map((line, i) => {
+        line.ggbName = `d_${i}`;
+        return line;
+    })
         .flatMap((l, i) => l.toGGBCommands(false, {
         color: "black",
         showLabel: i < 2,
     }));
     const arrCommandAngles = arrAngle
         .map((angle, i) => {
-        angle.name = `angle_${i}`;
+        angle.name = `angle${i}`;
         return angle;
     })
         .flatMap((a, i) => [
@@ -249,7 +294,7 @@ const getGGBOptions = (identifiers, opts) => {
         }),
     ]);
     const arrCommandOther = [
-        `lb_parallel = Text("\\tex$d_1$${isParallel ? "∥" : "∦"}$d_2$", (${-4.5},${-3.1}), false, true, -1, -1)`,
+        `lbparallel = Text("\\tex$d_1$${isParallel ? "∥" : "∦"}$d_2$", (${-4.5},${-3.1}), false, true, -1, -1)`,
     ];
     const ggb = new GeogebraConstructor({
         commands: [
@@ -280,46 +325,22 @@ const getKeys = () => {
     ];
 };
 const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
-};
-const optsDefault = {
-    angleTypes: ["alternes-internes"],
-    isFakeDisplay: true,
-    nbDigits: "0",
+    if (ans === answer) {
+        return true;
+    }
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = parseAlgebraic(answer);
+        const isValid = NodeComparator.isEqualViaSub(nodeAns, nodeAnswer) ||
+            NodeComparator.isEqualViaFrac(nodeAns, nodeAnswer);
+        return isValid;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
 };
-const options = [
-    {
-        id: "angleTypes",
-        label: "Type d'angles",
-        target: GeneratorOptionTarget.generation,
-        type: GeneratorOptionType.multiselect,
-        values: [
-            "alternes-internes",
-            "correspondants",
-            "alternes-externes",
-            "autres",
-        ],
-        defaultValue: optsDefault.angleTypes,
-    },
-    {
-        id: "isFakeDisplay",
-        label: "Affichage trompeur",
-        target: GeneratorOptionTarget.generation,
-        type: GeneratorOptionType.checkbox,
-        defaultValue: optsDefault.isFakeDisplay,
-    },
-    {
-        id: "nbDigits",
-        label: "Nombre de décimales",
-        target: GeneratorOptionTarget.generation,
-        type: GeneratorOptionType.select,
-        values: ["0", "1", "2"],
-        defaultValue: optsDefault.nbDigits,
-    },
-];
-const getAnglesUsingIsParallelQuestion = (optsIn) => {
+const createRandomIdentifiers = (opts) => {
     const isParallel = coinFlip();
-    const opts = optsIn ?? optsDefault;
     //---create intersections---
     //this config will be used to create ggb lines
     function createConfigGeom(isParallelInGeom, isLookingParallel) {
@@ -412,6 +433,72 @@ const getAnglesUsingIsParallelQuestion = (optsIn) => {
         arrAngleIndex,
         arrAngleForLabel,
     };
+    return identifiers;
+};
+const isIdentifiersQCPassed = (identifiers) => {
+    const isExploding = (identifiers) => {
+        let isExploding = false;
+        try {
+            getAnswer(identifiers);
+            getCorrection(identifiers);
+        }
+        catch (_) {
+            isExploding = true;
+        }
+        return isExploding;
+    };
+    return !isExploding(identifiers);
+};
+const createQCPassedIdentifiers = (opts) => {
+    let identifiers;
+    let counter = -1;
+    let isValid = false;
+    while (!isValid && counter < 100) {
+        counter++;
+        let identifiersCandidate;
+        try {
+            identifiersCandidate = createRandomIdentifiers(opts);
+            isValid = isIdentifiersQCPassed(identifiersCandidate);
+        }
+        catch (_) {
+            isValid = false;
+        }
+        if (isValid) {
+            identifiers = identifiersCandidate;
+        }
+    }
+    {
+        identifiers = createRandomIdentifiers(opts);
+        isValid = true;
+    }
+    if (!isValid) {
+        const identifiersDefault = (() => {
+            const lineH1 = new MyLine(new Point("H11", -4, 3), new Point("H12", 8, 1), "h");
+            const lineV = new MyLine(new Point("V1", 1, 0), new Point("V2", 3, 4), "h");
+            const lineH2 = new MyLine(new Point("H21", -4, -2), new Point("H22", 6, -2), "h");
+            const intersection1 = IntersectionConstructor.fromBaselines("i1", lineH1, lineV);
+            const intersection2 = IntersectionConstructor.fromBaselines("i2", lineH2, lineV);
+            const angleType = "alternes-internes";
+            const arrAngleForLabel = [50, 130, 50, 130];
+            const arrAngleIndex = random([
+                [2, 0],
+                [3, 1],
+            ]);
+            return {
+                isParallel: false,
+                arrIntersectionIds: [intersection1, intersection2].map((intersection) => intersection.toIdentifiers()),
+                angleType,
+                arrAngleForLabel,
+                arrAngleIndex,
+            };
+        })();
+        identifiers = identifiersDefault;
+    }
+    return identifiers;
+};
+const getAnglesUsingIsParallelQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const identifiers = createQCPassedIdentifiers(opts);
     return getQuestionFromIdentifiers(identifiers, opts);
 };
 const getQuestionFromIdentifiers = (identifiers, opts) => {
@@ -427,6 +514,41 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
     };
     return question;
 };
+const optsDefault = {
+    angleTypes: ["alternes-internes"],
+    isFakeDisplay: true,
+    nbDigits: "0",
+};
+const options = [
+    {
+        id: "angleTypes",
+        label: "Type d'angles",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: [
+            "alternes-internes",
+            "correspondants",
+            "alternes-externes",
+            "autres",
+        ],
+        defaultValue: optsDefault.angleTypes,
+    },
+    {
+        id: "isFakeDisplay",
+        label: "Affichage trompeur",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.checkbox,
+        defaultValue: optsDefault.isFakeDisplay,
+    },
+    {
+        id: "nbDigits",
+        label: "Nombre de décimales",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["0", "1", "2"],
+        defaultValue: optsDefault.nbDigits,
+    },
+];
 export const anglesUsingIsParallel = {
     id: "anglesUsingIsParallel",
     label: "Déterminer un angle issu d'une sécante en utilisant le parallélisme",
@@ -441,7 +563,6 @@ export const anglesUsingIsParallel = {
     getHint,
     getCorrection,
     hasHintAndCorrection: true,
-    answerType: "QCU",
     getQuestionFromIdentifiers,
     hasGeogebra: true,
 };

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

@@ -1,3 +1,4 @@
 export * from "./recognizeAngleType.js";
 export * from "./parallelogramFourthAngle.js";
+export * from "./anglesUsingIsParallel.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/angles/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,+BAA+B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/angles/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,+BAA+B,CAAC;AAE9C,cAAc,4BAA4B,CAAC"}

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

@@ -1,4 +1,4 @@
 export * from "./recognizeAngleType.js";
 export * from "./parallelogramFourthAngle.js";
 //export * from "./isParallelUsingAngles.js";
-// export * from "./anglesUsingIsParallel.js";
+export * from "./anglesUsingIsParallel.js";

package/lib/exercises/math/geometry/parametric/extractVectorFromParametricLine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extractVectorFromParametricLine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/parametric/extractVectorFromParametricLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AA6GF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAkBjE,CAAC"}
+{"version":3,"file":"extractVectorFromParametricLine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/parametric/extractVectorFromParametricLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAgHF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAmBjE,CAAC"}

package/lib/exercises/math/geometry/parametric/extractVectorFromParametricLine.js

@@ -33,29 +33,33 @@ où $t\\in \\mathbb{R}$.
 Donner les coordonnées d'un vecteur directeur de la droite $d$.
   `;
 };
-// const getHint: GetHint<Identifiers> = (identifiers) => {
-//   return `Il suffit de remplacer $t$ par une valeur afin d'obtenir les coordonnées d'un point de la droite.`;
-// };
-// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
-//   const line = new ParametricLine(
-//     SpacePointConstructor.fromScalars(identifiers.startPoint),
-//     SpaceVectorConstructor.fromScalars(identifiers.vector),
-//   );
-//   const detailedEquations = line.toDetailedEvaluation(new NumberNode(0));
-//   const point = line.getPointCoords(new NumberNode(0));
-//   return `Pour obtenir les coordonnées d'un point appartenant à la droite, il suffit de remplacer $t$ par n'importe quelle valeur dans les trois équations. Par simplicité, prenons $t = 0$. On obtient alors :
-// $$
-// \\left\\{\\begin{matrix}
-// x=${detailedEquations[0].toTex()} \\\\
-// y=${detailedEquations[1].toTex()} \\\\
-// z=${detailedEquations[2].toTex()}
-// \\end{matrix}
-// \\right.
-// $$
-// On en déduit que le point de coordonnées $\\left(${point
-//     .map((e) => e.toTex())
-//     .join(";")}\\right)$ appartient à la droite $d$.`;
-// };
+const getHint = () => {
+    return `Dans un repère de l'espace, la droite $d$ passant par le point $A(x_0; y_0; z_0)$ et de vecteur directeur $\\overrightarrow{u}(a,b,c)$ a pour représentation paramétrique : 
+  
+$$
+\\left\\{\\begin{matrix}
+x=x_0 + at \\\\
+y=y_0 + bt \\\\
+z=z_0 + ct
+\\end{matrix}
+\\right.
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { startPoint, vector } = identifiers;
+    return `Dans un repère de l'espace, la droite $d$ passant par le point $A(x_0; y_0; z_0)$ et de vecteur directeur $\\overrightarrow{u}(a,b,c)$ a pour représentation paramétrique : 
+  
+$$
+\\left\\{\\begin{matrix}
+x=x_0 + at \\\\
+y=y_0 + bt \\\\
+z=z_0 + ct
+\\end{matrix}
+\\right.
+$$
+
+Ici, la droite $d$ passe donc par le point $A(${startPoint[0]}; ${startPoint[1]}; ${startPoint[2]})$ et a pour vecteur directeur $\\overrightarrow{u}(${vector[0]}; ${vector[1]}; ${vector[2]})$.`;
+};
 const getKeys = () => {
     return ["semicolon"];
 };
@@ -87,8 +91,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: getKeys(identifiers),
         answerFormat: "tex",
         identifiers,
-        // hint: getHint(identifiers),
-        // correction: getCorrection(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -107,5 +111,6 @@ export const extractVectorFromParametricLine = {
     // getCorrection,
     getAnswer,
     getInstruction,
+    hasHintAndCorrection: true,
     getQuestionFromIdentifiers,
 };

package/lib/exercises/math/geometry/parametric/pointFromParametricLine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pointFromParametricLine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/parametric/pointFromParametricLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAwFF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAmBzD,CAAC"}
+{"version":3,"file":"pointFromParametricLine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/parametric/pointFromParametricLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAkJF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAoBzD,CAAC"}

package/lib/exercises/math/geometry/parametric/pointFromParametricLine.js

@@ -4,7 +4,10 @@ import { ParametricLine } from "../../../../math/geometry/parametricLine.js";
 import { SpacePointConstructor } from "../../../../math/geometry/spacePoint.js";
 import { SpaceVectorConstructor } from "../../../../math/geometry/spaceVector.js";
 import { randint } from "../../../../math/utils/random/randint.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { doWhile } from "../../../../utils/doWhile.js";
 import { randomLetter } from "../../../../utils/strings/randomLetter.js";
 const getPropositions = (n, { answer }) => {
     const propositions = [];
@@ -31,14 +34,57 @@ où $t\\in \\mathbb{R}$.
 Le point $${askedPoint.toTexWithCoords()}$ appartient-il à $d$ ?
   `;
 };
-// const getHint: GetHint<Identifiers> = (identifiers) => {};
-// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getHint = () => {
+    return `Remplace $x$, $y$ et $z$ dans l'équation paramétrique par les coordonnées du point. 
+  
+Le point appartient à la droite $d$ si et seulement s'il existe une valeur de $t$ qui est solution des trois équations.`;
+};
+const getCorrection = (identifiers) => {
+    const { isOnLine, askedPointName, askedPointCoords, startPoint, vector } = identifiers;
+    const askedPoint = SpacePointConstructor.fromScalars(askedPointCoords, askedPointName);
+    const line = new ParametricLine(SpacePointConstructor.fromScalars(startPoint), SpaceVectorConstructor.fromScalars(vector));
+    //t1 = x-p.x / v.x
+    const t1 = frac(substract(askedPointCoords[0], startPoint[0]), vector[0]);
+    const t2 = frac(substract(askedPointCoords[1], startPoint[1]), vector[1]);
+    const t3 = frac(substract(askedPointCoords[2], startPoint[2]), vector[2]);
+    return `On remplace $x$, $y$ et $z$ par les coordonnées du point :
+  
+
+$$
+\\left\\{\\begin{matrix}
+${askedPoint.x.toTex()}=${line.equations[0].toTex()} \\\\
+${askedPoint.y.toTex()}=${line.equations[1].toTex()} \\\\
+${askedPoint.z.toTex()}=${line.equations[2].toTex()} 
+\\end{matrix}
+\\right.
+$$
+
+On résout alors les trois équations : 
+
+$$
+\\left\\{\\begin{matrix}
+t=${t1.toSimplificationTex()}  \\\\
+t=${t2.toSimplificationTex()} \\\\
+t=${t3.toSimplificationTex()} 
+\\end{matrix}
+\\right.
+$$
+
+${isOnLine
+        ? `Puisque $t = ${t1
+            .simplify()
+            .toTex()}$ est solution du système, le point $${askedPointName}$ appartient bien à la droite.`
+        : `Puisque ce système n'a pas de solution, le point $${askedPointName}$ n'appartient pas à la droite.`}
+  `;
+};
 const getKeys = () => {
     return [];
 };
 const getPointFromParametricLineQuestion = () => {
     const startPoint = SpacePointConstructor.random("A");
-    const vector = SpaceVectorConstructor.random("B");
+    const vector = doWhile(() => SpaceVectorConstructor.random("B"), (v) => v.x.equals((0).toTree()) ||
+        v.y.equals((0).toTree()) ||
+        v.z.equals((0).toTree()));
     const isOnLine = coinFlip();
     const askedPointName = randomLetter(true, ["O"]);
     let askedPoint;
@@ -68,8 +114,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: getKeys(identifiers),
         answerFormat: "tex",
         identifiers,
-        // hint: getHint(identifiers),
-        // correction: getCorrection(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -90,4 +136,5 @@ export const pointFromParametricLine = {
     answerType: "QCU",
     getInstruction,
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/integration/fromExpr/areaBetweenCrossingCurvesFixedPosFromExpr.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"areaBetweenCrossingCurvesFixedPosFromExpr.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/integration/fromExpr/areaBetweenCrossingCurvesFixedPosFromExpr.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAarC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAc7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;IAC1B,aAAa,EAAE,CAAC,eAAe,EAAE,eAAe,CAAC,CAAC;CACnD,CAAC;AAojBF,KAAK,OAAO,GAAG;IACb,kBAAkB,EAAE,MAAM,CAAC;IAC3B,gBAAgB,EAAE,MAAM,CAAC;IACzB,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAkDF,eAAO,MAAM,yCAAyC,EAAE,QAAQ,CAC9D,WAAW,EACX,OAAO,CAsBR,CAAC"}
+{"version":3,"file":"areaBetweenCrossingCurvesFixedPosFromExpr.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/integration/fromExpr/areaBetweenCrossingCurvesFixedPosFromExpr.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAgBrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAc7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;IAC1B,aAAa,EAAE,CAAC,eAAe,EAAE,eAAe,CAAC,CAAC;CACnD,CAAC;AA6iBF,KAAK,OAAO,GAAG;IACb,kBAAkB,EAAE,MAAM,CAAC;IAC3B,gBAAgB,EAAE,MAAM,CAAC;IACzB,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAkDF,eAAO,MAAM,yCAAyC,EAAE,QAAQ,CAC9D,WAAW,EACX,OAAO,CAsBR,CAAC"}

package/lib/exercises/math/integration/fromExpr/areaBetweenCrossingCurvesFixedPosFromExpr.js

@@ -315,43 +315,34 @@ const createRandomIdentifiers = (opts) => {
     const [nodeBoundLow, nodeBoundHigh] = [valueBoundLow, valueBoundHigh].map((v) => v.toTree());
     const [nodePBottom, nodePTop] = (() => {
         const [point1, point2] = zip(["P1", "P2"], [nodeBoundLow, nodeBoundHigh]).map(([name, nodeAbscissa]) => new Point(name, nodeAbscissa, randint(0, 6)));
-        switch (opts.typeCrossingCurves) {
-            case "Trinôme/Trinôme": {
-                const [nodeABottom, nodeATop] = [
-                    frac(randint(1, 3), 10),
-                    frac(randint(-2, 0), 10),
-                ];
-                const [nodePBottom, nodePTop] = [nodeABottom, nodeATop].map((nodeA) => createNodeFTrinomFromPoints(nodeA, [point1, point2]));
-                return [nodePBottom, nodePTop];
+        const [nodeABottom, nodeATop] = (() => {
+            switch (opts.typeCrossingCurves) {
+                case "Trinôme/Trinôme": {
+                    return [frac(randint(1, 3), 10), frac(randint(-2, 0), 10)];
+                }
+                case "Trinôme/Affine": {
+                    return [(0).toTree(), frac(randint(-2, 0), 10)];
+                }
+                case "Affine/Trinôme": {
+                    return [frac(randint(1, 3), 10), (0).toTree()];
+                }
+                default:
+                    throw new Error("Unsupported opts.typeCrossingCurves: " + opts.typeCrossingCurves);
             }
-            case "Trinôme/Affine": {
-                const [nodeABottom, nodeATop] = [
-                    (0).toTree(),
-                    frac(randint(-2, 0), 10),
-                ];
-                const [nodePBottom, nodePTop] = [nodeABottom, nodeATop].map((nodeA) => createNodeFTrinomFromPoints(nodeA, [point1, point2]));
-                return [nodePBottom, nodePTop];
-            }
-            case "Affine/Trinôme": {
-                const [nodeABottom, nodeATop] = [frac(randint(1, 3), 10), (0).toTree()];
-                const [nodePBottom, nodePTop] = [nodeABottom, nodeATop].map((nodeA) => createNodeFTrinomFromPoints(nodeA, [point1, point2]));
-                return [nodePBottom, nodePTop];
-            }
-            default:
-                throw new Error("Unsupported opts.typeCrossingCurves: " + opts.typeCrossingCurves);
-        }
+        })();
+        const isShouldSimplify = true;
+        const simplifyOptionsPass1 = {
+            towardsDistribute: true,
+            calculatePowers: true,
+            forceAddFractions: true,
+        };
+        const simplifyOptionsPass2 = {
+            forbidFactorize: false,
+            forceAddFractions: true,
+        };
+        return [nodeABottom, nodeATop].map((nodeA) => createNodeFTrinomFromPoints(nodeA, [point1, point2], isShouldSimplify, simplifyOptionsPass1, simplifyOptionsPass2));
     })();
-    const [nodeF, nodeG] = [nodePBottom, nodePTop].map((nodeP) => nodeP
-        .simplify({
-        towardsDistribute: true,
-        calculatePowers: true,
-        forceAddFractions: true,
-    })
-        .simplify({
-        towardsDistribute: true,
-        forceDistributeFractions: true,
-        forbidFactorize: true,
-    }));
+    const [nodeF, nodeG] = [nodePBottom, nodePTop];
     const identifiers = {
         nodeIdsF: nodeF.toIdentifiers(),
         nodeIdsG: nodeG.toIdentifiers(),

package/lib/exercises/math/integration/fromExpr/index.d.ts

@@ -3,6 +3,7 @@ export * from "./byParts/index.js";
 export * from "./meanValue/index.js";
 export * from "./boundIntegralByManualRectanglesMethodFromExpr.js";
 export * from "./boundIntegralByBoundingFunctionWithAffinesFromExpr.js";
+export * from "./areaBetweenCrossingCurvesFixedPosFromExpr.js";
 export * from "./integralFromExpr.js";
 export * from "./checkIsPrimitiveFromExpr.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/integration/fromExpr/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/integration/fromExpr/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AAErC,cAAc,oDAAoD,CAAC;AACnE,cAAc,yDAAyD,CAAC;AAExE,cAAc,uBAAuB,CAAC;AACtC,cAAc,+BAA+B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/integration/fromExpr/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AAErC,cAAc,oDAAoD,CAAC;AACnE,cAAc,yDAAyD,CAAC;AACxE,cAAc,gDAAgD,CAAC;AAC/D,cAAc,uBAAuB,CAAC;AACtC,cAAc,+BAA+B,CAAC"}

package/lib/exercises/math/integration/fromExpr/index.js

@@ -3,6 +3,6 @@ export * from "./byParts/index.js";
 export * from "./meanValue/index.js";
 export * from "./boundIntegralByManualRectanglesMethodFromExpr.js";
 export * from "./boundIntegralByBoundingFunctionWithAffinesFromExpr.js";
-// export * from "./areaBetweenCrossingCurvesFixedPosFromExpr.js";
+export * from "./areaBetweenCrossingCurvesFixedPosFromExpr.js";
 export * from "./integralFromExpr.js";
 export * from "./checkIsPrimitiveFromExpr.js";

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

@@ -2,13 +2,9 @@ export * from "./polynomLimit.js";
 export * from "./polynomLimitNoFI.js";
 export * from "./rationalFracForbiddenValueLimit.js";
 export * from "./rationalFracLimit.js";
-export * from "./sequenceGeometricLimit.js";
-export * from "./sequencePolynomLimit.js";
-export * from "./sequencePolynomNoFILimit.js";
-export * from "./sequencePolynomProductLimit.js";
-export * from "./sequenceRationalFracLimit.js";
 export * from "./limitReading.js";
 export * from "./frac1XTimesALogXPlusBLimit.js";
 export * from "./kLogXPlusTrinomLimit.js";
 export * from "./logOfPolynomialLimit.js";
+export * from "./sequences/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/limits/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sCAAsC,CAAC;AACrD,cAAc,wBAAwB,CAAC;AACvC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kCAAkC,CAAC;AACjD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,mBAAmB,CAAC;AAClC,cAAc,iCAAiC,CAAC;AAChD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,2BAA2B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/limits/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sCAAsC,CAAC;AACrD,cAAc,wBAAwB,CAAC;AAEvC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iCAAiC,CAAC;AAChD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sBAAsB,CAAC"}

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

@@ -2,12 +2,8 @@ export * from "./polynomLimit.js";
 export * from "./polynomLimitNoFI.js";
 export * from "./rationalFracForbiddenValueLimit.js";
 export * from "./rationalFracLimit.js";
-export * from "./sequenceGeometricLimit.js";
-export * from "./sequencePolynomLimit.js";
-export * from "./sequencePolynomNoFILimit.js";
-export * from "./sequencePolynomProductLimit.js";
-export * from "./sequenceRationalFracLimit.js";
 export * from "./limitReading.js";
 export * from "./frac1XTimesALogXPlusBLimit.js";
 export * from "./kLogXPlusTrinomLimit.js";
 export * from "./logOfPolynomialLimit.js";
+export * from "./sequences/index.js";