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