(declare-function math-to-percentsigns "calccomp" (x))

(defvar calc-quick-calc-history nil

;;;###autoload

(defun calc-do-quick-calc (&optional insert)

("₋" "-") ; -

("₍" "(") ; (

("₎" ")")) ; )

(defvar math-read-superscripts

"⁰¹²³⁴⁵⁶⁷⁸⁹⁺⁻⁽⁾ⁿⁱ" ; 0123456789+-()ni

0)

(setq sym (intern (substring (symbol-name sym)

1))))

(setq sym (intern

(concat "calcFunc-"

(symbol-name sym))))))

(let ((val (list 'var

(intern (math-remove-dashes

(symbol-name sym)))

sym

(intern (concat "var-"

(symbol-name sym)))))))

(defun math-power-of-2 (n) ; [I I] [Public]

(if (natnump n)

(ash 1 n)

(defun math-integer-log2 (n) ; [I I] [Public]

(and (natnump n)

(math-read-big-err-msg nil)

math-read-big-baseline math-read-big-h2

new-pos p)

(setq math-read-big-lines

(cons (substring str pos new-pos) math-read-big-lines)

pos (1+ new-pos)))

(t

(let ((str (math-format-flat-expr x 0))

(pos 0) p)

(while (<= (setq p (+ pos w)) (length str))

(while (and (> (setq p (1- p)) pos)

(not (= (aref str p) ? ))))

(math-format-radix-float a prec))

(format "%d#%s" calc-number-radix

(math-format-radix-float a prec)))))

(concat "(" str ")")

str))))

((eq (car a) 'frac)

;;; Users can redefine this in their init files.

(defvar calc-keypad-user-menu nil

It should contain a list of three rows.

Each row should be a list of six keys.

Each key should be a list of a label string, plus a Calc command name spec.

fmt))))

(defconst math-julian-date-beginning '(float 17214245 -1)

(defconst math-julian-date-beginning-int 1721425

(defconst math-unix-epoch 719163

(defun math-format-date-part (x)

(cond ((stringp x)

(if (eq (car-safe str2) 'error)

str2

(append '(calcFunc-lambda) (cdr str1) (list str2)))))

(let ((calc-hashes-used 0))

(and (setq str (math-read-expr str))

(if (eq (car-safe str) 'error)

((>= calc-gnuplot-version 3)

"dumb")

(t "postscript"))))

(if (equal device "dumb")

(setq device (format "dumb %d %d"

(1- (frame-width)) (1- (frame-height)))))

(setq tempoutfile (calc-temp-file-name -1)

output tempoutfile))

(setq output (eval output t)))

(or (equal output calc-graph-last-output)

(progn

(setq calc-graph-last-output output)

(calc-pop-stack 1))))

(if (string-match "\\[.+\\]" range)

(setq range (substring range 1 -1)))

(or (string-match "," range)

(string-match " " range)))

(aset range (match-beginning 0) ?\:))

(or calc-graph-no-auto-view (sit-for 0))))

(defun calc-gnuplot-check-for-errors ()

(calc-graph-view-trail)))

(defun calc-gnuplot-command (&rest args)

(calc-graph-init)

(let ((cmd (concat (mapconcat 'identity args " ") "\n")))

(or (calc-graph-w32-p)

(or (calc-graph-w32-p)

(accept-process-output (and (not calc-graph-no-wait)

calc-gnuplot-process)))

(defun calc-graph-init-buffers ()

(or (and calc-gnuplot-buffer

(with-current-buffer "*Help*"

(let ((inhibit-read-only t))

(goto-char (point-min))

(when (search-forward "Global bindings:" nil t)

(forward-line -1)

(delete-region (point) (point-max)))

":"

(if (and (equal cmd "e")

(or (not input)

"#" input))

(> radix 14))

(format "*%d.^" radix)

(setq math-exp-pos (match-end 0)

math-exp-token 'punc

math-expr-data "[")

(and right

(setq math-exp-str (copy-sequence math-exp-str))

(aset math-exp-str right ?\]))))))))))

(setq math-exp-pos (match-end 0)

math-exp-token 'punc

math-expr-data "[")

(and right

(setq math-exp-str (copy-sequence math-exp-str))

(aset math-exp-str right ?\]))))))))))

