math-exercises 2.0.7 → 2.0.10

package/lib/exercises/trigonometry/associatePoint.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.associatePoint = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const remarkableValue_1 = require("../../math/trigonometry/remarkableValue");
+const random_1 = require("../../utils/random");
+const points = [
+    "I",
+    "A",
+    "B",
+    "C",
+    "J",
+    "D",
+    "E",
+    "F",
+    "G",
+    "H",
+    "K",
+    "L",
+    "M",
+    "N",
+    "P",
+    "Q",
+];
+const getAssociatePointQuestion = () => {
+    const remarkableValue = remarkableValue_1.RemarkableValueConstructor.simplifiable();
+    const answer = remarkableValue.point;
+    const question = {
+        answer,
+        instruction: `À quel point du cercle trigonométrique ci-dessous le réel $${remarkableValue.angle.toTex()}$ est-il associé ?
+    ![](https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/mathliveV2/activities/quizzes/generator/piCircle.png)
+    `,
+        keys: points,
+        answerFormat: "tex",
+        identifiers: { angleValue: remarkableValue.mainAngle.evaluate({}) },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, angleValue }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        const rand = (0, random_1.random)(points);
+        (0, exercise_1.tryToAddWrongProp)(propositions, rand);
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return answer === ans;
+};
+exports.associatePoint = {
+    id: "associatePoint",
+    connector: "=",
+    label: "Associer un réel à un point du cercle trigonométrique",
+    levels: ["1reSpé", "TermSpé"],
+    isSingleStep: true,
+    sections: ["Trigonométrie"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getAssociatePointQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

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

@@ -3,4 +3,5 @@ export * from "./remarkableValues";
 export * from "./trigonometry";
 export * from "./trigonometryAngleCalcul";
 export * from "./trigonometrySideCalcul";
+export * from "./associatePoint";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/trigonometry/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/trigonometry/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,kBAAkB,CAAC"}

package/lib/exercises/trigonometry/index.js

@@ -19,3 +19,4 @@ __exportStar(require("./remarkableValues"), exports);
 __exportStar(require("./trigonometry"), exports);
 __exportStar(require("./trigonometryAngleCalcul"), exports);
 __exportStar(require("./trigonometrySideCalcul"), exports);
+__exportStar(require("./associatePoint"), exports);

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

@@ -1,6 +1,6 @@
 import { MathExercise } from "../exercise";
 type Identifiers = {
-    valueIndex: number;
+    mainValue: number;
     isCos: boolean;
 };
 export declare const remarkableValuesExercise: MathExercise<Identifiers>;

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

@@ -1 +1 @@
-{"version":3,"file":"remarkableValues.d.ts","sourceRoot":"","sources":["../../../src/exercises/trigonometry/remarkableValues.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,YAAY,EAQb,MAAM,aAAa,CAAC;AAerB,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAwCF,eAAO,MAAM,wBAAwB,EAAE,YAAY,CAAC,WAAW,CAY9D,CAAC"}
+{"version":3,"file":"remarkableValues.d.ts","sourceRoot":"","sources":["../../../src/exercises/trigonometry/remarkableValues.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,YAAY,EAQb,MAAM,aAAa,CAAC;AAerB,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAyCF,eAAO,MAAM,wBAAwB,EAAE,YAAY,CAAC,WAAW,CAY9D,CAAC"}

package/lib/exercises/trigonometry/remarkableValues.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.remarkableValuesExercise = void 0;
 const remarkableValue_1 = require("../../math/trigonometry/remarkableValue");
 const remarkableValues_1 = require("../../math/trigonometry/remarkableValues");
+const cosNode_1 = require("../../tree/nodes/functions/cosNode");
+const sinNode_1 = require("../../tree/nodes/functions/sinNode");
 const coinFlip_1 = require("../../utils/coinFlip");
 const random_1 = require("../../utils/random");
 const shuffle_1 = require("../../utils/shuffle");
@@ -22,21 +24,21 @@ const values = [
 const getRemarkableValues = () => {
     const isCos = (0, coinFlip_1.coinFlip)();
     const remarkableValue = remarkableValue_1.RemarkableValueConstructor.simplifiable();
-    const valueIndex = remarkableValue.index;
+    const mainValue = remarkableValue.mainAngle.evaluate({});
+    // const valueIndex = remarkableValue.index;
     const answer = isCos
         ? remarkableValue.cos.toTex()
         : remarkableValue.sin.toTex();
-    (0, shuffle_1.shuffle)(values);
     const statement = isCos
-        ? `\\cos\\left(${remarkableValue.angle.toTex()}\\right)`
-        : `\\sin\\left(${remarkableValue.angle.toTex()}\\right)`;
+        ? new cosNode_1.CosNode(remarkableValue.angle).toTex()
+        : new sinNode_1.SinNode(remarkableValue.angle).toTex();
     const question = {
         instruction: `Donner la valeur exacte de : $${statement}$`,
         startStatement: statement,
         answer: answer,
         keys: ["pi", "cos", "sin"],
         answerFormat: "tex",
-        identifiers: { isCos, valueIndex },
+        identifiers: { isCos, mainValue },
     };
     return question;
 };
@@ -49,8 +51,8 @@ const getPropositions = (n, { answer }) => {
     }
     return (0, shuffle_1.shuffle)(propositions);
 };
-const isAnswerValid = (ans, { valueIndex, isCos }) => {
-    const remarkableValue = remarkableValues_1.remarkableTrigoValues[valueIndex];
+const isAnswerValid = (ans, { mainValue, isCos }) => {
+    const remarkableValue = remarkableValues_1.remarkableTrigoValues.find((point) => point.angle.evaluate({}) === mainValue);
     const answer = isCos ? remarkableValue.cos : remarkableValue.sin;
     const texs = answer.toAllValidTexs({ allowFractionToDecimal: true });
     return texs.includes(ans);

package/lib/index.d.ts

@@ -1,9 +1,9 @@
 declare const mathExercises: (import("./exercises/exercise").MathExercise<{
-    numbers: number[];
+    chosenNumbers: number[];
 }> | import("./exercises/exercise").MathExercise<{
     numbers: number[];
 }> | import("./exercises/exercise").MathExercise<{
-    chosenNumbers: number[];
+    numbers: number[];
 }> | import("./exercises/exercise").MathExercise<{
     dividend: number;
     divisor: number;
@@ -35,6 +35,10 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
 }> | import("./exercises/exercise").MathExercise<{
     num: number;
     denum: number;
+}> | import("./exercises/exercise").MathExercise<{
+    num: number;
+    denum: number;
+    leadingPart: number;
 }> | import("./exercises/exercise").MathExercise<{
     numbers: number[];
 }> | import("./exercises/exercise").MathExercise<{
@@ -208,6 +212,8 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     re: number;
     im: number;
     isRe: boolean;
+}> | import("./exercises/exercise").MathExercise<{
+    arg: number;
 }> | import("./exercises/exercise").MathExercise<{
     randomUnitIndex: number;
     randomUnitInstructionIndex: number;
@@ -417,6 +423,17 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     b: number;
 }> | import("./exercises/exercise").MathExercise<{
     tenthPower: number;
+}> | import("./exercises/exercise").MathExercise<{
+    a: number;
+    powered: number;
+    c: number;
+    k: number;
+    isLog10: boolean;
+}> | import("./exercises/exercise").MathExercise<{
+    nb: number;
+    powers: number[];
+    signs: number[];
+    isLog10: boolean;
 }> | import("./exercises/exercise").MathExercise<{
     coin: boolean;
     radius: number;
@@ -691,7 +708,7 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     valueIndex: number;
     isCos: boolean;
 }> | import("./exercises/exercise").MathExercise<{
-    valueIndex: number;
+    mainValue: number;
     isCos: boolean;
 }> | import("./exercises/exercise").MathExercise<{
     sideA: string;
@@ -708,6 +725,8 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     randAngle: number;
     randSide: number;
     randSideQuestion: number;
+}> | import("./exercises/exercise").MathExercise<{
+    angleValue: number;
 }>)[];
 export { mathExercises };
 //# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAqCA,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA2B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAqCA,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA2B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/lib/math/numbers/decimals/decimal.d.ts

@@ -1,6 +1,8 @@
 import { NumberNode } from "../../../tree/nodes/numbers/numberNode";
 import { MultiplyNode } from "../../../tree/nodes/operators/multiplyNode";
+import { Integer } from "../integer/integer";
 import { Nombre, NumberType } from "../nombre";
+import { Rational } from "../rationals/rational";
 export declare abstract class DecimalConstructor {
     static randomFracPart(precision: number, leadingZeros?: number): string;
     static random(min: number, max: number, precision?: number): Decimal;
@@ -24,6 +26,7 @@ export declare class Decimal implements Nombre {
     multiplyByPowerOfTen(power: number): Decimal;
     toScientificPart(): NumberNode;
     toScientificNotation(): NumberNode | MultiplyNode;
+    toRational(): Rational | Integer;
     toTree(): NumberNode;
 }
 //# sourceMappingURL=decimal.d.ts.map

package/lib/math/numbers/decimals/decimal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decimal.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/decimals/decimal.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AACjE,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AAGvE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE/C,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,GAAE,MAAU,GAAG,MAAM;IAW1E,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO;IAMpE,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO;IAI/D,MAAM,CAAC,gBAAgB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO;CAMrD;AAED,qBAAa,OAAQ,YAAW,MAAM;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,aAAsB;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;gBACR,KAAK,EAAE,MAAM;IASzB;;;;OAIG;IACH,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAsEhC,oBAAoB,CAAC,KAAK,EAAE,MAAM;IA2BlC,gBAAgB;IAgBhB,oBAAoB;IAmBpB,MAAM;CAGP"}
+{"version":3,"file":"decimal.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/decimals/decimal.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AACjE,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AAEvE,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAC7C,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEjD,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,GAAE,MAAU,GAAG,MAAM;IAW1E,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO;IAMpE,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO;IAK/D,MAAM,CAAC,gBAAgB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO;CAMrD;AAED,qBAAa,OAAQ,YAAW,MAAM;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,aAAsB;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;gBACR,KAAK,EAAE,MAAM;IASzB;;;;OAIG;IACH,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAsEhC,oBAAoB,CAAC,KAAK,EAAE,MAAM;IA4BlC,gBAAgB;IAgBhB,oBAAoB;IAmBpB,UAAU;IAMV,MAAM;CAGP"}

package/lib/math/numbers/decimals/decimal.js

@@ -7,6 +7,7 @@ const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
 const powerNode_1 = require("../../../tree/nodes/operators/powerNode");
 const integer_1 = require("../integer/integer");
 const nombre_1 = require("../nombre");
+const rational_1 = require("../rationals/rational");
 class DecimalConstructor {
     static randomFracPart(precision, leadingZeros = 0) {
         let decimals = "";
@@ -27,6 +28,8 @@ class DecimalConstructor {
         return DecimalConstructor.fromParts(int, decimals);
     }
     static fromParts(intPart, decimalPart) {
+        if (decimalPart.length === 0)
+            return new Decimal(Number("" + intPart));
         return new Decimal(Number("" + intPart + "." + decimalPart));
     }
     //returns X.YYYY where X € [0, 9] and first Y is not zero if X is zero
@@ -127,6 +130,8 @@ class Decimal {
         return DecimalConstructor.fromParts(newIntPart, newFracPart);
     }
     multiplyByPowerOfTen(power) {
+        if (power === 0)
+            return this;
         let newIntPart = "", newFracPart = "";
         if (power > -1) {
             newIntPart = this.intPart + "";
@@ -180,6 +185,9 @@ class Decimal {
             return new multiplyNode_1.MultiplyNode(decNode, new numberNode_1.NumberNode(10));
         return new multiplyNode_1.MultiplyNode(decNode, new powerNode_1.PowerNode(new numberNode_1.NumberNode(10), new numberNode_1.NumberNode(power)));
     }
+    toRational() {
+        return new rational_1.Rational(this.multiplyByPowerOfTen(this.precision).value, 10 ** this.precision).simplify();
+    }
     toTree() {
         return new numberNode_1.NumberNode(this.value);
     }

package/lib/math/numbers/integer/integer.d.ts

@@ -16,6 +16,6 @@ export declare class Integer implements Nombre {
     divide(nb: Nombre): Nombre;
     multiply(nb: Nombre): Rational | Integer;
     opposite(): Integer;
-    add(nb: Nombre): Nombre | Integer;
+    add(nb: Nombre): Integer | Nombre;
 }
 //# sourceMappingURL=integer.d.ts.map

package/lib/math/numbers/nombre.d.ts

@@ -14,6 +14,6 @@ export interface Nombre {
     toTree: (opts?: NodeOptions) => AlgebraicNode;
 }
 export declare abstract class NombreConstructor {
-    static random(): import("./decimals/decimal").Decimal | Integer | import("./rationals/rational").Rational | import("./reals/real").Real;
+    static random(): import("./rationals/rational").Rational | Integer | import("./decimals/decimal").Decimal | import("./reals/real").Real;
 }
 //# sourceMappingURL=nombre.d.ts.map

package/lib/math/numbers/nombre.js

@@ -17,7 +17,7 @@ var NumberType;
 class NombreConstructor {
     static random() {
         const type = (0, random_1.random)([
-            NumberType.Decimal,
+            NumberType.Integer,
             NumberType.Decimal,
             NumberType.Rational,
             NumberType.Real,

package/lib/math/numbers/reals/extendedRingElement.d.ts

@@ -1,4 +1,5 @@
 import { NumberNode } from '../../../tree/nodes/numbers/numberNode';
+import { MultiplyNode } from '../../../tree/nodes/operators/multiplyNode';
 import { SubstractNode } from '../../../tree/nodes/operators/substractNode';
 import { Nombre } from '../nombre';
 /**
@@ -10,6 +11,6 @@ export declare class ExtendedRingElement {
     b: number;
     algebraicElement: Nombre;
     constructor(a: number, b: number, algebraicElement: Nombre);
-    toTree(): import("../../../tree/nodes/algebraicNode").AlgebraicNode | NumberNode | SubstractNode;
+    toTree(): import("../../../tree/nodes/algebraicNode").AlgebraicNode | NumberNode | MultiplyNode | SubstractNode;
 }
 //# sourceMappingURL=extendedRingElement.d.ts.map

package/lib/math/numbers/reals/extendedRingElement.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extendedRingElement.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/reals/extendedRingElement.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAGjE,OAAO,EAAE,aAAa,EAAE,MAAM,0CAA0C,CAAC;AACzE,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAEnC;;;GAGG;AACH,qBAAa,mBAAmB;IAM9B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,gBAAgB,EAAE,MAAM,CAAC;gBACb,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM;IAM1D,MAAM;CAeP"}
+{"version":3,"file":"extendedRingElement.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/reals/extendedRingElement.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAEjE,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,EAAE,aAAa,EAAE,MAAM,0CAA0C,CAAC;AACzE,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAEnC;;;GAGG;AACH,qBAAa,mBAAmB;IAM9B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,gBAAgB,EAAE,MAAM,CAAC;gBACb,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM;IAM1D,MAAM;CAeP"}

package/lib/math/polynomials/rationalFrac.d.ts

@@ -7,6 +7,6 @@ export declare class RationalFrac {
     denum: Polynomial;
     constructor(num: Polynomial, denum: Polynomial);
     toTree(): FractionNode;
-    simplify(): Integer | Rational | RationalFrac;
+    simplify(): Rational | Integer | RationalFrac;
 }
 //# sourceMappingURL=rationalFrac.d.ts.map

package/lib/math/polynomials/trinom.d.ts

@@ -27,8 +27,8 @@ export declare class Trinom extends Polynomial {
     getAlphaNode(): NumberNode | FractionNode | OppositeNode;
     getBeta(): number;
     getBetaNode(): NumberNode | FractionNode | OppositeNode;
-    getFactorizedForm(): AlgebraicNode;
-    getCanonicalForm(): AddNode | MultiplyNode;
+    getFactorizedForm(): AlgebraicNode | MultiplyNode;
+    getCanonicalForm(): MultiplyNode | AddNode;
     getSommet(): Point;
 }
 //# sourceMappingURL=trinom.d.ts.map

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

@@ -1,16 +1,9 @@
-import { Node } from "../../tree/nodes/node";
-import { Integer } from "../numbers/integer/integer";
-import { Rational } from "../numbers/rationals/rational";
-export interface RemarkableValue {
-    angleValue: Integer | Rational;
-    angle: Node;
-    cos: Node;
-    sin: Node;
-}
+import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
+import { RemarkableValue } from "./remarkableValues";
 export declare abstract class RemarkableValueConstructor {
     static mainInterval: () => RemarkableValue;
     static simplifiable: () => RemarkableValue & {
-        index: number;
+        mainAngle: AlgebraicNode;
     };
 }
 //# sourceMappingURL=remarkableValue.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"remarkableValue.d.ts","sourceRoot":"","sources":["../../../src/math/trigonometry/remarkableValue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAM7C,OAAO,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAC;AAErD,OAAO,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AAKzD,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,OAAO,GAAG,QAAQ,CAAC;IAC/B,KAAK,EAAE,IAAI,CAAC;IACZ,GAAG,EAAE,IAAI,CAAC;IACV,GAAG,EAAE,IAAI,CAAC;CACX;AAED,8BAAsB,0BAA0B;IAC9C,MAAM,CAAC,YAAY,QAAO,eAAe,CAIvC;IAEF,MAAM,CAAC,YAAY;eAAkC,MAAM;MAwBzD;CACH"}
+{"version":3,"file":"remarkableValue.d.ts","sourceRoot":"","sources":["../../../src/math/trigonometry/remarkableValue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAa/D,OAAO,EAAE,eAAe,EAAyB,MAAM,oBAAoB,CAAC;AAE5E,8BAAsB,0BAA0B;IAC9C,MAAM,CAAC,YAAY,QAAO,eAAe,CAGvC;IACF,MAAM,CAAC,YAAY,QAAO,eAAe,GAAG;QAC1C,SAAS,EAAE,aAAa,CAAC;KAC1B,CAeC;CACH"}

package/lib/math/trigonometry/remarkableValue.js

@@ -3,12 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RemarkableValueConstructor = void 0;
 const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
 const piNode_1 = require("../../tree/nodes/numbers/piNode");
-const fractionNode_1 = require("../../tree/nodes/operators/fractionNode");
+const addNode_1 = require("../../tree/nodes/operators/addNode");
 const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
 const random_1 = require("../../utils/random");
-const integer_1 = require("../numbers/integer/integer");
-const nombre_1 = require("../numbers/nombre");
-const rational_1 = require("../numbers/rationals/rational");
 const randint_1 = require("../utils/random/randint");
 const remarkableValues_1 = require("./remarkableValues");
 class RemarkableValueConstructor {
@@ -17,24 +14,17 @@ exports.RemarkableValueConstructor = RemarkableValueConstructor;
 RemarkableValueConstructor.mainInterval = () => {
     const randValue = (0, random_1.random)(remarkableValues_1.remarkableTrigoValues);
     return randValue;
-    // return new RemarkableValue(randValue.angle, randValue.cos, randValue.sin);
 };
 RemarkableValueConstructor.simplifiable = () => {
     const index = (0, randint_1.randint)(0, remarkableValues_1.remarkableTrigoValues.length);
     const randValue = remarkableValues_1.remarkableTrigoValues[index];
-    const isInt = randValue.angleValue.type === nombre_1.NumberType.Integer;
     const toAdd = (0, randint_1.randint)(-3, 4) * 2;
-    const newRadian = isInt
-        ? new integer_1.Integer(randValue.angleValue.value + toAdd)
-        : new rational_1.Rational(randValue.angleValue.num, randValue.angleValue.denum).add(new integer_1.Integer(toAdd));
-    const newAngle = isInt
-        ? new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(newRadian.value), piNode_1.PiNode)
-        : new fractionNode_1.FractionNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(newRadian.num), piNode_1.PiNode), new numberNode_1.NumberNode(newRadian.denum));
+    const newRadian = new addNode_1.AddNode(randValue.angle, new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(toAdd), piNode_1.PiNode)).simplify();
     return {
-        angleValue: newRadian,
-        angle: newAngle,
+        mainAngle: randValue.angle,
+        angle: newRadian,
         cos: randValue.cos,
         sin: randValue.sin,
-        index,
+        point: randValue.point,
     };
 };

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

@@ -1,3 +1,9 @@
-import { RemarkableValue } from "./remarkableValue";
+import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
+export interface RemarkableValue {
+    angle: AlgebraicNode;
+    cos: AlgebraicNode;
+    sin: AlgebraicNode;
+    point: string;
+}
 export declare const remarkableTrigoValues: RemarkableValue[];
 //# 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":"AAQA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD,eAAO,MAAM,qBAAqB,EAAE,eAAe,EA+ElD,CAAC"}
+{"version":3,"file":"remarkableValues.d.ts","sourceRoot":"","sources":["../../../src/math/trigonometry/remarkableValues.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAW/D,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,aAAa,CAAC;IACrB,GAAG,EAAE,aAAa,CAAC;IACnB,GAAG,EAAE,aAAa,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACf;AACD,eAAO,MAAM,qBAAqB,EAAE,eAAe,EA2KlD,CAAC"}

package/lib/math/trigonometry/remarkableValues.js

@@ -7,61 +7,111 @@ const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
 const piNode_1 = require("../../tree/nodes/numbers/piNode");
 const fractionNode_1 = require("../../tree/nodes/operators/fractionNode");
 const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
-const integer_1 = require("../numbers/integer/integer");
-const rational_1 = require("../numbers/rationals/rational");
 exports.remarkableTrigoValues = [
     {
-        angleValue: new integer_1.Integer(0),
+        // angleValue: 0,
         angle: new numberNode_1.NumberNode(0),
         cos: new numberNode_1.NumberNode(1),
         sin: new numberNode_1.NumberNode(0),
+        point: "I",
     },
     {
-        angleValue: new rational_1.Rational(1, 6),
+        // angleValue: Math.PI / 6,
         angle: new fractionNode_1.FractionNode(piNode_1.PiNode, new numberNode_1.NumberNode(6)),
         cos: new fractionNode_1.FractionNode(new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(3)), new numberNode_1.NumberNode(2)),
         sin: new fractionNode_1.FractionNode(new numberNode_1.NumberNode(1), new numberNode_1.NumberNode(2)),
+        point: "A",
     },
     {
-        angleValue: new rational_1.Rational(1, 4),
+        // angleValue: Math.PI / 4,
         angle: new fractionNode_1.FractionNode(piNode_1.PiNode, new numberNode_1.NumberNode(4)),
         cos: new fractionNode_1.FractionNode(new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(2)), new numberNode_1.NumberNode(2)),
         sin: new fractionNode_1.FractionNode(new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(2)), new numberNode_1.NumberNode(2)),
+        point: "B",
     },
     {
-        angleValue: new rational_1.Rational(1, 3),
+        // angleValue: Math.PI / 3,
         angle: new fractionNode_1.FractionNode(piNode_1.PiNode, new numberNode_1.NumberNode(3)),
         cos: new fractionNode_1.FractionNode(new numberNode_1.NumberNode(1), new numberNode_1.NumberNode(2)),
         sin: new fractionNode_1.FractionNode(new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(3)), new numberNode_1.NumberNode(2)),
+        point: "C",
     },
     {
-        angleValue: new rational_1.Rational(1, 2),
+        // angleValue: Math.PI / 2,
         angle: new fractionNode_1.FractionNode(piNode_1.PiNode, new numberNode_1.NumberNode(2)),
         cos: new numberNode_1.NumberNode(0),
         sin: new numberNode_1.NumberNode(1),
+        point: "J",
     },
     {
-        angleValue: new rational_1.Rational(2, 3),
+        // angleValue: (Math.PI * 2) / 3,
         angle: new fractionNode_1.FractionNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(2), piNode_1.PiNode), new numberNode_1.NumberNode(3)),
         cos: new oppositeNode_1.OppositeNode(new fractionNode_1.FractionNode(new numberNode_1.NumberNode(1), new numberNode_1.NumberNode(2))),
         sin: new fractionNode_1.FractionNode(new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(3)), new numberNode_1.NumberNode(2)),
+        point: "D",
     },
     {
-        angleValue: new rational_1.Rational(3, 4),
+        // angleValue: (Math.PI * 3) / 4,
         angle: new fractionNode_1.FractionNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(3), piNode_1.PiNode), new numberNode_1.NumberNode(4)),
         cos: new oppositeNode_1.OppositeNode(new fractionNode_1.FractionNode(new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(2)), new numberNode_1.NumberNode(2))),
         sin: new fractionNode_1.FractionNode(new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(2)), new numberNode_1.NumberNode(2)),
+        point: "E",
     },
     {
-        angleValue: new rational_1.Rational(5, 6),
+        // angleValue: (Math.PI * 5) / 6,
         angle: new fractionNode_1.FractionNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(5), piNode_1.PiNode), new numberNode_1.NumberNode(6)),
-        cos: new oppositeNode_1.OppositeNode(new fractionNode_1.FractionNode(new numberNode_1.NumberNode(1), new numberNode_1.NumberNode(2))),
-        sin: new oppositeNode_1.OppositeNode(new fractionNode_1.FractionNode(new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(3)), new numberNode_1.NumberNode(2))),
+        cos: new oppositeNode_1.OppositeNode(new fractionNode_1.FractionNode(new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(3)), new numberNode_1.NumberNode(2))),
+        sin: new fractionNode_1.FractionNode(new numberNode_1.NumberNode(1), new numberNode_1.NumberNode(2)),
+        point: "F",
     },
     {
-        angleValue: new integer_1.Integer(1),
+        // angleValue: Math.PI,
+        //
         angle: piNode_1.PiNode,
         cos: new numberNode_1.NumberNode(-1),
         sin: new numberNode_1.NumberNode(0),
+        point: "G",
+    },
+    {
+        angle: new fractionNode_1.FractionNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(7), piNode_1.PiNode), new numberNode_1.NumberNode(6)),
+        cos: new oppositeNode_1.OppositeNode(new fractionNode_1.FractionNode(new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(3)), new numberNode_1.NumberNode(2))),
+        sin: new oppositeNode_1.OppositeNode(new fractionNode_1.FractionNode(new numberNode_1.NumberNode(1), new numberNode_1.NumberNode(2))),
+        point: "H",
+    },
+    {
+        angle: new fractionNode_1.FractionNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(5), piNode_1.PiNode), new numberNode_1.NumberNode(4)),
+        cos: new oppositeNode_1.OppositeNode(new fractionNode_1.FractionNode(new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(2)), new numberNode_1.NumberNode(2))),
+        sin: new oppositeNode_1.OppositeNode(new fractionNode_1.FractionNode(new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(2)), new numberNode_1.NumberNode(2))),
+        point: "K",
+    },
+    {
+        angle: new fractionNode_1.FractionNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(7), piNode_1.PiNode), new numberNode_1.NumberNode(3)),
+        cos: new oppositeNode_1.OppositeNode(new fractionNode_1.FractionNode(new numberNode_1.NumberNode(1), new numberNode_1.NumberNode(2))),
+        sin: new oppositeNode_1.OppositeNode(new fractionNode_1.FractionNode(new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(3)), new numberNode_1.NumberNode(2))),
+        point: "L",
+    },
+    {
+        angle: new fractionNode_1.FractionNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(3), piNode_1.PiNode), new numberNode_1.NumberNode(2)),
+        cos: new numberNode_1.NumberNode(0),
+        sin: new numberNode_1.NumberNode(-1),
+        point: "M",
+    },
+    {
+        angle: new fractionNode_1.FractionNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(5), piNode_1.PiNode), new numberNode_1.NumberNode(3)),
+        cos: new fractionNode_1.FractionNode(new numberNode_1.NumberNode(1), new numberNode_1.NumberNode(2)),
+        sin: new oppositeNode_1.OppositeNode(new fractionNode_1.FractionNode(new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(3)), new numberNode_1.NumberNode(2))),
+        point: "N",
+    },
+    {
+        angle: new fractionNode_1.FractionNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(7), piNode_1.PiNode), new numberNode_1.NumberNode(4)),
+        cos: new fractionNode_1.FractionNode(new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(2)), new numberNode_1.NumberNode(2)),
+        sin: new oppositeNode_1.OppositeNode(new fractionNode_1.FractionNode(new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(2)), new numberNode_1.NumberNode(2))),
+        point: "P",
+    },
+    {
+        angle: new fractionNode_1.FractionNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(11), piNode_1.PiNode), new numberNode_1.NumberNode(6)),
+        cos: new fractionNode_1.FractionNode(new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(3)), new numberNode_1.NumberNode(2)),
+        sin: new oppositeNode_1.OppositeNode(new fractionNode_1.FractionNode(new numberNode_1.NumberNode(1), new numberNode_1.NumberNode(2))),
+        point: "Q",
     },
 ];

package/lib/math/utils/arithmetic/gcd.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.gcd = void 0;
 function pgcd(a, b) {
-    return b ? gcd(b, a % b) : a;
+    return b ? pgcd(b, a % b) : Math.abs(a);
 }
 function gcd(...args) {
     if (args.length === 2)

package/lib/server.js

@@ -35,22 +35,17 @@ const express_1 = __importDefault(require("express"));
 const body_parser_1 = __importDefault(require("body-parser"));
 const dotenv_1 = __importDefault(require("dotenv"));
 const cors_1 = __importDefault(require("cors"));
-const multiplyNode_1 = require("./tree/nodes/operators/multiplyNode");
-const numberNode_1 = require("./tree/nodes/numbers/numberNode");
-const addNode_1 = require("./tree/nodes/operators/addNode");
-const powerNode_1 = require("./tree/nodes/operators/powerNode");
 const jsonParser = body_parser_1.default.json();
 const allExercises = [...exercises];
 const runServer = () => {
     dotenv_1.default.config();
     const app = (0, express_1.default)();
     app.use((0, cors_1.default)());
-    console.log(exercises.length);
+    console.log(exercises.length + " exercices");
+    console.log(exercises.filter((exo) => exo.isSingleStep).length);
     app.get("/", (req, res) => {
         res.json(allExercises);
     });
-    const tree = new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(3), new addNode_1.AddNode(new powerNode_1.SquareNode(new numberNode_1.NumberNode(4)), new powerNode_1.PowerNode(new numberNode_1.NumberNode(2), new numberNode_1.NumberNode(3))));
-    console.log(tree.evaluate({}));
     app.get("/exo", (req, res) => {
         const exoId = req.query.exoId;
         const exoIndex = allExercises.findIndex((exo) => exo.id == exoId);

package/lib/tree/nodes/algebraicNode.d.ts

@@ -2,5 +2,8 @@ import { Node, NodeOptions } from "./node";
 export interface AlgebraicNode extends Node {
     evaluate: (vars: Record<string, number>) => number;
     toEquivalentNodes: (opts?: NodeOptions) => AlgebraicNode[];
+    simplify: () => AlgebraicNode;
+    equals: (node: AlgebraicNode) => boolean;
+    isNumeric: boolean;
 }
 //# sourceMappingURL=algebraicNode.d.ts.map

package/lib/tree/nodes/algebraicNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"algebraicNode.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/algebraicNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAE3C,MAAM,WAAW,aAAc,SAAQ,IAAI;IAEzC,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,MAAM,CAAC;IACnD,iBAAiB,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,aAAa,EAAE,CAAC;CAC5D"}
+{"version":3,"file":"algebraicNode.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/algebraicNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAE3C,MAAM,WAAW,aAAc,SAAQ,IAAI;IAEzC,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,MAAM,CAAC;IACnD,iBAAiB,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,aAAa,EAAE,CAAC;IAC3D,QAAQ,EAAE,MAAM,aAAa,CAAC;IAC9B,MAAM,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,OAAO,CAAC;IACzC,SAAS,EAAE,OAAO,CAAC;CACpB"}