math-exercises 3.0.172 → 3.0.174

package/lib/exercises/math/trigonometry/functions/cosInequationMainInterval.js

@@ -0,0 +1,208 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { red } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { InequationSymbolConstructor, } from "../../../../math/inequations/inequation.js";
+import { mainTrigoValues } from "../../../../math/trigonometry/remarkableValues.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { PiNode } from "../../../../tree/nodes/numbers/piNode.js";
+import { ClosureType } from "../../../../tree/nodes/sets/closure.js";
+import { IntervalNode } from "../../../../tree/nodes/sets/intervalNode.js";
+import { UnionIntervalNode } from "../../../../tree/nodes/sets/unionIntervalNode.js";
+import { unionIntervalParser } from "../../../../tree/parsers/unionIntervalParser.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, ineqType, cosIds }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, getAnswer({
+        ineqType: InequationSymbolConstructor.reverse(ineqType),
+        cosIds: cosIds,
+    }));
+    propWhile(propositions, n, () => {
+        const value = random(mainTrigoValues.filter((v) => Math.abs(v.cos.evaluate()) !== 1));
+        tryToAddWrongProp(propositions, getAnswer({
+            ineqType: ineqType,
+            cosIds: value.cos.toIdentifiers(),
+        }));
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { cosIds, ineqType } = identifiers;
+    const cosValue = reifyAlgebraic(cosIds);
+    //trouve la premiere value dans ]-pi; 0]
+    const values = mainTrigoValues
+        .filter((v) => Math.abs(v.cos.evaluate() - cosValue.evaluate()) < 0.0001)
+        .map((e) => e.angle);
+    switch (ineqType) {
+        case "<":
+            return new UnionIntervalNode([
+                new IntervalNode(opposite(PiNode), values[0], ClosureType.OO),
+                new IntervalNode(values[1], PiNode, ClosureType.OF),
+            ]).toTex();
+        case "\\le":
+            return new UnionIntervalNode([
+                new IntervalNode(opposite(PiNode), values[0], ClosureType.OF),
+                new IntervalNode(values[1], PiNode, ClosureType.FF),
+            ]).toTex();
+        case ">":
+            return new IntervalNode(values[0], values[1], ClosureType.OO).toTex();
+            break;
+        case "\\ge":
+            return new IntervalNode(values[0], values[1], ClosureType.FF).toTex();
+    }
+};
+const getInstruction = (identifiers) => {
+    const { cosIds, ineqType } = identifiers;
+    const cosValue = reifyAlgebraic(cosIds);
+    return `Résoudre dans $]-\\pi; \\pi]$ l'inéquation suivante : 
+  
+$$
+\\cos(x)${ineqType}${cosValue.toTex()}
+$$`;
+};
+const getHint = (identifiers) => {
+    const { cosIds } = identifiers;
+    const cosValue = reifyAlgebraic(cosIds);
+    return `Commence par résoudre sur $]-\\pi; \\pi]$ l'équation :
+  
+$$
+\\cos(x)=${cosValue.toTex()}
+$$
+
+Puis, sers-toi du cercle trigonométrique pour en déduire l'ensemble des solutions de l'inéquation proposée.`;
+};
+const getCorrection = (identifiers) => {
+    const { cosIds, ineqType } = identifiers;
+    const cosValue = reifyAlgebraic(cosIds);
+    //trouve la premiere value dans ]-pi; 0]
+    const values = mainTrigoValues
+        .filter((v) => Math.abs(v.cos.evaluate() - cosValue.evaluate()) < 0.0001)
+        .map((e) => e.angle);
+    return `On commence par résoudre sur $]-\\pi; \\pi]$ l'équation :
+  
+$$
+\\cos(x)=${cosValue.toTex()}
+$$
+
+Les solutions sont $${values[0].toTex()}$ et $${values[1].toTex()}$.
+
+Puis on se sers du cercle trigonométrique ci-dessous, pour en déduire que l'ensemble des solutions de l'inéquation $\\cos(x)${ineqType}${cosValue.toTex()}$ est :
+
+$$
+${getAnswer(identifiers)}
+$$
+`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { cosIds, ineqType } = identifiers;
+    const cosValue = reifyAlgebraic(cosIds);
+    const values = mainTrigoValues
+        .filter((v) => Math.abs(v.cos.evaluate() - cosValue.evaluate()) < 0.0001)
+        .map((e) => e.angle);
+    const commands = [
+        `C : x^2 + y^2 = 1`,
+        `O = (0,0)`,
+        `ShowLabel(O, false)`,
+        `SetVisibleInView(O, 1, false)`,
+        `ShowLabel(C, false)`,
+        `SetFixed(C, true ,false)`,
+        `d : x = ${cosValue.evaluate()}`,
+        `SetLineThickness(d, 1.7)`,
+        `SetLineStyle(d, 1)`,
+        `A = (cos(${values[0].evaluate()}), sin(${values[0].evaluate()}))`,
+        `ShowLabel(A, false)`,
+        `Text("$\\tiny ${values[0].toTex()}$", A+0.3*Vector(O,A), false, true, 0, 0)`,
+        `B = (cos(${values[1].evaluate()}), sin(${values[1].evaluate()}))`,
+        `Text("$\\tiny ${values[1].toTex()}$", B+0.3*Vector(O,B), false, true, 0, 0)`,
+        `ShowLabel(B, false)`,
+        `D = (${cosValue.evaluate()}, 0)`,
+        `SetCaption(D, "$\\tiny ${cosValue.toTex()}$")`,
+        `Text("$\\tiny ${cosValue.toTex()}$", D, false, true, 0, 0)`,
+        `SetPointSize(D, 1.3)`,
+        `ShowLabel(D, false)`,
+        `E = (-1,0)`,
+        `I = (1,0)`,
+        `SetVisibleInView(E, 1, false)`,
+        `SetVisibleInView(I, 1, false)`,
+        `v = Vector(E, I)`,
+        `w = Vector((0, -1), (0, 1))`,
+        `SetLineThickness(v, 1.3)`,
+        `SetLineThickness(w, 1.3)`,
+    ];
+    if (ineqType === "<" || ineqType === "\\le") {
+        commands.push(`S = CircumcircularArc(A,E,B)`);
+    }
+    else {
+        commands.push(`S = CircumcircularArc(A,I,B)`);
+    }
+    commands.push(`SetFixed(S, true, false)`);
+    commands.push(`SetColor(S, "${red}")`);
+    const ggb = new GeogebraConstructor({
+        commands,
+        hideAxes: true,
+        hideGrid: true,
+    });
+    return ggb.getOptions({
+        coords: cosValue.evaluate() === 0
+            ? [-1.1, 1.1, -1.5, 1.5]
+            : [-1.1, 1.1, -1.3, 1.3],
+    });
+};
+const getKeys = () => {
+    return ["pi", "cup", "lbracket", "semicolon", "rbracket"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = unionIntervalParser(ans, {
+            allowCommaInsteadOfSemicolon: true,
+            allowNoBrackets: true,
+        });
+        if (!parsed)
+            return false;
+        return parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getCosInequationMainIntervalQuestion = () => {
+    const value = random(mainTrigoValues.filter((v) => Math.abs(v.cos.evaluate()) !== 1));
+    const identifiers = {
+        cosIds: value.cos.toIdentifiers(),
+        ineqType: random(["<", ">", "\\le", "\\ge"]),
+    };
+    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),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers),
+    };
+};
+export const cosInequationMainInterval = {
+    id: "cosInequationMainInterval",
+    label: "Résoudre une inéquation du type $\\cos(x)\\leq k$ sur $]-\\pi; \\pi]$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCosInequationMainIntervalQuestion(opts), nb, 20),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    maxAllowedQuestions: 20,
+};

