math-exercises 3.0.124 → 3.0.126

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

@@ -0,0 +1,402 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, GeneratorOptionTarget, GeneratorOptionType, } 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 { Line, LineConstructor, } from "../../../../math/geometry/line.js";
+import { Point, PointConstructor, } from "../../../../math/geometry/point.js";
+import { Vector } from "../../../../math/geometry/vector.js";
+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 { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+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());
+};
+const createPoint = (x, y, name, precision = 5) => {
+    return new Point(name, round(x, precision), round(y, precision));
+};
+const midPoint = (pointA, pointB, name, precision = 2) => {
+    return createPoint(multiply(add(pointA.x, pointB.x), 0.5).evaluate(), multiply(add(pointA.y, pointB.y), 0.5).evaluate(), name, precision);
+};
+const degreesToRadians = (angleInDegrees, precision) => {
+    const oneOver180 = 0.00555555555555555;
+    return round(multiply(multiply(angleInDegrees, PiNode), oneOver180).evaluate(), precision);
+};
+const rotatePoint = (target, angle, center, name, precision = 2) => {
+    const vSrc = createVector(center, target, "vSrc", precision);
+    const vRotated = vSrc.rotate(angle, "vRotated");
+    return createPoint(add(center.x, vRotated.x).evaluate(), add(center.y, vRotated.y).evaluate(), name, precision);
+};
+const buildLines = (cAngleInDegreesTop, cAngleInDegreesBottom) => {
+    //we build the quasiparallels using corresponding angles
+    /*
+           cAngleTop/
+    topLine------------------------
+                    /
+                   /
+    cAngleBottom/
+    bottomLine----------------------
+                /
+  */
+    const precision = 5;
+    const [cAngleTop, cAngleBottom] = [
+        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");
+    //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");
+    //build bottom line
+    const lineBottom = new Line(lineSecant.pointB, rotatePoint(lineSecant.pointA, cAngleBottom, lineSecant.pointB, "E", 5), "d_2");
+    return {
+        lineTop,
+        lineSecant,
+        lineBottom,
+    };
+};
+class IntersectionConstructor {
+    static fromBaselines(pointName, lineHBase, lineVBase) {
+        const center = lineHBase.intersect(lineVBase, pointName);
+        const lineH = Intersection.createLineBothSideOfPoint(lineHBase, center, lineVBase, "x");
+        const lineV = Intersection.createLineBothSideOfPoint(lineVBase, center, lineHBase, "y");
+        return new Intersection(center, lineH, lineV);
+    }
+    static fromIdentifiers(intersectionIds) {
+        const center = PointConstructor.fromIdentifiers(intersectionIds.center);
+        const lineH = LineConstructor.fromIdentifiers(intersectionIds.lineH);
+        const lineV = LineConstructor.fromIdentifiers(intersectionIds.lineV);
+        return new Intersection(center, lineH, lineV);
+    }
+    static byRotatingIntersection(intersectionSrc, rotationCenter, rotationAngle, precision = 5) {
+        const arrPointSrc = [
+            intersectionSrc.center,
+            intersectionSrc.lineH.pointA,
+            intersectionSrc.lineH.pointB,
+            intersectionSrc.lineV.pointA,
+            intersectionSrc.lineV.pointB,
+        ];
+        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));
+    }
+}
+class Intersection {
+    center;
+    lineH;
+    lineV;
+    constructor(center, lineH, lineV) {
+        this.center = center;
+        this.lineH = lineH;
+        this.lineV = lineV;
+    }
+    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);
+            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);
+        }
+    }
+    getAngle(angleIndex) {
+        /*
+              lineV.pointB
+                  0 | 1
+    lineH.pointA--center--lineH.pointB
+                  3 | 2
+              lineV.pointA
+    */
+        switch ((angleIndex % 4)) {
+            case 0:
+                return new Angle([this.lineH.pointA, this.center, this.lineV.pointB]);
+            case 1:
+                return new Angle([this.lineV.pointB, this.center, this.lineH.pointB]);
+            case 2:
+                return new Angle([this.lineH.pointB, this.center, this.lineV.pointA]);
+            case 3:
+                return new Angle([this.lineV.pointA, this.center, this.lineH.pointA]);
+        }
+    }
+    toIdentifiers() {
+        return {
+            center: this.center.toIdentifiers(),
+            lineH: this.lineH.toIdentifiers(),
+            lineV: this.lineV.toIdentifiers(),
+        };
+    }
+}
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Oui", "raw");
+    tryToAddWrongProp(propositions, "Non", "raw");
+    tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    return identifiers.isParralel ? "Oui" : "Non";
+};
+const getInstruction = () => {
+    return `Les droites $d_{1}$ et $d_{2}$ sont-elles parallèles ?`;
+};
+const getHint = () => {
+    return `Trouve la relation entre les deux angles et déduis-en, en fonction de leurs valeurs, si les droites sont parallèles ou non.`;
+};
+const getCorrection = (identifiers) => {
+    const { isParralel, angleType } = identifiers;
+    if (angleType !== "autres") {
+        return `Les deux angles sont ${(() => {
+            switch (angleType) {
+                case "alternes-internes":
+                    return `alternes-internes`;
+                case "correspondants":
+                    return `correspondants`;
+                    break;
+                case "alternes-externes":
+                    return `alternes-externes.`;
+            }
+        })()}.
+      ${isParralel
+            ? "Ils ont la même mesure donc les deux droites sont parallèles."
+            : "Ils n'ont pas la même mesure donc les deux droites ne sont pas parallèles."}
+    `;
+    }
+    else {
+        return `On calcule les mesures de deux angles correspondants à partir des angles donnés.
+      ${isParralel
+            ? "Ils ont la même mesure donc les deux droites sont parallèles."
+            : "Ils n'ont pas la même mesure donc les deux droites ne sont pas parallèles."}
+    `;
+    }
+};
+const getGGBOptions = (identifiers, opts) => {
+    const { arrIntersectionIds, arrAngleIndex, arrAngleForLabel } = identifiers;
+    const nbDigits = opts?.nbDigits ?? 1;
+    const arrIntersection = arrIntersectionIds.map(IntersectionConstructor.fromIdentifiers);
+    const arrAngle = arrAngleIndex.map((angleIndex, i) => arrIntersection[i].getAngle(angleIndex));
+    const arrCommandPoints = arrAngle
+        .flatMap((a) => a.points)
+        .flatMap((p) => [
+        ...p.toGGBCommand({
+            isFixed: true,
+            showLabel: false,
+            showUnderlyingPoints: false,
+            showUnderlyingPointsLabel: false,
+        }),
+        //hide points
+        `SetVisibleInView(${p.name}, 1, false)`,
+    ]);
+    const arrCommandLines = [
+        arrIntersectionIds[0].lineH, //top
+        arrIntersectionIds[1].lineH, //bottom
+        arrIntersectionIds[0].lineV, //secant
+    ]
+        .map((lIds) => LineConstructor.fromIdentifiers(lIds))
+        .flatMap((l, i) => l.toGGBCommands(false, {
+        color: "black",
+        showLabel: i < 2,
+    }));
+    const arrCommandAngles = arrAngle
+        .map((angle, i) => {
+        angle.name = `angle_${i}`;
+        return angle;
+    })
+        .flatMap((a, i) => [
+        ...a.toCommands({
+            pointsAreNotBuilt: false,
+            color: ["red", "blue"][i],
+            showValue: false,
+        }),
+        //fake or real label
+        `ShowLabel(${a.name}, false)`,
+        ...a.getFitCaptionCommands({
+            text: round(arrAngleForLabel ? arrAngleForLabel[i] : a.evaluate(), nbDigits).frenchify(),
+            size: "small",
+            color: ["red", "blue"][i],
+        }),
+    ]);
+    const ggb = new GeogebraConstructor({
+        commands: [...arrCommandPoints, ...arrCommandLines, ...arrCommandAngles],
+        hideAxes: true,
+        hideGrid: true,
+        forbidShiftDragZoom: true,
+    });
+    return ggb.getOptions({
+        coords: [-5, 5, -5, 5],
+    });
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+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,
+    },
+];
+const getIsParallelUsingAnglesQuestion = (optsIn) => {
+    const isParralel = coinFlip();
+    const opts = optsIn ?? optsDefault;
+    //---create intersections---
+    //this config will be used to create ggb lines
+    function createConfigGeom(isParralelInGeom, isLookingParallel) {
+        const deviation = isLookingParallel ? 1 : 5;
+        const cAngleInDegreesMin = 30;
+        const cAngleInDegreesTop = randfloat(cAngleInDegreesMin, 180 - cAngleInDegreesMin, opts.nbDigits);
+        const cAngleInDegreesBottom = isParralelInGeom
+            ? cAngleInDegreesTop
+            : cAngleInDegreesTop +
+                randfloat(-deviation, deviation, opts.nbDigits, [0]);
+        return {
+            cAngleInDegreesTop,
+            cAngleInDegreesBottom,
+        };
+    }
+    const configGeom = createConfigGeom(opts.isFakeDisplay ? coinFlip() : isParralel, opts.isFakeDisplay ? coinFlip() : isParralel);
+    const dictLine = buildLines(configGeom.cAngleInDegreesTop, configGeom.cAngleInDegreesBottom);
+    const arrIntersectionRaw = [
+        //intersection: top
+        IntersectionConstructor.fromBaselines("I", dictLine.lineTop, dictLine.lineSecant),
+        //intersection: bottom
+        IntersectionConstructor.fromBaselines("J", dictLine.lineBottom, dictLine.lineSecant),
+    ];
+    //rotate randomly around center
+    const rotationCenter = midPoint(arrIntersectionRaw[0].center, arrIntersectionRaw[1].center, "K", 5);
+    const rotationAngle = randfloat(-PiNode.value, PiNode.value);
+    const arrIntersection = arrIntersectionRaw.map((intersection) => IntersectionConstructor.byRotatingIntersection(intersection, rotationCenter, rotationAngle));
+    //---create angles---
+    const angleType = random(opts.angleTypes);
+    function randomArrAngleIndex(angleType) {
+        /*
+          0 | 1
+          -----
+          3 | 2
+            |
+          0 | 1
+          -----
+          3 | 2
+    */
+        switch (angleType) {
+            case "alternes-internes":
+                return random([
+                    [2, 0],
+                    [3, 1],
+                ]);
+            case "correspondants":
+                return random([
+                    [0, 0],
+                    [1, 1],
+                    [2, 2],
+                    [3, 3],
+                ]);
+            case "alternes-externes":
+                return random([
+                    [0, 2],
+                    [1, 3],
+                ]);
+            case "autres":
+                return random([
+                    [0, 1],
+                    [0, 3],
+                    [1, 2],
+                    [1, 0],
+                    [2, 1],
+                    [2, 3],
+                    [3, 0],
+                    [3, 2],
+                ]);
+        }
+    }
+    const arrAngleIndex = randomArrAngleIndex(angleType);
+    //this is the fake display part:
+    let arrAngleForLabel;
+    if (opts.isFakeDisplay) {
+        const angleInDegreesMin = 25;
+        const cAngleInDegreesTop = randfloat(angleInDegreesMin, 180 - angleInDegreesMin, opts.nbDigits);
+        const cAngleInDegreesBottom = isParralel
+            ? cAngleInDegreesTop
+            : cAngleInDegreesTop + randfloat(-25, 50, opts.nbDigits, [0]);
+        //angles at angleIndexes 0 and 2 have same value. Same for angleIndexes 1 and 3.
+        arrAngleForLabel = [cAngleInDegreesTop, cAngleInDegreesBottom].map((angle, i) => {
+            return arrAngleIndex[i] % 2 == 0 ? angle : 180 - angle;
+        });
+    }
+    const identifiers = {
+        isParralel,
+        arrIntersectionIds: arrIntersection.map((intersection) => intersection.toIdentifiers()),
+        angleType,
+        arrAngleIndex,
+        arrAngleForLabel,
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers, opts),
+    };
+    return question;
+};
+export const isParallelUsingAngles = {
+    id: "isParallelUsingAngles",
+    label: "Déterminer si deux droites sont parallèles en utilisant des angles issus d'une sécante",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getIsParallelUsingAnglesQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+    getQuestionFromIdentifiers,
+    hasGeogebra: true,
+};

