pimath 0.0.121 → 0.0.123

package/src/maths/algebra/study.ts

@@ -91,6 +91,7 @@ export interface StudyConfig {
     derivative?: boolean,
     domain?: boolean,
     name?: string,
+    variable?: string,
     signs?: boolean,
     variations?: boolean
 }
@@ -125,6 +126,7 @@ export class Study {
 
         this._config = {
             name :'f',
+            variable: 'x',
             domain :true,
             asymptotes :true,
             signs :true,
@@ -136,9 +138,11 @@ export class Study {
             if (typeof config === 'string') {
                 const d = config.split(',')
                 this._config = {}
-                let n = d.filter(x=>x.includes('(x)'))
+                let n = d.filter(x=>x.includes('(') && x.includes(')'))
+
                 if(n.length===1){
-                    this._config.name = n[0].split('(x)')[0]
+                    this._config.name = n[0].split('(')[0]
+                    this._config.variable = n[0].split('(')[1].split(')')[0]
                 }
                 this._config.domain = d.includes('d')
                 this._config.asymptotes = d.includes('a')
@@ -150,18 +154,16 @@ export class Study {
             }
         }
 
-        this._name = this._config?.name ?? 'f'
-
         this.makeStudy()
         return this
     }
 
     get name(): string {
-        return this._name;
+        return this._config.name;
     }
 
     set name(value: string) {
-        this._name = value;
+        this._config.name = value;
     }
 
     get config(): StudyConfig {
@@ -468,14 +470,14 @@ export class Study {
 
     private _makeTexFromTableOfSigns = (tos: ITableOfSigns): string => {
         let factors = tos.factors.map(x => `\\(${x.tex}\\)/1`),
-            factorsFx = `\\(${this._name}(x)\\)/1.2`,
+            factorsFx = `\\(${this._config.name}(${this._config.variable})\\)/1.2`,
             zeroes = tos.zeroes
 
         // Add the last lines "label"
         if (tos.type === TABLE_OF_SIGNS.GROWS) {
-            factorsFx = `\\(${this._name}'(x)\\)/1.2,\\(f(x)\\)/2`
+            factorsFx = `\\(${this._config.name}'(${this._config.variable})\\)/1.2,\\(f(x${this._config.variable})\\)/2`
         } else if (tos.type === TABLE_OF_SIGNS.VARIATIONS) {
-            factorsFx = `\\(${this._name}''(x)\\)/1.2,\\(f(x)\\)/2`
+            factorsFx = `\\(${this._config.name}''(${this._config.variable})\\)/1.2,\\(f(${this._config.variable})\\)/2`
         }
 
         // Create the tikzPicture header

package/src/maths/numexp.ts

@@ -97,7 +97,7 @@ export class NumExp {
         stack.push(this._numberCorrection(value))
     }
 
-    evaluate(values: { [Key: string]: number }): number {
+    evaluate(values?: { [Key: string]: number }): number {
         const stack: number[] = []
 
         if(this._rpn===null){

package/src/maths/shutingyard.ts

@@ -254,22 +254,23 @@ export class Shutingyard {
             crtToken = expr[i]
             nextToken = expr[i + 1]
             normalizedExpr += crtToken
+
             if (crtToken.match(/[a-zA-Z]/g)) {
                 // Current element is a letter.
                 // if the next element is a letter, a number or an opening parentheses, add the multiplication sign.
-                if (nextToken.match(/[a-zA-Z\d(]/)) {
+                if (nextToken?.match(/[a-zA-Z\d(]/)) {
                     normalizedExpr += '*'
                 }
             } else if (crtToken.match(/\d/)) {
                 // Current element is a number.
                 // if the next element is a letter or a parentheses, add the multiplication sign.
-                if (nextToken.match(/[a-zA-Z(]/)) {
+                if (nextToken?.match(/[a-zA-Z(]/)) {
                     normalizedExpr += '*'
                 }
             } else if (crtToken === ')') {
                 // Current element is a closing parentheses.
                 // if the next element is a letter, a number or an opening parentheses, add the multiplication sign
-                if (nextToken.match(/[a-zA-Z\d(]/)) {
+                if (nextToken?.match(/[a-zA-Z\d(]/)) {
                     normalizedExpr += '*'
                 }
             }
@@ -279,7 +280,7 @@ export class Shutingyard {
         }
 
         // add the last token
-        return normalizedExpr + nextToken
+        return normalizedExpr + (nextToken===undefined?'':nextToken)
     }
 
     // /**
@@ -374,6 +375,7 @@ export class Shutingyard {
         // Normalize the input if required.
         if (uniformize || this._uniformize) expr = this.normalize(expr)
 
+
         let securityLoopLvl1 = 50,
             securityLoopLvl2_default = 50,
             securityLoopLvl2;

package/tests/algebra/polynom.test.ts

@@ -139,6 +139,14 @@ describe('Polynom tests', () => {
         expect(Q.isFactorized('4(2x+5)(x-6)')).to.be.true
         expect(Q.isFactorized('(8x+20)(x-6)')).to.be.false
         expect(Q.isFactorized('(8x+20)(x-6)', true)).to.be.true
+    });
+
+    it('should check if a polynom is developed', function () {
+        let P = new Polynom('x(x+1)')
+
+        expect(P.isDeveloped('x^(2)+x')).true
+        expect(P.isDeveloped('x^2+x')).true
+        expect(P.isDeveloped('x(x+1)')).false
 
     });
 

package/tests/numexp.test.ts

@@ -61,4 +61,16 @@ describe('Numerical expression', () => { // the tests container
         expect(p.evaluate({x: 16})).to.be.equal(2)
         expect(p.evaluate({x: -16})).to.be.NaN
     })
+
+    it('should work with constant', function () {
+
+        let k = new NumExp('2pi*x')
+        expect(+k.evaluate({x: 1}).toFixed(6)).to.be.equal(6.283185)
+    });
+
+    it('should work with constant but without variables', function () {
+
+        let k = new NumExp('2pi')
+        expect(+k.evaluate().toFixed(6)).to.be.equal(6.283185)
+    });
 });