/*
 * FormulaVariableMath.java
 *
 * Created on July 21, 2006, 9:35 AM
 *
 * Copyright 2006 Lee Lofgern and Accounting Enhancements Inc Licensed under the Apache License, Version 2.0 (the "License"); 
 * you may not use this file except in compliance with the License. 
 * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 
 * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed 
 * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and limitations under the License.
 */

package com.accountingenhancements.formula;

import com.accountingenhancements.common.SupportParameters;
import java.text.ParseException;

/**
 *
 *  @author Lee lofgren lofgren_opensource@accountingenhancements.com
 * @version 0.1009102006
 */
public class FormulaVariableMath {
    
    /** Creates a new instance of FormulaVariableMath */
    public FormulaVariableMath() {
    }
    
    /**
     *Apply unary operations to variable
     *@param unaryOperator FormulaVariable.TYPE_OPERATOR_UNARY_BIT_NOT or FormulaVariable.TYPE_OPERATOR_UNARY_NOT
     *@param variable the variable to which the unary operation is to be applied
     *@param variableList a list of variables, used to resolve variable if variable is of TYPE_VARIABLE, TYPE_FUNCTION, or TYPE_FORMULA
     *@param supportParameters a list of function parameters, used to resolve variable if variable is of TYPE_FORMULA or TYPE_FUNCTION
     *@param functionList a list of functions, used to resolve variable if variable is of TYPE_FORMULA or TYPE_FUNCTION
     *@param resolveEverythingAboveLevel reflects level at which TYPE_VARIABLE, TYPE_FUNCTION, and TYPE_FORMULA variables need to be re-solved.
     *@return FormulaVariable containing the result of the operation. If of the TYPE_OPERATOR_UNARY_NOT variety then a TYPE_BOOLEAN variable is returned.
     *@throws ParseException, ArithmeticException, ClassNotFoundException
     */
    public static FormulaVariable solveUnaryOfVariable(int unaryOperator, FormulaVariable variable, FormulaVariableList variableList, SupportParameters supportParameters, FormulaFunctionList functionList, int resolveEverythingAboveLevel) throws ParseException, java.lang.ArithmeticException, ClassNotFoundException{
        FormulaVariable result=null;
        String operatorSymbol;
        int type;
        String valueString;
        char[] charArray;
        
        if (variable==null)throw new java.lang.ArithmeticException("Unable to apply unaryOperator to a null value");
        
        operatorSymbol=Integer.toString(unaryOperator);
        if(unaryOperator>=0&&unaryOperator<FormulaVariable.TYPE_TO_STRING_ARRAY.length) operatorSymbol=FormulaVariable.TYPE_TO_STRING_ARRAY[unaryOperator];
        
        result = variable.solve(variableList,0,supportParameters,functionList,resolveEverythingAboveLevel);
        
        if(result==null)throw new java.lang.ArithmeticException("variable.solve(...) returned a null value. Unable to apply unaryOperator to a null value");
        
        type=variable.getVariableType();
        if(unaryOperator==FormulaVariable.TYPE_OPERATOR_UNARY_BIT_NOT){
            switch (type){
                case FormulaVariable.TYPE_BOOLEAN:
                    if(result.getBoolean()==true)result.setValue(false); else result.setValue(true);
                    break;
                
                case FormulaVariable.TYPE_DATE:
                    throw new java.lang.ArithmeticException("Unable to carry out unary operation: TYPE_OPERATOR_UNARY_BIT_NOT(~) on a TYPE_DATE FormulaVariable: "+result.toString());
                    
                case FormulaVariable.TYPE_DOUBLE:
                    throw new java.lang.ArithmeticException("Unable to carry out unary operation: TYPE_OPERATOR_UNARY_BIT_NOT(~) on a TYPE_DOUBLE FormulaVariable: "+result.toString());
                
                case FormulaVariable.TYPE_STRING:
                    charArray=result.getString().toCharArray();
                    for(int i=0;i<charArray.length;i++)charArray[i]=(char)~charArray[i];
                    result.setValue(String.valueOf(charArray));
                    break;
                    
                case FormulaVariable.TYPE_LONG:
                    result.setValue(~result.getLong());
                    break;
                
                default:
                    throw new java.lang.ArithmeticException("Unable to carry out unary operation: TYPE_OPERATOR_UNARY_BIT_NOT(~) on this FormulaVariable: "+result.toString());

            }
        } else if(unaryOperator==FormulaVariable.TYPE_OPERATOR_UNARY_NOT){
            switch (type){
                case FormulaVariable.TYPE_DOUBLE:
                case FormulaVariable.TYPE_LONG:
                case FormulaVariable.TYPE_STRING:
                    result=new FormulaVariable("",!result.getBoolean(),result.getLevel());
                    break;
                case FormulaVariable.TYPE_BOOLEAN: 
                    if(result.getBoolean()==true)result.setValue(false); else result.setValue(true);
                    break;
                
                case FormulaVariable.TYPE_DATE:
                    if(result.isNull())result=new FormulaVariable("",true,result.getLevel()); else result=new FormulaVariable("",false,result.getLevel());
                    break;
                    
                default:
                    throw new java.lang.ArithmeticException("Unable to carry out unary operation:: TYPE_OPERATOR_UNARY_NOT(!) on this FormulaVariable: "+result.toString());

            }
        } else {
            throw new java.lang.ArithmeticException("Unrecognized unary operator: "+operatorSymbol);
        }
        
        return result;
    }
    
