Thoughts on search engine,cloud,big data,linux,java,lucene,hadoop

Expression Calculator

Expression Calculator
Expression:
 
  Evaluate  
Variable Name :
Variable Value :
Add Variable

Usage:

1. Input math expressions in the Expression textbox, click "Evaluate" to calculate the value;

2. You can use arithmetic operators, and functions, for example: (33+50*2- 234^2)/6.

3. Supported arithmetic operators: +,-,*,/,%,^

4. Functions: AVG,ABS,ACOS,ASIN,ATAN,COS,LOG,MAX,MIN,SQRT,TAN

5. You can use variables in your expression too; Fill in a variable name and value, click "Add Variable"

6. Expression with variables: (3+a)*a-4, here a is a variable you defined in step 5.
Plus more than one variables are supported.






var MONTH_NAMES=new Array('January','February','March','April','May','June','July','August','September','October','November','December','Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'); var DAY_NAMES=new Array('Sunday','Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sun','Mon','Tue','Wed','Thu','Fri','Sat'); function LZ(x) {return(x<0||x>9?"":"0")+x}

// ------------------------------------------------------------------ // isDate ( date_string, format_string ) // Returns true if date string matches format of format string and // is a valid date. Else returns false. // It is recommended that you trim whitespace around the value before // passing it to this function, as whitespace is NOT ignored! // ------------------------------------------------------------------ function isDate(val,format) { var date=getDateFromFormat(val,format); if (date==0) { return false; } return true; }

// ------------------------------------------------------------------- // compareDates(date1,date1format,date2,date2format) // Compare two date strings to see which is greater. // Returns: // 1 if date1 is greater than date2 // 0 if date2 is greater than date1 of if they are the same // -1 if either of the dates is in an invalid format // ------------------------------------------------------------------- function compareDates(date1,dateformat1,date2,dateformat2) { var d1=getDateFromFormat(date1,dateformat1); var d2=getDateFromFormat(date2,dateformat2); if (d1==0 || d2==0) { return -1; } else if (d1 > d2) { return 1; } return 0; }

