Calc Beta

dofile("Class.lua")   --Load Class API for OOP
import("Classes.lua") -- Import Stack and Queue class


local opOrder={} -- table that holds the operators , the rank of the operator ( * before + )
opOrder["*"]={rank=2,isLeft=true }
opOrder["/"]={rank=2,isLeft=true }
opOrder["+"]={rank=1,isLeft=false}
opOrder["-"]={rank=1,isLeft=true }
opOrder["^"]={rank=3,isLeft=false}
opOrder["%"]={rank=2,isLeft=true }


local action={} -- the actions for all standart math operators

action["+"]=function(l,r)
        return l+r
end

action["-"]=function(l,r)
        return l-r
end

action["*"]=function(l,r)
        return l*r
end

action["/"]=function(l,r)
        return l/r
end

action["^"]=function(l,r)
        return math.pow(l,r)
end

action["%"]=function(l,r)
        return math.fmod(l,r)
end

-- /**
--  * shuntingYard turns a Queue of tokens(infix expression) and turns it into a (RPN expression)
--  * @param  [Queue] exp Queue representing the infix expression
--  * @return [Queue] Queue representing the RPN expression
--  */
local function shuntingYard(exp)
        local input=exp
        local output=Queue()
        local op=Stack()
        while not input.isEmpty do
                local token=input:dequeue()
                if tonumber(token) then
                        output:enqueue(token)
                elseif opOrder[token] then
                        local top=op:peek()

                        while op.isEmpty==false and opOrder[top]~=nil and ((opOrder[token].isLeft and opOrder[token].rank<opOrder[top].rank) or opOrder[token].rank<=opOrder[top].rank)  do
                                output:enqueue(op:pop())
                                top=op:peek()
                        end

                        op:push(token)

                elseif token=="(" then
                        op:push(token)
                elseif token==")" then
                        while op:peek()~="(" do
                                if op.isEmpty then
                                        return("[ERROR]:The closing bracket is not preceeded by an opening bracket")
                                end
                                output:enqueue(op:pop())
                        end
                        op:pop()
                end
        end
        while not op.isEmpty do
                if op:peek()=="(" then
                        return("[ERROR]:More opening brackets than closing brackets")
                end
                output:enqueue(op:pop())
        end
        return output
end

-- /**
--  * toTokenStream turns a string expression into a Queue of Tokens that represent numbers, operators and brackets
--  * @param  [string] sExpression the string that holds the math expression in infix notation
--  * @return [Queue]  the token Queue
--  */
local function toTokenStream(sExpression)
        local _tokens=Queue()
         pos=1
        while pos<=#sExpression do
                local e=sExpression:sub(pos,pos)
                if tonumber(e) then
                        local notNum=false
                        local number=e
                        local p=pos+1
                        while notNum==false do
                                if tonumber(sExpression:sub(p,p)) then
                                        number=number..sExpression:sub(p,p)
                                        p=p+1
                                else
                                        notNum=true
                                end
                        end
                        number=tonumber(number)
                        _tokens:enqueue(number)
                        pos=p
                elseif e~=" " then
                        _tokens:enqueue(e)
                        pos=pos+1
                elseif e:match("%a")~=nil then
                        local f=e
                        local notFunc=false
                        local p=pos+1
                        while notFunc==false do
                                if sExpression:sub(p,p):match("%a") then
                                        f=f..sExpression:sub(p,p)
                                        p=p+1
                                else
                                        notFunc=true
                                end
                        end
                        _tokens:enqueue(f)
                        pos=p
                end
        end
        return _tokens
end

-- /**
--  * evaluateRPN evaluates a RPN expression
--  * @param  [Queue]   reverse the Queue that holds the RPN expression
--  * @return [number]  the result of the expression
--  */
local function evaluateRPN(reverse)
        local op=Stack()
        while not reverse.isEmpty do
                local val=reverse:dequeue()
                if tonumber(val) then
                        op:push(val)
                elseif opOrder[val] then
                        local r=op:pop()
                        local l=op:pop()
                        op:push(action[val](tonumber(l),tonumber(r)))
                end
        end
        return op:pop()
end

local expression = table.concat({ ... }, " ")


if #expression==0 then
        print("Enter your expression: ")
        expression=io.read()
else
        local TOKENSTREAM=toTokenStream(expression)
        local reverse=shuntingYard(TOKENSTREAM)
        local result=evaluateRPN(reverse)
        print(result)
        return

end




local TOKENSTREAM=toTokenStream(expression)

local reverse=shuntingYard(TOKENSTREAM)


if type(reverse)=="string" then
        print(reverse)
else
        print("Your result is :"..evaluateRPN(reverse))
end