    /**
     *Please <bold>note</bold>, when doing multiplication or division with doubles (where both variables are TYPE_DOUBLE, precision becomes important.<br/>
     * The lowest precision determines the number of digits to the right of the decimal point.<br/>
     * Ex: Assuming the precision of 10 is 2 (Not overriden by user so 2 digits long) .234 * 10 = 2.3 therefore scale=1<br/>
     * However, differing from real math, 12.345 * 10 = 123 (scale=0) instead of 120 (scale=-1) as regular math requires it because 
     * I am assuming user intent is that accuracy is always at least to the 1's place.<br/>
     * On a related note if one variable is a TYPE_LONG or TYPE_BOOLEAN , that variable defaults to a precision of 17, so in this case the precision ends up being the same as the precision of the only double value.
     * This means (Assuming scale of 12.345 is 5) that 12.345 * 10 = 123.45 and scale=2. When adding or subtracting with only 1 variable being TYPE_DOUBLE, the scale is the scale of the TYPE_DOUBLE. The TYPE_LONG scale==0 is ignored.<br/>
     *The upshot is two TYPE_DOUBLEs can give you a different result than a TYPE_DOUBLE and TYPE_LONG given the same values.
     */
    
    public static FormulaVariable applyOperatorToTwoVariables(FormulaVariable leftVariable, int operator, FormulaVariable rightVariable, FormulaVariableList variableList, SupportParameters supportParameters, FormulaFunctionList functionList, int resolveEverythingAboveLevel) throws ParseException, java.lang.ArithmeticException, ClassNotFoundException{
        return applyOperatorToTwoVariables(null,leftVariable,operator,null,rightVariable,variableList,supportParameters,functionList,resolveEverythingAboveLevel);
    }
    
    /**
     *Please <bold>note</bold>, when doing multiplication or division with doubles (where both variables are TYPE_DOUBLE, precision becomes important.<br/>
     * The lowest precision determines the number of digits to the right of the decimal point.<br/>
     * Ex: Assuming the precision of 10 is 2 (Not overriden by user so 2 digits long) .234 * 10 = 2.3 therefore scale=1<br/>
     * However, differing from real math, 12.345 * 10 = 123 (scale=0) instead of 120 (scale=-1) as regular math requires it because 
     * I am assuming user intent is that accuracy is always at least to the 1's place.<br/>
     * On a related note if one variable is a TYPE_LONG or TYPE_BOOLEAN , that variable defaults to a precision of 17, so in this case the precision ends up being the same as the precision of the only double value.<br/>
     * This means (Assuming scale of 12.345 is 5) that 12.345 * 10 = 123.45 and scale=2. When adding or subtracting with only 1 variable being TYPE_DOUBLE, the scale is the scale of the TYPE_DOUBLE. The TYPE_LONG scale==0 is ignored.<br/>
     *The upshot is two TYPE_DOUBLEs can give you a different result than a TYPE_DOUBLE and TYPE_LONG given the same values.<br/>
     *When working with Dates, If either or both arguments is/are TYPE_STRING(s) but the detectVariableType() confirms that it/they are date(s), the string(s) will be treated as date(s).<br/>
     */
    
