pimath 0.0.25 → 0.0.29

package/src/maths/algebra/monom.ts

@@ -1,7 +1,5 @@
 /***
  * Monom class
- * Defined as coefficient * literal
- * Examples: 3x^2, 3/5x^2, ...
  */
 import {Fraction} from "../coefficients";
 import {Numeric} from "../numeric";
@@ -16,8 +14,10 @@ export class Monom {
     private _literal: literalType;
 
     /**
-     * Create the monom object.
-     * @param value (optional) string
+     * Create a Monom
+     * Defined as \\(k \\cdot x^{n}\\), where \\( k,n \in \\mathbb{Q}\\).
+     * Examples: \\(3x^2\\) or \\(3/5x^2\\)
+     * @param value (optional) string The value that should be parse. Can be a Monom, a Fraction, a string or a number. If nothing is provided, it will return the trivial monom (0).
      */
     constructor(value?: unknown) {
         this.zero();
@@ -34,29 +34,35 @@ export class Monom {
     // Getter and setter
     // ------------------------------------------
     /**
-     * Get the coefficient as fraction
+     * Get the coefficient \\(k\\) of the Monom \\(k\\cdot x^{n}\\)
+     * @returns {Fraction}
      */
     get coefficient(): Fraction {
         return this._coefficient;
     }
 
     /**
-     * Set the coefficient value of the monom
-     * @param F     Fraction
+     * Set the coefficient \\(k\\) value of the monom
+     * @param {Fraction | number | string} F
      */
-    set coefficient(F: Fraction) {
-        this._coefficient = F;
+    set coefficient(F: Fraction | number | string) {
+        this._coefficient = new Fraction(F);
     }
 
     /**
-     * Get the literal part, as dictionary
+     * Get the literal part of \\(x^{n_1}y^{n_2}\\) as dictionary \\[\\begin{array}{ll}x&=n_1\\\\y&=n_2\\end{array}\\]
+     * @returns {literalType}
      */
     get literal(): literalType {
         return this._literal;
     }
 
+    /**
+     * Get the literal square roots of the Monom.
+     * TODO: remove this getter ? Is it used and is it correct ?
+     * @returns {literalType}
+     */
     get literalSqrt(): literalType {
-
         if (this.isLiteralSquare()) {
             let L: literalType = {}
             for (let key in this._literal) {
@@ -69,8 +75,8 @@ export class Monom {
     }
 
     /**
-     * Set the literal part of the monom
-     * @param L     Literal part as dictionary: <setLetter: exposant>
+     * Set the literal part of the monom. Must be a dictionary {x: Fraction, y: Fraction, ...}
+     * @param {literalType} L
      */
     set literal(L: literalType) {
         this._literal = L;
@@ -230,11 +236,18 @@ export class Monom {
      * Display the monom, forcing the '+' sign to appear
      */
     get displayWithSign(): string {
-        // TODO: Rename or remove this getter ?
         let d: String = this.display;
         return (d[0] !== '-' ? '+' : '') + d;
     }
 
+    get texWithSign(): string {
+        if (this.coefficient.isStrictlyPositive()) {
+            return '+' + this.tex
+        }
+
+        return this.tex
+    }
+
     /**
      * Get the tex output of the monom
      */
@@ -281,15 +294,15 @@ export class Monom {
      */
     parse = (inputStr: unknown): Monom => {
 
-        if(typeof inputStr === 'string') {
+        if (typeof inputStr === 'string') {
             this._shutingYardToReducedMonom(inputStr)
-        }else if(typeof inputStr ==='number') {
+        } else if (typeof inputStr === 'number') {
             this._coefficient = new Fraction(inputStr)
             this._literal = {}
-        }else if(inputStr instanceof Fraction) {
+        } else if (inputStr instanceof Fraction) {
             this._coefficient = inputStr.clone()
             this._literal = {}
-        }else if(inputStr instanceof Monom){
+        } else if (inputStr instanceof Monom) {
             this._coefficient = inputStr._coefficient.clone()
             this._literal = this.copyLiterals(inputStr.literal)
         }
@@ -384,7 +397,7 @@ export class Monom {
     };
 
     copyLiterals = (literal: literalType): literalType => {
-        let L:literalType = {}
+        let L: literalType = {}
 
         for (let k in literal) {
             L[k] = literal[k].clone()
@@ -392,7 +405,7 @@ export class Monom {
         return L
     }
 
-    makeSame = (M: Monom):Monom => {
+    makeSame = (M: Monom): Monom => {
         // Copy the literal parts.
         for (let k in M._literal) {
             this.setLetter(k, M._literal[k].clone());
@@ -451,7 +464,7 @@ export class Monom {
     add = (...M: Monom[]): Monom => {
         for (let m of M) {
             if (this.isSameAs(m)) {
-                if(this.isZero()){
+                if (this.isZero()) {
                     this.makeSame(m)
                 }
                 this._coefficient.add(m.coefficient);
@@ -469,7 +482,7 @@ export class Monom {
     subtract = (...M: Monom[]): Monom => {
         for (let m of M) {
             if (this.isSameAs(m)) {
-                if(this.isZero()){
+                if (this.isZero()) {
                     this.makeSame(m)
                 }
                 this._coefficient.add(m.clone().coefficient.opposed());

package/src/maths/algebra/polynom.ts

@@ -461,7 +461,7 @@ export class Polynom {
 
         // Make the euclidian division of the two polynoms.
         let MaxIteration = this.degree(letter).clone().multiply(2);
-        while (reminder.degree(letter) >= degreeP && MaxIteration.isPositive()) {
+        while (reminder.degree(letter).geq(degreeP) && MaxIteration.isPositive()) {
             MaxIteration.subtract(1)
 
             // Get the greatest monom divided by the max monom of the divider

package/src/maths/algebra/rational.ts

@@ -4,7 +4,7 @@
  */
 
 import {Polynom} from "./polynom";
-import {Fraction} from "../coefficients/fraction";
+import {Fraction} from "../coefficients";
 
 /**
  * Rational class can handle rational polynoms

package/src/maths/geometry/line.ts

@@ -312,6 +312,9 @@ export class Line {
     isSameAs = (line: Line): Boolean => {
         return this.slope.isEqual(line.slope) && this.height.isEqual(line.height);
     }
+    isVertical = (): Boolean => {
+        return this.slope.isInfinity()
+    }
     simplify = (): Line => {
         let lcm = Numeric.lcm(this._a.denominator, this._b.denominator, this._c.denominator),
             gcd = Numeric.gcd(this._a.numerator, this._b.numerator, this._c.numerator);

package/src/maths/geometry/vector.ts

@@ -81,12 +81,20 @@ export class Vector {
             }
 
             // Fractions or a number are give
-            if (values[0].isFraction || !isNaN(values[0])) {
+            if (values[0] instanceof Fraction || !isNaN(values[0])) {
                 this._x = new Fraction(values[0])
             }
-            if (values[1].isFraction || !isNaN(values[1])) {
+            if (values[1] instanceof Fraction || !isNaN(values[1])) {
                 this._y = new Fraction(values[1])
             }
+
+            if(
+                (typeof values[0] === 'object' && !isNaN(values[0].x) && !isNaN(values[0].x)) &&
+                (typeof values[1] === 'object' && !isNaN(values[1].x) && !isNaN(values[1].x))
+            ){
+                this._x = new Fraction(+values[1].x-values[0].x)
+                this._y = new Fraction(+values[1].y-values[0].y)
+            }
         }
 
         return this;

package/src/maths/numexp.ts

@@ -0,0 +1,138 @@
+import {Shutingyard, ShutingyardMode, ShutingyardType, tokenConstant} from "./shutingyard";
+import {Fraction} from "./coefficients";
+
+export class NumExp {
+    private _rpn: { token: string, tokenType: string }[]
+    private _expression: string
+
+    constructor(value: string) {
+        this._expression = value
+        this._rpn = new Shutingyard(ShutingyardMode.NUMERIC).parse(value).rpn
+    }
+
+    get rpn(): { token: string; tokenType: string }[] {
+        return this._rpn;
+    }
+
+    get expression(): string {
+        return this._expression;
+    }
+
+    private _extractDecimalPart(value: number): string {
+        let decimal = value.toString()
+
+        if (!decimal.includes('.')) {
+            return ''
+        }
+
+        decimal = decimal.split('.')[1]
+
+        return decimal.substring(0, decimal.length - 2)
+    }
+
+    private _numberCorrection(value: number): number {
+        // Must modify the number if it's like:
+        // a: 3.0000000000000003
+        // b: 3.9999999999999994
+        // remove the last character
+        // check if around n last characters are either 0 or 9
+        // if it is, 'round' the number.
+
+        const epsilon = 0.00000000000001,
+            number_of_digits = 6
+
+        let decimal = this._extractDecimalPart(value)
+        if(decimal===''){return value}
+
+        const n9 = decimal.match(/9+$/g)
+        const n0 = decimal.match(/0+$/g)
+
+        if (n9 && n9[0].length >= number_of_digits) {
+            // New tested values.
+            let mod = this._extractDecimalPart(value + epsilon),
+                mod0 = mod.match(/0+$/g)
+
+            if(mod0 && mod0[0].length>= number_of_digits){
+                // The value can be changed. Remove all zeros!
+                return +((value+epsilon).toString().split(mod0[0])[0])
+            }
+        }
+
+        if (n0 && n0[0].length >= number_of_digits) {
+            // New tested values.
+            let mod = this._extractDecimalPart(value - epsilon),
+                mod9 = mod.match(/9+$/g)
+
+            if(mod9 && mod9[0].length>= number_of_digits){
+                // The value can be changed. Remove all nines!
+                return +(value.toString().split(n0[0])[0])
+            }
+        }
+
+        return value
+    }
+
+    private _addToStack(stack:number[], value: number): void {
+        stack.push(this._numberCorrection(value))
+    }
+
+    evaluate(values: { [Key: string]: number }): number {
+        let stack: number[] = []
+        for (const element of this._rpn) {
+            if (element.tokenType === ShutingyardType.COEFFICIENT) {
+                // May be a numeric value or a Fraction.
+                if (!isNaN(+element.token)) {
+                    this._addToStack(stack, +element.token)
+                } else {
+                    this._addToStack(stack, new Fraction(element.token).value)
+                }
+            } else if (element.tokenType === ShutingyardType.VARIABLE) {
+                if (values[element.token] !== undefined) {
+                    this._addToStack(stack, +values[element.token])
+                }
+            } else if (element.tokenType === ShutingyardType.CONSTANT) {
+                this._addToStack(stack, tokenConstant[element.token])
+            } else if (element.tokenType === ShutingyardType.OPERATION) {
+                if (element.token === '*') {
+                    const b = +stack.pop(),
+                        a = +stack.pop()
+                    this._addToStack(stack, a * b)
+                } else if (element.token === '/') {
+                    const b = +stack.pop(),
+                        a = +stack.pop()
+                    this._addToStack(stack, a / b)
+                } else if (element.token === '+') {
+                    const b = +stack.pop(),
+                        a = +stack.pop()
+                    this._addToStack(stack, a + b)
+                } else if (element.token === '-') {
+                    const b = +stack.pop(),
+                        a = +stack.pop()
+                    this._addToStack(stack, a - b)
+                } else if (element.token === '^') {
+                    const b = +stack.pop(),
+                        a = +stack.pop()
+                    this._addToStack(stack, Math.pow(a, b))
+                }
+            } else if (element.tokenType === ShutingyardType.FUNCTION) {
+                const a = +stack.pop()
+                if (element.token === 'sin') {
+                    this._addToStack(stack, Math.sin(a))
+                } else if (element.token === 'cos') {
+                    this._addToStack(stack, Math.cos(a))
+                } else if (element.token === 'tan') {
+                    this._addToStack(stack, Math.tan(a))
+                } else if(element.token === 'sqrt') {
+                    this._addToStack(stack, Math.sqrt(a))
+                }
+            }
+        }
+
+        if (stack.length === 1) {
+            return stack[0]
+        } else {
+            console.error('There was a problem parsing', this._expression, '. The RPN array is', this._rpn)
+            return 0
+        }
+    }
+}

package/src/maths/shutingyard.ts

@@ -1,20 +1,42 @@
 import {loadHighlighter} from "typedoc/dist/lib/utils/highlighter";
+import exp = require("constants");
 
 type tokenType = {
     [key: string]: {
         precedence: number,
-        associative: string
+        associative: string,
+        type: string
     }
 }
 
+export const tokenConstant:{[Key:string]:number} = {
+    pi: Math.PI,
+    e: Math.exp(1)
+}
+export enum ShutingyardType {
+    VARIABLE='variable',
+    COEFFICIENT='coefficient',
+    OPERATION = 'operation',
+    CONSTANT = 'constant',
+    FUNCTION = 'function',
+    MONOM = 'monom'
+}
+export enum ShutingyardMode {
+    POLYNOM= 'polynom',
+    SET = 'set',
+    NUMERIC = 'numeric'
+}
+
 export class Shutingyard {
     private _rpn: { token: string, tokenType: string }[] = [];
-    readonly _mode: 'polynom' | 'set';
+    readonly _mode: ShutingyardMode;
     private _tokenConfig: tokenType;
+    private _tokenConstant: {[Key:string]: number}
     private _uniformize: boolean;
+    private _tokenKeys: string[]
 
-    constructor(mode?: 'polynom' | 'set') {
-        this._mode = typeof mode === 'undefined' ? 'polynom' : mode;
+    constructor(mode?: ShutingyardMode ) {
+        this._mode = typeof mode === 'undefined' ? ShutingyardMode.POLYNOM : mode;
         this.tokenConfigInitialization()
     }
 
@@ -23,41 +45,57 @@ export class Shutingyard {
      * Defined operations: + - * / ^ sin cos tan
      * @param token
      */
-    isOperation(token: string): boolean {
-        if (token[0].match(/[+\-*/^]/g)) {
-            return true;
-        }
-        //
-        // if (token.match(/^sin|cos|tan/g)) {
-        //     return true;
-        // }
-
-        return false;
-    }
+    // isOperation(token: string): boolean {
+    //     if (token[0].match(/[+\-*/^]/g)) {
+    //         return true;
+    //     }
+    //     //
+    //     // if (token.match(/^sin|cos|tan/g)) {
+    //     //     return true;
+    //     // }
+    //
+    //     return false;
+    // }
 
     tokenConfigInitialization(): tokenType {
-        if (this._mode === 'set') {
+        if (this._mode === ShutingyardMode.SET) {
             this._tokenConfig = {
-                '&': {precedence: 3, associative: 'left'},
-                '|': {precedence: 3, associative: 'left'},
-                '!': {precedence: 4, associative: 'right'},
-                '-': {precedence: 2, associative: 'left'}
+                '&': {precedence: 3, associative: 'left', type: ShutingyardType.OPERATION},
+                '|': {precedence: 3, associative: 'left', type: ShutingyardType.OPERATION},
+                '!': {precedence: 4, associative: 'right', type: ShutingyardType.OPERATION},
+                '-': {precedence: 2, associative: 'left', type: ShutingyardType.OPERATION}
             }
             this._uniformize = false;
+        }else if (this._mode === ShutingyardMode.NUMERIC){
+            this._tokenConfig = {
+                '^': {precedence: 4, associative: 'right', type: ShutingyardType.OPERATION},
+                '*': {precedence: 3, associative: 'left', type: ShutingyardType.OPERATION},
+                '/': {precedence: 3, associative: 'left', type: ShutingyardType.OPERATION},
+                '+': {precedence: 2, associative: 'left', type: ShutingyardType.OPERATION},
+                '-': {precedence: 2, associative: 'left', type: ShutingyardType.OPERATION},
+                '%': {precedence: 3, associative: 'right', type: ShutingyardType.OPERATION},
+                'sin': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
+                'cos': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
+                'tan': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
+                'sqrt': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
+            }
+            this._uniformize = false
         } else {
             this._tokenConfig = {
-                '^': {precedence: 4, associative: 'right'},
-                '*': {precedence: 3, associative: 'left'},
-                '/': {precedence: 3, associative: 'left'},
-                '+': {precedence: 2, associative: 'left'},
-                '-': {precedence: 2, associative: 'left'},
-                '%': {precedence: 3, associative: 'right'},
-                'sin': {precedence: 4, associative: 'right'},
-                'cos': {precedence: 4, associative: 'right'},
-                'tab': {precedence: 4, associative: 'right'},
+                '^': {precedence: 4, associative: 'right', type: ShutingyardType.OPERATION},
+                '*': {precedence: 3, associative: 'left', type: ShutingyardType.OPERATION},
+                '/': {precedence: 3, associative: 'left', type: ShutingyardType.OPERATION},
+                '+': {precedence: 2, associative: 'left', type: ShutingyardType.OPERATION},
+                '-': {precedence: 2, associative: 'left', type: ShutingyardType.OPERATION},
+                '%': {precedence: 3, associative: 'right', type: ShutingyardType.OPERATION},
+                'sin': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
+                'cos': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
+                'tan': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
             }
             this._uniformize = true
         }
+
+        this._tokenKeys = Object.keys(this._tokenConfig).sort((a,b)=>b.length-a.length)
         return this._tokenConfig
     }
 
@@ -66,7 +104,7 @@ export class Shutingyard {
      * @param expr (string) Expression to analyse
      * @param start (number) CUrrent position in the expr string.
      */
-    NextToken2(expr: string, start: number): [string, number, string] {
+    NextToken(expr: string, start: number): [string, number, string] {
         let token: string, tokenType: string;
         token = '';
         tokenType = '';
@@ -86,12 +124,23 @@ export class Shutingyard {
             tokenType = 'function-argument';
         } else{
             // Order token keys by token characters length (descending)
-            const keys = Object.keys(this._tokenConfig).sort((a,b)=>b.length-a.length)
+            // TODO: this is done each time ! SHould be done once !
+            // const keys = Object.keys(this._tokenConfig).sort((a,b)=>b.length-a.length)
+
+            // Extract operation and function tokens
+            for(let key of this._tokenKeys){
+                if(expr.substring(start, start+key.length) === key){
+                    token += key;
+                    tokenType = this._tokenConfig[key].type
+                    break
+                }
+            }
 
-            for(let key of keys){
-                if(expr.substr(start, key.length) === key){
+            // Extract constant
+            for(let key in tokenConstant){
+                if(expr.substring(start, start+key.length) === key){
                     token += key;
-                    tokenType = 'operation'
+                    tokenType = ShutingyardType.CONSTANT
                     break
                 }
             }
@@ -99,77 +148,24 @@ export class Shutingyard {
             if(token===''){
                 // No function found ! Might be a coefficient !
                 if( expr[start].match(/[0-9]/) ) {
-                    token = expr.substr(start).match(/^([0-9.,/]+)/)[0]
-                    tokenType = 'coefficient'
+                    if(this._mode === ShutingyardMode.POLYNOM) {
+                        token = expr.substring(start).match(/^([0-9.,/]+)/)[0]
+                    }else{
+                        token = expr.substring(start).match(/^([0-9.,]+)/)[0]
+                    }
+                    tokenType = ShutingyardType.COEFFICIENT
                 }else if (expr[start].match(/[a-zA-Z]/)) {
-                    token = expr.substr(start).match(/^([a-zA-Z])/)[0]
-                    tokenType = 'variable'
+                    token = expr.substring(start).match(/^([a-zA-Z])/)[0]
+                    tokenType = ShutingyardType.VARIABLE
                 }else{
                     console.log('Unidentified token', expr[start], expr, start)
                     token = expr[start]
-                    tokenType = 'monom'
+                    tokenType = ShutingyardType.MONOM
                 }
 
             }
         }
 
-
-        // console.log(token, tokenType)
-        return [token, start + token.length, tokenType];
-    }
-
-    NextToken(expr: string, start: number): [string, number, string] {
-        let tokenMatch: string[], token: string, tokenType: string;
-
-        this.NextToken2(expr, start)
-        // Detect a fraction monoms or return empty array
-        tokenMatch = (expr.substr(start).match(/^[0-9/a-zA-Z^]+/g)) || [];
-
-        if (expr.substr(start, start + 3).match(/^(sin|cos|tan)/g)) {
-            token = expr.substr(start, 3)
-            tokenType = 'function'
-        } else if (tokenMatch.length > 0) {
-            token = tokenMatch[0];
-            tokenType = 'monom';
-        }
-        // It's an operation !
-        else if (expr[start].match(/[+\-*/^]/g)) {
-            token = expr[start];
-            tokenType = 'operation';
-        } else if (expr[start].match(/[&|!]/g)) {
-            token = expr[start];
-            tokenType = 'operation';
-        }
-        // It's an opening parenthese
-        else if (expr[start] === '(') {
-            token = '(';
-            tokenType = '(';
-        }
-        // It's a closing parenthese
-        else if (expr[start] === ')') {
-            token = ')';
-            tokenType = ')';
-        }
-        // It's an argument separator for a function
-        else if (expr[start] === ',') {
-            token = ',';
-            tokenType = 'function-argument';
-        }
-        // It's a monom.
-        else {
-            // TODO: Actually, negative exposant aren't supported.
-            // token = (expr.substr(start).match(/^[\da-z\^]+/g)[0])||'';
-            token = tokenMatch[0];
-            tokenType = 'monom';
-
-            if (token === '') {
-                token = expr[start];
-                tokenType = 'monom';
-                console.log('SHUTING YARD - NEXT TOKEN: error at ', start);
-            }
-        }
-
-        // console.log(token, start + token.length, tokenType);
         return [token, start + token.length, tokenType];
     }
 
@@ -241,12 +237,13 @@ export class Shutingyard {
             }
 
             // Get the next token and the corresponding new (ending) position
-            [token, tokenPos, tokenType] = this.NextToken2(expr, tokenPos);
+            [token, tokenPos, tokenType] = this.NextToken(expr, tokenPos);
 
             switch (tokenType) {
                 case 'monom':
                 case 'coefficient':
                 case 'variable':
+                case 'constant':
                     outQueue.push({
                         token,
                         tokenType

package/tests/algebra/monom.test.ts

@@ -66,7 +66,7 @@ describe('Monom tests', () => {
     });
 })
 
-describe('Monom as numerical expression', () => {
+describe('Monom as numerical expression WIP', () => {
     it('should create a numerical expression', () => {
         let M = new Monom()
 

package/tests/algebra/polynom.test.ts

@@ -46,8 +46,17 @@ describe('Polynom tests', () => {
             }
         })
 
-        console.log(P.tex)
         expect(P.length).to.be.equal(3)
         expect(P.degree().value).to.be.equal(6)
     });
+
+    it('should calculate correctly the quotient and reminder', function () {
+        let P = new Polynom('(x-3)(x^2+5x-4)+12'),
+            D = new Polynom('x-3')
+
+        let euclidian = P.euclidian(D);
+
+        expect(euclidian.quotient.tex).to.be.equal('x^{2}+5x-4')
+        expect(euclidian.reminder.tex).to.be.equal('12')
+    });
 })

package/tests/numexp.test.ts

@@ -0,0 +1,14 @@
+import {expect} from 'chai';
+import {NumExp} from "../esm/maths/numexp";
+
+describe('Numerical expression', () => { // the tests container
+    it('RPN for numerical expression', () => {
+        const RPN = new NumExp('3*x+5').rpn
+        expect(RPN.map(x => x.token)).to.have.all.members(['3', 'x', '*', '5', '+'])
+    })
+
+    it('Evaluation simple mathematical functions', () => {
+        const expr = new NumExp('sqrt(x)')
+        expect(expr.evaluate({x: 9})).to.be.equal(3)
+    })
+});

package/tests/shutingyard.test.ts

@@ -1,5 +1,5 @@
 import {expect} from 'chai';
-import {Shutingyard} from "../src/maths/shutingyard";
+import {Shutingyard, ShutingyardMode} from "../src/maths/shutingyard";
 
 describe('Shuting yard', () => { // the tests container
     it('RPN for polynom', () => {
@@ -28,8 +28,8 @@ describe('Shuting yard', () => { // the tests container
     })
 
 	it('Custom RPN', () => {
-		const SY1: Shutingyard = new Shutingyard('set').parse('(A|B)&C');
-        const SY2: Shutingyard = new Shutingyard('set').parse('(A-B)&!C');
+		const SY1: Shutingyard = new Shutingyard(ShutingyardMode.SET).parse('(A|B)&C');
+        const SY2: Shutingyard = new Shutingyard(ShutingyardMode.SET).parse('(A-B)&!C');
 		expect(SY1.rpn.map(x=>x.token)).to.have.all.members(['A', 'B', '|', 'C', '&'])
 		expect(SY2.rpn.map(x=>x.token)).to.have.all.members(['A', 'B', '-', 'C', '!', '&'])
 	})