(math-read-big-emptyp math-rb-h1 (1+ v) h math-rb-v2 nil t)

(if (= (math-read-big-char widest v) ?\()

(progn

(intern p)

(intern (concat "calcFunc-" p)))

h (1+ widest)

(setq p (cons line (nreverse p))))

(setq p (list 'var

(intern (math-remove-dashes p))

(intern p)

(intern (concat "var-" p)))))))

(defvar calc-verify-arglist t)

(defun calc-map-stack ()

(interactive)

(let ((calc-verify-arglist nil))

(calc-unread-command ?\$)

(defun math-nth-root-float (a nrf-n &optional guess)

(math-inexact-result)

(math-with-extra-prec 1

(math-nth-root-float-iter a (or guess

(math-make-float

1 (/ (+ (math-numdigs (nth 1 a))

;;; Commentary:

(defvar calc-arithmetic-menu

(list "Arithmetic"

(list "Basic"

0 (zero) calc-reset. Reset Calc stack and modes to default state.

Press `*' twice (`C-x * *') to turn Calc on or off using the same

(interactive "P")

(calc-check-defines)

(if calc-dispatch-help

(defun math-atomic-factorp (expr)

(cond ((eq (car-safe expr) '*)

(and (math-atomic-factorp (nth 1 expr))

(math-atomic-factorp (nth 2 expr))))

(or (memq (car-safe (car-safe place)) '(error xxxerror))

(setq place (aref (nth 2 (nth 2 (symbol-function 'calc-do))) 27)))

(or (memq (car (car place)) '(error xxxerror))

(setcar (car place) 'xxxerror))

(error (error "The calc-do function has been modified; unable to patch"))))

(progn

(setq cmd-base-default (concat "User-" keyname))

(setq cmd (completing-read

obarray 'commandp nil

(if (and odef (symbolp (cdr odef)))

(symbol-name (cdr odef))

(setq func

(concat "calcFunc-"

(completing-read

(mapcar (lambda (x) (substring x 9))

(all-completions "calcFunc-"

obarray))

((equal name "#")

(search-backward "#")

(error "Token `#' is reserved"))

(error "Tokens containing `#' must be quoted"))

((not (string-match "[^ ]" name))

(search-backward "\"" nil t)

(when match

(kill-line 1)

(setq line (concat line (substring curline 0 match))))

(insert line "\t\t\t")

(if (> (current-column) 24)

(delete-char -1))

(when match

(kill-line 1)

(setq line (concat line (substring curline 0 match))))

(insert cmdbeg " " line "\t\t\t")

(if (> (current-column) 24)

(delete-char -1))

(when match

(kill-line 1)

(setq line (concat line (substring curline 0 match))))

(insert line "\t\t\t")

(if (> (current-column) 24)

(delete-char -1))

(insert (setq str (prin1-to-string

(cons 'defun (cons cmd (cdr fcmd)))))

"\n")

(fill-region pt (point)))

(indent-rigidly pt (point) 2)

(delete-region pt (1+ pt))

(cons 'defun (cons func

(cdr ffunc)))))

"\n")

(fill-region pt (point)))

(indent-rigidly pt (point) 2)

(delete-region pt (1+ pt))

(cdr prim))

((memq exp math-exp-env)

exp)

exp)

(t

(intern (concat "var-" name))))))

(defun calc-permanent-variable (&optional var)

(interactive)

(calc-wrapper

(let (calc-pv-pos)

(and var (or (and (boundp var) (symbol-value var))

(error "No such variable")))

If EXPR is nil, return nil."

(if expr

(let ((cexpr (math-compose-expr expr 0)))

" / " "/"

(if (stringp cexpr)

cexpr

(setq defunits (math-get-default-units expr))

(unless new-units

(setq new-units

(if (and uoldname (not nouold))

(concat "Old units: "

uoldname

", new units")

"New units")

(if (and

(string= new-units "")

defunits)

(calc-slow-wrapper

(let* ((expr (calc-top-n 1)))

(unless (math-units-in-expr-p expr t)

(let* ((old-units (math-extract-units expr))

(defunits (math-get-default-units expr))

units

(if (and

(string= new-units "")

defunits)

(setq expr (math-mul expr uold)))

(setq defunits (math-get-default-units expr))

(setq unew (or new-units

(setq unew (math-read-expr (if (string= unew "") defunits unew)))

(when (eq (car-safe unew) 'error)

(error "Bad format in units expression: %s" (nth 2 unew)))

;;; Code:

(require 'calc-macs)

;; Declare functions which are defined elsewhere.

(declare-function calc-set-language "calc-lang" (lang &optional option no-refresh))

(defcustom calc-embedded-announce-formula

"%Embed\n\\(% .*\n\\)*"

:type '(regexp))

(defcustom calc-embedded-announce-formula-alist

(defcustom calc-embedded-close-formula

"\\'\\|\n$\\|\\$\\$?\\|\\\\]\\|^\\\\end[^{].*\n\\|^\\\\end{.*[^x]}.*\n\\|^@.*\n\\|^\\.EN.*\n\\|\\\\)\\|\n%\n\\|^\\.\\\\\"\n"

:type '(regexp))

(defcustom calc-embedded-open-close-formula-alist

nil

:type '(alist :key-type (symbol :tag "Major mode")

:value-type (list (regexp :tag "Opening formula delimiter")

(regexp :tag "Closing formula delimiter"))))

(defcustom calc-embedded-open-mode

"% "

This is not required to be present for user-written mode annotations."

:type '(string))

(defcustom calc-embedded-close-mode

"\n"

This is not required to be present for user-written mode annotations."

:type '(string))

:type '(string)

:version "26.2")

"Name of command for displaying GNUPLOT output; %s = file name to print."

:type '(choice (string) (sexp)))

"Name of command for printing GNUPLOT output; %s = file name to print."

:type '(choice (string) (sexp)))

:type 'boolean)

:version "24.3"

:type 'boolean)

"If non-nil, the stack element under the cursor will be copied by `calc-enter'

and deleted by `calc-pop'."

:version "24.4"

:type 'boolean)

"The number of undo steps that will be preserved when Calc is quit."

:type 'integer)

"If non-nil, use a separate face to indicate selected sub-formulas.

If option `calc-show-selections' is non-nil, then selected sub-formulas are

shown by displaying the rest of the formula in `calc-nonselected-face'.

:version "24.1"

:type 'boolean)

"The default reference level for logarithmic units (field)."

:version "24.1"

:type '(string))

"The default reference level for logarithmic units (power)."

:version "24.1"

:type '(string))

(defvar calc-display-sci-high 0

"Floating-point numbers with this positive exponent or higher above the

(defvar calc-display-sci-low -3

"Floating-point numbers with this negative exponent or lower are displayed

(defvar calc-digit-after-point nil

"If t, display at least one digit after the decimal point, as in `12.0'.

"List of strings for Y prefix help.")

(defvar calc-loaded-settings-file nil

(defvar calc-mode-var-list '()

"List of variables used in customizing GNU Calc.")

(defmacro defcalcmodevar (var defval &optional doc)

The variable VAR will be added to `calc-mode-var-list'."

`(progn

(defvar ,var ,defval ,doc)

(add-to-list 'calc-mode-var-list (list (quote ,var) ,defval))))

"Initial height of Calculator window.")

(defcalcmodevar calc-display-trail t

(defcalcmodevar calc-show-selections t

"If non-nil, selected sub-formulas are shown by obscuring rest of formula.

(defvar calc-trail-pointer nil

"The \"current\" entry in trail buffer.")

(defvar calc-trail-overlay nil

(defvar calc-undo-list nil

"The list of previous operations for undo.")

(defvar calc-redo-list nil

(defvar calc-lang-allow-percentsigns nil

"A list of languages which allow percent signs in variable names.")

(defvar calc-lang-c-type-hex nil

(defvar calc-lang-brackets-are-subscripts nil

"Languages in which subscripts are indicated by brackets.")

(defvar calc-lang-parens-are-subscripts nil

<1 jan 91> Date form (enter using \\=' key)

(interactive)

(mapc (lambda (v)

;; FIXME: Why (set-default v (symbol-value v)) ?!?!?

map))

(defun calc--header-line (long short width &optional fudge)

LONG is a desired text for a wide window, SHORT is a desired

abbreviated text, and width is the buffer width, which will be

some fraction of the 'parent' window width (At the time of

trial-and-error adjustment number for the edge-cases at the

border of the two cases."

;; TODO: This could be called as part of a 'window-resize' hook.

This mode is used by the *Calc Trail* buffer, which records all results

obtained by the GNU Emacs Calculator.

the Trail.

This buffer uses the same key map as the *Calculator* buffer; calculator

(with-current-buffer (calc-trail-buffer)

(and calc-display-trail

(calc-trail-display 1 t)))

(run-hooks 'calc-start-hook)

(and (windowp full-display)

(window-point full-display)

(calc nil t interactive))

(defun calc-same-interface (arg)

(interactive "P")

(if (and (equal (buffer-name) "*Gnuplot Trail*")

(> (recursion-depth) 0))

"Invoke the Calculator in \"visual keypad\" mode.

This is most useful in the X window system.

In this mode, click on the Calc \"buttons\" using the left mouse button.

(interactive "p")

(require 'calc-ext)

(calc-do-keypad calc-full-mode interactive))

(goto-char (point-max))

(cond ((null prefix) (insert " "))

((and (> (length prefix) 4)

(insert (substring prefix 0 4) " "))

(t (insert (format "%4s " prefix))))

(insert fval "\n")

(calc-minibuffer-contains

"[-+]?\\(.*\\+/- *\\|.*mod *\\)?\\([0-9]+\\.?0*[@oh] *\\)?\\([0-9]+\\.?0*['m] *\\)?[0-9]*\\(\\.?[0-9]*\\(e[-+]?[0-3]?[0-9]?[0-9]?[0-9]?[0-9]?[0-9]?[0-9]?\\)?\\|[0-9]:\\([0-9]+:\\)?[0-9]*\\)?[\"s]?\\'"))

(if (and (memq last-command-event '(?@ ?o ?h ?\' ?m))

(insert " "))

(if (and (memq last-command '(calcDigit-start calcDigit-key))

(eq last-command-event ?.))

(defun calc-count-lines (s)

(let ((pos 0)

(num 1))

(setq pos (1+ pos)

num (1+ num)))

num))

"Parse the region as a vector of numbers and push it on the Calculator stack."

(interactive "r\nP")

(require 'calc-ext)

;;;###autoload

(defun calc-grab-rectangle (top bot arg)

(require 'calc-ext)

(calc-do-grab-rectangle top bot arg))

(defun calc-grab-sum-down (top bot arg)

"Parse a rectangle as a matrix of numbers and sum its columns."

(interactive "r\nP")

(require 'calc-ext)

(calc-do-grab-rectangle top bot arg 'calcFunc-reduced))

(defun calc-grab-sum-across (top bot arg)

"Parse a rectangle as a matrix of numbers and sum its rows."

(interactive "r\nP")

actual Lisp function name.

See Info node `(calc)Defining Functions'."

(require 'calc-ext)

(math-do-defmath func args body))

(calc-top-n 2)

(calc-top-n 1)))

(let ((var (if (and (string-match ",\\|[^ ] +[^ ]" var)

(math-read-expr (concat "[" var "]"))

(math-read-expr var))))

(if (eq (car-safe var) 'error)

(calc-top-n 2)

(calc-top-n 1)))

(let ((var (if (and (string-match ",\\|[^ ] +[^ ]" var)

(math-read-expr (concat "[" var "]"))

(math-read-expr var))))

(if (eq (car-safe var) 'error)

(fset 'calcFunc-integ math-old-integ))))

;; See if the function is a symbolic derivative.

(let ((name (symbol-name (car expr)))

(p expr) (n 0) (which nil) (bad nil))

(while (setq n (1+ n) p (cdr p))

(calc-top-n 1)

(calc-top-n 2)))

(let ((var (if (and (string-match ",\\|[^ ] +[^ ]" var)

(math-read-expr (concat "[" var "]"))

(math-read-expr var))))

(if (eq (car-safe var) 'error)

(calc-top-n 1)

(calc-top-n 2)))

(let ((var (if (and (string-match ",\\|[^ ] +[^ ]" var)

(math-read-expr (concat "[" var "]"))

(math-read-expr var))))

(if (eq (car-safe var) 'error)

defc)

",")))))

(coefs nil))

(math-read-expr vars)

(math-read-expr (concat "[" vars "]"))))

(if (eq (car-safe vars) 'error)

h (cdr h)))

(setq curh (math-div-float curh '(float 9 0))))

ss

(defun math-ninteg-evaluate (expr x mode)