root/trunk/lisp/calc/calc-lang.el

;;; calc-lang.el --- calc language functions

;; Copyright (C) 1990, 1991, 1992, 1993, 2001, 2002, 2003, 2004,
;;   2005, 2006, 2007, 2008 Free Software Foundation, Inc.

;; Author: David Gillespie <daveg@synaptics.com>
;; Maintainer: Jay Belanger <jay.p.belanger@gmail.com>

;; This file is part of GNU Emacs.

;; GNU Emacs is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 3, or (at your option)
;; any later version.

;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING.  If not, write to the
;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
;; Boston, MA 02110-1301, USA.

;;; Commentary:

;;; Code:

;; This file is autoloaded from calc-ext.el.

(require 'calc-ext)
(require 'calc-macs)

;;; Alternate entry/display languages.

(defun calc-set-language (lang &optional option no-refresh)
  (setq math-expr-opers (or (get lang 'math-oper-table) math-standard-opers)
        math-expr-function-mapping (get lang 'math-function-table)
        math-expr-special-function-mapping (get lang 'math-special-function-table)
        math-expr-variable-mapping (get lang 'math-variable-table)
        calc-language-input-filter (get lang 'math-input-filter)
        calc-language-output-filter (get lang 'math-output-filter)
        calc-vector-brackets (or (get lang 'math-vector-brackets) "[]")
        calc-complex-format (get lang 'math-complex-format)
        calc-radix-formatter (get lang 'math-radix-formatter)
        calc-function-open (or (get lang 'math-function-open) "(")
        calc-function-close (or (get lang 'math-function-close) ")"))
  (if no-refresh
      (setq calc-language lang
            calc-language-option option)
    (calc-change-mode '(calc-language calc-language-option)
                      (list lang option) t)))

(defun calc-normal-language ()
  (interactive)
  (calc-wrapper
   (calc-set-language nil)
   (message "Normal language mode")))

(defun calc-flat-language ()
  (interactive)
  (calc-wrapper
   (calc-set-language 'flat)
   (message "Flat language mode (all stack entries shown on one line)")))

(defun calc-big-language ()
  (interactive)
  (calc-wrapper
   (calc-set-language 'big)
   (message "\"Big\" language mode")))

(defun calc-unformatted-language ()
  (interactive)
  (calc-wrapper
   (calc-set-language 'unform)
   (message "Unformatted language mode")))


(defun calc-c-language ()
  (interactive)
  (calc-wrapper
   (calc-set-language 'c)
   (message "`C' language mode")))

(put 'c 'math-oper-table
  '( ( "u+"    ident         -1 1000 )
     ( "u-"    neg           -1 1000 )
     ( "u!"    calcFunc-lnot -1 1000 )
     ( "~"     calcFunc-not  -1 1000 )
     ( "*"     *             190 191 )
     ( "/"     /             190 191 )
     ( "%"     %             190 191 )
     ( "+"     +             180 181 )
     ( "-"     -             180 181 )
     ( "<<"    calcFunc-lsh  170 171 )
     ( ">>"    calcFunc-rsh  170 171 )
     ( "<"     calcFunc-lt   160 161 )
     ( ">"     calcFunc-gt   160 161 )
     ( "<="    calcFunc-leq  160 161 )
     ( ">="    calcFunc-geq  160 161 )
     ( "=="    calcFunc-eq   150 151 )
     ( "!="    calcFunc-neq  150 151 )
     ( "&"     calcFunc-and  140 141 )
     ( "^"     calcFunc-xor  131 130 )
     ( "|"     calcFunc-or   120 121 )
     ( "&&"    calcFunc-land 110 111 )
     ( "||"    calcFunc-lor  100 101 )
     ( "?"     (math-read-if)  91  90 )
     ( "!!!"   calcFunc-pnot  -1  88 )
     ( "&&&"   calcFunc-pand  85  86 )
     ( "|||"   calcFunc-por   75  76 )
     ( "="     calcFunc-assign 51 50 )
     ( ":="    calcFunc-assign 51 50 )
     ( "::"    calcFunc-condition 45 46 ))) ; should support full assignments

(put 'c 'math-function-table
  '( ( acos        . calcFunc-arccos )
     ( acosh       . calcFunc-arccosh )
     ( asin        . calcFunc-arcsin )
     ( asinh       . calcFunc-arcsinh )
     ( atan        . calcFunc-arctan )
     ( atan2       . calcFunc-arctan2 )
     ( atanh       . calcFunc-arctanh )))

(put 'c 'math-variable-table
  '( ( M_PI        . var-pi )
     ( M_E         . var-e )))

(put 'c 'math-vector-brackets "{}")

(put 'c 'math-radix-formatter
     (function (lambda (r s)
                 (if (= r 16) (format "0x%s" s)
                   (if (= r 8) (format "0%s" s)
                     (format "%d#%s" r s))))))


(defun calc-pascal-language (n)
  (interactive "P")
  (calc-wrapper
   (and n (setq n (prefix-numeric-value n)))
   (calc-set-language 'pascal n)
   (message (if (and n (/= n 0))
                (if (> n 0)
                    "Pascal language mode (all uppercase)"
                  "Pascal language mode (all lowercase)")
              "Pascal language mode"))))

(put 'pascal 'math-oper-table
  '( ( "not"   calcFunc-lnot -1 1000 )
     ( "*"     *             190 191 )
     ( "/"     /             190 191 )
     ( "and"   calcFunc-and  190 191 )
     ( "div"   calcFunc-idiv 190 191 )
     ( "mod"   %             190 191 )
     ( "u+"    ident         -1  185 )
     ( "u-"    neg           -1  185 )
     ( "+"     +             180 181 )
     ( "-"     -             180 181 )
     ( "or"    calcFunc-or   180 181 )
     ( "xor"   calcFunc-xor  180 181 )
     ( "shl"   calcFunc-lsh  180 181 )
     ( "shr"   calcFunc-rsh  180 181 )
     ( "in"    calcFunc-in   160 161 )
     ( "<"     calcFunc-lt   160 161 )
     ( ">"     calcFunc-gt   160 161 )
     ( "<="    calcFunc-leq  160 161 )
     ( ">="    calcFunc-geq  160 161 )
     ( "="     calcFunc-eq   160 161 )
     ( "<>"    calcFunc-neq  160 161 )
     ( "!!!"   calcFunc-pnot  -1  85 )
     ( "&&&"   calcFunc-pand  80  81 )
     ( "|||"   calcFunc-por   75  76 )
     ( ":="    calcFunc-assign 51 50 )
     ( "::"    calcFunc-condition 45 46 )))

(put 'pascal 'math-input-filter 'calc-input-case-filter)
(put 'pascal 'math-output-filter 'calc-output-case-filter)

(put 'pascal 'math-radix-formatter
     (function (lambda (r s)
                 (if (= r 16) (format "$%s" s)
                   (format "%d#%s" r s)))))

(defun calc-input-case-filter (str)
  (cond ((or (null calc-language-option) (= calc-language-option 0))
         str)
        (t
         (downcase str))))

(defun calc-output-case-filter (str)
  (cond ((or (null calc-language-option) (= calc-language-option 0))
         str)
        ((> calc-language-option 0)
         (upcase str))
        (t
         (downcase str))))


(defun calc-fortran-language (n)
  (interactive "P")
  (calc-wrapper
   (and n (setq n (prefix-numeric-value n)))
   (calc-set-language 'fortran n)
   (message (if (and n (/= n 0))
                (if (> n 0)
                    "FORTRAN language mode (all uppercase)"
                  "FORTRAN language mode (all lowercase)")
              "FORTRAN language mode"))))

(put 'fortran 'math-oper-table
  '( ( "u/"    (math-parse-fortran-vector) -1 1 )
     ( "/"     (math-parse-fortran-vector-end) 1 -1 )
     ( "**"    ^             201 200 )
     ( "u+"    ident         -1  191 )
     ( "u-"    neg           -1  191 )
     ( "*"     *             190 191 )
     ( "/"     /             190 191 )
     ( "+"     +             180 181 )
     ( "-"     -             180 181 )
     ( ".LT."  calcFunc-lt   160 161 )
     ( ".GT."  calcFunc-gt   160 161 )
     ( ".LE."  calcFunc-leq  160 161 )
     ( ".GE."  calcFunc-geq  160 161 )
     ( ".EQ."  calcFunc-eq   160 161 )
     ( ".NE."  calcFunc-neq  160 161 )
     ( ".NOT." calcFunc-lnot -1  121 )
     ( ".AND." calcFunc-land 110 111 )
     ( ".OR."  calcFunc-lor  100 101 )
     ( "!!!"   calcFunc-pnot  -1  85 )
     ( "&&&"   calcFunc-pand  80  81 )
     ( "|||"   calcFunc-por   75  76 )
     ( "="     calcFunc-assign 51 50 )
     ( ":="    calcFunc-assign 51 50 )
     ( "::"    calcFunc-condition 45 46 )))

(put 'fortran 'math-vector-brackets "//")

(put 'fortran 'math-function-table
  '( ( acos        . calcFunc-arccos )
     ( acosh       . calcFunc-arccosh )
     ( aimag       . calcFunc-im )
     ( aint        . calcFunc-ftrunc )
     ( asin        . calcFunc-arcsin )
     ( asinh       . calcFunc-arcsinh )
     ( atan        . calcFunc-arctan )
     ( atan2       . calcFunc-arctan2 )
     ( atanh       . calcFunc-arctanh )
     ( conjg       . calcFunc-conj )
     ( log         . calcFunc-ln )
     ( nint        . calcFunc-round )
     ( real        . calcFunc-re )))

(put 'fortran 'math-input-filter 'calc-input-case-filter)
(put 'fortran 'math-output-filter 'calc-output-case-filter)

;; The next few variables are local to math-read-exprs in calc-aent.el 
;; and math-read-expr in calc-ext.el, but are set in functions they call.

(defvar math-exp-token)
(defvar math-expr-data)
(defvar math-exp-old-pos)

(defvar math-parsing-fortran-vector nil)
(defun math-parse-fortran-vector (op)
  (let ((math-parsing-fortran-vector '(end . "\000")))
    (prog1
        (math-read-brackets t "]")
      (setq math-exp-token (car math-parsing-fortran-vector)
            math-expr-data (cdr math-parsing-fortran-vector)))))

(defun math-parse-fortran-vector-end (x op)
  (if math-parsing-fortran-vector
      (progn
        (setq math-parsing-fortran-vector (cons math-exp-token math-expr-data)
              math-exp-token 'end
              math-expr-data "\000")
        x)
    (throw 'syntax "Unmatched closing `/'")))

(defun math-parse-fortran-subscr (sym args)
  (setq sym (math-build-var-name sym))
  (while args
    (setq sym (list 'calcFunc-subscr sym (car args))
          args (cdr args)))
  sym)


(defun calc-tex-language (n)
  (interactive "P")
  (calc-wrapper
   (and n (setq n (prefix-numeric-value n)))
   (calc-set-language 'tex n)
   (cond ((not n)
          (message "TeX language mode"))
         ((= n 0)
          (message "TeX language mode with multiline matrices"))
         ((= n 1)
          (message "TeX language mode with \\hbox{func}(\\hbox{var})"))
         ((> n 1)
          (message 
           "TeX language mode with \\hbox{func}(\\hbox{var}) and multiline matrices"))
         ((= n -1)
          (message "TeX language mode with \\func(\\hbox{var})"))
         ((< n -1)
          (message 
           "TeX language mode with \\func(\\hbox{var}) and multiline matrices")))))

(defun calc-latex-language (n)
  (interactive "P")
  (calc-wrapper
   (and n (setq n (prefix-numeric-value n)))
   (calc-set-language 'latex n)
   (cond ((not n)
          (message "LaTeX language mode"))
         ((= n 0)
          (message "LaTeX language mode with multiline matrices"))
         ((= n 1)
          (message "LaTeX language mode with \\text{func}(\\text{var})"))
         ((> n 1)
          (message 
           "LaTeX language mode with \\text{func}(\\text{var}) and multiline matrices"))
         ((= n -1)
          (message "LaTeX language mode with \\func(\\text{var})"))
         ((< n -1)
          (message 
           "LaTeX language mode with \\func(\\text{var}) and multiline matrices")))))

(put 'tex 'math-oper-table
  '( ( "u+"       ident            -1 1000 )
     ( "u-"       neg              -1 1000 )
     ( "\\hat"    calcFunc-hat     -1  950 )
     ( "\\check"  calcFunc-check   -1  950 )
     ( "\\tilde"  calcFunc-tilde   -1  950 )
     ( "\\acute"  calcFunc-acute   -1  950 )
     ( "\\grave"  calcFunc-grave   -1  950 )
     ( "\\dot"    calcFunc-dot     -1  950 )
     ( "\\ddot"   calcFunc-dotdot  -1  950 )
     ( "\\breve"  calcFunc-breve   -1  950 )
     ( "\\bar"    calcFunc-bar     -1  950 )
     ( "\\vec"    calcFunc-Vec     -1  950 )
     ( "\\underline" calcFunc-under -1  950 )
     ( "u|"       calcFunc-abs     -1    0 )
     ( "|"        closing           0   -1 )
     ( "\\lfloor" calcFunc-floor   -1    0 )
     ( "\\rfloor" closing           0   -1 )
     ( "\\lceil"  calcFunc-ceil    -1    0 )
     ( "\\rceil"  closing           0   -1 )
     ( "\\pm"     sdev             300 300 )
     ( "!"        calcFunc-fact    210  -1 )
     ( "^"        ^                201 200 )
     ( "_"        calcFunc-subscr  201 200 )
     ( "\\times"  *                191 190 )
     ( "*"        *                191 190 )
     ( "2x"       *                191 190 )
     ( "/"        /                185 186 )
     ( "+"        +                180 181 )
     ( "-"        -                180 181 )
     ( "\\over"   /                170 171 )
     ( "\\choose" calcFunc-choose  170 171 )
     ( "\\mod"    %                170 171 )
     ( "<"        calcFunc-lt      160 161 )
     ( ">"        calcFunc-gt      160 161 )
     ( "\\leq"    calcFunc-leq     160 161 )
     ( "\\geq"    calcFunc-geq     160 161 )
     ( "="        calcFunc-eq      160 161 )
     ( "\\neq"    calcFunc-neq     160 161 )
     ( "\\ne"     calcFunc-neq     160 161 )
     ( "\\lnot"   calcFunc-lnot     -1 121 )
     ( "\\land"   calcFunc-land    110 111 )
     ( "\\lor"    calcFunc-lor     100 101 )
     ( "?"        (math-read-if)    91  90 )
     ( "!!!"      calcFunc-pnot     -1  85 )
     ( "&&&"      calcFunc-pand     80  81 )
     ( "|||"      calcFunc-por      75  76 )
     ( "\\gets"   calcFunc-assign   51  50 )
     ( ":="       calcFunc-assign   51  50 )
     ( "::"       calcFunc-condition 45 46 )
     ( "\\to"     calcFunc-evalto   40  41 )
     ( "\\to"     calcFunc-evalto   40  -1 )
     ( "=>"       calcFunc-evalto   40  41 )
     ( "=>"       calcFunc-evalto   40  -1 )))

(put 'tex 'math-function-table
  '( ( \\arccos    . calcFunc-arccos )
     ( \\arcsin    . calcFunc-arcsin )
     ( \\arctan    . calcFunc-arctan )
     ( \\arg       . calcFunc-arg )
     ( \\cos       . calcFunc-cos )
     ( \\cosh      . calcFunc-cosh )
     ( \\cot       . calcFunc-cot )
     ( \\coth      . calcFunc-coth )
     ( \\csc       . calcFunc-csc )
     ( \\det       . calcFunc-det )
     ( \\exp       . calcFunc-exp )
     ( \\gcd       . calcFunc-gcd )
     ( \\ln        . calcFunc-ln )
     ( \\log       . calcFunc-log10 )
     ( \\max       . calcFunc-max )
     ( \\min       . calcFunc-min )
     ( \\sec       . calcFunc-sec )
     ( \\sin       . calcFunc-sin )
     ( \\sinh      . calcFunc-sinh )
     ( \\sqrt      . calcFunc-sqrt )
     ( \\tan       . calcFunc-tan )
     ( \\tanh      . calcFunc-tanh )
     ( \\phi       . calcFunc-totient )
     ( \\mu        . calcFunc-moebius )))

(put 'tex 'math-variable-table
  '( 
    ;; The Greek letters
    ( \\alpha      . var-alpha )
    ( \\beta       . var-beta  )
    ( \\gamma      . var-gamma )
    ( \\Gamma      . var-Gamma )
    ( \\delta      . var-delta )
    ( \\Delta      . var-Delta )
    ( \\epsilon    . var-epsilon )
    ( \\varepsilon . var-varepsilon)
    ( \\zeta       . var-zeta )
    ( \\eta        . var-eta  )
    ( \\theta      . var-theta )
    ( \\vartheta   . var-vartheta )
    ( \\Theta      . var-Theta )
    ( \\iota       . var-iota )
    ( \\kappa      . var-kappa )
    ( \\lambda     . var-lambda )
    ( \\Lambda     . var-Lambda )
    ( \\mu         . var-mu )
    ( \\nu         . var-nu )
    ( \\xi         . var-xi )
    ( \\Xi         . var-Xi )
    ( \\pi         . var-pi )
    ( \\varpi      . var-varpi )
    ( \\Pi         . var-Pi )
    ( \\rho        . var-rho )
    ( \\varrho     . var-varrho )
    ( \\sigma      . var-sigma )
    ( \\sigma      . var-varsigma )
    ( \\Sigma      . var-Sigma )
    ( \\tau        . var-tau )
    ( \\upsilon    . var-upsilon )
    ( \\Upsilon    . var-Upsilon )
    ( \\phi        . var-phi )
    ( \\varphi     . var-varphi )
    ( \\Phi        . var-Phi )
    ( \\chi        . var-chi )
    ( \\psi        . var-psi )
    ( \\Psi        . var-Psi )
    ( \\omega      . var-omega )
    ( \\Omega      . var-Omega )
    ;; Others
    ( \\ell        . var-ell )
    ( \\infty      . var-inf )
    ( \\infty      . var-uinf )
    ( \\sum        . (math-parse-tex-sum calcFunc-sum) )
    ( \\prod       . (math-parse-tex-sum calcFunc-prod) )))

(put 'tex 'math-complex-format 'i)

(defun math-parse-tex-sum (f val)
  (let (low high save)
    (or (equal math-expr-data "_") (throw 'syntax "Expected `_'"))
    (math-read-token)
    (setq save math-exp-old-pos)
    (setq low (math-read-factor))
    (or (eq (car-safe low) 'calcFunc-eq)
        (progn
          (setq math-exp-old-pos (1+ save))
          (throw 'syntax "Expected equation")))
    (or (equal math-expr-data "^") (throw 'syntax "Expected `^'"))
    (math-read-token)
    (setq high (math-read-factor))
    (list (nth 2 f) (math-read-factor) (nth 1 low) (nth 2 low) high)))

(defun math-tex-input-filter (str)   ; allow parsing of 123\,456\,789.
  (while (string-match "[0-9]\\\\,[0-9]" str)
    (setq str (concat (substring str 0 (1+ (match-beginning 0)))
                      (substring str (1- (match-end 0))))))
  str)
(put 'tex 'math-input-filter 'math-tex-input-filter)

(put 'latex 'math-oper-table
     (append (get 'tex 'math-oper-table)
             '(( "\\Hat"    calcFunc-Hat     -1  950 )
               ( "\\Check"  calcFunc-Check   -1  950 )
               ( "\\Tilde"  calcFunc-Tilde   -1  950 )
               ( "\\Acute"  calcFunc-Acute   -1  950 )
               ( "\\Grave"  calcFunc-Grave   -1  950 )
               ( "\\Dot"    calcFunc-Dot     -1  950 )
               ( "\\Ddot"   calcFunc-Dotdot  -1  950 )
               ( "\\Breve"  calcFunc-Breve   -1  950 )
               ( "\\Bar"    calcFunc-Bar     -1  950 )
               ( "\\Vec"    calcFunc-VEC     -1  950 )
               ( "\\dddot"  calcFunc-dddot   -1  950 )
               ( "\\ddddot" calcFunc-ddddot  -1  950 )
               ( "\div"     /                170 171 )
               ( "\\le"     calcFunc-leq     160 161 )
               ( "\\leqq"   calcFunc-leq     160 161 )
               ( "\\leqsland" calcFunc-leq   160 161 )
               ( "\\ge"     calcFunc-geq     160 161 )
               ( "\\geqq"   calcFunc-geq     160 161 )
               ( "\\geqslant" calcFunc-geq   160 161 )
               ( "="        calcFunc-eq      160 161 )
               ( "\\neq"    calcFunc-neq     160 161 )
               ( "\\ne"     calcFunc-neq     160 161 )
               ( "\\lnot"   calcFunc-lnot     -1 121 )
               ( "\\land"   calcFunc-land    110 111 )
               ( "\\lor"    calcFunc-lor     100 101 )
               ( "?"        (math-read-if)    91  90 )
               ( "!!!"      calcFunc-pnot     -1  85 )
               ( "&&&"      calcFunc-pand     80  81 )
               ( "|||"      calcFunc-por      75  76 )
               ( "\\gets"   calcFunc-assign   51  50 )
               ( ":="       calcFunc-assign   51  50 )
               ( "::"       calcFunc-condition 45 46 )
               ( "\\to"     calcFunc-evalto   40  41 )
               ( "\\to"     calcFunc-evalto   40  -1 )
               ( "=>"       calcFunc-evalto   40  41 )
               ( "=>"       calcFunc-evalto   40  -1 ))))

(put 'latex 'math-function-table
     (append
      (get 'tex 'math-function-table)
      '(( \\frac      . (math-latex-parse-frac))
        ( \\tfrac     . (math-latex-parse-frac))
        ( \\dfrac     . (math-latex-parse-frac))
        ( \\binom     . (math-latex-parse-two-args calcFunc-choose))
        ( \\tbinom    . (math-latex-parse-two-args calcFunc-choose))
        ( \\dbinom    . (math-latex-parse-two-args calcFunc-choose))
        ( \\phi       . calcFunc-totient )
        ( \\mu        . calcFunc-moebius ))))

(put 'latex 'math-special-function-table
     '((/               . (math-latex-print-frac "\\frac"))
       (calcFunc-choose . (math-latex-print-frac "\\binom"))))

(put 'latex 'math-variable-table
     (get 'tex 'math-variable-table))

(put 'latex 'math-complex-format 'i)


(defun math-latex-parse-frac (f val)
  (let (numer denom)
    (setq numer (car (math-read-expr-list)))
    (math-read-token)
    (setq denom (math-read-factor))
    (if (and (Math-num-integerp numer)
             (Math-num-integerp denom))
        (list 'frac numer denom)
      (list '/ numer denom))))

(defun math-latex-parse-two-args (f val)
  (let (first second)
    (setq first (car (math-read-expr-list)))
    (math-read-token)
    (setq second (math-read-factor))
    (list (nth 2 f) first second)))

(defun math-latex-print-frac (a fn)
  (list 'horiz (nth 1 fn) "{" (math-compose-expr (nth 1 a) -1)
               "}{"
               (math-compose-expr (nth 2 a) -1)
               "}"))

(put 'latex 'math-input-filter 'math-tex-input-filter)

(defun calc-eqn-language (n)
  (interactive "P")
  (calc-wrapper
   (calc-set-language 'eqn)
   (message "Eqn language mode")))

(put 'eqn 'math-oper-table
  '( ( "u+"       ident            -1 1000 )
     ( "u-"       neg              -1 1000 )
     ( "prime"    (math-parse-eqn-prime) 950  -1 )
     ( "prime"    calcFunc-Prime   950  -1 )
     ( "dot"      calcFunc-dot     950  -1 )
     ( "dotdot"   calcFunc-dotdot  950  -1 )
     ( "hat"      calcFunc-hat     950  -1 )
     ( "tilde"    calcFunc-tilde   950  -1 )
     ( "vec"      calcFunc-Vec     950  -1 )
     ( "dyad"     calcFunc-dyad    950  -1 )
     ( "bar"      calcFunc-bar     950  -1 )
     ( "under"    calcFunc-under   950  -1 )
     ( "sub"      calcFunc-subscr  931 930 )
     ( "sup"      ^                921 920 )
     ( "sqrt"     calcFunc-sqrt    -1  910 )
     ( "over"     /                900 901 )
     ( "u|"       calcFunc-abs     -1    0 )
     ( "|"        closing           0   -1 )
     ( "left floor"  calcFunc-floor -1   0 )
     ( "right floor" closing        0   -1 )
     ( "left ceil"   calcFunc-ceil  -1   0 )
     ( "right ceil"  closing        0   -1 )
     ( "+-"       sdev             300 300 )
     ( "!"        calcFunc-fact    210  -1 )
     ( "times"    *                191 190 )
     ( "*"        *                191 190 )
     ( "2x"       *                191 190 )
     ( "/"        /                180 181 )
     ( "%"        %                180 181 )
     ( "+"        +                170 171 )
     ( "-"        -                170 171 )
     ( "<"        calcFunc-lt      160 161 )
     ( ">"        calcFunc-gt      160 161 )
     ( "<="       calcFunc-leq     160 161 )
     ( ">="       calcFunc-geq     160 161 )
     ( "="        calcFunc-eq      160 161 )
     ( "=="       calcFunc-eq      160 161 )
     ( "!="       calcFunc-neq     160 161 )
     ( "u!"       calcFunc-lnot     -1 121 )
     ( "&&"       calcFunc-land    110 111 )
     ( "||"       calcFunc-lor     100 101 )
     ( "?"        (math-read-if)    91  90 )
     ( "!!!"      calcFunc-pnot     -1  85 )
     ( "&&&"      calcFunc-pand     80  81 )
     ( "|||"      calcFunc-por      75  76 )
     ( "<-"       calcFunc-assign   51  50 )
     ( ":="       calcFunc-assign   51  50 )
     ( "::"       calcFunc-condition 45 46 )
     ( "->"       calcFunc-evalto   40  41 )
     ( "->"       calcFunc-evalto   40  -1 )
     ( "=>"       calcFunc-evalto   40  41 )
     ( "=>"       calcFunc-evalto   40  -1 )))

(put 'eqn 'math-function-table
  '( ( arc\ cos    . calcFunc-arccos )
     ( arc\ cosh   . calcFunc-arccosh )
     ( arc\ sin    . calcFunc-arcsin )
     ( arc\ sinh   . calcFunc-arcsinh )
     ( arc\ tan    . calcFunc-arctan )
     ( arc\ tanh   . calcFunc-arctanh )
     ( GAMMA       . calcFunc-gamma )
     ( phi         . calcFunc-totient )
     ( mu          . calcFunc-moebius )
     ( matrix      . (math-parse-eqn-matrix) )))

(put 'eqn 'math-variable-table
  '( ( inf         . var-uinf )))

(put 'eqn 'math-complex-format 'i)

(defun math-parse-eqn-matrix (f sym)
  (let ((vec nil))
    (while (assoc math-expr-data '(("ccol") ("lcol") ("rcol")))
      (math-read-token)
      (or (equal math-expr-data calc-function-open)
          (throw 'syntax "Expected `{'"))
      (math-read-token)
      (setq vec (cons (cons 'vec (math-read-expr-list)) vec))
      (or (equal math-expr-data calc-function-close)
          (throw 'syntax "Expected `}'"))
      (math-read-token))
    (or (equal math-expr-data calc-function-close)
        (throw 'syntax "Expected `}'"))
    (math-read-token)
    (math-transpose (cons 'vec (nreverse vec)))))

(defun math-parse-eqn-prime (x sym)
  (if (eq (car-safe x) 'var)
      (if (equal math-expr-data calc-function-open)
          (progn
            (math-read-token)
            (let ((args (if (or (equal math-expr-data calc-function-close)
                                (eq math-exp-token 'end))
                            nil
                          (math-read-expr-list))))
              (if (not (or (equal math-expr-data calc-function-close)
                           (eq math-exp-token 'end)))
                  (throw 'syntax "Expected `)'"))
              (math-read-token)
              (cons (intern (format "calcFunc-%s'" (nth 1 x))) args)))
        (list 'var
              (intern (concat (symbol-name (nth 1 x)) "'"))
              (intern (concat (symbol-name (nth 2 x)) "'"))))
    (list 'calcFunc-Prime x)))


(defun calc-mathematica-language ()
  (interactive)
  (calc-wrapper
   (calc-set-language 'math)
   (message "Mathematica language mode")))

(put 'math 'math-oper-table
  '( ( "[["    (math-read-math-subscr) 250 -1 )
     ( "!"     calcFunc-fact  210 -1 )
     ( "!!"    calcFunc-dfact 210 -1 )
     ( "^"     ^             201 200 )
     ( "u+"    ident         -1  197 )
     ( "u-"    neg           -1  197 )
     ( "/"     /             195 196 )
     ( "*"     *             190 191 )
     ( "2x"    *             190 191 )
     ( "+"     +             180 181 )
     ( "-"     -             180 181 )
     ( "<"     calcFunc-lt   160 161 )
     ( ">"     calcFunc-gt   160 161 )
     ( "<="    calcFunc-leq  160 161 )
     ( ">="    calcFunc-geq  160 161 )
     ( "=="    calcFunc-eq   150 151 )
     ( "!="    calcFunc-neq  150 151 )
     ( "u!"    calcFunc-lnot -1  121 )
     ( "&&"    calcFunc-land 110 111 )
     ( "||"    calcFunc-lor  100 101 )
     ( "!!!"   calcFunc-pnot  -1  85 )
     ( "&&&"   calcFunc-pand  80  81 )
     ( "|||"   calcFunc-por   75  76 )
     ( ":="    calcFunc-assign 51 50 )
     ( "="     calcFunc-assign 51 50 )
     ( "->"    calcFunc-assign 51 50 )
     ( ":>"    calcFunc-assign 51 50 )
     ( "::"    calcFunc-condition 45 46 )
))

(put 'math 'math-function-table
  '( ( Abs         . calcFunc-abs )
     ( ArcCos      . calcFunc-arccos )
     ( ArcCosh     . calcFunc-arccosh )
     ( ArcSin      . calcFunc-arcsin )
     ( ArcSinh     . calcFunc-arcsinh )
     ( ArcTan      . calcFunc-arctan )
     ( ArcTanh     . calcFunc-arctanh )
     ( Arg         . calcFunc-arg )
     ( Binomial    . calcFunc-choose )
     ( Ceiling     . calcFunc-ceil )
     ( Conjugate   . calcFunc-conj )
     ( Cos         . calcFunc-cos )
     ( Cosh        . calcFunc-cosh )
     ( Cot         . calcFunc-cot )
     ( Coth        . calcFunc-coth )
     ( Csc         . calcFunc-csc )
     ( Csch        . calcFunc-csch )
     ( D           . calcFunc-deriv )
     ( Dt          . calcFunc-tderiv )
     ( Det         . calcFunc-det )
     ( Exp         . calcFunc-exp )
     ( EulerPhi    . calcFunc-totient )
     ( Floor       . calcFunc-floor )
     ( Gamma       . calcFunc-gamma )
     ( GCD         . calcFunc-gcd )
     ( If          . calcFunc-if )
     ( Im          . calcFunc-im )
     ( Inverse     . calcFunc-inv )
     ( Integrate   . calcFunc-integ )
     ( Join        . calcFunc-vconcat )
     ( LCM         . calcFunc-lcm )
     ( Log         . calcFunc-ln )
     ( Max         . calcFunc-max )
     ( Min         . calcFunc-min )
     ( Mod         . calcFunc-mod )
     ( MoebiusMu   . calcFunc-moebius )
     ( Random      . calcFunc-random )
     ( Round       . calcFunc-round )
     ( Re          . calcFunc-re )
     ( Sec         . calcFunc-sec )
     ( Sech        . calcFunc-sech )
     ( Sign        . calcFunc-sign )
     ( Sin         . calcFunc-sin )
     ( Sinh        . calcFunc-sinh )
     ( Sqrt        . calcFunc-sqrt )
     ( Tan         . calcFunc-tan )
     ( Tanh        . calcFunc-tanh )
     ( Transpose   . calcFunc-trn )
     ( Length      . calcFunc-vlen )
))

(put 'math 'math-variable-table
  '( ( I           . var-i )
     ( Pi          . var-pi )
     ( E           . var-e )
     ( GoldenRatio . var-phi )
     ( EulerGamma  . var-gamma )
     ( Infinity    . var-inf )
     ( ComplexInfinity . var-uinf )
     ( Indeterminate . var-nan )
))

(put 'math 'math-vector-brackets "{}")
(put 'math 'math-complex-format 'I)
(put 'math 'math-function-open "[")
(put 'math 'math-function-close "]")

(put 'math 'math-radix-formatter
     (function (lambda (r s) (format "%d^^%s" r s))))

(defun math-read-math-subscr (x op)
  (let ((idx (math-read-expr-level 0)))
    (or (and (equal math-expr-data "]")
             (progn
               (math-read-token)
               (equal math-expr-data "]")))
        (throw 'syntax "Expected ']]'"))
    (math-read-token)
    (list 'calcFunc-subscr x idx)))


(defun calc-maple-language ()
  (interactive)
  (calc-wrapper
   (calc-set-language 'maple)
   (message "Maple language mode")))

(put 'maple 'math-oper-table
  '( ( "matrix" ident        -1  300 )
     ( "MATRIX" ident        -1  300 )
     ( "!"     calcFunc-fact  210 -1 )
     ( "^"     ^             201 200 )
     ( "**"    ^             201 200 )