math-exercises 3.0.125 → 3.0.127

package/lib/exercises/math/functions/composition/functionComposition.js

@@ -0,0 +1,238 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { realize } from "../../../../math/utils/latex/realize.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { isFunctionNode, } from "../../../../tree/nodes/functions/functionNode.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+// import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { isOperatorNode } from "../../../../tree/nodes/operators/operatorNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { random } from "../../../../utils/alea/random.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const nodeBySubstitutingX = (node, strVar) => {
+    return parseAlgebraic(node.toTex({ forceParenthesis: true }).replaceAll("x", `("${strVar}")`));
+};
+const functionNameForFunctionId = (functionId) => {
+    return [
+        "opposite",
+        "sqrt",
+        "cos",
+        "sin",
+        "tan",
+        "log",
+        "log10",
+        "exp",
+        "abs",
+        "arcsin",
+        "arccos",
+        "arctan",
+    ][functionId];
+};
+const extractElementaryFunctionNamesDict = (nodes, functionNamesDictIn = {}) => {
+    let functionNamesDict = functionNamesDictIn;
+    nodes.forEach((node) => {
+        if (isFunctionNode(node)) {
+            const functionId = node.id;
+            const functionName = functionNameForFunctionId(functionId);
+            if (!(functionName in functionNamesDict)) {
+                functionNamesDict[functionName] = functionName;
+            }
+            functionNamesDict = Object.assign(functionNamesDict, extractElementaryFunctionNamesDict([node.child], functionNamesDict));
+        }
+        else if (isOperatorNode(node)) {
+            functionNamesDict = Object.assign(functionNamesDict, extractElementaryFunctionNamesDict([node.leftChild, node.rightChild], functionNamesDict));
+        }
+    });
+    return functionNamesDict;
+};
+const getInstruction = (identifiers) => {
+    const { nodeIds } = identifiers;
+    const [nodeU, nodeV] = nodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `Soient $u$ et $v$ deux fonctions telles que, pour tout $x$ réel :
+  
+$$
+u(x)=${nodeU.toTex()}
+$$
+
+$$
+v(x)=${nodeV.toTex()}
+$$
+
+Pour tout $x$ réel, donner l'expression de $u \\circ v(x)$.`;
+};
+const getHint = () => {
+    return `Pour tout $x$ réel on a: 
+  
+$$
+u \\circ v(x) = u(v(x))
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIds } = identifiers;
+    const [nodeU, nodeV] = nodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const arrayRHS = [
+        ...new Set([
+            ...(isOperatorNode(nodeV)
+                ? [`${nodeU.toTex().replaceAll("x", `(${nodeV.toTex()})`)}`]
+                : []),
+            getAnswer(identifiers),
+        ]).values(),
+    ];
+    return `Pour tout réel $x$, on a :
+  
+${alignTex([
+        [`u \\circ v(x)`, `=`, `u(v(x))`],
+        [``, `=`, `${nodeU.toTex().replaceAll("x", "v(x)")}`],
+        ...arrayRHS.map((rhs) => [``, `=`, rhs]),
+    ])}`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeIds } = identifiers;
+    const [nodeU, nodeV] = nodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `${nodeBySubstitutingX(nodeU.simplify(), nodeV.simplify().toTex())
+        .simplify()
+        .toTex()}`;
+};
+const isAnswerValid = (ans, { answer }) => {
+    const nodeAns = parseAlgebraic(ans);
+    const nodeAnswer = parseAlgebraic(answer);
+    // return (
+    //   substract(nodeAns.simplify(), nodeAnswer.simplify())
+    //     .simplify()
+    //     .evaluate() === 0
+    // );
+    // return (
+    //   nodeAns.simplify().toMathString() === nodeAnswer.simplify().toMathString()
+    // );
+    //
+    //  Une façon de savoir que expr1(x) et expr2(x) sont équivalentes:
+    //  x|->expr1(expr2(x)) doit être la même fonction que x|->expr2(expr1(x))
+    const nodeAnsOfAnswer = nodeBySubstitutingX(nodeAns.simplify(), nodeAnswer.simplify().toTex()).simplify();
+    const nodeAnswerOfAns = nodeBySubstitutingX(nodeAnswer.simplify(), nodeAns.simplify().toTex()).simplify();
+    return [0, 1, 1000].every((x) => {
+        return (substract(nodeAnsOfAnswer.evaluate({ x }), nodeAnswerOfAns.evaluate({ x })).evaluate() === 0);
+    });
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { nodeIds } = identifiers;
+    const [nodeU, nodeV] = nodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const wrongTexs = [
+        //mauvais ordre
+        `${nodeBySubstitutingX(nodeV, nodeU.toTex()).toTex({
+            forceParenthesis: true,
+        })}`,
+        `${nodeBySubstitutingX(nodeV, nodeU.toTex()).simplify().toTex()}`,
+        //multiplication
+        `${multiply(nodeU, nodeV).toTex({
+            forceParenthesis: true,
+        })}`,
+        //\\circ is 0
+        `${multiply(nodeU, multiply(0, nodeV)).toTex({
+            forceTimesSign: true,
+            forceParenthesis: true,
+        })}`,
+        //substitution littéraire
+        `${nodeU
+            .toTex({ forceParenthesis: true })
+            .replaceAll("x", `${nodeV.toTex()}`)}`,
+        `${nodeU
+            .toTex({ forceParenthesis: true })
+            .replaceAll("x", `${nodeV.toTex()}`)}`,
+    ];
+    wrongTexs.forEach((wrongTex) => {
+        tryToAddWrongProp(propositions, wrongTex);
+    });
+    if (propositions.length < n) {
+        [
+            `${nodeBySubstitutingX(nodeU, nodeU.toTex()).toTex({
+                forceParenthesis: true,
+            })}`,
+            `${nodeBySubstitutingX(nodeU, nodeU.toTex()).simplify().toTex()}`,
+            `${nodeBySubstitutingX(nodeV, nodeV.toTex()).toTex({
+                forceParenthesis: true,
+            })}`,
+            `${nodeBySubstitutingX(nodeV, nodeV.toTex()).simplify().toTex()}`,
+        ].forEach((wrongTex) => {
+            tryToAddWrongProp(propositions, wrongTex);
+        });
+    }
+    return shuffleProps(propositions, n);
+};
+const getKeys = (identifiers) => {
+    const { nodeIds } = identifiers;
+    const nodes = nodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const functionNamesDict = extractElementaryFunctionNamesDict(nodes);
+    return [
+        "x",
+        ...Object.values(functionNamesDict).map((functionName) => {
+            return {
+                id: "custom",
+                label: functionName,
+                labelType: "tex",
+                mathfieldInstructions: {
+                    method: "write",
+                    content: functionName,
+                },
+            };
+        }),
+    ];
+};
+const getFunctionCompositionQuestion = (_) => {
+    function getRandomNode() {
+        return random([
+            ...[
+                realize({ a: "I" })(`x+a`),
+                realize({ a: { custom: () => randint(2, 10).toTree() } })(`ax`),
+                realize({ a: "I", b: "I" })(`ax+b`),
+                realize({ a: "I", b: "I" })(`(ax+b)^2`),
+                realize({ a: "RI", b: "RI" })(`(x+a)(x+b)`),
+                `\\sin(x)`,
+                realize({ a: "I" })(`\\sin(ax)`),
+                `\\cos(x)`,
+                realize({ a: "I" })(`\\sin(ax)`),
+            ].map((tex) => parseAlgebraic(tex)),
+            //! TODO: simplify({maxSimplificationSteps: 100}) to allow using fracs
+            // frac(randomNodeWithType("I"), "x"),
+            // frac(1, "x"),
+        ]);
+    }
+    const [nodeU, nodeV] = [0, 1].map(() => getRandomNode());
+    const identifiers = {
+        nodeIds: [nodeU, nodeV].map((node) => node.toIdentifiers()),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const functionComposition = {
+    id: "functionComposition",
+    label: "Déterminer l'expression d'une fonction composée",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFunctionCompositionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/functions/composition/index.d.ts

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

package/lib/exercises/math/functions/composition/index.d.ts.map

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

package/lib/exercises/math/functions/composition/index.js

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

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

@@ -14,4 +14,5 @@ export * from "./sign/index.js";
 export * from "./variations/index.js";
 export * from "./sqrt/index.js";
 export * from "./inverse/index.js";
+export * from "./composition/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/functions/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/functions/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC"}

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

@@ -14,3 +14,4 @@ export * from "./sign/index.js";
 export * from "./variations/index.js";
 export * from "./sqrt/index.js";
 export * from "./inverse/index.js";
+export * from "./composition/index.js";

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

@@ -0,0 +1,23 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { LineIdentifiers } from "../../../../math/geometry/line.js";
+import { PointIdentifiers } from "../../../../math/geometry/point.js";
+type IntersectionIds = {
+    center: PointIdentifiers;
+    lineH: LineIdentifiers;
+    lineV: LineIdentifiers;
+};
+type Identifiers = {
+    isParallel: boolean;
+    angleType: "alternes-internes" | "correspondants" | "alternes-externes" | "autres";
+    arrIntersectionIds: IntersectionIds[];
+    arrAngleIndex: number[];
+    arrAngleForLabel: number[] | undefined;
+};
+type Options = {
+    angleTypes: ("alternes-internes" | "correspondants" | "alternes-externes" | "autres")[];
+    isFakeDisplay: boolean;
+    nbDigits: 0 | 1 | 2;
+};
+export declare const anglesUsingIsParallel: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=anglesUsingIsParallel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"anglesUsingIsParallel.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/angles/anglesUsingIsParallel.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAGL,eAAe,EAChB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAuItC,KAAK,eAAe,GAAG;IACrB,MAAM,EAAE,gBAAgB,CAAC;IACzB,KAAK,EAAE,eAAe,CAAC;IACvB,KAAK,EAAE,eAAe,CAAC;CACxB,CAAC;AA6HF,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,OAAO,CAAC;IACpB,SAAS,EACL,mBAAmB,GACnB,gBAAgB,GAChB,mBAAmB,GACnB,QAAQ,CAAC;IAGb,kBAAkB,EAAE,eAAe,EAAE,CAAC;IACtC,aAAa,EAAE,MAAM,EAAE,CAAC;IAGxB,gBAAgB,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;CACxC,CAAC;AAwMF,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,CACR,mBAAmB,GACnB,gBAAgB,GAChB,mBAAmB,GACnB,QAAQ,CACX,EAAE,CAAC;IACJ,aAAa,EAAE,OAAO,CAAC;IACvB,QAAQ,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;CACrB,CAAC;AA2NF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkBhE,CAAC"}