    public static FormulaVariable applyOperatorToTwoVariables(Integer optionalLeftUnaryOperator,FormulaVariable leftVariable, int operator, Integer optionalRightUnaryOperator, FormulaVariable rightVariable, FormulaVariableList variableList, SupportParameters supportParameters, FormulaFunctionList functionList, int resolveEverythingAboveLevel) throws ParseException, java.lang.ArithmeticException, ClassNotFoundException{
        FormulaVariable result=null;
        String leftType;
        String rightType;
        String operatorType;
        int tmpVal;
        long leftLong;
        long rightLong;
        long resultLong;
        String leftString;
        String rightString;
        String resultString;
        boolean leftBoolean;
        boolean rightBoolean;
        boolean resultBoolean;
        double leftDouble;
        double rightDouble;
        double resultDouble;
        java.util.Date leftDate;
        java.util.Date rightDate;
        java.util.Date resultDate;
        int level;
        int scale;
        int precision;
        //long to long, long to boolean, or boolean to long (boolean treated as 1 or 0)
        //String to String or either argument is a string
        //boolean to boolean
        //Date to Date (Compare or Subtract) Also Date to String, String to date, and String to String when the String contains a date.
        //Date to long, or Date to double (Add or Subtract)
        //double to double, double to long, or long to double
        
        operatorType=Integer.toString(operator);
        if(operator>-1&&operator<FormulaVariable.TYPE_TO_STRING_ARRAY.length)operatorType=FormulaVariable.TYPE_TO_STRING_ARRAY[operator];
        if(FormulaVariable.testIsOperator(operator)==false||FormulaVariable.testIsUnaryOperator(operator)==true) throw new java.lang.ArithmeticException("Invalid operator: "+operatorType);
        
        //If leftVariable requires solving, then solve.
        if(leftVariable==null||leftVariable.isNull()) throw new java.lang.ArithmeticException("Left side variable is null");
        if ((tmpVal=leftVariable.getVariableType())==FormulaVariable.TYPE_FORMULA||tmpVal==FormulaVariable.TYPE_FUNCTION||tmpVal==FormulaVariable.TYPE_VARIABLE)leftVariable=leftVariable.solve(variableList,0,supportParameters,functionList,resolveEverythingAboveLevel);
        if(leftVariable==null||leftVariable.isNull()) throw new java.lang.ArithmeticException("Solution to Left side variable is null");
        if(optionalLeftUnaryOperator!=null&&FormulaVariable.testIsUnaryOperator(optionalLeftUnaryOperator))leftVariable=solveUnaryOfVariable(optionalLeftUnaryOperator,leftVariable,variableList, supportParameters, functionList, resolveEverythingAboveLevel);
        //If this is an OR or AND operation then check whether there is any point in going further so that we don't solve the rightVariable prematurely. The Right side variable does not need to be valid unless the result of the left side variable is insufficient to solve the equation.
        
        //If this is part of and LOGICAL OR or LOGICAL AND then we may be done. If we are done, set result to the new result and return
        result=null;
        if(operator==FormulaVariable.TYPE_OPERATOR_OR&&leftVariable.getBoolean()==true){
           result=new FormulaVariable("",true,leftVariable.getHighestLevel()); 
        } else if (operator==FormulaVariable.TYPE_OPERATOR_AND&&leftVariable.getBoolean()==false){
            result=new FormulaVariable("",false,leftVariable.getHighestLevel()); 
        }
        if(result==null){
            //If rightVariable requires solving, then solve
            if(rightVariable==null||rightVariable.isNull()) throw new java.lang.ArithmeticException("Right side variable is null");
            if ((tmpVal=rightVariable.getVariableType())==FormulaVariable.TYPE_FORMULA||tmpVal==FormulaVariable.TYPE_FUNCTION||tmpVal==FormulaVariable.TYPE_VARIABLE)rightVariable=rightVariable.solve(variableList,0,supportParameters,functionList,resolveEverythingAboveLevel);
            if(rightVariable==null||rightVariable.isNull()) throw new java.lang.ArithmeticException("Solution to right side variable is null");
            if(optionalRightUnaryOperator!=null&&FormulaVariable.testIsUnaryOperator(optionalRightUnaryOperator))rightVariable=solveUnaryOfVariable(optionalRightUnaryOperator,rightVariable,variableList, supportParameters, functionList, resolveEverythingAboveLevel);
            
            
            //Get highest level used to solve equation
            level=leftVariable.getHighestLevel();
            if((tmpVal=rightVariable.getHighestLevel())>level)level=tmpVal;

            //Get String descriptions of operator, leftVariableType, and rightVariableType for error messages.
            operatorType=Integer.toString(operator);
            if(operator>-1&&operator<FormulaVariable.TYPE_TO_STRING_ARRAY.length)operatorType=FormulaVariable.TYPE_TO_STRING_ARRAY[operator];
            tmpVal=leftVariable.getVariableType();
            leftType=Integer.toString(tmpVal);
            if(tmpVal>-1&&tmpVal<FormulaVariable.TYPE_TO_STRING_ARRAY.length)leftType=FormulaVariable.TYPE_TO_STRING_ARRAY[tmpVal];
            tmpVal=rightVariable.getVariableType();
            rightType=Integer.toString(tmpVal);
            if(tmpVal>-1&&tmpVal<FormulaVariable.TYPE_TO_STRING_ARRAY.length)rightType=FormulaVariable.TYPE_TO_STRING_ARRAY[tmpVal];

            //Solve problem
            if((leftVariable.getVariableType()==FormulaVariable.TYPE_LONG&&rightVariable.getVariableType()==FormulaVariable.TYPE_LONG)||(leftVariable.getVariableType()==FormulaVariable.TYPE_BOOLEAN&&rightVariable.getVariableType()==FormulaVariable.TYPE_LONG)||(leftVariable.getVariableType()==FormulaVariable.TYPE_LONG&&rightVariable.getVariableType()==FormulaVariable.TYPE_BOOLEAN)){
                leftLong=leftVariable.getLong();
                rightLong=rightVariable.getLong();
                resultLong=applyOperatorToTwoVariables(leftLong,operator,rightLong);
                result=new FormulaVariable("",resultLong,level);
            } else if(leftVariable.getVariableType()==FormulaVariable.TYPE_BOOLEAN&&rightVariable.getVariableType()==FormulaVariable.TYPE_BOOLEAN){
                leftBoolean=leftVariable.getBoolean();
                rightBoolean = rightVariable.getBoolean();
                resultBoolean = applyOperatorToTwoVariables(leftBoolean,operator,rightBoolean);
                result=new FormulaVariable("",resultBoolean,4,level);
            } else if((leftVariable.getVariableType()==FormulaVariable.TYPE_DATE&&rightVariable.getVariableType()==FormulaVariable.TYPE_DATE)||(leftVariable.getVariableType()==FormulaVariable.TYPE_DATE&&rightVariable.getVariableType()==FormulaVariable.TYPE_STRING&&FormulaVariable.detectVariableType(rightVariable.getString(),false)==FormulaVariable.TYPE_DATE)||(leftVariable.getVariableType()==FormulaVariable.TYPE_STRING&&rightVariable.getVariableType()==FormulaVariable.TYPE_DATE&&FormulaVariable.detectVariableType(leftVariable.getString(),false)==FormulaVariable.TYPE_DATE)||(leftVariable.getVariableType()==FormulaVariable.TYPE_STRING&&rightVariable.getVariableType()==FormulaVariable.TYPE_STRING&&FormulaVariable.detectVariableType(rightVariable.getString(),false)==FormulaVariable.TYPE_DATE&&FormulaVariable.detectVariableType(leftVariable.getString(),false)==FormulaVariable.TYPE_DATE)){
                leftDate=leftVariable.getDate();
                rightDate=rightVariable.getDate();
                if(FormulaVariable.testIsComparatorOperator(operator)){
                    resultBoolean=applyOperatorToCompareDates(leftDate,operator,rightDate);
                    result = new FormulaVariable("",resultBoolean,4,level);
                } else {
                    resultLong=applyOperatorToTwoVariables(leftDate,operator,rightDate);
                    result=new FormulaVariable("",resultLong,level);
                }
            } else if(leftVariable.getVariableType()==FormulaVariable.TYPE_DATE&&(rightVariable.getVariableType()==FormulaVariable.TYPE_LONG||rightVariable.getVariableType()==FormulaVariable.TYPE_DOUBLE)){
                leftDate=leftVariable.getDate();
                rightLong=rightVariable.getLong();
                resultDate=applyOperatorToTwoVariables(leftDate,operator,rightLong);
                if(resultDate==null)throw new java.lang.ArithmeticException("Unexpected received a null return value from date arithmetic: applyOperatorTwoTwoVariables(" +leftVariable.toString()+ ","+operatorType+","+rightVariable.toString()+")");
                result=new FormulaVariable("",resultDate,level);
            } else if((leftVariable.getVariableType()==FormulaVariable.TYPE_DOUBLE&&rightVariable.getVariableType()==FormulaVariable.TYPE_DOUBLE)||(leftVariable.getVariableType()==FormulaVariable.TYPE_DOUBLE&&rightVariable.getVariableType()==FormulaVariable.TYPE_LONG)||(leftVariable.getVariableType()==FormulaVariable.TYPE_LONG&&rightVariable.getVariableType()==FormulaVariable.TYPE_DOUBLE)){
                leftDouble=leftVariable.getDouble();
                rightDouble=rightVariable.getDouble();
                resultDouble=applyOperatorToTwoVariables(leftDouble, operator, rightDouble);

                //Figure out the scale and precision of this problem. If Adding or Subtracting then the scale used to determine the number of digits to the right of the decimal point else precision is used to determine the number of significant digits.
                scale=0;
                precision=17;
                if(leftVariable.getVariableType()==FormulaVariable.TYPE_DOUBLE){scale=leftVariable.getScale();precision=leftVariable.getPrecision();}
                if(rightVariable.getVariableType()==FormulaVariable.TYPE_DOUBLE&&(leftVariable.getVariableType()!=FormulaVariable.TYPE_DOUBLE||rightVariable.getScale()<scale))scale=rightVariable.getScale();
                if(rightVariable.getVariableType()==FormulaVariable.TYPE_DOUBLE&&(leftVariable.getVariableType()!=FormulaVariable.TYPE_DOUBLE||rightVariable.getPrecision()<precision))precision=rightVariable.getPrecision();
                //If multiply or divide then the precision determines the number of digits to the right of the decimal point. Ex: Assuming the precision of 10 is 2 (Not overriden by user). .234*10 = 2.3 However, differing from real math, 12.345 * 10 = 123 instead of 120 as regular math requires it because I am assuming user intent is that accuracy is always at least to the 1's place.
                if(operator!=FormulaVariable.TYPE_OPERATOR_PLUS&&operator!=FormulaVariable.TYPE_OPERATOR_MINUS){
                    resultLong=Double.valueOf(resultDouble).longValue();
                    if(resultLong<0)resultLong*=-1;
                    scale=precision-Long.toString(resultLong).length();
                    if (scale<0)scale=0;

                }
                result=new FormulaVariable("",resultDouble, scale, level);
                result.setPrecision(precision);
            } else if(leftVariable.getVariableType()==FormulaVariable.TYPE_STRING||rightVariable.getVariableType()==FormulaVariable.TYPE_STRING){
                leftString=leftVariable.getString();
                rightString=rightVariable.getString();
                if(FormulaVariable.testIsComparatorOperator(operator)){
                    resultBoolean = applyOperatorToCompareStrings(leftString,operator,rightString);
                    result = new FormulaVariable("",resultBoolean,level);
                } else {
                    resultString=applyOperatorToTwoVariables(leftString,operator,rightString);
                    if(resultString==null)result=new FormulaVariable("","",FormulaVariable.TYPE_STRING,0,level);
                    else result=new FormulaVariable("",resultString,FormulaVariable.TYPE_STRING,0,level);
                }
            } else {
                throw new java.lang.ArithmeticException("Operation with this  mix of variable types not supported \""+leftType+" "+operatorType+" "+rightType+"\". Values were ("+leftVariable.toString()+","+rightVariable.toString()+")");
            }

        }
        return result;
    }
    
