math-exercises 3.0.177 → 3.0.179

package/lib/index.d.ts

@@ -1480,6 +1480,9 @@ declare const mathExercises: (Exercise<{
     a: number;
     b: number;
     c: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    affineCoeffs: number[];
+    trinomCoeffs: number[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
     param: string;
     coeffs: number[];
@@ -1594,13 +1597,6 @@ declare const mathExercises: (Exercise<{
     expBRounded: number;
     precision: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
-    nodeIdsA: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-    nodeIdsB: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-    nodeIdsAOpB: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-    rand: number;
-}, {
-    isUseExpNotation: boolean;
-}> | Exercise<{
     nodeIdsF: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     nodeIdsT: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     x: number;
@@ -1835,8 +1831,6 @@ declare const mathExercises: (Exercise<{
     isMinusInside: boolean;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     k: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    nodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
     isFindU: boolean;
     nodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
@@ -2858,15 +2852,6 @@ declare const mathExercises: (Exercise<{
     kIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     uCoeffs: number[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
-    flip: number;
-    pA?: number;
-    pB?: number;
-    pAB?: number;
-    pA_B?: number;
-    pB_A?: number;
-}, {
-    probaType: string[];
-}> | Exercise<{
     randomValues: number[];
     randomEffectives: number[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -3011,6 +2996,7 @@ declare const mathExercises: (Exercise<{
     allowedAnsType: string[];
 }, {
     allowedAnsType: string[];
+    probaTypes: string[];
 }> | Exercise<{
     exerciseVars: {
         n: number;
@@ -3202,6 +3188,25 @@ declare const mathExercises: (Exercise<{
     situationIndex: number;
     dictShuffle: Record<string, string>;
     pType: string;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    flip: number;
+    pA?: number;
+    pB?: number;
+    pAB?: number;
+    pA_B?: number;
+    pB_A?: number;
+}, {
+    probaType: string[];
+}> | Exercise<{
+    params: import("./exercises/math/probaStat/trees/probaTreeSituations.js").ProbaTreeSituationParams;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    situationIndex: number;
+    aCapB: number;
+    aCapBBarre: number;
+    aBarreCapB: number;
+    aBarreCapBBarre: number;
+    knowing: "A" | "\\overline{A}" | "B" | "\\overline{B}";
+    asked: "A" | "\\overline{A}" | "B" | "\\overline{B}";
 }, Record<string, string | boolean | string[]>> | Exercise<{
     situationIndex: number;
     values: number[];
@@ -3252,8 +3257,6 @@ declare const mathExercises: (Exercise<{
     firstValue: number;
     reason: number;
     randValue: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    final: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     sequences: number[][];
     answerIndex: number;
@@ -3270,13 +3273,6 @@ declare const mathExercises: (Exercise<{
     sequence: number[];
 }, {
     firstTermRankOne?: boolean;
-}> | Exercise<{
-    firstRank: number;
-    firstValue: number;
-    reason: number;
-    nbTerms: number;
-}, {
-    firstTermRank: string;
 }> | Exercise<{
     firstValue: number;
     reason: number;
@@ -3286,12 +3282,6 @@ declare const mathExercises: (Exercise<{
     rank2: number;
     reason: number;
     value1: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    rank1: number;
-    value1: number;
-    rank2: number;
-    value2: number;
-    rankAsked: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     firstRank: number;
     firstTerm: number;
@@ -3306,6 +3296,51 @@ declare const mathExercises: (Exercise<{
     b: number;
     n: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
+    rank1: number;
+    value1: number;
+    rank2: number;
+    value2: number;
+    rankAsked: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    rank1: number;
+    value1: number;
+    rank2: number;
+    value2: number;
+}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne> | Exercise<{
+    situationIndex: number;
+    initial: number;
+    reason: number;
+    superfluousData?: import("./math/utils/sequences/situations/seqArithmeticSituations.js").SituationArithmeticSuperfluousData;
+}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne & import("./exercises/options/optionIsWithSuperfluousData.js").OptionIsWithSuperfluousData> | Exercise<{
+    situationIndex: number;
+    initial: number;
+    reason: number;
+    superfluousData?: import("./math/utils/sequences/situations/seqArithmeticSituations.js").SituationArithmeticSuperfluousData;
+}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne & import("./exercises/options/optionIsWithSuperfluousData.js").OptionIsWithSuperfluousData> | Exercise<{
+    situationIndex: number;
+    initial: number;
+    reason: number;
+    superfluousData?: import("./math/utils/sequences/situations/seqArithmeticSituations.js").SituationArithmeticSuperfluousData;
+    rankAsked: number;
+}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne & import("./exercises/options/optionIsWithSuperfluousData.js").OptionIsWithSuperfluousData> | Exercise<{
+    final: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    firstRank: number;
+    firstValue: number;
+    reason: number;
+    nbTerms: number;
+}, {
+    firstTermRank: string;
+}> | Exercise<{
+    initial: number;
+    reason: number;
+    nbTerms: number;
+    lowRankDots: number;
+    highRankDots: number;
+}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne & {
+    isGiveCount: boolean;
+    isForceWriteSumWithPlusSymbol: boolean;
+}> | Exercise<{
     firstRank: number;
     firstTerm: number;
     reason: number;
@@ -3326,9 +3361,6 @@ declare const mathExercises: (Exercise<{
     value1: number;
     reason: number;
     rank1: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    raison: number;
-    final: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     reason: number;
     startRank: number;
@@ -3356,6 +3388,20 @@ declare const mathExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     sequence: number[];
     reason: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    q: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    a: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    rank1: number;
+    value1: number;
+    rank2: number;
+    value2: number;
+    precisionInitial: number;
+    precisionReason: number;
+    rankAsked: number;
+}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne> | Exercise<{
+    raison: number;
+    final: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     firstRank: number;
     firstValue: number;
@@ -3365,18 +3411,39 @@ declare const mathExercises: (Exercise<{
     positiveReason: boolean;
     firstRankOne: boolean;
 }> | Exercise<{
-    q: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-    a: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
+    initial: number;
+    reason: number;
+    nbTerms: number;
+    lowRankDots: number;
+    highRankDots: number;
+}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne & {
+    isGiveCount: boolean;
+}> | Exercise<{
+    situationIndex: number;
+    initial: number;
+    reason: number;
+    superfluousData?: import("./math/utils/sequences/situations/seqGeometricSituations.js").SituationGeometricSuperfluousData;
+}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne & import("./exercises/options/optionIsWithSuperfluousData.js").OptionIsWithSuperfluousData> | Exercise<{
+    situationIndex: number;
+    initial: number;
+    reason: number;
+    superfluousData?: import("./math/utils/sequences/situations/seqGeometricSituations.js").SituationGeometricSuperfluousData;
+    rankAsked: number;
+}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne & import("./exercises/options/optionIsWithSuperfluousData.js").OptionIsWithSuperfluousData> | Exercise<{
     rank: number;
     coeffs: number[];
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    functionType: string[];
+}> | Exercise<{
     coeffs: number[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
     rank: number;
     u0: number;
     coeffs: number[];
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    functionType: string[];
+    askedRank: string[];
+}> | Exercise<{
     termeid: number;
     affine: number[];
     termeAdd: number;
@@ -3402,6 +3469,13 @@ declare const mathExercises: (Exercise<{
     askedTerm: number;
 }, {
     firstRank: string;
+}> | Exercise<{
+    rank1: number;
+    value1: number;
+    coeffs: number[];
+    rankAsked: number;
+}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne & {
+    distanceOfRankAsked: string;
 }> | Exercise<{
     formulaIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, {
@@ -3784,6 +3858,43 @@ declare const mathExercises: (Exercise<{
     m: number;
     p: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
+    firstValue: number;
+    rankAsked: number;
+    coeffs: number[];
+}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne> | Exercise<{
+    firstValue: number;
+    coeffs: number[];
+    rankAsked: number;
+    keyIncomplete: string;
+}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne> | Exercise<{
+    firstValue: number;
+    lengthAsked: number;
+    coeffs: number[];
+    isUseFuncRecur: boolean;
+}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne> | Exercise<{
+    firstValue: number;
+    lengthAsked: number;
+    coeffs: number[];
+    isAnswerAlternative: boolean;
+}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne & import("./exercises/options/optionIsUsePythonDef.js").OptionIsUsePythonDef> | Exercise<{
+    firstValue: number;
+    coeffs: number[];
+    rankAsked: number;
+}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne & import("./exercises/options/optionIsUsePythonDef.js").OptionIsUsePythonDef & {
+    typeAsked: string;
+}> | Exercise<{
+    nAsked: number;
+    cyRandModFour?: number;
+    arrRandForStr: number[];
+}, import("./exercises/options/optionIsUsePythonDef.js").OptionIsUsePythonDef> | Exercise<{
+    valueThreshold: number;
+    valueLimit: number;
+    nodeIdsDistanceMax: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    keyIncomplete: string;
+}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne & import("./exercises/options/optionIsUsePythonDef.js").OptionIsUsePythonDef & {
+    isUsePythonList: boolean;
+    typeSequence: string;
+}> | Exercise<{
     p: number;
     n: number;
     wordingType: number;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}

package/lib/latexTester.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"latexTester.d.ts","sourceRoot":"","sources":["../src/latexTester.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,EAAE,6BAA2B,YAuLrE,CAAC"}
+{"version":3,"file":"latexTester.d.ts","sourceRoot":"","sources":["../src/latexTester.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,EAAE,6BAA2B,YAgMrE,CAAC"}

package/lib/latexTester.js

@@ -19,12 +19,14 @@ export const latexTester = (latex, isDefaultInMathMode = false) => {
         }
         if (char === "$") {
             if (isDefaultInMathMode)
-                throw new Error("Dollar in default math mode");
+                throw new Error(`Dollar in default math mode, ${latex}`);
             if (inPython || inInlinePython)
                 throw new Error("Dollar in python mode");
             if (nextChar === "$") {
-                if (inDollarMode)
-                    throw new Error("Double dollar instead of single");
+                if (inDollarMode) {
+                    const strAround = `${prevChar}${char}${nextChar}${nextNextChar}`;
+                    throw new Error(`Double dollar instead of single, around ${strAround}, ${latex}`);
+                }
                 inDoubleDollarMode = !inDoubleDollarMode;
                 if (inDoubleDollarMode &&
                     nextNextChar !== undefined &&
@@ -57,7 +59,8 @@ export const latexTester = (latex, isDefaultInMathMode = false) => {
                 char !== "\n" &&
                 char !== "\t") {
                 if (!inDollarMode && !inDoubleDollarMode) {
-                    throw new Error(`Number not in math mode, ${char}, ${latex}`);
+                    const strAround = `${prevChar}${char}${nextChar}${nextNextChar}`;
+                    throw new Error(`Number not in math mode, ${char}, ${strAround}, ${latex}`);
                 }
             }
             //check si charactere spécial
@@ -230,6 +233,8 @@ const validCmds = [
     "\\newline",
     "\\lVert",
     "\\rVert",
+    "\\lvert",
+    "\\rvert",
     "\\hline",
     "\\mathrm",
     "\\overline",
@@ -265,6 +270,4 @@ const validCmds = [
     "\\searrow",
     "\\mapsto",
     "\\color",
-    "\\lvert",
-    "\\rvert",
 ];

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

@@ -4,6 +4,7 @@ import { Polynomial } from "./polynomial.js";
 import { Trinom } from "./trinom.js";
 export declare abstract class AffineConstructor {
     static fromCoeffs(coeffs: number[]): Affine;
+    static randomNiceRoot(): Affine;
     static random(aOpts?: {
         min?: number;
         max?: number;

package/lib/math/polynomials/affine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"affine.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/affine.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAGlE,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAG9C,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM;IAG3C,MAAM,CAAC,MAAM,CACX,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,EAC3D,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,EAC3D,QAAQ,CAAC,EAAE,MAAM,GAChB,MAAM;IAcT,MAAM,CAAC,gBAAgB,CACrB,EAAE,EAAE,MAAM,EACV,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,EAC3D,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,GAC1D,MAAM,EAAE;CAcZ;AAED,qBAAa,MAAO,SAAQ,UAAU;IACpC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,MAAM,CAAC;gBAEL,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAY;IAOxD,OAAO,IAAI,MAAM;IAGjB,KAAK,CAAC,CAAC,EAAE,aAAa,GAAG,MAAM;IAG/B,MAAM,IAAI,MAAM;IAMhB,KAAK,CAAC,CAAC,EAAE,MAAM;IAIf,iBAAiB,IAAI,MAAM;IAI3B,QAAQ,IAAI,MAAM;IAMlB,aAAa;CAGd"}
+{"version":3,"file":"affine.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/affine.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAGlE,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAG9C,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM;IAG3C,MAAM,CAAC,cAAc,IAAI,MAAM;IAK/B,MAAM,CAAC,MAAM,CACX,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,EAC3D,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,EAC3D,QAAQ,CAAC,EAAE,MAAM,GAChB,MAAM;IAcT,MAAM,CAAC,gBAAgB,CACrB,EAAE,EAAE,MAAM,EACV,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,EAC3D,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,GAC1D,MAAM,EAAE;CAcZ;AAED,qBAAa,MAAO,SAAQ,UAAU;IACpC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,MAAM,CAAC;gBAEL,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAY;IAOxD,OAAO,IAAI,MAAM;IAGjB,KAAK,CAAC,CAAC,EAAE,aAAa,GAAG,MAAM;IAG/B,MAAM,IAAI,MAAM;IAMhB,KAAK,CAAC,CAAC,EAAE,MAAM;IAIf,iBAAiB,IAAI,MAAM;IAI3B,QAAQ,IAAI,MAAM;IAMlB,aAAa;CAGd"}

package/lib/math/polynomials/affine.js

@@ -9,6 +9,11 @@ export class AffineConstructor {
     static fromCoeffs(coeffs) {
         return new Affine(coeffs[1], coeffs[0]);
     }
+    static randomNiceRoot() {
+        const root = randint(-10, 10, [0]);
+        const a = randint(-10, 10, [0]);
+        return new Affine(a, -root * a);
+    }
     static random(aOpts, bOpts, variable) {
         const a = randint(aOpts?.min ?? -9, aOpts?.max ?? 10, aOpts?.excludes ?? [0]);
         const b = randint(bOpts?.min ?? -9, bOpts?.max ?? 10, bOpts?.excludes ?? []);

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

@@ -5,7 +5,7 @@
 export const primeFactors = (n) => {
     // Validate input
     if (!Number.isInteger(n) || n <= 0) {
-        throw new Error("Input must be an integer greater than 1.");
+        // throw new Error("Input must be an integer greater than 1.");
         return [];
     }
     if (n === 1)

package/lib/math/utils/functions/functionComposition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"functionComposition.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/functions/functionComposition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,eAAe,EAChB,MAAM,mCAAmC,CAAC;AAU3C,OAAO,EAEL,YAAY,EACb,MAAM,4CAA4C,CAAC;AAEpD,eAAO,MAAM,qBAAqB,GAChC,aAAa,aAAa,EAC1B,cAAc,aAAa,EAC3B,eAAc,YAA2C,kBAiB1D,CAAC;AAMF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,QAAQ,EAAE,QAAQ,CAAC;CACpB,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,MAAM,aAAa,wBA4ClD,CAAC;AAMF,MAAM,MAAM,QAAQ,GAAG;IACrB,IAAI,EAAE,CAAC,WAAW,GAAG,YAAY,GAAG,OAAO,CAAC,EAAE,CAAC;CAChD,CAAC;AA6BF,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,aAAa,EAC1B,IAAI,EAAE,QAAQ,EACd,YAAY,EAAE,aAAa,EAC3B,iBAAiB,GAAE,MAAW,EAC9B,eAAe,GAAE,eAAoB,iBAsDtC"}
+{"version":3,"file":"functionComposition.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/functions/functionComposition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,eAAe,EAChB,MAAM,mCAAmC,CAAC;AAc3C,OAAO,EAEL,YAAY,EACb,MAAM,4CAA4C,CAAC;AAEpD,eAAO,MAAM,qBAAqB,GAChC,aAAa,aAAa,EAC1B,cAAc,aAAa,EAC3B,eAAc,YAA2C,kBAiB1D,CAAC;AAMF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,QAAQ,EAAE,QAAQ,CAAC;CACpB,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,MAAM,aAAa,wBA4ClD,CAAC;AAMF,MAAM,MAAM,QAAQ,GAAG;IACrB,IAAI,EAAE,CAAC,WAAW,GAAG,YAAY,GAAG,OAAO,CAAC,EAAE,CAAC;CAChD,CAAC;AA+CF,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,aAAa,EAC1B,IAAI,EAAE,QAAQ,EACd,YAAY,EAAE,aAAa,EAC3B,iBAAiB,GAAE,MAAW,EAC9B,eAAe,GAAE,eAAoB,iBA0DtC"}

package/lib/math/utils/functions/functionComposition.js

@@ -1,3 +1,4 @@
+import { isEqualNode, } from "../../../tree/nodes/equations/equalNode.js";
 import { isFunctionNode, } from "../../../tree/nodes/functions/functionNode.js";
 import { NodeConstructor } from "../../../tree/nodes/nodeConstructor.js";
 import { isOperatorNode, } from "../../../tree/nodes/operators/operatorNode.js";
@@ -11,7 +12,7 @@ export const nodeBySubstitutingVar = (nodeCarrier, nodeInjected, variableNode =
 };
 export const getAllNodePaths = (node) => {
     const arrNodePaths = [];
-    if (isOperatorNode(node)) {
+    if (isOperatorNode(node) || isEqualNode(node)) {
         getAllNodePaths(node.leftChild).forEach((nodePathWithNodes) => {
             arrNodePaths.push({
                 arrNode: [node, ...nodePathWithNodes.arrNode],
@@ -64,6 +65,16 @@ function operatorNodeByReplacingRightChild(opNode, nodeRightChildNew) {
     nodeIds.rightChild = nodeRightChildNew.toIdentifiers();
     return NodeConstructor.fromIdentifiers(nodeIds);
 }
+function equalNodeByReplacingLeftChild(equalNode, nodeLeftChildNew) {
+    const nodeIds = equalNode.toIdentifiers();
+    nodeIds.leftChild = nodeLeftChildNew.toIdentifiers();
+    return NodeConstructor.fromIdentifiers(nodeIds);
+}
+function equalNodeByReplacingRightChild(equalNode, nodeRightChildNew) {
+    const nodeIds = equalNode.toIdentifiers();
+    nodeIds.rightChild = nodeRightChildNew.toIdentifiers();
+    return NodeConstructor.fromIdentifiers(nodeIds);
+}
 export function nodeByReplacingNodeAtPath(nodeCarrier, path, nodeInjected, simplifyUpToLevel = -1, simplifyOptions = {}) {
     function getNodeForKey(node, key) {
         if (key === "leftChild" || key === "rightChild") {
@@ -83,6 +94,12 @@ export function nodeByReplacingNodeAtPath(nodeCarrier, path, nodeInjected, simpl
         else if (key === "rightChild" && isOperatorNode(node)) {
             return operatorNodeByReplacingRightChild(node, nodeInjected);
         }
+        else if (key === "leftChild" && isEqualNode(node)) {
+            return equalNodeByReplacingLeftChild(node, nodeInjected);
+        }
+        else if (key === "rightChild" && isEqualNode(node)) {
+            return equalNodeByReplacingRightChild(node, nodeInjected);
+        }
         else if (key === "child" && isFunctionNode(node)) {
             return functionNodeByReplacingChild(node, nodeInjected);
         }

package/lib/math/utils/polynomial/polynomialInterpolationUtils.d.ts

@@ -0,0 +1,19 @@
+import { AlgebraicNode } from "../../../tree/nodes/algebraicNode.js";
+import { NodeIdentifiers } from "../../../tree/nodes/nodeConstructor.js";
+export declare class PointOfFunction {
+    nodeAbscissa: AlgebraicNode;
+    nodeValue: AlgebraicNode;
+    nodeDerivative: AlgebraicNode;
+    constructor(nodeAbscissa: AlgebraicNode, nodeValue: AlgebraicNode, nodeDerivative: AlgebraicNode);
+    toIdentifiers(): PointOfFunctionIdentifiers;
+}
+export type PointOfFunctionIdentifiers = {
+    nodeIdsAbscissa: NodeIdentifiers;
+    nodeIdsValue: NodeIdentifiers;
+    nodeIdsDerivative: NodeIdentifiers;
+};
+export declare abstract class PointOfFunctionConstructor {
+    static fromIdentifiers(pofIds: PointOfFunctionIdentifiers): PointOfFunction;
+}
+export declare function createArrNodeCoeffCubic(pof1: PointOfFunction, pof2: PointOfFunction): import("../../../tree/nodes/operators/fractionNode.js").FractionNode[];
+//# sourceMappingURL=polynomialInterpolationUtils.d.ts.map

package/lib/math/utils/polynomial/polynomialInterpolationUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polynomialInterpolationUtils.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/polynomial/polynomialInterpolationUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAElE,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAO7C,qBAAa,eAAe;IAEjB,YAAY,EAAE,aAAa;IAC3B,SAAS,EAAE,aAAa;IACxB,cAAc,EAAE,aAAa;gBAF7B,YAAY,EAAE,aAAa,EAC3B,SAAS,EAAE,aAAa,EACxB,cAAc,EAAE,aAAa;IAEtC,aAAa,IAKN,0BAA0B;CAElC;AAED,MAAM,MAAM,0BAA0B,GAAG;IACvC,eAAe,EAAE,eAAe,CAAC;IACjC,YAAY,EAAE,eAAe,CAAC;IAC9B,iBAAiB,EAAE,eAAe,CAAC;CACpC,CAAC;AAEF,8BAAsB,0BAA0B;IAC9C,MAAM,CAAC,eAAe,CAAC,MAAM,EAAE,0BAA0B;CAY1D;AAED,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,eAAe,EACrB,IAAI,EAAE,eAAe,uEA0FtB"}

package/lib/math/utils/polynomial/polynomialInterpolationUtils.js

@@ -0,0 +1,53 @@
+import { opposite } from "../../../tree/nodes/functions/oppositeNode.js";
+import { NodeConstructor, } from "../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../tree/nodes/operators/substractNode.js";
+export class PointOfFunction {
+    nodeAbscissa;
+    nodeValue;
+    nodeDerivative;
+    constructor(nodeAbscissa, nodeValue, nodeDerivative) {
+        this.nodeAbscissa = nodeAbscissa;
+        this.nodeValue = nodeValue;
+        this.nodeDerivative = nodeDerivative;
+    }
+    toIdentifiers() {
+        return {
+            nodeIdsAbscissa: this.nodeAbscissa.toIdentifiers(),
+            nodeIdsValue: this.nodeValue.toIdentifiers(),
+            nodeIdsDerivative: this.nodeDerivative.toIdentifiers(),
+        };
+    }
+}
+export class PointOfFunctionConstructor {
+    static fromIdentifiers(pofIds) {
+        const nodeAbscissa = NodeConstructor.fromIdentifiers(pofIds.nodeIdsAbscissa);
+        const nodeValue = NodeConstructor.fromIdentifiers(pofIds.nodeIdsValue);
+        const nodeDerivative = NodeConstructor.fromIdentifiers(pofIds.nodeIdsDerivative);
+        return new PointOfFunction(nodeAbscissa, nodeValue, nodeDerivative);
+    }
+}
+export function createArrNodeCoeffCubic(pof1, pof2) {
+    //
+    //pof1 = {x1,u1,v1}
+    //pof2 = {x2,u2,v2}
+    //
+    //f(x)  = ax^3+bx^2+cx+d
+    //f'(x) = 2ax+b
+    //
+    //f(x1) = u1 <=> a(x1)^3+b(x1)^2+c(x1)+d = u1
+    //f(x2) = u2 <=> a(x2)^3+b(x2)^2+c(x2)+d = u2
+    //f'(x1) = v1 <=> 3a(x1)^2+2b(x1)+c = v1
+    //f'(x2) = v2 <=> 3a(x2)^2+2b(x2)+c = v2
+    //
+    const { nodeAbscissa: x1, nodeValue: u1, nodeDerivative: v1 } = pof1;
+    const { nodeAbscissa: x2, nodeValue: u2, nodeDerivative: v2 } = pof2;
+    const nodeA = frac(add(multiply(add(v1, v2), substract(x1, x2)), multiply(2, substract(u2, u1))), power(substract(x1, x2), 3));
+    const nodeB = frac(add(multiply(opposite(add(v1, multiply(2, v2))), power(x1, 2)), add(multiply(add(multiply(substract(v2, v1), x2), multiply(3, substract(u1, u2))), x1), multiply(2, multiply(x2, add(multiply(add(v1, frac(v2, 2)), x2), multiply(frac(3, 2), substract(u1, u2))))))), power(substract(x1, x2), 3));
+    const nodeC = frac(substract(add(multiply(v2, power(x1, 3)), multiply(2, multiply(add(v1, frac(v2, 2)), multiply(x2, power(x1, 2))))), add(multiply(x2, multiply(x1, add(multiply(add(v1, multiply(2, v2)), x2), multiply(6, substract(u1, u2))))), multiply(v1, power(x2, 3)))), power(substract(x1, x2), 3));
+    const nodeD = frac(substract(add(multiply(substract(u2, multiply(v2, x2)), power(x1, 3)), multiply(power(x2, 2), multiply(x1, add(multiply(v1, x2), multiply(3, u1))))), add(multiply(power(x1, 2), multiply(x2, add(multiply(substract(v1, v2), x2), multiply(3, u2)))), multiply(u1, power(x2, 3)))), power(substract(x1, x2), 3));
+    return [nodeD, nodeC, nodeB, nodeA];
+}

package/lib/math/utils/polynomial/polynomialUtils.d.ts

@@ -0,0 +1,37 @@
+import { AlgebraicNode } from "../../../tree/nodes/algebraicNode.js";
+import { VariableNode } from "../../../tree/nodes/variables/variableNode.js";
+/**
+ *
+ * @param nodeA
+ * @param arrNodeRoot
+ * @returns a(x - root1)...(x - rootn)
+ */
+export declare function createNodeFPolynomialFromRoots(nodeA: AlgebraicNode, arrNodeRoot: AlgebraicNode[]): AlgebraicNode;
+/**
+ *
+ * @param nodePolynomial
+ * @returns for example: [nodeCoeffC, nodeCoeffB, nodeCoeffA] if nodePolynomial is a trinom
+ */
+export declare function getArrNodeCoeffOfPolynomialNode(nodePolynomial: AlgebraicNode): AlgebraicNode[];
+/**
+ *
+ * @param arrNodeCoeff
+ * @returns coeffN x^N + ... + coeff2 x^2 + coeff1 x^1 + coeff0
+ */
+export declare function createNodeFPolynomialFromCoeffs(arrNodeCoeff: AlgebraicNode[]): AlgebraicNode | import("../../../tree/nodes/operators/multiplyNode.js").MultiplyNode;
+/**
+ *
+ * @param arrNodeCoeff
+ * @returns discriminator
+ */
+export declare function createNodeDiscriminator(arrNodeCoeff: AlgebraicNode[]): import("../../../tree/nodes/operators/substractNode.js").SubstractNode;
+export declare const getTexSolveSecondDegreeEquation: (nodePolynomial: AlgebraicNode, opts?: {
+    nodeVar: VariableNode;
+    isShouldApprox: boolean;
+}) => string;
+export declare const getAnswerStuffSolveSecondDegreePolynomial: (nodePolynomial: AlgebraicNode) => {
+    nodePolynomial: AlgebraicNode;
+    arrNodeX: AlgebraicNode[];
+};
+export declare function createIntegratedPolynomialNode(nodePolynomial: AlgebraicNode, nodeC: AlgebraicNode): AlgebraicNode;
+//# sourceMappingURL=polynomialUtils.d.ts.map

package/lib/math/utils/polynomial/polynomialUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polynomialUtils.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/polynomial/polynomialUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EAEd,MAAM,mCAAmC,CAAC;AAQ3C,OAAO,EAAE,YAAY,EAAE,MAAM,4CAA4C,CAAC;AAM1E;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,aAAa,EACpB,WAAW,EAAE,aAAa,EAAE,iBAO7B;AAED;;;;GAIG;AACH,wBAAgB,+BAA+B,CAAC,cAAc,EAAE,aAAa,mBAe5E;AAED;;;;GAIG;AACH,wBAAgB,+BAA+B,CAAC,YAAY,EAAE,aAAa,EAAE,qFAgB5E;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,YAAY,EAAE,aAAa,EAAE,uEAGpE;AAaD,eAAO,MAAM,+BAA+B,GAC1C,gBAAgB,aAAa,EAC7B,OAAM;IAAE,OAAO,EAAE,YAAY,CAAC;IAAC,cAAc,EAAE,OAAO,CAAA;CAGrD,WAoGF,CAAC;AAEF,eAAO,MAAM,yCAAyC,GACpD,gBAAgB,aAAa;;;CA+C9B,CAAC;AAEF,wBAAgB,8BAA8B,CAC5C,cAAc,EAAE,aAAa,EAC7B,KAAK,EAAE,aAAa,iBAQrB"}