package/lib/exercises/math/trigonometry/functions/equationSinOnRandomInterval.d.ts

@@ -1,8 +1,2 @@
-import { Exercise } from "../../../../exercises/exercise.js";
-type Identifiers = {
-    degree: number;
-    leftBoundPiMultiple: number;
-};
-export declare const equationSinOnRandomInterval: Exercise<Identifiers>;
 export {};
 //# sourceMappingURL=equationSinOnRandomInterval.d.ts.map

package/lib/exercises/math/trigonometry/functions/equationSinOnRandomInterval.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"equationSinOnRandomInterval.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/functions/equationSinOnRandomInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAmBrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,mBAAmB,EAAE,MAAM,CAAC;CAC7B,CAAC;AAiHF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAc7D,CAAC"}
+{"version":3,"file":"equationSinOnRandomInterval.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/functions/equationSinOnRandomInterval.ts"],"names":[],"mappings":""}

package/lib/exercises/math/trigonometry/functions/equationSinOnRandomInterval.js

@@ -1,101 +1,164 @@
-import { addValidProp, shuffleProps, propWhile, } from "../../../../exercises/exercise.js";
-import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
-import { mainPositiveTrigovalues, mainTrigoValues, trigoValuesOnZeroTwoPIOF, } from "../../../../math/trigonometry/remarkableValues.js";
-import { randint } from "../../../../math/utils/random/randint.js";
-import { EquationSolutionNode } from "../../../../tree/nodes/equations/equationSolutionNode.js";
-import { SinNode } from "../../../../tree/nodes/functions/sinNode.js";
-import { PiNode } from "../../../../tree/nodes/numbers/piNode.js";
-import { AddNode } from "../../../../tree/nodes/operators/addNode.js";
-import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
-import { ClosureType } from "../../../../tree/nodes/sets/closure.js";
-import { DiscreteSetNode } from "../../../../tree/nodes/sets/discreteSetNode.js";
-import { IntervalNode } from "../../../../tree/nodes/sets/intervalNode.js";
-import { random } from "../../../../utils/alea/random.js";
-const getPropositions = (n, { answer }) => {
-    const propositions = [];
-    addValidProp(propositions, answer);
-    propWhile(propositions, n, () => {
-        throw Error("QCM not implemented");
-    });
-    return shuffleProps(propositions, n);
-};
-const getAnswer = (identifiers) => {
-    const coeff = identifiers.leftBoundPiMultiple;
-    /**
-     * Si l'intervalle est centré autour d'un multiple de 2pi (coeff impair) (genre ]3pi, 5pi]) on ajoute (coeff+1)/2 tours
-     * Sinon (coeff pair) (genre ]2pi, 4pipi]) , on chope la value de ]0, 2pi] et on ajoute coeff/2 tours
-     */
-    const turnsToAdd = Math.abs(coeff % 2) === 1 ? (coeff + 1) / 2 : coeff / 2;
-    const sin = mainTrigoValues
-        .find((v) => v.degree === identifiers.degree)
-        .sin.evaluate({});
-    const values = (Math.abs(coeff % 2) === 1 ? mainTrigoValues : trigoValuesOnZeroTwoPIOF).filter((v) => v.sin.evaluate({}) === sin);
-    if (values.length === 1) {
-        const value = values[0];
-        const newValue = new AddNode(value.angle, new MultiplyNode((turnsToAdd * 2).toTree(), PiNode)).simplify();
-        return (new EquationSolutionNode(new DiscreteSetNode([newValue])).toTex() +
-            ` turns ${turnsToAdd}, value : ${value.angle.toTex()}`);
-    }
-    else {
-        const newValues = values.map((v) => {
-            return new AddNode(v.angle, new MultiplyNode((turnsToAdd * 2).toTree(), PiNode)).simplify();
-        });
-        return (new EquationSolutionNode(new DiscreteSetNode(newValues.sort((a, b) => a.evaluate({}) - b.evaluate({})))).toTex() +
-            ` turns ${turnsToAdd}, values: ${values.map((v) => v.angle.toTex())}`);
-    }
-};
-const getInstruction = ({ degree, leftBoundPiMultiple, }) => {
-    const value = mainPositiveTrigovalues.find((v) => v.degree === degree);
-    const leftBound = new MultiplyNode(leftBoundPiMultiple.toTree(), PiNode).simplify();
-    const rightBound = new MultiplyNode((leftBoundPiMultiple + 2).toTree(), PiNode).simplify();
-    const interval = new IntervalNode(leftBound, rightBound, ClosureType.OF);
-    return `Résoudre sur $${interval.toTex()}$ l'équation : 
-    
-$$
-${new SinNode("x".toTree()).toTex()}=${value.sin.toTex()}
-$$`;
-};
-// const getHint: GetHint<Identifiers> = (identifiers) => {
-//   return "";
+// import {
+//   Exercise,
+//   Proposition,
+//   QCMGenerator,
+//   Question,
+//   QuestionGenerator,
+//   VEA,
+//   addValidProp,
+//   shuffleProps,
+//   GetAnswer,
+//   GetInstruction,
+//   GetKeys,
+//   GetQuestionFromIdentifiers,
+//   propWhile,
+// } from "../../../../exercises/exercise.js";
+// import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+// import {
+//   mainPositiveTrigovalues,
+//   mainTrigoValues,
+//   trigoValuesOnZeroTwoPIOF,
+// } from "../../../../math/trigonometry/remarkableValues.js";
+// import { randint } from "../../../../math/utils/random/randint.js";
+// import { EquationSolutionNode } from "../../../../tree/nodes/equations/equationSolutionNode.js";
+// import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
+// import { sin, SinNode } from "../../../../tree/nodes/functions/sinNode.js";
+// import {
+//   NodeIdentifiers,
+//   reifyAlgebraic,
+// } from "../../../../tree/nodes/nodeConstructor.js";
+// import { PiNode } from "../../../../tree/nodes/numbers/piNode.js";
+// import { add, AddNode } from "../../../../tree/nodes/operators/addNode.js";
+// import {
+//   multiply,
+//   MultiplyNode,
+// } from "../../../../tree/nodes/operators/multiplyNode.js";
+// import { ClosureType } from "../../../../tree/nodes/sets/closure.js";
+// import { DiscreteSetNode } from "../../../../tree/nodes/sets/discreteSetNode.js";
+// import { IntervalNode } from "../../../../tree/nodes/sets/intervalNode.js";
+// import { random } from "../../../../utils/alea/random.js";
+export {};
+// // résoudre sin(x) = k sur ]a; a+2pi] avec a  = kpi
+// type Identifiers = {
+//   sinIds: NodeIdentifiers;
+//   multipleOfPiToAdd: number;
 // };
-// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
-//   return "";
+// const getPropositions: QCMGenerator<Identifiers> = (n, { answer }) => {
+//   const propositions: Proposition[] = [];
+//   addValidProp(propositions, answer);
+//   propWhile(propositions, n, () => {
+//     throw Error("QCM not implemented");
+//   });
+//   return shuffleProps(propositions, n);
+// };
+// const getAnswer: GetAnswer<Identifiers> = (identifiers) => {
+//   const { multipleOfPiToAdd, sinIds } = identifiers;
+//   /**
+//    * Si l'intervalle est centré autour d'un multiple de 2pi (coeff impair) (genre ]3pi, 5pi]) on ajoute (coeff+1)/2 tours
+//    * Sinon (coeff pair) (genre ]2pi, 4pipi]) , on chope la value de ]0, 2pi] et on ajoute coeff/2 tours
+//    */
+//   const turnsToAdd = Math.abs(coeff % 2) === 1 ? (coeff + 1) / 2 : coeff / 2;
+//   const sin = mainTrigoValues
+//     .find((v) => v.degree === identifiers.degree)!
+//     .sin.evaluate({});
+//   const values = (
+//     Math.abs(coeff % 2) === 1 ? mainTrigoValues : trigoValuesOnZeroTwoPIOF
+//   ).filter((v) => v.sin.evaluate({}) === sin)!;
+//   if (values.length === 1) {
+//     const value = values[0];
+//     const newValue = new AddNode(
+//       value.angle,
+//       new MultiplyNode((turnsToAdd * 2).toTree(), PiNode),
+//     ).simplify();
+//     return (
+//       new EquationSolutionNode(new DiscreteSetNode([newValue])).toTex() +
+//       ` turns ${turnsToAdd}, value : ${value.angle.toTex()}`
+//     );
+//   } else {
+//     const newValues = values.map((v) => {
+//       return new AddNode(
+//         v.angle,
+//         new MultiplyNode((turnsToAdd * 2).toTree(), PiNode),
+//       ).simplify();
+//     });
+//     return (
+//       new EquationSolutionNode(
+//         new DiscreteSetNode(
+//           newValues.sort((a, b) => a.evaluate({}) - b.evaluate({})),
+//         ),
+//       ).toTex() +
+//       ` turns ${turnsToAdd}, values: ${values.map((v) => v.angle.toTex())}`
+//     );
+//   }
+// };
+// const getInstruction: GetInstruction<Identifiers> = ({
+//   sinIds,
+//   multipleOfPiToAdd,
+// }) => {
+//   const sinValue = reifyAlgebraic(sinIds);
+//   const leftBound = add(
+//     opposite(PiNode),
+//     multiply(2 * multipleOfPiToAdd, PiNode),
+//   ).simplify();
+//   const rightBound = add(
+//     PiNode,
+//     multiply(2 * multipleOfPiToAdd, PiNode),
+//   ).simplify();
+//   const interval = new IntervalNode(leftBound, rightBound, ClosureType.OF);
+//   return `Résoudre sur $${interval.toTex()}$ l'équation :
+// $$
+// ${sin("x").toTex()}=${sinValue.toTex()}
+// $$`;
+// };
+// // const getHint: GetHint<Identifiers> = (identifiers) => {
+// //   return "";
+// // };
+// // const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
+// //   return "";
+// // };
+// const getKeys: GetKeys<Identifiers> = () => {
+//   return ["pi"];
+// };
+// const isAnswerValid: VEA<Identifiers> = () => {
+//   throw Error("VEA not implemented");
+// };
+// const getEquationSinOnRandomIntervalQuestion: QuestionGenerator<
+//   Identifiers
+// > = () => {
+//   const value = random(mainTrigoValues);
+//   const multipleOfPiToAdd = randint(-3, 4, [0]);
+//   const identifiers: Identifiers = {
+//     sinIds: value.sin.toIdentifiers(),
+//     multipleOfPiToAdd,
+//   };
+//   return getQuestionFromIdentifiers(identifiers);
+// };
+// const getQuestionFromIdentifiers: GetQuestionFromIdentifiers<Identifiers> = (
+//   identifiers,
+// ) => {
+//   const question: Question<Identifiers> = {
+//     answer: getAnswer(identifiers),
+//     instruction: getInstruction(identifiers),
+//     keys: getKeys(identifiers),
+//     answerFormat: "tex",
+//     identifiers,
+//     // hint: getHint(identifiers),
+//     // correction: getCorrection(identifiers),
+//   };
+//   return question;
+// };
+// export const equationSinOnRandomInterval: Exercise<Identifiers> = {
+//   id: "equationSinOnRandomInterval",
+//   connector: "\\iff",
+//   label:
+//     "Résoudre une équation du type $\\sin\\left(x\\right)=k$ sur un intervalle donné",
+//   isSingleStep: true,
+//   generator: (nb: number) =>
+//     getDistinctQuestions(getEquationSinOnRandomIntervalQuestion, nb),
+//   qcmTimer: 60,
+//   freeTimer: 60,
+//   getPropositions,
+//   isAnswerValid,
+//   subject: "Mathématiques",
+//   getQuestionFromIdentifiers,
 // };
