pimath 0.0.97 → 0.0.99

package/src/maths/algebra/study.ts

@@ -117,13 +117,13 @@ export class Study {
     private _signs: ITableOfSigns
     private _variations: ITableOfSigns
     private _zeroes: IZero[]
-    private config: StudyConfig
-    private name: string
+    private _config: StudyConfig
+    private _name: string
 
     constructor(fx: StudyableFunction, config?: StudyConfig | string) {
         this.fx = fx
 
-        this.config = {
+        this._config = {
             name :'f',
             domain :true,
             asymptotes :true,
@@ -135,27 +135,43 @@ export class Study {
         if (config) {
             if (typeof config === 'string') {
                 const d = config.split(',')
-                this.config = {}
+                this._config = {}
                 let n = d.filter(x=>x.includes('(x)'))
                 if(n.length===1){
-                    this.config.name = n[0].split('(x)')[0]
+                    this._config.name = n[0].split('(x)')[0]
                 }
-                this.config.domain = d.includes('d')
-                this.config.asymptotes = d.includes('a')
-                this.config.signs = d.includes('signs')
-                this.config.derivative = d.includes('dx')
-                this.config.variations = d.includes('ddx')
+                this._config.domain = d.includes('d')
+                this._config.asymptotes = d.includes('a')
+                this._config.signs = d.includes('signs')
+                this._config.derivative = d.includes('dx')
+                this._config.variations = d.includes('ddx')
             } else {
-                this.config = config
+                this._config = config
             }
         }
 
-        this.name = this.config?.name ?? 'f'
+        this._name = this._config?.name ?? 'f'
 
         this.makeStudy()
         return this
     }
 
+    get name(): string {
+        return this._name;
+    }
+
+    set name(value: string) {
+        this._name = value;
+    }
+
+    get config(): StudyConfig {
+        return this._config;
+    }
+
+    set config(value: StudyConfig) {
+        this._config = value;
+    }
+
     get zeroes(): IZero[] {
         return this._zeroes;
     }
@@ -191,20 +207,20 @@ export class Study {
     makeStudy = (): void => {
         this._zeroes = this.makeZeroes()
 
-        if (this.config.signs) this._signs = this.makeSigns()
+        if (this._config.signs) this._signs = this.makeSigns()
 
-        if (this.config.asymptotes) this._asymptotes = this.makeAsymptotes()
+        if (this._config.asymptotes) this._asymptotes = this.makeAsymptotes()
 
-        if (this.config.derivative) this._derivative = this.makeDerivative()
+        if (this._config.derivative) this._derivative = this.makeDerivative()
 
-        if (this.config.variations) this._variations = this.makeVariation()
+        if (this._config.variations) this._variations = this.makeVariation()
 
         // Table of signs / derivative / variation
-        if (this.config.signs) this._signs.tex = this.texSigns
+        if (this._config.signs) this._signs.tex = this.texSigns
 
-        if (this.config.derivative) this._derivative.tex = this.texGrows
+        if (this._config.derivative) this._derivative.tex = this.texGrows
 
-        if (this.config.variations) this._variations.tex = this.texVariations
+        if (this._config.variations) this._variations.tex = this.texVariations
     };
 
     indexOfZero = (zeroes: IZero[], zero: IZero | ISolution): number => {
@@ -452,14 +468,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._name}(x)\\)/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._name}'(x)\\)/1.2,\\(f(x)\\)/2`
         } else if (tos.type === TABLE_OF_SIGNS.VARIATIONS) {
-            factorsFx = `\\(${this.name}''(x)\\)/1.2,\\(f(x)\\)/2`
+            factorsFx = `\\(${this._name}''(x)\\)/1.2,\\(f(x)\\)/2`
         }
 
         // Create the tikzPicture header

package/tests/algebra/polynom.test.ts

@@ -99,6 +99,18 @@ describe('Polynom tests', () => {
         P2.factorize()
         expect(P2.texFactors).to.be.equal('-2x\\left( x+3 \\right)\\left( x-3 \\right)')
     });
+
+    it('should detect if a polynom is factorized', function (){
+        let P = new Polynom('x-1')
+
+        expect(P.isFactorized('x-1')).to.be.true
+        expect(P.isFactorized('x-2')).to.be.false
+
+        let Q = new Polynom('(x-1)(x+2)')
+
+        expect(Q.isFactorized('(x+2)(x-1)')).to.be.true
+        expect(Q.isFactorized('x^2+x-2')).to.be.false
+    })
 })
 
 describe('Polynom parsing with rational power', () => {
@@ -109,6 +121,18 @@ describe('Polynom parsing with rational power', () => {
 })
 
 
+describe("test simple", ()=>{
+    it('should parce this one correctly', ()=>{
+        const P = new Polynom('-(x+2)(x-1)(x-1)(5x+4)')
+        const Q = new Polynom('(2+x)^2(1-x)^3')
+
+        console.log(Q.tex)
+        console.log(Q.derivative().tex)
+        console.log(P.tex)
+        console.log(P.displayFactors)
+    })
+})
+
 // TODO: working with roots !
 // describe('WIP : working with roots', ()=>{
 //     it('should parse with roots coefficient',  ()=>{

package/tests/algebra/study.test.ts

@@ -11,8 +11,6 @@ describe('Study tests', () => {
             new Rational('(3x-2)(x-3)(x+4)', 'x^2-5x+6')
         )
         let AO = study.asymptotes.filter(x => x.type === ASYMPTOTE.SLOPE)[0]
-
-        console.log(AO.tableOfSign.signs)
     });
 
     it('should create draw code block', function () {
@@ -38,4 +36,19 @@ describe('Study tests', () => {
 
         expect(study.asymptotes[0].position).to.have.all.members(["LB", "RT"])
     });
+
+    it('should get only the domain and the signs of a rational', function () {
+        const R = new Rational('x-3', 'x^2-4')
+        const study = R.study('\\delta(x),d,signs')
+
+        console.log('CONFIG')
+        console.log(study.config)
+        console.log('DOMAIN')
+        console.log(study.domain)
+        console.log('SIGNS')
+        console.log(Object.keys(study.signs))
+
+        console.log(study.signs.tex)
+        console.log(study.signs.signs)
+    });
 })