math-exercises 3.0.151 → 3.0.153

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

@@ -0,0 +1,301 @@
+import { GeneratorOptionType, GeneratorOptionTarget, shuffleProps, addValidProp, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { toolBarConstructor } from "../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Point, PointConstructor, } from "../../../../math/geometry/point.js";
+import { VectorConstructor } from "../../../../math/geometry/vector.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
+import { add, AddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { frac, isFractionNode, } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { SquareNode } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { doWhile } from "../../../../utils/doWhile.js";
+const getSquaredNormNode = (vec) => {
+    return new AddNode(new SquareNode(vec.x), new SquareNode(vec.y));
+};
+const getDivisorsOfVector = (vec) => {
+    return [2, 3, 4, 5, 7, 8, 9].filter((n) => [vec.x, vec.y].every((z) => z.evaluate() % n === 0));
+};
+const getRandomFactorNodeForVector = (vec, isPositiveFactorOnly = false, excludes = [], factorType) => {
+    let factorNode;
+    switch (factorType) {
+        case "fraction":
+            {
+                const divisorsOfVec = getDivisorsOfVector(vec);
+                if (divisorsOfVec.length > 0) {
+                    const den = random(divisorsOfVec);
+                    const num = randint(1, 3 * den, [den, 2 * den]);
+                    factorNode = frac(num, den);
+                }
+                else {
+                    throw new Error("can't find frac for vec");
+                }
+            }
+            break;
+        default:
+        case "entier":
+            {
+                factorNode = randint(1, 5, excludes).toTree();
+            }
+            break;
+    }
+    return multiply(isPositiveFactorOnly ? 1 : coinFlip() ? 1 : -1, factorNode);
+};
+const getInstruction = (identifiers) => {
+    const { nameCenterPoint, nameSrcPoint, nameDstPoint } = identifiers;
+    return `Quel est le rapport de l'homothétie de centre $${nameCenterPoint}$ qui transforme $${nameSrcPoint}$ en $${nameDstPoint}$ ?`;
+};
+const getAnswerNode = (identifiers) => {
+    const { nameCenterPoint, nameSrcPoint, nameDstPoint, pointsDict } = identifiers;
+    const [pointCenter, pointSrc, pointDst] = [
+        nameCenterPoint,
+        nameSrcPoint,
+        nameDstPoint,
+    ].map((pointName) => PointConstructor.fromIdentifiers(pointsDict[pointName]));
+    const vec1 = VectorConstructor.fromPoints(pointCenter, pointSrc);
+    const vec2 = VectorConstructor.fromPoints(pointCenter, pointDst);
+    const nodeFactor = multiply(Math.sign(vec1.scalarProduct(vec2).evaluate()), sqrt(frac(getSquaredNormNode(vec2).simplify(), getSquaredNormNode(vec1).simplify())).simplify()).simplify();
+    return nodeFactor;
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = (identifiers) => {
+    const { nameCenterPoint, nameSrcPoint, nameDstPoint } = identifiers;
+    return `Compare la longueur algébrique $\\overline{${nameCenterPoint}${nameDstPoint}}$ à la longueur algébrique $\\overline{${nameCenterPoint}${nameSrcPoint}}$`;
+};
+const getCorrection = (identifiers) => {
+    const { nameCenterPoint, nameSrcPoint, nameDstPoint } = identifiers;
+    const answerTex = getAnswer(identifiers);
+    return `Le rapport de l'homothétie de centre $${nameCenterPoint}$ qui transforme $${nameSrcPoint}$ en $${nameDstPoint}$ est :
+  
+$$
+\\frac{\\overline{${nameCenterPoint}${nameDstPoint}}}{\\overline{${nameCenterPoint}${nameSrcPoint}}} = ${answerTex}
+$$
+
+`;
+};
+const getGGBOptions = (identifiers) => {
+    const points = Object.values(identifiers.pointsDict).map((p) => PointConstructor.fromIdentifiers(p));
+    const ggb = new GeogebraConstructor({
+        hideAxes: true,
+        isGridSimple: true,
+        customToolBar: toolBarConstructor({ point: true }),
+        commands: points.flatMap((p) => p.toGGBCommand({
+            size: 3,
+            style: 1,
+        })),
+        fontSize: 16,
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints(points),
+    });
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const [nodeAns, nodeAnswer] = [ans, answer].map((str) => parseAlgebraic(str));
+        return substract(nodeAns, nodeAnswer).simplify().evaluate() === 0;
+    }
+    catch (_) {
+        return false;
+    }
+};
+const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const propositions = [];
+    const answerNode = getAnswerNode(identifiers);
+    addValidProp(propositions, answerNode.toTex());
+    if (!opts.isPositiveFactorOnly) {
+        //sign
+        tryToAddWrongProp(propositions, multiply(-1, answerNode).simplify().toTex());
+    }
+    //+-1
+    {
+        const nodePlus1 = add(+1, answerNode).simplify();
+        const nodeMinus1 = add(-1, answerNode).simplify();
+        [nodePlus1, nodeMinus1].forEach((node) => {
+            const value = node.evaluate();
+            if (value !== 0 && value !== 1) {
+                tryToAddWrongProp(propositions, node.toTex());
+            }
+        });
+        if (!opts.isPositiveFactorOnly) {
+            //sign
+            [nodePlus1, nodeMinus1].forEach((node) => {
+                const oppNode = multiply(-1, node).simplify();
+                const value = node.evaluate();
+                if (value !== 0 && value !== 1) {
+                    tryToAddWrongProp(propositions, oppNode.toTex());
+                }
+            });
+        }
+    }
+    //num:+-1
+    {
+        if (isFractionNode(answerNode)) {
+            const [numNode, denNode] = [
+                answerNode.leftChild,
+                answerNode.rightChild,
+            ];
+            const nodeNumPlus1 = frac(add(+1, numNode), denNode).simplify();
+            const nodeNumMinus1 = frac(add(-1, numNode), denNode).simplify();
+            [nodeNumPlus1, nodeNumMinus1].forEach((node) => {
+                const value = node.evaluate();
+                if (value !== 0 && value !== 1) {
+                    tryToAddWrongProp(propositions, node.toTex());
+                }
+            });
+            if (!opts.isPositiveFactorOnly) {
+                //sign
+                [nodeNumPlus1, nodeNumMinus1].forEach((node) => {
+                    const oppNode = multiply(-1, node).simplify();
+                    const value = node.evaluate();
+                    if (value !== 0 && value !== 1) {
+                        tryToAddWrongProp(propositions, oppNode.toTex());
+                    }
+                });
+            }
+        }
+    }
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randint(-3, 3, [0]).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getHomothetyFactorFromPointsQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { isPositiveFactorOnly, factorTypes } = opts;
+    const factorType = random(factorTypes);
+    function createRandomPoints() {
+        const points = [];
+        for (let i = 0; i < 2; i++) {
+            const name = String.fromCharCode(65 + i);
+            const newPoint = doWhile(() => PointConstructor.random(name, -3, 4), (p) => points.some((p2) => p.distanceTo(p2) < 2));
+            points.push(newPoint);
+        }
+        return points;
+    }
+    function createRandomIdentifiers() {
+        const points = createRandomPoints();
+        const [pointCenter, pointSrc] = randomMany(points, 2);
+        const vec1 = VectorConstructor.fromPoints(pointCenter, pointSrc);
+        const factorNode = getRandomFactorNodeForVector(vec1, isPositiveFactorOnly, [1], factorType).simplify();
+        const pointDst = vec1
+            .times(factorNode)
+            .getEndPoint(pointCenter, String.fromCharCode(65 + points.length));
+        points.push(pointDst);
+        const identifiersRaw = {
+            pointsDict: Object.fromEntries(points.map((p) => [p.name, p.toIdentifiers()])),
+            nameCenterPoint: pointCenter.name,
+            nameSrcPoint: pointSrc.name,
+            nameDstPoint: pointDst.name,
+        };
+        //shuffle
+        const pointNamesRaw = Object.keys(identifiersRaw.pointsDict);
+        const shuffleDict = Object.fromEntries(shuffle(pointNamesRaw).map((pointNameOld, i) => [
+            pointNameOld,
+            pointNamesRaw[i],
+        ]));
+        const identifiersShuffled = {
+            pointsDict: Object.fromEntries(Object.entries(identifiersRaw.pointsDict).map(([pointNameOld, pointIds]) => {
+                const pointNameNew = shuffleDict[pointNameOld];
+                return [
+                    pointNameNew,
+                    Object.assign({}, pointIds, { name: pointNameNew }),
+                ];
+            })),
+            nameCenterPoint: shuffleDict[pointCenter.name],
+            nameSrcPoint: shuffleDict[pointSrc.name],
+            nameDstPoint: shuffleDict[pointDst.name],
+        };
+        return identifiersShuffled;
+    }
+    const pointOrigin = new Point("O", 0, 0);
+    let identifiers;
+    let counter = -1;
+    let isValidIdentifiers = false;
+    while (!isValidIdentifiers && counter < 100) {
+        counter++;
+        try {
+            identifiers = createRandomIdentifiers();
+        }
+        catch (_) {
+            continue;
+        }
+        const points = Object.values(identifiers.pointsDict).map((pointIds) => PointConstructor.fromIdentifiers(pointIds));
+        const isPointsDistinct = [...new Set(points.map((point) => point.toCoords()))].length ===
+            points.length;
+        const isPointsCloseToOrigin = points.every((point) => point.distanceTo(pointOrigin) < 10);
+        isValidIdentifiers = isPointsDistinct && isPointsCloseToOrigin;
+    }
+    // const identifiers = createRandomIdentifiers(points);
+    const defaultIdentifiers = {
+        pointsDict: Object.fromEntries([
+            new Point("O", 0, 0),
+            new Point("A", 5, 0),
+            new Point("B", 0, 5),
+            new Point("C", -5, 0),
+            new Point("D", 0, -5),
+        ].map((point) => [point.name, point.toIdentifiers()])),
+        nameSrcPoint: "A",
+        nameCenterPoint: "O",
+        nameDstPoint: "C",
+    };
+    return getQuestionFromIdentifiers(identifiers ?? defaultIdentifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        ggbOptions: getGGBOptions(identifiers, opts),
+        keys: [],
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+    };
+    return question;
+};
+const options = [
+    {
+        id: "isPositiveFactorOnly",
+        label: "Rapports positifs uniquement",
+        type: GeneratorOptionType.checkbox,
+        target: GeneratorOptionTarget.generation,
+        defaultValue: false,
+    },
+    {
+        id: "factorTypes",
+        label: "Rapport: type de nombre",
+        type: GeneratorOptionType.multiselect,
+        target: GeneratorOptionTarget.generation,
+        values: ["entier", "fraction"],
+        defaultValue: ["entier", "fraction"],
+    },
+];
+const optsDefault = {
+    isPositiveFactorOnly: false,
+    factorTypes: ["entier", "fraction"],
+};
+export const homothetyFactorFromPoints = {
+    id: "homothetyFactorFromPoints",
+    label: "Trouver le rapport d'une homothétie",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getHomothetyFactorFromPointsQuestion(opts), nb),
+    ggbTimer: 60,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getGGBOptions,
+    hasGeogebra: true,
+    options,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    isAnswerValid,
+    getPropositions,
+};

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