    /**
     *@param left left value
     *@param operator operation to be applied to left and right values
     *@param right right value
     *@return the result of the computation
     *@throws ArithmeticException if operation is invalid for these values.
     */
    public static boolean applyOperatorToTwoVariables(boolean left , int operator, boolean right)throws java.lang.ArithmeticException{
        boolean result=false;
        String operatorSymbol=Integer.toString(operator);
        if(operator>=0&&operator<FormulaVariable.TYPE_TO_STRING_ARRAY.length)operatorSymbol=FormulaVariable.TYPE_TO_STRING_ARRAY[operator];
        if(operator==FormulaVariable.TYPE_OPERATOR_AND){
            result=left && right;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_BIT_AND) {
            result=left & right;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_BIT_OR) {
            result = left | right;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_BIT_XOR) {
            result = left ^ right;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_DIVIDE) {
            if(left==false && right==false)result=false;
            else if(left==true && right==false)result=true;
            else if(left==false && right==true)result=false;
            else if(left==true && right==true)result=true;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_EQUALS) {
            result = left==right;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_GREATER_THAN) {
            if(left==true&&right==false)result=true; else result=false;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_GREATER_THAN_OR_EQUAL) {
            if(left==true||left==right)result=true; else result=false;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_LESS_THAN) {
            if(left==false&&right==true)result=true; else result=false;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_LESS_THAN_OR_EQUAL) {
            if(left==false||left==right)result=true; else result=false;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_MINUS) {
            result=false;
            if(left==true&&right==false)result=true;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_MODULUS) {
            throw new java.lang.ArithmeticException("Can't solve for modulus of boolean values");
        } else if(operator==FormulaVariable.TYPE_OPERATOR_MULTIPLY) {
            if(left==true&&right==true)result=true; else result=false;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_NOT_EQUAL) {
            result=!(left==right);
        } else if(operator==FormulaVariable.TYPE_OPERATOR_OR) {
            result=left||right;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_PLUS) {
            if(left==true||right==true)result=true; else result=false;
        } else throw new java.lang.ArithmeticException("Unrecognized operator: "+operatorSymbol);
        
        return result;
    }
    
