math-exercises 3.0.37 → 3.0.39

package/lib/exercises/math/sequences/arithmetic/recognizeReasonFromFirstTerms.js

@@ -2,18 +2,46 @@ import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exer
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { numberParser } from "../../../../tree/parsers/numberParser.js";
+const getInstruction = (identifiers) => {
+    const { sequence, reason } = identifiers;
+    return `Voici les premiers termes d'une suite arithmétique $u$ :
+  
+$$
+${sequence.join("\\ ; \\ ")}
+$$
+
+Quelle est la raison de $u$ ?`;
+};
+const getAnswer = (identifiers) => {
+    const { sequence, reason } = identifiers;
+    return reason + "";
+};
+const getHint = (identifiers) => {
+    return `La raison d'une suite arithmétique est le nombre par lequel on additionne un terme pour obtenir le suivant.`;
+};
+const getCorrection = (identifiers) => {
+    return `La raison d'une suite arithmétique est le nombre par lequel on additionne un terme pour obtenir le suivant.
+  
+Ici, on remarque que pour passer d'un terme au suivant, on additionne toujours par $${identifiers.reason}$.
+
+La raison de $u$ est donc $${identifiers.reason}$.
+`;
+};
 const getRecognizeReasonFromFirstTermsQuestion = () => {
     const firstTerm = randint(1, 20);
     const reason = randint(-5, 6, [0]);
     const sequence = new Array(5)
         .fill(0)
         .map((el, index) => firstTerm + index * reason);
+    const identifiers = { sequence, reason };
     const question = {
-        answer: reason + "",
-        instruction: `Voici les premiers termes d'une suite arithmétique $u$ : $${sequence.join("\\ ; \\ ")}$. Quelle est la raison de $u$ ?`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: [],
         answerFormat: "tex",
-        identifiers: { sequence, reason },
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -32,13 +60,16 @@ const isAnswerValid = (ans, { answer }) => {
 export const recognizeReasonFromFirstTerms = {
     id: "recognizeReasonFromFirstTerms",
     label: "Reconnaître la raison d'une suite arithmétique via ses premiers termes",
-    levels: ["1reESM", "1rePro", "1reSpé", "1reTech"],
     isSingleStep: true,
-    sections: ["Suites"],
     generator: (nb) => getDistinctQuestions(getRecognizeReasonFromFirstTermsQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/sequences/geometric/geometricRecognizeReasonFromFirstTerms.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometricRecognizeReasonFromFirstTerms.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricRecognizeReasonFromFirstTerms.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAIrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAqCF,eAAO,MAAM,sCAAsC,EAAE,QAAQ,CAAC,WAAW,CAexE,CAAC"}
+{"version":3,"file":"geometricRecognizeReasonFromFirstTerms.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricRecognizeReasonFromFirstTerms.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAIrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAiEF,eAAO,MAAM,sCAAsC,EAAE,QAAQ,CAAC,WAAW,CAkBxE,CAAC"}

package/lib/exercises/math/sequences/geometric/geometricRecognizeReasonFromFirstTerms.js

@@ -1,18 +1,46 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
+const getInstruction = (identifiers) => {
+    const { sequence, reason } = identifiers;
+    return `Voici les premiers termes d'une suite géométrique $u$ :
+  
+$$
+${sequence.join("\\ ; \\ ")}
+$$
+
+Quelle est la raison de $u$ ?`;
+};
+const getAnswer = (identifiers) => {
+    const { sequence, reason } = identifiers;
+    return reason + "";
+};
+const getHint = (identifiers) => {
+    return `La raison d'une suite géométrique est le nombre par lequel on multiplie un terme pour obtenir le suivant.`;
+};
+const getCorrection = (identifiers) => {
+    return `La raison d'une suite géométrique est le nombre par lequel on multiplie un terme pour obtenir le suivant.
+  
+Ici, on remarque que pour passer d'un terme au suivant, on multiplie toujours par $${identifiers.reason}$.
+
+La raison de $u$ est donc $${identifiers.reason}$.
+`;
+};
 const getGeometricRecognizeReasonFromFirstTermsQuestion = () => {
     const firstTerm = randint(1, 20);
     const reason = randint(-5, 6, [0, 1]);
     const sequence = new Array(5)
         .fill(0)
         .map((el, index) => firstTerm * Math.pow(reason, index));
+    const identifiers = { sequence, reason };
     const question = {
-        answer: reason + "",
-        instruction: `Voici les premiers termes d'une suite géométrique $u$ : $${sequence.join("\\ ; \\ ")}$. Quelle est la raison de $u$ ?`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: [],
         answerFormat: "tex",
-        identifiers: { sequence, reason },
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -31,13 +59,16 @@ export const geometricRecognizeReasonFromFirstTerms = {
     id: "geometricRecognizeReasonFromFirstTerms",
     connector: "=",
     label: "Reconnaître la raison d'une suite géométrique via ses premiers termes",
-    levels: [],
     isSingleStep: true,
-    sections: [],
     generator: (nb) => getDistinctQuestions(getGeometricRecognizeReasonFromFirstTermsQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"associatePoint.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/associatePoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAItE,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,eAAe,CAAC;IAClC,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA0DF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAchD,CAAC"}
+{"version":3,"file":"associatePoint.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/associatePoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAKtE,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,eAAe,CAAC;IAClC,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA4DF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAchD,CAAC"}

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

@@ -1,6 +1,7 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
 import { RemarkableValueConstructor } from "../../../math/trigonometry/remarkableValue.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
 import { random } from "../../../utils/alea/random.js";
 const points = [
     "I",
@@ -21,7 +22,9 @@ const points = [
     "Q",
 ];
 const getAssociatePointQuestion = () => {
-    const remarkableValue = RemarkableValueConstructor.simplifiable();
+    const remarkableValue = coinFlip()
+        ? RemarkableValueConstructor.simplifiable()
+        : RemarkableValueConstructor.mainInterval();
     const answer = remarkableValue.point;
     const question = {
         answer,
@@ -31,7 +34,7 @@ const getAssociatePointQuestion = () => {
         keys: points,
         answerFormat: "tex",
         identifiers: {
-            angleValue: remarkableValue.mainAngle.evaluate({}),
+            angleValue: remarkableValue.angle.evaluate({}),
             point: answer,
             angleIdentifiers: remarkableValue.angle.toIdentifiers(),
         },

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

@@ -88,7 +88,7 @@ const isAnswerValid = (ans, { answer, valueIndex, isCos }) => {
 export const mainRemarkableValuesExercise = {
     id: "mainRemarkableValues",
     connector: "=",
-    label: "Valeurs remarquables de $\\cos$ et $\\sin$ sur $]-\\pi, \\pi]$",
+    label: "Valeurs remarquables de $\\cos$ et $\\sin$ sur $]-\\pi; \\pi]$",
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(getMainRemarkableValues, nb, 18),
     qcmTimer: 60,

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

@@ -45,7 +45,7 @@ const getAnswer = (identifiers) => {
 const getRemarkableValues = () => {
     const isCos = coinFlip();
     const remarkableValue = RemarkableValueConstructor.simplifiable();
-    const mainValue = remarkableValue.mainAngle.evaluate({});
+    const mainValue = remarkableValue.angle.evaluate({});
     // const valueIndex = remarkableValue.index;
     const identifiers = {
         isCos,
@@ -87,7 +87,7 @@ const isAnswerValid = (ans, { answer, mainValue, isCos }) => {
 export const remarkableValuesExercise = {
     id: "remarkableValues",
     connector: "=",
-    label: "Valeurs remarquables de $\\cos$ et $\\sin$",
+    label: "Valeurs remarquables de $\\cos$ et $\\sin$ (hors de $]-\\pi; \\pi]$)",
     levels: ["1reSpé", "TermSpé", "MathComp"],
     isSingleStep: true,
     sections: ["Trigonométrie"],

package/lib/geogebra/geogebraConstructor.d.ts

@@ -8,6 +8,8 @@ type GetAdaptedCoords = {
     zMin?: number;
     zMax?: number;
     forceShowAxes?: boolean;
+    minCoords?: number[];
+    ratio?: number;
 };
 type GetOptionsProps = {
     coords: number[];
@@ -33,7 +35,7 @@ export declare class GeogebraConstructor {
     hideFullScreenButton?: boolean;
     constructor(options: Omit<GeogebraOptions, "coords">);
     getCoordsForPoints(points: Point[]): number[];
-    getAdaptedCoords({ xMin, xMax, yMin, yMax, zMin, zMax, forceShowAxes, }: GetAdaptedCoords): number[];
+    getAdaptedCoords({ xMin, xMax, yMin, yMax, zMin, zMax, forceShowAxes, minCoords, ratio, }: GetAdaptedCoords): number[];
     getOptions({ coords }: GetOptionsProps): GeogebraOptions;
 }
 export {};

package/lib/geogebra/geogebraConstructor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geogebraConstructor.d.ts","sourceRoot":"","sources":["../../src/geogebra/geogebraConstructor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,eAAe,EAChB,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AAErD,KAAK,gBAAgB,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AACF,KAAK,eAAe,GAAG;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AACF,qBAAa,mBAAmB;IAC9B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC;IACxC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACjC,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oBAAoB,CAAC,EAAE,OAAO,CAAC;gBACnB,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,QAAQ,CAAC;IAoBpD,kBAAkB,CAAC,MAAM,EAAE,KAAK,EAAE;IAOlC,gBAAgB,CAAC,EACf,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,aAAa,GACd,EAAE,gBAAgB;IAiDnB,UAAU,CAAC,EAAE,MAAM,EAAE,EAAE,eAAe,GAAG,eAAe;CAuBzD"}
+{"version":3,"file":"geogebraConstructor.d.ts","sourceRoot":"","sources":["../../src/geogebra/geogebraConstructor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,eAAe,EAChB,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AAErD,KAAK,gBAAgB,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AACF,KAAK,eAAe,GAAG;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AACF,qBAAa,mBAAmB;IAC9B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC;IACxC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACjC,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oBAAoB,CAAC,EAAE,OAAO,CAAC;gBACnB,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,QAAQ,CAAC;IAoBpD,kBAAkB,CAAC,MAAM,EAAE,KAAK,EAAE;IAOlC,gBAAgB,CAAC,EACf,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,aAAa,EACb,SAAS,EACT,KAAK,GACN,EAAE,gBAAgB;IAsDnB,UAAU,CAAC,EAAE,MAAM,EAAE,EAAE,eAAe,GAAG,eAAe;CAuBzD"}

package/lib/geogebra/geogebraConstructor.js

@@ -45,11 +45,11 @@ export class GeogebraConstructor {
         const yMax = Math.max(...points.map((p) => p.y.evaluate()));
         return this.getAdaptedCoords({ xMin, xMax, yMin, yMax });
     }
-    getAdaptedCoords({ xMin, xMax, yMin, yMax, zMin, zMax, forceShowAxes, }) {
+    getAdaptedCoords({ xMin, xMax, yMin, yMax, zMin, zMax, forceShowAxes, minCoords, ratio, }) {
         const showAxes = forceShowAxes ?? (this.hideAxes ? false : true);
         const xDelta = xMax - xMin;
         const yDelta = yMax - yMin;
-        const coeff = 0.1;
+        const coeff = ratio ?? 0.1;
         if (this.is3D && zMin !== undefined && zMax !== undefined) {
             const zDelta = zMax - zMin;
             const coords = [
@@ -91,6 +91,9 @@ export class GeogebraConstructor {
                 coords[2] = Math.min(-1, coords[2]);
                 coords[3] = Math.max(1, coords[3]);
             }
+            if (minCoords) {
+                return coords.map((coord, index) => (index % 2 === 0 ? Math.min : Math.max)(minCoords[index], coord));
+            }
             return coords;
         }
     }

package/lib/index.d.ts

@@ -76,7 +76,9 @@ declare const mathExercises: (Exercise<{
     num2: number;
     denom1: number;
     denom2: number;
-}, {}> | Exercise<{
+}, {
+    allowNonIrreductible?: boolean;
+}> | Exercise<{
     num1: number;
     num2: number;
     denom1: number;
@@ -176,7 +178,9 @@ declare const mathExercises: (Exercise<{
     precisionAsked: number;
     decimal: number;
     precision: number;
-}, {}> | Exercise<{
+}, {
+    precisionAsked: number;
+}> | Exercise<{
     nb: number;
     rankAsked: number;
 }, {}> | Exercise<{
@@ -1190,6 +1194,7 @@ declare const mathExercises: (Exercise<{
     AB: number;
     AC: number;
     trigoPoint: string;
+    letters: string[];
 }, {}> | Exercise<{
     c: number;
     vec1Name: string;
@@ -2021,6 +2026,7 @@ declare const pcExercises: (Exercise<{
     AB: number;
     AC: number;
     trigoPoint: string;
+    letters: string[];
 }, {}> | Exercise<{
     total: number;
     lefties: number;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/lib/latexTester.js

@@ -225,4 +225,5 @@ const validCmds = [
     "\\frown",
     "\\varepsilon",
     "\\ell",
+    "\\cancel",
 ];

package/lib/math/geometry/point.d.ts

@@ -37,8 +37,10 @@ export declare class Point {
     toCoords(): string;
     getXnumber(): number;
     getYnumber(): number;
+    midpointNode(B: Point, name?: string): Point;
     midpoint(B: Point, name?: string): Point;
     distanceTo(B: Point): number;
+    distanceToNode(B: Point): AlgebraicNode;
     equals(B: Point): boolean;
     isAligned(B: Point, C: Point): boolean;
     toMathString(): string;

package/lib/math/geometry/point.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/point.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAGlE,OAAO,EAAE,kBAAkB,EAAE,MAAM,sDAAsD,CAAC;AAC1F,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAM7C,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;CACpB,CAAC;AACF,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE;IAGrC,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,MAAM;IAKhC,MAAM,CAAC,MAAM,CAAC,IAAI,SAAM;IAGxB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,SAAM,EAAE,GAAG,SAAK,GAAG,KAAK;IAMvD,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,gBAAgB;IAQpD,MAAM,CAAC,SAAS,CACd,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,MAAM,EACZ,EACE,OAAa,EACb,WAAW,GACZ,GAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAO;IAQpD,MAAM,CAAC,eAAe,CACpB,KAAK,EAAE,MAAM,EACb,EACE,KAAK,EACL,WAAW,EACX,mBAAmB,GACpB,EAAE;QACD,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;QACjB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,mBAAmB,CAAC,EAAE,MAAM,CAAC;KAC9B;IA4BH,MAAM,CAAC,cAAc,CAAC,GAAG,EAAE,MAAM;CAclC;AAED,qBAAa,KAAK;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBAEf,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,aAAa,GAAG,MAAM,EACzB,CAAC,EAAE,aAAa,GAAG,MAAM;IAO3B,KAAK,IAAI,MAAM;IAGf,aAAa,IAAI,gBAAgB;IAQjC,eAAe,IAAI,MAAM;IAGzB,QAAQ,IAAI,MAAM;IAIlB,UAAU,IAAI,MAAM;IAIpB,UAAU,IAAI,MAAM;IAIpB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,KAAK;IAQrC,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM;IAM5B,MAAM,CAAC,CAAC,EAAE,KAAK,GAAG,OAAO;IAGzB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK;IAK5B,YAAY;IAGZ,YAAY,CAAC,EACX,OAAc,EACd,SAAgB,EAChB,KAAK,EACL,IAAI,EACJ,KAAK,GACN,GAAE,kBAAuB;IAiB1B,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK;IAiBnC,eAAe,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,SAAkB;IAIrD,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,SAAkB;IAI1C,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,SAAkB;CAIjD"}
+{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/point.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAGlE,OAAO,EAAE,kBAAkB,EAAE,MAAM,sDAAsD,CAAC;AAC1F,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAM7C,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAIvC,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;CACpB,CAAC;AACF,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE;IAGrC,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,MAAM;IAKhC,MAAM,CAAC,MAAM,CAAC,IAAI,SAAM;IAGxB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,SAAM,EAAE,GAAG,SAAK,GAAG,KAAK;IAMvD,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,gBAAgB;IAQpD,MAAM,CAAC,SAAS,CACd,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,MAAM,EACZ,EACE,OAAa,EACb,WAAW,GACZ,GAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAO;IAQpD,MAAM,CAAC,eAAe,CACpB,KAAK,EAAE,MAAM,EACb,EACE,KAAK,EACL,WAAW,EACX,mBAAmB,GACpB,EAAE;QACD,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;QACjB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,mBAAmB,CAAC,EAAE,MAAM,CAAC;KAC9B;IA4BH,MAAM,CAAC,cAAc,CAAC,GAAG,EAAE,MAAM;CAclC;AAED,qBAAa,KAAK;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBAEf,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,aAAa,GAAG,MAAM,EACzB,CAAC,EAAE,aAAa,GAAG,MAAM;IAO3B,KAAK,IAAI,MAAM;IAGf,aAAa,IAAI,gBAAgB;IAQjC,eAAe,IAAI,MAAM;IAGzB,QAAQ,IAAI,MAAM;IAIlB,UAAU,IAAI,MAAM;IAIpB,UAAU,IAAI,MAAM;IAIpB,YAAY,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,KAAK;IAOzC,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,KAAK;IAQrC,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM;IAK5B,cAAc,CAAC,CAAC,EAAE,KAAK,GAAG,aAAa;IAMvC,MAAM,CAAC,CAAC,EAAE,KAAK,GAAG,OAAO;IAGzB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK;IAK5B,YAAY;IAGZ,YAAY,CAAC,EACX,OAAc,EACd,SAAgB,EAChB,KAAK,EACL,IAAI,EACJ,KAAK,GACN,GAAE,kBAAuB;IAiB1B,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK;IAiBnC,eAAe,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,SAAkB;IAIrD,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,SAAkB;IAI1C,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,SAAkB;CAIjD"}

package/lib/math/geometry/point.js

@@ -8,6 +8,8 @@ import { multiply } from "../../tree/nodes/operators/multiplyNode.js";
 import { add } from "../../tree/nodes/operators/addNode.js";
 import { randomLetter } from "../../utils/strings/randomLetter.js";
 import { frac } from "../../tree/nodes/operators/fractionNode.js";
+import { sqrt } from "../../tree/nodes/functions/sqrtNode.js";
+import { square } from "../../tree/nodes/operators/powerNode.js";
 export class PointConstructor {
     static randomName(excludes) {
         return randomLetter(true, ["O", ...(excludes ?? [])]);
@@ -94,6 +96,9 @@ export class Point {
     getYnumber() {
         return this.y.evaluate();
     }
+    midpointNode(B, name = "I") {
+        return new Point(name, frac(add(this.x, B.x), 2), frac(add(this.y, B.y), 2));
+    }
     midpoint(B, name = "I") {
         return new Point(name, frac(add(this.x, B.x), 2).simplify(), frac(add(this.y, B.y), 2).simplify());
     }
@@ -102,6 +107,11 @@ export class Point {
         const dy = this.getYnumber() - B.getYnumber();
         return Math.sqrt(dx ** 2 + dy ** 2);
     }
+    distanceToNode(B) {
+        const dx = substract(this.x, B.x);
+        const dy = substract(this.y, B.y);
+        return sqrt(add(square(dx), square(dy)));
+    }
     equals(B) {
         return this.x.equals(B.x) && this.y.equals(B.y);
     }

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

@@ -15,7 +15,7 @@ export declare class Integer implements Nombre {
     constructor(value: number, tex?: string);
     equals(n: Nombre): boolean;
     toTree(): NumberNode;
-    times(n: number | Nombre): Decimal | Integer;
+    times(n: number | Nombre): Integer | Decimal;
     round(precision: number): Integer;
     divide(nb: Nombre): Nombre;
     multiply(nb: Nombre): Rational | Integer;

package/lib/math/numbers/rationals/rational.d.ts

@@ -22,6 +22,7 @@ export declare class Rational implements Nombre {
     isSimplified: boolean;
     type: NumberType;
     constructor(numerator: number, denumerator: number);
+    toArray(): number[];
     equals(n: Nombre): boolean;
     toTex(): string;
     add(nb: Nombre): Nombre;

package/lib/math/numbers/rationals/rational.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rational.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/rationals/rational.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAElE,OAAO,EAAQ,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAQ7D,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAEhD,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAElD,8BAAsB,mBAAmB;IACvC;;OAEG;IACH,MAAM,CAAC,kBAAkB,CAAC,MAAM,GAAE,MAAW;IAW7C,MAAM,CAAC,kBAAkB,CACvB,GAAG,GAAE,MAAW,EAChB,EAAE,UAAkB,EAAE,GAAE;QAAE,UAAU,CAAC,EAAE,OAAO,CAAA;KAAO;IASvD,MAAM,CAAC,uBAAuB,CAAC,QAAQ,GAAE,MAAW;IAKpD,MAAM,CAAC,0BAA0B,CAAC,GAAG,GAAE,MAAW;IAQlD,MAAM,CAAC,kBAAkB,CAAC,GAAG,GAAE,MAAW;CAO3C;AAED,qBAAa,QAAS,YAAW,MAAM;IACrC,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,OAAO,CAAC;IACtB,IAAI,EAAE,UAAU,CAAC;gBAEL,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;IAYlD,MAAM,CAAC,CAAC,EAAE,MAAM;IAGhB,KAAK;IAML,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAkBvB,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO;IAgBxC,OAAO,CAAC,cAAc,EAAE,OAAO,GAAG,MAAM;IAIxC,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAgB1B,QAAQ,IAAI,QAAQ;IAIpB,MAAM,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa;IAgBzC,cAAc;IAId,QAAQ,IAAI,OAAO,GAAG,QAAQ;CAqB/B"}
+{"version":3,"file":"rational.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/rationals/rational.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAElE,OAAO,EAAQ,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAQ7D,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAEhD,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAElD,8BAAsB,mBAAmB;IACvC;;OAEG;IACH,MAAM,CAAC,kBAAkB,CAAC,MAAM,GAAE,MAAW;IAW7C,MAAM,CAAC,kBAAkB,CACvB,GAAG,GAAE,MAAW,EAChB,EAAE,UAAkB,EAAE,GAAE;QAAE,UAAU,CAAC,EAAE,OAAO,CAAA;KAAO;IASvD,MAAM,CAAC,uBAAuB,CAAC,QAAQ,GAAE,MAAW;IAKpD,MAAM,CAAC,0BAA0B,CAAC,GAAG,GAAE,MAAW;IAQlD,MAAM,CAAC,kBAAkB,CAAC,GAAG,GAAE,MAAW;CAO3C;AAED,qBAAa,QAAS,YAAW,MAAM;IACrC,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,OAAO,CAAC;IACtB,IAAI,EAAE,UAAU,CAAC;gBAEL,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;IAYlD,OAAO;IAGP,MAAM,CAAC,CAAC,EAAE,MAAM;IAGhB,KAAK;IAML,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAkBvB,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO;IAgBxC,OAAO,CAAC,cAAc,EAAE,OAAO,GAAG,MAAM;IAIxC,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAgB1B,QAAQ,IAAI,QAAQ;IAIpB,MAAM,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa;IAgBzC,cAAc;IAId,QAAQ,IAAI,OAAO,GAAG,QAAQ;CAqB/B"}

package/lib/math/numbers/rationals/rational.js

@@ -74,6 +74,9 @@ export class Rational {
         this.tex = `${this.num < 0 ? "-" : ""}\\frac{${this.num < 0 ? -this.num : this.num}}{${this.denum}}`;
         this.type = NumberType.Rational;
     }
+    toArray() {
+        return [this.num, this.denum];
+    }
     equals(n) {
         return this.value === n.value;
     }

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

@@ -1,9 +1,6 @@
-import { AlgebraicNode } from "../../tree/nodes/algebraicNode.js";
 import { RemarkableValue } from "./remarkableValues.js";
 export declare abstract class RemarkableValueConstructor {
     static mainInterval: () => RemarkableValue;
-    static simplifiable: () => RemarkableValue & {
-        mainAngle: AlgebraicNode;
-    };
+    static simplifiable: () => RemarkableValue;
 }
 //# 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,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAQlE,OAAO,EAAE,eAAe,EAAyB,MAAM,uBAAuB,CAAC;AAE/E,8BAAsB,0BAA0B;IAC9C,MAAM,CAAC,YAAY,QAAO,eAAe,CAGvC;IACF,MAAM,CAAC,YAAY,QAAO,eAAe,GAAG;QAC1C,SAAS,EAAE,aAAa,CAAC;KAC1B,CAiBC;CACH"}
+{"version":3,"file":"remarkableValue.d.ts","sourceRoot":"","sources":["../../../src/math/trigonometry/remarkableValue.ts"],"names":[],"mappings":"AAQA,OAAO,EACL,eAAe,EAGhB,MAAM,uBAAuB,CAAC;AAE/B,8BAAsB,0BAA0B;IAC9C,MAAM,CAAC,YAAY,QAAO,eAAe,CAGvC;IACF,MAAM,CAAC,YAAY,QAAO,eAAe,CAgBvC;CACH"}

package/lib/math/trigonometry/remarkableValue.js

@@ -4,19 +4,18 @@ import { AddNode } from "../../tree/nodes/operators/addNode.js";
 import { MultiplyNode } from "../../tree/nodes/operators/multiplyNode.js";
 import { random } from "../../utils/alea/random.js";
 import { randint } from "../utils/random/randint.js";
-import { remarkableTrigoValues } from "./remarkableValues.js";
+import { mainTrigoValues, } from "./remarkableValues.js";
 export class RemarkableValueConstructor {
     static mainInterval = () => {
-        const randValue = random(remarkableTrigoValues);
+        const randValue = random(mainTrigoValues);
         return randValue;
     };
     static simplifiable = () => {
-        const index = randint(0, remarkableTrigoValues.length);
-        const randValue = remarkableTrigoValues[index];
-        const toAdd = randint(-3, 4) * 2;
+        const index = randint(0, mainTrigoValues.length);
+        const randValue = mainTrigoValues[index];
+        const toAdd = randint(-3, 4, [0]) * 2;
         const newRadian = new AddNode(randValue.angle, new MultiplyNode(new NumberNode(toAdd), PiNode)).simplify();
         return {
-            mainAngle: randValue.angle,
             angle: newRadian,
             cos: randValue.cos,
             sin: randValue.sin,

package/lib/math/utils/stats/generateAffineCloud.js

@@ -12,7 +12,7 @@ export const generateAffineCloud = (n) => {
         }
         generatedXs.add(x);
         let noise = Math.random() * 100;
-        let y = round(slope * x + intercept + noise, 2);
+        let y = round(slope * x + intercept + noise, 0);
         data.push({ x, y });
     }
     return data;

package/lib/playground.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAqBA,eAAO,MAAM,UAAU,YAGtB,CAAC"}
+{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAuBA,eAAO,MAAM,UAAU,YAMtB,CAAC"}

package/lib/playground.js

@@ -1,4 +1,9 @@
+import { multiply } from "./tree/nodes/operators/multiplyNode.js";
+import { substract } from "./tree/nodes/operators/substractNode.js";
 export const playground = () => {
     // const tex = "3\\%";
     // console.log(parseAlgebraic(tex).simplify({}).toTex());
+    const x = multiply(3, substract("x", 9));
+    console.log(x.simplify().toTex());
+    console.log(x.equals(x.simplify()));
 };

package/lib/tests/pdfExo.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pdfExo.test.d.ts","sourceRoot":"","sources":["../../src/tests/pdfExo.test.ts"],"names":[],"mappings":"AAeA,OAAO,6BAA6B,CAAC"}
+{"version":3,"file":"pdfExo.test.d.ts","sourceRoot":"","sources":["../../src/tests/pdfExo.test.ts"],"names":[],"mappings":"AAgBA,OAAO,6BAA6B,CAAC"}

package/lib/tests/pdfExo.test.js

@@ -1,8 +1,8 @@
-import { extractPointFromParametricLine, } from "../exercises/math/index.js";
+import { factorizedFormFromRoots, } from "../exercises/math/index.js";
 import { buildPdfForExercise } from "./pdfs/buildPDFForExercise.js";
 import "../prototypesEnhancement.js";
 try {
-    buildPdfForExercise(extractPointFromParametricLine);
+    buildPdfForExercise(factorizedFormFromRoots);
 }
 catch (err) {
     console.log(err);

package/lib/tree/nodes/functions/oppositeNode.d.ts

@@ -1,6 +1,5 @@
 import { Node, NodeIds, NodeOptions, NodeType } from "../node.js";
 import { FunctionNode, FunctionsIds } from "./functionNode.js";
-import { NumberNode } from "../numbers/numberNode.js";
 import { AlgebraicNode, SimplifyOptions } from "../algebraicNode.js";
 export declare function isOppositeNode(a: Node): a is OppositeNode;
 export declare const opposite: <T extends AlgebraicNode = AlgebraicNode>(a: T | number | string) => OppositeNode<T>;
@@ -27,7 +26,7 @@ export declare class OppositeNode<T extends AlgebraicNode = AlgebraicNode> imple
      */
     toAllValidTexs(opts?: NodeOptions): string[];
     evaluate(vars?: Record<string, number>): number;
-    simplify(opts?: SimplifyOptions): AlgebraicNode | NumberNode;
+    simplify(opts?: SimplifyOptions): AlgebraicNode;
     equals(node: AlgebraicNode): boolean;
     toDetailedEvaluation(vars: Record<string, AlgebraicNode>): OppositeNode<AlgebraicNode>;
     derivative(varName?: string | undefined): AlgebraicNode;

package/lib/tree/nodes/functions/oppositeNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"oppositeNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/oppositeNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAMlE,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,mBAAmB,CAAC;AAC/E,OAAO,EAAE,UAAU,EAAgB,MAAM,0BAA0B,CAAC;AACpE,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAIrE,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,eAAO,MAAM,QAAQ,GAAI,CAAC,SAAS,aAAa,qBAC3C,CAAC,GAAG,MAAM,GAAG,MAAM,oBAKvB,CAAC;AAEF,qBAAa,YAAY,CAAC,CAAC,SAAS,aAAa,GAAG,aAAa,CAC/D,YAAW,YAAY,CAAC,CAAC,CAAC;IAE1B,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,CAAC,CAAC;IACT,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBACP,KAAK,EAAE,CAAC,EAAE,IAAI,CAAC,EAAE,WAAW;IAQxC,aAAa;;;;;;IAMb,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAef,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAgCtD;;;;OAIG;IACH,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAQ5C,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAK/B,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAGpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAGxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAGxD"}
+{"version":3,"file":"oppositeNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/oppositeNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAMlE,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,mBAAmB,CAAC;AAE/E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAIrE,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,eAAO,MAAM,QAAQ,GAAI,CAAC,SAAS,aAAa,qBAC3C,CAAC,GAAG,MAAM,GAAG,MAAM,oBAKvB,CAAC;AAEF,qBAAa,YAAY,CAAC,CAAC,SAAS,aAAa,GAAG,aAAa,CAC/D,YAAW,YAAY,CAAC,CAAC,CAAC;IAE1B,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,CAAC,CAAC;IACT,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBACP,KAAK,EAAE,CAAC,EAAE,IAAI,CAAC,EAAE,WAAW;IAQxC,aAAa;;;;;;IAMb,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAef,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAgCtD;;;;OAIG;IACH,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAQ5C,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAK/B,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAGpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAGxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAGxD"}

package/lib/tree/nodes/functions/sqrtNode.d.ts

@@ -21,9 +21,10 @@ export declare class SqrtNode implements FunctionNode {
     toEquivalentNodes(opts?: NodeOptions): AlgebraicNode[];
     toAllValidTexs(opts?: NodeOptions): string[];
     evaluate(vars?: Record<string, number>): number;
-    simplify(opts?: SimplifyOptions): AlgebraicNode;
+    simplify(opts?: SimplifyOptions, steps?: AlgebraicNode[]): AlgebraicNode;
     equals(node: AlgebraicNode): boolean;
     toDetailedEvaluation(vars: Record<string, AlgebraicNode>): SqrtNode;
     derivative(varName?: string | undefined): AlgebraicNode;
+    toSimplificationTex(opts?: SimplifyOptions): void;
 }
 //# sourceMappingURL=sqrtNode.d.ts.map

package/lib/tree/nodes/functions/sqrtNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sqrtNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/sqrtNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAClE,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,mBAAmB,CAAC;AAK/E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAKrE,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,QAAQ,CAEjD;AAED,eAAO,MAAM,IAAI,MAAO,aAAa,GAAG,MAAM,GAAG,MAAM,aAItD,CAAC;AAEF,qBAAa,QAAS,YAAW,YAAY;IAC3C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBACP,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;IAOpD,aAAa;;;;;;IAMb,YAAY,IAAI,MAAM;IAMtB,KAAK,IAAI,MAAM;IAIf,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAwBtD,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAG5C,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAyC/B,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAGpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAGxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAGxD"}
+{"version":3,"file":"sqrtNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/sqrtNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAClE,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,mBAAmB,CAAC;AAK/E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAMrE,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,QAAQ,CAEjD;AAED,eAAO,MAAM,IAAI,MAAO,aAAa,GAAG,MAAM,GAAG,MAAM,aAItD,CAAC;AAEF,qBAAa,QAAS,YAAW,YAAY;IAC3C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBACP,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;IAOpD,aAAa;;;;;;IAMb,YAAY,IAAI,MAAM;IAMtB,KAAK,IAAI,MAAM;IAIf,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAwBtD,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAG5C,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,EAAE,KAAK,CAAC,EAAE,aAAa,EAAE;IA2CxD,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAGpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAGxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;IAGvD,mBAAmB,CAAC,IAAI,CAAC,EAAE,eAAe;CAI3C"}

package/lib/tree/nodes/functions/sqrtNode.js

@@ -69,12 +69,13 @@ export class SqrtNode {
     evaluate(vars) {
         return Math.sqrt(this.child.evaluate(vars));
     }
-    simplify(opts) {
+    simplify(opts, steps) {
         const simplifiedChild = this.child.simplify(opts);
         const copy = new SqrtNode(simplifiedChild, this.opts);
+        if (steps && !this.child.equals(simplifiedChild))
+            steps.push(copy);
         const externals = [];
         //ex [3, x^2] pour sqrt(3x^2)
-        //TODO fractions
         const recursive = (node) => {
             if (isMultiplyNode(node)) {
                 recursive(node.leftChild);
@@ -120,4 +121,48 @@ export class SqrtNode {
     derivative(varName) {
         throw new Error("unimplemented derivative");
     }
+    toSimplificationTex(opts) {
+        const nodes = [this];
+        const simp = this.simplify(opts, nodes);
+    }
 }
+// const simplifyInteger = (a: number)=>{
+//     if (a === 0) return 0..toTree()
+//       if (a === 1) return 1..toTree();
+//       const [outsideSqrt, insideSqrt] = this.getSimplifiedCoeffs();
+//       const simplified =
+//         insideSqrt !== 1
+//           ? new Real(
+//               outsideSqrt * Math.sqrt(insideSqrt),
+//               `${outsideSqrt === 1 ? "" : `${outsideSqrt}`}\\sqrt{${insideSqrt}}`,
+//             )
+//           : new Real(outsideSqrt, outsideSqrt + "");
+//       simplified.toTree = (): AlgebraicNode => {
+//         return insideSqrt !== 1
+//           ? outsideSqrt === 1
+//             ? new SqrtNode(new NumberNode(insideSqrt))
+//             : new MultiplyNode(
+//                 new NumberNode(outsideSqrt),
+//                 new SqrtNode(new NumberNode(insideSqrt)),
+//               )
+//           : new NumberNode(outsideSqrt);
+//       };
+//       return simplified;
+// }
+// const getMaxSquareAndRest = (a: number)=> {
+//     if (a === 0) return [1, 0];
+//     const factors = primeFactors( a);
+//     // finds primes with even exponents
+//     const multiples = [1];
+//     for (let i = 0; i < factors.length - 1; i++) {
+//       if (factors[i] === factors[i + 1]) {
+//         multiples.push(factors[i]);
+//         factors.splice(i, 2);
+//         i--;
+//       }
+//     }
+//     const maxSquare = multiples.reduce((x, y) => x * y);
+//     const insideSqrt =
+//       factors.length === 0 ? 1 : factors.reduce((x, y) => x * y);
+//     return [maxSquare, insideSqrt];
+//   }

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

@@ -42,6 +42,7 @@ export type ToTexOptions = {
     color?: string;
     noPropagation?: boolean;
     unit?: string;
+    cancel?: boolean;
 };
 export declare enum NodeIds {
     add = 0,