pimath 0.1.24 → 0.1.25

package/README.md

@@ -1,18 +1,15 @@
 PI - javascript math in your hands 
 =============
 
-PI is a script designed to create and generate mathematical exercises. 
-Each class has a tex output, designed to be used in any LaTeX document.
+PiMath is a script designed to create and generate mathematical exercises. 
 
-Fraction will create... fraction !
 
 ```
-let A = new Pi.Fraction('2/3');
+let A = new PiMath.Fraction('2/3');
 console.log(A.tex) // -> \frac{ 2 }{ 3 }
 
 // Add another fraction
-let B = new Pi.Fraction('2/5');
+let B = new PiMath.Fraction('2/5');
 A.add(B);
 console.log(A.frac) // -> \frac{ 16 }{ 15 }
-```
-New version today
+```

package/dist/algebra/factor.d.ts

@@ -1,11 +1,12 @@
-import { IAlgebra, IExpression, InputAlgebra, InputValue, IPiMathObject, ISolution, literalType, TABLE_OF_SIGNS } from '../pimath.interface';
+import { IAlgebra, IExpression, InputAlgebra, InputValue, IPiMathObject, literalType, TABLE_OF_SIGNS } from '../pimath.interface';
 import { Fraction } from '../coefficients/fraction';
 import { Polynom } from './polynom';
 export declare class Factor implements IPiMathObject<Factor>, IExpression<Factor>, IAlgebra<Factor> {
     #private;
-    constructor(value: InputAlgebra<Polynom> | Factor, power?: InputValue<Fraction>);
+    constructor(value?: InputAlgebra<Polynom> | Factor, power?: InputValue<Fraction>);
     parse(): Factor;
     clone(): Factor;
+    fromPolynom(polynom: InputValue<Polynom>): this;
     get tex(): string;
     get display(): string;
     add(): Factor;
@@ -34,7 +35,7 @@ export declare class Factor implements IPiMathObject<Factor>, IExpression<Factor
     root(value: number): this;
     sqrt(): this;
     subtract(): Factor;
-    tableOfSigns(roots?: ISolution[]): TABLE_OF_SIGNS;
+    tableOfSigns(): TABLE_OF_SIGNS;
     get variables(): string[];
     get withPower(): this;
     get withRoot(): this;

package/dist/algebra/monom.d.ts

@@ -101,7 +101,6 @@ export declare class Monom implements IPiMathObject<Monom>, IExpression<Monom>,
     set literal(L: literalType<Fraction>);
     /**
      * Get the literal square roots of the Monom.
-     * TODO: remove this getter ? Is it used and is it correct ?
      * @returns {literalType<Fraction>}
      */
     get literalSqrt(): literalType<Fraction>;

package/dist/algebra/polyFactor.d.ts

@@ -4,8 +4,8 @@ import { Factor } from './factor';
 import { Polynom } from './polynom';
 export declare class PolyFactor implements IPiMathObject<PolyFactor>, IExpression<PolyFactor>, IAlgebra<PolyFactor> {
     #private;
-    constructor(...values: (Factor | InputAlgebra<Polynom> | PolyFactor)[]);
-    parse(...values: (Factor | InputAlgebra<Polynom> | PolyFactor)[]): this;
+    constructor(...values: (Factor | PolyFactor)[]);
+    parse(...values: (Factor | PolyFactor)[]): this;
     clone(): PolyFactor;
     get tex(): string;
     get display(): string;
@@ -38,7 +38,13 @@ export declare class PolyFactor implements IPiMathObject<PolyFactor>, IExpressio
     primitive(): PolyFactor;
     reduce(): this;
     root(value: number): this;
-    sort(): this;
+    /**
+     * Reoarder the factors using :
+     * 1. number of monoms
+     * 2. degree of polynom
+     * 3. power of polyfactor
+     */
+    sort(letter?: string): this;
     sqrt(): this;
     subtract(...values: PolyFactor[]): this;
     tableOfSigns(): POLYFACTOR_TABLE_OF_SIGNS;

package/dist/algebra/polynom.d.ts

@@ -1,5 +1,5 @@
 import { IAlgebra, IAnalyse, IExpression, InputAlgebra, InputValue, IPiMathObject, ISolution, literalType, TABLE_OF_SIGNS } from '../pimath.interface';
-import { Fraction } from '../coefficients/fraction';
+import { Fraction } from '../coefficients';
 import { Monom } from './monom';
 export type PolynomParsingType = InputValue<Polynom> | Monom;
 export interface IEuclidean {
@@ -30,11 +30,12 @@ export declare class Polynom implements IPiMathObject<Polynom>, IExpression<Poly
      * Clone the polynom
      */
     clone: () => Polynom;
+    get tex(): string;
+    get display(): string;
     add: (...values: InputAlgebra<Polynom>[]) => Polynom;
     commonMonom: () => Monom;
     degree: (letter?: string) => Fraction;
     derivative: (letter?: string) => Polynom;
-    get display(): string;
     divide: (value: InputAlgebra<Polynom>) => Polynom;
     empty: () => this;
     /**
@@ -49,8 +50,10 @@ export declare class Polynom implements IPiMathObject<Polynom>, IExpression<Poly
      * @param letter
      */
     factorize: (letter?: string) => Polynom[];
+    fromCoefficients(...values: InputValue<Fraction>[]): this;
     gcdDenominator: () => number;
     gcdNumerator: () => number;
+    getCoefficients(): Fraction[];
     getDenominators: () => number[];
     getNumerators: () => number[];
     getZeroes: () => ISolution[];
@@ -97,8 +100,7 @@ export declare class Polynom implements IPiMathObject<Polynom>, IExpression<Poly
     set roots(value: ISolution[]);
     sqrt(): Polynom;
     subtract: (...values: InputAlgebra<Polynom>[]) => Polynom;
-    tableOfSigns(rootsArray?: ISolution[]): TABLE_OF_SIGNS;
-    get tex(): string;
+    tableOfSigns(): TABLE_OF_SIGNS;
     get variables(): string[];
     /**
      * Set the polynom to zero.

package/dist/geometry/triangle.d.ts

@@ -27,7 +27,6 @@ export declare class Triangle {
      * Parse values to a triangle. Supported formats:
      * Vector2D, Vector2D, Vector2D
      * x1, y1, x2, y2, x3, y3
-     * TODO: Something else ?
      * @param values
      */
     parse: (...values: unknown[]) => Triangle;

package/dist/pimath.interface.d.ts

@@ -1,9 +1,6 @@
-import { Fraction } from './coefficients/fraction';
-import { NthRoot } from './coefficients/nthRoot';
-import { Monom } from './algebra/monom';
-import { Factor } from './algebra/factor';
+import { Fraction, NthRoot } from './coefficients';
+import { Monom, Factor, Equation } from './algebra';
 import { Line, Point, Vector } from './geometry';
-import { Equation } from './algebra';
 export type InputValue<T> = T | string | number | Fraction | NthRoot;
 export type InputAlgebra<T> = InputValue<T> | Monom;
 export type literalType<T> = Record<string, T>;