    /**
     *@param left left value
     *@param operator operation to be applied to left and right values
     *@param right right value
     *@return the result of the computation
     *@throws ArithmeticException if operation is invalid for these values.
     */
    public static long applyOperatorToTwoVariables(long left , int operator, long right)throws java.lang.ArithmeticException{
        long result=0;
        String operatorSymbol=Integer.toString(operator);
        if(operator>=0&&operator<FormulaVariable.TYPE_TO_STRING_ARRAY.length)operatorSymbol=FormulaVariable.TYPE_TO_STRING_ARRAY[operator];
        if(operator==FormulaVariable.TYPE_OPERATOR_AND){
            if((left!=0) && (right!=0))result=1; else result=0;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_BIT_AND) {
            result=left & right;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_BIT_OR) {
            result = left | right;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_BIT_XOR) {
            result = left ^ right;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_DIVIDE) {
            result=left/right;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_EQUALS) {
            if(left==right)result=1; else result=0;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_GREATER_THAN) {
            if(left>right)result=1; else result=0;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_GREATER_THAN_OR_EQUAL) {
            if(left>=right)result=1; else result=0;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_LESS_THAN) {
            if(left<right)result=1; else result=0;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_LESS_THAN_OR_EQUAL) {
            if(left<=right)result=1; else result=0;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_MINUS) {
            result=left-right;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_MODULUS) {
            result=left % right;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_MULTIPLY) {
            result=left*right;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_NOT_EQUAL) {
            if(left!=right)result=1; else result=0;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_OR) {
            if(left!=0||right!=0)result=1; else result=0;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_PLUS) {
            result=left+right;
        } else throw new java.lang.ArithmeticException("Unrecognized operator: "+operatorSymbol);
        
        return result;
    }    
    
