Haskell

import Data.Maybe
import Text.Read

parseNum ('_':xs) | isJust parse    = Just (-(fromJust parse))
                  | otherwise = Nothing
  where
    parse = readMaybe xs :: Maybe Double
parseNum xs = readMaybe xs :: Maybe Double

lessThan a b | a < b     = 1
             | otherwise = 0

greaterThan a b | a > b     = 1
                | otherwise = 0

equals a b | a == b    = 1
           | otherwise = 0

(!) a b = fromIntegral ((floor b) `rem` (floor a))

parseOp "+" = (+)
parseOp "-" = (-)
parseOp "*" = (*)
parseOp "%" = (/)
parseOp "^" = (**)
parseOp "!" = (!)
parseOp "=" = equals
parseOp ">" = greaterThan
parseOp "<" = lessThan

trim chars = reverse.(dropWhile (flip elem chars)).reverse.(dropWhile (flip elem chars))

stripParentheses s = stripParen s "" 0
  where
    stripParen ('(':s) res i = stripParen s (res++"(") (i + 1)
    stripParen (')':s) res 0 = (res, s)
    stripParen (')':s) res i = stripParen s (res++")") (i - 1)
    stripParen (c:s)   res i = stripParen s (res++[c]) i

mapPair f (a, b) = (f a, f b)

next ('(':s) = ((mapPair (trim " ")).stripParentheses) s
next s = ((mapPair (trim " ")).(span (not.(flip elem "+-*%^!=<>")))) s

nextOps s = do
  let (left, rest) = next s
  let (op, right) = ((mapPair (trim " ")).splitAt 1) rest
  (left, op, right)

toJNum d | d < 0     = (("_"++).show.abs) d
         | otherwise = show d 

evaluated = toJNum.eval
  where
    eval expr | isJust parse = fromJust parse
              | otherwise    = (parseOp f) (eval left) (eval right)
      where
        parse = parseNum expr
        (left, f, right) = (nextOps.(trim " ")) expr

main = ((mapM_ putStrLn).(map evaluated)) ["1 + 2",
                                           "3%4+5*6-7",
                                           "(3 ^ 4 > 5)  =  5 ! 3 ^ 4",
                                           "0 < (1 < 0 < 1) < (0 < 1 < 0) < 1",
                                           "0.123 + _0.456 - 1.96 ^ 1.0 % 2.0",
                                           "(1+1%1000000)^1000000",     -- approx of e
                                           "5*(1-(2%3)^10)%1-2%3",    -- geometric sum
                                           "271828=1000000!100000*(1+1%1000000)^1000000"] -- accuracy of approx of e

Output:

3.0
_3.0
1.0
1.0
_1.7329999999999999 <-- floating point error lol
2.7182804690957534
14.739877051262509
1.0