math-exercises 2.2.27 → 2.2.28

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/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");

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,
         });
     }

package/lib/math/sets/discreteSet.d.ts

@@ -1,5 +1,5 @@
-import { Nombre } from '../numbers/nombre';
-import { MathSetInterface } from './mathSetInterface';
+import { Nombre } from "../numbers/nombre";
+import { MathSetInterface } from "./mathSetInterface";
 export declare class DiscreteSet implements MathSetInterface {
     elements: Nombre[];
     tex: string;

package/lib/math/sets/discreteSet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"discreteSet.d.ts","sourceRoot":"","sources":["../../../src/math/sets/discreteSet.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC3C,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtD,qBAAa,WAAY,YAAW,gBAAgB;IAClD,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC;gBACA,QAAQ,EAAE,MAAM,EAAE;IAW9B,KAAK,IAAI,MAAM;IAIf,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAI7B,gBAAgB,IAAI,MAAM;CAG3B"}
+{"version":3,"file":"discreteSet.d.ts","sourceRoot":"","sources":["../../../src/math/sets/discreteSet.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC3C,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtD,qBAAa,WAAY,YAAW,gBAAgB;IAClD,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC;gBACA,QAAQ,EAAE,MAAM,EAAE;IAW9B,KAAK,IAAI,MAAM;IAIf,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAM7B,gBAAgB,IAAI,MAAM;CAG3B"}

package/lib/math/sets/discreteSet.js

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DiscreteSet = void 0;
-const random_1 = require("../../utils/random");
+const random_1 = require("../../utils/alea/random");
 class DiscreteSet {
     constructor(elements) {
         this.elements = Array.from(new Set(elements));
-        let tex = '\\{';
+        let tex = "\\{";
         this.elements.forEach((el, index) => {
             tex += el.tex;
             if (index < this.elements.length - 1)
-                tex += ';';
+                tex += ";";
             else
-                tex += '\\}';
+                tex += "\\}";
         });
         this.tex = tex;
     }

package/lib/math/sets/intervals/intervals.js

@@ -6,7 +6,7 @@ const infiniteNode_1 = require("../../../tree/nodes/numbers/infiniteNode");
 const closure_1 = require("../../../tree/nodes/sets/closure");
 const discreteSetNode_1 = require("../../../tree/nodes/sets/discreteSetNode");
 const intervalNode_1 = require("../../../tree/nodes/sets/intervalNode");
-const coinFlip_1 = require("../../../utils/coinFlip");
+const coinFlip_1 = require("../../../utils/alea/coinFlip");
 const mathSet_1 = require("../mathSet");
 class IntervalConstructor {
     static random() {

package/lib/math/trigonometry/remarkableValue.js

@@ -5,7 +5,7 @@ const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
 const piNode_1 = require("../../tree/nodes/numbers/piNode");
 const addNode_1 = require("../../tree/nodes/operators/addNode");
 const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
-const random_1 = require("../../utils/random");
+const random_1 = require("../../utils/alea/random");
 const randint_1 = require("../utils/random/randint");
 const remarkableValues_1 = require("./remarkableValues");
 class RemarkableValueConstructor {

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

@@ -7,5 +7,8 @@ export interface RemarkableValue {
     tan: AlgebraicNode;
     point: string;
 }
+export declare const negativeMainTrigovalues: RemarkableValue[];
 export declare const remarkableTrigoValues: RemarkableValue[];
+export declare const mainTrigoValues: RemarkableValue[];
+export declare const mainPositiveTrigovalues: RemarkableValue[];
 //# sourceMappingURL=remarkableValues.d.ts.map

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

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

package/lib/math/trigonometry/remarkableValues.js

@@ -1,12 +1,78 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.remarkableTrigoValues = void 0;
+exports.mainPositiveTrigovalues = exports.mainTrigoValues = exports.remarkableTrigoValues = exports.negativeMainTrigovalues = void 0;
 const oppositeNode_1 = require("../../tree/nodes/functions/oppositeNode");
 const sqrtNode_1 = require("../../tree/nodes/functions/sqrtNode");
 const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
 const piNode_1 = require("../../tree/nodes/numbers/piNode");
 const fractionNode_1 = require("../../tree/nodes/operators/fractionNode");
 const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
+exports.negativeMainTrigovalues = [
+    {
+        angle: new oppositeNode_1.OppositeNode(new fractionNode_1.FractionNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(5), piNode_1.PiNode), new numberNode_1.NumberNode(6))),
+        degree: 210,
+        cos: new oppositeNode_1.OppositeNode(new fractionNode_1.FractionNode(new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(3)), new numberNode_1.NumberNode(2))),
+        sin: new oppositeNode_1.OppositeNode(new fractionNode_1.FractionNode(new numberNode_1.NumberNode(1), new numberNode_1.NumberNode(2))),
+        tan: new fractionNode_1.FractionNode(new numberNode_1.NumberNode(1), new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(3))),
+        point: "H",
+    },
+    {
+        angle: new oppositeNode_1.OppositeNode(new fractionNode_1.FractionNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(3), piNode_1.PiNode), new numberNode_1.NumberNode(4))),
+        degree: 225,
+        cos: new oppositeNode_1.OppositeNode(new fractionNode_1.FractionNode(new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(2)), new numberNode_1.NumberNode(2))),
+        sin: new oppositeNode_1.OppositeNode(new fractionNode_1.FractionNode(new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(2)), new numberNode_1.NumberNode(2))),
+        tan: new numberNode_1.NumberNode(1),
+        point: "K",
+    },
+    {
+        angle: new oppositeNode_1.OppositeNode(new fractionNode_1.FractionNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(2), piNode_1.PiNode), new numberNode_1.NumberNode(3))),
+        degree: 240,
+        cos: new oppositeNode_1.OppositeNode(new fractionNode_1.FractionNode(new numberNode_1.NumberNode(1), new numberNode_1.NumberNode(2))),
+        sin: new oppositeNode_1.OppositeNode(new fractionNode_1.FractionNode(new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(3)), new numberNode_1.NumberNode(2))),
+        tan: new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(3)),
+        point: "L",
+    },
+    {
+        angle: new oppositeNode_1.OppositeNode(new fractionNode_1.FractionNode(piNode_1.PiNode, new numberNode_1.NumberNode(2))),
+        degree: 270,
+        cos: new numberNode_1.NumberNode(0),
+        sin: new numberNode_1.NumberNode(-1),
+        tan: new numberNode_1.NumberNode(Infinity),
+        point: "M",
+    },
+    {
+        angle: new oppositeNode_1.OppositeNode(new fractionNode_1.FractionNode(piNode_1.PiNode, new numberNode_1.NumberNode(3))),
+        degree: 300,
+        cos: new fractionNode_1.FractionNode(new numberNode_1.NumberNode(1), new numberNode_1.NumberNode(2)),
+        sin: new oppositeNode_1.OppositeNode(new fractionNode_1.FractionNode(new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(3)), new numberNode_1.NumberNode(2))),
+        tan: new oppositeNode_1.OppositeNode(new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(3))),
+        point: "N",
+    },
+    {
+        angle: new oppositeNode_1.OppositeNode(new fractionNode_1.FractionNode(piNode_1.PiNode, new numberNode_1.NumberNode(4))),
+        degree: 315,
+        cos: new fractionNode_1.FractionNode(new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(2)), new numberNode_1.NumberNode(2)),
+        sin: new oppositeNode_1.OppositeNode(new fractionNode_1.FractionNode(new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(2)), new numberNode_1.NumberNode(2))),
+        tan: new oppositeNode_1.OppositeNode(new numberNode_1.NumberNode(1)),
+        point: "P",
+    },
+    {
+        angle: new oppositeNode_1.OppositeNode(new fractionNode_1.FractionNode(piNode_1.PiNode, new numberNode_1.NumberNode(6))),
+        degree: 330,
+        cos: new fractionNode_1.FractionNode(new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(3)), new numberNode_1.NumberNode(2)),
+        sin: new oppositeNode_1.OppositeNode(new fractionNode_1.FractionNode(new numberNode_1.NumberNode(1), new numberNode_1.NumberNode(2))),
+        tan: new oppositeNode_1.OppositeNode(new fractionNode_1.FractionNode(new numberNode_1.NumberNode(1), new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(3)))),
+        point: "Q",
+    },
+    {
+        angle: new numberNode_1.NumberNode(0),
+        degree: 0,
+        cos: new numberNode_1.NumberNode(1),
+        sin: new numberNode_1.NumberNode(0),
+        tan: new numberNode_1.NumberNode(0),
+        point: "I",
+    },
+];
 exports.remarkableTrigoValues = [
     {
         angle: new numberNode_1.NumberNode(0),
@@ -137,3 +203,8 @@ exports.remarkableTrigoValues = [
         point: "Q",
     },
 ];
+exports.mainTrigoValues = [
+    ...exports.negativeMainTrigovalues,
+    ...exports.remarkableTrigoValues.slice(1).slice(0, 8),
+];
+exports.mainPositiveTrigovalues = exports.remarkableTrigoValues.slice(0, 9);

package/lib/math/utils/random/randTupleInt.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.distinctRandTupleInt = exports.randTupleInt = void 0;
-const arrayEqual_1 = require("../../../utils/arrayEqual");
+const arrayEqual_1 = require("../../../utils/arrays/arrayEqual");
 const randint_1 = require("./randint");
 /**
  * @param size tuple length

package/lib/playground.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAwBA,eAAO,MAAM,UAAU,YAmCtB,CAAC"}
+{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AA4BA,eAAO,MAAM,UAAU,YAEtB,CAAC"}