// ------------------------------------------------------------------ // formatDate (date_object, format) // Returns a date in the output format specified. // The format string uses the same abbreviations as in getDateFromFormat() // ------------------------------------------------------------------ function formatDate(date,format) { format=format+""; var result=""; var i_format=0; var c=""; var token=""; var y=date.getYear()+""; var M=date.getMonth()+1; var d=date.getDate(); var E=date.getDay(); var H=date.getHours(); var m=date.getMinutes(); var s=date.getSeconds(); var yyyy,yy,MMM,MM,dd,hh,h,mm,ss,ampm,HH,H,KK,K,kk,k; // Convert real date parts into formatted versions var value=new Object(); if (y.length < 4) {y=""+(y-0+1900);} value["y"]=""+y; value["yyyy"]=y; value["yy"]=y.substring(2,4); value["M"]=M; value["MM"]=LZ(M); value["MMM"]=MONTH_NAMES[M-1]; value["NNN"]=MONTH_NAMES[M+11]; value["d"]=d; value["dd"]=LZ(d); value["E"]=DAY_NAMES[E+7]; value["EE"]=DAY_NAMES[E]; value["H"]=H; value["HH"]=LZ(H); if (H==0){value["h"]=12;} else if (H>12){value["h"]=H-12;} else {value["h"]=H;} value["hh"]=LZ(value["h"]); if (H>11){value["K"]=H-12;} else {value["K"]=H;} value["k"]=H+1; value["KK"]=LZ(value["K"]); value["kk"]=LZ(value["k"]); if (H > 11) { value["a"]="PM"; } else { value["a"]="AM"; } value["m"]=m; value["mm"]=LZ(m); value["s"]=s; value["ss"]=LZ(s); while (i_format < format.length) { c=format.charAt(i_format); token=""; while ((format.charAt(i_format)==c) && (i_format < format.length)) { token += format.charAt(i_format++); } if (value[token] != null) { result=result + value[token]; } else { result=result + token; } } return result; } // ------------------------------------------------------------------ // Utility functions for parsing in getDateFromFormat() // ------------------------------------------------------------------ function _isInteger(val) { var digits="1234567890"; for (var i=0; i < val.length; i++) { if (digits.indexOf(val.charAt(i))==-1) { return false; } } return true; } function _getInt(str,i,minlength,maxlength) { for (var x=maxlength; x>=minlength; x--) { var token=str.substring(i,i+x); if (token.length < minlength) { return null; } if (_isInteger(token)) { return token; } } return null; } // ------------------------------------------------------------------ // getDateFromFormat( date_string , format_string ) // // This function takes a date string and a format string. It matches // If the date string matches the format string, it returns the // getTime() of the date. If it does not match, it returns 0. // ------------------------------------------------------------------ function getDateFromFormat(val,format) { val=val+""; format=format+""; var i_val=0; var i_format=0; var c=""; var token=""; var token2=""; var x,y; var now=new Date(); var year=now.getYear(); var month=now.getMonth()+1; var date=1; var hh=now.getHours(); var mm=now.getMinutes(); var ss=now.getSeconds(); var ampm=""; while (i_format < format.length) { // Get next token from format string c=format.charAt(i_format); token=""; while ((format.charAt(i_format)==c) && (i_format < format.length)) { token += format.charAt(i_format++); } // Extract contents of value based on format token if (token=="yyyy" || token=="yy" || token=="y") { if (token=="yyyy") { x=4;y=4; } if (token=="yy") { x=2;y=2; } if (token=="y") { x=2;y=4; } year=_getInt(val,i_val,x,y); if (year==null) { return 0; } i_val += year.length; if (year.length==2) { if (year > 70) { year=1900+(year-0); } else { year=2000+(year-0); } } } else if (token=="MMM"||token=="NNN"){ month=0; for (var i=0; i11)) { month=i+1; if (month>12) { month -= 12; } i_val += month_name.length; break; } } } if ((month < 1)||(month>12)){return 0;} } else if (token=="EE"||token=="E"){ for (var i=0; i12)){return 0;} i_val+=month.length;} else if (token=="dd"||token=="d") { date=_getInt(val,i_val,token.length,2); if(date==null||(date<1)||(date>31)){return 0;} i_val+=date.length;} else if (token=="hh"||token=="h") { hh=_getInt(val,i_val,token.length,2); if(hh==null||(hh<1)||(hh>12)){return 0;} i_val+=hh.length;} else if (token=="HH"||token=="H") { hh=_getInt(val,i_val,token.length,2); if(hh==null||(hh<0)||(hh>23)){return 0;} i_val+=hh.length;} else if (token=="KK"||token=="K") { hh=_getInt(val,i_val,token.length,2); if(hh==null||(hh<0)||(hh>11)){return 0;} i_val+=hh.length;} else if (token=="kk"||token=="k") { hh=_getInt(val,i_val,token.length,2); if(hh==null||(hh<1)||(hh>24)){return 0;} i_val+=hh.length;hh--;} else if (token=="mm"||token=="m") { mm=_getInt(val,i_val,token.length,2); if(mm==null||(mm<0)||(mm>59)){return 0;} i_val+=mm.length;} else if (token=="ss"||token=="s") { ss=_getInt(val,i_val,token.length,2); if(ss==null||(ss<0)||(ss>59)){return 0;} i_val+=ss.length;} else if (token=="a") { if (val.substring(i_val,i_val+2).toLowerCase()=="am") {ampm="AM";} else if (val.substring(i_val,i_val+2).toLowerCase()=="pm") {ampm="PM";} else {return 0;} i_val+=2;} else { if (val.substring(i_val,i_val+token.length)!=token) {return 0;} else {i_val+=token.length;} } } // If there are any trailing characters left in the value, it doesn't match if (i_val != val.length) { return 0; } // Is date valid for month? if (month==2) { // Check for leap year if ( ( (year%4==0)&&(year%100 != 0) ) || (year%400==0) ) { // leap year if (date > 29){ return 0; } } else { if (date > 28) { return 0; } } } if ((month==4)||(month==6)||(month==9)||(month==11)) { if (date > 30) { return 0; } } // Correct hours value if (hh<12 && ampm=="PM") { hh=hh-0+12; } else if (hh>11 && ampm=="AM") { hh-=12; } var newdate=new Date(year,month-1,date,hh,mm,ss); return newdate.getTime(); }