-const getKeys = () => {
-    return ["pi"];
-};
-const isAnswerValid = () => {
-    throw Error("VEA not implemented");
-};
-const getEquationSinOnRandomIntervalQuestion = () => {
-    const value = random(mainPositiveTrigovalues);
-    const degree = value.degree;
-    const leftBoundPiMultiple = randint(-3, 4);
-    const identifiers = { degree, leftBoundPiMultiple };
-    return getQuestionFromIdentifiers(identifiers);
-};
-const getQuestionFromIdentifiers = (identifiers) => {
-    const question = {
-        answer: getAnswer(identifiers),
-        instruction: getInstruction(identifiers),
-        keys: getKeys(identifiers),
-        answerFormat: "tex",
-        identifiers,
-        // hint: getHint(identifiers),
-        // correction: getCorrection(identifiers),
-    };
-    return question;
-};
-export const equationSinOnRandomInterval = {
-    id: "equationSinOnRandomInterval",
-    connector: "\\iff",
-    label: "Résoudre une équation du type $\\sin\\left(x\\right)=k$ sur un intervalle donné",
-    isSingleStep: true,
-    generator: (nb) => getDistinctQuestions(getEquationSinOnRandomIntervalQuestion, nb),
-    qcmTimer: 60,
-    freeTimer: 60,
-    getPropositions,
-    isAnswerValid,
-    subject: "Mathématiques",
-    getQuestionFromIdentifiers,
-};

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

