math-exercises 3.0.125 → 3.0.126

package/lib/exercises/math/functions/affines/recognizeExprAffine.js

@@ -0,0 +1,284 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { TrinomConstructor } from "../../../../math/polynomials/trinom.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { NodeShuffler } from "../../../../tree/utilities/nodeShuffler.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { probaLawFlip } from "../../../../utils/alea/probaLawFlip.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+const getStringCommaCommaAnd = (strings, stringComma = ", ", stringAnd = " et ") => {
+    return strings.slice(0, -1).length > 0
+        ? [strings.slice(0, -1).join(stringComma), ...strings.slice(-1)].join(stringAnd)
+        : strings[0];
+};
+const fNames = ["f", "g", "h", "i"];
+const getInstruction = (identifiers) => {
+    const { askedType } = identifiers;
+    return `Parmi les fonctions suivantes, laquelle ou lesquelles sont des fonctions ${(() => {
+        switch (askedType) {
+            case "affine":
+                return "affines";
+            case "linear":
+                return "linéaires";
+        }
+    })()} ?`;
+};
+const getHint = (identifiers) => {
+    const { askedType } = identifiers;
+    switch (askedType) {
+        case "affine":
+            return `L'expression d'une fonction affine est de la forme  $ax+b$,
+avec  $a$ et $b$ des nombres réels.`;
+        case "linear":
+            return `L'expression d'une fonction linéaire est de la forme  $ax$,
+avec $a$ un nombre réel.`;
+    }
+};
+const getCorrection = (identifiers) => {
+    const { items, askedType } = identifiers;
+    const affines = items.filter((item) => item.fType === askedType);
+    const affineFNames = affines.map((item) => `$${item.fName}$`);
+    const affinesTex = affines.map((item) => {
+        return `$${item.fName}(x) = ${item.tex}$`;
+    });
+    switch (askedType) {
+        case "affine": {
+            return `${getStringCommaCommaAnd(affinesTex)} ${affinesTex.length > 1 ? `sont des expressions` : `est une expression`} de la forme  $ax+b$,
+avec $a$ et $b$ des nombres réels.
+
+${affines.map((item) => {
+                return `Pour $${item.fName}(x)$, $a=${item.a}$ et $b=${item.b}$.`;
+            }).join(`
+    
+`)}
+  
+${affinesTex.length > 1
+                ? `Les fonctions affines sont`
+                : `La fonction affine est`} ${getStringCommaCommaAnd(affineFNames)}.`;
+        }
+        case "linear":
+            return `${getStringCommaCommaAnd(affinesTex)} ${affinesTex.length > 1 ? `sont des expressions` : `est une expression`} de la forme  $ax$,
+avec $a$ un nombre réel.
+
+${affines.map((item) => {
+                return `Pour $${item.fName}(x)$, $a=${item.a}$.`;
+            }).join(`
+    
+`)}
+  
+${affinesTex.length > 1
+                ? `Les fonctions linéaires sont`
+                : `La fonction linéaire est`} ${getStringCommaCommaAnd(affineFNames)}.`;
+    }
+};
+const getPropositions = (_, { answer, ...identifiers }) => {
+    const { items, askedType } = identifiers;
+    const propositions = [];
+    items.forEach((item, _) => {
+        const tex = `${item.fName}(x) = ${item.tex}`;
+        if (item.fType === askedType) {
+            addValidProp(propositions, tex);
+        }
+        else {
+            tryToAddWrongProp(propositions, tex);
+        }
+    });
+    return propositions;
+};
+const getRecognizeExprAffineQuestion = (opts) => {
+    const askedType = opts.askedType;
+    const nbTotal = 4;
+    const createAffineNodeObj = (affineType, fType) => {
+        switch (affineType) {
+            case "affine": {
+                const a = randint(-10, 11, [0]);
+                const b = randint(-10, 11, [0]);
+                return {
+                    node: AffineConstructor.fromCoeffs([b, a]).toTree(),
+                    a,
+                    b,
+                    fType,
+                };
+            }
+            case "linear": {
+                const a = randint(-10, 11, [0]);
+                const b = 0;
+                return {
+                    node: AffineConstructor.fromCoeffs([b, a]).toTree(),
+                    a,
+                    b,
+                    fType,
+                };
+            }
+            case "constant": {
+                const a = 0;
+                const b = randint(-10, 11, [0]);
+                return {
+                    node: b.toTree(),
+                    a,
+                    b,
+                    fType,
+                };
+            }
+        }
+    };
+    const createNonAffineFuncNode = (nonAffineType) => {
+        switch (nonAffineType) {
+            case "trinomA": {
+                const a = randint(-10, 11, [0]);
+                return TrinomConstructor.fromCoeffs([0, 0, a]).toTree();
+            }
+            case "trinomAC": {
+                const a = randint(-10, 11, [0]);
+                const c = randint(-10, 11, [0]);
+                return TrinomConstructor.fromCoeffs([c, 0, a]).toTree();
+            }
+            case "inv": {
+                const a = randint(-10, 11, [0]);
+                return frac(a, "x".toTree());
+            }
+            case "invPlusB": {
+                const a = randint(-10, 11, [0]);
+                const b = randint(-10, 11, [0]);
+                const aInvX = frac(a, "x".toTree());
+                return add(aInvX, b);
+            }
+        }
+    };
+    let affinesObj;
+    let arrayOfFillerObj;
+    switch (askedType) {
+        case "affine":
+            {
+                const nbAffineMore = probaLawFlip([
+                    [0, 0.7],
+                    [1, 0.25],
+                    [2, 0.04],
+                    [3, 0.01],
+                ]);
+                affinesObj = [
+                    createAffineNodeObj("affine", "affine"),
+                    ...[...Array(nbAffineMore).keys()].map((_) => {
+                        return createAffineNodeObj(probaLawFlip([
+                            ["affine", 0.5],
+                            ["linear", 0.45],
+                            ["constant", 0.05],
+                        ]), "affine");
+                    }),
+                ];
+                const nbFiller = nbTotal - (nbAffineMore + 1);
+                arrayOfFillerObj = [...Array(nbFiller).keys()].map((_) => {
+                    const fType = probaLawFlip([
+                        ["trinomA", 0.35],
+                        ["trinomAC", 0.35],
+                        ["inv", 0.15],
+                        ["invPlusB", 0.15],
+                    ]);
+                    return { node: createNonAffineFuncNode(fType), fType };
+                });
+            }
+            break;
+        case "linear":
+            {
+                const nbLinearMore = probaLawFlip([
+                    [0, 0.7],
+                    [1, 0.25],
+                    [2, 0.04],
+                    [3, 0.01],
+                ]);
+                affinesObj = [
+                    createAffineNodeObj("linear", "linear"),
+                    ...[...Array(nbLinearMore).keys()].map((_) => {
+                        return createAffineNodeObj("linear", "linear");
+                    }),
+                ];
+                const nbFiller = nbTotal - (nbLinearMore + 1);
+                arrayOfFillerObj = [...Array(nbFiller).keys()].map((_) => {
+                    if (coinFlip()) {
+                        const fType = probaLawFlip([
+                            ["affine", 0.55],
+                            ["constant", 0.45],
+                        ]);
+                        return {
+                            node: createAffineNodeObj(fType, fType).node,
+                            fType,
+                        };
+                    }
+                    else {
+                        const fType = probaLawFlip([
+                            ["trinomA", 0.35],
+                            ["trinomAC", 0.35],
+                            ["inv", 0.15],
+                            ["invPlusB", 0.15],
+                        ]);
+                        return {
+                            node: createNonAffineFuncNode(fType),
+                            fType,
+                        };
+                    }
+                });
+            }
+            break;
+    }
+    const shuffledArray = shuffle([...affinesObj, ...arrayOfFillerObj]);
+    const items = shuffledArray.map(({ node, fType, a, b }, i) => {
+        const tex = coinFlip()
+            ? node.toTex()
+            : NodeShuffler.deepShuffle(node).toTex();
+        return {
+            tex: tex,
+            fType,
+            fName: fNames[i],
+            a,
+            b,
+        };
+    });
+    const identifiers = { items, askedType };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const recognizeExprAffine = {
+    id: "recognizeExprAffine",
+    label: "Reconnaître l’expression d’une fonction affine",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getRecognizeExprAffineQuestion({
+        askedType: "affine",
+    }), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCM",
+    isQCM: true,
+};
+export const recognizeExprLinear = {
+    id: "recognizeExprLinear",
+    label: "Reconnaître l’expression d’une fonction linéaire",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getRecognizeExprAffineQuestion({
+        askedType: "linear",
+    }), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCM",
+    isQCM: true,
+};

package/lib/exercises/math/functions/affines/representationOfAffine.d.ts

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Item = {
+    tex: string;
+    isValid: boolean;
+};
+type Identifiers = {
+    fName: string;
+    coeffs: number[];
+    items: Item[];
+};
+export declare const representationOfAffine: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=representationOfAffine.d.ts.map

package/lib/exercises/math/functions/affines/representationOfAffine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"representationOfAffine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/representationOfAffine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,IAAI,GAAG;IACV,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,KAAK,EAAE,IAAI,EAAE,CAAC;CACf,CAAC;AAwOF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAexD,CAAC"}