    /**
     *Find out the number of days between two dates.
     *@param left left value
     *@param operator operation to be applied to left and right values. Only allowed to TYPE_OPERATOR_MINUS two dates.
     *@param right right value
     *@return the number of days between the two dates.
     *@throws ArithmeticException if operation is invalid for these values.
     */
    public static long applyOperatorToTwoVariables(java.util.Date left , int operator, java.util.Date right)throws java.lang.ArithmeticException{
        long result=0;
        if (left==null&&right==null)throw new java.lang.ArithmeticException("One of the values was null while trying to compare dates");
        String operatorSymbol=Integer.toString(operator);
        if(operator>=0&&operator<FormulaVariable.TYPE_TO_STRING_ARRAY.length)operatorSymbol=FormulaVariable.TYPE_TO_STRING_ARRAY[operator];
        if(operator==FormulaVariable.TYPE_OPERATOR_MINUS) {
            result=(left.getTime()-right.getTime())/(24*60*60*1000); //Convert to days.
        } else throw new java.lang.ArithmeticException("Unrecognized operator or operator doesn't apply. Only allowed to add or subtract dates: "+operatorSymbol);
        
        return result;
    }
    
    /**
     *@param left left value
     *@param operator operation to be applied to left and right values
     *@param right right value in days
     *@return the result of the computation
     *@throws ArithmeticException if operation is invalid for these values.
     */
    public static java.util.Date applyOperatorToTwoVariables(java.util.Date left , int operator, long right)throws java.lang.ArithmeticException{
        java.util.Date result=null;
        String operatorSymbol=Integer.toString(operator);
        right=right*(24*60*60*1000); //Convert to milliseconds.
        if(operator>=0&&operator<FormulaVariable.TYPE_TO_STRING_ARRAY.length)operatorSymbol=FormulaVariable.TYPE_TO_STRING_ARRAY[operator];
        if(operator==FormulaVariable.TYPE_OPERATOR_MINUS) {
            result=new java.util.Date(left.getTime()-right);
        } else if(operator==FormulaVariable.TYPE_OPERATOR_PLUS) {
            result=new java.util.Date(left.getTime()+right);
        } else throw new java.lang.ArithmeticException("Unrecognized operator or operator doesn't apply. Only allowed to add or subtract milliseconds from dates: "+operatorSymbol);
        
        return result;
    }
    
    /**
     *@param left left value
     *@param operator operation to be applied to left and right values
     *@param right right value
     *@return the result of the computation
     *@throws ArithmeticException if operation is invalid for these values.
     */
    public static double applyOperatorToTwoVariables(double left , int operator, double right)throws java.lang.ArithmeticException{
        double result=0;
        String operatorSymbol=Integer.toString(operator);
        if(operator>=0&&operator<FormulaVariable.TYPE_TO_STRING_ARRAY.length)operatorSymbol=FormulaVariable.TYPE_TO_STRING_ARRAY[operator];
        if(operator==FormulaVariable.TYPE_OPERATOR_AND){
            if((java.lang.Math.round(left*10000)!=0) && (java.lang.Math.round(right*10000)!=0))result=1; else result=0;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_BIT_AND) {
            result=(long)left & (long)right;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_BIT_OR) {
            result = (long)left | (long)right;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_BIT_XOR) {
            result = (long)left ^ (long)right;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_DIVIDE) {
            result=left/right;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_EQUALS) {
            if(java.lang.Math.round(left*10000)==java.lang.Math.round(right*10000))result=1; else result=0;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_GREATER_THAN) {
            if(java.lang.Math.round(left*10000)>java.lang.Math.round(right*10000))result=1; else result=0;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_GREATER_THAN_OR_EQUAL) {
            if(java.lang.Math.round(left*10000)>=java.lang.Math.round(right*10000))result=1; else result=0;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_LESS_THAN) {
            if(java.lang.Math.round(left*10000)<java.lang.Math.round(right*10000))result=1; else result=0;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_LESS_THAN_OR_EQUAL) {
            if(java.lang.Math.round(left*10000)<=java.lang.Math.round(right*10000))result=1; else result=0;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_MINUS) {
            result=left-right;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_MODULUS) {
            result=left % right;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_MULTIPLY) {
            result=left*right;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_NOT_EQUAL) {
            if(java.lang.Math.round(left*10000)!=java.lang.Math.round(right*10000))result=1; else result=0;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_OR) {
            if(java.lang.Math.round(left*10000)!=0||java.lang.Math.round(right*10000)!=0)result=1; else result=0;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_PLUS) {
            result=left+right;
        } else throw new java.lang.ArithmeticException("Unrecognized operator: "+operatorSymbol);
        
        return result;
    }
    
    /**
     *Compares two dates.<br/>
     * Note: Ignores Time portion of date so new Date(1151064000000L) equals new Date(1151064006000L)
     *@param left left value
     *@param operator operation to be applied to left and right values
     *@param right right value
     *@return the result of the computation
     *@throws ArithmeticException if operation is invalid for these values.
     */
    public static boolean applyOperatorToCompareDates(java.util.Date left , int operator, java.util.Date right)throws java.lang.ArithmeticException{
        boolean result=false;
        java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat("yyyyMMdd");
        String operatorSymbol=Integer.toString(operator);
        if(operator>=0&&operator<FormulaVariable.TYPE_TO_STRING_ARRAY.length)operatorSymbol=FormulaVariable.TYPE_TO_STRING_ARRAY[operator];
        if(operator==FormulaVariable.TYPE_OPERATOR_AND){
            if(left!=null&&right!=null)result=true; else result=false;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_BIT_AND) {
            throw new java.lang.ArithmeticException("Can't use TYPE_OPERATOR_BIT_AND to compare Dates");
        } else if(operator==FormulaVariable.TYPE_OPERATOR_BIT_OR) {
            throw new java.lang.ArithmeticException("Can't use TYPE_OPERATOR_BIT_OR to compare Dates");
        } else if(operator==FormulaVariable.TYPE_OPERATOR_BIT_XOR) {
            throw new java.lang.ArithmeticException("Can't use TYPE_OPERATOR_BIT_XOR to compare Dates");
        } else if(operator==FormulaVariable.TYPE_OPERATOR_DIVIDE) {
            throw new java.lang.ArithmeticException("Can't use TYPE_OPERATOR_DIVIDE to compare Dates");
        } else if(operator==FormulaVariable.TYPE_OPERATOR_EQUALS) {
            if(sdf.format(left).equals(sdf.format(right)))result=true; else result=false;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_GREATER_THAN) {
            if(sdf.format(left).compareTo(sdf.format(right))>0)result=true; else result=false;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_GREATER_THAN_OR_EQUAL) {
            if(sdf.format(left).compareTo(sdf.format(right))>=0)result=true; else result=false;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_LESS_THAN) {
            if(sdf.format(left).compareTo(sdf.format(right))<0)result=true; else result=false;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_LESS_THAN_OR_EQUAL) {
            if(sdf.format(left).compareTo(sdf.format(right))<=0)result=true; else result=false;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_MINUS) {
            throw new java.lang.ArithmeticException("Can't use TYPE_OPERATOR_MINUS to compare Dates");
        } else if(operator==FormulaVariable.TYPE_OPERATOR_MODULUS) {
            throw new java.lang.ArithmeticException("Can't use TYPE_OPERATOR_MODULUS to compare Dates");
        } else if(operator==FormulaVariable.TYPE_OPERATOR_MULTIPLY) {
            throw new java.lang.ArithmeticException("Can't use TYPE_OPERATOR_MULTIPLY to compare Dates");
        } else if(operator==FormulaVariable.TYPE_OPERATOR_NOT_EQUAL) {
            if(sdf.format(left).compareTo(sdf.format(right))!=0)result=true; else result=false;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_OR) {
            if(left!=null||right!=null)result=true; else result=false;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_PLUS) {
            throw new java.lang.ArithmeticException("Can't use TYPE_OPERATOR_PLUS to compare dates");
        } else throw new java.lang.ArithmeticException("Unrecognized operator: "+operatorSymbol);
        
        return result;
    }
    