package/lib/exercises/math/geometry/cartesian/placeAbscissOnSemiLine.d.ts

@@ -1,13 +1,16 @@
 import { Exercise } from "../../../../exercises/exercise.js";
 import { NumberType } from "../../../../math/numbers/nombre.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
 type Identifiers = {
     abscissType: NumberType;
-    axisUnit: number;
-    oneUnitTex: string;
-    absciss: number;
-    abscissTex: string;
-    coeff: number;
+    axisUnit: NodeIdentifiers;
+    absciss1: NodeIdentifiers;
+    absciss2: NodeIdentifiers;
 };
-export declare const placeAbscissOnSemiLine: Exercise<Identifiers>;
+type Options = {
+    questionType: "standard" | "éviter le comptage";
+    numberType: "Entiers" | "Rationnels" | "Décimaux";
+};
+export declare const placeAbscissOnSemiLine: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=placeAbscissOnSemiLine.d.ts.map

package/lib/exercises/math/geometry/cartesian/placeAbscissOnSemiLine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"placeAbscissOnSemiLine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/placeAbscissOnSemiLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAQ1D,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,UAAU,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA0IF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAWxD,CAAC"}
+{"version":3,"file":"placeAbscissOnSemiLine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/placeAbscissOnSemiLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAK1D,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,UAAU,CAAC;IACxB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AAkOF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,UAAU,GAAG,oBAAoB,CAAC;IAChD,UAAU,EAAE,SAAS,GAAG,YAAY,GAAG,UAAU,CAAC;CACnD,CAAC;AA6BF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAYjE,CAAC"}