math-exercises 3.0.125 → 3.0.127

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

@@ -0,0 +1,275 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Point, PointConstructor, } from "../../../../math/geometry/point.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 { parseAlgebraic } from "../../../../tree/parsers/latexParser.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 = (validSuffixObj, invalidSuffixObjs) => {
+    return {
+        rights: primordialRightsAndWrongs.rights.map((rightStr) => (pointName) => {
+            const point = validSuffixObj.nodeX &&
+                validSuffixObj.nodeY &&
+                new Point(pointName, validSuffixObj.nodeX, validSuffixObj.nodeY);
+            return {
+                str: validSuffixObj.suffixFunc(rightStr, pointName),
+                point,
+                isPointValid: point ? true : undefined,
+            };
+        }),
+        wrongs: [
+            ...primordialRightsAndWrongs.wrongs.map((wrongStr) => (pointName) => {
+                const point = validSuffixObj.nodeX &&
+                    validSuffixObj.nodeY &&
+                    new Point(pointName, validSuffixObj.nodeX, validSuffixObj.nodeY);
+                return {
+                    str: validSuffixObj.suffixFunc(wrongStr, pointName),
+                    point,
+                    isPointValid: point ? true : undefined,
+                };
+            }),
+            ...invalidSuffixObjs.flatMap((invalidSuffixObj) => primordialRightsAndWrongs.rights.map((rightStr) => (pointName) => {
+                const point = invalidSuffixObj.nodeX &&
+                    invalidSuffixObj.nodeY &&
+                    new Point(pointName, invalidSuffixObj.nodeX, invalidSuffixObj.nodeY);
+                return {
+                    str: invalidSuffixObj.suffixFunc(rightStr, pointName),
+                    point,
+                    isPointValid: point ? false : undefined,
+                };
+            })),
+        ],
+    };
+};
+const nodeBySubstitutingX = (node, strVar) => {
+    return parseAlgebraic(node.toTex().replaceAll("x", `({${strVar}})`));
+};
+const calculateWithNode = (f, nodeX) => {
+    return nodeBySubstitutingX(f.toTree(), nodeX.toTex()).simplify();
+};
+const createArrayOfRightsAndWrongs = (f) => {
+    function createRightAndWrongsCoords(f, nodeX) {
+        const nodeYR = calculateWithNode(f, nodeX);
+        const nodeYWs = [
+            f.a.toTree(),
+            f.b.toTree(),
+            add(f.a, f.b),
+            substract(f.a, f.b),
+        ].filter((yW) => substract(yW, nodeYR).evaluate() !== 0);
+        return {
+            right: [nodeX, nodeYR],
+            wrongs: nodeYWs.map((nodeYW) => [nodeX, nodeYW]),
+        };
+    }
+    const coordObjects = [-1, 0, 1]
+        .map((x) => x.toTree())
+        .map((nodeX) => createRightAndWrongsCoords(f, nodeX));
+    const strFunc = (str, pointName, nodeX, nodeY) => `${str} qui passe par $${pointName}(${nodeX.simplify().toTex()};${nodeY
+        .simplify()
+        .toTex()})$`;
+    return [
+        createRightsAndWrongs({
+            suffixFunc: (str) => `${str}`,
+        }, []),
+        ...coordObjects.flatMap((coordObject) => createRightsAndWrongs({
+            suffixFunc: (str, pointName) => strFunc(str, pointName, coordObject.right[0], coordObject.right[1]),
+            nodeX: coordObject.right[0],
+            nodeY: coordObject.right[1],
+        }, coordObject.wrongs.map(([nodeX, nodeY]) => {
+            return {
+                suffixFunc: (str, pointName) => strFunc(str, pointName, nodeX, nodeY),
+                nodeX,
+                nodeY,
+            };
+        }))),
+    ];
+};
+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, items, coeffs } = identifiers;
+    const affine = AffineConstructor.fromCoeffs(coeffs);
+    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 une droite.
+
+$\\ $
+
+${items
+        .filter((item) => item.isValid && item.point && item.isPointValid)
+        .map((item) => {
+        const point = PointConstructor.fromIdentifiers(item.point);
+        const applyNode = nodeBySubstitutingX(affine.toTree(), point.x.toTex());
+        const texRaw = applyNode.toTex();
+        const texSimplified = applyNode.simplify().toTex();
+        return `On a :
+
+$$
+${fName}(${point.x.toTex()}) = ${texRaw} = ${texSimplified} 
+$$
+
+Donc elle passe par le point $${point.name}(${point.x.toTex()},${point.y.toTex()})$.`;
+    }).join(`
+
+$\\ $
+
+`)}
+
+$\\ $
+
+${items
+        .filter((item) => !item.isValid && item.point && !item.isPointValid)
+        .map((item) => {
+        const point = PointConstructor.fromIdentifiers(item.point);
+        const applyNode = nodeBySubstitutingX(affine.toTree(), point.x.toTex());
+        const texRaw = applyNode.toTex();
+        const texSimplified = applyNode.simplify().toTex();
+        return `On a :
+
+$$
+${fName}(${point.x.toTex()}) = ${texRaw} = ${texSimplified} \\neq ${point.y.toTex()}
+$$
+
+Donc le point $${point.name}(${point.x.toTex()},${point.y.toTex()})$ n'appartient pas à la droite représentant $${fName}$.`;
+    }).join(`
+  
+$\\ $
+
+`)}`;
+};
+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 {
+                objFunc: 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 {
+                objFunc: 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 obj = pick.objFunc(pointName);
+        previouslyPickedIndexes.push(pick.index);
+        const item = {
+            tex: obj.str,
+            isValid,
+            point: obj.point?.toIdentifiers(),
+            isPointValid: obj.isPointValid,
+        };
+        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,EAcT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAe7C,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;AA0SF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAe3D,CAAC"}

package/lib/exercises/math/functions/basics/coordsOfPointOnCurveFindY.js

@@ -0,0 +1,235 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Point } from "../../../../math/geometry/point.js";
+import { Polynomial } from "../../../../math/polynomials/polynomial.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { isOperatorNode, OperatorIds, } from "../../../../tree/nodes/operators/operatorNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { pointParser } from "../../../../tree/parsers/pointParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+const nodeByReplacingOperations = (node, replacementDict) => {
+    if (isOperatorNode(node)) {
+        const leftChild = nodeByReplacingOperations(node.leftChild, replacementDict);
+        const rightChild = nodeByReplacingOperations(node.rightChild, replacementDict);
+        const targetOperatorId = replacementDict[+node.id] ?? node.id;
+        switch (+targetOperatorId) {
+            case OperatorIds.add:
+                return add(leftChild, rightChild);
+            case OperatorIds.substract:
+                return substract(leftChild, rightChild);
+            case OperatorIds.multiply:
+                return multiply(leftChild, rightChild);
+            case OperatorIds.divide:
+                return frac(leftChild, rightChild);
+            case OperatorIds.power:
+                return power(leftChild, rightChild);
+            default:
+                return add(leftChild, rightChild);
+        }
+    }
+    else {
+        return node;
+    }
+};
+const nodeBySubstitutingX = (node, strVar) => {
+    return parseAlgebraic(node.toTex().replaceAll("x", `"${strVar}"`));
+};
+const getInstruction = (identifiers) => {
+    const { xValue, questionFunc } = identifiers;
+    const node = NodeConstructor.fromIdentifiers(questionFunc.nodeIds);
+    return `Le point $M$ d'abscisse $${xValue}$ appartient à la courbe d'équation 
+
+$$
+y=${node.toTex()} 
+$$
+
+Quelles sont les coordonnées de $M$ ?`;
+};
+const getAnswerPoint = (identifiers) => {
+    const { xValue, questionFunc } = identifiers;
+    const node = NodeConstructor.fromIdentifiers(questionFunc.nodeIds);
+    const nodeWithXValue = nodeBySubstitutingX(node, `(${xValue})`);
+    return new Point("A", xValue.toTree(), nodeWithXValue.simplify({ calculatePowers: true }));
+};
+const getAnswer = (identifiers) => {
+    const answerPoint = getAnswerPoint(identifiers);
+    const answer = `(${answerPoint.x.toTex()};${answerPoint.y.toTex()})`;
+    return answer;
+};
+const getHint = (identifiers) => {
+    const { xValue, questionFunc } = identifiers;
+    const node = NodeConstructor.fromIdentifiers(questionFunc.nodeIds);
+    const texWithXM = node.toTex().replaceAll("x", "x_M");
+    const nodeWithXValue = nodeBySubstitutingX(node, `(${xValue})`);
+    return `Les coordonnées $(x_M;y_M)$ de $M$ vérifient:
+
+$$
+${texWithXM} = y_M 
+$$
+
+On doit calculer : 
+  
+$$
+y_M = ${nodeWithXValue.toTex()}  
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { xValue, questionFunc } = identifiers;
+    const node = NodeConstructor.fromIdentifiers(questionFunc.nodeIds);
+    const texWithXM = node.toTex().replaceAll("x", "x_M");
+    const nodeWithXValue = nodeBySubstitutingX(node, `(${xValue})`);
+    const answer = getAnswer(identifiers);
+    return `Les coordonnées $(x_M;y_M)$ de $M$ vérifient:
+
+$$
+${texWithXM} = y_M 
+$$
+  
+On calcule : 
+  
+$$
+y_M = ${nodeWithXValue.toTex()} 
+$$
+
+$$
+y_M = ${answer.slice(1, -1).split(";")[1]}  
+$$
+
+Les coordonnées de $M$ sont donc $${answer}$.`;
+};
+const getPropositions = (n, { answer, questionFunc, xValue }) => {
+    const node = NodeConstructor.fromIdentifiers(questionFunc.nodeIds);
+    const propositions = [];
+    addValidProp(propositions, answer);
+    //power becomes multiply
+    tryToAddWrongProp(propositions, `(${xValue.frenchify()};${nodeBySubstitutingX(nodeByReplacingOperations(node, {
+        [OperatorIds.power]: OperatorIds.multiply,
+    }), `(${xValue})`)
+        .simplify({ calculatePowers: true })
+        .toTex()})`);
+    //sign mistake
+    tryToAddWrongProp(propositions, `(${xValue.frenchify()};${nodeBySubstitutingX(nodeByReplacingOperations(node, {
+        [OperatorIds.add]: OperatorIds.substract,
+        [OperatorIds.substract]: coinFlip()
+            ? OperatorIds.add
+            : OperatorIds.substract,
+    }), `(${xValue})`)
+        .simplify({ calculatePowers: true })
+        .toTex()})`);
+    //multiply becomes add
+    tryToAddWrongProp(propositions, `(${xValue.frenchify()};${nodeBySubstitutingX(nodeByReplacingOperations(node, {
+        [OperatorIds.multiply]: OperatorIds.add,
+    }), `(${xValue})`)
+        .simplify({ calculatePowers: true })
+        .toTex()})`);
+    //let's try 0
+    tryToAddWrongProp(propositions, `(${xValue.frenchify()};0)`);
+    //(x,y) becomes (y,x)
+    if (propositions.length < n) {
+        const [x, y] = answer.slice(1, -1).split(";");
+        tryToAddWrongProp(propositions, `(${y};${x})`);
+    }
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, `(${xValue.frenchify()};${randint(-50, 50, [0])})`);
+        tryToAddWrongProp(propositions, `(${randint(-50, 50, [0])};${xValue.frenchify()})`);
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    const pointAns = pointParser(ans);
+    if (!pointAns)
+        return false;
+    const pointAnswer = getAnswerPoint(identifiers);
+    return [
+        [pointAns.x, pointAnswer.x],
+        [pointAns.y, pointAnswer.y],
+    ].every(([ansNode, answerNode]) => substract(ansNode, answerNode).simplify().evaluate() === 0);
+};
+const getCoordsOfPointOnAffineFindYQuestion = () => {
+    const xValue = randint(-9, 10);
+    const questionFunc = random([
+        {
+            type: "...x^2",
+            nodeIds: new Polynomial([
+                randint(-9, 10),
+                randint(-5, 6),
+                randint(-2, 3, [0]),
+            ])
+                .toTree()
+                .toIdentifiers(),
+        },
+        {
+            type: "...x^3",
+            nodeIds: new Polynomial([
+                randint(-9, 10),
+                randint(-5, 6),
+                0,
+                randint(-1, 2, [0]),
+            ])
+                .toTree()
+                .toIdentifiers(),
+        },
+        {
+            type: "(x-...)(x-...)",
+            nodeIds: multiply(substract("x", randint(-3, 4, [0, xValue])), substract("x", randint(-3, 4, [0, xValue]))).toIdentifiers(),
+        },
+        {
+            type: "(x+...)(x-...)",
+            nodeIds: multiply(add("x", randint(-3, 4, [0, -xValue])), substract("x", randint(-3, 4, [0, xValue]))).toIdentifiers(),
+        },
+        {
+            type: "(x+...)(x+...)",
+            nodeIds: multiply(add("x", randint(-3, 4, [0, -xValue])), add("x", randint(-3, 4, [0, -xValue]))).toIdentifiers(),
+        },
+        {
+            type: "a/(x+...)",
+            nodeIds: frac(randint(-3, 4, [0]), add("x", randint(-3, 4, [0, -xValue]))).toIdentifiers(),
+        },
+        {
+            type: "(x+...)/(x+...)",
+            nodeIds: (() => {
+                const a = randint(-3, 4, [0]);
+                const b = randint(-3, 4, [0, -xValue, a]);
+                return frac(add("x", a), add("x", b)).toIdentifiers();
+            })(),
+        },
+    ]);
+    const identifiers = {
+        questionFunc,
+        xValue,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: ["semicolon"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const coordsOfPointOnCurveFindY = {
+    id: "coordsOfPointOnCurveFindY",
+    label: "Déterminer les coordonnées d'un point appartenant à une courbe et dont on connaît l'abscisse",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getCoordsOfPointOnAffineFindYQuestion, nb),
+    getPropositions,
+    isAnswerValid,
+    qcmTimer: 60,
+    freeTimer: 60,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

@@ -15,4 +15,5 @@ export * from "./valueTableFromGraph.js";
 export * from "./isPointOnFunction.js";
 export * from "./countFunctionZeroes.js";
 export * from "./findZeroesProductQuotient.js";
+export * from "./coordsOfPointOnCurveFindY.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mCAAmC,CAAC;AAClD,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kCAAkC,CAAC;AACjD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,gCAAgC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mCAAmC,CAAC;AAClD,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kCAAkC,CAAC;AACjD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,gCAAgC,CAAC"}

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

@@ -15,3 +15,4 @@ export * from "./valueTableFromGraph.js";
 export * from "./isPointOnFunction.js";
 export * from "./countFunctionZeroes.js";
 export * from "./findZeroesProductQuotient.js";
+export * from "./coordsOfPointOnCurveFindY.js";

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

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIds: NodeIdentifiers[];
+};
+export declare const functionComposition: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=functionComposition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"functionComposition.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/composition/functionComposition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA+D7C,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,eAAe,EAAE,CAAC;CAC5B,CAAC;AA8NF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAiBrD,CAAC"}