// ------------------------------------------------------------------ // parseDate( date_string [, prefer_euro_format] ) // // This function takes a date string and tries to match it to a // number of possible date formats to get the value. It will try to // match against the following international formats, in this order: // y-M-d MMM d, y MMM d,y y-MMM-d d-MMM-y MMM d // M/d/y M-d-y M.d.y MMM-d M/d M-d // d/M/y d-M-y d.M.y d-MMM d/M d-M // A second argument may be passed to instruct the method to search // for formats like d/M/y (european format) before M/d/y (American). // Returns a Date object or null if no patterns match. // ------------------------------------------------------------------ function parseDate(val) { var preferEuro=(arguments.length==2)?arguments[1]:false; generalFormats=new Array('y-M-d','MMM d, y','MMM d,y','y-MMM-d','d-MMM-y','MMM d'); monthFirst=new Array('M/d/y','M-d-y','M.d.y','MMM-d','M/d','M-d'); dateFirst =new Array('d/M/y','d-M-y','d.M.y','d-MMM','d/M','d-M'); var checkList=new Array('generalFormats',preferEuro?'dateFirst':'monthFirst',preferEuro?'monthFirst':'dateFirst'); var d=null; for (var i=0; i

// Stack object constructor function Stack() { this.arrStack = new Array(); this.intIndex = 0;

this.Size = getSize; this.IsEmpty = isStackEmpty; this.Push = pushElement; this.Pop = popElement; this.Get = getElement; this.toString = dumpStack; }

// Converts stack contents into a comma seperated string function dumpStack() { var intCntr = 0; var strRet = ""; if (this.intIndex == 0) return null; for (intCntr = 0; intCntr < this.intIndex; intCntr++) { if (strRet.length == 0) strRet += this.arrStack[intCntr]; else strRet += "," + this.arrStack[intCntr]; } return strRet; } // Returns size of stack function getSize() { return this.intIndex; } // This method tells us if this Stack object is empty function isStackEmpty() { if (this.intIndex == 0) return true; else return false; } // This method pushes a new element onto the top of the stack function pushElement(newData) { // Assign our new element to the top debugAssert ("Pushing " + newData); this.arrStack[this.intIndex] = newData; this.intIndex++; } // This method pops the top element off of the stack function popElement() { var retVal; retVal = null; if (this.intIndex > 0) { // Assign our new element to the top this.intIndex--; retVal = this.arrStack[this.intIndex]; } return retVal; }

// Gets an element at a particular offset from top of the stack function getElement(intPos) { var retVal;

//alert ("Size : " + this.intIndex + ", Index " + intPos); if (intPos >= 0 && intPos < this.intIndex) retVal = this.arrStack[this.intIndex - intPos - 1]; return retVal; }

var lstAlpha = "a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,uv,w,x,y,z"; var lstDigits = "0,1,2,3,4,5,6,7,8,9"; var lstArithOps = "^,*,/,%,+,-"; var lstLogicOps = "!,&,|"; var lstCompaOps = "<,<=,>,>=,<>,="; var lstFuncOps = ["AVG","ABS","ACOS","ASC","ASIN","ATAN","CDATE","CHR","COS","DATE","FIX","HEX","IIF","LCASE","LEFT","LOG","MAX","MID","MIN","RIGHT","ROUND","SIN","SQRT","TAN","UCASE"];

