This is ../../info/calc, produced by makeinfo version 4.11 from calc.texi. This file documents Calc, the GNU Emacs calculator. Copyright (C) 1990, 1991, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with the Invariant Sections being just "GNU GENERAL PUBLIC LICENSE", with the Front-Cover texts being "A GNU Manual," and with the Back-Cover Texts as in (a) below. A copy of the license is included in the section entitled "GNU Free Documentation License." (a) The FSF's Back-Cover Text is: "You have the freedom to copy and modify this GNU manual. Buying copies from the FSF supports it in developing GNU and promoting software freedom." INFO-DIR-SECTION Emacs START-INFO-DIR-ENTRY * Calc: (calc). Advanced desk calculator and mathematical tool. END-INFO-DIR-ENTRY  File: calc, Node: Command Index, Next: Function Index, Prev: Key Index, Up: Top Index of Calculator Commands **************************** Since all Calculator commands begin with the prefix `calc-', the `x' key has been provided as a variant of `M-x' which automatically types `calc-' for you. Thus, `x last-args' is short for `M-x calc-last-args'. [index] * Menu: * another-calc: Multiple Calculators. (line 6) * calc: Basic Commands. (line 6) * calc-abs: Basic Arithmetic. (line 165) * calc-abs (vectors): Vector and Matrix Arithmetic. (line 19) * calc-abssqr: Basic Arithmetic. (line 175) * calc-alg-evaluate: Algebraic Manipulation. (line 15) * calc-alg-simplify-mode: Simplification Modes. (line 48) * calc-algebraic-entry: Algebraic Entry. (line 6) * calc-algebraic-mode: Algebraic Entry. (line 28) * calc-alt-summation: Summations. (line 104) * calc-always-load-extensions: General Mode Commands. (line 48) * calc-and: Binary Functions. (line 57) * calc-apart: Polynomials. (line 105) * calc-append-to-register: Saving Into Registers. (line 6) * calc-apply: Reducing and Mapping. (line 9) * calc-arccos: Trigonometric and Hyperbolic Functions. (line 44) * calc-arccosh: Trigonometric and Hyperbolic Functions. (line 44) * calc-arcsin: Trigonometric and Hyperbolic Functions. (line 34) * calc-arcsinh: Trigonometric and Hyperbolic Functions. (line 39) * calc-arctan: Trigonometric and Hyperbolic Functions. (line 44) * calc-arctan2: Trigonometric and Hyperbolic Functions. (line 49) * calc-arctanh: Trigonometric and Hyperbolic Functions. (line 44) * calc-argument: Complex Number Functions. (line 12) * calc-arrange-vector: Manipulating Vectors. (line 23) * calc-assign: Evaluates-To Operator. (line 90) * calc-auto-recompute <1>: Evaluates-To Operator. (line 41) * calc-auto-recompute: Automatic Recomputation. (line 11) * calc-auto-why: Error Messages. (line 20) * calc-autorange-units: Basic Operations on Units. (line 138) * calc-base-units: Basic Operations on Units. (line 116) * calc-bernoulli-number: Combinatorial Functions. (line 52) * calc-bessel-J: Advanced Math Functions. (line 58) * calc-bessel-Y: Advanced Math Functions. (line 58) * calc-beta: Advanced Math Functions. (line 42) * calc-big-language: Normal Language Modes. (line 24) * calc-bin-simplify-mode: Simplification Modes. (line 41) * calc-break: Loops in Macros. (line 26) * calc-break-selections: Making Selections. (line 96) * calc-break-vectors: Vector and Matrix Formats. (line 86) * calc-build-vector: Building Vectors. (line 80) * calc-business-days-minus: Business Days. (line 13) * calc-business-days-plus: Business Days. (line 13) * calc-c-language: C FORTRAN Pascal. (line 6) * calc-ceiling: Integer Truncation. (line 19) * calc-center-justify: Justification. (line 6) * calc-change-sign: Basic Arithmetic. (line 161) * calc-choose: Combinatorial Functions. (line 42) * calc-clean: Conversions. (line 81) * calc-clean-num: Conversions. (line 101) * calc-clear-selections: Making Selections. (line 118) * calc-clip: Binary Functions. (line 26) * calc-cnorm: Vector and Matrix Arithmetic. (line 31) * calc-collect: Polynomials. (line 68) * calc-commute-left: Rearranging with Selections. (line 32) * calc-commute-right: Rearranging with Selections. (line 6) * calc-complex-notation: Complex Formats. (line 6) * calc-concat: Building Vectors. (line 9) * calc-conj: Complex Number Functions. (line 6) * calc-conj-transpose: Vector and Matrix Arithmetic. (line 16) * calc-cons: Building Vectors. (line 92) * calc-convert-percent: Percentages. (line 34) * calc-convert-temperature: Basic Operations on Units. (line 126) * calc-convert-time-zones: Date Conversions. (line 60) * calc-convert-units: Basic Operations on Units. (line 51) * calc-copy-as-kill: Killing From Stack. (line 6) * calc-copy-region-as-kill: Killing From Stack. (line 6) * calc-copy-special-constant: Storing Variables. (line 137) * calc-copy-to-buffer: Yanking Into Buffers. (line 6) * calc-copy-to-register: Saving Into Registers. (line 6) * calc-copy-variable: Storing Variables. (line 115) * calc-cos: Trigonometric and Hyperbolic Functions. (line 44) * calc-cosh: Trigonometric and Hyperbolic Functions. (line 44) * calc-cot: Trigonometric and Hyperbolic Functions. (line 65) * calc-coth: Trigonometric and Hyperbolic Functions. (line 65) * calc-cross: Vector and Matrix Arithmetic. (line 38) * calc-csc: Trigonometric and Hyperbolic Functions. (line 65) * calc-csch: Trigonometric and Hyperbolic Functions. (line 65) * calc-curve-fit: Linear Fits. (line 6) * calc-date: Date Conversions. (line 6) * calc-date-notation: Date Formats. (line 6) * calc-date-part: Date Functions. (line 11) * calc-declare-variable: Declaration Basics. (line 6) * calc-decrement: Basic Arithmetic. (line 227) * calc-default-simplify-mode: Simplification Modes. (line 36) * calc-define-unit: User-Defined Units. (line 27) * calc-degrees-mode: Angular Modes. (line 20) * calc-del-selection: Operating on Selections. (line 77) * calc-derivative: Differentiation. (line 6) * calc-describe-function: Help Commands. (line 67) * calc-describe-key: Help Commands. (line 41) * calc-describe-key-briefly: Help Commands. (line 52) * calc-describe-variable: Help Commands. (line 74) * calc-diag: Building Vectors. (line 32) * calc-diff: Binary Functions. (line 71) * calc-display-strings: Strings. (line 25) * calc-divide: Basic Arithmetic. (line 89) * calc-dots: Incomplete Objects. (line 32) * calc-double-factorial: Combinatorial Functions. (line 34) * calc-edit: Editing Stack Entries. (line 6) * calc-edit-finish: Editing Stack Entries. (line 6) * calc-edit-selection: Operating on Selections. (line 53) * calc-edit-user-syntax: Syntax Tables. (line 13) * calc-edit-variable: Operations on Variables. (line 6) * calc-embedded: Basic Embedded Mode. (line 6) * calc-embedded-activate: Assignments in Embedded Mode. (line 93) * calc-embedded-duplicate: More About Embedded Mode. (line 84) * calc-embedded-edit: More About Embedded Mode. (line 134) * calc-embedded-new-formula: More About Embedded Mode. (line 115) * calc-embedded-next: More About Embedded Mode. (line 123) * calc-embedded-preserve-modes: Mode Settings in Embedded Mode. (line 6) * calc-embedded-previous: More About Embedded Mode. (line 123) * calc-embedded-select: Assignments in Embedded Mode. (line 51) * calc-embedded-update-formula: Assignments in Embedded Mode. (line 64) * calc-embedded-word: Basic Embedded Mode. (line 53) * calc-enable-selections: Operating on Selections. (line 11) * calc-eng-notation: Float Formats. (line 34) * calc-enter: Stack Manipulation. (line 6) * calc-enter-selection: Operating on Selections. (line 43) * calc-enter-units-table: The Units Table. (line 6) * calc-eqn-language: Eqn Language Mode. (line 6) * calc-equal-to: Logical Operations. (line 20) * calc-erf: Advanced Math Functions. (line 53) * calc-euler-number: Combinatorial Functions. (line 60) * calc-eval-num: Symbolic Mode. (line 17) * calc-evalto: Evaluates-To Operator. (line 22) * calc-evaluate: Variables. (line 30) * calc-execute-extended-command: Basic Commands. (line 23) * calc-exp: Logarithmic Functions. (line 11) * calc-expand: Polynomials. (line 83) * calc-expand-formula: Algebraic Manipulation. (line 59) * calc-expand-vector: Manipulating Vectors. (line 115) * calc-explain-units: The Units Table. (line 45) * calc-expm1: Logarithmic Functions. (line 37) * calc-ext-simplify-mode: Simplification Modes. (line 53) * calc-extended-gcd: Combinatorial Functions. (line 20) * calc-extract-units: Basic Operations on Units. (line 131) * calc-factor: Polynomials. (line 13) * calc-factorial: Combinatorial Functions. (line 24) * calc-fdiv: Basic Arithmetic. (line 153) * calc-fin-ddb: Depreciation Functions. (line 29) * calc-fin-fv: Future Value. (line 6) * calc-fin-irr: Related Financial Functions. (line 50) * calc-fin-nper: Related Financial Functions. (line 21) * calc-fin-npv: Present Value. (line 46) * calc-fin-pmt: Related Financial Functions. (line 9) * calc-fin-pv: Present Value. (line 6) * calc-fin-rate: Related Financial Functions. (line 38) * calc-fin-sln: Depreciation Functions. (line 16) * calc-fin-syd: Depreciation Functions. (line 22) * calc-find-maximum: Minimization. (line 6) * calc-find-minimum: Minimization. (line 6) * calc-find-root: Root Finding. (line 6) * calc-fix-notation: Float Formats. (line 20) * calc-flat-language: Normal Language Modes. (line 11) * calc-float: Conversions. (line 9) * calc-floor: Integer Truncation. (line 15) * calc-flush-caches: Caches. (line 19) * calc-fortran-language: C FORTRAN Pascal. (line 40) * calc-frac-mode: Fraction Mode. (line 13) * calc-fraction: Conversions. (line 40) * calc-from-hms: Conversions. (line 70) * calc-full-help: Help Commands. (line 12) * calc-full-trail-vectors: Vector and Matrix Formats. (line 78) * calc-full-vectors: Vector and Matrix Formats. (line 71) * calc-gamma: Advanced Math Functions. (line 18) * calc-gcd: Combinatorial Functions. (line 9) * calc-get-modes: Modes Variable. (line 6) * calc-get-unit-definition: The Units Table. (line 35) * calc-get-user-defn: Algebraic Definitions. (line 75) * calc-giac-language: Giac Language Mode. (line 6) * calc-grab-rectangle: Grabbing From Buffers. (line 37) * calc-grab-region: Grabbing From Buffers. (line 6) * calc-grab-selection: Operating on Selections. (line 83) * calc-grab-sum-across: Grabbing From Buffers. (line 77) * calc-grab-sum-down: Grabbing From Buffers. (line 77) * calc-grade: Manipulating Vectors. (line 53) * calc-graph-add: Managing Curves. (line 11) * calc-graph-add-3d: Managing Curves. (line 62) * calc-graph-border: Graphics Options. (line 13) * calc-graph-clear: Basic Graphics. (line 68) * calc-graph-command: Devices. (line 111) * calc-graph-delete: Managing Curves. (line 78) * calc-graph-device: Devices. (line 6) * calc-graph-display: Devices. (line 92) * calc-graph-fast: Basic Graphics. (line 6) * calc-graph-fast-3d: Three Dimensional Graphics. (line 6) * calc-graph-geometry: Devices. (line 97) * calc-graph-grid: Graphics Options. (line 6) * calc-graph-header: Graphics Options. (line 45) * calc-graph-hide: Managing Curves. (line 83) * calc-graph-juggle: Managing Curves. (line 88) * calc-graph-key: Graphics Options. (line 17) * calc-graph-kill: Devices. (line 149) * calc-graph-line-style: Graphics Options. (line 89) * calc-graph-log-x: Graphics Options. (line 74) * calc-graph-log-y: Graphics Options. (line 74) * calc-graph-log-z: Graphics Options. (line 78) * calc-graph-name: Graphics Options. (line 49) * calc-graph-num-points: Graphics Options. (line 22) * calc-graph-output: Devices. (line 45) * calc-graph-plot: Managing Curves. (line 95) * calc-graph-point-style: Graphics Options. (line 98) * calc-graph-print: Managing Curves. (line 126) * calc-graph-quit: Devices. (line 142) * calc-graph-range-x: Graphics Options. (line 65) * calc-graph-range-y: Graphics Options. (line 65) * calc-graph-range-z: Graphics Options. (line 78) * calc-graph-title-x: Graphics Options. (line 57) * calc-graph-title-y: Graphics Options. (line 57) * calc-graph-title-z: Graphics Options. (line 78) * calc-graph-view-commands: Devices. (line 117) * calc-graph-view-trail: Devices. (line 117) * calc-graph-zero-x: Graphics Options. (line 82) * calc-graph-zero-y: Graphics Options. (line 82) * calc-greater-equal: Logical Operations. (line 51) * calc-greater-than: Logical Operations. (line 51) * calc-group-char: Grouping Digits. (line 20) * calc-group-digits: Grouping Digits. (line 6) * calc-head: Building Vectors. (line 87) * calc-help: Help Commands. (line 6) * calc-histogram: Manipulating Vectors. (line 79) * calc-hms-mode: Angular Modes. (line 20) * calc-hms-notation: HMS Formats. (line 6) * calc-hyperbolic: Inverse and Hyperbolic. (line 12) * calc-hypot: Basic Arithmetic. (line 192) * calc-i-notation: Complex Formats. (line 11) * calc-ident: Building Vectors. (line 45) * calc-idiv: Basic Arithmetic. (line 139) * calc-ilog: Logarithmic Functions. (line 29) * calc-im: Complex Number Functions. (line 29) * calc-imaginary: Complex Number Functions. (line 19) * calc-in-set: Logical Operations. (line 109) * calc-inc-beta: Advanced Math Functions. (line 47) * calc-inc-gamma: Advanced Math Functions. (line 25) * calc-inc-month: Date Functions. (line 98) * calc-increment: Basic Arithmetic. (line 227) * calc-index: Building Vectors. (line 61) * calc-infinite-mode: Infinite Mode. (line 10) * calc-info: Help Commands. (line 20) * calc-info-summary: Help Commands. (line 37) * calc-inner-product: Generalized Products. (line 14) * calc-insert-register: Inserting From Registers. (line 6) * calc-insert-variables: Operations on Variables. (line 87) * calc-integral: Integration. (line 6) * calc-inv: Basic Arithmetic. (line 184) * calc-inv (matrices): Vector and Matrix Arithmetic. (line 42) * calc-inverse: Inverse and Hyperbolic. (line 6) * calc-isqrt: Basic Arithmetic. (line 197) * calc-j-notation: Complex Formats. (line 11) * calc-julian: Date Conversions. (line 35) * calc-kbd-else: Conditionals in Macros. (line 6) * calc-kbd-else-if: Conditionals in Macros. (line 6) * calc-kbd-end-for: Loops in Macros. (line 33) * calc-kbd-end-if: Conditionals in Macros. (line 6) * calc-kbd-end-loop: Loops in Macros. (line 56) * calc-kbd-end-repeat: Loops in Macros. (line 6) * calc-kbd-for: Loops in Macros. (line 33) * calc-kbd-if: Conditionals in Macros. (line 6) * calc-kbd-loop: Loops in Macros. (line 56) * calc-kbd-pop: Local Values in Macros. (line 11) * calc-kbd-push: Local Values in Macros. (line 11) * calc-kbd-query: Queries in Macros. (line 6) * calc-kbd-repeat: Loops in Macros. (line 6) * calc-keep-args: Keep Arguments. (line 6) * calc-keypad: Keypad Mode. (line 6) * calc-kill: Killing From Stack. (line 6) * calc-kill-region: Killing From Stack. (line 6) * calc-kron: Vector and Matrix Arithmetic. (line 67) * calc-last-args: Undo. (line 31) * calc-latex-language: TeX and LaTeX Language Modes. (line 6) * calc-lcm: Combinatorial Functions. (line 16) * calc-leading-zeros: Radix Modes. (line 23) * calc-left-justify: Justification. (line 6) * calc-left-label: Labels. (line 6) * calc-less-equal: Logical Operations. (line 51) * calc-less-recursion-depth: Recursion Depth. (line 6) * calc-less-than: Logical Operations. (line 51) * calc-let: Let Command. (line 6) * calc-line-breaking: Normal Language Modes. (line 16) * calc-line-numbering: Stack Basics. (line 24) * calc-ln: Logarithmic Functions. (line 6) * calc-lnp1: Logarithmic Functions. (line 41) * calc-load-everything: Autoloading Problems. (line 12) * calc-log: Logarithmic Functions. (line 22) * calc-log10: Logarithmic Functions. (line 16) * calc-logical-and: Logical Operations. (line 75) * calc-logical-if: Logical Operations. (line 90) * calc-logical-not: Logical Operations. (line 86) * calc-logical-or: Logical Operations. (line 81) * calc-lshift-arith: Binary Functions. (line 97) * calc-lshift-binary: Binary Functions. (line 78) * calc-ltpt: Probability Distribution Functions. (line 57) * calc-mant-part: Basic Arithmetic. (line 210) * calc-map: Mapping. (line 6) * calc-map-equation: Algebraic Manipulation. (line 73) * calc-maple-language: Maple Language Mode. (line 6) * calc-mask-vector: Manipulating Vectors. (line 107) * calc-match: Matching Commands. (line 6) * calc-mathematica-language: Mathematica Language Mode. (line 6) * calc-matrix-brackets: Vector and Matrix Formats. (line 28) * calc-matrix-center-justify: Vector and Matrix Formats. (line 12) * calc-matrix-left-justify: Vector and Matrix Formats. (line 12) * calc-matrix-mode: Matrix Mode. (line 11) * calc-matrix-right-justify: Vector and Matrix Formats. (line 12) * calc-max: Basic Arithmetic. (line 204) * calc-maxima-language: Maxima Language Mode. (line 6) * calc-mcol: Extracting Elements. (line 44) * calc-mdet: Vector and Matrix Arithmetic. (line 53) * calc-min: Basic Arithmetic. (line 204) * calc-minus: Basic Arithmetic. (line 65) * calc-mlud: Vector and Matrix Arithmetic. (line 56) * calc-mod: Basic Arithmetic. (line 146) * calc-mode: Basic Commands. (line 6) * calc-mode-record-mode: General Mode Commands. (line 18) * calc-moebius: Combinatorial Functions. (line 122) * calc-more-recursion-depth: Recursion Depth. (line 6) * calc-mrow: Extracting Elements. (line 6) * calc-mtrace: Vector and Matrix Arithmetic. (line 63) * calc-new-month: Date Functions. (line 51) * calc-new-week: Date Functions. (line 68) * calc-new-year: Date Functions. (line 59) * calc-next-prime: Combinatorial Functions. (line 103) * calc-no-simplify-mode: Simplification Modes. (line 21) * calc-normal-language: Normal Language Modes. (line 6) * calc-normal-notation: Float Formats. (line 12) * calc-normalize-rat: Polynomials. (line 112) * calc-not: Binary Functions. (line 75) * calc-not-equal-to: Logical Operations. (line 46) * calc-now: Date Functions. (line 6) * calc-num-integral: Numerical Integration. (line 6) * calc-num-prefix: Prefix Arguments. (line 39) * calc-num-simplify-mode: Simplification Modes. (line 26) * calc-or: Binary Functions. (line 63) * calc-other-window: Basic Commands. (line 61) * calc-outer-product: Generalized Products. (line 6) * calc-over: Stack Manipulation. (line 16) * calc-over-notation: Fraction Formats. (line 6) * calc-pack <1>: Packing and Unpacking. (line 11) * calc-pack: Complex Number Functions. (line 33) * calc-pack-bits: Set Operations. (line 111) * calc-pascal-language: C FORTRAN Pascal. (line 30) * calc-percent: Percentages. (line 6) * calc-percent-change: Percentages. (line 44) * calc-perm: Combinatorial Functions. (line 49) * calc-permanent-units: User-Defined Units. (line 63) * calc-permanent-variable: Operations on Variables. (line 70) * calc-pi: Scientific Functions. (line 12) * calc-plus: Basic Arithmetic. (line 6) * calc-point-char: Float Formats. (line 50) * calc-polar: Conversions. (line 73) * calc-polar-mode: Polar Mode. (line 12) * calc-poly-div: Polynomials. (line 119) * calc-poly-div-rem: Polynomials. (line 139) * calc-poly-gcd: Polynomials. (line 145) * calc-poly-interp: Interpolation. (line 6) * calc-poly-rem: Polynomials. (line 133) * calc-poly-roots: Multiple Solutions. (line 63) * calc-pop: Stack Manipulation. (line 23) * calc-pop-above: Stack Manipulation. (line 33) * calc-power: Basic Arithmetic. (line 128) * calc-precision: Precision. (line 6) * calc-prepend-to-register: Saving Into Registers. (line 6) * calc-prev-prime: Combinatorial Functions. (line 115) * calc-prime-factors: Combinatorial Functions. (line 93) * calc-prime-test: Combinatorial Functions. (line 71) * calc-product: Summations. (line 116) * calc-quick-units: User-Defined Units. (line 9) * calc-quit: Basic Commands. (line 77) * calc-radians-mode: Angular Modes. (line 20) * calc-radix: Radix Modes. (line 19) * calc-random: Random Numbers. (line 6) * calc-random-again: Random Numbers. (line 63) * calc-re: Complex Number Functions. (line 24) * calc-realign: Stack Basics. (line 30) * calc-recall: Recalling Variables. (line 6) * calc-redo: Undo. (line 23) * calc-reduce: Reducing. (line 6) * calc-refresh: Basic Commands. (line 88) * calc-refresh-top: Display Modes. (line 19) * calc-remove-duplicates: Set Operations. (line 34) * calc-remove-equal: Logical Operations. (line 65) * calc-remove-units: Basic Operations on Units. (line 131) * calc-reset: Basic Commands. (line 105) * calc-reverse-vector: Manipulating Vectors. (line 101) * calc-rewrite: Rewrite Rules. (line 6) * calc-rewrite-selection: Selections with Rewrite Rules. (line 12) * calc-right-justify: Justification. (line 6) * calc-right-label: Labels. (line 16) * calc-rnorm: Vector and Matrix Arithmetic. (line 25) * calc-roll-down: Stack Manipulation. (line 39) * calc-roll-up: Stack Manipulation. (line 49) * calc-rotate-binary: Binary Functions. (line 111) * calc-round: Integer Truncation. (line 23) * calc-rrandom: Random Numbers. (line 60) * calc-rshift-arith: Binary Functions. (line 102) * calc-rshift-binary: Binary Functions. (line 93) * calc-save-modes: General Mode Commands. (line 6) * calc-scale-float: Basic Arithmetic. (line 221) * calc-sci-notation: Float Formats. (line 28) * calc-scroll-down: Basic Commands. (line 101) * calc-scroll-left: Basic Commands. (line 95) * calc-scroll-right: Basic Commands. (line 95) * calc-scroll-up: Basic Commands. (line 101) * calc-sec: Trigonometric and Hyperbolic Functions. (line 65) * calc-sech: Trigonometric and Hyperbolic Functions. (line 65) * calc-sel-add-both-sides: Rearranging with Selections. (line 161) * calc-sel-commute: Rearranging with Selections. (line 74) * calc-sel-distribute: Rearranging with Selections. (line 41) * calc-sel-div-both-sides: Rearranging with Selections. (line 116) * calc-sel-evaluate: Rearranging with Selections. (line 173) * calc-sel-expand-formula: Rearranging with Selections. (line 189) * calc-sel-invert: Rearranging with Selections. (line 98) * calc-sel-isolate: Rearranging with Selections. (line 109) * calc-sel-jump-equals: Rearranging with Selections. (line 103) * calc-sel-merge: Rearranging with Selections. (line 68) * calc-sel-mult-both-sides: Rearranging with Selections. (line 116) * calc-sel-negate: Rearranging with Selections. (line 90) * calc-sel-sub-both-sides: Rearranging with Selections. (line 161) * calc-sel-unpack: Rearranging with Selections. (line 167) * calc-select-additional: Making Selections. (line 66) * calc-select-here: Making Selections. (line 6) * calc-select-here-maybe: Making Selections. (line 83) * calc-select-less: Changing Selections. (line 29) * calc-select-more: Changing Selections. (line 6) * calc-select-next: Changing Selections. (line 49) * calc-select-once: Making Selections. (line 73) * calc-select-once-maybe: Making Selections. (line 83) * calc-select-part: Changing Selections. (line 35) * calc-select-previous: Changing Selections. (line 49) * calc-set-cardinality: Set Operations. (line 95) * calc-set-complement: Set Operations. (line 70) * calc-set-difference: Set Operations. (line 55) * calc-set-enumerate: Set Operations. (line 84) * calc-set-floor: Set Operations. (line 75) * calc-set-intersect: Set Operations. (line 47) * calc-set-span: Set Operations. (line 89) * calc-set-union: Set Operations. (line 42) * calc-set-xor: Set Operations. (line 65) * calc-settings-file-name: General Mode Commands. (line 27) * calc-shift-prefix: General Mode Commands. (line 57) * calc-show-plain: More About Embedded Mode. (line 19) * calc-show-selections: Displaying Selections. (line 6) * calc-shuffle: Random Numbers. (line 67) * calc-sign: Basic Arithmetic. (line 178) * calc-simplify: Simplifying Formulas. (line 6) * calc-simplify-extended: Unsafe Simplifications. (line 6) * calc-simplify-units: Basic Operations on Units. (line 31) * calc-sin: Trigonometric and Hyperbolic Functions. (line 6) * calc-sincos: Trigonometric and Hyperbolic Functions. (line 59) * calc-sinh: Trigonometric and Hyperbolic Functions. (line 39) * calc-solve-for: Solving Equations. (line 6) * calc-sort: Manipulating Vectors. (line 39) * calc-sqrt: Basic Arithmetic. (line 188) * calc-stirling-number: Combinatorial Functions. (line 64) * calc-store: Storing Variables. (line 6) * calc-store-AlgSimpRules: Operations on Variables. (line 25) * calc-store-concat: Storing Variables. (line 41) * calc-store-Decls: Operations on Variables. (line 25) * calc-store-decr: Storing Variables. (line 41) * calc-store-div: Storing Variables. (line 41) * calc-store-EvalRules: Operations on Variables. (line 25) * calc-store-exchange: Storing Variables. (line 102) * calc-store-ExtSimpRules: Operations on Variables. (line 25) * calc-store-FitRules: Operations on Variables. (line 25) * calc-store-GenCount: Operations on Variables. (line 25) * calc-store-Holidays: Operations on Variables. (line 25) * calc-store-incr: Storing Variables. (line 41) * calc-store-IntegLimit: Operations on Variables. (line 25) * calc-store-into: Storing Variables. (line 12) * calc-store-inv: Storing Variables. (line 41) * calc-store-LineStyles: Operations on Variables. (line 25) * calc-store-map: Storing Variables. (line 84) * calc-store-minus: Storing Variables. (line 41) * calc-store-neg: Storing Variables. (line 41) * calc-store-PlotRejects: Operations on Variables. (line 25) * calc-store-plus: Storing Variables. (line 41) * calc-store-PointStyles: Operations on Variables. (line 25) * calc-store-power: Storing Variables. (line 41) * calc-store-times: Storing Variables. (line 41) * calc-store-TimeZone: Operations on Variables. (line 25) * calc-store-Units: Operations on Variables. (line 25) * calc-subscript: Extracting Elements. (line 24) * calc-substitute: Algebraic Manipulation. (line 109) * calc-subvector: Extracting Elements. (line 57) * calc-summation: Summations. (line 6) * calc-symbolic-mode: Symbolic Mode. (line 12) * calc-tabulate: Summations. (line 122) * calc-tail: Building Vectors. (line 87) * calc-tan: Trigonometric and Hyperbolic Functions. (line 44) * calc-tanh: Trigonometric and Hyperbolic Functions. (line 44) * calc-taylor: Taylor Series. (line 6) * calc-tex-language: TeX and LaTeX Language Modes. (line 6) * calc-time: HMS Forms. (line 29) * calc-time-zone: Time Zones. (line 30) * calc-times: Basic Arithmetic. (line 70) * calc-timing: Debugging Calc. (line 10) * calc-to-degrees: Conversions. (line 56) * calc-to-hms: Conversions. (line 64) * calc-to-radians: Conversions. (line 61) * calc-total-algebraic-mode: Algebraic Entry. (line 42) * calc-totient: Combinatorial Functions. (line 118) * calc-trail-backward: Trail Commands. (line 40) * calc-trail-display: Trail Commands. (line 9) * calc-trail-first: Trail Commands. (line 47) * calc-trail-forward: Trail Commands. (line 40) * calc-trail-here: Trail Commands. (line 47) * calc-trail-in: Trail Commands. (line 19) * calc-trail-isearch-backward: Trail Commands. (line 53) * calc-trail-isearch-forward: Trail Commands. (line 53) * calc-trail-kill: Trail Commands. (line 66) * calc-trail-last: Trail Commands. (line 47) * calc-trail-marker: Trail Commands. (line 60) * calc-trail-next: Trail Commands. (line 40) * calc-trail-out: Trail Commands. (line 19) * calc-trail-previous: Trail Commands. (line 40) * calc-trail-scroll-left: Trail Commands. (line 36) * calc-trail-scroll-right: Trail Commands. (line 36) * calc-trail-yank: Trail Commands. (line 30) * calc-transpose: Manipulating Vectors. (line 96) * calc-transpose-lines: Stack Manipulation. (line 72) * calc-trunc: Integer Truncation. (line 29) * calc-truncate-down: Truncating the Stack. (line 25) * calc-truncate-stack: Truncating the Stack. (line 6) * calc-truncate-up: Truncating the Stack. (line 25) * calc-tutorial: Help Commands. (line 29) * calc-undefine-unit: User-Defined Units. (line 40) * calc-undo: Undo. (line 6) * calc-unformatted-language: Normal Language Modes. (line 67) * calc-units-simplify-mode: Simplification Modes. (line 57) * calc-unix-time: Date Conversions. (line 50) * calc-unpack <1>: Packing and Unpacking. (line 124) * calc-unpack: Complex Number Functions. (line 39) * calc-unpack-bits: Set Operations. (line 111) * calc-unselect: Making Selections. (line 113) * calc-unstore: Storing Variables. (line 110) * calc-user-define: Creating User Keys. (line 6) * calc-user-define-composition: User-Defined Compositions. (line 6) * calc-user-define-edit: Creating User Keys. (line 60) * calc-user-define-formula: Algebraic Definitions. (line 6) * calc-user-define-invocation: Invocation Macros. (line 6) * calc-user-define-kbd-macro: Naming Keyboard Macros. (line 6) * calc-user-define-permanent: Creating User Keys. (line 36) * calc-user-invocation: Invocation Macros. (line 6) * calc-user-undefine: Creating User Keys. (line 32) * calc-utpb: Probability Distribution Functions. (line 22) * calc-utpc: Probability Distribution Functions. (line 40) * calc-utpf: Probability Distribution Functions. (line 44) * calc-utpn: Probability Distribution Functions. (line 49) * calc-utpp: Probability Distribution Functions. (line 53) * calc-vector-braces: Vector and Matrix Formats. (line 17) * calc-vector-brackets: Vector and Matrix Formats. (line 17) * calc-vector-commas: Vector and Matrix Formats. (line 59) * calc-vector-correlation: Paired-Sample Statistics. (line 28) * calc-vector-count: Single-Variable Statistics. (line 36) * calc-vector-covariance: Paired-Sample Statistics. (line 13) * calc-vector-find: Manipulating Vectors. (line 16) * calc-vector-geometric-mean: Single-Variable Statistics. (line 103) * calc-vector-harmonic-mean: Single-Variable Statistics. (line 99) * calc-vector-max: Single-Variable Statistics. (line 48) * calc-vector-mean: Single-Variable Statistics. (line 55) * calc-vector-mean-error: Single-Variable Statistics. (line 73) * calc-vector-median: Single-Variable Statistics. (line 85) * calc-vector-min: Single-Variable Statistics. (line 48) * calc-vector-parens: Vector and Matrix Formats. (line 17) * calc-vector-pop-covariance: Paired-Sample Statistics. (line 24) * calc-vector-pop-sdev: Single-Variable Statistics. (line 130) * calc-vector-pop-variance: Single-Variable Statistics. (line 143) * calc-vector-prod: Single-Variable Statistics. (line 42) * calc-vector-sdev: Single-Variable Statistics. (line 116) * calc-vector-sum: Single-Variable Statistics. (line 42) * calc-vector-variance: Single-Variable Statistics. (line 143) * calc-view-units-table: The Units Table. (line 27) * calc-vlength: Manipulating Vectors. (line 6) * calc-why: Error Messages. (line 6) * calc-word-size: Binary Functions. (line 35) * calc-working: Working Message. (line 14) * calc-xor: Binary Functions. (line 67) * calc-xpon-part: Basic Arithmetic. (line 210) * calc-yacas-language: Yacas Language Mode. (line 6) * calc-yank: Yanking Into Stack. (line 6) * describe-bindings: Help Commands. (line 77) * full-calc: Basic Commands. (line 53) * full-calc-keypad: Keypad Mode. (line 13) * quick-calc: Quick Calculator. (line 6) * read-kbd-macro: Naming Keyboard Macros. (line 39)  File: calc, Node: Function Index, Next: Concept Index, Prev: Command Index, Up: Top Index of Algebraic Functions **************************** This is a list of built-in functions and operators usable in algebraic expressions. Their full Lisp names are derived by adding the prefix `calcFunc-', as in `calcFunc-sqrt'. [index] * Menu: * ! <1>: Logical Operations. (line 86) * !: Combinatorial Functions. (line 24) * !!: Combinatorial Functions. (line 34) * !!!: Other Features of Rewrite Rules. (line 80) * !=: Logical Operations. (line 46) * % <1>: Percentages. (line 6) * %: Basic Arithmetic. (line 146) * &&: Logical Operations. (line 75) * &&&: Other Features of Rewrite Rules. (line 71) * *: Basic Arithmetic. (line 70) * +: Basic Arithmetic. (line 6) * +/-: Error Forms. (line 47) * -: Basic Arithmetic. (line 65) * /: Basic Arithmetic. (line 89) * :: Logical Operations. (line 90) * ::: Other Features of Rewrite Rules. (line 67) * :=: Evaluates-To Operator. (line 90) * <: Logical Operations. (line 51) * <=: Logical Operations. (line 51) * =: Logical Operations. (line 20) * ==: Logical Operations. (line 20) * =>: Evaluates-To Operator. (line 6) * >: Logical Operations. (line 51) * >=: Logical Operations. (line 51) * ?: Logical Operations. (line 90) * \: Basic Arithmetic. (line 139) * ^: Basic Arithmetic. (line 128) * _: Extracting Elements. (line 24) * abs: Basic Arithmetic. (line 165) * abs (vectors): Vector and Matrix Arithmetic. (line 19) * abssqr: Basic Arithmetic. (line 175) * accum: Reducing. (line 21) * Acute: TeX and LaTeX Language Modes. (line 91) * acute: TeX and LaTeX Language Modes. (line 91) * add: Specifying Operators. (line 92) * afixp: Nesting and Fixed Points. (line 22) * agmean: Single-Variable Statistics. (line 108) * alog: Logarithmic Functions. (line 22) * an: Multiple Solutions. (line 35) * and: Binary Functions. (line 57) * anest: Nesting and Fixed Points. (line 13) * apart: Polynomials. (line 105) * append: Building Vectors. (line 22) * apply: Reducing and Mapping. (line 9) * apply (rewrites): Other Features of Rewrite Rules. (line 95) * arccos: Trigonometric and Hyperbolic Functions. (line 44) * arccosh: Trigonometric and Hyperbolic Functions. (line 44) * arcsin: Trigonometric and Hyperbolic Functions. (line 34) * arcsincos: Trigonometric and Hyperbolic Functions. (line 59) * arcsinh: Trigonometric and Hyperbolic Functions. (line 39) * arctan: Trigonometric and Hyperbolic Functions. (line 44) * arctan2: Trigonometric and Hyperbolic Functions. (line 49) * arctanh: Trigonometric and Hyperbolic Functions. (line 44) * arg: Complex Number Functions. (line 12) * arrange: Manipulating Vectors. (line 23) * as: Multiple Solutions. (line 35) * ash: Binary Functions. (line 97) * assign: Evaluates-To Operator. (line 90) * asum: Summations. (line 104) * badd: Business Days. (line 13) * Bar: TeX and LaTeX Language Modes. (line 91) * bar: TeX and LaTeX Language Modes. (line 91) * bcount: Bit Counting Example. (line 6) * bern: Combinatorial Functions. (line 52) * besJ: Advanced Math Functions. (line 58) * besY: Advanced Math Functions. (line 58) * beta: Advanced Math Functions. (line 42) * betaB: Advanced Math Functions. (line 47) * betaI: Advanced Math Functions. (line 47) * Breve: TeX and LaTeX Language Modes. (line 91) * breve: TeX and LaTeX Language Modes. (line 91) * bstring: Strings. (line 54) * bsub: Business Days. (line 13) * call: Specifying Operators. (line 100) * cascent: Information about Compositions. (line 19) * cbase: Vertical Compositions. (line 16) * cbbase: Vertical Compositions. (line 29) * cbspace: Other Compositions. (line 41) * cdescent: Information about Compositions. (line 19) * ceil: Integer Truncation. (line 19) * cflat: Other Compositions. (line 16) * Check: TeX and LaTeX Language Modes. (line 91) * check: TeX and LaTeX Language Modes. (line 91) * cheight: Information about Compositions. (line 16) * choose: Combinatorial Functions. (line 42) * choriz: Horizontal Compositions. (line 6) * clean: Conversions. (line 126) * clip: Binary Functions. (line 26) * clvert: Vertical Compositions. (line 59) * cnorm: Vector and Matrix Arithmetic. (line 31) * collect: Polynomials. (line 68) * condition: Other Features of Rewrite Rules. (line 67) * conj: Complex Number Functions. (line 6) * cons: Building Vectors. (line 92) * cons (rewrites): Other Features of Rewrite Rules. (line 84) * constant: Logical Operations. (line 141) * cos: Trigonometric and Hyperbolic Functions. (line 44) * cosh: Trigonometric and Hyperbolic Functions. (line 44) * cot: Trigonometric and Hyperbolic Functions. (line 65) * coth: Trigonometric and Hyperbolic Functions. (line 65) * cprec: Composition Basics. (line 70) * cross: Vector and Matrix Arithmetic. (line 38) * crule: Vertical Compositions. (line 46) * crvert: Vertical Compositions. (line 59) * csc: Trigonometric and Hyperbolic Functions. (line 65) * csch: Trigonometric and Hyperbolic Functions. (line 65) * cspace: Other Compositions. (line 22) * csub: Other Compositions. (line 11) * csup: Other Compositions. (line 6) * ctbase: Vertical Compositions. (line 29) * ctrn: Vector and Matrix Arithmetic. (line 16) * ctspace: Other Compositions. (line 41) * curve: Composing Patterns in Rewrite Rules. (line 44) * cvec: Building Vectors. (line 80) * cvert: Vertical Compositions. (line 6) * cvspace: Other Compositions. (line 35) * cwidth: Information about Compositions. (line 10) * date: Date Conversions. (line 6) * day: Date Functions. (line 25) * ddb: Depreciation Functions. (line 29) * ddddot: TeX and LaTeX Language Modes. (line 91) * dddot: TeX and LaTeX Language Modes. (line 91) * decr: Basic Arithmetic. (line 227) * deg: Conversions. (line 56) * deriv: Differentiation. (line 6) * det: Vector and Matrix Arithmetic. (line 53) * deven: Functions for Declarations. (line 57) * dfact: Combinatorial Functions. (line 34) * diag: Building Vectors. (line 32) * diff: Binary Functions. (line 71) * dimag: Functions for Declarations. (line 38) * dint: Functions for Declarations. (line 22) * div: Specifying Operators. (line 92) * dnatnum: Functions for Declarations. (line 22) * dneg: Functions for Declarations. (line 41) * dnonneg: Functions for Declarations. (line 41) * dnonzero: Functions for Declarations. (line 49) * dnumint: Functions for Declarations. (line 22) * dodd: Functions for Declarations. (line 57) * Dot: TeX and LaTeX Language Modes. (line 91) * dot: TeX and LaTeX Language Modes. (line 91) * DotDot: TeX and LaTeX Language Modes. (line 91) * dotdot: TeX and LaTeX Language Modes. (line 91) * dpos: Functions for Declarations. (line 41) * drange: Functions for Declarations. (line 63) * drat: Functions for Declarations. (line 31) * dreal: Functions for Declarations. (line 35) * dsadj: Time Zones. (line 178) * dscalar: Functions for Declarations. (line 72) * dyad: TeX and LaTeX Language Modes. (line 91) * efit: Error Estimates for Fits. (line 6) * egcd: Combinatorial Functions. (line 20) * Ei: Customizing the Integrator. (line 22) * elim: Solving Systems of Equations. (line 30) * ends: Composing Patterns in Rewrite Rules. (line 27) * eq: Logical Operations. (line 20) * erf: Advanced Math Functions. (line 53) * erfc: Advanced Math Functions. (line 53) * esimplify: Unsafe Simplifications. (line 6) * euler: Combinatorial Functions. (line 60) * eval: Other Features of Rewrite Rules. (line 178) * evalextsimp: Other Features of Rewrite Rules. (line 191) * evalsimp: Other Features of Rewrite Rules. (line 187) * evalto: Evaluates-To Operator. (line 6) * evalv: Algebraic Manipulation. (line 40) * evalvn: Algebraic Manipulation. (line 40) * exp: Logarithmic Functions. (line 11) * exp10: Logarithmic Functions. (line 16) * expand: Polynomials. (line 83) * expm1: Logarithmic Functions. (line 37) * fact: Combinatorial Functions. (line 24) * factor: Polynomials. (line 13) * factors: Polynomials. (line 56) * fceil: Integer Truncation. (line 19) * fdiv: Basic Arithmetic. (line 153) * ffinv: Multiple Solutions. (line 56) * ffloor: Integer Truncation. (line 15) * fib: Rewrites Tutorial. (line 183) * find: Manipulating Vectors. (line 16) * finv: Multiple Solutions. (line 56) * fit: Linear Fits. (line 6) * fitdummy: Curve Fitting Details. (line 158) * fitmodel: Curve Fitting Details. (line 158) * fitparam: Curve Fitting Details. (line 158) * fitsystem: Curve Fitting Details. (line 158) * fitvar: Curve Fitting Details. (line 158) * fixp: Nesting and Fixed Points. (line 18) * float: Conversions. (line 30) * floor: Integer Truncation. (line 15) * frac: Conversions. (line 52) * fround: Integer Truncation. (line 23) * frounde: Integer Truncation. (line 40) * froundu: Integer Truncation. (line 40) * fsolve: Multiple Solutions. (line 6) * ftrunc: Integer Truncation. (line 29) * fv: Future Value. (line 6) * fvb: Future Value. (line 15) * fvl: Future Value. (line 24) * gamma: Advanced Math Functions. (line 18) * gammaG: Advanced Math Functions. (line 25) * gammag: Advanced Math Functions. (line 25) * gammaP: Advanced Math Functions. (line 25) * gammaQ: Advanced Math Functions. (line 25) * gcd: Combinatorial Functions. (line 9) * geq: Logical Operations. (line 51) * getdiag: Extracting Elements. (line 40) * gpoly: Decomposing Polynomials. (line 24) * grade: Manipulating Vectors. (line 53) * Grave: TeX and LaTeX Language Modes. (line 91) * grave: TeX and LaTeX Language Modes. (line 91) * gt: Logical Operations. (line 51) * hasfitparams: Curve Fitting Details. (line 234) * hasfitvars: Curve Fitting Details. (line 234) * Hat: TeX and LaTeX Language Modes. (line 91) * hat: TeX and LaTeX Language Modes. (line 91) * head: Building Vectors. (line 87) * histogram: Manipulating Vectors. (line 79) * hms: Conversions. (line 64) * holiday: Business Days. (line 115) * hour: Date Functions. (line 28) * hypot: Basic Arithmetic. (line 192) * idiv: Basic Arithmetic. (line 139) * idn: Building Vectors. (line 45) * ierf: Other Features of Rewrite Rules. (line 243) * if: Logical Operations. (line 90) * ilog: Logarithmic Functions. (line 29) * im: Complex Number Functions. (line 29) * import: Other Features of Rewrite Rules. (line 11) * in: Logical Operations. (line 109) * incmonth: Date Functions. (line 98) * incr: Basic Arithmetic. (line 227) * incyear: Date Functions. (line 108) * index: Building Vectors. (line 61) * inner: Generalized Products. (line 14) * integ: Integration. (line 6) * integer: Logical Operations. (line 141) * intv: Interval Forms. (line 68) * inv: Basic Arithmetic. (line 184) * inv (matrices): Vector and Matrix Arithmetic. (line 42) * irr: Related Financial Functions. (line 50) * irrb: Related Financial Functions. (line 55) * islin: Logical Operations. (line 182) * islinnt: Logical Operations. (line 182) * isqrt: Basic Arithmetic. (line 197) * istrue: Logical Operations. (line 213) * iterations: Nested Formulas with Rewrite Rules. (line 44) * julian: Date Conversions. (line 35) * kron: Vector and Matrix Arithmetic. (line 67) * lambda: Specifying Operators. (line 80) * land: Logical Operations. (line 75) * lcm: Combinatorial Functions. (line 16) * leq: Logical Operations. (line 51) * let: Other Features of Rewrite Rules. (line 200) * lin: Logical Operations. (line 182) * linnt: Logical Operations. (line 182) * ln: Logarithmic Functions. (line 6) * lnot: Logical Operations. (line 86) * lnp1: Logarithmic Functions. (line 41) * log: Logarithmic Functions. (line 22) * log10: Logarithmic Functions. (line 16) * lor: Logical Operations. (line 81) * lsh: Binary Functions. (line 78) * lt: Logical Operations. (line 51) * ltpb: Probability Distribution Functions. (line 22) * ltpc: Probability Distribution Functions. (line 40) * ltpf: Probability Distribution Functions. (line 44) * ltpn: Probability Distribution Functions. (line 49) * ltpp: Probability Distribution Functions. (line 53) * ltpt: Probability Distribution Functions. (line 57) * lud: Vector and Matrix Arithmetic. (line 56) * makemod: Modulo Forms. (line 60) * mant: Basic Arithmetic. (line 210) * map: Mapping. (line 6) * mapa: Mapping. (line 73) * mapc: Mapping. (line 39) * mapd: Mapping. (line 73) * mapeq: Algebraic Manipulation. (line 73) * mapeqp: Algebraic Manipulation. (line 98) * mapeqr: Algebraic Manipulation. (line 104) * mapr: Mapping. (line 24) * match: Matching Commands. (line 6) * matches: Matching Commands. (line 29) * matchnot: Matching Commands. (line 26) * max: Basic Arithmetic. (line 204) * maximize: Minimization. (line 6) * mcol: Extracting Elements. (line 44) * mdims: Manipulating Vectors. (line 11) * min: Basic Arithmetic. (line 204) * minimize: Minimization. (line 6) * minute: Date Functions. (line 33) * mod: Specifying Operators. (line 92) * mod (operator): Modulo Forms. (line 12) * moebius: Combinatorial Functions. (line 122) * month: Date Functions. (line 22) * mrcol: Extracting Elements. (line 44) * mrow: Extracting Elements. (line 6) * mrrow: Extracting Elements. (line 34) * mul: Specifying Operators. (line 92) * mysin: Sine Example. (line 6) * neg: Specifying Operators. (line 92) * negative: Logical Operations. (line 163) * neq: Logical Operations. (line 46) * nest: Nesting and Fixed Points. (line 6) * newmonth: Date Functions. (line 51) * newweek: Date Functions. (line 68) * newyear: Date Functions. (line 59) * nextprime: Combinatorial Functions. (line 103) * ninteg: Numerical Integration. (line 6) * nonvar: Logical Operations. (line 177) * not: Binary Functions. (line 75) * now: Date Functions. (line 6) * nper: Related Financial Functions. (line 21) * nperb: Related Financial Functions. (line 27) * nperl: Related Financial Functions. (line 32) * npv: Present Value. (line 46) * npvb: Present Value. (line 65) * nrat: Polynomials. (line 112) * nroot: Basic Arithmetic. (line 135) * nterms: Rewrites Answer 5. (line 6) * opt: Other Features of Rewrite Rules. (line 47) * or: Binary Functions. (line 63) * outer: Generalized Products. (line 6) * pack: Packing and Unpacking. (line 116) * pand: Other Features of Rewrite Rules. (line 71) * pclean: Conversions. (line 81) * pcont: Decomposing Polynomials. (line 83) * pdeg: Decomposing Polynomials. (line 66) * pdiv: Polynomials. (line 119) * pdivide: Polynomials. (line 139) * pdivrem: Polynomials. (line 139) * percent: Percentages. (line 6) * perm: Combinatorial Functions. (line 49) * pfloat: Conversions. (line 9) * pfrac: Conversions. (line 40) * pgcd: Polynomials. (line 145) * phase: Multi-Phase Rewrite Rules. (line 11) * plain: Other Features of Rewrite Rules. (line 38) * plead: Decomposing Polynomials. (line 77) * pmt: Related Financial Functions. (line 9) * pmtb: Related Financial Functions. (line 14) * pnot: Other Features of Rewrite Rules. (line 80) * polar: Conversions. (line 73) * polint: Interpolation. (line 6) * poly: Decomposing Polynomials. (line 6) * por: Other Features of Rewrite Rules. (line 76) * pow: Specifying Operators. (line 92) * pprim: Decomposing Polynomials. (line 102) * prem: Polynomials. (line 133) * prevprime: Combinatorial Functions. (line 115) * prfac: Combinatorial Functions. (line 93) * prime: Combinatorial Functions. (line 86) * Prime: TeX and LaTeX Language Modes. (line 91) * prod: Summations. (line 116) * pv: Present Value. (line 6) * pvb: Present Value. (line 28) * pvl: Present Value. (line 34) * pwday: Date Functions. (line 87) * quote: Other Features of Rewrite Rules. (line 29) * raccum: Reducing. (line 27) * rad: Conversions. (line 61) * random: Random Numbers. (line 6) * rash: Binary Functions. (line 102) * rate: Related Financial Functions. (line 38) * rateb: Related Financial Functions. (line 43) * ratel: Related Financial Functions. (line 43) * ratint: Interpolation. (line 35) * rcons: Building Vectors. (line 98) * rcons (rewrites): Other Features of Rewrite Rules. (line 91) * rdup: Set Operations. (line 34) * re: Complex Number Functions. (line 24) * real: Logical Operations. (line 141) * rect: Conversions. (line 73) * reduce: Reducing. (line 6) * reducea: Reducing. (line 31) * reducec: Reducing. (line 51) * reduced: Reducing. (line 31) * reducer: Reducing. (line 40) * refers: Logical Operations. (line 156) * relch: Percentages. (line 44) * remember: Other Features of Rewrite Rules. (line 290) * rev: Manipulating Vectors. (line 101) * rewrite: Rewrite Rules. (line 6) * rgrade: Manipulating Vectors. (line 53) * rhead: Building Vectors. (line 98) * rmeq: Logical Operations. (line 65) * rnorm: Vector and Matrix Arithmetic. (line 25) * root: Root Finding. (line 6) * roots: Multiple Solutions. (line 63) * rot: Binary Functions. (line 111) * round: Integer Truncation. (line 23) * rounde: Integer Truncation. (line 40) * roundu: Integer Truncation. (line 40) * rreduce: Reducing. (line 15) * rreducea: Reducing. (line 31) * rreducec: Reducing. (line 51) * rreduced: Reducing. (line 31) * rreducer: Reducing. (line 40) * rsh: Binary Functions. (line 93) * rsort: Manipulating Vectors. (line 39) * rsubvec: Extracting Elements. (line 73) * rtail: Building Vectors. (line 98) * scf: Basic Arithmetic. (line 221) * schedule: Multi-Phase Rewrite Rules. (line 53) * sdev: Error Forms. (line 65) * sec: Trigonometric and Hyperbolic Functions. (line 65) * sech: Trigonometric and Hyperbolic Functions. (line 65) * second: Date Functions. (line 36) * select: Other Features of Rewrite Rules. (line 135) * seq: Rewrites Answer 4. (line 6) * shuffle: Random Numbers. (line 67) * Si: Programming Tutorial. (line 46) * sign: Basic Arithmetic. (line 178) * simplify: Simplifying Formulas. (line 6) * sin: Trigonometric and Hyperbolic Functions. (line 6) * sincos: Trigonometric and Hyperbolic Functions. (line 59) * sinh: Trigonometric and Hyperbolic Functions. (line 39) * sln: Depreciation Functions. (line 16) * solve: Solving Equations. (line 6) * sort: Manipulating Vectors. (line 39) * sqr: Scientific Functions. (line 23) * sqrt: Basic Arithmetic. (line 188) * stir1: Combinatorial Functions. (line 64) * stir2: Combinatorial Functions. (line 64) * string: Strings. (line 40) * sub: Specifying Operators. (line 92) * subscr: Extracting Elements. (line 24) * subst: Algebraic Manipulation. (line 109) * subvec: Extracting Elements. (line 57) * sum: Summations. (line 6) * syd: Depreciation Functions. (line 22) * table: Summations. (line 122) * tail: Building Vectors. (line 87) * tan: Trigonometric and Hyperbolic Functions. (line 44) * tanh: Trigonometric and Hyperbolic Functions. (line 44) * taylor: Taylor Series. (line 6) * tderiv: Differentiation. (line 6) * thecoefs: Polynomials. (line 38) * thefactors: Polynomials. (line 38) * Tilde: TeX and LaTeX Language Modes. (line 91) * tilde: TeX and LaTeX Language Modes. (line 91) * time: Date Functions. (line 48) * totient: Combinatorial Functions. (line 118) * tr: Vector and Matrix Arithmetic. (line 63) * trn: Manipulating Vectors. (line 96) * trunc: Integer Truncation. (line 29) * typeof: Logical Operations. (line 118) * tzconv: Date Conversions. (line 60) * tzone: Time Zones. (line 30) * under: TeX and LaTeX Language Modes. (line 91) * unixtime: Date Conversions. (line 50) * unpack: Packing and Unpacking. (line 166) * unpackt: Packing and Unpacking. (line 172) * usimplify: Basic Operations on Units. (line 31) * utpb: Probability Distribution Functions. (line 22) * utpc: Probability Distribution Functions. (line 40) * utpf: Probability Distribution Functions. (line 44) * utpn: Probability Distribution Functions. (line 49) * utpp: Probability Distribution Functions. (line 53) * utpt: Probability Distribution Functions. (line 57) * variable: Logical Operations. (line 172) * vcard: Set Operations. (line 95) * vcompl: Set Operations. (line 70) * vconcat: Specifying Operators. (line 92) * vcorr: Paired-Sample Statistics. (line 28) * vcount: Single-Variable Statistics. (line 36) * vcov: Paired-Sample Statistics. (line 13) * vdiff: Set Operations. (line 55) * VEC: TeX and LaTeX Language Modes. (line 91) * Vec: TeX and LaTeX Language Modes. (line 91) * vec: Vectors and Matrices. (line 30) * venum: Set Operations. (line 84) * vexp: Manipulating Vectors. (line 115) * vflat: Single-Variable Statistics. (line 150) * vfloor: Set Operations. (line 75) * vgmean: Single-Variable Statistics. (line 103) * vhmean: Single-Variable Statistics. (line 99) * vint: Set Operations. (line 47) * vlen: Manipulating Vectors. (line 6) * vmask: Manipulating Vectors. (line 107) * vmatches: Matching Commands. (line 34) * vmax: Single-Variable Statistics. (line 48) * vmean: Single-Variable Statistics. (line 55) * vmeane: Single-Variable Statistics. (line 73) * vmedian: Single-Variable Statistics. (line 85) * vmin: Single-Variable Statistics. (line 48) * vpack: Set Operations. (line 111) * vpcov: Paired-Sample Statistics. (line 24) * vprod: Single-Variable Statistics. (line 42) * vpsdev: Single-Variable Statistics. (line 130) * vpvar: Single-Variable Statistics. (line 143) * vsdev: Single-Variable Statistics. (line 116) * vspan: Set Operations. (line 89) * vsum: Single-Variable Statistics. (line 42) * vunion: Set Operations. (line 42) * vunpack: Set Operations. (line 111) * vvar: Single-Variable Statistics. (line 143) * vxor: Set Operations. (line 65) * weekday: Date Functions. (line 41) * wmaximize: Minimization. (line 39) * wminimize: Minimization. (line 39) * wroot: Root Finding. (line 52) * xfit: Error Estimates for Fits. (line 50) * xor: Binary Functions. (line 67) * xpon: Basic Arithmetic. (line 210) * xy: Basic Graphics. (line 33) * xyz: Three Dimensional Graphics. (line 38) * year: Date Functions. (line 16) * yearday: Date Functions. (line 44) * |: Building Vectors. (line 9) * ||: Logical Operations. (line 81) * |||: Other Features of Rewrite Rules. (line 76)  File: calc, Node: Concept Index, Next: Variable Index, Prev: Function Index, Up: Top Concept Index ************* [index] * Menu: * "Computation got stuck" message: Recursion Depth. (line 6) * => operator: Evaluates-To Operator. (line 6) * Accuracy of calculations <1>: Precision. (line 25) * Accuracy of calculations: Floats. (line 41) * Algebraic Mode: Algebraic Entry. (line 28) * Algebraic notation: Algebraic Entry. (line 6) * Algebraic simplifications: Algebraic Simplifications. (line 6) * AlgSimpRules variable: Automatic Rewrites. (line 136) * Alternating sums: Summations. (line 104) * Angle and slope of a line: Types Tutorial. (line 179) * Angular mode: Angular Modes. (line 6) * Area under a curve: Basic Algebra Tutorial. (line 227) * Arguments, not evaluated: Logical Operations. (line 90) * Arguments, restoring: Undo. (line 31) * Arranging a matrix: Manipulating Vectors. (line 23) * Beatles: Types Tutorial. (line 141) * Bernoulli numbers, approximate: Programming Tutorial. (line 237) * Bibliography: History and Acknowledgements. (line 77) * Binary numbers: Binary Functions. (line 9) * Binary operators: Arithmetic Tutorial. (line 19) * Branch cuts: Branch Cuts. (line 6) * Breaking up long lines: Normal Language Modes. (line 16) * C language: C FORTRAN Pascal. (line 6) * Caches: Caches. (line 6) * Calc init file, mode settings: General Mode Commands. (line 6) * Calc init file, user-defined commands: Creating User Keys. (line 36) * Calc init file, user-defined units: User-Defined Units. (line 63) * Calc init file, variables: Operations on Variables. (line 70) * calc-ext module: Basic Commands. (line 35) * Character strings: Strings. (line 6) * Clearing the stack: RPN Tutorial. (line 298) * Coefficients of polynomial: Decomposing Polynomials. (line 18) * Columns of data, extracting: List Tutorial. (line 112) * Common logarithm: Arithmetic Tutorial. (line 175) * Complex numbers: Complex Numbers. (line 6) * Composite units: Basic Operations on Units. (line 97) * Compositions: Compositions. (line 6) * Conditional structures: Conditionals in Macros. (line 6) * Continued fractions: Programming Tutorial. (line 162) * Continuous memory: General Mode Commands. (line 6) * Correlation coefficient: Paired-Sample Statistics. (line 28) * Covariance: Paired-Sample Statistics. (line 13) * Cross product: Vector Analysis Tutorial. (line 49) * Data, extracting from buffers: List Tutorial. (line 112) * Date arithmetic, additional functions: Date Arithmetic. (line 6) * Date forms: Date Forms. (line 6) * Daylight saving time: Time Zones. (line 6) * Decimal and non-decimal numbers: Radix Modes. (line 6) * Declaring scalar variables: Matrix Mode. (line 46) * Decls variable: Declaration Basics. (line 23) * Default simplifications: Default Simplifications. (line 6) * Degree of polynomial: Decomposing Polynomials. (line 18) * Degrees-minutes-seconds forms: HMS Forms. (line 6) * Deleting stack entries: Stack Manipulation. (line 23) * Demonstration of Calc: Demonstration of Calc. (line 6) * Digamma function: Programming Tutorial. (line 375) * Digit grouping: Grouping Digits. (line 6) * Digits, vectors of: List Tutorial. (line 430) * Division of integers: Fraction Mode. (line 6) * Divisor functions: List Tutorial. (line 385) * Dot product: Vector Analysis Tutorial. (line 30) * Duplicate values in a list: List Tutorial. (line 391) * Duplicating a stack entry: RPN Tutorial. (line 118) * Duplicating stack entries: Stack Manipulation. (line 6) * e variable <1>: Scientific Functions. (line 12) * e variable: Variables. (line 39) * Editing the stack with Emacs: Editing Stack Entries. (line 6) * Editing user definitions: Creating User Keys. (line 60) * Emptying the stack: RPN Tutorial. (line 298) * Engineering notation, display of: Float Formats. (line 34) * Entering numbers: Numeric Entry. (line 6) * Equations, solving: Solving Equations. (line 6) * Error forms: Error Forms. (line 6) * Errors, messages: Error Messages. (line 6) * Errors, undoing: Undo. (line 6) * Euler's gamma constant <1>: Scientific Functions. (line 12) * Euler's gamma constant: Programming Tutorial. (line 375) * EvalRules variable: Automatic Rewrites. (line 6) * Evaluates-to operator: Evaluates-To Operator. (line 6) * Evaluation of variables in a formula: Variables. (line 30) * Exchanging stack entries: RPN Tutorial. (line 134) * Exiting the Calculator: Basic Commands. (line 77) * Exponential integral Ei(x): Customizing the Integrator. (line 22) * Expressions: Formulas. (line 6) * Extended simplification: Unsafe Simplifications. (line 6) * Extensions module: Basic Commands. (line 35) * ExtSimpRules variable: Automatic Rewrites. (line 149) * Fermat, primality test of: Types Tutorial. (line 271) * Fibonacci numbers <1>: Programming Tutorial. (line 137) * Fibonacci numbers: Rewrites Tutorial. (line 183) * Fitting data to a line: List Tutorial. (line 112) * Fixed points: Nesting and Fixed Points. (line 18) * Flattening a matrix: Manipulating Vectors. (line 23) * Floating-point numbers: Floats. (line 6) * Floats vs. fractions: Modes Tutorial. (line 342) * Flushing caches: Caches. (line 6) * Formulas: Formulas. (line 6) * Formulas, entering: Algebraic Entry. (line 6) * Formulas, evaluation: Variables. (line 30) * Formulas, referring to stack: Algebraic Entry. (line 57) * FORTRAN language: C FORTRAN Pascal. (line 40) * Fraction mode: Fraction Mode. (line 6) * Fractional part of a number: Integer Truncation. (line 62) * Fractions: Fractions. (line 6) * Fractions vs. floats: Modes Tutorial. (line 342) * Function call notation: Formulas. (line 100) * Gamma constant, Euler's <1>: Scientific Functions. (line 12) * Gamma constant, Euler's: Programming Tutorial. (line 375) * gamma variable <1>: Scientific Functions. (line 12) * gamma variable: Variables. (line 39) * Garbled displays, refreshing: Basic Commands. (line 88) * GenCount variable: Multiple Solutions. (line 35) * Generic functions: Specifying Operators. (line 54) * Geometric mean <1>: Single-Variable Statistics. (line 103) * Geometric mean: List Tutorial. (line 316) * Giac language: Giac Language Mode. (line 6) * Golden ratio <1>: Scientific Functions. (line 12) * Golden ratio: Programming Tutorial. (line 151) * Gregorian calendar: Date Forms. (line 48) * Grouping digits: Grouping Digits. (line 6) * Guard digits: Modes Tutorial. (line 104) * Harmonic mean: Single-Variable Statistics. (line 99) * Harmonic numbers: Programming Tutorial. (line 176) * Hash tables: Arithmetic Tutorial. (line 263) * Help commands: Help Commands. (line 6) * Hexadecimal integers: Radix Modes. (line 12) * Histograms: Manipulating Vectors. (line 79) * Holidays variable: Business Days. (line 25) * Horizontal scrolling: Basic Commands. (line 95) * Hours-minutes-seconds forms: HMS Forms. (line 6) * i variable <1>: Complex Formats. (line 15) * i variable: Variables. (line 39) * Identity matrix: Matrix Tutorial. (line 76) * Implicit comma in vectors: Formulas. (line 75) * Implicit multiplication: Formulas. (line 64) * Incomplete Algebraic Mode: Algebraic Entry. (line 37) * Incomplete complex numbers: Incomplete Objects. (line 6) * Incomplete interval forms: Incomplete Objects. (line 6) * Incomplete vectors: Incomplete Objects. (line 6) * Index tables: Manipulating Vectors. (line 53) * Inexact results: Symbolic Mode. (line 6) * inf variable: Infinities. (line 6) * Infinite mode: Infinite Mode. (line 6) * Infinity: Infinities. (line 6) * Integer part of a number: Integer Truncation. (line 15) * Integers: Integers. (line 6) * Integration by Simpson's rule: Basic Algebra Tutorial. (line 314) * Integration, numerical: Basic Algebra Tutorial. (line 255) * Interval forms: Interval Forms. (line 6) * Inverse of permutation: Manipulating Vectors. (line 53) * Iterative structures: Loops in Macros. (line 6) * Julian calendar: Date Forms. (line 48) * Julian day counting: Date Forms. (line 83) * Julian day counts, conversions: Date Conversions. (line 35) * Keyboard macros: Keyboard Macros. (line 6) * Keyboard macros, editing: Naming Keyboard Macros. (line 26) * Kill ring: Killing From Stack. (line 6) * Knuth, Art of Computer Programming: History and Acknowledgements. (line 77) * Lambda expressions: Specifying Operators. (line 80) * Large numbers, readability: Modes Tutorial. (line 173) * Last-arguments feature: Undo. (line 31) * LaTeX language: TeX and LaTeX Language Modes. (line 6) * Leading zeros: Radix Modes. (line 23) * Least-squares fits: Linear Fits. (line 6) * Least-squares for fitting a straight line: List Tutorial. (line 112) * Least-squares for over-determined systems: Matrix Tutorial. (line 171) * Levels of stack: RPN Tutorial. (line 44) * Line breaking: Normal Language Modes. (line 16) * Line, fitting data to: List Tutorial. (line 112) * Linear correlation: Paired-Sample Statistics. (line 28) * Linear equations, systems of: Matrix Tutorial. (line 116) * Linear regression: Linear Fits. (line 6) * Linearity testing: Logical Operations. (line 182) * LineStyles variable: Graphics Options. (line 105) * Lists: List Tutorial. (line 6) * Local variables: Local Values in Macros. (line 6) * Looping structures: Loops in Macros. (line 6) * Maple language: Maple Language Mode. (line 6) * Matchstick problem: List Tutorial. (line 454) * Mathematica language: Mathematica Language Mode. (line 6) * Matrices: Vectors and Matrices. (line 6) * Matrix display: Normal Language Modes. (line 11) * Matrix mode: Matrix Mode. (line 6) * max-lisp-eval-depth: Recursion Depth. (line 6) * max-specpdl-size: Recursion Depth. (line 6) * Maxima language: Maxima Language Mode. (line 6) * Maximizing a function over a list of values: List Tutorial. (line 422) * Maximum of a function using Calculus: Basic Algebra Tutorial. (line 48) * Mean of data values: Single-Variable Statistics. (line 55) * Median of data values: Single-Variable Statistics. (line 85) * Minimization, numerical: Minimization. (line 6) * Minus signs: Numeric Entry. (line 12) * Mistakes, undoing: Undo. (line 6) * Mode line indicators: Calc Mode Line. (line 6) * Modes variable: Modes Variable. (line 12) * Modulo division: Modulo Forms. (line 35) * Modulo forms: Modulo Forms. (line 6) * Moving stack entries: Stack Manipulation. (line 72) * Multiplication, implicit: Formulas. (line 64) * Nameless functions: Specifying Operators. (line 54) * nan variable: Infinities. (line 6) * Narrowing the stack: Truncating the Stack. (line 6) * Negative numbers, entering: Numeric Entry. (line 12) * Newton's method: Root Finding. (line 6) * Non-decimal numbers: Radix Modes. (line 6) * Normalizing a vector: Vector Analysis Tutorial. (line 84) * Numerator of a fraction, extracting: Packing and Unpacking. (line 181) * Numeric entry: Numeric Entry. (line 6) * Numerical integration: Basic Algebra Tutorial. (line 255) * Numerical Recipes: History and Acknowledgements. (line 77) * Numerical root-finding: Root Finding. (line 6) * Octal integers: Radix Modes. (line 12) * Operands: RPN Tutorial. (line 16) * Operators: RPN Tutorial. (line 16) * Operators in formulas: Formulas. (line 6) * Over-determined systems of equations: Matrix Tutorial. (line 171) * Parsing formulas, customized: Syntax Tables. (line 6) * Parts of formulas: Selecting Subformulas. (line 6) * Pascal language: C FORTRAN Pascal. (line 30) * Pattern matching: Rewrite Rules. (line 6) * Performance: Working Message. (line 6) * Permanent mode settings: General Mode Commands. (line 6) * Permanent user definitions: Creating User Keys. (line 36) * Permanent variables: Operations on Variables. (line 70) * Permutation, inverse of: Manipulating Vectors. (line 53) * Permutations, applying: Extracting Elements. (line 13) * Perpendicular vectors: Vector Analysis Tutorial. (line 49) * phi variable <1>: Scientific Functions. (line 12) * phi variable: Variables. (line 39) * Phi, golden ratio <1>: Scientific Functions. (line 12) * Phi, golden ratio: Programming Tutorial. (line 151) * pi variable <1>: Scientific Functions. (line 12) * pi variable: Variables. (line 39) * Plain vectors: Vectors and Matrices. (line 6) * PlotRejects variable: Basic Graphics. (line 58) * PointStyles variable: Graphics Options. (line 105) * Polar mode: Polar Mode. (line 6) * Polynomial, list of coefficients: Programming Tutorial. (line 397) * Population statistics: Single-Variable Statistics. (line 130) * Positive Infinite mode: Infinite Mode. (line 25) * Precedence of operators: Formulas. (line 6) * Precision of calculations: Precision. (line 6) * Primes: Combinatorial Functions. (line 71) * Principal values: Branch Cuts. (line 6) * Product of a sequence: Summations. (line 116) * Programming with algebraic formulas: Algebraic Definitions. (line 6) * Programming with keyboard macros: Keyboard Macros. (line 6) * Pythagorean Theorem: RPN Tutorial. (line 183) * Quaternions: Examples of Rewrite Rules. (line 40) * Quick Calculator: Quick Calculator. (line 6) * Quick units: User-Defined Units. (line 9) * Quick variables: Storing Variables. (line 6) * Quitting the Calculator: Basic Commands. (line 77) * Radix display: Radix Modes. (line 6) * Rank tables: Manipulating Vectors. (line 53) * Recalling variables: Recalling Variables. (line 6) * Reciprocal: Basic Arithmetic. (line 184) * Recursion: Programming Tutorial. (line 405) * Recursion depth: Recursion Depth. (line 6) * Redoing after an Undo: Undo. (line 23) * Refreshing a garbled display: Basic Commands. (line 88) * Registers: Saving Into Registers. (line 6) * Removing stack entries: Stack Manipulation. (line 23) * Reshaping a matrix: Manipulating Vectors. (line 23) * Restoring saved modes: Local Values in Macros. (line 6) * Retrieving previous results: Trail Commands. (line 30) * Rewrite rules: Rewrite Rules. (line 6) * Root-mean-square: Single-Variable Statistics. (line 113) * Roots of equations: Root Finding. (line 6) * Round-off errors: Modes Tutorial. (line 89) * Roundoff errors, correcting: Conversions. (line 96) * Roundoff errors, examples <1>: Arithmetic Tutorial. (line 162) * Roundoff errors, examples: Modes Tutorial. (line 288) * Roundoff errors, in non-decimal numbers: Modes Tutorial. (line 250) * RPN notation: RPN Tutorial. (line 6) * Running the Calculator: Basic Commands. (line 6) * Sample statistics: Single-Variable Statistics. (line 116) * Saving mode settings: General Mode Commands. (line 6) * Scalar mode: Matrix Mode. (line 6) * Scientific notation, display of: Float Formats. (line 28) * Scientific notation, entry of: Modes Tutorial. (line 78) * Scientific notation, in non-decimal numbers: Modes Tutorial. (line 258) * Scrolling: Basic Commands. (line 95) * Selections: Selecting Subformulas. (line 6) * Sets, as binary numbers: Set Operations. (line 100) * Sets, as vectors: Set Operations. (line 6) * Simpson's rule: Basic Algebra Tutorial. (line 314) * Sine integral Si(x): Programming Tutorial. (line 46) * Slope and angle of a line: Types Tutorial. (line 179) * Solving equations: Solving Equations. (line 6) * Sorting data: Manipulating Vectors. (line 39) * Speed of light: Types Tutorial. (line 382) * Square-free numbers: List Tutorial. (line 391) * Stack basics: Stack Basics. (line 6) * Stack levels: RPN Tutorial. (line 44) * Standalone Operation: Standalone Operation. (line 6) * Standard deviation: Single-Variable Statistics. (line 116) * Standard deviations: Error Forms. (line 6) * Standard user interface: The Standard Interface. (line 6) * Starting the Calculator: Basic Commands. (line 6) * Statistical functions: Statistical Operations. (line 6) * Storing user definitions: Creating User Keys. (line 36) * Storing variables <1>: Operations on Variables. (line 70) * Storing variables: Storing Variables. (line 6) * Strings: Strings. (line 6) * Sub-formulas: Selecting Subformulas. (line 6) * Subscript notation: Extracting Elements. (line 24) * Summation of a series: Summations. (line 6) * Summations (by keyboard macros): Loops in Macros. (line 42) * Summations (statistical): Single-Variable Statistics. (line 42) * Summing rows and columns of data: Grabbing From Buffers. (line 77) * Symbolic mode: Symbolic Mode. (line 6) * Syntax tables: Syntax Tables. (line 6) * Systems of equations, numerical: Numerical Systems of Equations. (line 6) * Systems of equations, symbolic: Solving Systems of Equations. (line 6) * Systems of linear equations: Matrix Tutorial. (line 116) * Temperature conversion: Basic Operations on Units. (line 126) * Temporary assignment to variables: Let Command. (line 6) * TeX language: TeX and LaTeX Language Modes. (line 6) * Time of day: HMS Forms. (line 29) * Time travel: Undo Tutorial. (line 39) * Time zones: Time Zones. (line 6) * Time Zones, converting between: Date Conversions. (line 60) * TimeZone variable: Time Zones. (line 72) * Torus, volume of: Types Tutorial. (line 196) * Total Algebraic Mode: Algebraic Entry. (line 42) * Trail buffer: Trail Commands. (line 6) * Trail pointer: Trail Commands. (line 25) * Transformations: Rewrite Rules. (line 6) * Triangular lists: List Tutorial. (line 398) * Truncating the stack: Truncating the Stack. (line 6) * Two's complements: Radix Modes. (line 32) * uinf variable: Infinities. (line 6) * Un-storing variables: Storing Variables. (line 110) * Unary operators: Arithmetic Tutorial. (line 32) * Undoing mistakes: Undo. (line 6) * Unit vectors: Vector Analysis Tutorial. (line 84) * Units variable: User-Defined Units. (line 9) * UnitSimpRules variable: Automatic Rewrites. (line 149) * Unix time format: Date Forms. (line 120) * Unix time format, conversions: Date Conversions. (line 50) * Unsafe simplifications: Unsafe Simplifications. (line 6) * User-defined units: User-Defined Units. (line 27) * Variables, evaluation: Variables. (line 30) * Variables, in formulas: Variables. (line 6) * Variables, temporary assignment: Let Command. (line 6) * Variance of data values: Single-Variable Statistics. (line 143) * Vectors: Vectors and Matrices. (line 6) * Vertical scrolling: Basic Commands. (line 101) * Void variables: Storing Variables. (line 110) * Why did an error occur?: Error Messages. (line 6) * Wide text, scrolling: Basic Commands. (line 95) * Word size for binary operations: Binary Functions. (line 15) * Working messages: Working Message. (line 6) * Yacas language: Yacas Language Mode. (line 6)  File: calc, Node: Variable Index, Next: Lisp Function Index, Prev: Concept Index, Up: Top Index of Variables ****************** The variables in this list that do not contain dashes are accessible as Calc variables. Add a `var-' prefix to get the name of the corresponding Lisp variable. The remaining variables are Lisp variables suitable for `setq'ing in your Calc init file or `.emacs' file. [index] * Menu: * AlgSimpRules: Automatic Rewrites. (line 136) * all: Multi-Phase Rewrite Rules. (line 11) * All: Declaration Basics. (line 48) * calc-alg-ent-map: Hooks. (line 112) * calc-define: Defining Functions. (line 144) * calc-digit-map: Hooks. (line 106) * calc-edit-mode-hook: Hooks. (line 74) * calc-edit-mode-map: Hooks. (line 121) * calc-embedded-announce-formula <1>: Customizing Calc. (line 93) * calc-embedded-announce-formula: Customizing Embedded Mode. (line 108) * calc-embedded-announce-formula-alist: Customizing Calc. (line 94) * calc-embedded-close-formula <1>: Customizing Calc. (line 128) * calc-embedded-close-formula: Customizing Embedded Mode. (line 69) * calc-embedded-close-mode <1>: Customizing Calc. (line 238) * calc-embedded-close-mode: Customizing Embedded Mode. (line 129) * calc-embedded-close-new-formula <1>: Customizing Calc. (line 213) * calc-embedded-close-new-formula: Customizing Embedded Mode. (line 101) * calc-embedded-close-plain <1>: Customizing Calc. (line 177) * calc-embedded-close-plain: Customizing Embedded Mode. (line 88) * calc-embedded-mode-hook: Hooks. (line 63) * calc-embedded-new-buffer-hook: Hooks. (line 66) * calc-embedded-new-formula-hook: Hooks. (line 70) * calc-embedded-open-close-formula-alist: Customizing Calc. (line 129) * calc-embedded-open-close-mode-alist: Customizing Calc. (line 239) * calc-embedded-open-close-new-formula-alist: Customizing Calc. (line 214) * calc-embedded-open-close-plain-alist: Customizing Calc. (line 178) * calc-embedded-open-formula <1>: Customizing Calc. (line 127) * calc-embedded-open-formula: Customizing Embedded Mode. (line 15) * calc-embedded-open-mode <1>: Customizing Calc. (line 237) * calc-embedded-open-mode: Customizing Embedded Mode. (line 122) * calc-embedded-open-new-formula <1>: Customizing Calc. (line 212) * calc-embedded-open-new-formula: Customizing Embedded Mode. (line 94) * calc-embedded-open-plain <1>: Customizing Calc. (line 176) * calc-embedded-open-plain: Customizing Embedded Mode. (line 81) * calc-embedded-word-regexp <1>: Customizing Calc. (line 160) * calc-embedded-word-regexp: Customizing Embedded Mode. (line 77) * calc-embedded-word-regexp-alist: Customizing Calc. (line 161) * calc-end-hook: Hooks. (line 43) * calc-ext-load-hook: Hooks. (line 18) * calc-gnuplot-default-device: Devices. (line 77) * calc-gnuplot-default-output: Devices. (line 77) * calc-gnuplot-name <1>: Customizing Calc. (line 45) * calc-gnuplot-name: Graphics. (line 13) * calc-gnuplot-plot-command <1>: Customizing Calc. (line 54) * calc-gnuplot-plot-command: Devices. (line 77) * calc-gnuplot-print-command <1>: Customizing Calc. (line 55) * calc-gnuplot-print-command: Devices. (line 77) * calc-gnuplot-print-device: Devices. (line 77) * calc-gnuplot-print-output: Devices. (line 77) * calc-language-alist: Customizing Calc. (line 68) * calc-load-hook: Hooks. (line 13) * calc-local-var-list: Hooks. (line 133) * calc-mode-hook: Hooks. (line 27) * calc-mode-map: Hooks. (line 97) * calc-mode-save-hook: Hooks. (line 81) * calc-mode-var-list: Hooks. (line 126) * calc-multiplication-has-precedence: Customizing Calc. (line 274) * calc-other-modes: Hooks. (line 90) * calc-reset-hook: Hooks. (line 86) * calc-settings-file: Customizing Calc. (line 35) * calc-start-hook: Hooks. (line 21) * calc-store-var-map: Hooks. (line 116) * calc-trail-mode-hook: Hooks. (line 37) * calc-trail-window-hook: Hooks. (line 57) * calc-undo-length: Customizing Calc. (line 287) * calc-window-hook: Hooks. (line 49) * calc-Y-help-msgs: Defining Simple Commands. (line 87) * CommuteRules: Rearranging with Selections. (line 74) * Decls: Declaration Basics. (line 23) * DistribRules: Rearranging with Selections. (line 55) * e <1>: Scientific Functions. (line 12) * e: Variables. (line 39) * EvalRules: Automatic Rewrites. (line 6) * ExtSimpRules: Automatic Rewrites. (line 149) * FactorRules: Polynomials. (line 38) * FitRules: Curve Fitting Details. (line 149) * gamma <1>: Scientific Functions. (line 12) * gamma: Variables. (line 39) * GenCount: Multiple Solutions. (line 35) * Holidays: Business Days. (line 25) * i <1>: Complex Formats. (line 15) * i: Variables. (line 39) * inf: Infinities. (line 6) * IntegAfterRules: Customizing the Integrator. (line 91) * IntegLimit: Integration. (line 48) * IntegRules: Customizing the Integrator. (line 6) * IntegSimpRules: Customizing the Integrator. (line 78) * InvertRules: Rearranging with Selections. (line 98) * JumpRules: Rearranging with Selections. (line 103) * LineStyles: Graphics Options. (line 105) * math-daylight-savings-hook: Time Zones. (line 92) * math-tzone-names: Time Zones. (line 62) * MergeRules: Rearranging with Selections. (line 68) * Model1: Standard Nonlinear Models. (line 138) * Model2: Standard Nonlinear Models. (line 138) * Modes: Modes Variable. (line 12) * nan: Infinities. (line 6) * NegateRules: Rearranging with Selections. (line 90) * phi: Variables. (line 39) * pi <1>: Scientific Functions. (line 12) * pi: Variables. (line 39) * PlotData1: Managing Curves. (line 30) * PlotData2: Managing Curves. (line 30) * PlotRejects: Basic Graphics. (line 58) * PointStyles: Graphics Options. (line 105) * q0: Storing Variables. (line 6) * q9: Storing Variables. (line 6) * RandSeed: Random Numbers. (line 48) * remember: Other Features of Rewrite Rules. (line 266) * TimeZone: Time Zones. (line 72) * uinf: Infinities. (line 6) * Units: User-Defined Units. (line 9) * UnitSimpRules: Automatic Rewrites. (line 149)  File: calc, Node: Lisp Function Index, Prev: Variable Index, Up: Top Index of Lisp Math Functions **************************** The following functions are meant to be used with `defmath', not `defun' definitions. For names that do not start with `calc-', the corresponding full Lisp name is derived by adding a prefix of `math-'. [index] * Menu: * abs-approx: Computational Lisp Functions. (line 156) * anglep: Predicates. (line 83) * apply-rewrites: Symbolic Lisp Functions. (line 229) * beforep: Predicates. (line 152) * build-polynomial-expr: Symbolic Lisp Functions. (line 461) * build-vector: Vector Lisp Functions. (line 35) * calc-binary-op: Stack Lisp Functions. (line 132) * calc-change-current-selection: Symbolic Lisp Functions. (line 51) * calc-check-defines: Defining Functions. (line 175) * calc-clear-command-flag: Interactive Lisp Functions. (line 19) * calc-cursor-stack-index: Stack Lisp Functions. (line 150) * calc-do-alg-entry: Formatting Lisp Functions. (line 31) * calc-encase-atoms: Symbolic Lisp Functions. (line 39) * calc-enter-result <1>: Stack Lisp Functions. (line 96) * calc-enter-result: Defining Stack Commands. (line 59) * calc-eval: Formatting Lisp Functions. (line 10) * calc-find-assoc-parent-formula: Symbolic Lisp Functions. (line 73) * calc-find-nth-part: Symbolic Lisp Functions. (line 58) * calc-find-parent-formula: Symbolic Lisp Functions. (line 65) * calc-find-selected-part: Symbolic Lisp Functions. (line 45) * calc-find-sub-formula: Symbolic Lisp Functions. (line 86) * calc-grow-assoc-formula: Symbolic Lisp Functions. (line 80) * calc-is-hyperbolic: Interactive Lisp Functions. (line 55) * calc-is-inverse: Interactive Lisp Functions. (line 51) * calc-normalize: Stack Lisp Functions. (line 70) * calc-pop-stack: Stack Lisp Functions. (line 53) * calc-prepare-selection: Symbolic Lisp Functions. (line 10) * calc-push-list: Stack Lisp Functions. (line 10) * calc-record-list: Stack Lisp Functions. (line 64) * calc-record-undo: Interactive Lisp Functions. (line 23) * calc-record-why: Interactive Lisp Functions. (line 37) * calc-refresh: Stack Lisp Functions. (line 166) * calc-replace-sub-formula: Symbolic Lisp Functions. (line 93) * calc-select-buffer: Defining Simple Commands. (line 52) * calc-set-command-flag <1>: Interactive Lisp Functions. (line 13) * calc-set-command-flag: Defining Simple Commands. (line 56) * calc-slow-wrapper: Defining Stack Commands. (line 49) * calc-stack-size: Stack Lisp Functions. (line 145) * calc-substack-height: Stack Lisp Functions. (line 157) * calc-top-list: Stack Lisp Functions. (line 26) * calc-top-list-n <1>: Stack Lisp Functions. (line 79) * calc-top-list-n: Defining Stack Commands. (line 54) * calc-top-n: Stack Lisp Functions. (line 90) * calc-unary-op: Stack Lisp Functions. (line 121) * calc-wrapper: Defining Simple Commands. (line 38) * cancel-common-factor: Symbolic Lisp Functions. (line 184) * check-unit-name: Symbolic Lisp Functions. (line 468) * col-matrix: Vector Lisp Functions. (line 50) * common-constant-factor: Symbolic Lisp Functions. (line 178) * comp-ascent: Formatting Lisp Functions. (line 109) * comp-descent: Formatting Lisp Functions. (line 113) * comp-first-char: Formatting Lisp Functions. (line 117) * comp-height: Formatting Lisp Functions. (line 106) * comp-last-char: Formatting Lisp Functions. (line 122) * comp-width: Formatting Lisp Functions. (line 103) * compare: Computational Lisp Functions. (line 105) * compile-rewrites: Symbolic Lisp Functions. (line 221) * complete: Argument Qualifiers. (line 21) * complexp: Predicates. (line 91) * compose-expr: Formatting Lisp Functions. (line 81) * composition-to-string: Formatting Lisp Functions. (line 96) * constp: Predicates. (line 138) * convert-temp: Calling Calc from Your Programs. (line 295) * copy-matrix: Vector Lisp Functions. (line 104) * defmath: Defining Functions. (line 6) * deriv: Symbolic Lisp Functions. (line 256) * dimension-error: Vector Lisp Functions. (line 30) * div-mod: Computational Lisp Functions. (line 200) * e: Computational Lisp Functions. (line 160) * equal: Predicates. (line 162) * equal-int: Predicates. (line 174) * evaluate-expr: Computational Lisp Functions. (line 45) * evenp: Predicates. (line 65) * expr-contains: Symbolic Lisp Functions. (line 361) * expr-contains-count: Symbolic Lisp Functions. (line 370) * expr-contains-vars: Symbolic Lisp Functions. (line 379) * expr-depends: Symbolic Lisp Functions. (line 374) * expr-height: Symbolic Lisp Functions. (line 400) * expr-subst: Symbolic Lisp Functions. (line 383) * expr-weight: Symbolic Lisp Functions. (line 395) * extract-units: Symbolic Lisp Functions. (line 500) * fixnatnump: Predicates. (line 49) * fixnum <1>: Computational Lisp Functions. (line 123) * fixnum: Argument Qualifiers. (line 36) * fixnump: Predicates. (line 43) * flatten-vector: Vector Lisp Functions. (line 100) * float <1>: Computational Lisp Functions. (line 98) * float: Argument Qualifiers. (line 42) * floatp: Predicates. (line 86) * format-flat-expr: Formatting Lisp Functions. (line 53) * format-nice-expr: Formatting Lisp Functions. (line 64) * format-number: Formatting Lisp Functions. (line 50) * format-value: Formatting Lisp Functions. (line 71) * frac-gcd: Symbolic Lisp Functions. (line 200) * from-hms: Computational Lisp Functions. (line 220) * from-radians: Computational Lisp Functions. (line 230) * from-radians-2: Computational Lisp Functions. (line 238) * full-circle: Computational Lisp Functions. (line 183) * gamma-const: Computational Lisp Functions. (line 160) * half-circle: Computational Lisp Functions. (line 182) * idiv: Computational Lisp Functions. (line 136) * idivmod: Computational Lisp Functions. (line 148) * imod: Computational Lisp Functions. (line 142) * inexact-value: Predicates. (line 212) * integ: Symbolic Lisp Functions. (line 290) * integer: Argument Qualifiers. (line 28) * integer-log2: Computational Lisp Functions. (line 195) * integerp: Predicates. (line 40) * interactive: Defining Simple Commands. (line 6) * is-polynomial: Symbolic Lisp Functions. (line 415) * is-true: Predicates. (line 201) * isqrt: Computational Lisp Functions. (line 209) * lessp: Predicates. (line 143) * ln-10: Computational Lisp Functions. (line 160) * ln-2: Computational Lisp Functions. (line 160) * looks-evenp: Predicates. (line 68) * looks-negp: Predicates. (line 34) * make-float: Computational Lisp Functions. (line 68) * make-frac: Computational Lisp Functions. (line 64) * make-intv: Computational Lisp Functions. (line 81) * make-mod: Computational Lisp Functions. (line 92) * make-sdev: Computational Lisp Functions. (line 74) * make-vec: Vector Lisp Functions. (line 40) * map-tree: Symbolic Lisp Functions. (line 207) * map-vec: Vector Lisp Functions. (line 55) * map-vec-2: Vector Lisp Functions. (line 60) * mat-col: Vector Lisp Functions. (line 86) * mat-dimens: Vector Lisp Functions. (line 19) * mat-less-col: Vector Lisp Functions. (line 94) * mat-less-row: Vector Lisp Functions. (line 90) * mat-row: Vector Lisp Functions. (line 81) * match-patterns: Symbolic Lisp Functions. (line 250) * math-concat: Vector Lisp Functions. (line 10) * math-defcache: Computational Lisp Functions. (line 169) * math-defintegral: Symbolic Lisp Functions. (line 294) * math-defintegral-2: Symbolic Lisp Functions. (line 323) * math-defsimplify: Symbolic Lisp Functions. (line 131) * math-equal: Predicates. (line 168) * math-prev-weekday-in-month: Time Zones. (line 119) * math-std-daylight-savings: Time Zones. (line 92) * matrixp: Predicates. (line 114) * messy-integerp: Predicates. (line 57) * multi-subst: Symbolic Lisp Functions. (line 389) * natnum: Argument Qualifiers. (line 33) * natnump: Predicates. (line 46) * nearly-equal: Predicates. (line 180) * nearly-zerop: Predicates. (line 194) * negp: Predicates. (line 22) * normalize: Computational Lisp Functions. (line 20) * num-integerp: Predicates. (line 52) * num-natnump: Predicates. (line 62) * numberp: Predicates. (line 101) * numdigs: Computational Lisp Functions. (line 110) * numvecp: Predicates. (line 111) * objectp: Predicates. (line 121) * objvecp: Predicates. (line 127) * oddp: Predicates. (line 72) * overflow: Predicates. (line 222) * phi: Computational Lisp Functions. (line 160) * pi: Computational Lisp Functions. (line 161) * pi-over-180: Computational Lisp Functions. (line 160) * pi-over-2: Computational Lisp Functions. (line 160) * pi-over-4: Computational Lisp Functions. (line 160) * polar-complexp: Predicates. (line 98) * poly-mix: Symbolic Lisp Functions. (line 451) * poly-mul: Symbolic Lisp Functions. (line 457) * poly-simplify: Symbolic Lisp Functions. (line 447) * polynomial-base: Symbolic Lisp Functions. (line 435) * polynomial-p: Symbolic Lisp Functions. (line 405) * posp: Predicates. (line 30) * pow: Computational Lisp Functions. (line 152) * pow-mod: Computational Lisp Functions. (line 204) * power-of-2: Computational Lisp Functions. (line 190) * prime-test: Computational Lisp Functions. (line 252) * primp: Predicates. (line 132) * quarter-circle: Computational Lisp Functions. (line 182) * quarter-integer: Computational Lisp Functions. (line 278) * quotient: Computational Lisp Functions. (line 131) * random-digit: Computational Lisp Functions. (line 242) * random-digits: Computational Lisp Functions. (line 245) * random-float: Computational Lisp Functions. (line 249) * ratp: Predicates. (line 75) * read-expr: Formatting Lisp Functions. (line 19) * read-exprs: Formatting Lisp Functions. (line 26) * read-number: Formatting Lisp Functions. (line 14) * realp: Predicates. (line 79) * rect-complexp: Predicates. (line 95) * reduce-cols: Vector Lisp Functions. (line 76) * reduce-vec: Vector Lisp Functions. (line 71) * reject-arg: Predicates. (line 206) * remove-units: Symbolic Lisp Functions. (line 496) * rewrite: Symbolic Lisp Functions. (line 245) * rewrite-heads: Symbolic Lisp Functions. (line 241) * row-matrix: Vector Lisp Functions. (line 45) * scalarp: Predicates. (line 104) * scale-int: Computational Lisp Functions. (line 115) * scale-rounding: Computational Lisp Functions. (line 119) * simplify: Symbolic Lisp Functions. (line 97) * simplify-extended: Symbolic Lisp Functions. (line 116) * simplify-units: Symbolic Lisp Functions. (line 126) * single-units-in-expr-p: Symbolic Lisp Functions. (line 483) * solve-eqn: Symbolic Lisp Functions. (line 350) * solve-for: Symbolic Lisp Functions. (line 329) * solve-system: Symbolic Lisp Functions. (line 356) * sort-intv: Computational Lisp Functions. (line 87) * sqr: Computational Lisp Functions. (line 128) * sqrt-e: Computational Lisp Functions. (line 160) * sqrt-two-pi: Computational Lisp Functions. (line 160) * square-matrixp: Predicates. (line 118) * swap-rows: Vector Lisp Functions. (line 111) * tderiv: Symbolic Lisp Functions. (line 285) * to-fraction: Computational Lisp Functions. (line 273) * to-hms: Computational Lisp Functions. (line 214) * to-radians: Computational Lisp Functions. (line 226) * to-radians-2: Computational Lisp Functions. (line 234) * to-simple-fraction: Computational Lisp Functions. (line 267) * to-standard-units: Symbolic Lisp Functions. (line 489) * transpose: Vector Lisp Functions. (line 97) * two-pi: Computational Lisp Functions. (line 160) * underflow: Predicates. (line 226) * units-in-expr-p: Symbolic Lisp Functions. (line 477) * vec-length: Vector Lisp Functions. (line 14) * vectorp: Predicates. (line 107) * with-extra-prec: Computational Lisp Functions. (line 50) * zerop: Predicates. (line 14)