@@ -1,3 +1,10 @@
 export * from "./pythagoreOrThales.js";
 export * from "./orthogonalProjectFromPicture.js";
+export * from "./pinPointFromAxialOrCentralSymmetry.js";
+export * from "./pinPointFromRotation.js";
+export * from "./recognizeAngleFromRotation.js";
+export * from "./pinSegmentFromRotation.js";
+export * from "./pinPointFromTranslation.js";
+export * from "./homothetyFactorFromPoints.js";
+export * from "./recognizeHomothetyCenter.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidian/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,mCAAmC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidian/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,mCAAmC,CAAC;AAClD,cAAc,yCAAyC,CAAC;AACxD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iCAAiC,CAAC;AAChD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,+BAA+B,CAAC"}

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

@@ -1,2 +1,9 @@
 export * from "./pythagoreOrThales.js";
 export * from "./orthogonalProjectFromPicture.js";
+export * from "./pinPointFromAxialOrCentralSymmetry.js";
+export * from "./pinPointFromRotation.js";
+export * from "./recognizeAngleFromRotation.js";
+export * from "./pinSegmentFromRotation.js";
+export * from "./pinPointFromTranslation.js";
+export * from "./homothetyFactorFromPoints.js";
+export * from "./recognizeHomothetyCenter.js";

