mirror of
https://git.savannah.gnu.org/git/emacs.git
synced 2024-11-27 07:37:33 +00:00
1664 lines
61 KiB
EmacsLisp
1664 lines
61 KiB
EmacsLisp
;;; calc-menu.el --- a menu for Calc
|
|
|
|
;; Copyright (C) 2007-2013 Free Software Foundation, Inc.
|
|
|
|
;; 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 of the License, 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. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
;;; Commentary:
|
|
|
|
(defvar calc-arithmetic-menu
|
|
(list "Arithmetic"
|
|
(list "Basic"
|
|
["-(1:)" calc-change-sign
|
|
:keys "n" :active (>= (calc-stack-size) 1)]
|
|
["(2:) + (1:)" calc-plus
|
|
:keys "+" :active (>= (calc-stack-size) 2)]
|
|
["(2:) - (1:)" calc-minus
|
|
:keys "-" :active (>= (calc-stack-size) 2)]
|
|
["(2:) * (1:)" calc-times
|
|
:keys "*" :active (>= (calc-stack-size) 2)]
|
|
["(2:) / (1:)" calc-divide
|
|
:keys "/" :active (>= (calc-stack-size) 2)]
|
|
["(2:) ^ (1:)" calc-power
|
|
:keys "^" :active (>= (calc-stack-size) 2)]
|
|
["(2:) ^ (1/(1:))"
|
|
(progn
|
|
(require 'calc-ext)
|
|
(let ((calc-inverse-flag t))
|
|
(call-interactively 'calc-power)))
|
|
:keys "I ^"
|
|
:active (>= (calc-stack-size) 2)
|
|
:help "The (1:)th root of (2:)"]
|
|
["abs(1:)"
|
|
(progn
|
|
(require 'calc-arith)
|
|
(call-interactively 'calc-abs))
|
|
:keys "A"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "Absolute value"]
|
|
["1/(1:)"
|
|
(progn
|
|
(require 'calc-arith)
|
|
(call-interactively 'calc-inv))
|
|
:keys "&"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["sqrt(1:)"
|
|
(progn
|
|
(require 'calc-math)
|
|
(call-interactively 'calc-sqrt))
|
|
:keys "Q"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["idiv(2:,1:)"
|
|
(progn
|
|
(require 'calc-arith)
|
|
(call-interactively 'calc-idiv))
|
|
:keys "\\"
|
|
:active (>= (calc-stack-size) 2)
|
|
:help "The integer quotient of (2:) over (1:)"]
|
|
["(2:) mod (1:)"
|
|
(progn
|
|
(require 'calc-misc)
|
|
(call-interactively 'calc-mod))
|
|
:keys "%"
|
|
:active (>= (calc-stack-size) 2)
|
|
:help "The remainder when (2:) is divided by (1:)"])
|
|
(list "Rounding"
|
|
["floor(1:)"
|
|
(progn
|
|
(require 'calc-arith)
|
|
(call-interactively 'calc-floor))
|
|
:keys "F"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "The greatest integer less than or equal to (1:)"]
|
|
["ceiling(1:)"
|
|
(progn
|
|
(require 'calc-arith)
|
|
(call-interactively 'calc-ceiling))
|
|
:keys "I F"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "The smallest integer greater than or equal to (1:)"]
|
|
["round(1:)"
|
|
(progn
|
|
(require 'calc-arith)
|
|
(call-interactively 'calc-round))
|
|
:keys "R"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "The nearest integer to (1:)"]
|
|
["truncate(1:)"
|
|
(progn
|
|
(require 'calc-arith)
|
|
(call-interactively 'calc-trunc))
|
|
:keys "I R"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "The integer part of (1:)"])
|
|
(list "Complex Numbers"
|
|
["Re(1:)"
|
|
(progn
|
|
(require 'calc-cplx)
|
|
(call-interactively 'calc-re))
|
|
:keys "f r"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["Im(1:)"
|
|
(progn
|
|
(require 'calc-cplx)
|
|
(call-interactively 'calc-im))
|
|
:keys "f i"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["conj(1:)"
|
|
(progn
|
|
(require 'calc-cplx)
|
|
(call-interactively 'calc-conj))
|
|
:keys "J"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "The complex conjugate of (1:)"]
|
|
["length(1:)"
|
|
(progn (require 'calc-arith)
|
|
(call-interactively 'calc-abs))
|
|
:keys "A"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "The length (absolute value) of (1:)"]
|
|
["arg(1:)"
|
|
(progn
|
|
(require 'calc-cplx)
|
|
(call-interactively 'calc-argument))
|
|
:keys "G"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "The argument (polar angle) of (1:)"])
|
|
(list "Conversion"
|
|
["Convert (1:) to a float"
|
|
(progn
|
|
(require 'calc-ext)
|
|
(call-interactively 'calc-float))
|
|
:keys "c f"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["Convert (1:) to a fraction"
|
|
(progn
|
|
(require 'calc-ext)
|
|
(call-interactively 'calc-fraction))
|
|
:keys "c F"
|
|
:active (>= (calc-stack-size) 1)])
|
|
(list "Binary"
|
|
["Set word size"
|
|
(progn
|
|
(require 'calc-bin)
|
|
(call-interactively 'calc-word-size))
|
|
:keys "b w"]
|
|
["Clip (1:) to word size"
|
|
(progn
|
|
(require 'calc-bin)
|
|
(call-interactively 'calc-clip))
|
|
:keys "b c"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "Reduce (1:) modulo 2^wordsize"]
|
|
["(2:) and (1:)"
|
|
(progn
|
|
(require 'calc-bin)
|
|
(call-interactively 'calc-and))
|
|
:keys "b a"
|
|
:active (>= (calc-stack-size) 2)
|
|
:help "Bitwise AND [modulo 2^wordsize]"]
|
|
["(2:) or (1:)"
|
|
(progn
|
|
(require 'calc-bin)
|
|
(call-interactively 'calc-or))
|
|
:keys "b o"
|
|
:active (>= (calc-stack-size) 2)
|
|
:help "Bitwise inclusive OR [modulo 2^wordsize]"]
|
|
["(2:) xor (1:)"
|
|
(progn
|
|
(require 'calc-bin)
|
|
(call-interactively 'calc-xor))
|
|
:keys "b x"
|
|
:active (>= (calc-stack-size) 2)
|
|
:help "Bitwise exclusive OR [modulo 2^wordsize]"]
|
|
["diff(2:,1:)"
|
|
(progn
|
|
(require 'calc-bin)
|
|
(call-interactively 'calc-diff))
|
|
:keys "b d"
|
|
:active (>= (calc-stack-size) 2)
|
|
:help "Bitwise difference [modulo 2^wordsize]"]
|
|
["not (1:)"
|
|
(progn
|
|
(require 'calc-bin)
|
|
(call-interactively 'calc-not))
|
|
:keys "b n"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "Bitwise NOT [modulo 2^wordsize]"]
|
|
["left shift(1:)"
|
|
(progn
|
|
(require 'calc-bin)
|
|
(call-interactively 'calc-lshift-binary))
|
|
:keys "b l"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "Shift (1:)[modulo 2^wordsize] one bit left"]
|
|
["right shift(1:)"
|
|
(progn
|
|
(require 'calc-bin)
|
|
(call-interactively 'calc-rshift-binary))
|
|
:keys "b r"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "Shift (1:)[modulo 2^wordsize] one bit right, putting 0s on the left"]
|
|
["arithmetic right shift(1:)"
|
|
(progn
|
|
(require 'calc-bin)
|
|
(call-interactively 'calc-rshift-arith))
|
|
:keys "b R"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "Shift (1:)[modulo 2^wordsize] one bit right, duplicating the leftmost bit"]
|
|
["rotate(1:)"
|
|
(progn
|
|
(require 'calc-bin)
|
|
(call-interactively 'calc-rotate-binary))
|
|
:keys "b t"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "Rotate (1:)[modulo 2^wordsize] one bit left"])
|
|
"-------"
|
|
["Help on Arithmetic"
|
|
(calc-info-goto-node "Arithmetic")])
|
|
"Menu for Calc's arithmetic functions.")
|
|
|
|
(defvar calc-scientific-function-menu
|
|
(list "Scientific Functions"
|
|
(list "Constants"
|
|
["pi"
|
|
(progn
|
|
(require 'calc-math)
|
|
(call-interactively 'calc-pi))
|
|
:keys "P"]
|
|
["e"
|
|
(progn
|
|
(require 'calc-math)
|
|
(let ((calc-hyperbolic-flag t))
|
|
(call-interactively 'calc-pi)))
|
|
:keys "H P"]
|
|
["phi"
|
|
(progn
|
|
(require 'calc-math)
|
|
(let ((calc-inverse-flag t)
|
|
(calc-hyperbolic-flag t))
|
|
(call-interactively 'calc-pi)))
|
|
:keys "I H P"
|
|
:help "The golden ratio"]
|
|
["gamma"
|
|
(progn
|
|
(require 'calc-math)
|
|
(let ((calc-inverse-flag t))
|
|
(call-interactively 'calc-pi)))
|
|
:keys "I P"
|
|
:help "Euler's constant"])
|
|
(list "Logs and Exps"
|
|
["ln(1:)"
|
|
(progn
|
|
(require 'calc-math)
|
|
(call-interactively 'calc-ln))
|
|
:keys "L"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "The natural logarithm"]
|
|
["e^(1:)"
|
|
(progn
|
|
(require 'calc-math)
|
|
(call-interactively 'calc-exp))
|
|
:keys "E"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["log(1:) [base 10]"
|
|
(progn
|
|
(require 'calc-math)
|
|
(call-interactively 'calc-log10))
|
|
:keys "H L"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "The common logarithm"]
|
|
["10^(1:)"
|
|
(progn
|
|
(require 'calc-math)
|
|
(let ((calc-inverse-flag t))
|
|
(call-interactively 'calc-log10)))
|
|
:keys "I H L"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["log(2:) [base(1:)]"
|
|
(progn
|
|
(require 'calc-math)
|
|
(call-interactively 'calc-log))
|
|
:keys "B"
|
|
:active (>= (calc-stack-size) 2)
|
|
:help "The logarithm with an arbitrary base"]
|
|
["(2:) ^ (1:)"
|
|
calc-power
|
|
:keys "^"
|
|
:active (>= (calc-stack-size) 2)])
|
|
(list "Trigonometric Functions"
|
|
["sin(1:)"
|
|
(progn
|
|
(require 'calc-math)
|
|
(call-interactively 'calc-sin))
|
|
:keys "S"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["cos(1:)"
|
|
(progn
|
|
(require 'calc-math)
|
|
(call-interactively 'calc-cos))
|
|
:keys "C"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["tan(1:)"
|
|
(progn
|
|
(require 'calc-math)
|
|
(call-interactively 'calc-tan))
|
|
:keys "T"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["arcsin(1:)"
|
|
(progn
|
|
(require 'calc-math)
|
|
(call-interactively 'calc-arcsin))
|
|
:keys "I S"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["arccos(1:)"
|
|
(progn
|
|
(require 'calc-math)
|
|
(call-interactively 'calc-arccos))
|
|
:keys "I C"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["arctan(1:)"
|
|
(progn
|
|
(require 'calc-math)
|
|
(call-interactively 'calc-arctan))
|
|
:keys "I T"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["arctan2(2:,1:)"
|
|
(progn
|
|
(require 'calc-math)
|
|
(call-interactively 'calc-arctan2))
|
|
:keys "f T"
|
|
:active (>= (calc-stack-size) 2)]
|
|
"--Angle Measure--"
|
|
["Radians"
|
|
(progn
|
|
(require 'calc-math)
|
|
(calc-radians-mode))
|
|
:keys "m r"
|
|
:style radio
|
|
:selected (eq calc-angle-mode 'rad)]
|
|
["Degrees"
|
|
(progn
|
|
(require 'calc-math)
|
|
(calc-degrees-mode))
|
|
:keys "m d"
|
|
:style radio
|
|
:selected (eq calc-angle-mode 'deg)]
|
|
["HMS"
|
|
(progn
|
|
(require 'calc-math)
|
|
(calc-hms-mode))
|
|
:keys "m h"
|
|
:style radio
|
|
:selected (eq calc-angle-mode 'hms)])
|
|
(list "Hyperbolic Functions"
|
|
["sinh(1:)"
|
|
(progn
|
|
(require 'calc-math)
|
|
(call-interactively 'calc-sinh))
|
|
:keys "H S"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["cosh(1:)"
|
|
(progn
|
|
(require 'calc-math)
|
|
(call-interactively 'calc-cosh))
|
|
:keys "H C"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["tanh(1:)"
|
|
(progn
|
|
(require 'calc-math)
|
|
(call-interactively 'calc-tanh))
|
|
:keys "H T"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["arcsinh(1:)"
|
|
(progn
|
|
(require 'calc-math)
|
|
(call-interactively 'calc-arcsinh))
|
|
:keys "I H S"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["arccosh(1:)"
|
|
(progn
|
|
(require 'calc-math)
|
|
(call-interactively 'calc-arccosh))
|
|
:keys "I H C"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["arctanh(1:)"
|
|
(progn
|
|
(require 'calc-math)
|
|
(call-interactively 'calc-arctanh))
|
|
:keys "I H T"
|
|
:active (>= (calc-stack-size) 1)])
|
|
(list "Advanced Math Functions"
|
|
["Gamma(1:)"
|
|
(progn
|
|
(require 'calc-comb)
|
|
(call-interactively 'calc-gamma))
|
|
:keys "f g"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "The Euler Gamma function"]
|
|
["GammaP(2:,1:)"
|
|
(progn
|
|
(require 'calc-funcs)
|
|
(call-interactively 'calc-inc-gamma))
|
|
:keys "f G"
|
|
:active (>= (calc-stack-size) 2)
|
|
:help "The lower incomplete Gamma function"]
|
|
["Beta(2:,1:)"
|
|
(progn
|
|
(require 'calc-funcs)
|
|
(call-interactively 'calc-beta))
|
|
:keys "f b"
|
|
:active (>= (calc-stack-size) 2)
|
|
:help "The Euler Beta function"]
|
|
["BetaI(3:,2:,1:)"
|
|
(progn
|
|
(require 'calc-funcs)
|
|
(call-interactively 'calc-inc-beta))
|
|
:keys "f B"
|
|
:active (>= (calc-stack-size) 3)
|
|
:help "The incomplete Beta function"]
|
|
["erf(1:)"
|
|
(progn
|
|
(require 'calc-funcs)
|
|
(call-interactively 'calc-erf))
|
|
:keys "f e"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "The error function"]
|
|
["BesselJ(2:,1:)"
|
|
(progn
|
|
(require 'calc-funcs)
|
|
(call-interactively 'calc-bessel-J))
|
|
:keys "f j"
|
|
:active (>= (calc-stack-size) 2)
|
|
:help "The Bessel function of the first kind (of order (2:))"]
|
|
["BesselY(2:,1:)"
|
|
(progn
|
|
(require 'calc-funcs)
|
|
(call-interactively 'calc-bessel-Y))
|
|
:keys "f y"
|
|
:active (>= (calc-stack-size) 2)
|
|
:help "The Bessel function of the second kind (of order (2:))"])
|
|
(list "Combinatorial Functions"
|
|
["gcd(2:,1:)"
|
|
(progn
|
|
(require 'calc-comb)
|
|
(call-interactively 'calc-gcd))
|
|
:keys "k g"
|
|
:active (>= (calc-stack-size) 2)]
|
|
["lcm(2:,1:)"
|
|
(progn
|
|
(require 'calc-comb)
|
|
(call-interactively 'calc-lcm))
|
|
:keys "k l"
|
|
:active (>= (calc-stack-size) 2)]
|
|
["factorial(1:)"
|
|
(progn
|
|
(require 'calc-comb)
|
|
(call-interactively 'calc-factorial))
|
|
:keys "!"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["(2:) choose (1:)"
|
|
(progn
|
|
(require 'calc-comb)
|
|
(call-interactively 'calc-choose))
|
|
:keys "k c"
|
|
:active (>= (calc-stack-size) 2)]
|
|
["permutations(2:,1:)"
|
|
(progn
|
|
(require 'calc-comb)
|
|
(call-interactively 'calc-perm))
|
|
:keys "H k c"
|
|
:active (>= (calc-stack-size) 2)]
|
|
["Primality test for (1:)"
|
|
(progn
|
|
(require 'calc-comb)
|
|
(call-interactively 'calc-prime-test))
|
|
:keys "k p"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "For large (1:), a probabilistic test"]
|
|
["Factor (1:) into primes"
|
|
(progn
|
|
(require 'calc-comb)
|
|
(call-interactively 'calc-prime-factors))
|
|
:keys "k f"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["Next prime after (1:)"
|
|
(progn
|
|
(require 'calc-comb)
|
|
(call-interactively 'calc-next-prime))
|
|
:keys "k n"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["Previous prime before (1:)"
|
|
(progn
|
|
(require 'calc-comb)
|
|
(call-interactively 'calc-prev-prime))
|
|
:keys "I k n"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["phi(1:)"
|
|
(progn
|
|
(require 'calc-comb)
|
|
(call-interactively 'calc-totient))
|
|
:keys "k n"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "Euler's totient function"]
|
|
["random(1:)"
|
|
(progn
|
|
(require 'calc-comb)
|
|
(call-interactively 'calc-random))
|
|
:keys "k r"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "A random number >=1 and < (1:)"])
|
|
"----"
|
|
["Help on Scientific Functions"
|
|
(calc-info-goto-node "Scientific Functions")])
|
|
"Menu for Calc's scientific functions.")
|
|
|
|
(defvar calc-algebra-menu
|
|
(list "Algebra"
|
|
(list "Simplification"
|
|
["Simplify (1:)"
|
|
(progn
|
|
(require 'calc-alg)
|
|
(call-interactively 'calc-simplify))
|
|
:keys "a s"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["Simplify (1:) with extended rules"
|
|
(progn
|
|
(require 'calc-alg)
|
|
(call-interactively 'calc-simplify-extended))
|
|
:keys "a e"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "Apply possibly unsafe simplifications"])
|
|
(list "Manipulation"
|
|
["Expand formula (1:)"
|
|
(progn
|
|
(require 'calc-alg)
|
|
(call-interactively 'calc-expand-formula))
|
|
:keys "a \""
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "Expand (1:) into its defining formula, if possible"]
|
|
["Evaluate variables in (1:)"
|
|
(progn
|
|
(require 'calc-ext)
|
|
(call-interactively 'calc-evaluate))
|
|
:keys "="
|
|
:active (>= (calc-stack-size) 1)]
|
|
["Make substitution in (1:)"
|
|
(progn
|
|
(require 'calc-alg)
|
|
(call-interactively 'calc-substitute))
|
|
:keys "a b"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help
|
|
"Substitute all occurrences of a sub-expression with a new sub-expression"])
|
|
(list "Polynomials"
|
|
["Factor (1:)"
|
|
(progn
|
|
(require 'calc-alg)
|
|
(call-interactively 'calc-factor))
|
|
:keys "a f"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["Collect terms in (1:)"
|
|
(progn
|
|
(require 'calc-alg)
|
|
(call-interactively 'calc-collect))
|
|
:keys "a c"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "Arrange as a polynomial in a given variable"]
|
|
["Expand (1:)"
|
|
(progn
|
|
(require 'calc-alg)
|
|
(call-interactively 'calc-expand))
|
|
:keys "a x"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "Apply distributive law everywhere"]
|
|
["Find roots of (1:)"
|
|
(progn
|
|
(require 'calcalg2)
|
|
(call-interactively 'calc-poly-roots))
|
|
:keys "a P"
|
|
:active (>= (calc-stack-size) 1)])
|
|
(list "Calculus"
|
|
["Differentiate (1:)"
|
|
(progn
|
|
(require 'calcalg2)
|
|
(call-interactively 'calc-derivative))
|
|
:keys "a d"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["Integrate (1:) [indefinite]"
|
|
(progn
|
|
(require 'calcalg2)
|
|
(call-interactively 'calc-integral))
|
|
:keys "a i"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["Integrate (1:) [definite]"
|
|
(progn
|
|
(require 'calcalg2)
|
|
(let ((var (read-string "Integration variable: ")))
|
|
(calc-tabular-command 'calcFunc-integ "Integration"
|
|
"intg" nil var nil nil)))
|
|
:keys "C-u a i"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["Integrate (1:) [numeric]"
|
|
(progn
|
|
(require 'calcalg2)
|
|
(call-interactively 'calc-num-integral))
|
|
:keys "a I"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "Integrate using the open Romberg method"]
|
|
["Taylor expand (1:)"
|
|
(progn
|
|
(require 'calcalg2)
|
|
(call-interactively 'calc-taylor))
|
|
:keys "a t"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["Minimize (2:) [initial guess = (1:)]"
|
|
(progn
|
|
(require 'calcalg3)
|
|
(call-interactively 'calc-find-minimum))
|
|
:keys "a N"
|
|
:active (>= (calc-stack-size) 2)
|
|
:help "Find a local minimum"]
|
|
["Maximize (2:) [initial guess = (1:)]"
|
|
(progn
|
|
(require 'calcalg3)
|
|
(call-interactively 'calc-find-maximum))
|
|
:keys "a X"
|
|
:active (>= (calc-stack-size) 2)
|
|
:help "Find a local maximum"])
|
|
(list "Solving"
|
|
["Solve equation (1:)"
|
|
(progn
|
|
(require 'calcalg2)
|
|
(call-interactively 'calc-solve-for))
|
|
:keys "a S"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["Solve equation (2:) numerically [initial guess = (1:)]"
|
|
(progn
|
|
(require 'calcalg3)
|
|
(call-interactively 'calc-find-root))
|
|
:keys "a R"
|
|
:active (>= (calc-stack-size) 2)]
|
|
["Find roots of polynomial (1:)"
|
|
(progn
|
|
(require 'calcalg2)
|
|
(call-interactively 'calc-poly-roots))
|
|
:keys "a P"
|
|
:active (>= (calc-stack-size) 1)])
|
|
(list "Curve Fitting"
|
|
["Fit (1:)=[x values, y values] to a curve"
|
|
(progn
|
|
(require 'calcalg3)
|
|
(call-interactively 'calc-curve-fit))
|
|
:keys "a F"
|
|
:active (>= (calc-stack-size) 1)])
|
|
"----"
|
|
["Help on Algebra"
|
|
(calc-info-goto-node "Algebra")])
|
|
"Menu for Calc's algebraic facilities.")
|
|
|
|
|
|
(defvar calc-graphics-menu
|
|
(list "Graphics"
|
|
["Graph 2D [(1:)= y values, (2:)= x values]"
|
|
(progn
|
|
(require 'calc-graph)
|
|
(call-interactively 'calc-graph-fast))
|
|
:keys "g f"
|
|
:active (>= (calc-stack-size) 2)]
|
|
["Graph 3D [(1:)= z values, (2:)= y values, (3:)= x values]"
|
|
(progn
|
|
(require 'calc-graph)
|
|
(call-interactively 'calc-graph-fast-3d))
|
|
:keys "g F"
|
|
:active (>= (calc-stack-size) 3)]
|
|
"----"
|
|
["Help on Graphics"
|
|
(calc-info-goto-node "Graphics")])
|
|
"Menu for Calc's graphics.")
|
|
|
|
|
|
(defvar calc-vectors-menu
|
|
(list "Matrices/Vectors"
|
|
(list "Matrices"
|
|
["(2:) + (1:)" calc-plus
|
|
:keys "+" :active (>= (calc-stack-size) 2)]
|
|
["(2:) - (1:)" calc-minus
|
|
:keys "-" :active (>= (calc-stack-size) 2)]
|
|
["(2:) * (1:)" calc-times
|
|
:keys "*" :active (>= (calc-stack-size) 2)]
|
|
["(1:)^(-1)"
|
|
(progn
|
|
(require 'calc-arith)
|
|
(call-interactively 'calc-inv))
|
|
:keys "&"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["Create an identity matrix"
|
|
(progn
|
|
(require 'calc-vec)
|
|
(call-interactively 'calc-ident))
|
|
:keys "v i"]
|
|
["transpose(1:)"
|
|
(progn
|
|
(require 'calc-vec)
|
|
(call-interactively 'calc-transpose))
|
|
:keys "v t"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["det(1:)"
|
|
(progn
|
|
(require 'calc-mtx)
|
|
(call-interactively 'calc-mdet))
|
|
:keys "V D"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["trace(1:)"
|
|
(progn
|
|
(require 'calc-mtx)
|
|
(call-interactively 'calc-mtrace))
|
|
:keys "V T"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["LUD decompose (1:)"
|
|
(progn
|
|
(require 'calc-mtx)
|
|
(call-interactively 'calc-mlud))
|
|
:keys "V L"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["Extract a row from (1:)"
|
|
(progn
|
|
(require 'calc-vec)
|
|
(call-interactively 'calc-mrow))
|
|
:keys "v r"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["Extract a column from (1:)"
|
|
(progn
|
|
(require 'calc-vec)
|
|
(call-interactively 'calc-mcol))
|
|
:keys "v c"
|
|
:active (>= (calc-stack-size) 1)])
|
|
(list "Vectors"
|
|
["Extract the first element of (1:)"
|
|
(progn
|
|
(require 'calc-vec)
|
|
(call-interactively 'calc-head))
|
|
:keys "v h"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["Extract an element from (1:)"
|
|
(progn
|
|
(require 'calc-vec)
|
|
(call-interactively 'calc-mrow))
|
|
:keys "v r"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["Reverse (1:)"
|
|
(progn
|
|
(require 'calc-vec)
|
|
(call-interactively 'calc-reverse-vector))
|
|
:keys "v v"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["Unpack (1:)"
|
|
(progn
|
|
(require 'calc-vec)
|
|
(call-interactively 'calc-unpack))
|
|
:keys "v u"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "Separate the elements of (1:)"]
|
|
["(2:) cross (1:)"
|
|
(progn
|
|
(require 'calc-vec)
|
|
(call-interactively 'calc-cross))
|
|
:keys "V C"
|
|
:active (>= (calc-stack-size) 2)
|
|
:help "The cross product in R^3"]
|
|
["(2:) dot (1:)"
|
|
calc-mult
|
|
:keys "*"
|
|
:active (>= (calc-stack-size) 2)
|
|
:help "The dot product"]
|
|
["Map a function across (1:)"
|
|
(progn
|
|
(require 'calc-map)
|
|
(call-interactively 'calc-map))
|
|
:keys "V M"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "Apply a function to each element"])
|
|
(list "Vectors As Sets"
|
|
["Remove duplicates from (1:)"
|
|
(progn
|
|
(require 'calc-vec)
|
|
(call-interactively 'calc-remove-duplicates))
|
|
:keys "V +"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["(2:) union (1:)"
|
|
(progn
|
|
(require 'calc-vec)
|
|
(call-interactively 'calc-set-union))
|
|
:keys "V V"
|
|
:active (>= (calc-stack-size) 2)]
|
|
["(2:) intersect (1:)"
|
|
(progn
|
|
(require 'calc-vec)
|
|
(call-interactively 'calc-set-intersect))
|
|
:keys "V ^"
|
|
:active (>= (calc-stack-size) 2)]
|
|
["(2:) \\ (1:)"
|
|
(progn
|
|
(require 'calc-vec)
|
|
(call-interactively 'calc-set-difference))
|
|
:keys "V -"
|
|
:help "Set difference"
|
|
:active (>= (calc-stack-size) 2)])
|
|
(list "Statistics On Vectors"
|
|
["length(1:)"
|
|
(progn
|
|
(require 'calc-stat)
|
|
(call-interactively 'calc-vector-count))
|
|
:keys "u #"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "The number of data values"]
|
|
["sum(1:)"
|
|
(progn
|
|
(require 'calc-stat)
|
|
(call-interactively 'calc-vector-sum))
|
|
:keys "u +"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "The sum of the data values"]
|
|
["max(1:)"
|
|
(progn
|
|
(require 'calc-stat)
|
|
(call-interactively 'calc-vector-max))
|
|
:keys "u x"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "The maximum of the data values"]
|
|
["min(1:)"
|
|
(progn
|
|
(require 'calc-stat)
|
|
(call-interactively 'calc-vector-min))
|
|
:keys "u N"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "The minimum of the data values"]
|
|
["mean(1:)"
|
|
(progn
|
|
(require 'calc-stat)
|
|
(call-interactively 'calc-vector-mean))
|
|
:keys "u M"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "The average (arithmetic mean) of the data values"]
|
|
["mean(1:) with error"
|
|
(progn
|
|
(require 'calc-stat)
|
|
(call-interactively 'calc-vector-mean-error))
|
|
:keys "I u M"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "The average (arithmetic mean) of the data values as an error form"]
|
|
["sdev(1:)"
|
|
(progn
|
|
(require 'calc-stat)
|
|
(call-interactively 'calc-vector-sdev))
|
|
:keys "u S"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "The sample sdev, sqrt[sum((values - mean)^2)/(N-1)]"]
|
|
["variance(1:)"
|
|
(progn
|
|
(require 'calc-stat)
|
|
(call-interactively 'calc-vector-variance))
|
|
:keys "H u S"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "The sample variance, sum((values - mean)^2)/(N-1)"]
|
|
["population sdev(1:)"
|
|
(progn
|
|
(require 'calc-stat)
|
|
(call-interactively 'calc-vector-pop-sdev))
|
|
:keys "I u S"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "The population sdev, sqrt[sum((values - mean)^2)/N]"]
|
|
["population variance(1:)"
|
|
(progn
|
|
(require 'calc-stat)
|
|
(call-interactively 'calc-vector-pop-variance))
|
|
:keys "H I u S"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "The population variance, sum((values - mean)^2)/N"]
|
|
["median(1:)"
|
|
(progn
|
|
(require 'calc-stat)
|
|
(call-interactively 'calc-vector-median))
|
|
:keys "H u M"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "The median of the data values"]
|
|
["harmonic mean(1:)"
|
|
(progn
|
|
(require 'calc-stat)
|
|
(call-interactively 'calc-vector-harmonic-mean))
|
|
:keys "H I u M"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["geometric mean(1:)"
|
|
(progn
|
|
(require 'calc-stat)
|
|
(call-interactively 'calc-vector-geometric-mean))
|
|
:keys "u G"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["arithmetic-geometric mean(1:)"
|
|
(progn
|
|
(require 'calc-stat)
|
|
(let ((calc-hyperbolic-flag t))
|
|
(call-interactively 'calc-vector-geometric-mean)))
|
|
:keys "H u G"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["RMS(1:)"
|
|
(progn (require 'calc-arith)
|
|
(call-interactively 'calc-abs))
|
|
:keys "A"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "The root-mean-square, or quadratic mean"])
|
|
["Abbreviate long vectors"
|
|
(progn
|
|
(require 'calc-mode)
|
|
(call-interactively 'calc-full-vectors))
|
|
:keys "v ."
|
|
:style toggle
|
|
:selected (not calc-full-vectors)]
|
|
"----"
|
|
["Help on Matrices/Vectors"
|
|
(calc-info-goto-node "Matrix Functions")])
|
|
"Menu for Calc's vector and matrix functions.")
|
|
|
|
(defvar calc-units-menu
|
|
(list "Units"
|
|
["Convert units in (1:)"
|
|
(progn
|
|
(require 'calc-units)
|
|
(call-interactively 'calc-convert-units ))
|
|
:keys "u c"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["Convert temperature in (1:)"
|
|
(progn
|
|
(require 'calc-units)
|
|
(call-interactively 'calc-convert-temperature))
|
|
:keys "u t"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["Simplify units in (1:)"
|
|
(progn
|
|
(require 'calc-units)
|
|
(call-interactively 'calc-simplify-units))
|
|
:keys "u s"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["View units table"
|
|
(progn
|
|
(require 'calc-units)
|
|
(call-interactively 'calc-view-units-table))
|
|
:keys "u V"]
|
|
(list "Logarithmic Units"
|
|
["Convert (1:) to dB (power)"
|
|
(progn
|
|
(require 'calc-units)
|
|
(call-interactively 'calc-db))
|
|
:keys "l d"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["Convert (2:) to dB (power) with reference level (1:)"
|
|
(progn
|
|
(require 'calc-units)
|
|
(let ((calc-option-flag t))
|
|
(call-interactively 'calc-db)))
|
|
:keys "O l d"
|
|
:active (>= (calc-stack-size) 2)]
|
|
["Convert (1:) to Np (power)"
|
|
(progn
|
|
(require 'calc-units)
|
|
(call-interactively 'calc-np))
|
|
:keys "l n"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["Convert (2:) to Np (power) with reference level (1:)"
|
|
(progn
|
|
(require 'calc-units)
|
|
(let ((calc-option-flag t))
|
|
(call-interactively 'calc-np)))
|
|
:keys "O l n"
|
|
:active (>= (calc-stack-size) 2)]
|
|
["Convert (1:) to power quantity"
|
|
(progn
|
|
(require 'calc-units)
|
|
(call-interactively 'calc-lu-quant))
|
|
:keys "l q"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["Convert (2:) to power quantity with reference level (1:)"
|
|
(progn
|
|
(require 'calc-units)
|
|
(let ((calc-option-flag t))
|
|
(call-interactively 'calc-lu-quant)))
|
|
:keys "O l q"
|
|
:active (>= (calc-stack-size) 2)]
|
|
"----"
|
|
["Convert (1:) to dB (field)"
|
|
(progn
|
|
(require 'calc-units)
|
|
(let ((calc-hyperbolic-flag t))
|
|
(call-interactively 'calc-db)))
|
|
:keys "H l d"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["Convert (2:) to dB (field) with reference level (1:)"
|
|
(progn
|
|
(require 'calc-units)
|
|
(let ((calc-option-flag t)
|
|
(calc-hyperbolic-flag t))
|
|
(call-interactively 'calc-db)))
|
|
:keys "O H l d"
|
|
:active (>= (calc-stack-size) 2)]
|
|
["Convert (1:) to Np (field)"
|
|
(progn
|
|
(require 'calc-units)
|
|
(let ((calc-hyperbolic-flag t))
|
|
(call-interactively 'calc-np)))
|
|
:keys "H l n"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["Convert (2:) to Np (field) with reference level (1:)"
|
|
(progn
|
|
(require 'calc-units)
|
|
(let ((calc-option-flag t)
|
|
(calc-hyperbolic-flag t))
|
|
(call-interactively 'calc-np)))
|
|
:keys "O H l d"
|
|
:active (>= (calc-stack-size) 2)]
|
|
["Convert (1:) to field quantity"
|
|
(progn
|
|
(require 'calc-units)
|
|
(let ((calc-hyperbolic-flag t))
|
|
(call-interactively 'calc-lu-quant)))
|
|
:keys "H l q"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["Convert (2:) to field quantity with reference level (1:)"
|
|
(progn
|
|
(require 'calc-units)
|
|
(let ((calc-option-flag t)
|
|
(calc-hyperbolic-flag))
|
|
(call-interactively 'calc-lu-quant)))
|
|
:keys "O H l q"
|
|
:active (>= (calc-stack-size) 2)])
|
|
(list "Musical Notes"
|
|
["Convert (1:) to scientific pitch notation"
|
|
(progn
|
|
(require 'calc-units)
|
|
(call-interactively 'calc-spn))
|
|
:keys "l s"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["Convert (1:) to midi number"
|
|
(progn
|
|
(require 'calc-units)
|
|
(call-interactively 'calc-midi))
|
|
:keys "l m"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["Convert (1:) to frequency"
|
|
(progn
|
|
(require 'calc-units)
|
|
(call-interactively 'calc-freq))
|
|
:keys "l f"
|
|
:active (>= (calc-stack-size) 1)])
|
|
"----"
|
|
["Help on Units"
|
|
(calc-info-goto-node "Units")])
|
|
"Menu for Calc's units functions.")
|
|
|
|
(defvar calc-variables-menu
|
|
(list "Variables"
|
|
["Store (1:) into a variable"
|
|
(progn
|
|
(require 'calc-store)
|
|
(call-interactively 'calc-store))
|
|
:keys "s s"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["Recall a variable value"
|
|
(progn
|
|
(require 'calc-store)
|
|
(call-interactively 'calc-recall ))
|
|
:keys "s r"]
|
|
["Edit the value of a variable"
|
|
(progn
|
|
(require 'calc-store)
|
|
(call-interactively 'calc-edit-variable))
|
|
:keys "s e"]
|
|
["Exchange (1:) with a variable value"
|
|
(progn
|
|
(require 'calc-store)
|
|
(call-interactively 'calc-store-exchange))
|
|
:keys "s x"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["Clear variable value"
|
|
(progn
|
|
(require 'calc-store)
|
|
(call-interactively 'calc-unstore))
|
|
:keys "s u"]
|
|
["Evaluate variables in (1:)"
|
|
(progn
|
|
(require 'calc-ext)
|
|
(call-interactively 'calc-evaluate))
|
|
:keys "="
|
|
:active (>= (calc-stack-size) 1)]
|
|
["Evaluate (1:), assigning a value to a variable"
|
|
(progn
|
|
(require 'calc-store)
|
|
(call-interactively 'calc-let))
|
|
:keys "s l"
|
|
:active (>= (calc-stack-size) 1)
|
|
:help "Evaluate (1:) under a temporary assignment of a variable"]
|
|
"----"
|
|
["Help on Variables"
|
|
(calc-info-goto-node "Store and Recall")])
|
|
"Menu for Calc's variables.")
|
|
|
|
(defvar calc-stack-menu
|
|
(list "Stack"
|
|
["Remove (1:)"
|
|
calc-pop
|
|
:keys "DEL"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["Switch (1:) and (2:)"
|
|
calc-roll-down
|
|
:keys "TAB"
|
|
:active (>= (calc-stack-size) 2)]
|
|
["Duplicate (1:)"
|
|
calc-enter
|
|
:keys "RET"
|
|
:active (>= (calc-stack-size) 1)]
|
|
["Edit (1:)"
|
|
(progn
|
|
(require 'calc-yank)
|
|
(call-interactively calc-edit))
|
|
:keys "`"
|
|
:active (>= (calc-stack-size) 1)]
|
|
"----"
|
|
["Help on Stack"
|
|
(calc-info-goto-node "Stack and Trail")])
|
|
"Menu for Calc's stack functions.")
|
|
|
|
(defvar calc-errors-menu
|
|
(list "Undo"
|
|
["Undo"
|
|
(progn
|
|
(require 'calc-undo)
|
|
(call-interactively 'calc-undo))
|
|
:keys "U"]
|
|
["Redo"
|
|
(progn
|
|
(require 'calc-undo)
|
|
(call-interactively 'calc-redo))
|
|
:keys "D"]
|
|
"----"
|
|
["Help on Undo"
|
|
(progn
|
|
(calc-info-goto-node "Introduction")
|
|
(Info-goto-node "Undo"))]))
|
|
|
|
(defvar calc-modes-menu
|
|
(list "Modes"
|
|
["Precision"
|
|
(progn
|
|
(require 'calc-ext)
|
|
(call-interactively 'calc-precision))
|
|
:keys "p"
|
|
:help "Set the precision for floating point calculations"]
|
|
["Fraction mode"
|
|
(progn
|
|
(require 'calc-frac)
|
|
(call-interactively 'calc-frac-mode))
|
|
:keys "m f"
|
|
:style toggle
|
|
:selected calc-prefer-frac
|
|
:help "Leave integer quotients as fractions"]
|
|
["Symbolic mode"
|
|
(lambda ()
|
|
(interactive)
|
|
(require 'calc-mode)
|
|
(calc-symbolic-mode nil))
|
|
:keys "m s"
|
|
:style toggle
|
|
:selected calc-symbolic-mode
|
|
:help "Leave functions producing inexact answers in symbolic form"]
|
|
["Infinite mode"
|
|
(lambda ()
|
|
(interactive)
|
|
(require 'calc-mode)
|
|
(calc-infinite-mode nil))
|
|
:keys "m i"
|
|
:style toggle
|
|
:selected calc-infinite-mode
|
|
:help "Let expressions like 1/0 produce infinite results"]
|
|
["Abbreviate long vectors"
|
|
(progn
|
|
(require 'calc-mode)
|
|
(call-interactively 'calc-full-vectors))
|
|
:keys "v ."
|
|
:style toggle
|
|
:selected (not calc-full-vectors)]
|
|
(list "Simplification"
|
|
["No simplification mode"
|
|
(progn
|
|
(require 'calc-mode)
|
|
(calc-no-simplify-mode t))
|
|
:keys "m O"
|
|
:style radio
|
|
:selected (eq calc-simplify-mode 'none)
|
|
:help "No simplifications are done automatically"]
|
|
["Numeric simplification mode"
|
|
(progn
|
|
(require 'calc-mode)
|
|
(calc-num-simplify-mode t))
|
|
:keys "m N"
|
|
:style radio
|
|
:selected (eq calc-simplify-mode 'num)
|
|
:help "Only numeric simplifications are done automatically"]
|
|
["Basic simplification mode"
|
|
(progn
|
|
(require 'calc-mode)
|
|
(calc-basic-simplify-mode t))
|
|
:keys "m I"
|
|
:style radio
|
|
:selected (eq calc-simplify-mode nil)
|
|
:help "Only basic simplifications are done automatically"]
|
|
["Binary simplification mode"
|
|
(progn
|
|
(require 'calc-mode)
|
|
(calc-bin-simplify-mode t))
|
|
:keys "m B"
|
|
:style radio
|
|
:selected (eq calc-simplify-mode 'binary)
|
|
:help "Basic simplifications with binary clipping are done automatically"]
|
|
["Algebraic simplification mode"
|
|
(progn
|
|
(require 'calc-mode)
|
|
(calc-alg-simplify-mode t))
|
|
:keys "m A"
|
|
:style radio
|
|
:selected (eq calc-simplify-mode 'alg)
|
|
:help "Standard algebraic simplifications are done automatically"]
|
|
["Extended simplification mode"
|
|
(progn
|
|
(require 'calc-mode)
|
|
(calc-ext-simplify-mode t))
|
|
:keys "m E"
|
|
:style radio
|
|
:selected (eq calc-simplify-mode 'ext)
|
|
:help "Extended (unsafe) simplifications are done automatically"]
|
|
["Units simplification mode"
|
|
(progn
|
|
(require 'calc-mode)
|
|
(calc-units-simplify-mode t))
|
|
:keys "m U"
|
|
:style radio
|
|
:selected (eq calc-simplify-mode 'units)
|
|
:help "Algebraic and unit simplifications are done automatically"])
|
|
(list "Angle Measure"
|
|
["Radians"
|
|
(progn
|
|
(require 'calc-math)
|
|
(call-interactively 'calc-radians-mode))
|
|
:keys "m r"
|
|
:style radio
|
|
:selected (eq calc-angle-mode 'rad)]
|
|
["Degrees"
|
|
(progn
|
|
(require 'calc-math)
|
|
(call-interactively 'calc-degrees-mode))
|
|
:keys "m d"
|
|
:style radio
|
|
:selected (eq calc-angle-mode 'deg)]
|
|
["HMS"
|
|
(progn
|
|
(require 'calc-math)
|
|
(call-interactively 'calc-hms-mode))
|
|
:keys "m h"
|
|
:style radio
|
|
:selected (eq calc-angle-mode 'hms)])
|
|
(list "Radix"
|
|
["Decimal"
|
|
(progn
|
|
(require 'calc-bin)
|
|
(call-interactively 'calc-decimal-radix))
|
|
:keys "d 0"
|
|
:style radio
|
|
:selected (and (= calc-number-radix 10)
|
|
(not calc-twos-complement-mode))]
|
|
["Binary"
|
|
(progn
|
|
(require 'calc-bin)
|
|
(call-interactively 'calc-binary-radix))
|
|
:keys "d 2"
|
|
:style radio
|
|
:selected (and (= calc-number-radix 2)
|
|
(not calc-twos-complement-mode))]
|
|
["Octal"
|
|
(progn
|
|
(require 'calc-bin)
|
|
(call-interactively 'calc-octal-radix))
|
|
:keys "d 8"
|
|
:style radio
|
|
:selected (and (= calc-number-radix 8)
|
|
(not calc-twos-complement-mode))]
|
|
["Hexadecimal"
|
|
(progn
|
|
(require 'calc-bin)
|
|
(call-interactively 'calc-hex-radix))
|
|
:keys "d 6"
|
|
:style radio
|
|
:selected (and (= calc-number-radix 16)
|
|
(not calc-twos-complement-mode))]
|
|
["Other"
|
|
(progn
|
|
(require 'calc-bin)
|
|
(call-interactively 'calc-radix))
|
|
:keys "d r"
|
|
:style radio
|
|
:selected (and
|
|
(not calc-twos-complement-mode)
|
|
(not
|
|
(or
|
|
(= calc-number-radix 10)
|
|
(= calc-number-radix 2)
|
|
(= calc-number-radix 8)
|
|
(= calc-number-radix 16))))]
|
|
["--Two's Complement--"
|
|
(lambda () ())
|
|
:style radio
|
|
:selected nil]
|
|
["Binary"
|
|
(progn
|
|
(require 'calc-bin)
|
|
(call-interactively
|
|
(lambda () (interactive) (calc-binary-radix t))))
|
|
:keys "C-u d 2"
|
|
:style radio
|
|
:selected (and (= calc-number-radix 2)
|
|
calc-twos-complement-mode)]
|
|
["Octal"
|
|
(progn
|
|
(require 'calc-bin)
|
|
(call-interactively
|
|
(lambda () (interactive) (calc-octal-radix t))))
|
|
:keys "C-u d 8"
|
|
:style radio
|
|
:selected (and (= calc-number-radix 8)
|
|
calc-twos-complement-mode)]
|
|
["Hexadecimal"
|
|
(progn
|
|
(require 'calc-bin)
|
|
(call-interactively
|
|
(lambda () (interactive) (calc-hex-radix t))))
|
|
:keys "C-u d 6"
|
|
:style radio
|
|
:selected (and (= calc-number-radix 16)
|
|
calc-twos-complement-mode)])
|
|
(list "Float Format"
|
|
["Normal"
|
|
(progn
|
|
(require 'calc-mode)
|
|
(call-interactively 'calc-normal-notation))
|
|
:keys "d n"
|
|
:style radio
|
|
:selected (eq (car-safe calc-float-format) 'float)]
|
|
["Fixed point"
|
|
(progn
|
|
(require 'calc-mode)
|
|
(call-interactively 'calc-fix-notation))
|
|
:keys "d f"
|
|
:style radio
|
|
:selected (eq (car-safe calc-float-format) 'fix)]
|
|
["Scientific notation"
|
|
(progn
|
|
(require 'calc-mode)
|
|
(call-interactively 'calc-sci-notation))
|
|
:keys "d s"
|
|
:style radio
|
|
:selected (eq (car-safe calc-float-format) 'sci)]
|
|
["Engineering notation"
|
|
(progn
|
|
(require 'calc-mode)
|
|
(call-interactively 'calc-eng-notation))
|
|
:keys "d e"
|
|
:style radio
|
|
:selected (eq (car-safe calc-float-format) 'eng)])
|
|
(list "Complex Format"
|
|
["Default"
|
|
(progn
|
|
(require 'calc-cplx)
|
|
(calc-complex-notation))
|
|
:style radio
|
|
:selected (not calc-complex-format)
|
|
:keys "d c"
|
|
:help "Display complex numbers as ordered pairs."]
|
|
["i notation"
|
|
(progn
|
|
(require 'calc-cplx)
|
|
(calc-i-notation))
|
|
:style radio
|
|
:selected (eq calc-complex-format 'i)
|
|
:keys "d i"
|
|
:help "Display complex numbers as a+bi."]
|
|
["j notation"
|
|
(progn
|
|
(require 'calc-cplx)
|
|
(calc-i-notation))
|
|
:style radio
|
|
:selected (eq calc-complex-format 'j)
|
|
:keys "d j"
|
|
:help "Display complex numbers as a+bj."]
|
|
["Other"
|
|
(calc-complex-notation)
|
|
:style radio
|
|
:selected (and calc-complex-format
|
|
(not (eq calc-complex-format 'i))
|
|
(not (eq calc-complex-format 'j)))
|
|
:active nil]
|
|
"----"
|
|
["Polar mode"
|
|
(progn
|
|
(require 'calc-cplx)
|
|
(calc-polar-mode nil))
|
|
:style toggle
|
|
:selected (eq calc-complex-mode 'polar)
|
|
:keys "m p"
|
|
:help "Prefer polar form for complex numbers."])
|
|
(list "Algebraic"
|
|
["Normal"
|
|
(progn
|
|
(require 'calc-mode)
|
|
(cond
|
|
(calc-incomplete-algebraic-mode
|
|
(calc-algebraic-mode t))
|
|
(calc-algebraic-mode
|
|
(calc-algebraic-mode nil))))
|
|
:style radio
|
|
:selected (not calc-algebraic-mode)]
|
|
["Algebraic mode"
|
|
(progn
|
|
(require 'calc-mode)
|
|
(if (or
|
|
calc-incomplete-algebraic-mode
|
|
(not calc-algebraic-mode))
|
|
(calc-algebraic-mode nil)))
|
|
:keys "m a"
|
|
:style radio
|
|
:selected (and calc-algebraic-mode
|
|
(not calc-incomplete-algebraic-mode))
|
|
:help "Keys which start numeric entry also start algebraic entry"]
|
|
["Incomplete algebraic mode"
|
|
(progn
|
|
(require 'calc-mode)
|
|
(unless calc-incomplete-algebraic-mode
|
|
(calc-algebraic-mode t)))
|
|
:keys "C-u m a"
|
|
:style radio
|
|
:selected calc-incomplete-algebraic-mode
|
|
:help "Only ( and [ begin algebraic entry"]
|
|
["Total algebraic mode"
|
|
(progn
|
|
(require 'calc-mode)
|
|
(unless (eq calc-algebraic-mode 'total)
|
|
(calc-total-algebraic-mode nil)))
|
|
:keys "m t"
|
|
:style radio
|
|
:selected (eq calc-algebraic-mode 'total)
|
|
:help "All regular letters and punctuation begin algebraic entry"])
|
|
(list "Matrix"
|
|
["Off"
|
|
(progn
|
|
(require 'calc-mode)
|
|
(calc-matrix-mode -1))
|
|
:style radio
|
|
:selected (eq calc-matrix-mode nil)
|
|
:help "Variables are not assumed to be matrix or scalar"]
|
|
["Matrix mode"
|
|
(progn
|
|
(require 'calc-mode)
|
|
(calc-matrix-mode -2))
|
|
:style radio
|
|
:selected (eq calc-matrix-mode 'matrix)
|
|
:help "Variables are assumed to be matrices"]
|
|
["Square matrix mode"
|
|
(progn
|
|
(require 'calc-mode)
|
|
(calc-matrix-mode '(4)))
|
|
:style radio
|
|
:selected (eq calc-matrix-mode 'sqmatrix)
|
|
:help "Variables are assumed to be square matrices"]
|
|
["Dimensioned matrix mode"
|
|
(let ((dim (string-to-number (read-from-minibuffer "Dimension: "))))
|
|
(if (natnump dim)
|
|
(progn
|
|
(require 'calc-mode)
|
|
(calc-matrix-mode dim))
|
|
(error "The dimension must be a positive integer")))
|
|
:style radio
|
|
:selected (and (integerp calc-matrix-mode) (> calc-matrix-mode 0))
|
|
:help "Variables are assumed to be NxN matrices"]
|
|
["Scalar mode"
|
|
(progn
|
|
(require 'calc-mode)
|
|
(calc-matrix-mode 0))
|
|
:style radio
|
|
:selected (eq calc-matrix-mode 'scalar)
|
|
:help "Variables are assumed to be scalars"])
|
|
(list "Language"
|
|
["Normal"
|
|
(progn
|
|
(require 'calc-lang)
|
|
(call-interactively 'calc-normal-language))
|
|
:keys "d N"
|
|
:style radio
|
|
:selected (eq calc-language nil)]
|
|
["Big"
|
|
(progn
|
|
(require 'calc-lang)
|
|
(call-interactively 'calc-big-language))
|
|
:keys "d B"
|
|
:style radio
|
|
:selected (eq calc-language 'big)
|
|
:help "Use textual approximations to various mathematical notations"]
|
|
["Flat"
|
|
(progn
|
|
(require 'calc-lang)
|
|
(call-interactively 'calc-flat-language))
|
|
:keys "d O"
|
|
:style radio
|
|
:selected (eq calc-language 'flat)
|
|
:help "Write matrices on a single line"]
|
|
["C"
|
|
(progn
|
|
(require 'calc-lang)
|
|
(call-interactively 'calc-c-language))
|
|
:keys "d C"
|
|
:style radio
|
|
:selected (eq calc-language 'c)]
|
|
["Pascal"
|
|
(progn
|
|
(require 'calc-lang)
|
|
(call-interactively 'calc-pascal-language))
|
|
:keys "d P"
|
|
:style radio
|
|
:selected (eq calc-language 'pascal)]
|
|
["Fortran"
|
|
(progn
|
|
(require 'calc-lang)
|
|
(call-interactively 'calc-fortran-language))
|
|
:keys "d F"
|
|
:style radio
|
|
:selected (eq calc-language 'fortran)]
|
|
["TeX"
|
|
(progn
|
|
(require 'calc-lang)
|
|
(call-interactively 'calc-tex-language))
|
|
:keys "d T"
|
|
:style radio
|
|
:selected (eq calc-language 'tex)]
|
|
["LaTeX"
|
|
(progn
|
|
(require 'calc-lang)
|
|
(call-interactively 'calc-latex-language))
|
|
:keys "d L"
|
|
:style radio
|
|
:selected (eq calc-language 'latex)]
|
|
["Eqn"
|
|
(progn
|
|
(require 'calc-lang)
|
|
(call-interactively 'calc-eqn-language))
|
|
:keys "d E"
|
|
:style radio
|
|
:selected (eq calc-language 'eqn)]
|
|
["Yacas"
|
|
(progn
|
|
(require 'calc-lang)
|
|
(call-interactively 'calc-yacas-language))
|
|
:keys "d Y"
|
|
:style radio
|
|
:selected (eq calc-language 'yacas)]
|
|
["Maxima"
|
|
(progn
|
|
(require 'calc-lang)
|
|
(call-interactively 'calc-maxima-language))
|
|
:keys "d X"
|
|
:style radio
|
|
:selected (eq calc-language 'maxima)]
|
|
["Giac"
|
|
(progn
|
|
(require 'calc-lang)
|
|
(call-interactively 'calc-giac-language))
|
|
:keys "d A"
|
|
:style radio
|
|
:selected (eq calc-language 'giac)]
|
|
["Mma"
|
|
(progn
|
|
(require 'calc-lang)
|
|
(call-interactively 'calc-mathematica-language))
|
|
:keys "d M"
|
|
:style radio
|
|
:selected (eq calc-language 'math)]
|
|
["Maple"
|
|
(progn
|
|
(require 'calc-lang)
|
|
(call-interactively 'calc-maple-language))
|
|
:keys "d W"
|
|
:style radio
|
|
:selected (eq calc-language 'maple)])
|
|
"----"
|
|
["Save mode settings" calc-save-modes :keys "m m"]
|
|
"----"
|
|
["Help on Modes"
|
|
(calc-info-goto-node "Mode settings")])
|
|
"Menu for Calc's mode settings.")
|
|
|
|
(defvar calc-help-menu
|
|
(list "Help"
|
|
["Manual"
|
|
calc-info
|
|
:keys "h i"]
|
|
["Tutorial"
|
|
calc-tutorial
|
|
:keys "h t"]
|
|
["Summary"
|
|
calc-info-summary
|
|
:keys "h s"]
|
|
"----"
|
|
["Help on Help"
|
|
(progn
|
|
(calc-info-goto-node "Introduction")
|
|
(Info-goto-node "Help Commands"))])
|
|
"Menu for Calc's help functions.")
|
|
|
|
(defvar calc-mode-map)
|
|
|
|
(easy-menu-define
|
|
calc-menu
|
|
calc-mode-map
|
|
"Menu for Calc."
|
|
(list "Calc"
|
|
:visible '(eq major-mode 'calc-mode)
|
|
calc-arithmetic-menu
|
|
calc-scientific-function-menu
|
|
calc-algebra-menu
|
|
calc-graphics-menu
|
|
calc-vectors-menu
|
|
calc-units-menu
|
|
calc-variables-menu
|
|
calc-stack-menu
|
|
calc-errors-menu
|
|
calc-modes-menu
|
|
calc-help-menu
|
|
["Reset"
|
|
(progn
|
|
(require 'calc-ext)
|
|
(call-interactively 'calc-reset))
|
|
:help "Reset Calc to its initial state"]
|
|
["Quit" calc-quit]))
|
|
|
|
(provide 'calc-menu)
|