math-exercises 2.2.32 → 2.2.34

package/lib/exercises/math/trigonometry/equationCosOnRandomInterval.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.equationCosOnRandomInterval = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const remarkableValues_1 = require("../../../math/trigonometry/remarkableValues");
+const randint_1 = require("../../../math/utils/random/randint");
+const equationSolutionNode_1 = require("../../../tree/nodes/equations/equationSolutionNode");
+const cosNode_1 = require("../../../tree/nodes/functions/cosNode");
+const piNode_1 = require("../../../tree/nodes/numbers/piNode");
+const addNode_1 = require("../../../tree/nodes/operators/addNode");
+const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
+const closure_1 = require("../../../tree/nodes/sets/closure");
+const discreteSetNode_1 = require("../../../tree/nodes/sets/discreteSetNode");
+const intervalNode_1 = require("../../../tree/nodes/sets/intervalNode");
+const random_1 = require("../../../utils/alea/random");
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        throw Error("QCM not implemented");
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswerNode = (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 cos = remarkableValues_1.mainTrigoValues
+        .find((v) => v.degree === identifiers.degree)
+        .cos.evaluate({});
+    const values = (Math.abs(coeff % 2) === 1 ? remarkableValues_1.mainTrigoValues : remarkableValues_1.trigoValuesOnZeroTwoPIOF).filter((v) => v.cos.evaluate({}) === cos);
+    if (values.length === 1) {
+        const value = values[0];
+        const newValue = new addNode_1.AddNode(value.angle, new multiplyNode_1.MultiplyNode((turnsToAdd * 2).toTree(), piNode_1.PiNode)).simplify();
+        return new equationSolutionNode_1.EquationSolutionNode(new discreteSetNode_1.DiscreteSetNode([newValue]));
+    }
+    else {
+        const newValues = values.map((v) => {
+            return new addNode_1.AddNode(v.angle, new multiplyNode_1.MultiplyNode((turnsToAdd * 2).toTree(), piNode_1.PiNode)).simplify();
+        });
+        return new equationSolutionNode_1.EquationSolutionNode(new discreteSetNode_1.DiscreteSetNode(newValues.sort((a, b) => a.evaluate({}) - b.evaluate({}))));
+    }
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getInstruction = ({ degree, leftBoundPiMultiple, }) => {
+    const value = remarkableValues_1.mainPositiveTrigovalues.find((v) => v.degree === degree);
+    const leftBound = new multiplyNode_1.MultiplyNode(leftBoundPiMultiple.toTree(), piNode_1.PiNode).simplify();
+    const rightBound = new multiplyNode_1.MultiplyNode((leftBoundPiMultiple + 2).toTree(), piNode_1.PiNode).simplify();
+    const interval = new intervalNode_1.IntervalNode(leftBound, rightBound, closure_1.ClosureType.OF);
+    return `Résoudre sur $${interval.toTex()}$ l'équation : 
+  
+$$
+${new cosNode_1.CosNode("x".toTree()).toTex()}=${value.cos.toTex()}
+$$`;
+};
+const getHint = (identifiers) => {
+    return "";
+};
+const getCorrection = (identifiers) => {
+    return "";
+};
+const getKeys = (identifiers) => {
+    return ["pi"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    throw Error("VEA not implemented");
+};
+const getEquationCosOnRandomIntervalQuestion = () => {
+    const value = (0, random_1.random)(remarkableValues_1.mainPositiveTrigovalues);
+    const degree = value.degree;
+    const leftBoundPiMultiple = (0, randint_1.randint)(-3, 4);
+    const identifiers = { degree, leftBoundPiMultiple };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.equationCosOnRandomInterval = {
+    id: "equationCosOnRandomInterval",
+    connector: "\\iff",
+    label: "Résoudre une équation du type $\\cos\\left(x\\right)=k$ sur un intervalle donné",
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getEquationCosOnRandomIntervalQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getAnswer,
+};

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

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

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

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

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

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.equationSinOnRandomInterval = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const remarkableValues_1 = require("../../../math/trigonometry/remarkableValues");
+const randint_1 = require("../../../math/utils/random/randint");
+const equationSolutionNode_1 = require("../../../tree/nodes/equations/equationSolutionNode");
+const sinNode_1 = require("../../../tree/nodes/functions/sinNode");
+const piNode_1 = require("../../../tree/nodes/numbers/piNode");
+const addNode_1 = require("../../../tree/nodes/operators/addNode");
+const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
+const closure_1 = require("../../../tree/nodes/sets/closure");
+const discreteSetNode_1 = require("../../../tree/nodes/sets/discreteSetNode");
+const intervalNode_1 = require("../../../tree/nodes/sets/intervalNode");
+const random_1 = require("../../../utils/alea/random");
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        throw Error("QCM not implemented");
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswerNode = (identifiers) => { };
+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 = remarkableValues_1.mainTrigoValues
+        .find((v) => v.degree === identifiers.degree)
+        .sin.evaluate({});
+    const values = (Math.abs(coeff % 2) === 1 ? remarkableValues_1.mainTrigoValues : remarkableValues_1.trigoValuesOnZeroTwoPIOF).filter((v) => v.sin.evaluate({}) === sin);
+    if (values.length === 1) {
+        const value = values[0];
+        const newValue = new addNode_1.AddNode(value.angle, new multiplyNode_1.MultiplyNode((turnsToAdd * 2).toTree(), piNode_1.PiNode)).simplify();
+        return (new equationSolutionNode_1.EquationSolutionNode(new discreteSetNode_1.DiscreteSetNode([newValue])).toTex() +
+            ` turns ${turnsToAdd}, value : ${value.angle.toTex()}`);
+    }
+    else {
+        const newValues = values.map((v) => {
+            return new addNode_1.AddNode(v.angle, new multiplyNode_1.MultiplyNode((turnsToAdd * 2).toTree(), piNode_1.PiNode)).simplify();
+        });
+        return (new equationSolutionNode_1.EquationSolutionNode(new discreteSetNode_1.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 = remarkableValues_1.mainPositiveTrigovalues.find((v) => v.degree === degree);
+    const leftBound = new multiplyNode_1.MultiplyNode(leftBoundPiMultiple.toTree(), piNode_1.PiNode).simplify();
+    const rightBound = new multiplyNode_1.MultiplyNode((leftBoundPiMultiple + 2).toTree(), piNode_1.PiNode).simplify();
+    const interval = new intervalNode_1.IntervalNode(leftBound, rightBound, closure_1.ClosureType.OF);
+    return `Résoudre sur $${interval.toTex()}$ l'équation : 
+    
+  $$
+  ${new sinNode_1.SinNode("x".toTree()).toTex()}=${value.sin.toTex()}
+  $$`;
+};
+const getHint = (identifiers) => {
+    return "";
+};
+const getCorrection = (identifiers) => {
+    return "";
+};
+const getKeys = (identifiers) => {
+    return ["pi"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    throw Error("VEA not implemented");
+};
+const getEquationSinOnRandomIntervalQuestion = () => {
+    const value = (0, random_1.random)(remarkableValues_1.mainPositiveTrigovalues);
+    const degree = value.degree;
+    const leftBoundPiMultiple = (0, randint_1.randint)(-3, 4);
+    const identifiers = { degree, leftBoundPiMultiple };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.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) => (0, getDistinctQuestions_1.getDistinctQuestions)(getEquationSinOnRandomIntervalQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getAnswer,
+};

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

@@ -28,3 +28,4 @@ __exportStar(require("./basicTrigoSystemEquation"), exports);
 __exportStar(require("./mainAngleMeasure"), exports);
 __exportStar(require("./degreeToRadians"), exports);
 __exportStar(require("./arcLength"), exports);
+// export * from "./equationCosOnRandomInterval";

package/lib/index.d.ts

@@ -564,14 +564,20 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     G2x: number;
     G2y: number;
     G1y: number;
+    xValues: number[];
+    yValues: number[];
 }> | import("./exercises/exercise").Exercise<{
     rSquared: number;
+    xValues: number[];
+    yValues: number[];
 }> | import("./exercises/exercise").Exercise<{
     G1x: number;
     G2x: number;
     G2y: number;
     G1y: number;
     rSquared: number;
+    xValues: number[];
+    yValues: number[];
 }> | import("./exercises/exercise").Exercise<{
     trinomial: number[];
     leftbound: number;
@@ -1087,7 +1093,10 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
 }> | import("./exercises/exercise").Exercise<{
     total: number;
     lefties: number;
-}> | import("./exercises/exercise").Exercise<{}> | import("./exercises/exercise").Exercise<{
+}> | import("./exercises/exercise").Exercise<{
+    xValues: number[];
+    yValues: number[];
+}> | import("./exercises/exercise").Exercise<{
     evolution: number;
 }> | import("./exercises/exercise").Exercise<{
     TVA: number;
@@ -1198,6 +1207,7 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     rand: number;
 }> | import("./exercises/exercise").Exercise<{
     randomValues: number[];
+    randomEffectives: number[];
 }> | import("./exercises/exercise").Exercise<{
     sortedValues: number[];
 }> | import("./exercises/exercise").Exercise<{

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,yBAAyB,CAAC;AAEjC,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,yBAAyB,CAAC;AAEjC,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}

package/lib/math/trigonometry/remarkableValues.d.ts

@@ -1,4 +1,6 @@
 import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
+import { NumberNode } from "../../tree/nodes/numbers/numberNode";
+import { MultiplyNode } from "../../tree/nodes/operators/multiplyNode";
 export interface RemarkableValue {
     angle: AlgebraicNode;
     cos: AlgebraicNode;
@@ -11,4 +13,12 @@ export declare const negativeMainTrigovalues: RemarkableValue[];
 export declare const remarkableTrigoValues: RemarkableValue[];
 export declare const mainTrigoValues: RemarkableValue[];
 export declare const mainPositiveTrigovalues: RemarkableValue[];
+export declare const trigoValuesOnZeroTwoPIOF: (RemarkableValue | {
+    angle: MultiplyNode;
+    degree: number;
+    cos: NumberNode;
+    sin: NumberNode;
+    tan: NumberNode;
+    point: string;
+})[];
 //# sourceMappingURL=remarkableValues.d.ts.map

package/lib/math/trigonometry/remarkableValues.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"remarkableValues.d.ts","sourceRoot":"","sources":["../../../src/math/trigonometry/remarkableValues.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAQ/D,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,aAAa,CAAC;IACrB,GAAG,EAAE,aAAa,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,aAAa,CAAC;IACnB,GAAG,EAAE,aAAa,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,eAAO,MAAM,uBAAuB,EAAE,eAAe,EAoGpD,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,eAAe,EA2LlD,CAAC;AAEF,eAAO,MAAM,eAAe,mBAG3B,CAAC;AAEF,eAAO,MAAM,uBAAuB,mBAAoC,CAAC"}
+{"version":3,"file":"remarkableValues.d.ts","sourceRoot":"","sources":["../../../src/math/trigonometry/remarkableValues.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAG/D,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAGjE,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AAEvE,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,aAAa,CAAC;IACrB,GAAG,EAAE,aAAa,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,aAAa,CAAC;IACnB,GAAG,EAAE,aAAa,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,eAAO,MAAM,uBAAuB,EAAE,eAAe,EAoGpD,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,eAAe,EA2LlD,CAAC;AAEF,eAAO,MAAM,eAAe,mBAG3B,CAAC;AAEF,eAAO,MAAM,uBAAuB,mBAAoC,CAAC;AAEzE,eAAO,MAAM,wBAAwB;;;;;;;IAUpC,CAAC"}

package/lib/math/trigonometry/remarkableValues.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mainPositiveTrigovalues = exports.mainTrigoValues = exports.remarkableTrigoValues = exports.negativeMainTrigovalues = void 0;
+exports.trigoValuesOnZeroTwoPIOF = exports.mainPositiveTrigovalues = exports.mainTrigoValues = exports.remarkableTrigoValues = exports.negativeMainTrigovalues = void 0;
 const oppositeNode_1 = require("../../tree/nodes/functions/oppositeNode");
 const sqrtNode_1 = require("../../tree/nodes/functions/sqrtNode");
 const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
@@ -208,3 +208,14 @@ exports.mainTrigoValues = [
     ...exports.remarkableTrigoValues.slice(1).slice(0, 8),
 ];
 exports.mainPositiveTrigovalues = exports.remarkableTrigoValues.slice(0, 9);
+exports.trigoValuesOnZeroTwoPIOF = [
+    ...exports.remarkableTrigoValues.slice(1),
+    {
+        angle: new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(2), piNode_1.PiNode),
+        degree: 0,
+        cos: new numberNode_1.NumberNode(1),
+        sin: new numberNode_1.NumberNode(0),
+        tan: new numberNode_1.NumberNode(0),
+        point: "I",
+    },
+];

package/lib/utils/latex/dollarize.d.ts

@@ -0,0 +1,2 @@
+export declare const dollarize: (text: string | number) => string;
+//# sourceMappingURL=dollarize.d.ts.map

package/lib/utils/latex/dollarize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dollarize.d.ts","sourceRoot":"","sources":["../../../src/utils/latex/dollarize.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS,SAAU,MAAM,GAAG,MAAM,WAE9C,CAAC"}

package/lib/utils/latex/dollarize.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dollarize = void 0;
+const dollarize = (text) => {
+    return `$${text}$`;
+};
+exports.dollarize = dollarize;

package/lib/utils/markdown/mdTable.d.ts

@@ -0,0 +1,2 @@
+export declare const mdTable: (rows: (string | number)[][]) => string;
+//# sourceMappingURL=mdTable.d.ts.map

package/lib/utils/markdown/mdTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mdTable.d.ts","sourceRoot":"","sources":["../../../src/utils/markdown/mdTable.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,OAAO,SAAU,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,EAAE,WASlD,CAAC"}

package/lib/utils/markdown/mdTable.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mdTable = void 0;
+const rowBuilder = (row) => {
+    return "|" + row.join("|") + "|";
+};
+const mdTable = (rows) => {
+    const width = rows[0].length;
+    return `
+<!-- table -->
+${rowBuilder(rows[0])}
+${rowBuilder(new Array(width).fill("-"))}
+${rows.slice(1).map(rowBuilder).join("\n")}
+<!-- !table -->
+`;
+};
+exports.mdTable = mdTable;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "math-exercises",
-  "version": "2.2.32",
+  "version": "2.2.34",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [