doc/info/Command.texi

   1 @menu
   2 * Introduction to Command Line::
   3 * Functions and Variables for Command Line::
   4 * Functions and Variables for Display::
   5 @end menu
   6
   7 @c -----------------------------------------------------------------------------
   8 @node Introduction to Command Line, Functions and Variables for Command Line, Command Line, Command Line
   9 @section Introduction to Command Line
  10 @c -----------------------------------------------------------------------------
  11
  12 @c end concepts Command Line
  13
  14 @c -----------------------------------------------------------------------------
  15 @node Functions and Variables for Command Line, Functions and Variables for Display, Introduction to Command Line, Command Line
  16 @section Functions and Variables for Command Line
  17 @c -----------------------------------------------------------------------------
  18
  19 @c -----------------------------------------------------------------------------
  20 @anchor{__}
  21 @defvr {System variable} __
  22 @ifinfo
  23 @vrindex Current input expression
  24 @end ifinfo
  25
  26 @code{__} is the input expression currently being evaluated.  That is, while an
  27 input expression @var{expr} is being evaluated, @code{__} is @var{expr}.
  28
  29 @code{__} is assigned the input expression before the input is simplified or
  30 evaluated.  However, the value of @code{__} is simplified (but not evaluated)
  31 when it is displayed.
  32
  33 @code{__} is recognized by @mref{batch} and @mrefdot{load}  In a file processed
  34 by @code{batch}, @code{__} has the same meaning as at the interactive prompt.
  35 In a file processed by @code{load}, @code{__} is bound to the input expression
  36 most recently entered at the interactive prompt or in a batch file; @code{__}
  37 is not bound to the input expressions in the file being processed.  In
  38 particular, when @code{load (@var{filename})} is called from the interactive
  39 prompt, @code{__} is bound to @code{load (@var{filename})} while the file is
  40 being processed.
  41
  42 See also @mref{_} and @mrefdot{%}
  43
  44 Examples:
  45
  46 @c ===beg===
  47 @c print ("I was called as", __);
  48 @c foo (__);
  49 @c g (x) := (print ("Current input expression =", __), 0);
  50 @c [aa : 1, bb : 2, cc : 3];
  51 @c (aa + bb + cc)/(dd + ee + g(x));
  52 @c ===end===
  53 @example
  54 @group
  55 (%i1) print ("I was called as", __);
  56 I was called as print(I was called as, __)
  57 (%o1)              print(I was called as, __)
  58 @end group
  59 @group
  60 (%i2) foo (__);
  61 (%o2)                     foo(foo(__))
  62 @end group
  63 @group
  64 (%i3) g (x) := (print ("Current input expression =", __), 0);
  65 (%o3) g(x) := (print("Current input expression =", __), 0)
  66 @end group
  67 @group
  68 (%i4) [aa : 1, bb : 2, cc : 3];
  69 (%o4)                       [1, 2, 3]
  70 @end group
  71 @group
  72 (%i5) (aa + bb + cc)/(dd + ee + g(x));
  73                             cc + bb + aa
  74 Current input expression = --------------
  75                            g(x) + ee + dd
  76                                 6
  77 (%o5)                        -------
  78                              ee + dd
  79 @end group
  80 @end example
  81
  82 @opencatbox{Categories:}
  83 @category{Global variables}
  84 @closecatbox
  85 @end defvr
  86
  87 @c -----------------------------------------------------------------------------
  88 @anchor{_}
  89 @defvr {System variable} _
  90 @ifinfo
  91 @vrindex Previous input
  92 @end ifinfo
  93
  94 @code{_} is the most recent input expression (e.g., @code{%i1}, @code{%i2},
  95 @code{%i3}, @dots{}).
  96
  97 @code{_} is assigned the input expression before the input is simplified or
  98 evaluated.  However, the value of @code{_} is simplified (but not evaluated)
  99 when it is displayed.
 100
 101 @code{_} is recognized by @mref{batch} and @mrefdot{load}  In a file processed
 102 by @code{batch}, @code{_} has the same meaning as at the interactive prompt.
 103 In a file processed by @code{load}, @code{_} is bound to the input expression
 104 most recently evaluated at the interactive prompt or in a batch file; @code{_}
 105 is not bound to the input expressions in the file being processed.
 106
 107 See also @mref{__} and @mrefdot{%}
 108
 109 Examples:
 110
 111 @c ===beg===
 112 @c 13 + 29;
 113 @c :lisp $_
 114 @c _;
 115 @c sin (%pi/2);
 116 @c :lisp $_
 117 @c _;
 118 @c a: 13$
 119 @c b: 29$
 120 @c a + b;
 121 @c :lisp $_
 122 @c _;
 123 @c a + b;
 124 @c ev (_);
 125 @c ===end===
 126 @example
 127 @group
 128 (%i1) 13 + 29;
 129 (%o1)                          42
 130 @end group
 131 @group
 132 (%i2) :lisp $_
 133 ((MPLUS) 13 29)
 134 @end group
 135 @group
 136 (%i2) _;
 137 (%o2)                          42
 138 @end group
 139 @group
 140 (%i3) sin (%pi/2);
 141 (%o3)                           1
 142 @end group
 143 @group
 144 (%i4) :lisp $_
 145 ((%SIN) ((MQUOTIENT) $%PI 2))
 146 @end group
 147 @group
 148 (%i4) _;
 149 (%o4)                           1
 150 @end group
 151 (%i5) a: 13$
 152 (%i6) b: 29$
 153 @group
 154 (%i7) a + b;
 155 (%o7)                          42
 156 @end group
 157 @group
 158 (%i8) :lisp $_
 159 ((MPLUS) $A $B)
 160 @end group
 161 @group
 162 (%i8) _;
 163 (%o8)                         b + a
 164 @end group
 165 @group
 166 (%i9) a + b;
 167 (%o9)                          42
 168 @end group
 169 @group
 170 (%i10) ev (_);
 171 (%o10)                         42
 172 @end group
 173 @end example
 174
 175 @opencatbox{Categories:}
 176 @category{Console interaction}
 177 @category{Global variables}
 178 @closecatbox
 179 @end defvr
 180
 181 @c -----------------------------------------------------------------------------
 182 @anchor{%}
 183 @defvr {System variable} %
 184 @ifinfo
 185 @vrindex Previous output
 186 @end ifinfo
 187
 188 @code{%} is the output expression (e.g., @code{%o1}, @code{%o2}, @code{%o3},
 189 @dots{}) most recently computed by Maxima, whether or not it was displayed.
 190
 191 @code{%} is recognized by @mref{batch} and @mrefdot{load}  In a file processed
 192 by @code{batch}, @code{%} has the same meaning as at the interactive prompt.
 193 In a file processed by @code{load}, @code{%} is bound to the output expression
 194 most recently computed at the interactive prompt or in a batch file; @code{%}
 195 is not bound to output expressions in the file being processed.
 196
 197 See also @mrefcomma{_} @mrefcomma{%%} and @mrefdot{%th}
 198
 199 @opencatbox{Categories:}
 200 @category{Console interaction}
 201 @category{Global variables}
 202 @closecatbox
 203 @end defvr
 204
 205 @c -----------------------------------------------------------------------------
 206 @anchor{%%}
 207 @defvr {System variable} %%
 208 @ifinfo
 209 @vrindex Previous result in compound expression
 210 @end ifinfo
 211
 212 In compound statements, namely @mrefcomma{block} @mrefcomma{lambda} or
 213 @code{(@var{s_1}, ..., @var{s_n})}, @code{%%} is the value of the previous
 214 statement.
 215
 216 At the first statement in a compound statement, or outside of a compound
 217 statement, @code{%%} is undefined.
 218
 219 @code{%%} is recognized by @mref{batch} and @mrefcomma{load} and it has the
 220 same meaning as at the interactive prompt.
 221
 222 See also @mrefdot{%}
 223
 224 Examples:
 225
 226 The following two examples yield the same result.
 227
 228 @example
 229 (%i1) block (integrate (x^5, x), ev (%%, x=2) - ev (%%, x=1));
 230                                21
 231 (%o1)                          --
 232                                2
 233 (%i2) block ([prev], prev: integrate (x^5, x),
 234                ev (prev, x=2) - ev (prev, x=1));
 235                                21
 236 (%o2)                          --
 237                                2
 238
 239 @end example
 240
 241 A compound statement may comprise other compound statements.  Whether a
 242 statement be simple or compound, @code{%%} is the value of the previous
 243 statement.
 244
 245 @example
 246 (%i3) block (block (a^n, %%*42), %%/6);
 247                                  n
 248 (%o3)                         7 a
 249 @end example
 250
 251 Within a compound statement, the value of @code{%%} may be inspected at a break
 252 prompt, which is opened by executing the @mref{break} function.  For example,
 253 entering @code{%%;} in the following example yields @code{42}.
 254
 255 @example
 256 (%i4) block (a: 42, break ())$
 257
 258 Entering a Maxima break point. Type 'exit;' to resume.
 259 _%%;
 260 42
 261 _
 262 @end example
 263
 264 @opencatbox{Categories:}
 265 @category{Global variables}
 266 @closecatbox
 267 @end defvr
 268
 269 @c -----------------------------------------------------------------------------
 270 @anchor{%th}
 271 @deffn {Function} %th (@var{i})
 272 @ifinfo
 273 @fnindex N'th previous output
 274 @end ifinfo
 275
 276 The value of the @var{i}'th previous output expression.  That is, if the next
 277 expression to be computed is the @var{n}'th output, @code{%th (@var{m})} is the
 278 (@var{n} - @var{m})'th output.
 279
 280 @code{%th} is recognized by @mref{batch} and @mrefdot{load}  In a file processed
 281 by @code{batch}, @code{%th} has the same meaning as at the interactive prompt.
 282 In a file processed by @code{load}, @code{%th} refers to output expressions most
 283 recently computed at the interactive prompt or in a batch file; @code{%th} does
 284 not refer to output expressions in the file being processed.
 285
 286 See also @mref{%} and @mrefdot{%%}
 287
 288 Example:
 289
 290 @code{%th} is useful in @code{batch} files or for referring to a group of
 291 output expressions.  This example sets @code{s} to the sum of the last five
 292 output expressions.
 293
 294 @example
 295 (%i1) 1;2;3;4;5;
 296 (%o1)                           1
 297 (%o2)                           2
 298 (%o3)                           3
 299 (%o4)                           4
 300 (%o5)                           5
 301 (%i6) block (s: 0, for i:1 thru 5 do s: s + %th(i), s);
 302 (%o6)                          15
 303 @end example
 304
 305 @opencatbox{Categories:}
 306 @category{Console interaction}
 307 @closecatbox
 308 @end deffn
 309
 310 @c -----------------------------------------------------------------------------
 311 @anchor{?}
 312 @deffn {Special symbol} ?
 313 @ifinfo
 314 @fnindex Fetch documentation
 315 @end ifinfo
 316
 317 As prefix to a function or variable name, @code{?} signifies that the name is a
 318 Lisp name, not a Maxima name.  For example, @code{?round} signifies the Lisp
 319 function @code{ROUND}.  See @ref{Lisp and Maxima} for more on this point.
 320
 321 The notation @code{? word} (a question mark followed a word, separated by
 322 whitespace) is equivalent to @code{describe("word")}.  The question mark must
 323 occur at the beginning of an input line; otherwise it is not recognized as a
 324 request for documentation.  See also @mrefdot{describe}
 325
 326 @opencatbox{Categories:}
 327 @category{Help}
 328 @category{Console interaction}
 329 @closecatbox
 330 @end deffn
 331
 332 @c -----------------------------------------------------------------------------
 333 @anchor{??}
 334 @deffn {Special symbol} ??
 335 @ifinfo
 336 @fnindex Fetch documentation (inexact search)
 337 @end ifinfo
 338
 339 The notation @code{?? word} (@code{??} followed a word, separated by whitespace)
 340 is equivalent to @code{describe("word", inexact)}.  The question mark must occur
 341 at the beginning of an input line; otherwise it is not recognized as a request
 342 for documentation.  See also @mrefdot{describe}
 343
 344 @opencatbox{Categories:}
 345 @category{Help}
 346 @category{Console interaction}
 347 @closecatbox
 348 @end deffn
 349
 350 @c -----------------------------------------------------------------------------
 351 @anchor{$}
 352 @deffn {Input terminator} $
 353 @ifinfo
 354 @fnindex Input terminator (without display)
 355 @end ifinfo
 356
 357 The dollar sign @code{$} terminates an input expression,
 358 and the most recent output @code{%} and an output label, e.g. @code{%o1},
 359 are assigned the result, but the result is not displayed.
 360
 361 See also @mrefdot{;}
 362
 363 Example:
 364 @c ===beg===
 365 @c 1 + 2 + 3 $
 366 @c %;
 367 @c %o1;
 368 @c ===end===
 369 @example
 370 (%i1) 1 + 2 + 3 $
 371 @group
 372 (%i2) %;
 373 (%o2)                           6
 374 @end group
 375 @group
 376 (%i3) %o1;
 377 (%o3)                           6
 378 @end group
 379 @end example
 380 @end deffn
 381
 382 @c -----------------------------------------------------------------------------
 383 @anchor{;}
 384 @deffn {Input terminator} ;
 385 @ifinfo
 386 @fnindex Input terminator (with display)
 387 @end ifinfo
 388
 389 The semicolon @code{;} terminates an input expression,
 390 and the resulting output is displayed.
 391
 392 See also @mrefdot{$}
 393
 394 Example:
 395 @c ===beg===
 396 @c 1 + 2 + 3;
 397 @c ===end===
 398 @example
 399 @group
 400 (%i1) 1 + 2 + 3;
 401 (%o1)                           6
 402 @end group
 403 @end example
 404 @end deffn
 405
 406 @c -----------------------------------------------------------------------------
 407 @anchor{inchar}
 408 @defvr {Option variable} inchar
 409 Default value: @code{%i}
 410
 411 @code{inchar} is the prefix of the labels of expressions entered by the user.
 412 Maxima automatically constructs a label for each input expression by
 413 concatenating @code{inchar} and @mrefdot{linenum}
 414
 415 @code{inchar} may be assigned any string or symbol, not necessarily a single
 416 character.  Because Maxima internally takes into account only the first char of
 417 the prefix, the prefixes @code{inchar}, @mrefcomma{outchar} and
 418 @mref{linechar} should have a different first char.  Otherwise some commands
 419 like @code{kill(inlabels)} do not work as expected.
 420
 421 See also @mrefdot{labels}
 422
 423 Example:
 424
 425 @c ===beg===
 426 @c inchar: "input";
 427 @c expand((a+b)^3);
 428 @c ===end===
 429 @example
 430 @group
 431 (%i1) inchar: "input";
 432 (%o1)                         input
 433 @end group
 434 @group
 435 (input2) expand((a+b)^3);
 436                      3        2      2      3
 437 (%o2)               b  + 3 a b  + 3 a  b + a
 438 @end group
 439 @end example
 440
 441 @opencatbox{Categories:}
 442 @category{Display flags and variables}
 443 @closecatbox
 444 @end defvr
 445
 446 @c -----------------------------------------------------------------------------
 447 @anchor{infolists}
 448 @defvr {System variable} infolists
 449 Default value: @code{[]}
 450
 451 @code{infolists} is a list of the names of all of the information
 452 lists in Maxima.  These are:
 453
 454 @table @code
 455 @item labels
 456 All bound @code{%i}, @code{%o}, and @code{%t} labels.
 457 @item values
 458 All bound atoms which are user variables, not Maxima options or switches,
 459 created by @mref{:} or @mref{::} or functional binding.
 460 @c WHAT IS INTENDED BY "FUNCTIONAL BINDING" HERE ??
 461 @item functions
 462 All user-defined functions, created by @mref{:=} or @mrefdot{define}
 463 @item arrays
 464 All arrays, @mref{hashed arrays} and @mref{memoizing functions}.
 465 @item macros
 466 All user-defined macro functions, created by @mrefdot{::=}
 467 @item myoptions
 468 All options ever reset by the user (whether or not they
 469 are later reset to their default values).
 470 @item rules
 471 All user-defined pattern matching and simplification rules, created
 472 by @mrefcomma{tellsimp} @mrefcomma{tellsimpafter} @mrefcomma{defmatch} or
 473 @mrefdot{defrule}
 474 @item aliases
 475 All atoms which have a user-defined alias, created by the @mrefcomma{alias}@w{}
 476 @mrefcomma{ordergreat} @mref{orderless} functions or by declaring the atom as a
 477 @mref{noun} with @mrefdot{declare}
 478 @item dependencies
 479 All atoms which have functional dependencies, created by the
 480 @mref{depends}, @mref{dependencies}, or @mref{gradef} functions.
 481 @item gradefs
 482 All functions which have user-defined derivatives, created by the
 483 @mref{gradef} function.
 484 @c UMM, WE REALLY NEED TO BE SPECIFIC -- WHAT DOES "ETC" CONTAIN HERE ??
 485 @item props
 486 All atoms which have any property other than those mentioned above, such as
 487 properties established by @mref{atvalue} or @mref{matchdeclare}, etc.,
 488 as well as properties established in the @mref{declare} function.
 489 @item structures
 490 @c Is also documented in Structures.texi. But it definitively is an infolist
 491 @c so it has to be documented here, too.
 492 All structs defined using @mrefdot{defstruct}
 493 @item let_rule_packages
 494 All user-defined @mref{let} rule packages
 495 plus the special package @mrefdot{default_let_rule_package}
 496 (@code{default_let_rule_package} is the name of the rule package used when
 497 one is not explicitly set by the user.)
 498 @end table
 499
 500 @opencatbox{Categories:}
 501 @category{Declarations and inferences}
 502 @category{Global variables}
 503 @closecatbox
 504 @end defvr
 505
 506 @c REVIEW FOR ACCURACY AND COMPLETENESS
 507 @c THIS ITEM IS VERY IMPORTANT !!
 508 @c NEEDS EXAMPLES
 509
 510 @c -----------------------------------------------------------------------------
 511 @anchor{kill}
 512 @deffn  {Function} kill @
 513 @fname{kill} (@var{a_1}, @dots{}, @var{a_n}) @
 514 @fname{kill} (labels) @
 515 @fname{kill} (inlabels, outlabels, linelabels) @
 516 @fname{kill} (@var{n}) @
 517 @fname{kill} ([@var{m}, @var{n}]) @
 518 @fname{kill} (values, functions, arrays, @dots{}) @
 519 @fname{kill} (all) @
 520 @fname{kill} (allbut (@var{a_1}, @dots{}, @var{a_n}))
 521
 522 Removes all bindings (value, function, array, or rule) from the arguments
 523 @var{a_1}, @dots{}, @var{a_n}.  An argument @var{a_k} may be a symbol or a
 524 single array element.  When @var{a_k} is a single array element, @code{kill}
 525 unbinds that element without affecting any other elements of the array.
 526
 527 Several special arguments are recognized.  Different kinds of arguments
 528 may be combined, e.g., @code{kill (inlabels, functions, allbut (foo, bar))}.
 529
 530 @code{kill (labels)} unbinds all input, output, and intermediate expression
 531 labels created so far.  @code{kill (inlabels)} unbinds only input labels which
 532 begin with the current value of @mrefdot{inchar}  Likewise,
 533 @code{kill (outlabels)} unbinds only output labels which begin with the current
 534 value of @mrefcomma{outchar} and @code{kill (linelabels)} unbinds only
 535 intermediate expression labels which begin with the current value of
 536 @mrefdot{linechar}
 537
 538 @code{kill (@var{n})}, where @var{n} is an integer,
 539 unbinds the @var{n} most recent input and output labels.
 540
 541 @code{kill ([@var{m}, @var{n}])} unbinds input and output labels @var{m} through
 542 @var{n}.
 543
 544 @code{kill (@var{infolist})}, where @var{infolist} is any item in
 545 @code{infolists} (such as @mrefcomma{values} @mrefcomma{functions} or
 546 @mref{arrays}) unbinds all items in @var{infolist}.
 547 See also @mrefdot{infolists}
 548
 549 @code{kill (all)} unbinds all items on all infolists.  @code{kill (all)} does
 550 not reset global variables to their default values; see @mref{reset} on this
 551 point.
 552
 553 @code{kill (allbut (@var{a_1}, ..., @var{a_n}))} unbinds all items on all
 554 infolists except for @var{a_1}, @dots{}, @var{a_n}.
 555 @code{kill (allbut (@var{infolist}))} unbinds all items except for the ones on
 556 @var{infolist}, where @var{infolist} is @mrefcomma{values}@w{}
 557 @mrefcomma{functions} @mrefcomma{arrays} etc.
 558
 559 The memory taken up by a bound property is not released until all symbols are
 560 unbound from it.  In particular, to release the memory taken up by the value of
 561 a symbol, one unbinds the output label which shows the bound value, as well as
 562 unbinding the symbol itself.
 563
 564 @code{kill} quotes its arguments.  The quote-quote operator @code{'@w{}'}
 565 defeats quotation.
 566
 567 @code{kill (@var{symbol})} unbinds all properties of @var{symbol}.  In contrast,
 568 the functions @mrefcomma{remvalue} @mrefcomma{remfunction}@w{}
 569 @mrefcomma{remarray} and @mref{remrule} unbind a specific property.
 570 Note that facts declared by @mref{assume} don't require a symbol they apply to,
 571 therefore aren't stored as properties of symbols and therefore aren't affected
 572 by @code{kill}.
 573
 574 @code{kill} always returns @code{done}, even if an argument has no binding.
 575
 576 @opencatbox{Categories:}
 577 @category{Evaluation}
 578 @category{Console interaction}
 579 @category{Session management}
 580 @closecatbox
 581 @end deffn
 582
 583 @c -----------------------------------------------------------------------------
 584 @anchor{labels}
 585 @deffn  {Function} labels (@var{symbol})
 586
 587 Returns the list of input, output, or intermediate expression labels which begin
 588 with @var{symbol}.  Typically @var{symbol} is the value of
 589 @mrefcomma{inchar} @mrefcomma{outchar} or @mrefdot{linechar}
 590 If no labels begin with @var{symbol}, @code{labels} returns an empty list.
 591
 592 By default, Maxima displays the result of each user input expression, giving the
 593 result an output label.  The output display is suppressed by terminating the
 594 input with @code{$} (dollar sign) instead of @code{;} (semicolon).  An output
 595 label is constructed and bound to the result, but not displayed, and the label
 596 may be referenced in the same way as displayed output labels.  See also
 597 @mrefcomma{%} @mrefcomma{%%} and @mrefdot{%th}
 598
 599 Intermediate expression labels can be generated by some functions.  The option
 600 variable @mref{programmode} controls whether @mref{solve} and some other
 601 functions generate intermediate expression labels instead of returning a list of
 602 expressions.  Some other functions, such as @mrefcomma{ldisplay} always generate
 603 intermediate expression labels.
 604
 605 See also @mrefcomma{inchar} @mrefcomma{outchar} @mrefcomma{linechar} and
 606 @mrefdot{infolists}
 607
 608 @opencatbox{Categories:}
 609 @category{Display functions}
 610 @category{Console interaction}
 611 @closecatbox
 612 @end deffn
 613
 614 @defvr {System variable} labels
 615
 616 The variable @code{labels} is the list of input, output, and intermediate
 617 expression labels, including all previous labels if @code{inchar},
 618 @code{outchar}, or @code{linechar} were redefined.
 619
 620 @opencatbox{Categories:}
 621 @category{Display flags and variables}
 622 @category{Console interaction}
 623 @closecatbox
 624 @end defvr
 625
 626 @c -----------------------------------------------------------------------------
 627 @anchor{linechar}
 628 @defvr {Option variable} linechar
 629 Default value: @code{%t}
 630
 631 @code{linechar} is the prefix of the labels of intermediate expressions
 632 generated by Maxima.  Maxima constructs a label for each intermediate expression
 633 (if displayed) by concatenating @code{linechar} and @mrefdot{linenum}
 634
 635 @code{linechar} may be assigned any string or symbol, not necessarily a single
 636 character.  Because Maxima internally takes into account only the first char of
 637 the prefix, the prefixes @mrefcomma{inchar} @mrefcomma{outchar} and
 638 @code{linechar} should have a different first char.  Otherwise some commands
 639 like @code{kill(inlabels)} do not work as expected.
 640
 641 Intermediate expressions might or might not be displayed.
 642 See @mref{programmode} and @mrefdot{labels}
 643
 644 @opencatbox{Categories:}
 645 @category{Display flags and variables}
 646 @closecatbox
 647 @end defvr
 648
 649 @c EXPAND; SHOW WHAT HAPPENS WHEN linenum IS ASSIGNED A VALUE
 650
 651 @c -----------------------------------------------------------------------------
 652 @anchor{linenum}
 653 @defvr {System variable} linenum
 654
 655 The line number of the current pair of input and output expressions.
 656
 657 @opencatbox{Categories:}
 658 @category{Display flags and variables}
 659 @category{Console interaction}
 660 @closecatbox
 661 @end defvr
 662
 663 @c NEEDS WORK
 664
 665 @c -----------------------------------------------------------------------------
 666 @anchor{myoptions}
 667 @defvr {System variable} myoptions
 668 Default value: @code{[]}
 669
 670 @code{myoptions} is the list of all options ever reset by the user,
 671 whether or not they get reset to their default value.
 672
 673 @opencatbox{Categories:}
 674 @category{Global variables}
 675 @category{Session management}
 676 @category{Console interaction}
 677 @closecatbox
 678 @end defvr
 679
 680 @c -----------------------------------------------------------------------------
 681 @anchor{nolabels}
 682 @defvr {Option variable} nolabels
 683 Default value: @code{false}
 684
 685 When @code{nolabels} is @code{true}, input and output result labels (@code{%i}
 686 and @code{%o}, respectively) are displayed, but the labels are not bound to
 687 results, and the labels are not appended to the @mref{labels} list.  Since
 688 labels are not bound to results, garbage collection can recover the memory taken
 689 up by the results.
 690
 691 Otherwise input and output result labels are bound to results, and the labels
 692 are appended to the @code{labels} list.
 693
 694 Intermediate expression labels (@code{%t}) are not affected by @code{nolabels};
 695 whether @code{nolabels} is @code{true} or @code{false}, intermediate expression
 696 labels are bound and appended to the @code{labels} list.
 697
 698 See also @mrefcomma{batch} @mrefcomma{load} and @mrefdot{labels}
 699
 700 @opencatbox{Categories:}
 701 @category{Global flags}
 702 @category{Session management}
 703 @closecatbox
 704 @end defvr
 705
 706 @c NEEDS WORK
 707
 708 @c -----------------------------------------------------------------------------
 709 @anchor{optionset}
 710 @defvr {Option variable} optionset
 711 Default value: @code{false}
 712
 713 When @code{optionset} is @code{true}, Maxima prints out a message whenever a
 714 Maxima option is reset.  This is useful if the user is doubtful of the spelling
 715 of some option and wants to make sure that the variable he assigned a value to
 716 was truly an option variable.
 717
 718 Example:
 719
 720 @example
 721 (%i1) optionset:true;
 722 assignment: assigning to option optionset
 723 (%o1)                         true
 724 (%i2) gamma_expand:true;
 725 assignment: assigning to option gamma_expand
 726 (%o2)                         true
 727 @end example
 728
 729 @opencatbox{Categories:}
 730 @category{Global flags}
 731 @category{Session management}
 732 @category{Console interaction}
 733 @closecatbox
 734 @end defvr
 735
 736 @c -----------------------------------------------------------------------------
 737 @need 800
 738 @anchor{outchar}
 739 @defvr {Option variable} outchar
 740 Default value: @code{%o}
 741
 742 @code{outchar} is the prefix of the labels of expressions computed by Maxima.
 743 Maxima automatically constructs a label for each computed expression by
 744 concatenating @code{outchar} and @mrefdot{linenum}
 745
 746 @code{outchar} may be assigned any string or symbol, not necessarily a single
 747 character.  Because Maxima internally takes into account only the first char of
 748 the prefix, the prefixes @mrefcomma{inchar} @code{outchar} and
 749 @mref{linechar} should have a different first char.  Otherwise some commands
 750 like @code{kill(inlabels)} do not work as expected.
 751
 752 See also @mref{labels}.
 753
 754 Example:
 755
 756 @c ===beg===
 757 @c outchar: "output";
 758 @c expand((a+b)^3);
 759 @c ===end===
 760 @example
 761 @group
 762 (%i1) outchar: "output";
 763 (output1)                    output
 764 @end group
 765 @group
 766 (%i2) expand((a+b)^3);
 767                      3        2      2      3
 768 (output2)           b  + 3 a b  + 3 a  b + a
 769 @end group
 770 @end example
 771
 772 @opencatbox{Categories:}
 773 @category{Display flags and variables}
 774 @closecatbox
 775 @end defvr
 776
 777 @c -----------------------------------------------------------------------------
 778 @anchor{playback}
 779 @deffn {Function} playback @
 780 @fname{playback} () @
 781 @fname{playback} (@var{n}) @
 782 @fname{playback} ([@var{m}, @var{n}]) @
 783 @fname{playback} ([@var{m}]) @
 784 @fname{playback} (input) @
 785 @fname{playback} (slow) @
 786 @fname{playback} (time) @
 787 @fname{playback} (grind)
 788
 789 Displays input, output, and intermediate expressions, without recomputing them.
 790 @code{playback} only displays the expressions bound to labels; any other output
 791 (such as text printed by @mref{print} or @mrefcomma{describe} or error messages)
 792 is not displayed.  See also @mrefdot{labels}
 793
 794 @code{playback} quotes its arguments.  The quote-quote operator @code{'@w{}'}
 795 defeats quotation.  @code{playback} always returns @code{done}.
 796
 797 @code{playback ()} (with no arguments) displays all input, output, and
 798 intermediate expressions generated so far.  An output expression is displayed
 799 even if it was suppressed by the @code{$} terminator when it was originally
 800 computed.
 801
 802 @code{playback (@var{n})} displays the most recent @var{n} expressions.
 803 Each input, output, and intermediate expression counts as one.
 804
 805 @code{playback ([@var{m}, @var{n}])} displays input, output, and intermediate
 806 expressions with numbers from @var{m} through @var{n}, inclusive.
 807
 808 @code{playback ([@var{m}])} is equivalent to
 809 @code{playback ([@var{m}, @var{m}])}; this usually prints one pair of input and
 810 output expressions.
 811
 812 @code{playback (input)} displays all input expressions generated so far.
 813
 814 @code{playback (slow)} pauses between expressions and waits for the user to
 815 press @code{enter}.  This behavior is similar to @mrefdot{demo}
 816 @c WHAT DOES THE FOLLOWING MEAN ???
 817 @code{playback (slow)} is useful in conjunction with @code{save} or
 818 @mref{stringout} when creating a secondary-storage file in order to pick out
 819 useful expressions.
 820
 821 @code{playback (time)} displays the computation time for each expression.
 822 @c DON'T BOTHER TO MENTION OBSOLETE OPTIONS !!!
 823 @c The arguments @code{gctime} and @code{totaltime} have the same effect as @code{time}.
 824
 825 @code{playback (grind)} displays input expressions in the same format as the
 826 @code{grind} function.  Output expressions are not affected by the @code{grind}
 827 option.  See @mrefdot{grind}
 828
 829 Arguments may be combined, e.g., @code{playback ([5, 10], grind, time, slow)}.
 830 @c APPEARS TO BE input INTERSECT (UNION OF ALL OTHER ARGUMENTS). CORRECT ???
 831
 832 @opencatbox{Categories:}
 833 @category{Display functions}
 834 @category{Console interaction}
 835 @closecatbox
 836 @end deffn
 837
 838 @c -----------------------------------------------------------------------------
 839 @need 800
 840 @anchor{prompt}
 841 @defvr {Option variable} prompt
 842 Default value: @code{_}
 843
 844 @code{prompt} is the prompt symbol of the @mref{demo} function,
 845 @code{playback (slow)} mode, and the Maxima break loop (as invoked by
 846 @mref{break}).
 847
 848 @opencatbox{Categories:}
 849 @category{Global variables}
 850 @category{Console interaction}
 851 @closecatbox
 852 @end defvr
 853
 854 @c -----------------------------------------------------------------------------
 855 @anchor{quit}
 856 @deffn {Function} quit ()
 857
 858 Terminates the Maxima session.  Note that the function must be invoked as
 859 @code{quit();} or @code{quit()$}, not @code{quit} by itself.
 860
 861 To stop a lengthy computation, type @code{control-C}.  The default action is to
 862 return to the Maxima prompt.  If @code{*debugger-hook*} is @code{nil},
 863 @code{control-C} opens the Lisp debugger.  See also @ref{Debugging}.
 864
 865 @opencatbox{Categories:}
 866 @category{Console interaction}
 867 @closecatbox
 868 @end deffn
 869
 870 @c -----------------------------------------------------------------------------
 871 @anchor{read}
 872 @deffn {Function} read (@var{expr_1}, @dots{}, @var{expr_n})
 873
 874 Prints @var{expr_1}, @dots{}, @var{expr_n}, then reads one expression from the
 875 console and returns the evaluated expression.  The expression is terminated with
 876 a semicolon @code{;} or dollar sign @code{$}.
 877
 878 See also @mref{readonly}
 879
 880 Example:
 881
 882 @example
 883 (%i1) foo: 42$
 884 (%i2) foo: read ("foo is", foo, " -- enter new value.")$
 885 foo is 42  -- enter new value.
 886 (a+b)^3;
 887 (%i3) foo;
 888                                      3
 889 (%o3)                         (b + a)
 890 @end example
 891
 892 @opencatbox{Categories:}
 893 @category{Console interaction}
 894 @closecatbox
 895 @end deffn
 896
 897 @c -----------------------------------------------------------------------------
 898 @anchor{readonly}
 899 @deffn {Function} readonly (@var{expr_1}, @dots{}, @var{expr_n})
 900
 901 Prints @var{expr_1}, @dots{}, @var{expr_n}, then reads one expression from the
 902 console and returns the expression (without evaluation).  The expression is
 903 terminated with a @code{;} (semicolon) or @code{$} (dollar sign).
 904
 905 See also @mrefdot{read}
 906
 907 Examples:
 908
 909 @example
 910 (%i1) aa: 7$
 911 (%i2) foo: readonly ("Enter an expression:");
 912 Enter an expression:
 913 2^aa;
 914                                   aa
 915 (%o2)                            2
 916 (%i3) foo: read ("Enter an expression:");
 917 Enter an expression:
 918 2^aa;
 919 (%o3)                            128
 920 @end example
 921
 922 @opencatbox{Categories:}
 923 @category{Console interaction}
 924 @closecatbox
 925 @end deffn
 926
 927 @c -----------------------------------------------------------------------------
 928 @anchor{reset}
 929 @deffn {Function} reset ()
 930
 931 Resets many global variables and options, and some other variables, to their
 932 default values.
 933
 934 @code{reset} processes the variables on the Lisp list
 935 @code{*variable-initial-values*}.  The Lisp macro @code{defmvar} puts variables
 936 on this list (among other actions).  Many, but not all, global variables and
 937 options are defined by @code{defmvar}, and some variables defined by
 938 @code{defmvar} are not global variables or options.
 939
 940 @opencatbox{Categories:}
 941 @category{Session management}
 942 @closecatbox
 943 @end deffn
 944
 945 @c -----------------------------------------------------------------------------
 946 @anchor{showtime}
 947 @defvr {Option variable} showtime
 948 Default value: @code{false}
 949
 950 When @code{showtime} is @code{true}, the computation time and elapsed time is
 951 printed with each output expression.
 952
 953 The computation time is always recorded, so @mref{time} and @mref{playback} can
 954 display the computation time even when @code{showtime} is @code{false}.
 955
 956 See also @mrefdot{timer}
 957
 958 @opencatbox{Categories:}
 959 @category{Display flags and variables}
 960 @category{Debugging}
 961 @closecatbox
 962 @end defvr
 963
 964 @c -----------------------------------------------------------------------------
 965 @anchor{to_lisp}
 966 @deffn {Function} to_lisp ()
 967
 968 Enters the Lisp system under Maxima.  @code{(to-maxima)} returns to Maxima.
 969
 970 Example:
 971
 972 Define a function and enter the Lisp system under Maxima.  The definition is
 973 inspected on the property list, then the function definition is extracted,
 974 factored and stored in the variable @code{$result}.  The variable can be used in Maxima
 975 after returning to Maxima.
 976
 977 @example
 978 (%i1) f(x):=x^2+x;
 979                                   2
 980 (%o1)                    f(x) := x  + x
 981 (%i2) to_lisp();
 982 Type (to-maxima) to restart, ($quit) to quit Maxima.
 983 MAXIMA> (symbol-plist '$f)
 984 (MPROPS (NIL MEXPR ((LAMBDA) ((MLIST) $X)
 985                              ((MPLUS) ((MEXPT) $X 2) $X))))
 986 MAXIMA> (setq $result ($factor (caddr (mget '$f 'mexpr))))
 987 ((MTIMES SIMP FACTORED) $X ((MPLUS SIMP IRREDUCIBLE) 1 $X))
 988 MAXIMA> (to-maxima)
 989 Returning to Maxima
 990 (%o2)                         true
 991 (%i3) result;
 992 (%o3)                       x (x + 1)
 993 @end example
 994
 995 @opencatbox{Categories:}
 996 @category{Console interaction}
 997 @closecatbox
 998 @end deffn
 999
1000 @c -----------------------------------------------------------------------------
1001 @anchor{eval_string_lisp}
1002 @deffn {Function} eval_string_lisp (@var{str})
1003
1004 Sequentially read lisp forms from the string @var{str} and evaluate them.
1005 Any values produced from the last form are returned as a Maxima list.
1006
1007 Examples:
1008
1009 @c ===beg===
1010 @c eval_string_lisp ("");
1011 @c eval_string_lisp ("(values)");
1012 @c eval_string_lisp ("69");
1013 @c eval_string_lisp ("1 2 3");
1014 @c eval_string_lisp ("(values 1 2 3)");
1015 @c eval_string_lisp ("(defun $foo (x) (* 2 x))");
1016 @c foo (5);
1017 @c ===end===
1018 @example
1019 @group
1020 (%i1) eval_string_lisp ("");
1021 (%o1) []
1022 @end group
1023 @group
1024 (%i2) eval_string_lisp ("(values)");
1025 (%o2) []
1026 @end group
1027 @group
1028 (%i3) eval_string_lisp ("69");
1029 (%o3) [69]
1030 @end group
1031 @group
1032 (%i4) eval_string_lisp ("1 2 3");
1033 (%o4) [3]
1034 @end group
1035 @group
1036 (%i5) eval_string_lisp ("(values 1 2 3)");
1037 (%o5) [1,2,3]
1038 @end group
1039 @group
1040 (%i6) eval_string_lisp ("(defun $foo (x) (* 2 x))");
1041 (%o6) [foo]
1042 @end group
1043 @group
1044 (%i7) foo (5);
1045 (%o7) 10
1046 @end group
1047 @end example
1048
1049 See also @ref{eval_string}.
1050
1051 @opencatbox{Categories:}
1052 @category{Debugging}
1053 @category{Evaluation}
1054 @closecatbox
1055
1056 @end deffn
1057
1058 @c -----------------------------------------------------------------------------
1059 @anchor{values}
1060 @defvr {System variable} values
1061 Initial value: @code{[]}
1062
1063 @code{values} is a list of all bound user variables (not Maxima options or
1064 switches).  The list comprises symbols bound by @mrefcomma{:} or @mrefdot{::}
1065
1066 If the value of a variable is removed with the commands @code{kill},
1067 @mrefcomma{remove} or @mref{remvalue} the variable is deleted from
1068 @code{values}.
1069
1070 See @mref{functions} for a list of user defined functions.
1071
1072 Examples:
1073
1074 First, @code{values} shows the symbols @code{a}, @code{b}, and @code{c}, but
1075 not @code{d}, it is not bound to a value, and not the user function @code{f}.
1076 The values are removed from the variables.  @code{values} is the empty list.
1077
1078 @c ===beg===
1079 @c [a:99, b:: a-90, c:a-b, d, f(x):=x^2];
1080 @c values;
1081 @c [kill(a), remove(b,value), remvalue(c)];
1082 @c values;
1083 @c ===end===
1084 @example
1085 @group
1086 (%i1) [a:99, b:: a-90, c:a-b, d, f(x):=x^2];
1087                                            2
1088 (%o1)              [99, 9, 90, d, f(x) := x ]
1089 @end group
1090 @group
1091 (%i2) values;
1092 (%o2)                       [a, b, c]
1093 @end group
1094 @group
1095 (%i3) [kill(a), remove(b,value), remvalue(c)];
1096 (%o3)                   [done, done, [c]]
1097 @end group
1098 @group
1099 (%i4) values;
1100 (%o4)                          []
1101 @end group
1102 @end example
1103
1104 @opencatbox{Categories:}
1105 @category{Evaluation}
1106 @category{Global variables}
1107 @closecatbox
1108 @end defvr
1109
1110 @c -----------------------------------------------------------------------------
1111 @node Functions and Variables for Display, , Functions and Variables for Command Line, Command Line
1112 @section Functions and Variables for Display
1113 @c -----------------------------------------------------------------------------
1114
1115 @c -----------------------------------------------------------------------------
1116 @anchor{%edispflag}
1117 @defvr {Option variable} %edispflag
1118 Default value: @code{false}
1119
1120 When @code{%edispflag} is @code{true}, Maxima displays @code{%e} to a negative
1121 exponent as a quotient.  For example, @code{%e^-x} is displayed as
1122 @code{1/%e^x}.  See also @mrefdot{exptdispflag}
1123
1124 Example:
1125
1126 @c ===beg===
1127 @c %e^-10;
1128 @c %edispflag:true$
1129 @c %e^-10;
1130 @c ===end===
1131 @example
1132 @group
1133 (%i1) %e^-10;
1134                                - 10
1135 (%o1)                        %e
1136 @end group
1137 (%i2) %edispflag:true$
1138 @group
1139 (%i3) %e^-10;
1140                                1
1141 (%o3)                         ----
1142                                 10
1143                               %e
1144 @end group
1145 @end example
1146
1147 @opencatbox{Categories:}
1148 @category{Exponential and logarithm functions}
1149 @category{Display flags and variables}
1150 @closecatbox
1151 @end defvr
1152
1153 @c -----------------------------------------------------------------------------
1154 @anchor{absboxchar}
1155 @defvr {Option variable} absboxchar
1156 Default value: @code{!}
1157
1158 @code{absboxchar} is the character used to draw absolute value
1159 signs around expressions which are more than one line tall.
1160
1161 Example:
1162
1163 @example
1164 (%i1) abs((x^3+1));
1165                             ! 3    !
1166 (%o1)                       !x  + 1!
1167 @end example
1168
1169 @opencatbox{Categories:}
1170 @category{Display flags and variables}
1171 @closecatbox
1172 @end defvr
1173
1174 @c AFTER REVIEWING src/displa.lisp, IT LOOKS LIKE THIS VARIABLE HAS NO EFFECT
1175 @c CUT IT ON THE NEXT PASS
1176 @c @defvar cursordisp
1177 @c Default value: @code{true}
1178 @c
1179 @c When @code{cursordisp} is @code{true}, expressions are drawn by
1180 @c the displayer in logical sequence.  This only works with a console
1181 @c which can do cursor movement.  If @code{false}, expressions are
1182 @c printed line by line.
1183 @c
1184 @c @code{cursordisp} is always @code{false} when a @code{writefile} is in
1185 @c effect.
1186 @c
1187 @c @end defvar
1188
1189 @c -----------------------------------------------------------------------------
1190 @anchor{declare_index_properties}
1191 @deffn {Function} declare_index_properties (@var{a}, [@var{p_1}, @var{p_2}, @var{p_3}, ...])
1192 @deffnx {Function} declare_index_properties ([@var{a}, @var{b}, @var{c}, ...], [@var{p_1}, @var{p_2}, @var{p_3}, ...])
1193 @deffnx {Symbol} postsubscript
1194 @deffnx {Symbol} postsuperscript
1195 @deffnx {Symbol} presuperscript
1196 @deffnx {Symbol} presubscript
1197
1198 Declares the properties of indices applied to the symbol @var{a}
1199 or each of the of symbols @var{a}, @var{b}, @var{c}, ....
1200 If multiple symbols are given,
1201 the whole list of properties applies to each symbol.
1202
1203 Given a symbol with indices, @code{@var{a}[@var{i_1}, @var{i_2}, @var{i_3}, ...]},
1204 the @code{k}-th property @var{p_k} applies to the @code{k}-th index @var{i_k}.
1205 There may be any number of index properties, in any order.
1206
1207 Each property @var{p_k} must one of these four recognized properties:
1208 @code{postsubscript}, @code{postsuperscript}, @code{presuperscript}, or @code{presubscript},
1209 to denote indices which are displayed, respectively,
1210 to the right and below, to the right and above, to the left and above, or to the left and below.
1211
1212 Index properties apply only to the 2-dimensional display of indexed variables
1213 (i.e., when @mref{display2d} is @code{true})
1214 and TeX output via @code{tex}.
1215 Otherwise, index properties are ignored.
1216 Index properties do not change the input of indexed variables,
1217 do not change the algebraic properties of indexed variables,
1218 and do not change the 1-dimensional display of indexed variables.
1219
1220 @code{declare_index_properties} quotes (does not evaluate) its arguments.
1221
1222 @code{remove_index_properties} removes index properties.
1223 @code{kill} also removes index properties (and all other properties).
1224
1225 @code{get_index_properties} retrieves index properties.
1226
1227 Examples:
1228
1229 Given a symbol with indices, @code{@var{a}[@var{i_1}, @var{i_2}, @var{i_3}, ...]},
1230 the @code{k}-th property @var{p_k} applies to the @code{k}-th index @var{i_k}.
1231 There may be any number of index properties, in any order.
1232
1233 @c ===beg===
1234 @c declare_index_properties (A, [presubscript, postsubscript]);
1235 @c declare_index_properties (B, [postsuperscript, postsuperscript,
1236 @c  presuperscript]);
1237 @c declare_index_properties (C, [postsuperscript, presubscript,
1238 @c  presubscript, presuperscript]);
1239 @c A[w, x];
1240 @c B[w, x, y];
1241 @c C[w, x, y, z];
1242 @c ===end===
1243 @example
1244 @group
1245 (%i1) declare_index_properties (A, [presubscript, postsubscript]);
1246 (%o1)                         done
1247 @end group
1248 @group
1249 (%i2) declare_index_properties (B, [postsuperscript, postsuperscript,
1250  presuperscript]);
1251 (%o2)                         done
1252 @end group
1253 @group
1254 (%i3) declare_index_properties (C, [postsuperscript, presubscript,
1255  presubscript, presuperscript]);
1256 (%o3)                         done
1257 @end group
1258 @group
1259 (%i4) A[w, x];
1260 (%o4)                           A
1261                                w x
1262 @end group
1263 @group
1264 (%i5) B[w, x, y];
1265                              y w, x
1266 (%o5)                         B
1267 @end group
1268 @group
1269 (%i6) C[w, x, y, z];
1270                                 z w
1271 (%o6)                            C
1272                              x, y
1273 @end group
1274 @end example
1275
1276 Index properties apply only to the 2-dimensional display of indexed variables and TeX output.
1277 Otherwise, index properties are ignored.
1278
1279 @c ===beg===
1280 @c declare_index_properties (A, [presubscript, postsubscript]);
1281 @c A[w, x];
1282 @c tex (A[w, x]);
1283 @c display2d: false $
1284 @c A[w, x];
1285 @c display2d: true $
1286 @c grind (A[w, x]);
1287 @c stringdisp: true $
1288 @c string (A[w, x]);
1289 @c ===end===
1290 @example
1291 @group
1292 (%i1) declare_index_properties (A, [presubscript, postsubscript]);
1293 (%o1)                         done
1294 @end group
1295 @group
1296 (%i2) A[w, x];
1297 (%o2)                           A
1298                                w x
1299 @end group
1300 @group
1301 (%i3) tex (A[w, x]);
1302 $$@{@}_@{w@}A_@{x@}$$
1303 (%o3)                         false
1304 @end group
1305 (%i4) display2d: false $
1306 @group
1307 (%i5) A[w, x];
1308 (%o5) A[w,x]
1309 @end group
1310 (%i6) display2d: true $
1311 @group
1312 (%i7) grind (A[w, x]);
1313 A[w,x]$
1314 (%o7)                         done
1315 @end group
1316 (%i8) stringdisp: true $
1317 @group
1318 (%i9) string (A[w, x]);
1319 (%o9)                       "A[w,x]"
1320 @end group
1321 @end example
1322
1323 @opencatbox{Categories:}
1324 @category{Display flags and variables}
1325 @closecatbox
1326 @end deffn
1327
1328 @c -----------------------------------------------------------------------------
1329 @anchor{get_index_properties}
1330 @deffn {Function} get_index_properties (@var{a})
1331
1332 Returns the properties for @var{a} established by @code{declare_index_properties}.
1333
1334 See also @mrefdot{remove_index_properties}
1335
1336 @opencatbox{Categories:}
1337 @category{Display flags and variables}
1338 @closecatbox
1339 @end deffn
1340
1341 @c -----------------------------------------------------------------------------
1342 @anchor{remove_index_properties}
1343 @deffn {Function} remove_index_properties (@var{a}, @var{b}, @var{c}, ...)
1344
1345 Removes the properties established by @code{declare_index_properties}.
1346 All index properties are removed from each symbol @var{a}, @var{b}, @var{c}, ....
1347
1348 @code{remove_index_properties} quotes (does not evaluate) its arguments.
1349
1350 @opencatbox{Categories:}
1351 @category{Display flags and variables}
1352 @closecatbox
1353 @end deffn
1354
1355 @c -----------------------------------------------------------------------------
1356 @anchor{display_index_separator}
1357 @defvr {Symbol property} display_index_separator
1358
1359 When a symbol @var{A} has index display properties declared via @code{declare_index_properties},
1360 the value of the property @code{display_index_separator}
1361 is the string or other expression which is displayed between indices.
1362
1363 The value of @code{display_index_separator}
1364 is assigned by @code{put(@var{A}, @var{S}, display_index_separator)},
1365 where @var{S} is a string or other expression.
1366 The assigned value is retrieved by @code{get(@var{A}, display_index_separator)}.
1367
1368 The display index separator @var{S} can be a string, including an empty string,
1369 or @code{false}, indicating the default separator, or any expression.
1370 If not a string and not @code{false}, the property value is coerced to a string via @code{string}.
1371
1372 If no display index separator is assigned, the default separator is used.
1373 The default separator is a comma.
1374 There is no way to change the default separator.
1375
1376 Each symbol has its own value of @code{display_index_separator}.
1377
1378 See also @mref{put}, @mref{get}, and @mrefdot{declare_index_properties}
1379
1380 Examples:
1381
1382 When a symbol @var{A} has index display properties,
1383 the value of the property @code{display_index_separator}
1384 is the string or other expression which is displayed between indices.
1385 The value is assigned by @code{put(@var{A}, @var{S}, display_index_separator)},
1386
1387 @c ===beg===
1388 @c declare_index_properties (A, [postsuperscript, postsuperscript,
1389 @c  presubscript, presubscript]);
1390 @c put (A, ";", display_index_separator);
1391 @c A[w, x, y, z];
1392 @c ===end===
1393 @example
1394 @group
1395 (%i1) declare_index_properties (A, [postsuperscript, postsuperscript,
1396  presubscript, presubscript]);
1397 (%o1)                         done
1398 @end group
1399 @group
1400 (%i2) put (A, ";", display_index_separator);
1401 (%o2)                           ;
1402 @end group
1403 @group
1404 (%i3) A[w, x, y, z];
1405                                  w;x
1406 (%o3)                           A
1407                              y;z
1408 @end group
1409 @end example
1410
1411 The assigned value is retrieved by @code{get(@var{A}, display_index_separator)}.
1412
1413 @c ===beg===
1414 @c declare_index_properties (A, [postsuperscript, postsuperscript,
1415 @c  presubscript, presubscript]);
1416 @c put (A, ";", display_index_separator);
1417 @c get (A, display_index_separator);
1418 @c ===end===
1419 @example
1420 @group
1421 (%i1) declare_index_properties (A, [postsuperscript, postsuperscript,
1422  presubscript, presubscript]);
1423 (%o1)                         done
1424 @end group
1425 @group
1426 (%i2) put (A, ";", display_index_separator);
1427 (%o2)                           ;
1428 @end group
1429 @group
1430 (%i3) get (A, display_index_separator);
1431 (%o3)                           ;
1432 @end group
1433 @end example
1434
1435 The display index separator @var{S} can be a string, including an empty string,
1436 or @code{false}, indicating the default separator, or any expression.
1437
1438 @c ===beg===
1439 @c declare_index_properties (A, [postsuperscript, postsuperscript,
1440 @c  presubscript, presubscript]);
1441 @c A[w, x, y, z];
1442 @c put (A, "-", display_index_separator);
1443 @c A[w, x, y, z];
1444 @c put (A, " ", display_index_separator);
1445 @c A[w, x, y, z];
1446 @c put (A, "", display_index_separator);
1447 @c A[w, x, y, z];
1448 @c put (A, false, display_index_separator);
1449 @c A[w, x, y, z];
1450 @c put (A, 'foo, display_index_separator);
1451 @c A[w, x, y, z];
1452 @c ===end===
1453 @example
1454 @group
1455 (%i1) declare_index_properties (A, [postsuperscript, postsuperscript,
1456  presubscript, presubscript]);
1457 (%o1)                         done
1458 @end group
1459 @group
1460 (%i2) A[w, x, y, z];
1461                                  w, x
1462 (%o2)                           A
1463                             y, z
1464 @end group
1465 @group
1466 (%i3) put (A, "-", display_index_separator);
1467 (%o3)                           -
1468 @end group
1469 @group
1470 (%i4) A[w, x, y, z];
1471                                  w-x
1472 (%o4)                           A
1473                              y-z
1474 @end group
1475 @group
1476 (%i5) put (A, " ", display_index_separator);
1477 (%o5)
1478 @end group
1479 @group
1480 (%i6) A[w, x, y, z];
1481                                  w x
1482 (%o6)                           A
1483                              y z
1484 @end group
1485 @group
1486 (%i7) put (A, "", display_index_separator);
1487 (%o7)
1488 @end group
1489 @group
1490 (%i8) A[w, x, y, z];
1491                                  wx
1492 (%o8)                           A
1493                               yz
1494 @end group
1495 @group
1496 (%i9) put (A, false, display_index_separator);
1497 (%o9)                         false
1498 @end group
1499 @group
1500 (%i10) A[w, x, y, z];
1501                                  w, x
1502 (%o10)                          A
1503                             y, z
1504 @end group
1505 @group
1506 (%i11) put (A, 'foo, display_index_separator);
1507 (%o11)                         foo
1508 @end group
1509 @group
1510 (%i12) A[w, x, y, z];
1511                                  wfoox
1512 (%o12)                          A
1513                            yfooz
1514 @end group
1515 @end example
1516
1517 If no display index separator is assigned, the default separator is used.
1518 The default separator is a comma.
1519
1520 @c ===beg===
1521 @c declare_index_properties (A, [postsuperscript, postsuperscript,
1522 @c  presubscript, presubscript]);
1523 @c A[w, x, y, z];
1524 @c ===end===
1525 @example
1526 @group
1527 (%i1) declare_index_properties (A, [postsuperscript, postsuperscript,
1528  presubscript, presubscript]);
1529 (%o1)                         done
1530 @end group
1531 @group
1532 (%i2) A[w, x, y, z];
1533                                  w, x
1534 (%o2)                           A
1535                             y, z
1536 @end group
1537 @end example
1538
1539 Each symbol has its own value of @code{display_index_separator}.
1540
1541 @c ===beg===
1542 @c declare_index_properties (A, [postsuperscript, postsuperscript,
1543 @c  presubscript, presubscript]);
1544 @c put (A, " ", display_index_separator);
1545 @c declare_index_properties (B, [presuperscript, presuperscript,
1546 @c  postsubscript, postsubscript]);
1547 @c put (B, ";", display_index_separator);
1548 @c A[w, x, y, z] + B[w, x, y, z];
1549 @c ===end===
1550 @example
1551 @group
1552 (%i1) declare_index_properties (A, [postsuperscript, postsuperscript,
1553  presubscript, presubscript]);
1554 (%o1)                         done
1555 @end group
1556 @group
1557 (%i2) put (A, " ", display_index_separator);
1558 (%o2)
1559 @end group
1560 @group
1561 (%i3) declare_index_properties (B, [postsuperscript, postsuperscript, presubscript, presubscript]);
1562 (%o3)                         done
1563 @end group
1564 @group
1565 (%i4) put (B, ";", display_index_separator);
1566 (%o4)                           ;
1567 @end group
1568 @group
1569 (%i5) A[w, x, y, z] + B[w, x, y, z];
1570                             w;x       w x
1571 (%o5)                      B    +    A
1572                         y;z       y z
1573 @end group
1574 @end example
1575
1576 @opencatbox{Categories:}
1577 @category{Display flags and variables}
1578 @closecatbox
1579 @end defvr
1580
1581 @c -----------------------------------------------------------------------------
1582 @anchor{disp}
1583 @deffn {Function} disp (@var{expr_1}, @var{expr_2}, @dots{})
1584
1585 is like @mref{display} but only the value of the arguments are displayed rather
1586 than equations.  This is useful for complicated arguments which don't have names
1587 or where only the value of the argument is of interest and not the name.
1588
1589 See also @mref{ldisp} and @mrefdot{print}
1590
1591 Example:
1592
1593 @c ===beg===
1594 @c b[1,2]:x-x^2$
1595 @c x:123$
1596 @c disp(x, b[1,2], sin(1.0));
1597 @c ===end===
1598 @example
1599 (%i1) b[1,2]:x-x^2$
1600 (%i2) x:123$
1601 @group
1602 (%i3) disp(x, b[1,2], sin(1.0));
1603                                123
1604
1605                                   2
1606                              x - x
1607
1608                        0.8414709848078965
1609
1610 (%o3)                         done
1611 @end group
1612 @end example
1613
1614 @opencatbox{Categories:}
1615 @category{Display functions}
1616 @closecatbox
1617 @end deffn
1618
1619 @c -----------------------------------------------------------------------------
1620 @anchor{display}
1621 @deffn {Function} display (@var{expr_1}, @var{expr_2}, @dots{})
1622
1623 Displays equations whose left side is @var{expr_i} unevaluated, and whose right
1624 side is the value of the expression centered on the line.  This function is
1625 useful in blocks and @mref{for} statements in order to have intermediate results
1626 displayed.  The arguments to @code{display} are usually atoms, subscripted
1627 variables, or function calls.
1628
1629 See also @mrefcomma{ldisplay} @mrefcomma{disp} and @mrefdot{ldisp}
1630
1631 Example:
1632
1633 @c ===beg===
1634 @c b[1,2]:x-x^2$
1635 @c x:123$
1636 @c display(x, b[1,2], sin(1.0));
1637 @c ===end===
1638 @example
1639 (%i1) b[1,2]:x-x^2$
1640 (%i2) x:123$
1641 @group
1642 (%i3) display(x, b[1,2], sin(1.0));
1643                              x = 123
1644
1645                                       2
1646                          b     = x - x
1647                           1, 2
1648
1649                   sin(1.0) = 0.8414709848078965
1650
1651 (%o3)                         done
1652 @end group
1653 @end example
1654
1655 @opencatbox{Categories:}
1656 @category{Display functions}
1657 @closecatbox
1658 @end deffn
1659
1660 @c -----------------------------------------------------------------------------
1661 @anchor{display2d}
1662 @defvr {Option variable} display2d
1663 Default value: @code{true}
1664
1665 When @code{display2d} is @code{true},
1666 the console display is an attempt to present mathematical expressions
1667 as they might appear in books and articles,
1668 using only letters, numbers, and some punctuation characters.
1669 This display is sometimes called the "pretty printer" display.
1670
1671 When @code{display2d} is @code{true},
1672 Maxima attempts to honor the global variable for line length, @code{linel}.
1673 When an atom (symbol, number, or string) would otherwise cause a line to exceed @code{linel},
1674 the atom may be printed in pieces on successive lines,
1675 with a continuation character (backslash, @code{\}) at the end of the leading piece;
1676 however, in some cases, such atoms are printed without a line break,
1677 and the length of the line is greater than @code{linel}.
1678
1679 When @code{display2d} is @code{false},
1680 the console display is a 1-dimensional or linear form
1681 which is the same as the output produced by @code{grind}.
1682
1683 When @code{display2d} is @code{false},
1684 the value of @mref{stringdisp} is ignored,
1685 and strings are always displayed with quote marks.
1686
1687 When @code{display2d} is @code{false},
1688 Maxima attempts to honor @code{linel},
1689 but atoms are not broken across lines,
1690 and the actual length of an output line may exceed @code{linel}.
1691
1692 See also @mref{leftjust} to switch between a left justified and a centered
1693 display of equations.
1694
1695 Example:
1696
1697 @c ===beg===
1698 @c x/(x^2+1);
1699 @c display2d:false$
1700 @c x/(x^2+1);
1701 @c ===end===
1702 @example
1703 @group
1704 (%i1) x/(x^2+1);
1705                                x
1706 (%o1)                        ------
1707                               2
1708                              x  + 1
1709 @end group
1710 (%i2) display2d:false$
1711 @group
1712 (%i3) x/(x^2+1);
1713 (%o3) x/(x^2+1)
1714 @end group
1715 @end example
1716
1717 @opencatbox{Categories:}
1718 @category{Display flags and variables}
1719 @closecatbox
1720 @end defvr
1721
1722 @c -----------------------------------------------------------------------------
1723 @anchor{display_format_internal}
1724 @defvr {Option variable} display_format_internal
1725 Default value: @code{false}
1726
1727 When @code{display_format_internal} is @code{true}, expressions are displayed
1728 without being transformed in ways that hide the internal mathematical
1729 representation.  The display then corresponds to what @mref{inpart} returns
1730 rather than @mrefdot{part}
1731
1732 Examples:
1733
1734 @example
1735 User     part       inpart
1736 a-b;      a - b     a + (- 1) b
1737
1738            a            - 1
1739 a/b;       -         a b
1740            b
1741                        1/2
1742 sqrt(x);   sqrt(x)    x
1743
1744           4 X        4
1745 X*4/3;    ---        - X
1746            3         3
1747 @end example
1748
1749 @opencatbox{Categories:}
1750 @category{Display flags and variables}
1751 @closecatbox
1752 @end defvr
1753
1754 @c -----------------------------------------------------------------------------
1755 @anchor{with_default_2d_display}
1756 @deffn {Function} with_default_2d_display (expr)
1757
1758 While maxima by default realizes 2d Output using ASCII-Art some frontend
1759 change that to TeX, MathML or a specific XML dialect that better suits
1760 the needs for this specific frontend. @code{with_default_2d_display}
1761 temporarily switches maxima to the default 2D ASCII Art formatter for
1762 outputting the result of @code{expr}.
1763
1764 See also @mref{set_alt_display} and @mrefdot{display2d}
1765
1766 @opencatbox{Categories:}
1767 @category{Display functions}
1768 @closecatbox
1769 @end deffn
1770
1771 @c IS THIS FUNCTION STILL USEFUL ???
1772 @c REPHRASE, NEEDS EXAMPLES
1773
1774 @c -----------------------------------------------------------------------------
1775 @anchor{dispterms}
1776 @deffn {Function} dispterms (@var{expr})
1777
1778 Displays @var{expr} in parts one below the other.  That is, first the operator
1779 of @var{expr} is displayed, then each term in a sum, or factor in a product, or
1780 part of a more general expression is displayed separately.  This is useful if
1781 @var{expr} is too large to be otherwise displayed.  For example if @code{P1},
1782 @code{P2}, @dots{}  are very large expressions then the display program may run
1783 out of storage space in trying to display @code{P1 + P2 + ...}  all at once.
1784 However, @code{dispterms (P1 + P2 + ...)} displays @code{P1}, then below it
1785 @code{P2}, etc.  When not using @code{dispterms}, if an exponential expression
1786 is too wide to be displayed as @code{A^B} it appears as @code{expt (A, B)} (or
1787 as @code{ncexpt (A, B)} in the case of @code{A^^B}).
1788
1789 Example:
1790
1791 @example
1792 (%i1) dispterms(2*a*sin(x)+%e^x);
1793
1794 +
1795
1796 2 a sin(x)
1797
1798   x
1799 %e
1800
1801 (%o1)                         done
1802 @end example
1803
1804 @opencatbox{Categories:}
1805 @category{Display functions}
1806 @closecatbox
1807 @end deffn
1808
1809 @c -----------------------------------------------------------------------------
1810 @anchor{expt}
1811 @anchor{ncexpt}
1812 @deffn  {Special symbol} expt (@var{a}, @var{b})
1813 @deffnx {Special symbol} ncexpt (@var{a}, @var{b})
1814
1815 If an exponential expression is too wide to be displayed as
1816 @code{@var{a}^@var{b}} it appears as @code{expt (@var{a}, @var{b})} (or as
1817 @code{ncexpt (@var{a}, @var{b})} in the case of @code{@var{a}^^@var{b}}).
1818
1819 @c THIS SEEMS LIKE A BUG TO ME.  expt, ncexpt SHOULD BE RECOGNIZED SINCE MAXIMA
1820 @c ITSELF PRINTS THEM SOMETIMES.  THESE SHOULD JUST SIMPLIFY TO ^ AND ^^,
1821 @c RESPECTIVELY.
1822 @code{expt} and @code{ncexpt} are not recognized in input.
1823 @end deffn
1824
1825 @c -----------------------------------------------------------------------------
1826 @anchor{exptdispflag}
1827 @defvr {Option variable} exptdispflag
1828 Default value: @code{true}
1829
1830 When @code{exptdispflag} is @code{true}, Maxima displays expressions
1831 with negative exponents using quotients.  See also @mrefdot{%edispflag}
1832
1833 Example:
1834
1835 @example
1836 (%i1) exptdispflag:true;
1837 (%o1)                         true
1838 (%i2) 10^-x;
1839                                 1
1840 (%o2)                          ---
1841                                  x
1842                                10
1843 (%i3) exptdispflag:false;
1844 (%o3)                         false
1845 (%i4) 10^-x;
1846                                 - x
1847 (%o4)                         10
1848 @end example
1849
1850 @opencatbox{Categories:}
1851 @category{Expressions}
1852 @category{Display flags and variables}
1853 @closecatbox
1854 @end defvr
1855
1856 @c -----------------------------------------------------------------------------
1857 @anchor{grind}
1858 @deffn  {Function} grind (@var{expr})
1859
1860 The function @code{grind} prints @var{expr} to the console in a form suitable
1861 for input to Maxima.  @code{grind} always returns @code{done}.
1862
1863 When @var{expr} is the name of a function or macro, @code{grind} prints the
1864 function or macro definition instead of just the name.
1865
1866 See also @mrefcomma{string} which returns a string instead of printing its
1867 output.  @code{grind} attempts to print the expression in a manner which makes
1868 it slightly easier to read than the output of @code{string}.
1869
1870 @code{grind} evaluates its argument.
1871
1872 Examples:
1873
1874 @c ===beg===
1875 @c aa + 1729;
1876 @c grind (%);
1877 @c [aa, 1729, aa + 1729];
1878 @c grind (%);
1879 @c matrix ([aa, 17], [29, bb]);
1880 @c grind (%);
1881 @c set (aa, 17, 29, bb);
1882 @c grind (%);
1883 @c exp (aa / (bb + 17)^29);
1884 @c grind (%);
1885 @c expr: expand ((aa + bb)^10);
1886 @c grind (expr);
1887 @c string (expr);
1888 @c cholesky (A):= block ([n : length (A), L : copymatrix (A),
1889 @c   p : makelist (0, i, 1, length (A))],
1890 @c   for i thru n do for j : i thru n do
1891 @c   (x : L[i, j], x : x - sum (L[j, k] * L[i, k], k, 1, i - 1),
1892 @c   if i = j then p[i] : 1 / sqrt(x) else L[j, i] : x * p[i]),
1893 @c   for i thru n do L[i, i] : 1 / p[i],
1894 @c   for i thru n do for j : i + 1 thru n do L[i, j] : 0, L)$
1895 @c grind (cholesky);
1896 @c string (fundef (cholesky));
1897 @c ===end===
1898 @example
1899 @group
1900 (%i1) aa + 1729;
1901 (%o1)                       aa + 1729
1902 @end group
1903 @group
1904 (%i2) grind (%);
1905 aa+1729$
1906 (%o2)                         done
1907 @end group
1908 @group
1909 (%i3) [aa, 1729, aa + 1729];
1910 (%o3)                 [aa, 1729, aa + 1729]
1911 @end group
1912 @group
1913 (%i4) grind (%);
1914 [aa,1729,aa+1729]$
1915 (%o4)                         done
1916 @end group
1917 @group
1918 (%i5) matrix ([aa, 17], [29, bb]);
1919                            [ aa  17 ]
1920 (%o5)                      [        ]
1921                            [ 29  bb ]
1922 @end group
1923 @group
1924 (%i6) grind (%);
1925 matrix([aa,17],[29,bb])$
1926 (%o6)                         done
1927 @end group
1928 @group
1929 (%i7) set (aa, 17, 29, bb);
1930 (%o7)                   @{17, 29, aa, bb@}
1931 @end group
1932 @group
1933 (%i8) grind (%);
1934 @{17,29,aa,bb@}$
1935 (%o8)                         done
1936 @end group
1937 @group
1938 (%i9) exp (aa / (bb + 17)^29);
1939                                 aa
1940                             -----------
1941                                      29
1942                             (bb + 17)
1943 (%o9)                     %e
1944 @end group
1945 @group
1946 (%i10) grind (%);
1947 %e^(aa/(bb+17)^29)$
1948 (%o10)                        done
1949 @end group
1950 @group
1951 (%i11) expr: expand ((aa + bb)^10);
1952          10           9        2   8         3   7         4   6
1953 (%o11) bb   + 10 aa bb  + 45 aa  bb  + 120 aa  bb  + 210 aa  bb
1954          5   5         6   4         7   3        8   2
1955  + 252 aa  bb  + 210 aa  bb  + 120 aa  bb  + 45 aa  bb
1956         9        10
1957  + 10 aa  bb + aa
1958 @end group
1959 @group
1960 (%i12) grind (expr);
1961 bb^10+10*aa*bb^9+45*aa^2*bb^8+120*aa^3*bb^7+210*aa^4*bb^6
1962      +252*aa^5*bb^5+210*aa^6*bb^4+120*aa^7*bb^3+45*aa^8*bb^2
1963      +10*aa^9*bb+aa^10$
1964 (%o12)                        done
1965 @end group
1966 @group
1967 (%i13) string (expr);
1968 (%o13) bb^10+10*aa*bb^9+45*aa^2*bb^8+120*aa^3*bb^7+210*aa^4*bb^6\
1969 +252*aa^5*bb^5+210*aa^6*bb^4+120*aa^7*bb^3+45*aa^8*bb^2+10*aa^9*\
1970 bb+aa^10
1971 @end group
1972 @group
1973 (%i14) cholesky (A):= block ([n : length (A), L : copymatrix (A),
1974   p : makelist (0, i, 1, length (A))],
1975   for i thru n do for j : i thru n do
1976   (x : L[i, j], x : x - sum (L[j, k] * L[i, k], k, 1, i - 1),
1977   if i = j then p[i] : 1 / sqrt(x) else L[j, i] : x * p[i]),
1978   for i thru n do L[i, i] : 1 / p[i],
1979   for i thru n do for j : i + 1 thru n do L[i, j] : 0, L)$
1980 define: warning: redefining the built-in function cholesky
1981 @end group
1982 @group
1983 (%i15) grind (cholesky);
1984 cholesky(A):=block(
1985          [n:length(A),L:copymatrix(A),
1986           p:makelist(0,i,1,length(A))],
1987          for i thru n do
1988              (for j from i thru n do
1989                   (x:L[i,j],x:x-sum(L[j,k]*L[i,k],k,1,i-1),
1990                    if i = j then p[i]:1/sqrt(x)
1991                        else L[j,i]:x*p[i])),
1992          for i thru n do L[i,i]:1/p[i],
1993          for i thru n do (for j from i+1 thru n do L[i,j]:0),L)$
1994 (%o15)                        done
1995 @end group
1996 @group
1997 (%i16) string (fundef (cholesky));
1998 (%o16) cholesky(A):=block([n:length(A),L:copymatrix(A),p:makelis\
1999 t(0,i,1,length(A))],for i thru n do (for j from i thru n do (x:L\
2000 [i,j],x:x-sum(L[j,k]*L[i,k],k,1,i-1),if i = j then p[i]:1/sqrt(x\
2001 ) else L[j,i]:x*p[i])),for i thru n do L[i,i]:1/p[i],for i thru \
2002 n do (for j from i+1 thru n do L[i,j]:0),L)
2003 @end group
2004 @end example
2005
2006 @opencatbox{Categories:}
2007 @category{Display functions}
2008 @closecatbox
2009 @end deffn
2010
2011 @defvr {Option variable} grind
2012
2013 When the variable @code{grind} is @code{true}, the output of @code{string} and
2014 @mref{stringout} has the same format as that of @code{grind}; otherwise no
2015 attempt is made to specially format the output of those functions.  The default
2016 value of the variable @code{grind} is @code{false}.
2017
2018 @code{grind} can also be specified as an argument of @mrefdot{playback}  When
2019 @code{grind} is present, @code{playback} prints input expressions in the same
2020 format as the @code{grind} function.  Otherwise, no attempt is made to specially
2021 format input expressions.
2022
2023 @opencatbox{Categories:}
2024 @category{Display flags and variables}
2025 @closecatbox
2026 @end defvr
2027
2028 @c -----------------------------------------------------------------------------
2029 @anchor{ibase}
2030 @defvr {Option variable} ibase
2031 Default value: @code{10}
2032
2033 @code{ibase} is the base for integers read by Maxima.
2034
2035 @code{ibase} may be assigned any integer between 2 and 36 (decimal), inclusive.
2036 When @code{ibase} is greater than 10,
2037 the numerals comprise the decimal numerals 0 through 9
2038 plus letters of the alphabet @code{A}, @code{B}, @code{C}, @dots{},
2039 as needed to make @code{ibase} digits in all.
2040 Letters are interpreted as digits only if the first digit is 0 through 9.
2041
2042 Uppercase and lowercase letters are not distinguished.
2043 The numerals for base 36, the largest acceptable base,
2044 comprise 0 through 9 and @code{A} through @code{Z}.
2045
2046 Whatever the value of @code{ibase},
2047 when an integer is terminated by a decimal point,
2048 it is interpreted in base 10.
2049
2050 See also @mrefdot{obase}
2051
2052 Examples:
2053
2054 @code{ibase} less than 10 (for example binary numbers).
2055
2056 @c ===beg===
2057 @c ibase : 2 $
2058 @c obase;
2059 @c 1111111111111111;
2060 @c ===end===
2061 @example
2062 (%i1) ibase : 2 $
2063 @group
2064 (%i2) obase;
2065 (%o2)                          10
2066 @end group
2067 @group
2068 (%i3) 1111111111111111;
2069 (%o3)                         65535
2070 @end group
2071 @end example
2072
2073 @code{ibase} greater than 10.
2074 Letters are interpreted as digits only if the first digit is 0
2075 through 9 which means that hexadecimal numbers might need to
2076 be prepended by a 0.
2077
2078 @c ===beg===
2079 @c ibase : 16 $
2080 @c obase;
2081 @c 1000;
2082 @c abcd;
2083 @c symbolp (abcd);
2084 @c 0abcd;
2085 @c symbolp (0abcd);
2086 @c ===end===
2087 @example
2088 (%i1) ibase : 16 $
2089 @group
2090 (%i2) obase;
2091 (%o2)                          10
2092 @end group
2093 @group
2094 (%i3) 1000;
2095 (%o3)                         4096
2096 @end group
2097 @group
2098 (%i4) abcd;
2099 (%o4)                         abcd
2100 @end group
2101 @group
2102 (%i5) symbolp (abcd);
2103 (%o5)                         true
2104 @end group
2105 @group
2106 (%i6) 0abcd;
2107 (%o6)                         43981
2108 @end group
2109 @group
2110 (%i7) symbolp (0abcd);
2111 (%o7)                         false
2112 @end group
2113 @end example
2114
2115 When an integer is terminated by a decimal point,
2116 it is interpreted in base 10.
2117
2118 @c ===beg===
2119 @c ibase : 36 $
2120 @c obase;
2121 @c 1234;
2122 @c 1234.;
2123 @c ===end===
2124 @example
2125 (%i1) ibase : 36 $
2126 @group
2127 (%i2) obase;
2128 (%o2)                          10
2129 @end group
2130 @group
2131 (%i3) 1234;
2132 (%o3)                         49360
2133 @end group
2134 @group
2135 (%i4) 1234.;
2136 (%o4)                         1234
2137 @end group
2138 @end example
2139
2140 @opencatbox{Categories:}
2141 @category{Console interaction}
2142 @closecatbox
2143 @end defvr
2144
2145 @c -----------------------------------------------------------------------------
2146 @anchor{ldisp}
2147 @deffn {Function} ldisp (@var{expr_1}, @dots{}, @var{expr_n})
2148
2149 Displays expressions @var{expr_1}, @dots{}, @var{expr_n} to the console as
2150 printed output.  @code{ldisp} assigns an intermediate expression label to each
2151 argument and returns the list of labels.
2152
2153 See also @mrefcomma{disp} @mrefcomma{display} and @mrefdot{ldisplay}
2154
2155 Examples:
2156
2157 @example
2158 (%i1) e: (a+b)^3;
2159                                    3
2160 (%o1)                       (b + a)
2161 (%i2) f: expand (e);
2162                      3        2      2      3
2163 (%o2)               b  + 3 a b  + 3 a  b + a
2164 (%i3) ldisp (e, f);
2165                                    3
2166 (%t3)                       (b + a)
2167
2168                      3        2      2      3
2169 (%t4)               b  + 3 a b  + 3 a  b + a
2170
2171 (%o4)                      [%t3, %t4]
2172 (%i4) %t3;
2173                                    3
2174 (%o4)                       (b + a)
2175 (%i5) %t4;
2176                      3        2      2      3
2177 (%o5)               b  + 3 a b  + 3 a  b + a
2178 @end example
2179
2180 @opencatbox{Categories:}
2181 @category{Display functions}
2182 @closecatbox
2183 @end deffn
2184
2185 @c -----------------------------------------------------------------------------
2186 @anchor{ldisplay}
2187 @deffn {Function} ldisplay (@var{expr_1}, @dots{}, @var{expr_n})
2188
2189 Displays expressions @var{expr_1}, @dots{}, @var{expr_n} to the console as
2190 printed output.  Each expression is printed as an equation of the form
2191 @code{lhs = rhs} in which @code{lhs} is one of the arguments of @code{ldisplay}
2192 and @code{rhs} is its value.  Typically each argument is a variable.
2193 @mref{ldisp} assigns an intermediate expression label to each equation and
2194 returns the list of labels.
2195
2196 See also @mrefcomma{display} @mrefcomma{disp} and @mrefdot{ldisp}
2197
2198 Examples:
2199
2200 @example
2201 (%i1) e: (a+b)^3;
2202                                    3
2203 (%o1)                       (b + a)
2204 (%i2) f: expand (e);
2205                      3        2      2      3
2206 (%o2)               b  + 3 a b  + 3 a  b + a
2207 (%i3) ldisplay (e, f);
2208                                      3
2209 (%t3)                     e = (b + a)
2210
2211                        3        2      2      3
2212 (%t4)             f = b  + 3 a b  + 3 a  b + a
2213
2214 (%o4)                      [%t3, %t4]
2215 (%i4) %t3;
2216                                      3
2217 (%o4)                     e = (b + a)
2218 (%i5) %t4;
2219                        3        2      2      3
2220 (%o5)             f = b  + 3 a b  + 3 a  b + a
2221 @end example
2222
2223 @opencatbox{Categories:}
2224 @category{Display functions}
2225 @closecatbox
2226 @end deffn
2227
2228 @c -----------------------------------------------------------------------------
2229 @anchor{leftjust}
2230 @defvr {Option variable} leftjust
2231 Default value: @code{false}
2232
2233 When @code{leftjust} is @code{true}, equations in 2D-display are drawn left
2234 justified rather than centered.
2235
2236 See also @mref{display2d} to switch between 1D- and 2D-display.
2237
2238 Example:
2239
2240 @example
2241 (%i1) expand((x+1)^3);
2242                         3      2
2243 (%o1)                  x  + 3 x  + 3 x + 1
2244 (%i2) leftjust:true$
2245 (%i3) expand((x+1)^3);
2246        3      2
2247 (%o3) x  + 3 x  + 3 x + 1
2248 @end example
2249
2250 @opencatbox{Categories:}
2251 @category{Display flags and variables}
2252 @closecatbox
2253 @end defvr
2254
2255 @c -----------------------------------------------------------------------------
2256 @anchor{linel}
2257 @defvr {Option variable} linel
2258 Default value: @code{79}
2259
2260 @code{linel} is the assumed width (in characters) of the console display for the
2261 purpose of displaying expressions.  @code{linel} may be assigned any value by
2262 the user, although very small or very large values may be impractical.  Text
2263 printed by built-in Maxima functions, such as error messages and the output of
2264 @mrefcomma{describe} is not affected by @code{linel}.
2265
2266 @opencatbox{Categories:}
2267 @category{Display flags and variables}
2268 @closecatbox
2269 @end defvr
2270
2271 @c -----------------------------------------------------------------------------
2272 @need 800
2273 @anchor{lispdisp}
2274 @defvr {Option variable} lispdisp
2275 Default value: @code{false}
2276
2277 When @code{lispdisp} is @code{true}, Lisp symbols are displayed with a leading
2278 question mark @code{?}.  Otherwise, Lisp symbols are displayed with no leading
2279 mark. This has the same effect for 1-d and 2-d display.
2280
2281 Examples:
2282
2283 @c ===beg===
2284 @c lispdisp: false$
2285 @c ?foo + ?bar;
2286 @c lispdisp: true$
2287 @c ?foo + ?bar;
2288 @c ===end===
2289 @example
2290 (%i1) lispdisp: false$
2291 @group
2292 (%i2) ?foo + ?bar;
2293 (%o2)                       foo + bar
2294 @end group
2295 (%i3) lispdisp: true$
2296 @group
2297 (%i4) ?foo + ?bar;
2298 (%o4)                      ?foo + ?bar
2299 @end group
2300 @end example
2301
2302 @opencatbox{Categories:}
2303 @category{Display flags and variables}
2304 @closecatbox
2305 @end defvr
2306
2307 @c NEEDS CLARIFICATION, EXAMPLES
2308
2309 @c -----------------------------------------------------------------------------
2310 @anchor{negsumdispflag}
2311 @defvr {Option variable} negsumdispflag
2312 Default value: @code{true}
2313
2314 When @code{negsumdispflag} is @code{true}, @code{x - y} displays as @code{x - y}
2315 instead of as @code{- y + x}.  Setting it to @code{false} causes the special
2316 check in display for the difference of two expressions to not be done.  One
2317 application is that thus @code{a + %i*b} and @code{a - %i*b} may both be
2318 displayed the same way.
2319
2320 @opencatbox{Categories:}
2321 @category{Display flags and variables}
2322 @closecatbox
2323 @end defvr
2324
2325 @c -----------------------------------------------------------------------------
2326 @anchor{obase}
2327 @defvr {Option variable} obase
2328 Default value: @code{10}
2329
2330 @code{obase} is the base for integers displayed by Maxima.
2331
2332 @code{obase} may be assigned any integer between 2 and 36 (decimal), inclusive.
2333 When @code{obase} is greater than 10,
2334 the numerals comprise the decimal numerals 0 through 9
2335 plus capital letters of the alphabet A, B, C, @dots{}, as needed.
2336 A leading 0 digit is displayed if the leading digit is otherwise a letter.
2337 The numerals for base 36, the largest acceptable base,
2338 comprise 0 through 9, and A through Z.
2339
2340 See also @mrefdot{ibase}
2341
2342 Examples:
2343
2344 @c ===beg===
2345 @c obase : 2;
2346 @c 2^8 - 1;
2347 @c obase : 8;
2348 @c 8^8 - 1;
2349 @c obase : 16;
2350 @c 16^8 - 1;
2351 @c obase : 36;
2352 @c 36^8 - 1;
2353 @c ===end===
2354 @example
2355 @group
2356 (%i1) obase : 2;
2357 (%o1)                          10
2358 @end group
2359 @group
2360 (%i10) 2^8 - 1;
2361 (%o10)                      11111111
2362 @end group
2363 @group
2364 (%i11) obase : 8;
2365 (%o3)                          10
2366 @end group
2367 @group
2368 (%i4) 8^8 - 1;
2369 (%o4)                       77777777
2370 @end group
2371 @group
2372 (%i5) obase : 16;
2373 (%o5)                          10
2374 @end group
2375 @group
2376 (%i6) 16^8 - 1;
2377 (%o6)                       0FFFFFFFF
2378 @end group
2379 @group
2380 (%i7) obase : 36;
2381 (%o7)                          10
2382 @end group
2383 @group
2384 (%i8) 36^8 - 1;
2385 (%o8)                       0ZZZZZZZZ
2386 @end group
2387 @end example
2388
2389 @opencatbox{Categories:}
2390 @category{Display flags and variables}
2391 @category{Console interaction}
2392 @closecatbox
2393 @end defvr
2394
2395 @c -----------------------------------------------------------------------------
2396 @anchor{pfeformat}
2397 @defvr {Option variable} pfeformat
2398 Default value: @code{false}
2399
2400 When @code{pfeformat} is @code{true}, a ratio of integers is displayed with the
2401 solidus (forward slash) character, and an integer denominator @code{n} is
2402 displayed as a leading multiplicative term @code{1/n}.
2403
2404 Examples:
2405
2406 @example
2407 (%i1) pfeformat: false$
2408 (%i2) 2^16/7^3;
2409                               65536
2410 (%o2)                         -----
2411                                343
2412 (%i3) (a+b)/8;
2413                               b + a
2414 (%o3)                         -----
2415                                 8
2416 (%i4) pfeformat: true$
2417 (%i5) 2^16/7^3;
2418 (%o5)                       65536/343
2419 (%i6) (a+b)/8;
2420 (%o6)                      1/8 (b + a)
2421 @end example
2422
2423 @opencatbox{Categories:}
2424 @category{Display flags and variables}
2425 @closecatbox
2426 @end defvr
2427
2428 @c -----------------------------------------------------------------------------
2429 @anchor{powerdisp}
2430 @defvr {Option variable} powerdisp
2431 Default value: @code{false}
2432
2433 When @code{powerdisp} is @code{true},
2434 a sum is displayed with its terms in order of increasing power.
2435 Thus a polynomial is displayed as a truncated power series,
2436 with the constant term first and the highest power last.
2437
2438 By default, terms of a sum are displayed in order of decreasing power.
2439
2440 Example:
2441
2442 @example
2443 (%i1) powerdisp:true;
2444 (%o1)                         true
2445 (%i2) x^2+x^3+x^4;
2446                            2    3    4
2447 (%o2)                     x  + x  + x
2448 (%i3) powerdisp:false;
2449 (%o3)                         false
2450 (%i4) x^2+x^3+x^4;
2451                            4    3    2
2452 (%o4)                     x  + x  + x
2453 @end example
2454
2455 @opencatbox{Categories:}
2456 @category{Display flags and variables}
2457 @closecatbox
2458 @end defvr
2459
2460 @c -----------------------------------------------------------------------------
2461 @anchor{print}
2462 @deffn {Function} print (@var{expr_1}, @dots{}, @var{expr_n})
2463
2464 Evaluates and displays @var{expr_1}, @dots{}, @var{expr_n} one after another,
2465 from left to right, starting at the left edge of the console display.
2466
2467 The value returned by @code{print} is the value of its last argument.
2468 @code{print} does not generate intermediate expression labels.
2469
2470 See also @mrefcomma{display} @mrefcomma{disp} @mrefcomma{ldisplay} and
2471 @mrefdot{ldisp}  Those functions display one expression per line, while
2472 @code{print} attempts to display two or more expressions per line.
2473
2474 To display the contents of a file, see @mrefdot{printfile}
2475
2476 Examples:
2477
2478 @example
2479 (%i1) r: print ("(a+b)^3 is", expand ((a+b)^3), "log (a^10/b) is",
2480       radcan (log (a^10/b)))$
2481             3        2      2      3
2482 (a+b)^3 is b  + 3 a b  + 3 a  b + a  log (a^10/b) is
2483
2484                                               10 log(a) - log(b)
2485 (%i2) r;
2486 (%o2)                  10 log(a) - log(b)
2487 (%i3) disp ("(a+b)^3 is", expand ((a+b)^3), "log (a^10/b) is",
2488       radcan (log (a^10/b)))$
2489                            (a+b)^3 is
2490
2491                      3        2      2      3
2492                     b  + 3 a b  + 3 a  b + a
2493
2494                          log (a^10/b) is
2495
2496                        10 log(a) - log(b)
2497 @end example
2498
2499 @opencatbox{Categories:}
2500 @category{Display functions}
2501 @closecatbox
2502 @end deffn
2503
2504 @c -----------------------------------------------------------------------------
2505 @anchor{sqrtdispflag}
2506 @defvr {Option variable} sqrtdispflag
2507 Default value: @code{true}
2508
2509 When @code{sqrtdispflag} is @code{false}, causes @code{sqrt} to display with
2510 exponent 1/2.
2511 @c AND OTHERWISE ... ??
2512
2513 @opencatbox{Categories:}
2514 @category{Mathematical functions}
2515 @category{Display flags and variables}
2516 @closecatbox
2517 @end defvr
2518
2519 @c -----------------------------------------------------------------------------
2520 @anchor{stardisp}
2521 @defvr {Option variable} stardisp
2522 Default value: @code{false}
2523
2524 When @code{stardisp} is @code{true}, multiplication is
2525 displayed with an asterisk @code{*} between operands.
2526
2527 @opencatbox{Categories:}
2528 @category{Display flags and variables}
2529 @closecatbox
2530 @end defvr
2531
2532 @c -----------------------------------------------------------------------------
2533 @anchor{ttyoff}
2534 @defvr {Option variable} ttyoff
2535 Default value: @code{false}
2536
2537 When @code{ttyoff} is @code{true}, output expressions are not displayed.
2538 Output expressions are still computed and assigned labels.  See @mrefdot{labels}
2539
2540 Text printed by built-in Maxima functions, such as error messages and the output
2541 of @mrefcomma{describe} is not affected by @code{ttyoff}.
2542
2543 @opencatbox{Categories:}
2544 @category{Display flags and variables}
2545 @closecatbox
2546 @end defvr
2547