/*------------------------------------------------------------------------------ * NAME : Tokanize * PURPOSE : Breaks the string into a token array. It also checks whether the * parenthesis, single quotes and double quotes are balanced or not. * PARAMETERS : pstrExpression - The string from which token array is to be * constructed. * RETURNS : An array of tokens. * THROWS : Unterminated string constant - Single/Double quotes are not * properly terminated * Unbalanced parenthesis - Opening/closing braces are not balanced *----------------------------------------------------------------------------*/ function Tokanize(pstrExpression) { var intCntr, intBraces; var arrTokens; var intIndex, intPos; var chrChar, chrNext; var strToken, prevToken;

intCntr = 0; intBraces = 0; intIndex = 0; strToken = ""; arrTokens = new Array(); pstrExpression = Trim(pstrExpression); while (intCntr < pstrExpression.length) { prevToken = ""; chrChar = pstrExpression.substr(intCntr, 1); if (window) if (window.status) window.status = "Processing " + chrChar; switch (chrChar) { case " " : if (strToken.length > 0) { arrTokens[intIndex] = strToken; intIndex++; strToken = ""; } break; case "(": intBraces++; if (strToken.length > 0) { arrTokens[intIndex] = strToken; intIndex++; strToken = ""; } arrTokens[intIndex] = chrChar; intIndex++; break; case ")" : intBraces--; if (strToken.length > 0) { arrTokens[intIndex] = strToken; intIndex++; strToken = ""; } arrTokens[intIndex] = chrChar; intIndex++; break; case "^" : if (strToken.length > 0) { arrTokens[intIndex] = strToken; intIndex++; strToken = ""; } arrTokens[intIndex] = chrChar; intIndex++; break; case "*" : if (strToken.length > 0) { arrTokens[intIndex] = strToken; intIndex++; strToken = ""; } arrTokens[intIndex] = chrChar; intIndex++; break; case "/" : if (strToken.length > 0) { arrTokens[intIndex] = strToken; intIndex++; strToken = ""; } arrTokens[intIndex] = chrChar; intIndex++; break; case "%" : if (strToken.length > 0) { arrTokens[intIndex] = strToken; intIndex++; strToken = ""; } arrTokens[intIndex] = chrChar; intIndex++; break; case "&" : if (strToken.length > 0) { arrTokens[intIndex] = strToken; intIndex++; strToken = ""; } arrTokens[intIndex] = chrChar; intIndex++; break; case "|" : if (strToken.length > 0) { arrTokens[intIndex] = strToken; intIndex++; strToken = ""; } arrTokens[intIndex] = chrChar; intIndex++; break; case "," : if (strToken.length > 0) { arrTokens[intIndex] = strToken; intIndex++; strToken = ""; } arrTokens[intIndex] = chrChar; intIndex++; break; case "-" : if (strToken.length > 0) { arrTokens[intIndex] = strToken; intIndex++; strToken = ""; } chrNext = pstrExpression.substr(intCntr + 1, 1); if (arrTokens.length > 0) prevToken = arrTokens[intIndex - 1]; if (intCntr == 0 || ((IsOperator(prevToken) || prevToken == "(" || prevToken == ",") && (IsDigit(chrNext) || chrNext == "("))) { // Negative Number strToken += chrChar; } else { arrTokens[intIndex] = chrChar; intIndex++; strToken = ""; } break; case "+" : if (strToken.length > 0) { arrTokens[intIndex] = strToken; intIndex++; strToken = ""; } chrNext = pstrExpression.substr(intCntr + 1, 1); if (arrTokens.length > 0) prevToken = arrTokens[intIndex - 1]; if (intCntr == 0 || ((IsOperator(prevToken) || prevToken == "(" || prevToken == ",") && (IsDigit(chrNext) || chrNext == "("))) { // positive Number strToken += chrChar; } else { arrTokens[intIndex] = chrChar; intIndex++; strToken = ""; } break; case "<" : chrNext = pstrExpression.substr(intCntr + 1, 1); if (strToken.length > 0) { arrTokens[intIndex] = strToken; intIndex++; strToken = ""; } if (chrNext == "=") { arrTokens[intIndex] = chrChar + "="; intIndex++; intCntr++; } else if (chrNext == ">") { arrTokens[intIndex] = chrChar + ">"; intIndex++; intCntr++; } else { arrTokens[intIndex] = chrChar; intIndex++; } break; case ">" : chrNext = pstrExpression.substr(intCntr + 1, 1); if (strToken.length > 0) { arrTokens[intIndex] = strToken; intIndex++; strToken = ""; } if (chrNext == "=") { arrTokens[intIndex] = chrChar + "="; intIndex++; intCntr++; } else { arrTokens[intIndex] = chrChar; intIndex++; } break; case "=" : if (strToken.length > 0) { arrTokens[intIndex] = strToken; intIndex++; strToken = ""; } arrTokens[intIndex] = chrChar; intIndex++; break; case "'" : if (strToken.length > 0) { arrTokens[intIndex] = strToken; intIndex++; strToken = ""; }

intPos = pstrExpression.indexOf(chrChar, intCntr + 1); if (intPos < 0) throw "Unterminated string constant"; else { strToken += pstrExpression.substring(intCntr + 1, intPos); arrTokens[intIndex] = strToken; intIndex++; strToken = ""; intCntr = intPos; } break; case "\"" : if (strToken.length > 0) { arrTokens[intIndex] = strToken; intIndex++; strToken = ""; }

intPos = pstrExpression.indexOf(chrChar, intCntr + 1); if (intPos < 0) { throw "Unterminated string constant"; } else { strToken += pstrExpression.substring(intCntr + 1, intPos); arrTokens[intIndex] = strToken; intIndex++; strToken = ""; intCntr = intPos; } break; default : strToken += chrChar; break; } intCntr++; } if (intBraces > 0) throw "Unbalanced parenthesis!";

if (strToken.length > 0) arrTokens[intIndex] = strToken; return arrTokens; }

/*------------------------------------------------------------------------------ * NAME : IsDigit * PURPOSE : Checks whether the character specified by chrArg is a numeric * character. * PARAMETERS : chrArg - The character to be checked * RETURNS : False - If chrArg is not a numeric character * True - Otherwise *----------------------------------------------------------------------------*/ function IsDigit(chrArg) { if (lstDigits.indexOf(chrArg) >= 0) return true; return false; }

/*------------------------------------------------------------------------------ * NAME : IsAlpha * PURPOSE : Checks whether the character specified by chrArg is a alphabet * PARAMETERS : chrArg - The character to be checked * RETURNS : False - If chrArg is not a alphabet * True - Otherwise *----------------------------------------------------------------------------*/ function IsAlpha(chrArg) { if (lstAlpha.indexOf(chrArg) >= 0 || lstAlpha.toUpperCase().indexOf(chrArg) >= 0) return true; return false; }

/*------------------------------------------------------------------------------ * NAME : IsOperator * PURPOSE : Checks whether the string specified by strArg is an operator * PARAMETERS : strArg - The string to be checked * RETURNS : False - If strArg is not an operator symbol * True - Otherwise *----------------------------------------------------------------------------*/ function IsOperator(strArg) { if (lstArithOps.indexOf(strArg) >= 0 || lstCompaOps.indexOf(strArg) >= 0) return true; return false; }

/*------------------------------------------------------------------------------ * NAME : IsFunction * PURPOSE : Checks whether the string specified by strArg is a function name * PARAMETERS : strArg - The string to be checked * RETURNS : False - If strArg is not a valid built-in function name. * True - Otherwise *----------------------------------------------------------------------------*/ function IsFunction(strArg) { var idx = 0;

strArg = strArg.toUpperCase(); for (idx = 0; idx < lstFuncOps.length; idx++) { if (strArg == lstFuncOps[idx]) return true; } return false; } /*------------------------------------------------------------------------------ * NAME : Trim * PURPOSE : Removes trailing and leading spaces from a string. * PARAMETERS : pstrVal - The string from which leading and trailing spaces are * to be removed. * RETURNS : A string with leading and trailing spaces removed. *----------------------------------------------------------------------------*/ function Trim(pstrVal) { if (pstrVal.length < 1) return ""; pstrVal = RTrim(pstrVal); pstrVal = LTrim(pstrVal); if (pstrVal == "") return ""; else return pstrVal; } /*------------------------------------------------------------------------------ * NAME : RTrim * PURPOSE : Removes trailing spaces from a string. * PARAMETERS : pstrValue - The string from which trailing spaces are to be removed. * RETURNS : A string with trailing spaces removed. *----------------------------------------------------------------------------*/ function RTrim(pstrValue) { var w_space = String.fromCharCode(32); var v_length = pstrValue.length; var strTemp = ""; if(v_length < 0) { return""; } var iTemp = v_length - 1; while(iTemp > -1) { if(pstrValue.charAt(iTemp) == w_space) { } else { strTemp = pstrValue.substring(0, iTemp + 1); break; } iTemp = iTemp - 1; } return strTemp; }

/*------------------------------------------------------------------------------ * NAME : LTrim * PURPOSE : Removes leading spaces from a string. * PARAMETERS : pstrValue - The string from which leading spaces are to be removed. * RETURNS : A string with leading spaces removed. *----------------------------------------------------------------------------*/ function LTrim(pstrValue) { var w_space = String.fromCharCode(32); if(v_length < 1) { return ""; } var v_length = pstrValue.length; var strTemp = ""; var iTemp = 0; while(iTemp < v_length) { if(pstrValue.charAt(iTemp) == w_space) { } else { strTemp = pstrValue.substring(iTemp, v_length); break; } iTemp = iTemp + 1; } return strTemp; }

//alert (6 % 7);

var exp = new Expression("");

function Convert() { var frm = document.frmMain; var arrToks; var arrPFix; var strExp; var intCntr;

strExp = frm.txtExp.value; if (strExp == null || strExp == undefined) { alert ("No expression is specified!"); return false; }

exp.Expression(strExp); frm.txtResult.value = exp.Parse(); return false; }

function Compute() { var frm; var strExp;

frm = document.frmMain; strExp = frm.txtExp.value; exp.Expression(strExp); frm.txtResult.value = exp.Evaluate(); }

function AddVar() { var frm;

frm = document.frmMain; exp.AddVariable(frm.txtVarName.value, frm.txtVarValue.value); return true; }

function Reset() { exp.Reset(); }

Expression: