math-exercises 3.0.199 → 3.0.201

package/lib/exercises/math/derivation/derivative/trigo/sinCosDerivativeRewriteUsingCos2PlusSin2Equals1.js

@@ -0,0 +1,445 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { nodeByReplacingNodeAtPath } from "../../../../../math/utils/functions/functionComposition.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { cos, CosNode } from "../../../../../tree/nodes/functions/cosNode.js";
+import { isFunctionNode } from "../../../../../tree/nodes/functions/functionNode.js";
+import { sin, SinNode } from "../../../../../tree/nodes/functions/sinNode.js";
+import { NodeIds } from "../../../../../tree/nodes/node.js";
+import { NodeConstructor, } from "../../../../../tree/nodes/nodeConstructor.js";
+import { isNumberNode } from "../../../../../tree/nodes/numbers/numberNode.js";
+import { add } from "../../../../../tree/nodes/operators/addNode.js";
+import { multiply, } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { isOperatorNode, } from "../../../../../tree/nodes/operators/operatorNode.js";
+import { isPowerNode, isSquareNode, power, square, } from "../../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
+import { VariableNode } from "../../../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../../tree/utilities/nodeComparator.js";
+import { NodePrinter } from "../../../../../tree/utilities/nodePrinter.js";
+import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
+import { shuffle } from "../../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+function myRewrite(node, createFuncRewrite) {
+    const funcRewrite = createFuncRewrite(node);
+    if (funcRewrite !== undefined) {
+        const nodeRewritten = funcRewrite(node);
+        return nodeRewritten;
+    }
+    else {
+        if (isOperatorNode(node)) {
+            return nodeByReplacingNodeAtPath(nodeByReplacingNodeAtPath(node, { keys: ["leftChild"] }, myRewrite(node.leftChild, createFuncRewrite)), { keys: ["rightChild"] }, myRewrite(node.rightChild, createFuncRewrite));
+        }
+        else if (isFunctionNode(node)) {
+            return nodeByReplacingNodeAtPath(node, { keys: ["child"] }, myRewrite(node.child, createFuncRewrite));
+        }
+        else {
+            return node;
+        }
+    }
+}
+const mySimplify = (node) => {
+    const rewriteCosToCAndSinToS = (node) => myRewrite(node, (node) => {
+        if (node.toTex() === "\\cos\\left(x\\right)") {
+            return () => new VariableNode("c");
+        }
+        else if (node.toTex() === "\\sin\\left(x\\right)") {
+            return () => new VariableNode("s");
+        }
+        else {
+            return undefined;
+        }
+    });
+    const rewriteCToCosAndSToSin = (node) => myRewrite(node, (node) => {
+        if (node.toTex() === "c") {
+            return () => new CosNode(new VariableNode("x"));
+        }
+        else if (node.toTex() === "s") {
+            return () => new SinNode(new VariableNode("x"));
+        }
+        else {
+            return undefined;
+        }
+    });
+    const nodeCSRaw = rewriteCosToCAndSinToS(node);
+    const nodeCSSimplified = nodeCSRaw.simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    });
+    const nodeMySimplified = rewriteCToCosAndSToSin(nodeCSSimplified);
+    return nodeMySimplified;
+};
+const getPrettyNodeDerivative = (node) => {
+    if (isPowerNode(node)) {
+        const nodeDerivativeUgly = node.derivative();
+        const nodeDerivativeLeft = nodeDerivativeUgly.leftChild;
+        const nodeDerivativeRight = nodeDerivativeUgly.rightChild;
+        const nodeDerivativePretty = multiply(nodeDerivativeLeft.leftChild, multiply(nodeDerivativeLeft.rightChild.simplify({
+            towardsDistribute: true,
+            forbidFactorize: true,
+        }), nodeDerivativeRight));
+        return nodeDerivativePretty;
+    }
+    else {
+        return node.derivative();
+    }
+};
+const getInstruction = (identifiers) => {
+    const { nodeIdsLambda, nodeIdsU, nodeIdsV, nodeIdsRewriteUsing } = identifiers;
+    const [nodeLambda, nodeU, nodeV, nodeRewriteUsing] = [
+        nodeIdsLambda,
+        nodeIdsU,
+        nodeIdsV,
+        nodeIdsRewriteUsing,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeF = multiply(nodeLambda, multiply(nodeU, nodeV)).simplify();
+    return `Soit la fonction $f$ définie sur $\\mathbb{R}$ par : 
+  
+$$
+f(x) = ${nodeF.toTex()}
+$$
+
+Calculer $f'(x)$, et l'exprimer uniquement en fonction de $${nodeRewriteUsing.toTex()}$.`;
+};
+const getNodeFDerivativeStuff = (identifiers) => {
+    const { nodeIdsLambda, nodeIdsU, nodeIdsV } = identifiers;
+    const [nodeLambda, nodeU, nodeV] = [nodeIdsLambda, nodeIdsU, nodeIdsV].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    // const nodeF = multiply(nodeLambda, multiply(nodeU, nodeV)).simplify();
+    const [nodeUPrime, nodeVPrime] = [nodeU, nodeV].map(getPrettyNodeDerivative);
+    //f' = lambda (u'v+uv')
+    return {
+        nodeFDerivative0: multiply(nodeLambda, add(multiply(nodeUPrime, nodeV), multiply(nodeU, nodeVPrime))),
+        nodeFDerivative1: multiply(nodeLambda, add(mySimplify(multiply(nodeUPrime, nodeV).simplify()), mySimplify(multiply(nodeU, nodeVPrime).simplify()))),
+    };
+};
+const getAnswerNode = (identifiers) => {
+    const { nodeIdsRewriteUsing } = identifiers;
+    const { nodeFDerivative1: nodeDerivative1 } = getNodeFDerivativeStuff(identifiers);
+    const createFuncRewrite = (node) => {
+        const isPowerNode2 = (node) => isPowerNode(node) &&
+            isNumberNode(node.rightChild) &&
+            node.rightChild.value === 2;
+        if (isSquareNode(node) || isPowerNode2(node)) {
+            const nodeIdsLeftChild = node.leftChild.toIdentifiers();
+            switch (nodeIdsRewriteUsing.id) {
+                case NodeIds.cos:
+                    if (nodeIdsLeftChild.id === NodeIds.sin) {
+                        return (node) => {
+                            const nodeSin = node.leftChild;
+                            return substract(1, power(cos(nodeSin.child), 2));
+                        };
+                    }
+                    else {
+                        return undefined;
+                    }
+                case NodeIds.sin:
+                    if (nodeIdsLeftChild.id === NodeIds.cos) {
+                        return (node) => {
+                            const nodeCos = node.leftChild;
+                            return substract(1, power(sin(nodeCos.child), 2));
+                        };
+                    }
+                    else {
+                        return undefined;
+                    }
+            }
+        }
+        else {
+            return undefined;
+        }
+    };
+    const nodeDerivative2 = myRewrite(nodeDerivative1, createFuncRewrite);
+    return nodeDerivative2;
+};
+const getAnswer = (identifiers) => {
+    return mySimplify(getAnswerNode(identifiers)).toTex();
+};
+const getHint = (_identifiers) => {
+    return `Si $u$ et $v$ sont deux fonctions dérivables alors, 
+pour $x$ dans l'ensemble de dérivation de $u \\circ v = x \\mapsto u(v(x))$, on a : 
+
+$$
+(u \\circ v)'(x) = v'(x)u'(v(x))
+$$
+
+Une fois que tu as obtenu la dérivée, réécris-la en utilisant la formule,
+pour tout $x$ réel :
+
+$$
+\\sin^{2}{(x)} + \\cos^{2}{(x)} = 1
+$$
+  
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIdsLambda, nodeIdsU, nodeIdsV } = identifiers;
+    const [nodeLambda, nodeU, nodeV] = [nodeIdsLambda, nodeIdsU, nodeIdsV].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [nodeUPrime, nodeVPrime] = [nodeU, nodeV].map(getPrettyNodeDerivative);
+    const { nodeFDerivative0, nodeFDerivative1 } = getNodeFDerivativeStuff(identifiers);
+    const nodeAnswer = getAnswerNode(identifiers);
+    return `On doit calculer la dérivée d'un produit.
+  
+${(() => {
+        if (nodeLambda.evaluate() === 1) {
+            return `Ici, $f(x) = u(x) v(x)$ avec :`;
+        }
+        else {
+            return `Ici, $f(x) = \\lambda u(x) v(x)$ avec :
+
+$$
+\\lambda = ${nodeLambda.toTex({})}
+$$
+
+`;
+        }
+    })()}
+
+
+$$
+u(x) = ${nodeU.toTex({})}
+$$
+
+$$
+v(x) = ${nodeV.toTex()}
+$$
+
+On calcule (dérivées de fonctions composées): 
+
+$$
+u'(x) = ${nodeUPrime.toTex()}
+$$
+
+$$
+v'(x) = ${nodeVPrime.toTex()}
+$$
+
+Donc :
+
+${alignTex([
+        [
+            `f'(x)`,
+            `=`,
+            nodeLambda.evaluate() === 1
+                ? `u'(x)v(x)+u(x)v'(x)`
+                : `\\lambda(u'(x)v(x)+u(x)v'(x))`,
+        ],
+        [``, `=`, NodePrinter.toTexWithMaxWidth(nodeFDerivative0, 70)],
+        [``, `=`, nodeFDerivative1.toTex()],
+    ])}
+
+Pour tout $x$ réel, on a :
+
+$$
+\\sin^{2}{(x)} + \\cos^{2}{(x)} = 1
+$$
+
+On peut donc réécrire :
+
+${alignTex([
+        [`f'(x)`, `=`, nodeAnswer.toTex()],
+        [``, `=`, mySimplify(nodeAnswer).toTex()],
+    ])}
+
+`;
+};
+const getPropositions = (n, { answer: _answer, ...identifiers }) => {
+    const { nodeIdsU, nodeIdsV, nodeIdsRewriteUsing } = identifiers;
+    const [nodeU, nodeV] = [nodeIdsU, nodeIdsV].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [_nodeUPrime, _nodeVPrime] = [nodeU, nodeV].map((node) => node.derivative().simplify());
+    const maxWidthForTex = 70;
+    const propositions = [];
+    const nodeAnswer = mySimplify(getAnswerNode(identifiers));
+    addValidProp(propositions, NodePrinter.toTexWithMaxWidth(nodeAnswer, maxWidthForTex));
+    //student: cos^2(x) - sin^2(x) = 1
+    {
+        const { nodeFDerivative1: nodeDerivative1 } = getNodeFDerivativeStuff(identifiers);
+        const createFuncRewrite = (node) => {
+            const isPowerNode2 = (node) => isPowerNode(node) &&
+                isNumberNode(node.rightChild) &&
+                node.rightChild.value === 2;
+            if (isSquareNode(node) || isPowerNode2(node)) {
+                const nodeIdsLeftChild = node.leftChild.toIdentifiers();
+                switch (nodeIdsRewriteUsing.id) {
+                    case NodeIds.cos:
+                        if (nodeIdsLeftChild.id === NodeIds.sin) {
+                            return (node) => {
+                                const nodeSin = node.leftChild;
+                                return substract(power(cos(nodeSin.child), 2), 1);
+                            };
+                        }
+                        else {
+                            return undefined;
+                        }
+                    case NodeIds.sin:
+                        if (nodeIdsLeftChild.id === NodeIds.cos) {
+                            return (node) => {
+                                const nodeCos = node.leftChild;
+                                return add(1, power(sin(nodeCos.child), 2));
+                            };
+                        }
+                        else {
+                            return undefined;
+                        }
+                }
+            }
+            else {
+                return undefined;
+            }
+        };
+        const nodeDerivative2 = myRewrite(nodeDerivative1, createFuncRewrite);
+        try {
+            const nodeWrong = mySimplify(nodeDerivative2);
+            tryToAddWrongProp(propositions, NodePrinter.toTexWithMaxWidth(nodeWrong, maxWidthForTex));
+        }
+        catch (e) {
+            console.log(e);
+        }
+    }
+    //student: cos^2(x) + sin^2(x) = -1
+    {
+        const { nodeFDerivative1: nodeDerivative1 } = getNodeFDerivativeStuff(identifiers);
+        const createFuncRewrite = (node) => {
+            const isPowerNode2 = (node) => isPowerNode(node) &&
+                isNumberNode(node.rightChild) &&
+                node.rightChild.value === 2;
+            if (isSquareNode(node) || isPowerNode2(node)) {
+                const nodeIdsLeftChild = node.leftChild.toIdentifiers();
+                switch (nodeIdsRewriteUsing.id) {
+                    case NodeIds.cos:
+                        if (nodeIdsLeftChild.id === NodeIds.sin) {
+                            return (node) => {
+                                const nodeSin = node.leftChild;
+                                return substract(-1, power(cos(nodeSin.child), 2));
+                            };
+                        }
+                        else {
+                            return undefined;
+                        }
+                    case NodeIds.sin:
+                        if (nodeIdsLeftChild.id === NodeIds.cos) {
+                            return (node) => {
+                                const nodeCos = node.leftChild;
+                                return substract(-1, power(sin(nodeCos.child), 2));
+                            };
+                        }
+                        else {
+                            return undefined;
+                        }
+                }
+            }
+            else {
+                return undefined;
+            }
+        };
+        const nodeDerivative2 = myRewrite(nodeDerivative1, createFuncRewrite);
+        try {
+            const nodeWrong = mySimplify(nodeDerivative2);
+            tryToAddWrongProp(propositions, NodePrinter.toTexWithMaxWidth(nodeWrong, maxWidthForTex));
+        }
+        catch (e) {
+            console.log(e);
+        }
+    }
+    //student: cos(x) = sin(x)
+    {
+        const { nodeFDerivative1: nodeDerivative1 } = getNodeFDerivativeStuff(identifiers);
+        const createFuncRewrite = (node) => {
+            const isPowerNode2 = (node) => isPowerNode(node) &&
+                isNumberNode(node.rightChild) &&
+                node.rightChild.value === 2;
+            if (isSquareNode(node) || isPowerNode2(node)) {
+                const nodeIdsLeftChild = node.leftChild.toIdentifiers();
+                switch (nodeIdsRewriteUsing.id) {
+                    case NodeIds.cos:
+                        if (nodeIdsLeftChild.id === NodeIds.sin) {
+                            return (node) => {
+                                const nodeSin = node.leftChild;
+                                return power(cos(nodeSin.child), 2);
+                            };
+                        }
+                        else {
+                            return undefined;
+                        }
+                    case NodeIds.sin:
+                        if (nodeIdsLeftChild.id === NodeIds.cos) {
+                            return (node) => {
+                                const nodeCos = node.leftChild;
+                                return power(sin(nodeCos.child), 2);
+                            };
+                        }
+                        else {
+                            return undefined;
+                        }
+                }
+            }
+            else {
+                return undefined;
+            }
+        };
+        const nodeDerivative2 = myRewrite(nodeDerivative1, createFuncRewrite);
+        try {
+            const nodeWrong = mySimplify(nodeDerivative2);
+            tryToAddWrongProp(propositions, NodePrinter.toTexWithMaxWidth(nodeWrong, maxWidthForTex));
+        }
+        catch (e) {
+            console.log(e);
+        }
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = getAnswerNode(identifiers);
+        return NodeComparator.isEqualViaRandomEvaluations(nodeAns, nodeAnswer, 3);
+    }
+    catch (e) {
+        handleVEAError(e);
+        return false;
+    }
+};
+const getSinCosDerivativeRewriteUsingCos2PlusSin2Equals1Question = () => {
+    const nodeVarX = new VariableNode("x");
+    const createRandomFactorNode = () => ((coinFlip() ? +1 : -1) * randint(1, 7)).toTree();
+    const [func1, func2] = shuffle([sin, cos]);
+    const nodeLambda = createRandomFactorNode();
+    const node1 = square(func1(nodeVarX));
+    const node2 = func2(nodeVarX);
+    const [nodeU, nodeV] = shuffle([node1, node2]);
+    const identifiers = {
+        nodeIdsLambda: nodeLambda.toIdentifiers(),
+        nodeIdsU: nodeU.toIdentifiers(),
+        nodeIdsV: nodeV.toIdentifiers(),
+        nodeIdsRewriteUsing: func1(nodeVarX).toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["x", "sin", "cos", "tan"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const sinCosDerivativeRewriteUsingCos2PlusSin2Equals1 = {
+    id: "sinCosDerivativeRewriteUsingCos2PlusSin2Equals1",
+    connector: "=",
+    label: "Dérivée de $\\sin{(x)}\\cos^{2}{(x)}$ ou $\\sin^{2}{(x)}\\cos{(x)}$ à exprimer en fonction de $\\cos{(x)}$ ou $\\sin{(x)}$ uniquement",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getSinCosDerivativeRewriteUsingCos2PlusSin2Equals1Question, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/derivation/problems/index.d.ts

@@ -1,5 +1,4 @@
 export * from "./problemMaximizeBoxVolumeFindX.js";
 export * from "./problemProjectileHeightFindAbscissa.js";
-export * from "./problemMaximizeProfitFindProduction.js";
 export * from "./problemMovementOnLineFindSpeedAtPoint.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/derivation/problems/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/problems/index.ts"],"names":[],"mappings":"AAAA,cAAc,oCAAoC,CAAC;AACnD,cAAc,0CAA0C,CAAC;AACzD,cAAc,0CAA0C,CAAC;AACzD,cAAc,4CAA4C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/problems/index.ts"],"names":[],"mappings":"AAAA,cAAc,oCAAoC,CAAC;AACnD,cAAc,0CAA0C,CAAC;AAEzD,cAAc,4CAA4C,CAAC"}

package/lib/exercises/math/derivation/problems/index.js

@@ -1,4 +1,4 @@
 export * from "./problemMaximizeBoxVolumeFindX.js";
 export * from "./problemProjectileHeightFindAbscissa.js";
-export * from "./problemMaximizeProfitFindProduction.js";
+// export * from "./problemMaximizeProfitFindProduction.js";
 export * from "./problemMovementOnLineFindSpeedAtPoint.js";

package/lib/exercises/math/derivation/problems/problemMovementOnLineFindSpeedAtPoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"problemMovementOnLineFindSpeedAtPoint.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/problems/problemMovementOnLineFindSpeedAtPoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAUrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA0E7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,oBAAoB,EAAE,eAAe,CAAC;IACtC,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAyRF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAoCF,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAC1D,WAAW,EACX,OAAO,CAqBR,CAAC"}
+{"version":3,"file":"problemMovementOnLineFindSpeedAtPoint.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/problems/problemMovementOnLineFindSpeedAtPoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAUrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA0E7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,oBAAoB,EAAE,eAAe,CAAC;IACtC,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA2RF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAoCF,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAC1D,WAAW,EACX,OAAO,CAqBR,CAAC"}

package/lib/exercises/math/derivation/problems/problemMovementOnLineFindSpeedAtPoint.js

@@ -194,10 +194,13 @@ const getPropositions = (n, { answer, ...identifiers }) => {
     const propositions = [];
     addValidProp(propositions, answer);
     propWhile(propositions, n, () => {
-        const identifierWrong = createRandomIdentifiers(typeF);
-        if (isIdentifiersQCPassed(identifierWrong)) {
+        try {
+            const identifierWrong = createRandomIdentifiers(typeF);
             tryToAddWrongProp(propositions, getAnswer(identifierWrong));
         }
+        catch (_) {
+            (() => { })();
+        }
     });
     return shuffle(propositions);
 };

package/lib/exercises/math/derivation/tangent/index.d.ts

@@ -6,7 +6,6 @@ export * from "./derivativeNumberOrImageReading.js";
 export * from "./horizontalTangentFromAlgebraic.js";
 export * from "./derivativeReadingByManipulatingPoint.js";
 export * from "./derivativeEquationSolvingByManipulatingPoint.js";
-export * from "./derivativeEquationSolvingByManipulatingLineY.js";
 export * from "./placePointsOfDerivativeFromGraph.js";
 export * from "./tangentEquationFromGraph.js";
 export * from "./tangentEquationFromFunctionExpression.js";

package/lib/exercises/math/derivation/tangent/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/tangent/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uCAAuC,CAAC;AACtD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,qCAAqC,CAAC;AACpD,cAAc,qCAAqC,CAAC;AACpD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,mDAAmD,CAAC;AAClE,cAAc,mDAAmD,CAAC;AAClE,cAAc,uCAAuC,CAAC;AACtD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,4CAA4C,CAAC;AAC3D,cAAc,qDAAqD,CAAC;AACpE,cAAc,2DAA2D,CAAC;AAC1E,cAAc,4CAA4C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/tangent/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uCAAuC,CAAC;AACtD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,qCAAqC,CAAC;AACpD,cAAc,qCAAqC,CAAC;AACpD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,mDAAmD,CAAC;AAElE,cAAc,uCAAuC,CAAC;AACtD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,4CAA4C,CAAC;AAC3D,cAAc,qDAAqD,CAAC;AACpE,cAAc,2DAA2D,CAAC;AAC1E,cAAc,4CAA4C,CAAC"}

package/lib/exercises/math/derivation/tangent/index.js

@@ -6,7 +6,7 @@ export * from "./derivativeNumberOrImageReading.js";
 export * from "./horizontalTangentFromAlgebraic.js";
 export * from "./derivativeReadingByManipulatingPoint.js";
 export * from "./derivativeEquationSolvingByManipulatingPoint.js";
-export * from "./derivativeEquationSolvingByManipulatingLineY.js";
+// export * from "./derivativeEquationSolvingByManipulatingLineY.js";
 export * from "./placePointsOfDerivativeFromGraph.js";
 export * from "./tangentEquationFromGraph.js";
 export * from "./tangentEquationFromFunctionExpression.js";

package/lib/exercises/math/derivation/variations/index.d.ts

@@ -6,11 +6,11 @@ export * from "./signVarTableFromGraph.js";
 export * from "./signVarTableFromDerivativeGraph.js";
 export * from "./signVarTableTrinom.js";
 export * from "./signVarTableProductFExp.js";
-export * from "./signVarTableQuotientFExp.js";
 export * from "./findAbscissaOfExtremaFromFunctionExpression.js";
 export * from "./findExtremaFromFunctionExpression.js";
 export * from "./signVarTableFromFunctionExpression.js";
 export * from "./plausibleDerivativeGraphFromFunctionGraphByManipulatingPolynomial.js";
 export * from "./plausibleFunctionGraphFromDerivativeGraphByManipulatingPolynomial.js";
 export * from "./signVarTable3dDegree.js";
+export * from "./signVarTableAffinePlusCXLogX.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/derivation/variations/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/variations/index.ts"],"names":[],"mappings":"AAAA,cAAc,mCAAmC,CAAC;AAClD,cAAc,qCAAqC,CAAC;AACpD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4CAA4C,CAAC;AAC3D,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sCAAsC,CAAC;AACrD,cAAc,yBAAyB,CAAC;AAExC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kDAAkD,CAAC;AACjE,cAAc,wCAAwC,CAAC;AACvD,cAAc,yCAAyC,CAAC;AACxD,cAAc,wEAAwE,CAAC;AACvF,cAAc,wEAAwE,CAAC;AACvF,cAAc,2BAA2B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/variations/index.ts"],"names":[],"mappings":"AAAA,cAAc,mCAAmC,CAAC;AAClD,cAAc,qCAAqC,CAAC;AACpD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4CAA4C,CAAC;AAC3D,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sCAAsC,CAAC;AACrD,cAAc,yBAAyB,CAAC;AAExC,cAAc,8BAA8B,CAAC;AAE7C,cAAc,kDAAkD,CAAC;AACjE,cAAc,wCAAwC,CAAC;AACvD,cAAc,yCAAyC,CAAC;AACxD,cAAc,wEAAwE,CAAC;AACvF,cAAc,wEAAwE,CAAC;AACvF,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mCAAmC,CAAC"}

package/lib/exercises/math/derivation/variations/index.js

@@ -7,10 +7,11 @@ export * from "./signVarTableFromDerivativeGraph.js";
 export * from "./signVarTableTrinom.js";
 // export * from "./signVarTable3dDegree.js";
 export * from "./signVarTableProductFExp.js";
-export * from "./signVarTableQuotientFExp.js";
+// export * from "./signVarTableQuotientFExp.js";
 export * from "./findAbscissaOfExtremaFromFunctionExpression.js";
 export * from "./findExtremaFromFunctionExpression.js";
 export * from "./signVarTableFromFunctionExpression.js";
 export * from "./plausibleDerivativeGraphFromFunctionGraphByManipulatingPolynomial.js";
 export * from "./plausibleFunctionGraphFromDerivativeGraphByManipulatingPolynomial.js";
 export * from "./signVarTable3dDegree.js";
+export * from "./signVarTableAffinePlusCXLogX.js";

package/lib/exercises/math/derivation/variations/signVarTableAffinePlusCXLogX.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsA: NodeIdentifiers;
+    nodeIdsB: NodeIdentifiers;
+    nodeIdsC: NodeIdentifiers;
+};
+export declare const signVarTableAffinePlusCXLogX: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=signVarTableAffinePlusCXLogX.d.ts.map

package/lib/exercises/math/derivation/variations/signVarTableAffinePlusCXLogX.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signVarTableAffinePlusCXLogX.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/variations/signVarTableAffinePlusCXLogX.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AASrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAqD7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AAoNF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAoB9D,CAAC"}