    /**
     *@param left left value
     *@param operator operation to be applied to left and right values
     *@param right right value
     *@return the result of the computation
     *@throws ArithmeticException if operation is invalid for these values.
     */
    public static boolean applyOperatorToCompareStrings(String left , int operator, String right)throws java.lang.ArithmeticException{
        boolean result=false;
        String operatorSymbol=Integer.toString(operator);
        if(operator>=0&&operator<FormulaVariable.TYPE_TO_STRING_ARRAY.length)operatorSymbol=FormulaVariable.TYPE_TO_STRING_ARRAY[operator];
        if(operator==FormulaVariable.TYPE_OPERATOR_AND){
            if(left!=null&&right!=null)result=true; else result=false;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_BIT_AND) {
            throw new java.lang.ArithmeticException("Can't use TYPE_OPERATOR_BIT_AND to compare Strings");
        } else if(operator==FormulaVariable.TYPE_OPERATOR_BIT_OR) {
            throw new java.lang.ArithmeticException("Can't use TYPE_OPERATOR_BIT_OR to compare Strings");
        } else if(operator==FormulaVariable.TYPE_OPERATOR_BIT_XOR) {
            throw new java.lang.ArithmeticException("Can't use TYPE_OPERATOR_BIT_XOR to compare Strings");
        } else if(operator==FormulaVariable.TYPE_OPERATOR_DIVIDE) {
            throw new java.lang.ArithmeticException("Can't use TYPE_OPERATOR_DIVIDE to compare Strings");
        } else if(operator==FormulaVariable.TYPE_OPERATOR_EQUALS) {
            if(left.equals(right))result=true; else result=false;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_GREATER_THAN) {
            if(left.compareTo(right)>0)result=true; else result=false;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_GREATER_THAN_OR_EQUAL) {
            if(left.compareTo(right)>=0)result=true; else result=false;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_LESS_THAN) {
            if(left.compareTo(right)<0)result=true; else result=false;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_LESS_THAN_OR_EQUAL) {
            if(left.compareTo(right)<=0)result=true; else result=false;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_MINUS) {
            throw new java.lang.ArithmeticException("Can't use TYPE_OPERATOR_MINUS to compare Strings");
        } else if(operator==FormulaVariable.TYPE_OPERATOR_MODULUS) {
            throw new java.lang.ArithmeticException("Can't use TYPE_OPERATOR_MODULUS to compare Strings");
        } else if(operator==FormulaVariable.TYPE_OPERATOR_MULTIPLY) {
            throw new java.lang.ArithmeticException("Can't use TYPE_OPERATOR_MULTIPLY to compare Strings");
        } else if(operator==FormulaVariable.TYPE_OPERATOR_NOT_EQUAL) {
            if(left.compareTo(right)!=0)result=true; else result=false;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_OR) {
            if(left!=null||right!=null)result=true; else result=false;
        } else if(operator==FormulaVariable.TYPE_OPERATOR_PLUS) {
            throw new java.lang.ArithmeticException("Can't use TYPE_OPERATOR_PLUS to compare Strings");
        } else throw new java.lang.ArithmeticException("Unrecognized operator: "+operatorSymbol);
        
        return result;
    }
    
    /**
     *@param left left value
     *@param operator operation to be applied to left and right values. Only allowed to TYPE_OPERATOR_PLUS two strings
     *@param right right value
     *@return the result of the computation
     *@throws ArithmeticException if operation is invalid for these values.
     */
    public static String applyOperatorToTwoVariables(String left , int operator, String right)throws java.lang.ArithmeticException{
        String result=null;
        String operatorSymbol=Integer.toString(operator);
        if(operator>=0&&operator<FormulaVariable.TYPE_TO_STRING_ARRAY.length)operatorSymbol=FormulaVariable.TYPE_TO_STRING_ARRAY[operator];
        if(operator==FormulaVariable.TYPE_OPERATOR_PLUS) {
            result=left + right;
        } else throw new java.lang.ArithmeticException("Unrecognized operator or operator doesn't apply. Only allowed to add (concatinate) Strings: "+operatorSymbol);
        
        return result;
    }
}