package/lib/exercises/math/functions/affines/representationOfAffine.js

@@ -0,0 +1,184 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+const primordialRightsAndWrongs = {
+    rights: [`une droite`],
+    wrongs: [
+        `une parabole`,
+        `un demi-cercle`,
+        `une succession de deux segments`,
+        `un cercle`,
+        `une ellipse`,
+        `une fonction affine`,
+    ],
+};
+const createRightsAndWrongs = (validSuffixFunc, invalidSuffixFuncs) => {
+    return {
+        rights: primordialRightsAndWrongs.rights.map((rightStr) => (pointName) => validSuffixFunc(rightStr, pointName)),
+        wrongs: [
+            ...primordialRightsAndWrongs.wrongs.map((wrongStr) => (pointName) => validSuffixFunc(wrongStr, pointName)),
+            ...invalidSuffixFuncs.flatMap((invalidSuffixFunc) => primordialRightsAndWrongs.rights.map((rightStr) => (pointName) => invalidSuffixFunc(rightStr, pointName))),
+        ],
+    };
+};
+const createArrayOfRightsAndWrongs = (f) => {
+    function createRightAndWrongsCoords(f, x) {
+        const yR = f.calculate(x);
+        const yWs = [
+            f.a,
+            f.b,
+            add(f.a, f.b).evaluate(),
+            substract(f.a, f.b).evaluate(),
+        ].filter((yW) => yW !== yR);
+        return {
+            right: [x, yR],
+            wrongs: yWs.map((yW) => [x, yW]),
+        };
+    }
+    const coordObjects = [-1, 0, 1].map((x) => createRightAndWrongsCoords(f, x));
+    const strFunc = (str, pointName, x, y) => `${str} qui passe par $${pointName}(${x.frenchify()};${y.frenchify()})$`;
+    return [
+        createRightsAndWrongs((str) => `${str}`, []),
+        ...coordObjects.flatMap((coordObject) => {
+            return createRightsAndWrongs((str, pointName) => strFunc(str, pointName, coordObject.right[0], coordObject.right[1]), coordObject.wrongs.map(([x, y]) => (str, pointName) => strFunc(str, pointName, x, y)));
+        }),
+    ];
+};
+const getInstruction = (identifiers) => {
+    const { fName, coeffs } = identifiers;
+    const affine = AffineConstructor.fromCoeffs(coeffs);
+    return `La représentation graphique de
+
+$$
+${fName}(x)=${affine.toTex()}
+$$
+
+est :`;
+};
+const getHint = () => {
+    return `Les fonctions affines et linéaires sont représentées par des droites.`;
+};
+const getCorrection = (identifiers) => {
+    const { fName } = identifiers;
+    const abstractFName = ["f", "g", "h"].find((letter) => letter !== fName);
+    return `Une fonction affine $${abstractFName}$ est de la forme 
+  
+$$
+${abstractFName}(x)=mx+p
+$$
+
+Sa représentation graphique est donc une droite qui passe, entre autres, par le point de coordonnées $(1;m+p)$ car
+
+$$
+${abstractFName}(1)=m+p
+$$
+`;
+};
+const getPropositions = (_, { answer, ...idenfitiers }) => {
+    const { items } = idenfitiers;
+    const propositions = [];
+    //keep same order on each question
+    items.forEach((item) => {
+        if (item.isValid) {
+            addValidProp(propositions, item.tex, "raw");
+        }
+        else {
+            tryToAddWrongProp(propositions, item.tex, "raw");
+        }
+    });
+    return propositions;
+};
+const getRepresentationOfAffineQuestion = () => {
+    const fName = random(["f", "g", "h"]);
+    const coeffs = [0, 1].map(() => randint(-10, 10, [0]));
+    const f = AffineConstructor.fromCoeffs(coeffs);
+    const nbPropositions = 4;
+    const nbValid = randint(1, nbPropositions);
+    const nbInvalid = nbPropositions - nbValid;
+    const arrayOfIsValid = shuffle([
+        ...[...Array(nbValid).keys()].map(() => true),
+        ...[...Array(nbInvalid).keys()].map(() => false),
+    ]);
+    const pointNames = ["A", "B", "C", "D"];
+    const rightsAndWrongs = createArrayOfRightsAndWrongs(f);
+    const allIndexes = [...Array(rightsAndWrongs.length).keys()];
+    function getRightTexFunc(previouslyPickedIndexes) {
+        const index = random(allIndexes.filter((index) => !previouslyPickedIndexes.includes(index)));
+        if (rightsAndWrongs[index].rights.length > 0) {
+            return {
+                texFunc: random(rightsAndWrongs[index].rights),
+                index,
+            };
+        }
+        else {
+            return undefined;
+        }
+    }
+    function getWrongTexFunc(previouslyPickedIndexes) {
+        const indexArray = previouslyPickedIndexes.length > 0
+            ? coinFlip()
+                ? previouslyPickedIndexes
+                : allIndexes
+            : allIndexes;
+        const index = random(indexArray);
+        if (rightsAndWrongs[index].wrongs.length > 0) {
+            return {
+                texFunc: random(rightsAndWrongs[index].wrongs),
+                index,
+            };
+        }
+        else {
+            return undefined;
+        }
+    }
+    const previouslyPickedIndexes = [];
+    const items = shuffle(arrayOfIsValid.map((isValid, i) => {
+        const pointName = pointNames[i];
+        let pick;
+        do {
+            pick = isValid
+                ? getRightTexFunc(previouslyPickedIndexes)
+                : getWrongTexFunc(previouslyPickedIndexes);
+        } while (!pick);
+        const tex = pick.texFunc(pointName);
+        previouslyPickedIndexes.push(pick.index);
+        const item = {
+            tex,
+            isValid,
+        };
+        return item;
+    }));
+    const identifiers = { fName, coeffs, items };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const representationOfAffine = {
+    id: "representationOfAffine",
+    label: "Savoir que la représentation graphique d'une fonction affine est une droite",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getRepresentationOfAffineQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCM",
+    isQCM: true,
+};

package/lib/exercises/math/functions/basics/coordsOfPointOnCurveFindY.d.ts

@@ -0,0 +1,14 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type QuestionFuncType = "...x^2" | "...x^3" | "(x-...)(x-...)" | "(x+...)(x-...)" | "(x+...)(x+...)" | "a/(x+...)" | "(x+...)/(x+...)";
+type QuestionFunc = {
+    type: QuestionFuncType;
+    nodeIds: NodeIdentifiers;
+};
+type Identifiers = {
+    questionFunc: QuestionFunc;
+    xValue: number;
+};
+export declare const coordsOfPointOnCurveFindY: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=coordsOfPointOnCurveFindY.d.ts.map

package/lib/exercises/math/functions/basics/coordsOfPointOnCurveFindY.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coordsOfPointOnCurveFindY.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/coordsOfPointOnCurveFindY.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAc7C,KAAK,gBAAgB,GACjB,QAAQ,GACR,QAAQ,GACR,gBAAgB,GAChB,gBAAgB,GAChB,gBAAgB,GAChB,WAAW,GACX,iBAAiB,CAAC;AAEtB,KAAK,YAAY,GAAG;IAClB,IAAI,EAAE,gBAAgB,CAAC;IACvB,OAAO,EAAE,eAAe,CAAC;CAC1B,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,YAAY,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAsRF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAc3D,CAAC"}