package/lib/exercises/math/geometry/euclidian/pinPointFromAxialOrCentralSymmetry.d.ts

@@ -0,0 +1,21 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../math/geometry/point.js";
+type TransformationIdentifiers = {
+    type: string;
+    point1: PointIdentifiers;
+    point2?: PointIdentifiers;
+};
+type Identifiers = {
+    pointsDict: Record<string, PointIdentifiers>;
+    segments: string[];
+    transformationIds: TransformationIdentifiers;
+    namePointSrc: string;
+    namePointDst: string;
+};
+type Options = {
+    isForceDstDifferentFromSrc: boolean;
+    typeTransformation: string[];
+};
+export declare const pinPointFromAxialOrCentralSymmetry: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=pinPointFromAxialOrCentralSymmetry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pinPointFromAxialOrCentralSymmetry.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidian/pinPointFromAxialOrCentralSymmetry.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AA6JtC,KAAK,yBAAyB,GAAG;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,gBAAgB,CAAC;IACzB,MAAM,CAAC,EAAE,gBAAgB,CAAC;CAC3B,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAC7C,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,iBAAiB,EAAE,yBAAyB,CAAC;IAC7C,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAyXF,KAAK,OAAO,GAAG;IACb,0BAA0B,EAAE,OAAO,CAAC;IACpC,kBAAkB,EAAE,MAAM,EAAE,CAAC;CAC9B,CAAC;AAyBF,eAAO,MAAM,kCAAkC,EAAE,QAAQ,CACvD,WAAW,EACX,OAAO,CAoBR,CAAC"}