@@ -3,4 +3,7 @@ export * from "./basicEquationSin.js";
 export * from "./basicTrigoSystemEquation.js";
 export * from "./equationCosOnRandomInterval.js";
 export * from "./trigoAssociateAngle.js";
+export * from "./cosInequationMainInterval.js";
+export * from "./sinInequationMainInterval.js";
+export * from "./readPeriodicityOnFunctionGraph.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/functions/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kCAAkC,CAAC;AAEjD,cAAc,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/functions/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kCAAkC,CAAC;AAEjD,cAAc,0BAA0B,CAAC;AACzC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qCAAqC,CAAC"}

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

@@ -4,3 +4,6 @@ export * from "./basicTrigoSystemEquation.js";
 export * from "./equationCosOnRandomInterval.js";
 // export * from "./equationSinOnRandomInterval.js";
 export * from "./trigoAssociateAngle.js";
+export * from "./cosInequationMainInterval.js";
+export * from "./sinInequationMainInterval.js";
+export * from "./readPeriodicityOnFunctionGraph.js";

package/lib/exercises/math/trigonometry/functions/readPeriodicityOnFunctionGraph.d.ts

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    axisStep?: NodeIdentifiers;
+    isCos: boolean;
+    aIds: NodeIdentifiers;
+    bIds: NodeIdentifiers;
+    cIds: NodeIdentifiers;
+};
+export declare const readPeriodicityOnFunctionGraph: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=readPeriodicityOnFunctionGraph.d.ts.map

package/lib/exercises/math/trigonometry/functions/readPeriodicityOnFunctionGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readPeriodicityOnFunctionGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/functions/readPeriodicityOnFunctionGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAU7C,KAAK,WAAW,GAAG;IACjB,QAAQ,CAAC,EAAE,eAAe,CAAC;IAE3B,KAAK,EAAE,OAAO,CAAC;IACf,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,eAAe,CAAC;CACvB,CAAC;AA+IF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAuBhE,CAAC"}