Edit File - File Manager

Edit File: math-expression-evaluator.js

/** math-expression-evaluator version 1.3.8
 Dated:2021-07-03 */

// newAr is a specially designed data structure index of 1d array = length of tokens
 newAr[x] = newAr[x] || []
 for (var y = 0; y < newAr[x].length; y++) {
 if (tokens[i].token === newAr[x][y]) {
 temp = token.indexOf(newAr[x][y])
 break
 }
 }
 if (temp === -1) {
 token.push(tokens[i].token)
 type.push(tokens[i].type)
 if (newAr.length <= tokens[i].token.length) {
 newAr[tokens[i].token.length] = []
 }
 newAr[tokens[i].token.length].push(tokens[i].token)
 eva.push(tokens[i].value)
 show.push(tokens[i].show)
 } else {
 // overwrite
 token[temp] = tokens[i].token
 type[temp] = tokens[i].type
 eva[temp] = tokens[i].value
 show[temp] = tokens[i].show
 }
 }
}

Mexp.lex = function (inp, tokens) {
  'use strict'

var changeSignObj = {
    value: Mexp.math.changeSign,
    type: 0,
    pre: 21,
    show: '-'
  }
  var closingParObj = {
    value: ')',
    show: ')',
    type: 5,
    pre: 0
  }
  var openingParObj = {
    value: '(',
    type: 4,
    pre: 0,
    show: '('
  }
  var str = [openingParObj]

str.push(closingParObj)
  //        console.log(str);
  return new Mexp(str)
}
module.exports = Mexp

},{"./math_function.js":3}],3:[function(require,module,exports){
"use strict";
var Mexp = function (parsed) {
  this.value = parsed
}

Mexp.math = {
 isDegree: true, // mode of calculator
 acos: function (x) {
 return (Mexp.math.isDegree ? 180 / Math.PI * Math.acos(x) : Math.acos(x))
 },
 add: function (a, b) {
 return a + b
 },
 asin: function (x) {
 return (Mexp.math.isDegree ? 180 / Math.PI * Math.asin(x) : Math.asin(x))
 },
 atan: function (x) {
 return (Mexp.math.isDegree ? 180 / Math.PI * Math.atan(x) : Math.atan(x))
 },
 acosh: function (x) {
 return Math.log(x + Math.sqrt(x * x - 1))
 },
 asinh: function (x) {
 return Math.log(x + Math.sqrt(x * x + 1))
 },
 atanh: function (x) {
 return Math.log((1 + x) / (1 - x))
 },
 C: function (n, r) {
 var pro = 1
 var other = n - r
 var choice = r
 if (choice < other) {
 choice = other
 other = r
 }
 for (var i = choice + 1; i <= n; i++) {
 pro *= i
 }
 return pro / Mexp.math.fact(other)
 },
 changeSign: function (x) {
 return -x
 },
 cos: function (x) {
 if (Mexp.math.isDegree) x = Mexp.math.toRadian(x)
 return Math.cos(x)
 },
 cosh: function (x) {
 return (Math.pow(Math.E, x) + Math.pow(Math.E, -1 * x)) / 2
 },
 div: function (a, b) {
 return a / b
 },
 fact: function (n) {
 if (n % 1 !== 0) return 'NaN'
 var pro = 1
 for (var i = 2; i <= n; i++) {
 pro *= i
 }
 return pro
 },
 inverse: function (x) {
 return 1 / x
 },
 log: function (i) {
 return Math.log(i) / Math.log(10)
 },
 mod: function (a, b) {
 return a % b
 },
 mul: function (a, b) {
 return a * b
 },
 P: function (n, r) {
 var pro = 1
 for (var i = Math.floor(n) - Math.floor(r) + 1; i <= Math.floor(n); i++) {
 pro *= i
 }
 return pro
 },
 Pi: function (low, high, ex) {
 var pro = 1
 for (var i = low; i <= high; i++) {
 pro *= Number(ex.postfixEval({
 n: i
 }))
 }
 return pro
 },
 pow10x: function (e) {
 var x = 1
 while (e--) {
 x *= 10
 }
 return x
 },
 sigma: function (low, high, ex) {
 var sum = 0
 for (var i = low; i <= high; i++) {
 sum += Number(ex.postfixEval({
 n: i
 }))
 }
 return sum
 },
 sin: function (x) {
 if (Mexp.math.isDegree) x = Mexp.math.toRadian(x)
 return Math.sin(x)
 },
 sinh: function (x) {
 return (Math.pow(Math.E, x) - Math.pow(Math.E, -1 * x)) / 2
 },
 sub: function (a, b) {
 return a - b
 },
 tan: function (x) {
 if (Mexp.math.isDegree) x = Mexp.math.toRadian(x)
 return Math.tan(x)
 },
 tanh: function (x) {
 return Mexp.sinha(x) / Mexp.cosha(x)
 },
 toRadian: function (x) {
 return x * Math.PI / 180
 }
}
Mexp.Exception = function (message) {
 this.message = message
}
module.exports = Mexp

},{}],4:[function(require,module,exports){

var Mexp = require('./lexer.js');

Mexp.prototype.toPostfix = function () {
	'use strict';
	var post = [], elem, popped, prep, pre, ele;
	var stack = [{ value: "(", type: 4, pre: 0 }];
	var arr = this.value;
	for (var i = 1; i < arr.length; i++) {
		if (arr[i].type === 1 || arr[i].type === 3 || arr[i].type === 13) {	//if token is number,constant,or n(which is also a special constant in our case)
			if (arr[i].type === 1)
				arr[i].value = Number(arr[i].value);
			post.push(arr[i]);
		}
		else if (arr[i].type === 4) {
			stack.push(arr[i]);
		}
		else if (arr[i].type === 5) {
			while ((popped = stack.pop()).type !== 4) {
				post.push(popped);
			}
		}
		else if (arr[i].type === 11) {
			while ((popped = stack.pop()).type !== 4) {
				post.push(popped);
			}
			stack.push(popped);
		}
		else {
			elem = arr[i];
			pre = elem.pre;
			ele = stack[stack.length - 1];
			prep = ele.pre;
			var flag = ele.value == 'Math.pow' && elem.value == 'Math.pow';
			if (pre > prep) stack.push(elem);
			else {
				while (prep >= pre && !flag || flag && pre < prep) {
					popped = stack.pop();
					ele = stack[stack.length - 1];
					post.push(popped);
					prep = ele.pre;
					flag = elem.value == 'Math.pow' && ele.value == 'Math.pow';
				}
				stack.push(elem);
			}
		}
	}
	return new Mexp(post);
};
module.exports = Mexp;
},{"./lexer.js":2}],5:[function(require,module,exports){
var Mexp=require('./postfix.js');
Mexp.prototype.postfixEval = function (UserDefined) {
	'use strict';
	UserDefined=UserDefined||{};
	UserDefined.PI=Math.PI;
	UserDefined.E=Math.E;
	var stack=[],pop1,pop2,pop3;
	var disp=[];
	var temp='';
	var arr=this.value;
	var bool=(typeof UserDefined.n!=="undefined");
	for(var i=0;i<arr.length;i++){
		if(arr[i].type===1){
			stack.push({value:arr[i].value,type:1});
		}
		else if(arr[i].type===3){
			stack.push({value:UserDefined[arr[i].value],type:1});
		}
		else if(arr[i].type===0){
			if(typeof stack[stack.length-1].type==="undefined"){
				stack[stack.length-1].value.push(arr[i]);
			}
			else stack[stack.length-1].value=arr[i].value(stack[stack.length-1].value);
		}
		else if(arr[i].type===7){
			if(typeof stack[stack.length-1].type==="undefined"){
				stack[stack.length-1].value.push(arr[i]);
			}
			else stack[stack.length-1].value=arr[i].value(stack[stack.length-1].value);
		}
		else if(arr[i].type===8){
			pop1=stack.pop();
			pop2=stack.pop();
			stack.push({type:1,value:arr[i].value(pop2.value,pop1.value)});
		}
		else if(arr[i].type===10){
			pop1=stack.pop();
			pop2=stack.pop();
			if(typeof pop2.type==="undefined"){
				pop2.value=pop2.concat(pop1);
				pop2.value.push(arr[i]);
				stack.push(pop2);
			}
			else if (typeof pop1.type==="undefined") {
				pop1.unshift(pop2);
				pop1.push(arr[i]);
				stack.push(pop1);
			}
			else{
				stack.push({type:1,value:arr[i].value(pop2.value,pop1.value)});
 }
		}
		else if(arr[i].type===2||arr[i].type===9){
			pop1=stack.pop();
			pop2=stack.pop();
			if(typeof pop2.type==="undefined"){
				pop2=pop2.concat(pop1);
				pop2.push(arr[i]);
				stack.push(pop2);
			}
			else if (typeof pop1.type==="undefined") {
				pop1.unshift(pop2);
				pop1.push(arr[i]);
				stack.push(pop1);
			}
			else{
				stack.push({type:1,value:arr[i].value(pop2.value,pop1.value)});
			}
		}
		else if(arr[i].type===12){
			pop1=stack.pop();
			if (typeof pop1.type!=="undefined") {
				pop1=[pop1];
			}
			pop2=stack.pop();
			pop3=stack.pop();
			stack.push({type:1,value:arr[i].value(pop3.value,pop2.value,new Mexp(pop1))});
		}
		else if(arr[i].type===13){
			if(bool){
				stack.push({value:UserDefined[arr[i].value],type:3});
			}
			else stack.push([arr[i]]);
		}
	}
	if (stack.length>1) {
		throw(new Mexp.Exception("Uncaught Syntax error"));
	}
	return stack[0].value>1000000000000000?"Infinity":parseFloat(stack[0].value.toFixed(15));
};
Mexp.eval=function(str,tokens,obj){
	if (typeof tokens==="undefined") {
		return this.lex(str).toPostfix().postfixEval();
	}
	else if (typeof obj==="undefined") {
		if (typeof tokens.length!=="undefined") 
			return this.lex(str,tokens).toPostfix().postfixEval();
		else
			return this.lex(str).toPostfix().postfixEval(tokens);
	}
	else
		return this.lex(str,tokens).toPostfix().postfixEval(obj);
};
module.exports=Mexp;
},{"./postfix.js":4}]},{},[1])(1)
});

Back to File Manager