math-exercises 2.2.26 → 2.2.28

package/lib/exercises/pc/motion/motionReference.js

@@ -4,7 +4,7 @@ exports.MotionReferenceExercise = void 0;
 const exercise_1 = require("../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
 const randint_1 = require("../../../math/utils/random/randint");
-const coinFlip_1 = require("../../../utils/coinFlip");
+const coinFlip_1 = require("../../../utils/alea/coinFlip");
 const requiresApostropheBefore_1 = require("../../../utils/strings/requiresApostropheBefore");
 const situations = [
     {

package/lib/exercises/pc/motion/typeOfAcceleration.js

@@ -5,7 +5,7 @@ const exercise_1 = require("../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
 const geogebraConstructor_1 = require("../../../geogebra/geogebraConstructor");
 const randint_1 = require("../../../math/utils/random/randint");
-const random_1 = require("../../../utils/random");
+const random_1 = require("../../../utils/alea/random");
 const getTypeOfAccelerationQuestion = () => {
     const exo = generateExo();
     const question = {

package/lib/exercises/pc/motion/typeOfMovement.js

@@ -6,7 +6,7 @@ const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQues
 const geogebraConstructor_1 = require("../../../geogebra/geogebraConstructor");
 const affine_1 = require("../../../math/polynomials/affine");
 const randint_1 = require("../../../math/utils/random/randint");
-const random_1 = require("../../../utils/random");
+const random_1 = require("../../../utils/alea/random");
 const getTypeOfMovementQuestion = () => {
     const exo = generateExercise();
     const ggb = exo.ggb;

package/lib/exercises/pc/pH.js

@@ -6,7 +6,7 @@ const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestio
 const frenchify_1 = require("../../math/utils/latex/frenchify");
 const randint_1 = require("../../math/utils/random/randint");
 const round_1 = require("../../math/utils/round");
-const shuffle_1 = require("../../utils/shuffle");
+const shuffle_1 = require("../../utils/alea/shuffle");
 const getpH = () => {
     const randomNumber = (0, randint_1.randint)(1, 10);
     const randomTenPower = (0, randint_1.randint)(2, 10);

package/lib/exercises/pc/perceivedFrequency.js

@@ -6,7 +6,7 @@ const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestio
 const frenchify_1 = require("../../math/utils/latex/frenchify");
 const randint_1 = require("../../math/utils/random/randint");
 const round_1 = require("../../math/utils/round");
-const shuffle_1 = require("../../utils/shuffle");
+const shuffle_1 = require("../../utils/alea/shuffle");
 const soundSpeed = 340; // Vitesse du son dans l'air en m/s
 const observerSpeed = 0; // La vitesse de l'observateur est supposée être nulle (observateur immobile)
 const getPerceivedFrequency = () => {

package/lib/exercises/pc/potentialEnergy.js

@@ -10,7 +10,7 @@ const measure_1 = require("../../pc/measure/measure");
 const distanceUnits_1 = require("../../pc/units/distanceUnits");
 const energyUnit_1 = require("../../pc/units/energyUnit");
 const massUnits_1 = require("../../pc/units/massUnits");
-const shuffle_1 = require("../../utils/shuffle");
+const shuffle_1 = require("../../utils/alea/shuffle");
 const getPotentialEnergy = () => {
     const mass = Math.floor(Math.random() * 10 + 1); // Masse de l'objet entre 1 et 11 kg
     const massMeasure = new measure_1.Measure(mass, 0, massUnits_1.MassUnit.kg);

package/lib/exercises/pc/recognizeRefractionOrReflectionAngles.js

@@ -6,7 +6,7 @@ const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestio
 const colors_1 = require("../../geogebra/colors");
 const geogebraConstructor_1 = require("../../geogebra/geogebraConstructor");
 const randint_1 = require("../../math/utils/random/randint");
-const random_1 = require("../../utils/random");
+const random_1 = require("../../utils/alea/random");
 const IsAsking = {
     RefractionAngle: "Angle de réfraction",
     ReflectionAngle: "Angle de réflexion",

package/lib/exercises/pc/snellDescartes.js

@@ -6,7 +6,7 @@ const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestio
 const frenchify_1 = require("../../math/utils/latex/frenchify");
 const randint_1 = require("../../math/utils/random/randint");
 const round_1 = require("../../math/utils/round");
-const shuffle_1 = require("../../utils/shuffle");
+const shuffle_1 = require("../../utils/alea/shuffle");
 const refractionIndex = [
     { Material: "l'air", Material2: "d'air", Material3: "de l'air", n: 1 },
     { Material: "l'eau", Material2: "d'eau", Material3: "de l'eau", n: 1.33 },

package/lib/exercises/pc/sound/findPeriodFromGraph.js

@@ -7,7 +7,7 @@ const colors_1 = require("../../../geogebra/colors");
 const geogebraConstructor_1 = require("../../../geogebra/geogebraConstructor");
 const randfloat_1 = require("../../../math/utils/random/randfloat");
 const randint_1 = require("../../../math/utils/random/randint");
-const coinFlip_1 = require("../../../utils/coinFlip");
+const coinFlip_1 = require("../../../utils/alea/coinFlip");
 const getFindPeriodFromGraphQuestion = () => {
     const period = (0, randint_1.randint)(2, 5);
     const yStart = (0, randint_1.randint)(0, 4);

package/lib/exercises/pc/sound/findPeriodOrFrequencyFromGraph.js

@@ -7,7 +7,7 @@ const colors_1 = require("../../../geogebra/colors");
 const geogebraConstructor_1 = require("../../../geogebra/geogebraConstructor");
 const randfloat_1 = require("../../../math/utils/random/randfloat");
 const randint_1 = require("../../../math/utils/random/randint");
-const coinFlip_1 = require("../../../utils/coinFlip");
+const coinFlip_1 = require("../../../utils/alea/coinFlip");
 const isInt_1 = require("../../../utils/isInt");
 const getFindPeriodOrFrequencyFromGraphQuestion = () => {
     const period = (0, randint_1.randint)(2, 5);

package/lib/exercises/pc/sound/frequencyComparison.js

@@ -4,7 +4,7 @@ exports.frequencyComparison = void 0;
 const exercise_1 = require("../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
 const randint_1 = require("../../../math/utils/random/randint");
-const coinFlip_1 = require("../../../utils/coinFlip");
+const coinFlip_1 = require("../../../utils/alea/coinFlip");
 const getFrequencyComparisonQuestion = () => {
     const soundAsked = (0, coinFlip_1.coinFlip)() ? 1 : 2;
     const soundCompared = soundAsked === 1 ? 2 : 1;

package/lib/exercises/pc/waves/lightDistanceConversion.js

@@ -7,7 +7,7 @@ const randfloat_1 = require("../../../math/utils/random/randfloat");
 const randint_1 = require("../../../math/utils/random/randint");
 const waves_1 = require("../../../pc/constants/mechanics/waves");
 const measure_1 = require("../../../pc/measure/measure");
-const coinFlip_1 = require("../../../utils/coinFlip");
+const coinFlip_1 = require("../../../utils/alea/coinFlip");
 const getLightDistanceConversionQuestion = () => {
     const lightYear = (0, randfloat_1.randfloat)(10, 1000, 2);
     const speed = waves_1.lightSpeed.measure;

package/lib/exercises/pc/waves/periodicWaveCelerity.js

@@ -5,7 +5,7 @@ const exercise_1 = require("../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
 const randfloat_1 = require("../../../math/utils/random/randfloat");
 const round_1 = require("../../../math/utils/round");
-const random_1 = require("../../../utils/random");
+const random_1 = require("../../../utils/alea/random");
 // v = lambda / T
 const getPeriodicWaveCelerityQuestion = () => {
     const varAsked = (0, random_1.random)(["v", "T", "l"]);

package/lib/exercises/pc/weight/weightOnTheMoon.js

@@ -7,7 +7,7 @@ const frenchify_1 = require("../../../math/utils/latex/frenchify");
 const randfloat_1 = require("../../../math/utils/random/randfloat");
 const round_1 = require("../../../math/utils/round");
 const gravitational_1 = require("../../../pc/constants/mechanics/gravitational");
-const coinFlip_1 = require("../../../utils/coinFlip");
+const coinFlip_1 = require("../../../utils/alea/coinFlip");
 const getWeightOnTheMoonQuestion = () => {
     const originIsMoon = (0, coinFlip_1.coinFlip)();
     const origin = originIsMoon ? "Lune" : "Terre";

package/lib/exercises/utils/getDistinctQuestions.d.ts

@@ -7,5 +7,5 @@ export declare function equalTab<T>(array1: T[], array2: T[]): boolean;
  * @param max included
  * @returns
  */
-export declare const getDistinctQuestions: (generator: () => Question<any>, nb: number, max?: number) => Question<any>[];
+export declare const getDistinctQuestions: (generator: () => Question<any>, nb: number, max?: number, discriminator?: ((q1: Question<any>, q2: Question<any>) => boolean) | undefined) => Question<any>[];
 //# sourceMappingURL=getDistinctQuestions.d.ts.map

package/lib/exercises/utils/getDistinctQuestions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getDistinctQuestions.d.ts","sourceRoot":"","sources":["../../../src/exercises/utils/getDistinctQuestions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,WAOnD;AAED;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,cACpB,MAAM,SAAS,GAAG,CAAC,MAC1B,MAAM,QACJ,MAAM,KACX,SAAS,GAAG,CAAC,EAoBf,CAAC"}
+{"version":3,"file":"getDistinctQuestions.d.ts","sourceRoot":"","sources":["../../../src/exercises/utils/getDistinctQuestions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,WAOnD;AAED;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,cACpB,MAAM,SAAS,GAAG,CAAC,MAC1B,MAAM,QACJ,MAAM,wBACS,SAAS,GAAG,CAAC,MAAM,SAAS,GAAG,CAAC,KAAK,OAAO,kBAChE,SAAS,GAAG,CAAC,EAaf,CAAC"}

package/lib/exercises/utils/getDistinctQuestions.js

@@ -21,19 +21,25 @@ exports.equalTab = equalTab;
  * @param max included
  * @returns
  */
-const getDistinctQuestions = (generator, nb, max) => {
+const getDistinctQuestions = (generator, nb, max, discriminator) => {
     const res = [];
     const trueStop = max === undefined ? nb : Math.min(nb, max);
     for (let i = 0; i < trueStop ?? nb; i++) {
         let question;
         do {
             question = generator();
-        } while (res.some((q) => q.instruction === question.instruction &&
-            q.answer === question.answer &&
-            (!q.ggbOptions?.commands ||
-                equalTab(q.ggbOptions?.commands, question.ggbOptions?.commands))));
+        } while (res.some((q) => compare(q, question, discriminator)));
         res.push(question);
     }
     return res;
 };
 exports.getDistinctQuestions = getDistinctQuestions;
+const compare = (q1, q2, discriminator) => {
+    if (!!discriminator) {
+        return discriminator(q1, q2);
+    }
+    return (q1.instruction === q2.instruction &&
+        q1.answer === q2.answer &&
+        (!q1.ggbOptions?.commands ||
+            equalTab(q1.ggbOptions?.commands, q2.ggbOptions?.commands)));
+};

package/lib/geogebra/colors.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.randomColor = exports.colors = exports.purples = exports.purpleDark = exports.purpleMain = exports.purpleLight = exports.blues = exports.blueExtraDark = exports.blueMain = exports.blueDark = exports.blueLight = exports.greens = exports.greenDark = exports.greenMain = exports.greenLight = exports.oranges = exports.orangeLight = exports.orange = exports.orangeDark = exports.reds = exports.pinkLight = exports.pinkMain = exports.pinkDark = exports.red = void 0;
-const random_1 = require("../utils/random");
+const random_1 = require("../utils/alea/random");
 exports.red = "#FF3333";
 exports.pinkDark = "#A10039";
 exports.pinkMain = "#D83F63";

package/lib/geogebra/geogebraConstructor.js

@@ -5,7 +5,7 @@ const toolBarConstructor_1 = require("../exercises/utils/geogebra/toolBarConstru
 class GeogebraConstructor {
     constructor(options) {
         this.customToolBar = options?.customToolBar ?? (0, toolBarConstructor_1.toolBarConstructor)({});
-        this.forbidShiftDragZoom = options?.forbidShiftDragZoom;
+        this.forbidShiftDragZoom = options?.forbidShiftDragZoom ?? false;
         this.commands = options.commands;
         this.is3D = options?.is3D;
         this.gridDistance = options?.gridDistance ?? [1, 1];

package/lib/geogebra/parsers/ggbPointToCoords.d.ts

@@ -0,0 +1,5 @@
+export declare const ggbPointToCoords: (point: string) => {
+    x: number;
+    y: number;
+};
+//# sourceMappingURL=ggbPointToCoords.d.ts.map

package/lib/geogebra/parsers/ggbPointToCoords.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ggbPointToCoords.d.ts","sourceRoot":"","sources":["../../../src/geogebra/parsers/ggbPointToCoords.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,UAAW,MAAM;;;CAO7C,CAAC"}

package/lib/geogebra/parsers/ggbPointToCoords.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ggbPointToCoords = void 0;
+const ggbPointToCoords = (point) => {
+    const [x, y] = point
+        .replace("(", "")
+        .replace(")", "")
+        .split(",")
+        .map(parseFloat);
+    return { x, y };
+};
+exports.ggbPointToCoords = ggbPointToCoords;

package/lib/geogebra/parsers/parseGGBPoints.d.ts

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

package/lib/geogebra/parsers/parseGGBPoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseGGBPoints.d.ts","sourceRoot":"","sources":["../../../src/geogebra/parsers/parseGGBPoints.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc,aAAc,MAAM,EAAE,aAIhD,CAAC"}

package/lib/geogebra/parsers/parseGGBPoints.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseGGBPoints = void 0;
+const deleteObjectNamesFromAnswer_1 = require("../deleteObjectNamesFromAnswer");
+const parseGGBPoints = (commands) => {
+    const unnamed = (0, deleteObjectNamesFromAnswer_1.deleteObjectNamesFromAnswer)(commands);
+    const re = /\([^,]*,[^)]*\)/;
+    return unnamed.filter((cmd) => !!cmd.match(re)?.length);
+};
+exports.parseGGBPoints = parseGGBPoints;

package/lib/index.d.ts

@@ -833,6 +833,34 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
 }> | import("./exercises/exercise").Exercise<{
     x: number;
     y: number;
+}> | import("./exercises/exercise").Exercise<{
+    abscissType: import("./math/numbers/nombre").NumberType;
+    axisUnit: number;
+    oneUnitTex: string;
+    absciss: number;
+    abscissTex: string;
+    coeff: number;
+}> | import("./exercises/exercise").Exercise<{
+    abscissType: import("./math/numbers/nombre").NumberType;
+    axisUnit: number;
+    oneUnitTex: string;
+    absciss: number;
+    abscissTex: string;
+    coeff: number;
+}> | import("./exercises/exercise").Exercise<{
+    abscissType: import("./math/numbers/nombre").NumberType;
+    axisUnit: number;
+    oneUnitTex: string;
+    absciss: number;
+    abscissTex: string;
+    coeff: number;
+}> | import("./exercises/exercise").Exercise<{
+    abscissType: import("./math/numbers/nombre").NumberType;
+    axisUnit: number;
+    oneUnitTex: string;
+    absciss: number;
+    abscissTex: string;
+    coeff: number;
 }> | import("./exercises/exercise").Exercise<{
     coin: boolean;
     radius: number;
@@ -1068,6 +1096,20 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     ttc: number;
     ht: number;
     tva: number;
+}> | import("./exercises/exercise").Exercise<{
+    vd: number;
+    vf: number;
+}> | import("./exercises/exercise").Exercise<{
+    vf: number;
+    percentRate: number;
+}> | import("./exercises/exercise").Exercise<{
+    contextType: number;
+    total: number;
+    populationPercent: number;
+}> | import("./exercises/exercise").Exercise<{
+    subPopulationEffectif: number;
+    subPopulationPercent: number;
+    contextType: number;
 }> | import("./exercises/exercise").Exercise<{
     int: number;
     power: number;
@@ -1409,6 +1451,25 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
 }> | import("./exercises/exercise").Exercise<{
     degree: number;
     trigoFunct: string;
+}> | import("./exercises/exercise").Exercise<{
+    degree: number;
+}> | import("./exercises/exercise").Exercise<{
+    degree: number;
+}> | import("./exercises/exercise").Exercise<{
+    degree: number;
+}> | import("./exercises/exercise").Exercise<{
+    degree: number;
+    multipleOf2PiToAdd: number;
+    nodeIds: any;
+}> | import("./exercises/exercise").Exercise<{
+    degree: number;
+    radianNodeIds: any;
+    isDegreeToRadian: boolean;
+}> | import("./exercises/exercise").Exercise<{
+    radius: number;
+    thetaInDegree: number | undefined;
+    thetaInRadNodeIds: any;
+    isThetaInDegree: boolean;
 }> | import("./exercises/exercise").Exercise<{
     exercise: {
         a: number;

package/lib/index.d.ts.map

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

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

@@ -1 +1 @@
-{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/line.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AAEvF,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAQjE,OAAO,EAAE,KAAK,EAAoB,MAAM,SAAS,CAAC;AAClD,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC,8BAAsB,eAAe;IACnC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM;CAK5B;AACD,qBAAa,IAAI;IACf,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;IACd,UAAU,EAAE,OAAO,CAAC;IACpB,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;gBACJ,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM;IAoBvD,YAAY,CAAC,KAAK,EAAE,KAAK;IASzB,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,GAAE,OAAe;IAgBnD,cAAc,CAAC,IAAI,CAAC,EAAE,MAAM;IAa5B,WAAW,MAAO,MAAM,KAAK,KAAK,KAAG,SAAS,CAmB5C;IAEF,oBAAoB,IAAI,SAAS;IAuBjC,KAAK;IAGL,gBAAgB;IAIhB,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,GACjC,GAAE,kBAAuB;CAoB7B"}
+{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/line.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AAEvF,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAQjE,OAAO,EAAE,KAAK,EAAoB,MAAM,SAAS,CAAC;AAClD,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC,8BAAsB,eAAe;IACnC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM;CAK5B;AACD,qBAAa,IAAI;IACf,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;IACd,UAAU,EAAE,OAAO,CAAC;IACpB,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;gBACJ,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM;IAoBvD,YAAY,CAAC,KAAK,EAAE,KAAK;IASzB,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,GAAE,OAAe;IAenD,cAAc,CAAC,IAAI,CAAC,EAAE,MAAM;IAa5B,WAAW,MAAO,MAAM,KAAK,KAAK,KAAG,SAAS,CAmB5C;IAEF,oBAAoB,IAAI,SAAS;IAuBjC,KAAK;IAGL,gBAAgB;IAIhB,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,GACjC,GAAE,kBAAuB;CAoB7B"}

package/lib/math/geometry/line.js

@@ -66,7 +66,6 @@ class Line {
                 return point.x.equals(this.pointA.x);
         }
         const evaluation = new substractNode_1.SubstractNode(point.y, new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(this.a, point.x), this.b)).evaluate({});
-        console.log("eval", evaluation);
         if (allowApprox) {
             return Math.abs(evaluation) < 0.0000001;
         }

package/lib/math/inequations/inequation.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InequationSymbol = exports.InequationSymbolConstructor = void 0;
-const random_1 = require("../../utils/random");
+const random_1 = require("../../utils/alea/random");
 class InequationSymbolConstructor {
     static random() {
         return new InequationSymbol((0, random_1.random)(["<", ">", "\\le", "\\ge"]));

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

@@ -18,6 +18,7 @@ export declare class Decimal implements Nombre {
     intPart: number;
     decimalPart: string;
     constructor(value: number | string);
+    times(n: Nombre | number): Decimal;
     equals(n: Nombre): boolean;
     /**
      *

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":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,sCAAsC,CAAC;AACnE,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AAEvE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEjD,eAAO,MAAM,iBAAiB,UAAyC,CAAC;AACxE,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,GAAE,MAAU,GAAG,MAAM;IAY1E,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,GAAG,MAAM;IASlC,MAAM,CAAC,CAAC,EAAE,MAAM;IAIhB;;;;OAIG;IACH,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAIhC,oBAAoB,CAAC,KAAK,EAAE,MAAM;IAkClC,gBAAgB;IA6BhB,oBAAoB,CAAC,QAAQ,CAAC,EAAE,MAAM;IAwCtC,cAAc,CAAC,IAAI,EAAE,MAAM;IAS3B,UAAU;IAMV,MAAM;IAIN,aAAa;IAIb,YAAY,CAAC,UAAU,EAAE,MAAM;IAS/B,YAAY,CAAC,UAAU,EAAE,MAAM;CAShC"}
+{"version":3,"file":"decimal.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/decimals/decimal.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,sCAAsC,CAAC;AACnE,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AAEvE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEjD,eAAO,MAAM,iBAAiB,UAAyC,CAAC;AACxE,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,GAAE,MAAU,GAAG,MAAM;IAY1E,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,GAAG,MAAM;IAQlC,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IASxB,MAAM,CAAC,CAAC,EAAE,MAAM;IAIhB;;;;OAIG;IACH,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAIhC,oBAAoB,CAAC,KAAK,EAAE,MAAM;IAkClC,gBAAgB;IA6BhB,oBAAoB,CAAC,QAAQ,CAAC,EAAE,MAAM;IAwCtC,cAAc,CAAC,IAAI,EAAE,MAAM;IAS3B,UAAU;IAMV,MAAM;IAIN,aAAa;IAIb,YAAY,CAAC,UAAU,EAAE,MAAM;IAS/B,YAAY,CAAC,UAAU,EAAE,MAAM;CAShC"}

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

@@ -54,6 +54,16 @@ class Decimal {
         this.decimalPart = decimalPartString || "";
         this.precision = this.decimalPart.length;
     }
+    times(n) {
+        if (typeof n === "number")
+            return new Decimal((0, round_1.round)(this.value * n, 10));
+        throw Error("unimplemnented");
+        // if (n.type === NumberType.Real) {
+        //   throw Error("decimal times real not implemented");
+        // }
+        // if (n.type === NumberType.Rational)
+        //   throw Error("decimal times real not implemented");
+    }
     equals(n) {
         return this.value === n.value;
     }

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

@@ -1,4 +1,5 @@
 import { NumberNode } from "../../../tree/nodes/numbers/numberNode";
+import { Decimal } from "../decimals/decimal";
 import { Nombre, NumberType } from "../nombre";
 import { Rational } from "../rationals/rational";
 export declare const integerDigitRanks: string[];
@@ -14,6 +15,7 @@ export declare class Integer implements Nombre {
     constructor(value: number, tex?: string);
     equals(n: Nombre): boolean;
     toTree(): NumberNode;
+    times(n: number | Nombre): Integer | Decimal;
     round(precision: number): Integer;
     divide(nb: Nombre): Nombre;
     multiply(nb: Nombre): Rational | Integer;

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

@@ -1 +1 @@
-{"version":3,"file":"integer.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/integer/integer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAEjE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGjD,eAAO,MAAM,iBAAiB,UAK7B,CAAC;AACF,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE;IAGrD,MAAM,CAAC,WAAW,CAAC,GAAG,GAAE,MAAW;IAGnC,MAAM,CAAC,gBAAgB,CACrB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,EAAE,EAAE,MAAM,EACV,QAAQ,CAAC,EAAE,MAAM,EAAE;CAYtB;AAED,qBAAa,OAAQ,YAAW,MAAM;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;gBAEL,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM;IAMvC,MAAM,CAAC,CAAC,EAAE,MAAM;IAGhB,MAAM;IAIN,KAAK,CAAC,SAAS,EAAE,MAAM;IAkCvB,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAc1B,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO;IAYxC,QAAQ;IAGR,GAAG,CAAC,EAAE,EAAE,MAAM;CAYf"}
+{"version":3,"file":"integer.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/integer/integer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAEjE,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAC9C,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGjD,eAAO,MAAM,iBAAiB,UAK7B,CAAC;AACF,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE;IAGrD,MAAM,CAAC,WAAW,CAAC,GAAG,GAAE,MAAW;IAGnC,MAAM,CAAC,gBAAgB,CACrB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,EAAE,EAAE,MAAM,EACV,QAAQ,CAAC,EAAE,MAAM,EAAE;CAYtB;AAED,qBAAa,OAAQ,YAAW,MAAM;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;gBAEL,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM;IAMvC,MAAM,CAAC,CAAC,EAAE,MAAM;IAGhB,MAAM;IAIN,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAMxB,KAAK,CAAC,SAAS,EAAE,MAAM;IAkCvB,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAc1B,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO;IAYxC,QAAQ;IAGR,GAAG,CAAC,EAAE,EAAE,MAAM;CAYf"}

package/lib/math/numbers/integer/integer.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Integer = exports.IntegerConstructor = exports.integerDigitRanks = void 0;
 const randint_1 = require("../../../math/utils/random/randint");
 const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
-const random_1 = require("../../../utils/random");
+const random_1 = require("../../../utils/alea/random");
 const nombre_1 = require("../nombre");
 const rational_1 = require("../rationals/rational");
 const primes_1 = require("./primes");
@@ -45,6 +45,15 @@ class Integer {
     toTree() {
         return new numberNode_1.NumberNode(this.value, this.tex);
     }
+    times(n) {
+        if (typeof n === "number")
+            return new Integer(this.value * n);
+        if (n.type === nombre_1.NumberType.Integer)
+            return new Integer(this.value * n.value);
+        if (n.type === nombre_1.NumberType.Decimal)
+            return n.times(n);
+        throw Error("unimplemented");
+    }
     round(precision) {
         const intString = this.value + "";
         if (precision >= intString.length || precision < 1)

package/lib/math/numbers/nombre.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NombreConstructor = exports.NumberType = void 0;
-const random_1 = require("../../utils/random");
+const random_1 = require("../../utils/alea/random");
 const randint_1 = require("../utils/random/randint");
 const decimal_1 = require("./decimals/decimal");
 const integer_1 = require("./integer/integer");

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

@@ -8,9 +8,9 @@ const randint_1 = require("../../../math/utils/random/randint");
 const oppositeNode_1 = require("../../../tree/nodes/functions/oppositeNode");
 const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
 const fractionNode_1 = require("../../../tree/nodes/operators/fractionNode");
-const coinFlip_1 = require("../../../utils/coinFlip");
-const random_1 = require("../../../utils/random");
-const shuffle_1 = require("../../../utils/shuffle");
+const coinFlip_1 = require("../../../utils/alea/coinFlip");
+const random_1 = require("../../../utils/alea/random");
+const shuffle_1 = require("../../../utils/alea/shuffle");
 const integer_1 = require("../integer/integer");
 const nombre_1 = require("../nombre");
 class RationalConstructor {

package/lib/math/numbers/reals/real.js

@@ -8,8 +8,8 @@ const sqrtNode_1 = require("../../../tree/nodes/functions/sqrtNode");
 const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
 const piNode_1 = require("../../../tree/nodes/numbers/piNode");
 const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
-const diceFlip_1 = require("../../../utils/diceFlip");
-const random_1 = require("../../../utils/random");
+const diceFlip_1 = require("../../../utils/alea/diceFlip");
+const random_1 = require("../../../utils/alea/random");
 const integer_1 = require("../integer/integer");
 const primes_1 = require("../integer/primes");
 const nombre_1 = require("../nombre");

package/lib/math/polynomials/polynomial.js

@@ -8,7 +8,7 @@ const oppositeNode_1 = require("../../tree/nodes/functions/oppositeNode");
 const powerNode_1 = require("../../tree/nodes/operators/powerNode");
 const variableNode_1 = require("../../tree/nodes/variables/variableNode");
 const randint_1 = require("../../math/utils/random/randint");
-const coinFlip_1 = require("../../utils/coinFlip");
+const coinFlip_1 = require("../../utils/alea/coinFlip");
 const rational_1 = require("../numbers/rationals/rational");
 const infiniteNode_1 = require("../../tree/nodes/numbers/infiniteNode");
 class PolynomialConstructor {

package/lib/math/polynomials/trinom.js

@@ -15,7 +15,7 @@ const polynomial_1 = require("./polynomial");
 const oppositeNode_1 = require("../../tree/nodes/functions/oppositeNode");
 const gcd_1 = require("../utils/arithmetic/gcd");
 const randint_1 = require("../utils/random/randint");
-const random_1 = require("../../utils/random");
+const random_1 = require("../../utils/alea/random");
 const colors_1 = require("../../geogebra/colors");
 class TrinomConstructor {
     static random(aOpts, bOpts, cOpts) {

package/lib/math/sequences/geometricSequence.d.ts

@@ -1,5 +1,5 @@
-import { MultiplyNode } from '../../tree/nodes/operators/multiplyNode';
-import { Nombre, NumberType } from '../numbers/nombre';
+import { MultiplyNode } from "../../tree/nodes/operators/multiplyNode";
+import { Nombre, NumberType } from "../numbers/nombre";
 export declare abstract class GeometricSequenceConstructor {
     static random(reasonType?: NumberType): GeometricSequence;
     static randomWithLimit(reasonType?: NumberType): GeometricSequence;

package/lib/math/sequences/geometricSequence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometricSequence.d.ts","sourceRoot":"","sources":["../../../src/math/sequences/geometricSequence.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AAOvE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAIvD,8BAAsB,4BAA4B;IAChD,MAAM,CAAC,MAAM,CAAC,UAAU,GAAE,UAA+B;IAkBzD,MAAM,CAAC,eAAe,CAAC,UAAU,CAAC,EAAE,UAAU;CAsB/C;AAED,qBAAa,iBAAiB;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;gBAEH,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAK7C,QAAQ;IAMR,MAAM;CAKP"}
+{"version":3,"file":"geometricSequence.d.ts","sourceRoot":"","sources":["../../../src/math/sequences/geometricSequence.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AAOvE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAIvD,8BAAsB,4BAA4B;IAChD,MAAM,CAAC,MAAM,CAAC,UAAU,GAAE,UAA+B;IAoBzD,MAAM,CAAC,eAAe,CAAC,UAAU,CAAC,EAAE,UAAU;CA2B/C;AAED,qBAAa,iBAAiB;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;gBAEH,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAK7C,QAAQ;IAOR,MAAM;CASP"}

package/lib/math/sequences/geometricSequence.js

@@ -4,8 +4,8 @@ exports.GeometricSequence = exports.GeometricSequenceConstructor = void 0;
 const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
 const powerNode_1 = require("../../tree/nodes/operators/powerNode");
 const variableNode_1 = require("../../tree/nodes/variables/variableNode");
-const coinFlip_1 = require("../../utils/coinFlip");
-const random_1 = require("../../utils/random");
+const coinFlip_1 = require("../../utils/alea/coinFlip");
+const random_1 = require("../../utils/alea/random");
 const decimal_1 = require("../numbers/decimals/decimal");
 const integer_1 = require("../numbers/integer/integer");
 const nombre_1 = require("../numbers/nombre");
@@ -14,7 +14,8 @@ const randint_1 = require("../utils/random/randint");
 class GeometricSequenceConstructor {
     static random(reasonType = nombre_1.NumberType.Integer) {
         let reason;
-        const type = reasonType ?? (0, random_1.random)([nombre_1.NumberType.Decimal, nombre_1.NumberType.Integer, nombre_1.NumberType.Rational]);
+        const type = reasonType ??
+            (0, random_1.random)([nombre_1.NumberType.Decimal, nombre_1.NumberType.Integer, nombre_1.NumberType.Rational]);
         switch (type) {
             case nombre_1.NumberType.Decimal:
                 reason = decimal_1.DecimalConstructor.random(-9, 10);
@@ -26,18 +27,19 @@ class GeometricSequenceConstructor {
                 reason = rational_1.RationalConstructor.randomIrreductible();
                 break;
             case nombre_1.NumberType.Real:
-                throw Error('real geometric reason not supported yet');
+                throw Error("real geometric reason not supported yet");
         }
         return new GeometricSequence(new integer_1.Integer((0, randint_1.randint)(-9, 10, [0, 1])), reason);
     }
     static randomWithLimit(reasonType) {
         let reason;
-        const type = reasonType ?? (0, random_1.random)([nombre_1.NumberType.Decimal, nombre_1.NumberType.Integer, nombre_1.NumberType.Rational]);
+        const type = reasonType ??
+            (0, random_1.random)([nombre_1.NumberType.Decimal, nombre_1.NumberType.Integer, nombre_1.NumberType.Rational]);
         switch (type) {
             case nombre_1.NumberType.Decimal:
                 const precision = (0, randint_1.randint)(1, 4);
                 reason = (0, coinFlip_1.coinFlip)()
-                    ? decimal_1.DecimalConstructor.fromParts((0, coinFlip_1.coinFlip)() ? '0' : '-0', decimal_1.DecimalConstructor.randomFracPart(precision))
+                    ? decimal_1.DecimalConstructor.fromParts((0, coinFlip_1.coinFlip)() ? "0" : "-0", decimal_1.DecimalConstructor.randomFracPart(precision))
                     : decimal_1.DecimalConstructor.random(1, 10);
                 break;
             case nombre_1.NumberType.Integer:
@@ -47,7 +49,7 @@ class GeometricSequenceConstructor {
                 reason = rational_1.RationalConstructor.randomIrreductible();
                 break;
             case nombre_1.NumberType.Real:
-                throw Error('real geometric reason not supported yet');
+                throw Error("real geometric reason not supported yet");
         }
         return new GeometricSequence(new integer_1.Integer((0, randint_1.randint)(-9, 10, [0, 1])), reason);
     }
@@ -62,13 +64,13 @@ class GeometricSequence {
         if (this.reason.value <= -1)
             return null;
         if (this.reason.value === 1)
-            return this.firstTerm + '';
+            return this.firstTerm + "";
         if (this.reason.value > 1)
-            return this.firstTerm.value > 0 ? '+\\infty' : '-\\infty';
-        return '0';
+            return this.firstTerm.value > 0 ? "+\\infty" : "-\\infty";
+        return "0";
     }
     toTree() {
-        return new multiplyNode_1.MultiplyNode(this.firstTerm.toTree(), new powerNode_1.PowerNode(this.reason.toTree(), new variableNode_1.VariableNode('n')), {
+        return new multiplyNode_1.MultiplyNode(this.firstTerm.toTree(), new powerNode_1.PowerNode(this.reason.toTree(), new variableNode_1.VariableNode("n")), {
             forceTimesSign: true,
         });
     }