Maxima Manual

2.1 Einführung in Programmfehler

Maxima wird ständig weiterentwickelt. Der Funktionsumfang wird erweitert und Fehler, die bei einem Programm dieser Komplexität kaum zu vermeiden sind, werden korrigiert. Fehler können berichtet werden. Werden ausreichend Informationen mitgeteilt, können die Entwickler Maxima weiter verbessern. Ein aktueller Link zur Webseite zum Berichten von Fehlern sowie die notwendigen Informationen über die Maxima-Installation werden mit der Funktion bug_report angezeigt. Um die Installation auf dem Rechner zu testen, kann die Maxima-Testsuite mit der Funktion run_testsuite ausgeführt werden. Die folgende Übersicht zeigt die Funktionen und Variablen für das Testen der Installation und das Berichten von Fehlern:

   run_testsuite     testsuite_files     bug_report     build_info

2.2 Funktionen und Variablen für Programmfehler

Funktion: run_testsuite ([options]) ¶

Die Funktion run_testsuite führt die Maxima-Testsuite aus. Erfolgreiche Tests und Tests, die zwar nicht erfolgreich, aber als ein bekannter Fehler gekennzeichnet sind, geben die Meldung "passed". run_testsuite akzeptiert die folgenden optionalen Schlüsselworte als Argumente:

display_all

Hat das Schlüsselwort display_all den Wert true, werden alle Tests angezeigt. Der Standardwert ist false. In diesem Fall werden nur die Tests angezeigt, die fehlschlagen.

display_known_bugs

Hat das Schlüsselwort display_known_bugs den Wert true, werden alle Tests angezeigt, die als fehlerhaft gekennzeichnet sind. Der Standardwert ist false.

tests

Das Schlüsselwort tests erhält eine Liste mit den Testdateien, die ausgeführt werden sollen. Eine Testdatei kann durch eine Zeichenkette oder ein Symbol angegeben werden. Der Standard ist, dass alle Testdateien ausgeführt werden, die in der Optionsvariablen testsuite_files enthalten sind.

time

Hat das Schlüsselwort time den Wert true, werden die Laufzeiten der einzelnen Testdateien angezeigt. Hat time den Wert all und display_all den Wert true, wird die Laufzeit jedes einzelnen Tests angezeigt. Der Standardwert ist false.

Das Ausführen einer Testdatei kann die Maxima-Umgebung ändern. Typischerweise führt eine Testdatei zuerst das Kommando kill(all) aus, um eine definierte Umgebung herzustellen, in der keine nutzerdefinierten Funktionen und Variablen vorhanden sind. Siehe auch die Funktion kill.

Testdateien können auch von der Funktion batch mit der Option test ausgeführt werden. Siehe die Dokumentation der Funktion batch auch für ein Beispiel, wie eine Testdatei aufgebaut ist.

run_testsuite hat den Rückgabewert done.

Beispiele:

(%i1) run_testsuite(tests = ["rtest1", rtest2]);
Running tests in rtest1: 111/111 tests passed
Running tests in rtest2: 66/66 tests passed

No unexpected errors found out of 177 tests.
Evaluation took:
  0.344 seconds of real time
  0.30402 seconds of total run time (0.30002 user, 0.00400 system)
  88.37% CPU
  581,206,031 processor cycles
  7,824,088 bytes consed
  
(%o1)                         done

Es werden zusätzlich alle Tests angezeigt. Die Ausgabe wird hier nach dem zweiten Test abgekürzt.

(%i2) run_testsuite(display_all=true, tests=["rtest1",rtest2]);
Running tests in rtest1: 
********************** Problem 1 ***************
Input:
(fmakunbound(f), kill(functions, values, arrays))

Result:
done

... Which was correct.

********************** Problem 2 ***************
Input:
             2
f(x) := y + x

Result:
             2
f(x) := y + x

... Which was correct.

[...]

Im folgenden Beispiel werden die Tests ausgegeben, von denen bekannt ist, dass sie fehlerhaft sind. Dies sind die Tests mit den Nummern 76 und 78.

(%i1) run_testsuite(display_known_bugs=true, tests=[rtest12]);
Running tests in rtest12:

********************** Problem 76 ***************
Input:
           2
letsimp(foo (x))

Result:
       2
1 - bar (aa)

This differed from the expected result:
       2
1 - bar (x)

********************** Problem 78 ***************
Input:
           4
letsimp(foo (x))

Result:
   4            2
bar (aa) - 2 bar (aa) + 1

This differed from the expected result:
         2         4
1 - 2 bar (x) + bar (x)

76/78 tests passed

The following 2 problems failed: (76 78)

Error summary:
Errors found in /usr/local/share/maxima/5.23post/tests/rtest12.mac,
problems: (76 78)
2 tests failed out of 78 total tests.
Evaluation took:
  0.157 seconds of real time
  0.12801 seconds of total run time (0.12401 user, 0.00400 system)
  [Run times consist of 0.008 seconds GC time, 
   and 0.121 seconds non-GC time.]
  81.53% CPU
  9 forms interpreted
  71 lambdas converted
  254,604,658 processor cycles
  6,145,064 bytes consed
  
(%o0)                         done

Optionsvariable: testsuite_files ¶

Die Optionsvariable testsuite_files enthält die Liste der Testdateien, die von run_testsuite standardmäßig ausgeführt werden. Wenn bekannt ist, dass einzelne Tests einer Testdatei fehlschlagen werden, dann wird anstatt dem Namen der Datei eine Liste eingefügt, die den Namen und die Nummern der fehlerhaften Tests enthält. Das folgende Beispiel zeigt die Zuweisung einer neuen Liste und wie fehlerhafte Tests gekennzeichnet werden:

 testsuite_files : ["rtest13s", ["rtest14", 57, 63]]

Die Einträge der Liste bedeuten, dass die Dateien "rtest13s" und "rtest14" von der Funktion run_testsuite ausgeführt werden sollen und das bekannt ist, dass die Tests mit den Nummern 57 und 63 der Testdatei "rtest14" fehlschlagen werden.

Funktion: bug_report () ¶

Zeigt die Maxima- und Lisp-Version der Installation sowie einen Link zur Webseite des Maxima-Projekts. Die Informationen zur Version werden auch von build_info angezeigt. Wenn ein Programmfehler berichtet wird, ist es hilfreich, die Maxima- und Lisp-Version in den Fehlerbericht aufzunehmen. bug_report gibt eine leere Zeichenkette "" zurück.

Beispiel:

(%i1) bug_report();

Please report bugs to:
    https://sourceforge.net/p/maxima/bugs/
To report a bug, you must have a Sourceforge account.
Please include the following information with your bug report:
-------------------------------------------------------------
Maxima version: "5.36.1"
Maxima build date: "2015-06-02 11:26:48"
Host type: "x86_64-unknown-linux-gnu"
Lisp implementation type: "GNU Common Lisp (GCL)"
Lisp implementation version: "GCL 2.6.12"
-------------------------------------------------------------
The above information is also reported by the function 'build_info()'.

Funktion: build_info () ¶

Zeigt die Maxima- und Lisp-Version der Installation. build_info gibt die Eigenschaften der Maxima-Version als Maxima structure (definiert durch defstruct) zurück. Die Felder der Struktur sind: version, timestamp, host, lisp_name und lisp_version. Wenn die Ausgabe formatiert erfolgt (mit display2d:true;), werden die Ergebnisse als kurze Tabelle ausgegeben.

Beispiel:

(%i1) build_info ();
(%o1) 
Maxima version: "5.36.1"
Maxima build date: "2015-06-02 11:26:48"
Host type: "x86_64-unknown-linux-gnu"
Lisp implementation type: "GNU Common Lisp (GCL)"
Lisp implementation version: "GCL 2.6.12"

(%i2) x : build_info ()$

(%i3) x@version;
(%o3)                               5.36.1

(%i4) x@timestamp;
(%o4)                         2015-06-02 11:26:48

(%i5) x@host;
(%o5)                      x86_64-unknown-linux-gnu

(%i6) x@lisp_name;
(%o6)                        GNU Common Lisp (GCL)

(%i7) x@lisp_version;
(%o7)                             GCL 2.6.12

(%i8) x;
(%o8) 
Maxima version: "5.36.1"
Maxima build date: "2015-06-02 11:26:48"
Host type: "x86_64-unknown-linux-gnu"
Lisp implementation type: "GNU Common Lisp (GCL)"
Lisp implementation version: "GCL 2.6.12"

Der Versionsstring (hier 5.36.1) kann auch folgendermassen aussehen: branch_5_37_base_331_g8322940_dirty

(%i1) build_info();
(%o1) 
Maxima version: "branch_5_37_base_331_g8322940_dirty"
Maxima build date: "2016-01-01 15:37:35"
Host type: "x86_64-unknown-linux-gnu"
Lisp implementation type: "CLISP"
Lisp implementation version: "2.49 (2010-07-07) (built 3605577779) 
     (memory 3660647857)"

In diesem Fall wurde Maxima nicht von einem Release sondern direkt aus dem Git checkout des Sourcecodes compiliert. Im obigen Beispiel ist der Checkout 331 Commits nach dem letzten Git-Tag (üblicherweise ein Maxima-Release (5.37 im obigen Beispiel)) und der verkürzte Commit Hash des letzten Commits lautet "8322940".

3.1 Dokumentation

Die Maxima-Dokumentation ist in Texinfo geschrieben und wird in verschiedenen Formaten zur Verfügung gestellt. Von der Maxima-Kommandozeile kann die Dokumentation mit den Kommandos ?, ?? oder describe aufgerufen werden. Weiterhin kann die Dokumentation als GNU Infotext mit dem GNU Programm info, in einem Browser oder als PDF-Datei gelesen werden. Sowohl unter Windows als auch unter Linux kann die Dokumentation als Hilfedatei gelesen werden.

3.2 Funktionen und Variablen der Hilfe

Funktion: apropos (string) ¶

Gibt eine Liste der Maxima-Symbole zurück, die die Zeichenkette string im Namen enthalten. Das Kommando apropos("") gibt eine Liste mit allen Maxima-Symbolen zurück. Wenn apropos kein Maxima-Symbol finden kann, das die Zeichenkette string im Namen enthält, ist das Ergebnis eine leere Liste [].

Beispiel:

Zeige alle Maxima-Symbole, die die Zeichenkette "gamma" im Namen enthalten:

(%i1) apropos("gamma");
(%o1) [%gamma, gamma, gammalim, gamma_expand, gamma_incomplete_lower, 
gamma_incomplete, gamma_incomplete_generalized, 
gamma_incomplete_regularized, Gamma, log_gamma, makegamma, 
prefer_gamma_incomplete, 
gamma_incomplete_generalized_regularized]

Funktion: demo (filename) ¶

Führt die Beispiele der Demo-Datei filename aus. Das Argument filename kann ein Symbol oder eine Zeichenkette sein. demo macht nach jeder Ausgabe eine Pause und wartet auf eine Eingabe. demo sucht in den Ordnern, die in der Optionsvariablen file_search_demo enthalten sind, nach der Datei filename. Die Dateiendung .dem muss nicht angegeben werden.

Siehe auch die Funktion file_search für die Suche von Dateien und die Funktion batch für den Aufbau einer Demo-Datei. Demo-Dateien können auch von der Funktion batch mit der Option demo ausgeführt werden. demo wertet das Argument aus. demo gibt den Namen der Demo-Datei zurück, die ausgeführt wird.

Beispiel:

(%i1) demo ("disol");
batching /home/wfs/maxima/share/simplification/disol.dem
 At the _ prompt, type ';' followed by enter to get next demo
(%i2)                      load("disol")
_
(%i3)           exp1 : a (e (g + f) + b (d + c))
(%o3)               a (e (g + f) + b (d + c))
_
(%i4)                disolate(exp1, a, b, e)
(%t4)                         d + c

(%t5)                         g + f

(%o5)                   a (%t5 e + %t4 b)
_

Funktion: describe (topic) ¶

Funktion: describe (topic, exact) ¶

Funktion: describe (topic, inexact) ¶

describe(topic) entspricht dem Kommando describe(topic, exact). Das Argument topic ist eine Zeichenkette oder ein Symbol. Wenn topic ein Operator wie zum Beispiel +, *, do oder if ist, muss der Name des Operators als eine Zeichenkette angegeben werden. Der Name des Operators + für die Addition ist zum Beispiel "+".

describe(topic, exact) findet Einträge, die mit topic übereinstimmen. Bei der Suche nach einer Übereinstimmung werden Klein- und Großschreibung nicht voneinander unterschieden. describe(topic, inexact) findet Einträge, die topic enthalten. Sind mehrere Einträge vorhanden, fragt Maxima, welcher der Einträge angezeigt werden soll.

? foo (mit einem Leerzeichen zwischen ? und foo) entspricht describe("foo", exact) und ?? foo entspricht describe("foo", inexact). In der Kurzschreibweise muss das Argument ein Symbol sein. Siehe auch ? und ??.

describe("", inexact) gibt alle Themen aus, die in der Dokumentation enthalten sind.

describe wertet das Argument nicht aus. describe gibt true zurück, wenn Einträge gefunden wurden, ansonsten false.

Beispiel:

Im folgenden Beispiel werden die Einträge 2 und 3 ausgewählt (Die Ausgabe ist verkürzt wiedergeben). Alle oder keiner der Einträge werden mit all oder none ausgewählt. Die Eingabe kann mit a oder n abgekürzt werden.

(%i1) ?? integrat
 0: Functions and Variables for Integration
 1: Introduction to Integration
 2: integrate (Functions and Variables for Integration)
 3: integrate_use_rootsof (Functions and Variables for Integration)
 4: integration_constant (Functions and Variables for Integration)
 5: integration_constant_counter (Functions and Variables for 
    Integration)
Enter space-separated numbers, `all' or `none': 2 3

 -- Function: integrate (<expr>, <x>)
 -- Function: integrate (<expr>, <x>, <a>, <b>)
     Attempts to symbolically compute the integral of <expr> with
     respect to <x>.  `integrate (<expr>, <x>)' is an indefinite
     integral, while `integrate (<expr>, <x>, <a>, <b>)' is a 
     definite integral, with limits of integration <a> and <b>.
     [...]

 -- Option variable: integrate_use_rootsof
     Default value: `false'

     When `integrate_use_rootsof' is `true' and the denominator of
     a rational function cannot be factored, `integrate' returns
     the integral in a form which is a sum over the roots (not yet 
     known) of the denominator.
     [...]

Optionsvariable: output_format_for_help ¶

Standardwert: text

output_format_for_help gibt an, wie describe die Hilfe darstellt.

output_format_for_help kann auf folgende Werte gesetzt werden:

text

Die Hilfe wird als Text am Terminal dargestellt. Das ist der Standard.

html

Die Hilfe wird mit einem Browser als HTML Version des Handbuchs dargestellt.

frontend

Die Hilfe wird mit dem Hilfesystem des Frontends dargestellt. Wenn kein Frontend verwendet wird, wird ein Fehler ausgegeben. Frontends sind beispielsweise wxMaxima oder Xmaxima.

Andere Werte sind Fehler.

Siehe auch browser und url_base.

Categories: Help · Global variables ·

Optionsvariable: browser ¶

Damit wird das Browserkommando angegeben, mit dem die HTML Dateien dargestellt werden. Der String hat die Form <cmd> ~A wobei ~A mit der URL ersetzt wird und <cmd> ist das Programm, das die URL im Argument im Browser darstellt.

Auf Windows ist der Standardwert "start ~A", was den Default-Browser öffnet. Das kann beispielsweise durch start firefox ~A, start chrome ~A oder start iexplore ~A ersetzt werden, um andere Browser als den Standardbrowser zu verwenden.

Unter anderen Betriebssystemen wird der Standardbrowser automatisch verwendet (unter Verwendung von xdg-open unter Linux/Unix und open auf MacOS). Die browser variable kann auf einen Nicht-Default-Browser gesetzt werden, z.B. browser:"firefox '~A'"; oder browser:"chromium '~A'";

Siehe auch output_format_for_help und url_base.

Categories: Help · Global variables ·

Optionsvariable: url_base ¶

Wenn die Hilfe mit einem Webbrowser dargestellt wird, definiert url_base die zu verwendende URL. Der Standardwert ist eine file:// URL, die zum Directory mit den HTML-Dateien zeigt. Man könnte z.B. auch http://localhost:8080/ oder andere URLs verwenden, wo die Hilfe abrufbar ist. Achtung: Diese URL muß exakt dieselben HTML-Dateien enthalten, die aus dem Maxima-Sourcecode gebaut werden; eine Tabelle wird verwendet, um aus einem Thema die richtige Position in einer HTML-Datei zu finden.

Siehe auch output_format_for_help und browser..

Categories: Help · Global variables ·

Funktion: example (topic) ¶

Funktion: example () ¶

Das Kommando example(topic) zeigt Beispiele für das Argument topic. topic ist ein Symbol oder eine Zeichenkette. Ist das Argument ein Operator, wie zum Beispiel +, * oder do, muss das Argument topic eine Zeichenkette sein. Der Name des Operators + für die Addition ist zum Beispiel "+". Groß- und Kleinschreibung werden nicht unterschieden.

example() zeigt eine Liste aller Themen, für die Beispiele vorhanden sind.

Die Optionsvariable manual_demo enthält den Namen der Datei, die die Beispiele enthält. Der Standardwert ist "manual.demo".

example wertet das Argument nicht aus. example gibt done zurück, außer wenn kein Argument angeben ist oder wenn kein Beispiel gefunden wurde. In diesen Fällen wird eine Liste mit allen Themen ausgegeben, zu denen Beispiele vorhanden sind.

Beispiele:

(%i1) example(append);
(%i2) append([x+y,0,-3.2],[2.5e+20,x])
(%o2)             [y + x, 0, - 3.2, 2.5e+20, x]
(%o2)                         done
(%i3) example("lambda");

(%i4) lambda([x,y,z],z^2+y^2+x^2)
                                    2    2    2
(%o4)            lambda([x, y, z], z  + y  + x )
(%i5) %(1,2,a)
                              2
(%o5)                        a  + 5
(%i6) a+2+1
(%o6)                         a + 3
(%o6)                         done

Optionsvariable: manual_demo ¶

Standardwert: "manual.demo"

Die Optionsvariable manual_demo enthält den Namen der Datei, die die Beispiele für die Funktion example enthält. Siehe example.

4.1 Einführung in die Kommandozeile

Konsole

Für Maxima sind verschiedene Nutzeroberflächen erhältlich. Oberflächen, die je nach Betriebssystem bereits mit der Installation von Maxima zur Verfügung stehen, sind wxMaxima, Xmaxima, Imaxima und die Konsole.

Die Konsole (oder das Terminal) arbeitet in einem Textmodus. Für die Ausgabe in einem grafischen Modus mit einer menügesteuerten Eingabe müssen andere Nutzeroberflächen verwendet werden.

In dieser Dokumentation wird ausschließlich die Konsole eingesetzt, die unter allen Betriebssystemen zur Verfügung steht. Der Nutzer kann alle Maxima-Funktionen in einer Konsole nutzen. Im Textmodus der Konsole werden die Ergebnisse in der Regel in einem 2D-Modus dargestellt. Für die Ausgabe von Funktionsgraphen werden von Maxima Hilfsprogramme wie GNUPlot aufgerufen.

Eingabe, Auswertung, Vereinfachung und Ausgabe

Jede Eingabe des Nutzers in einer Konsole bis zur Ausgabe eines Ergebnisses auf der Konsole kann in vier Phasen eingeteilt werden:

1. Von der Tastatur oder aus einer Datei wird ein Ausdruck eingelesen und vom Parser in eine interne Darstellung umgewandelt. In dieser 1. Phase werden inbesondere Operatoren wie "+", "/" oder "do" behandelt.
2. Der vom Parser eingelesene Ausdruck wird von Maxima in der 2. Phase ausgewertet. Dabei werden Variablen durch ihren Wert ersetzt und Funktionen wie die Substitution oder Integration eines Ausdrucks ausgeführt. Das Ergebnis dieser Phase ist ein ausgewerteter Ausdruck.
3. Der ausgewertete Ausdruck wird in der 3. Phase von Maxima vereinfacht. Dabei werden Ausdrücke wie a+a zu 2*a oder sin(%pi/2) zu 1 vereinfacht.
4. Das Ergebnis ist ein ausgewerteter und vereinfachter Ausdruck. Zuletzt wird dieses Ergebnis in der 4. Phase für die Anzeige vorbereitet und auf der Konsole ausgegeben.

Der Nutzer kann auf jede einzelne Phase Einfluß nehmen. Verschiedene Kapitel der Dokumentation befassen sich mit diesen Möglichkeiten. In diesem Kapitel werden die Kommandos und Möglichkeiten zusammengestellt, die sich mit der Eingabe und Ausgabe auf der Konsole befassen. In Auswertung wird beschrieben wie auf die Auswertung und in Vereinfachung wie auf die Vereinfachung einer Eingabe Einfluss genommen werden kann.

Marken

Maxima speichert alle Eingaben in den Marken %i und die Ausgaben in den Marken %o ab. Die Marken erhalten eine laufende Nummer. Weiterhin erzeugen einige Funktionen Zwischenmarken %t. Andere Systemvariablen speichern das letzte Ergebnis oder die letzte Eingabe ab. Folgende Symbole bezeichnen Variablen und Funktionen für die Verwaltung der Marken:

   __          _        
   %           %%           %th
   inchar      linechar     outchar
   linenum     nolabels

Informationslisten

Maxima verwaltet Informationslisten. Die verfügbaren Informationslisten sind in der Systemvariablen infolists enthalten. In diesem Kapitel werden die Informationslisten labels, values und myoptions erläutert. Wird eine Optionsvariable vom Nutzer gesetzt, kontrolliert die Optionsvariable optionset die Ausgabe weiterer Informationen. Folgende Symbole bezeichnen Variablen und Funktionen für Informationslisten und Optionsvariablen:

   infolists     labels        values 
   myoptions     optionset

Weitere Informationslisten, die in anderen Kapiteln erläutert werden, sind:

   functions      arrays         macros
   rules          aliases        dependencies 
   gradefs        props          let_rule_packages
   structures

Löschen und Rücksetzen

Um eine Maxima-Umgebung herzustellen, in der keine Variablen oder Funktionen definiert sind, oder um einzelne Zuweisungen, Eigenschaften oder Definitionen zu entfernen, kennt Maxima die folgenden Funktionen:

   kill     reset     reset_verbosely

Weitere Kommandos der Kommandozeile

Mit den Symbolen ? und ?? kann Dokumentation abgerufen werden. Wird ? einem Bezeichner als Präfix vorangestellt, wird der Bezeichner als Lisp-Symbol interpretiert. Mit weiteren Kommandos kann eine Maxima-Sitzung beendet oder zu einer Lisp-Sitzung gewechselt werden. Das Zeichen für die Eingabeaufforderung einer Unterbrechung kann geändert werden. Die Zeit für jede einzelne Berechnung kann angezeigt werden und die Ergebnisse einer Sitzung können wiederholt ausgegeben werden. Maxima kennt hierfür die folgenden Symbole:

   ?            ??
   playback     prompt     showtime
   quit         to_lisp

Die Funktionen read und readonly geben Ausdrücke auf der Konsole aus und lesen dann die Eingabe des Nutzers ein:

   read               readonly

Ausgabe auf der Konsole

Für die Ausgabe werden Ausdrücke von einer internen Darstellung in eine externe Darstellung transformiert. Zum Beispiel hat die Eingabe sqrt(x) eine interne Darstellung, die dem Ausdruck x^(1/2) entspricht. Für die Ausgabe wird die interne Darstellung in einen Ausdruck transformiert, die der Ausgabe sqrt(x) entspricht. Dieses Verhalten wird von der Optionsvariablen sqrtdispflag kontrolliert. Siehe Ausdrücke für Funktionen, die die interne und externe Darstellung von Ausdrücken unterscheiden.

Folgende Optionsvariablen und Symbole kontrollieren die Ausgabe auf der Konsole:

   %edispflag         absboxchar       display2d
   display_format_internal             exptdispflag
   expt               nexpt            ibase
   linel              lispdisp         negsumdispflag
   obase              pfeformat        powerdisp
   sqrtdispflag       stardisp         ttyoff

Mit folgenden Funktionen kann die Ausgabe auf der Konsole formatiert werden:

   disp               display          dispterms
   grind              ldisp            ldisplay
   print

4.2 Funktionen und Variablen der Eingabe

Operator: ; ¶

Mit dem Semikolon ; wird die Eingabe eines Maxima-Ausdrucks auf der Konsole und in einer Datei abgeschlossen. Es können mehrere Ausdrücke mit einem Semikolon als Abschluss auf einer Zeile eingegeben werden. Siehe auch $.

Beispiele:

(%i1) a:10;
(%o1)                          10
(%i2) a+b;
(%o2)                        b + 10
(%i3) x:10; x+y;
(%o3)                          10
(%o4)                        y + 10

Operator: $ ¶

Das Dollarzeichen schließt wie das Semikolon die Eingabe eines Ausdruckes auf der Konsole und in einer Datei ab. Im Unterschied zum Semikolon wird die Ausgabe des Ergebnisses unterdrückt. Das Ergebnis wird jedoch weiterhin einer Ausgabemarke %o zugewiesen und die Systemvariable % enthält das Ergebnis. Siehe auch ;.

Beispiele:

(%i1) expand((a+b)^2)$

(%i2) %;
                          2            2
(%o2)                    b  + 2 a b + a
(%i3) a:10$ a+b$

(%i5) %o3;
(%o5)                          10
(%i6) %o4;
(%o6)                        b + 10

Systemvariable: __ ¶

Während einer laufenden Auswertung enthält die Systemvariable __ den zuletzt vom Parser eingelesenen Ausdruck expr. Der Ausdruck expr wird der Systemvariablen __ vor der Auswertung und Vereinfachung zugewiesen.

Die Systemvariable __ wird von den Funktionen batch und load erkannt. Wird eine Datei mit der Funktion batch ausgeführt, hat __ dieselbe Bedeutung wie bei der Eingabe in einer Kommandozeile. Wird eine Datei mit dem Namen filename mit der Funktion load geladen, enthält __ den Ausdruck load(filename). Das ist die letzte Eingabe in der Kommandozeile.

Siehe auch die Systemvariablen _ und %.

Beispiele:

(%i1) print ("I was called as: ", __)$
I was called as:  print(I was called as, __) 

(%i2) foo (__);
(%o2)                     foo(foo(__))

(%i3) g (x) := (print ("Current input expression =", __), 0)$
(%i4) [aa : 1, bb : 2, cc : 3]$
(%i5) (aa + bb + cc)/(dd + ee + g(x))$

                            cc + bb + aa
Current input expression = -------------- 
                           g(x) + ee + dd

Systemvariable: _ ¶

Die Systemvariable _ enthält den zuletzt eingegebenen Ausdruck expr. Der Ausdruck expr wird der Systemvariablen _ vor der Auswertung und Vereinfachung zugewiesen.

Die Systemvariable _ wird von den Funktionen batch und load erkannt. Wird eine Datei mit der Funktion batch ausgeführt, hat _ dieselbe Bedeutung wie bei der Eingabe in einer Kommandozeile. Wird eine Datei mit der Funktion load geladen, enthält _ das zuletzt in der Kommandozeile eingegebene Kommando.

Siehe auch die Systemvariablen __ und %.

Beispiele:

Die Funktion cabs wird ausgewertet und nicht vereinfacht. Das Beispiel zeigt, dass die Systemvariable _ den zuletzt eingelesenen Ausdruck vor der Auswertung enthält.

(%i1) cabs(1+%i);
(%o1)                        sqrt(2)
(%i2) _;
(%o2)                     cabs(%i + 1)

Die Funktion abs vereinfacht einen Ausdruck. Wird der Inhalt der Systemvariablen _ ausgegeben, wird das für die Ausgabe vereinfachte Ergebnis angezeigt. Mit der Funktion string wird der Inhalt der Systemvariablen _ vor der Ausgabe in ein Zeichenkette umgewandelt, um den nicht vereinfachten Wert sichtbar zu machen.

(%i3) abs(1+%i);
(%o3)                        sqrt(2)
(%i4) _;
(%o4)                        sqrt(2)
(%i5) abs(1+%i);
(%o5)                        sqrt(2)
(%i6) string(_);
(%o6)                       abs(1+%i)

Systemvariable: % ¶

Die Systemvariable % enthält das Ergebnis des zuletzt von Maxima ausgewerteten und vereinfachten Ausdrucks. % enhält das letzte Ergebnis auch dann, wenn die Ausgabe des Ergebnisses durch Abschluss der Eingabe mit einem Dollarzeichen $ unterdrückt wurde.

Die Systemvariable % wird von den Funktionen batch und load erkannt. Wird eine Datei mit der Funktion batch ausgeführt, hat % dieselbe Bedeutung wie bei der Eingabe in einer Kommandozeile. Wird eine Datei mit der Funktion load geladen, enthält % das letzte Ergebnis des Ausdrucks, der auf der Konsole eingegeben wurde.

Siehe auch die Systemvariablen _, __ und %th.

Systemvariable: %% ¶

In zusammengesetzten Ausdrücken, wie in Ausdrücken mit block oder lambda oder in Ausdrücken der Gestalt (s_1, ..., s_n), enthält die Systemvariable %% das Ergebnis des vorhergehenden Ausdrucks. Für den ersten Ausdruck oder außerhalb eines zusammengesetzten Ausdrucks ist %% nicht definiert.

Die Systemvariable %% wird von batch und load erkannt und hat dieselbe Bedeutung wie bei der Eingabe in der Konsole. Siehe auch die Systemvariable % und die Funktion %th.

Beispiele:

Auf die im ersten Ausdruck berechnete Stammfunktion wird im zweiten Ausdruck mit %% Bezug genommen, um das Integral an der oberen und unteren Grenze auszuwerten.

(%i1) block (integrate (x^5, x), ev (%%, x=2) - ev (%%, x=1));
                               21
(%o1)                          --
                               2

Ein zusammengesetzter Ausdruck kann weitere zusammengesetzte Ausdrücke enthalten. %% enthält dabei jeweils das Ergebnis des letzten Ausdrucks. Das folgende Beispiel hat das Ergebnis 7*a^n.

(%i3) block (block (a^n, %%*42), %%/6);
                                 n
(%o3)                         7 a

Der Wert der Systemvariablen %% kann nach einer Unterbrechung mit dem Kommando break inspiziert werden. In diesem Beispiel hat die Systemvariable %% den Wert 42.

(%i4) block (a: 42, break ())$
Entering a Maxima break point. Type 'exit;' to resume.
_%%;
42
_

Funktion: %th (n) ¶

Die Funktion %th liefert das n-te vorhergehende Ergebnis. Dies ist dann nützlich, wenn wie in Batch-Dateien die absolute Zeilennummer der letzten Ausgabemarken nicht bekannt ist.

Die Funktion %th wird von den Funktionen batch und load erkannt. Wird eine Datei mit batch ausgeführt, hat %th dieselbe Bedeutung wie bei der Eingabe in der Konsole. Wird eine Datei mit der Funktion load geladen, enthält %th das letzte Ergebnis der Eingabe in der Konsole.

Siehe auch % und %%.

Beispiel:

Das Beispiel zeigt, wie die letzten 5 eingegebenen Werte mit der Funktion %th aufsummiert werden.

(%i1) 1;2;3;4;5;
(%o1)                           1
(%o2)                           2
(%o3)                           3
(%o4)                           4
(%o5)                           5
(%i6) block (s: 0, for i:1 thru 5 do s: s + %th(i), s);
(%o6)                          15

Spezielles Symbol: ? ¶

Wird dem Namen einer Funktion oder Variablen ein ? als Präfix vorangestellt, wird der Name als ein Lisp-Symbol interpretiert. Zum Beispiel bedeutet ?round die Lisp-Funktion ROUND. Siehe Lisp und Maxima für weitere Ausführungen zu diesem Thema.

Die Eingabe ? word ist eine Kurzschreibweise für das Kommando describe("word"). Das Fragezeichen muss am Anfang einer Eingabezeile stehen, damit Maxima die Eingabe als eine Anfrage nach der Dokumentation interpretiert. Siehe auch describe.

Spezielles Symbol: ?? ¶

Die Eingabe ?? word ist eine Kurzschreibweise für das Kommando describe("word", inexact). Die Fragezeichen müssen am Anfang einer Eingabezeile stehen, damit Maxima die Eingabe als eine Anfrage nach der Dokumentation interpretiert. Siehe auch describe.

Optionsvariable: inchar ¶

Standardwert: %i

Die Optionsvariable inchar enthält den Präfix der Eingabemarken. Maxima erzeugt die Eingabemarken automatisch aus dem Präfix inchar und der Zeilennummer linenum.

Der Optionsvariablen inchar kann eine Zeichenkette oder ein Symbol zugewiesen werden, die auch mehr als ein Zeichen haben können. Da Maxima intern nur das erste Zeichen berücksichtigt, sollten sich die Präfixe inchar, outchar und linechar im ersten Zeichen voneinander unterscheiden. Ansonsten funktionieren einige Kommandos wie zum Beispiel kill(inlabels) nicht wie erwartet.

Siehe auch die Funktion und Systemvariable labels sowie die Optionsvariablen outchar und linechar.

Beispiele:

(%i1) inchar: "input";
(%o1)                         input
(input2) expand((a+b)^3);
                     3        2      2      3
(%o2)               b  + 3 a b  + 3 a  b + a
(input3)

Systemvariable: infolists ¶

Die Systemvariable infolists enthält eine Liste der Informationslisten, die Maxima zur Verfügung stellt. Diese sind:

labels

Enthält die Marken %i, %o und %t, denen bisher ein Ausdruck zugewiesen wurde.

values

Enthält die vom Nutzer mit den Operatoren : oder :: definierten Variablen.

functions

Enthält die vom Nutzer mit dem Operator := oder der Funktion define definierten Funktionen.

arrays

Enthält die mit den Operatoren :, :: oder := definierten Arrays oder Array-Funktionen.

macros

Enthält die vom Nutzer mit dem Operator ::= definierten Makros.

myoptions

Enthält die Optionsvariablen, die vom Nutzer bisher einen neuen Wert erhalten haben.

rules

Enthält die vom Nutzer mit den Funktionen tellsimp, tellsimpafter, defmatch oder defrule definierten Regeln.

aliases

Enthält die Symbole, die einen vom Nutzer definierten Alias-Namen mit der Funktion alias erhalten haben. Weiterhin erzeugen die Funktionen ordergreat und orderless sowie eine Deklaration als noun mit der Funktion declare Alias-Namen, die in die Liste eingetragen werden.

dependencies

Enthält alle Symbole, für die mit den Funktionen depends oder gradef eine Abhängigkeit definiert ist.

gradefs

Enthält die Funktionen, für die der Nutzer mit der Funktion gradef eine Ableitung definiert hat.

props

Enthält die Symbole, die eine Eigenschaft mit der Funktion declare erhalten haben.

let_rule_packages

Enthält die vom Nutzer definierten let-Regeln.

Funktion: kill (a_1, …, a_n) ¶

Funktion: kill (labels) ¶

Funktion: kill (inlabels, outlabels, linelabels) ¶

Funktion: kill (n) ¶

Funktion: kill ([m, n]) ¶

Funktion: kill (values, functions, arrays, …) ¶

Funktion: kill (all) ¶

Funktion: kill (allbut (a_1, …, a_n)) ¶

Die Funktion kill entfernt alle Zuweisungen (Werte, Funktionen, Arrays oder Regeln) und Eigenschaften von den Argumenten a_1, …, a_n. Ein Argument a_k kann ein Symbol oder ein einzelnes Array-Element sein. Ist a_k ein einzelnes Array-Element, entfernt kill die Zuweisungen an dieses Element, ohne die anderen Elemente des Arrays zu beeinflussen.

kill kennt verschiedene spezielle Argumente, die auch kombiniert werden können wie zum Beispiel kill(inlabels, functions, allbut(foo, bar)).

kill(labels) entfernt alle Zuweisungen an Eingabe-, Ausgabe- und Zwischenmarken. kill(inlabels) entfernt nur die Zuweisungen an Eingabemarken, die mit dem aktuellen Wert von inchar beginnen. Entsprechend entfernt kill(outlabels) die Zuweisungen an die Ausgabemarken, die mit dem aktuellen Wert von outchar beginnen und kill(linelabels) die Zuweisungen an die Zwischenmarken, die mit dem aktuellen Wert von linechar beginnen.

kill(n), wobei n eine ganze Zahl ist, entfernt die Zuweisungen an die n letzten Eingabe- und Ausgabemarken. kill([m, n]) entfernt die Zuweisungen an die Eingabe- und Ausgabemarken mit den Nummern von m bis n.

kill(infolist), wobei infolist eine Informationsliste wie zum Beispiel values, functions oder arrays ist, entfernt die Zuweisungen an allen Einträgen der Liste infolist. Siehe auch infolists.

kill(all) entfernt die Zuweisungen an die Einträge in sämtlichen Informationslisten. kill(all) setzt keine Optionsvariablen auf ihre Standardwerte zurück. Siehe die Funktion reset, um Optionsvariablen auf ihre Standwerte zurückzusetzen.

kill(allbut(a_1, ..., a_n)) entfernt alle Zuweisungen bis auf Zuweisungen an die Variablen a_1, …, a_n. kill(allbut(infolist)) entfernt alle Zuweisungen bis auf denen in der Informationsliste infolist.

kill(symbol) entfernt sämtliche Zuweisungen und Eigenschaften des Symbols symbol. Im Gegensatz dazu entfernen remvalue, remfunction, remarray und remrule jeweils eine spezielle Eigenschaft eines Symbols.

kill wertet die Argumente nicht aus. Der Quote-Quote-Operator '' kann die Auswertung erzwingen. kill gibt immer done zurück.

Funktion: labels (symbol) ¶

Systemvariable: labels ¶

Die Funktion labels gibt eine Liste der Eingabe-, Ausgabe- und Zwischenmarken zurück, die mit dem Argument symbol beginnen. Typischerweise ist symbol der Wert von inchar, outchar oder linechar. Dabei kann das Prozentzeichen fortgelassen werden. So haben zum Beispiel die Kommandos labels(i) und labels(%i) dasselbe Ergebnis.

Wenn keine Marke mit symbol beginnt, gibt labels eine leere Liste zurück.

Die Funktion labels wertet das Argument nicht aus. Mit dem Quote-Quote-Operator '' kann die Auswertung erzwungen werden. Zum Beispiel gibt das Kommando labels(''inchar) die Marken zurück, die mit dem aktuellen Buchstaben für die Eingabemarken beginnen.

Die Systemvariable labels ist eine Informationsliste, die die Eingabe-, Ausgabe- und Zwischenmarken enthält. In der Liste sind auch die Marken enthalten, die vor einer Änderung von inchar, outchar oder linechar erzeugt wurden.

Standardmäßig zeigt Maxima das Ergebnis jeder Eingabe an, wobei dem Ergebnis eine Ausgabemarke hinzugefügt wird. Die Anzeige der Ausgabe wird durch die Eingabe eines abschließenden $ (Dollarzeichen) statt eines ; (Semikolon) unterdrückt. Dabei wird eine Ausgabemarke erzeugt und das Ergebnis zugewiesen, jedoch nicht angezeigt. Die Marke kann aber in der gleichen Art und Weise wie bei angezeigten Ausgabemarken referenziert werden. Siehe auch %, %% und %th.

Einige Funktionen erzeugen Zwischenmarken. Die Optionsvariable programmode kontrolliert, ob zum Beispiel solve und einige andere Funktionen Zwischenmarken erzeugen, anstatt eine Liste von Ausdrücken zurückzugeben. Andere Funktionen wie zum Beispiel ldisplay erzeugen stets Zwischenmarken.

Siehe auch infolists.

Optionsvariable: linechar ¶

Standardwert: %t

Die Optionsvariable linechar enthält den Präfix der Zwischenmarken. Maxima generiert die Zwischenmarken automatisch aus linechar.

Der Optionsvariablen linechar kann eine Zeichenkette oder ein Symbol zugewiesen werden, die auch mehr als ein Zeichen haben können. Da Maxima intern nur das erste Zeichen berücksichtigt, sollten sich die Präfixe inchar, outchar und linechar im ersten Zeichen voneinander unterscheiden. Ansonsten funktionieren einige Kommandos wie kill(inlabels) nicht wie erwartet.

Die Ausgabe von Zwischenmarken kann mit verschiedenen Optionsvariablen kontrolliert werden. Siehe programmode und labels.

Systemvariable: linenum ¶

Enthält die Zeilennummer der aktuellen Ein- und Ausgabemarken. Die Zeilennummer wird von Maxima automatisch erhöht. Siehe auch labels, inchar und outchar.

Systemvariable: myoptions ¶

myoptions ist eine Informationsliste, die die Optionsvariablen enthält, die vom Nutzer während einer Sitzung geändert wurden. Die Variable verbleibt in der Liste, auch wenn sie wieder auf den Standardwert zurückgesetzt wird.

Optionsvariable: nolabels ¶

Standardwert: false

Hat nolabels den Wert true, werden die Eingabe- und Ausgabemarken zwar angezeigt, ihnen werden aber keine Eingaben und Ergebnisse zugewiesen und sie werden nicht der Informationsliste labels hinzugefügt. Andernfalls werden den Marken die Eingabe und die Ergebnisse zugewiesen und in die Informationsliste labels eingetragen.

Zwischenmarken %t werden durch nolabels nicht beeinflusst. Den Marken werden unabhängig vom Wert, den nolabels hat, Zwischenergebnisse zugewiesen und sie werden in die Informationsliste labels eingetragen.

Siehe auch labels.

Optionsvariable: optionset ¶

Standardwert: false

Hat optionset den Wert true, gibt Maxima eine Meldung aus, wenn einer Optionsvariablen ein Wert zugewiesen wird.

Beispiel:

(%i1) optionset:true;
assignment: assigning to option optionset
(%o1)                         true
(%i2) gamma_expand:true;
assignment: assigning to option gamma_expand
(%o2)                         true

Optionsvariable: outchar ¶

Standardwert: %o

Die Optionsvariable outchar enthält den Präfix der Ausgabemarken. Maxima generiert die Ausgabemarken automatisch aus outchar und linenum.

Der Optionsvariablen outchar kann eine Zeichenkette oder ein Symbol zugewiesen werden, die auch mehr als ein Zeichen haben können. Da Maxima intern nur das erste Zeichen berücksichtigt, sollten sich die Präfixe inchar, outchar und linechar im ersten Zeichen voneinander unterscheiden. Ansonsten funktionieren einige Kommandos wie kill(inlabels) nicht wie erwartet.

Siehe auch labels.

Beispiele:

(%i1) outchar: "output";
(output1)                    output
(%i2) expand((a+b)^3);
                     3        2      2      3
(output2)           b  + 3 a b  + 3 a  b + a
(%i3) 

Funktion: playback () ¶

Funktion: playback (n) ¶

Funktion: playback ([m, n]) ¶

Funktion: playback ([m]) ¶

Funktion: playback (input) ¶

Funktion: playback (slow) ¶

Funktion: playback (time) ¶

Funktion: playback (grind) ¶

Zeigt Eingaben, Ergebnisse und Zwischenergebnisse an, ohne diese neu zu berechnen. playback zeigt nur die Eingaben und Ergebnisse an, die Marken zugewiesen wurden. Andere Ausgaben, wie zum Beispiel durch print, describe oder Fehlermeldungen, werden nicht angezeigt. Siehe auch labels.

playback() zeigt sämtliche Eingaben und Ergebnisse an, die bis dahin erzeugt wurden. Ein Ergebnis wird auch dann angezeigt, wenn die Ausgabe mit $ unterdrückt war.

playback(n) zeigt die letzten n Ausdrücke an. Jeder Eingabe-, Ausgabe- und Zwischenausdruck zählt dabei als ein Ausdruck. playback([m, n]) zeigt die Eingabe-, Ausgabe- und Zwischenausdrücke mit den Zahlen von m bis einschließlich n an. playback([m]) ist äquivalent zu playback([m, m]). Die Ausgabe ist ein Paar von Ein- und Ausgabeausdrücken.

playback(input) zeigt sämtliche Eingabeausdrücke an, die bis dahin erzeugt wurden.

playback(slow) macht nach jeder Ausgabe eine Pause und wartet auf eine Eingabe. Dieses Verhalten ist vergleichbar mit der Funktion demo.

playback(time) zeigt für jeden Ausdruck die für die Berechnung benötigte Zeit an.

playback(grind) zeigt die Eingabeausdrücke in dem gleichen Format an, wie die Funktion grind. Ausgabeausdrücke werden von der Option grind nicht beeinflusst. Siehe auch grind.

Die Argumente können kombiniert werden, wie zum Beispiel im folgenden Kommando playback([5, 10], grind, time, slow).

playback wertet die Argumente nicht aus. playback gibt stets done zurück.

Optionsvariable: prompt ¶

Standardwert: _

Die Optionsvariable prompt enthält das Zeichen für die Eingabeaufforderung der Funktionen demo und playback sowie nach einer Unterbrechung, wie zum Beispiel durch das Kommando break.

Funktion: quit ([returnwert]) ¶

Die Funktion quit() beendet eine Maxima-Sitzung. Die Funktion muss als quit(); oder quit()$, nicht quit allein aufgerufen werden. quit kann einen Returnwert retournieren, wenn der Lisp-Compiler und das Betriebssystem Returnwerte unterstützt. Standardmässig wird der Wert 0 retourniert (meist als kein Fehler interpretiert). quit(1) könnte der Shell daher einen Fehler anzeigen. Das kann für Skripte nützlich sein, wo Maxima dadurch anzeigen kann, dass Maxima irgendwas nicht berechnen konnte oder ein sonstiger Fehler aufgetreten ist.

Mit der Tastatureingabe control-c oder Strg-c kann in der Konsole die Verarbeitung abgebrochen werden. Standardmäßig wird die Maxima-Sitzung fortgesetzt. Hat die globale Lisp-Variable *debugger-hook* den Wert nil, wird der Lisp-Debugger gestartet. Siehe Fehlersuche.

Funktion: read (expr_1, …, expr_n) ¶

Gibt die Ausdrücke expr_1, … expr_n auf der Konsole aus, liest sodann einen Ausdruck von der Konsole ein und wertet diesen aus. Die Eingabe des Ausdrucks wird mit den Zeichen ; oder $ beendet.

Siehe auch readonly.

Beispiele:

(%i1) foo: 42$ 
(%i2) foo: read ("foo is", foo, " -- enter new value.")$
foo is 42  -- enter new value.
(a+b)^3;
(%i3) foo;
                                     3
(%o3)                         (b + a)

Funktion: readonly (expr_1, …, expr_n) ¶

Gibt die Ausdrücke expr_1, … expr_n auf der Konsole aus, liest sodann einen Ausdruck von der Konsole ein und gibt den eingelesenen Ausdruck zurück ohne diesen auszuwerten. Die Eingabe des Ausdrucks wird mit den Zeichen ; oder $ beendet.

Siehe auch read.

Beispiele:

(%i1) aa: 7$
(%i2) foo: readonly ("Enter an expression:");
Enter an expression: 
2^aa;
                                  aa
(%o2)                            2
(%i3) foo: read ("Enter an expression:");
Enter an expression: 
2^aa;
(%o3)                            128

Funktion: reset () ¶

reset() setzt globale Maxima- und Lisp-Variablen und Optionen auf ihre Standardwerte zurück. Maxima legt eine interne Liste mit den Standardwerten von globalen Variablen an. Alle Variablen, die in dieser Liste enthalten sind, werden auf ihre Standardwerte zurückgesetzt. Nicht alle globalen Variablen sind mit ihren Standwerten in diese Liste eingetragen. Daher kann reset die Anfangswerte stets nur unvollständig wiederherstellen.

reset(arg_1, ..., arg_n) setzt die Variablen arg_1, …, arg_n auf ihren Standardwert zurück.

reset gibt eine Liste mit den Variablen zurück, die auf ihren Standardwert zurückgesetzt wurden. Ist die Liste leer, wurden keine Variablen zurückgesetzt.

Siehe auch reset_verbosely.

Funktion: reset_verbosely () ¶

Funktion: reset_verbosely (arg_1, …, arg_n) ¶

Entspricht der Funktion reset. Im Unterschied zu reset wird zu jeder Variable, die zurückgesetzt wird, zusätzlich der Standardwert angezeigt.

Siehe reset.

Optionsvariable: showtime ¶

Standardwert: false

Hat showtime den Wert true, werden die interne Rechenzeit und die gesamte verstrichene Zeit zu jeder Ausgabe angezeigt.

Die Rechenzeit wird unabhängig vom Wert der Optionsvariablen showtime nach jeder Auswertung eines Ausdruckes in den Ausgabemarken abgespeichert. Daher können die Funktionen time und playback die Rechenzeit auch dann anzeigen, wenn showtime den Wert false hat.

Siehe auch timer.

Funktion: to_lisp () ¶

Wechselt zu einer Lisp-Sitzung. (to-maxima) wechselt von der Lisp-Sitzung zurück in die Maxima-Sitzung.

Beispiel:

Definiere eine Funktion und wechsle zu Lisp. Die Definition wird von der Eigenschaftsliste gelesen. Dann wird die Definition der Funktion geholt, faktorisiert und in der Variablen $result gespeichert. Die Variable kann nach der Rückkehr in Maxima genutzt werden.

(%i1) f(x):=x^2+x;
                                  2
(%o1)                    f(x) := x  + x
(%i2) to_lisp();
Type (to-maxima) to restart, ($quit) to quit Maxima.
MAXIMA> (symbol-plist '$f)
(MPROPS (NIL MEXPR ((LAMBDA) ((MLIST) $X) 
                             ((MPLUS) ((MEXPT) $X 2) $X))))
MAXIMA> (setq $result ($factor (caddr (mget '$f 'mexpr))))
((MTIMES SIMP FACTORED) $X ((MPLUS SIMP IRREDUCIBLE) 1 $X))
MAXIMA> (to-maxima)
Returning to Maxima
(%o2)                         true
(%i3) result;
(%o3)                       x (x + 1)

Systemvariable: values ¶

Anfangswert: []

values ist eine Informationsliste, die die Variablen enthält, die vom Nutzer mit den Operatoren : oder :: einen Wert erhalten haben. Wird der Wert einer Variablen mit den Kommandos kill, remove oder remvalue entfernt, wird die Variable von der Liste values entfernt.

Siehe auch functions für die Informationsliste mit den vom Nutzer definierten Funktionen sowie infolists.

Beispiele:

(%i1) [a:99, b::a-90, c:a-b, d, f(x):= x^2];
                                           2
(%o1)              [99, 9, 90, d, f(x) := x ]
(%i2) values;
(%o2)                       [a, b, c]
(%i3) [kill(a), remove(b,value), remvalue(c)];
(%o3)                   [done, done, [c]]
(%i4) values;
(%o4)                          []

4.3 Funktionen und Variablen der Ausgabe

Optionsvariable: %edispflag ¶

Standardwert: false

Hat %edispflag den Wert true, zeigt Maxima die Exponentiation von %e mit einem negativen Exponenten als Quotienten an. Siehe auch die Optionsvariable exptdispflag.

Beispiel:

(%i1) %e^-10;
                               - 10
(%o1)                        %e
(%i2) %edispflag:true$
(%i3) %e^-10;
                               1
(%o3)                         ----
                                10
                              %e

Optionsvariable: absboxchar ¶

Standardwert: !

Die Optionsvariable absboxchar enthält das Zeichen, das von Maxima benutzt wird, um den Betrag eines Ausdruckes anzuzeigen, der mehr als eine Zeile benötigt.

Beispiel:

(%i1) abs((x^3+1));
                            ! 3    !
(%o1)                       !x  + 1!

Funktion: disp (expr_1, expr_2, …) ¶

Ist ähnlich wie die Funktion display. Die Funktion disp zeigt jedoch keine Gleichungen sondern nur die Ergebnisse der Ausdrücke expr_1, expr_2, … an.

Siehe auch die Funktionen ldisp, display und print.

Beispiele:

(%i1) b[1,2]:x-x^2$
(%i2) x:123$
(%i3) disp(x, b[1,2], sin(1.0));
                               123

                                  2
                             x - x

                        .8414709848078965

(%o3)                         done

Funktion: display (expr_1, expr_2, …) ¶

Die Variablen oder Ausdrücke expr_i werden als eine Gleichung ausgegeben. Die linke Seite der Gleichung ist die Variable oder der Ausdruck expr_i und die rechte Seite der Wert der Variablen oder das Ergebnis des Ausdrucks. Die Argumente können Variable, indizierte Variable oder Funktionen sein.

Siehe auch die Funktionen ldisplay, disp und ldisp.

Beispiele:

(%i1) b[1,2]:x-x^2$
(%i2) x:123$
(%i3) display(x, b[1,2], sin(1.0));
                             x = 123

                                      2
                         b     = x - x
                          1, 2

                  sin(1.0) = .8414709848078965

(%o3)                         done

Optionsvariable: display2d ¶

Standardwert: true

Hat display2d den Wert false, werden Ausdrücke auf der Konsole linear und nicht zweidimensional angezeigt.

Siehe auch die Optionsvariable leftjust, um Formeln linksbündig auszugeben.

Beispiel:

(%i1) x/(x^2+1);
                               x
(%o1)                        ------
                              2
                             x  + 1
(%i2) display2d:false$
(%i3) x/(x^2+1);
(%o3) x/(x^2+1)

Optionsvariable: display_format_internal ¶

Standardwert: false

Hat display_format_internal den Wert true, werden Ausdrücke für die Anzeige nicht in die externe Darstellung transformiert. Die Ausgabe erfolgt wie in der internen Darstellung. Das entspricht der Rückgabe der Funktion inpart.

Siehe die Funktion dispform für Beispiele, die den Unterschied zwischen der internen und der externen Darstellung zeigen.

Funktion: dispterms (expr) ¶

Der Ausdruck expr wird zeilenweise ausgegeben. Auf der ersten Zeile wird der Operator des Ausdrucks expr ausgegeben. Dann werden die Argumente des Operators zeilenweise ausgegeben. Dies kann nützlich sein, wenn ein Ausdruck sehr lang ist.

Beispiel:

(%i1) dispterms(2*a*sin(x)+%e^x);

+

2 a sin(x)

  x
%e

(%o1)                         done

Spezielles Symbol: expt (a, b) ¶

Spezielles Symbol: ncexpt (a, b) ¶

Ist ein Exponentialausdruck zu lang, um ihn als a^b anzuzeigen, wird stattdessen expt(a, b) angezeigt. Entsprechend wird statt a^^b, ncexpt(a, b) angezeigt. expt und ncexpt sind keine Funktionen und erscheinen nur in der Ausgabe.

Optionsvariable: exptdispflag ¶

Standardwert: true

Hat die Optionsvariable exptdispflag den Wert true, werden Ausdrücke mit einem negativen Exponenten als Quotient angezeigt. Siehe auch die Optionsvariable %edispflag.

Beispiele:

(%i1) exptdispflag:true;
(%o1)                         true
(%i2) 10^-x;
                                1
(%o2)                          ---
                                 x
                               10
(%i3) exptdispflag:false;
(%o3)                         false
(%i4) 10^-x;
                                - x
(%o4)                         10

Funktion: grind (expr) ¶

Optionsvariable: grind ¶

Die Funktion grind gibt den Ausdruck expr auf der Konsole in einer Form aus, die für die Eingabe in Maxima geeignet ist. grind gibt done zurück.

Ist expr der Name einer Funktion oder eines Makros, gibt grind die Definition der Funktion oder des Makros aus.

Siehe auch die Funktion string, die einen Ausdruck als eine Zeichenkette zurückgibt.

Hat die Optionsvariable grind den Wert true, haben die Ergebnisse der Funktionen stringout und string dasselbe Format wie die Funktion grind. Ansonsten werden keine spezielle Formatierungen von diesen Funktionen vorgenommen. Der Standardwert der Optionsvariablen grind ist false.

grind kann auch ein Argument der Funktion playback sein. In diesem Fall gibt playback die Eingabe im gleichen Format wie die Funktion grind aus.

grind wertet das Argument aus.

Beispiele:

(%i1) aa + 1729;
(%o1)                       aa + 1729
(%i2) grind (%);
aa+1729$
(%o2)                         done
(%i3) [aa, 1729, aa + 1729];
(%o3)                 [aa, 1729, aa + 1729]
(%i4) grind (%);
[aa,1729,aa+1729]$
(%o4)                         done
(%i5) matrix ([aa, 17], [29, bb]);
                           [ aa  17 ]
(%o5)                      [        ]
                           [ 29  bb ]
(%i6) grind (%);
matrix([aa,17],[29,bb])$
(%o6)                         done
(%i7) set (aa, 17, 29, bb);
(%o7)                   {17, 29, aa, bb}
(%i8) grind (%);
{17,29,aa,bb}$
(%o8)                         done
(%i9) exp (aa / (bb + 17)^29);

                                aa
                            -----------
                                     29
                            (bb + 17)
(%o9)                     %e

(%i10) grind (%);
%e^(aa/(bb+17)^29)$
(%o10)                        done
(%i11) expr: expand ((aa + bb)^10);

         10           9        2   8         3   7         4   6
(%o11) bb   + 10 aa bb  + 45 aa  bb  + 120 aa  bb  + 210 aa  bb
         5   5         6   4         7   3        8   2
 + 252 aa  bb  + 210 aa  bb  + 120 aa  bb  + 45 aa  bb
        9        10
 + 10 aa  bb + aa

(%i12) grind (expr);

bb^10+10*aa*bb^9+45*aa^2*bb^8+120*aa^3*bb^7+210*aa^4*bb^6
     +252*aa^5*bb^5+210*aa^6*bb^4+120*aa^7*bb^3+45*aa^8*bb^2
     +10*aa^9*bb+aa^10$
(%o12)                        done

(%i13) string (expr);
(%o13) bb^10+10*aa*bb^9+45*aa^2*bb^8+120*aa^3*bb^7+210*aa^4*bb^6\
+252*aa^5*bb^5+210*aa^6*bb^4+120*aa^7*bb^3+45*aa^8*bb^2+10*aa^9*\
bb+aa^10

Optionsvariable: ibase ¶

Standardwert: 10

ibase enthält die Basis der ganzen Zahlen, welche von Maxima eingelesen werden.

ibase kann eine ganze Zahl zwischen 2 und einschließlich 36 zugewiesen werden. Ist ibase größer als 10, werden die Zahlen 0 bis 9 und die Buchstaben A, B, C, … für die Darstellung der Zahl in der Basis ibase herangezogen. Große und kleine Buchstaben werden nicht unterschieden. Die erste Stelle muss immer eine Ziffer sein, damit Maxima den eingelesenen Ausdruck als eine Zahl interpretiert.

Gleitkommazahlen werden immer zur Basis 10 interpretiert.

Siehe auch obase.

Beispiele:

ibase ist kleiner als 10.

(%i1) ibase : 2 $
(%i2) obase;
(%o2)                          10
(%i3) 1111111111111111;
(%o3)                         65535

ibase ist größer als 10. Die erste Stelle muss eine Ziffer sein.

(%i1) ibase : 16 $
(%i2) obase;
(%o2)                          10
(%i3) 1000;
(%o3)                         4096
(%i4) abcd;
(%o4)                         abcd
(%i5) symbolp (abcd);
(%o5)                         true
(%i6) 0abcd;
(%o6)                         43981
(%i7) symbolp (0abcd);
(%o7)                         false

Wird eine ganze Zahl mit einem Dezimalpunkt beendet, wird die Zahl als Gleitkommazahl interpretiert.

(%i1) ibase : 36 $
(%i2) obase;
(%o2)                          10
(%i3) 1234;
(%o3)                         49360
(%i4) 1234.;
(%o4)                         1234

Funktion: ldisp (expr_1, …, expr_n) ¶

Die Ausdrücke expr_1, …, expr_n werden auf der Konsole ausgegeben. Dabei wird jedem Ausdruck eine Zwischenmarke zugewiesen. Die Liste der Zwischenmarken wird als Ergebnis zurückgegeben.

Siehe auch die Funktionen disp, display und ldisplay.

(%i1) e: (a+b)^3;
                                   3
(%o1)                       (b + a)

(%i2) f: expand (e);
                     3        2      2      3
(%o2)               b  + 3 a b  + 3 a  b + a
(%i3) ldisp (e, f);
                                   3
(%t3)                       (b + a)

                     3        2      2      3
(%t4)               b  + 3 a b  + 3 a  b + a

(%o4)                      [%t3, %t4]
(%i4) %t3;
                                   3
(%o4)                       (b + a)
(%i5) %t4;
                     3        2      2      3
(%o5)               b  + 3 a b  + 3 a  b + a

Funktion: ldisplay (expr_1, …, expr_n) ¶

Die Ausdrücke expr_1, …, expr_n werden als eine Gleichung der Form lhs = rhs ausgegeben. lhs ist eines der Argumente der Funktion ldisplay und rhs ist der Wert oder das Ergebnis des Argumentes. Im Unterschied zur Funktion display wird jeder Gleichung eine Zwischenmarke zugewiesen, die als Liste zurückgegeben werden.

Siehe auch display, disp und ldisp.

Beispiele:

(%i1) e: (a+b)^3;
                                   3
(%o1)                       (b + a)
(%i2) f: expand (e);
                     3        2      2      3
(%o2)               b  + 3 a b  + 3 a  b + a
(%i3) ldisplay (e, f);
                                     3
(%t3)                     e = (b + a)

                       3        2      2      3
(%t4)             f = b  + 3 a b  + 3 a  b + a

(%o4)                      [%t3, %t4]
(%i4) %t3;
                                     3
(%o4)                     e = (b + a)
(%i5) %t4;
                       3        2      2      3
(%o5)             f = b  + 3 a b  + 3 a  b + a

Optionsvariable: leftjust ¶

Standardwert: false

Hat die Optionsvariable leftjust den Wert true, werden Formeln linksbündig und nicht zentriert ausgegeben.

Siehe auch die Optionsvariable display2d, um zwischen der 1D- und 2D-Anzeige umzuschalten.

Beispiel:

(%i1) expand((x+1)^3);
                        3      2
(%o1)                  x  + 3 x  + 3 x + 1
(%i2) leftjust:true$
(%i3) expand((x+1)^3);
       3      2
(%o3) x  + 3 x  + 3 x + 1

Optionsvariable: linel ¶

Standardwert: 79

Die Optionsvariable linel enthält die Anzahl der Zeichen einer Zeile der Ausgabe. linel können beliebige positive ganze Zahlen zugewiesen werden, wobei sehr kleine oder große Werte unpraktisch sein können. Text, der von internen Funktionen ausgegeben wird, wie Fehlermeldungen oder Ausgaben der Hilfe, werden von linel nicht beeinflusst.

Optionsvariable: lispdisp ¶

Standardwert: false

Hat die Optionsvariable lispdisp den Wert true, werden Lisp-Symbole mit einem vorangestelltem Fragezeichen ? angezeigt.

Beispiele:

(%i1) lispdisp: false$
(%i2) ?foo + ?bar;
(%o2)                       foo + bar
(%i3) lispdisp: true$
(%i4) ?foo + ?bar;
(%o4)                      ?foo + ?bar

Optionsvariable: negsumdispflag ¶

Standardwert: true

Hat negsumdispflag den Wert true, wird eine Differenz mit zwei Argumenten x - y als x - y und nicht als -y + x angezeigt. Hat negsumdispflag den Wert false, wird die Differenz als -y + x angezeigt.

Optionsvariable: obase ¶

Standardwert: 10

obase enthält die Basis für ganze Zahlen für die Ausgabe von Maxima. obase kann eine ganze Zahl zwischen 2 und einschließlich 36 zugewiesen werden. Ist obase größer als 10, werden die Zahlen 0 bis 9 und die Buchstaben A, B, C, … für die Darstellung der Zahl in der Basis obase herangezogen. Große und kleine Buchstaben werden nicht unterschieden. Die erste Stelle ist immer eine Ziffer.

Siehe auch ibase.

Beispiele:

(%i1) obase : 2;
(%o1)                          10
(%i2) 2^8 - 1;
(%o10)                      11111111
(%i3) obase : 8;
(%o3)                          10
(%i4) 8^8 - 1;
(%o4)                       77777777
(%i5) obase : 16;
(%o5)                          10
(%i6) 16^8 - 1;
(%o6)                       0FFFFFFFF
(%i7) obase : 36;
(%o7)                          10
(%i8) 36^8 - 1;
(%o8)                       0ZZZZZZZZ

Optionsvariable: pfeformat ¶

Standardwert: false

Hat die Optionsvariable pfeformat den Wert true, werden Brüche mit ganzen Zahlen auf einer Zeile mit dem Zeichen / dargestellt. Ist der Nenner eine ganze Zahl, wird dieser als 1/n vor den Ausdruck gestellt.

Beispiele:

(%i1) pfeformat: false$
(%i2) 2^16/7^3;
                              65536
(%o2)                         -----
                               343
(%i3) (a+b)/8;
                              b + a
(%o3)                         -----
                                8
(%i4) pfeformat: true$ 
(%i5) 2^16/7^3;
(%o5)                       65536/343
(%i6) (a+b)/8;
(%o6)                      1/8 (b + a)

Optionsvariable: powerdisp ¶

Standardwert: false

Hat powerdisp den Wert true, werden die Terme einer Summe mit steigender Potenz angezeigt. Der Standardwert ist false und die Terme werden mit fallender Potenz angezeigt.

Beispiele:

(%i1) powerdisp:true;
(%o1)                         true
(%i2) x^2+x^3+x^4;
                           2    3    4
(%o2)                     x  + x  + x
(%i3) powerdisp:false;
(%o3)                         false
(%i4) x^2+x^3+x^4;
                           4    3    2
(%o4)                     x  + x  + x

Funktion: print (expr_1, …, expr_n) ¶

Wertet die Argumente expr_1, …, expr_n nacheinander von links nach rechts aus und zeigt die Ergebnisse an. print gibt das Ergebnis des letzten Arguments als Ergebnis zurück. print erzeugt keine Zwischenmarken.

Siehe auch display, disp, ldisplay und ldisp. Siehe printfile, um den Inhalt einer Datei anzuzeigen.

Beispiele:

(%i1) r: print ("(a+b)^3 is", expand ((a+b)^3), "log (a^10/b) is",
      radcan (log (a^10/b)))$
            3        2      2      3
(a+b)^3 is b  + 3 a b  + 3 a  b + a  log (a^10/b) is 

                                              10 log(a) - log(b) 
(%i2) r;
(%o2)                  10 log(a) - log(b)
(%i3) disp ("(a+b)^3 is", expand ((a+b)^3), "log (a^10/b) is",
      radcan (log (a^10/b)))$
                           (a+b)^3 is

                     3        2      2      3
                    b  + 3 a b  + 3 a  b + a

                         log (a^10/b) is

                       10 log(a) - log(b)

Optionsvariable: sqrtdispflag ¶

Standardwert: true

Hat die Optionsvariable den Wert false, wird die Wurzelfunktion als Exponentiation mit dem Exponenten 1/2 angezeigt.

Optionsvariable: stardisp ¶

Standardwert: false

Hat die Optionsvariable stardisp den Wert true, wird die Multiplikation mit einem Stern * angezeigt.

Optionsvariable: ttyoff ¶

Standardwert: false

Hat die Optionsvariable ttyoff den Wert true, werden Ergebnisse nicht angezeigt. Die Ergebnisse werden weiter berechnet und sie werden Marken zugewiesen. Siehe labels.

Textausgaben von Funktionen, wie Fehlermeldungen und Ausgaben der Hilfe mit describe werden nicht beeinflusst.

5.1 Zahlen

• Einführung in Zahlen
• Funktionen und Variablen für Zahlen

(%i1) 1/3+5/4+3;
                               55
(%o1)                          --
                               12
(%i2) 100!;
(%o2) 9332621544394415268169923885626670049071596826438162146859\
2963895217599993229915608941463976156518286253697920827223758251\
185210916864000000000000000000000000
(%i3) 100!/101!;
                                1
(%o3)                          ---
                               101

   integerp       numberp       nonnegintegerp     
   oddp           evenp
   ratnump        rationalize

(%i1) [2.0,1f10,1,e10,1d10,1d300];
(%o1)        [2.0, 1.e+10, 1, e10, 1.e+10, 1.e+300]
(%i2) [2.0b0,1b10,1b300];
(%o2)               [2.0b0, 1.0b10, 1.0b300]

(%i1) 2.0+1/2+3;
(%o1)                                 5.5
(%i2) 2.0b0+1/2+3;
(%o2)                                5.5b0

(%i1) float([2,1/2,1/3,2.0b0]);
(%o1)          [2.0, 0.5, .3333333333333333, 2.0]
(%i2) bfloat([2,1/2,1/3,2.0b0]);
(%o2)     [2.0b0, 5.0b-1, 3.333333333333333b-1, 2.0b0]

   float        floatnump     
   bfloat       bfloatp       fpprec
   float2bf     bftorat       ratepsilon

   number_pbranch 
   m1pbranch

   realpart     imagpart      rectform     polarform
   cabs         carg          conjugate    csign

5.2 Zeichenketten

• Einführung in Zeichenketten
• Funktionen und Variablen für Zeichenketten

   concat   sconcat   string   stringdisp

(%i1) s_1 : "This is a string.";
(%o1)               This is a string.
(%i2) s_2 : "Embedded \"double quotes\" and backslash \\ characters.";
(%o2) Embedded "double quotes" and backslash \ characters.
(%i3) s_3 : "Embedded line termination
in this string.";
(%o3) Embedded line termination
in this string.
(%i4) s_4 : "Ignore the \
line termination \
characters in \
this string.";
(%o4) Ignore the line termination characters in this string.
(%i5) stringdisp : false;
(%o5)                         false
(%i6) s_1;
(%o6)                   This is a string.
(%i7) stringdisp : true;
(%o7)                         true
(%i8) s_1;
(%o8)                  "This is a string."

5.3 Funktionen und Variablen für Konstante

Konstante: %e ¶

%e ist die Basis des natürlichen Logarithmus, auch Eulersche Zahl genannt. Der numerische Wert der Konstanten als Gleitkommazahl mit doppelter Genauigkeit ist 2.718281828459045d0.

Die Funktion bfloat kann %e mit einer beliebigen Genauigkeit berechnen.

Hat die Optionsvariable numer den Wert true, wird %e durch den numerischen Wert ersetzt, aber nicht, wenn %e die Basis der Exponentiation mit einem symbolischen Exponenten ist. Hat zusätzlich die Optionsvariable %enumer den Wert true, dann wird %e in einem Ausdruck immer durch den numerischen Wert ersetzt.

Beispiel:

Berechnung von %e auf 48 Stellen.

(%i1) fpprec: 48$
(%i2) bfloat(%e);
(%o2)  2.7182818284590452353602874713526624977572470937b0

Die Wirkung der Optionsvariablen numer und %enumer auf das Ersetzen von %e durch den numerischen Wert.

(%i1) %e, numer;
(%o1)                   2.718281828459045
(%i2) %e^x, numer;
                                 x
(%o2)                          %e
(%i3) %e^x, numer, %enumer;
                                        x
(%o3)                  2.718281828459045

Im ersten Beispiel vereinfacht die Reihe zu %e. Für die Vereinfachung der Reihe wird die Funktion simplify_sum geladen. Im zweiten Beispiel ist %e der Grenzwert.

(%i1) load("simplify_sum")$

(%i2) sum(1/n!, n, 0, inf);
                            inf
                            ====
                            \     1
(%o2)                        >    --
                            /     n!
                            ====
                            n = 0
(%i3) simplify_sum(%);

(%o3)                          %e

(%i4) limit((1+x)^(1/x), x, 0);
(%o4)                          %e

Konstante: %i ¶

%i ist die imaginäre Einheit.

Maxima kennt keinen eigenen Typ für komplexe Zahlen. Komplexe Zahlen werden von Maxima intern als die Addition von Realteil und dem mit der imaginären Einheit %i multiplizierten Imaginärteil dargestellt. Zum Beispiel sind die komplexen Zahlen 2 + 3*%i und 2 - 3*%i die Wurzeln der Gleichung x^2 - 4*x + 13 = 0. Siehe auch das Kapitel Zahlen.

Beispiele:

Einige Beispiele für das Rechnen mit der imaginären Einheit.

(%i1) sqrt(-1);
(%o1)                          %i
(%i2) %i^2;
(%o2)                          - 1
(%i3) exp(%i*%pi/2);
(%o3)                          %i
(%i4) sin(%i*x);
(%o4)                      %i sinh(x)

Konstante: false ¶

Repräsentiert den logischen Wert falsch. false wird intern von Maxima durch die Lisp-Konstante NIL dargestellt.

Siehe auch true für den logischen Wert wahr.

Konstante: %gamma ¶

Die Euler-Mascheroni-Konstante mit dem Wert 0.5772156649015329 als Gleitkommazahl in doppelter Genauigkeit.

Die Funktion bfloat kann %gamma mit einer beliebigen Genauigkeit berechnen.

Hat die Optionsvariable numer den Wert true, wird die Konstante %gamma durch ihren numerischen Wert ersetzt.

Beispiele:

Numerische Werte für %gamma.

(%i1) %gamma, numer;
(%o1)                   .5772156649015329
(%i2) bfloat(%gamma), fpprec: 48;
(%o2)  5.7721566490153286060651209008240243104215933594b-1

Bestimmte Integrale, die %gamma als Ergebnis haben.

(%i1) -integrate(exp(-t)*log(t), t, 0, inf);
(%o1)                        %gamma
(%i2) -integrate(log(log(1/t)),t, 0,1);
(%o2)                        %gamma

Konstante: ind ¶

ind repräsentiert ein unbestimmtes Ergebnis. Siehe auch und und die Funktion limit.

Beispiel:

(%i1) limit(sin(1/x), x, 0);
(%o1)                          ind

Konstante: inf ¶

inf repräsentiert einen positiven unendlich großen Wert. Siehe auch minf und infinity.

Die unendlichen Größen, aber auch die unbestimmten Größen ind und und, eignen sich nicht für das arithmetische Rechnen. Diese Größen werden von Maxima in Rechnungen wie Symbole behandelt, was zu fehlerhaften Ergebnissen führt. Daher sollten unendliche Größen nur im Zusammenhang mit Grenzwerten limit, bestimmten Integralen integrate oder Reihen sum verwendet werden.

Konstante: infinity ¶

infinity repräsentiert einen komplexen unendlichen Wert. Siehe auch inf und minf.

Die unendlichen Größen, aber auch die unbestimmten Größen ind und und, eignen sich nicht für das arithmetische Rechnen. Diese Größen werden von Maxima in Rechnungen wie Symbole behandelt, was zu fehlerhaften Ergebnissen führt. Daher sollten unendliche Größen nur im Zusammenhang mit Grenzwerten limit, bestimmten Integralen integrate oder Reihen sum verwendet werden.

Konstante: minf ¶

minf repräsentiert einen negativen unendlichen Wert. Siehe auch inf und infinity.

Die unendlichen Größen, aber auch die unbestimmten Größen ind und und, eignen sich nicht für das arithmetische Rechnen. Diese Größen werden von Maxima in Rechnungen wie Symbole behandelt, was zu fehlerhaften Ergebnissen führt. Daher sollten unendliche Größen nur im Zusammenhang mit Grenzwerten limit, bestimmten Integralen integrate oder Reihen sum verwendet werden.

Konstante: %phi ¶

%phi repräsentiert die Goldene Zahl (1 + sqrt(5))/2. Der Wert als Gleitkommazahl in doppelter Genauigkeit ist 1.618033988749895d0.

Die Funktion fibtophi drückt Fibonacci-Zahlen fib(n) durch die Goldene Zahl %phi aus. Standardmäßig kennt Maxima keine algebraischen Eigenschaften der Konstanten %phi. Mit den Eingaben tellrat(%phi^2-%phi-1) und algebraic: true kann die Funktion ratsimp einige Vereinfachungen ausführen.

Die Funktion bfloat kann %phi mit einer beliebigen Genauigkeit berechnen. Hat die Optionsvariable numer den Wert true, wird die Konstante %phi durch ihren numerischen Wert ersetzt.

Beispiele:

Numerische Werte für %phi.

(%i1) %phi, numer;
(%o1)                   1.618033988749895
(%i2) bfloat(%phi), fpprec: 48;
(%o2)  1.61803398874989484820458683436563811772030917981b0

fibtophi drückt Fibonacci-Zahlen fib(n) durch %phi aus.

(%i1) fibtophi (fib (n));
                           n             n
                       %phi  - (1 - %phi)
(%o1)                  -------------------
                           2 %phi - 1
(%i2) fib (n-1) + fib (n) - fib (n+1);
(%o2)          - fib(n + 1) + fib(n) + fib(n - 1)
(%i3) fibtophi (%);

            n + 1             n + 1       n             n
        %phi      - (1 - %phi)        %phi  - (1 - %phi)
(%o3) - --------------------------- + -------------------
                2 %phi - 1                2 %phi - 1
                                          n - 1             n - 1
                                      %phi      - (1 - %phi)
                                    + ---------------------------
                                              2 %phi - 1

(%i4) ratsimp (%);
(%o4)                           0

Mit den Eingaben tellrat(%phi^2-%phi-1) und algebraic:true kann die Funktion ratsimp einige Vereinfachungen für Ausdrücke ausführen, die %phi enthalten.

(%i1) e : expand ((%phi^2 - %phi - 1) * (A + 1));
                 2                      2
(%o1)        %phi  A - %phi A - A + %phi  - %phi - 1
(%i2) ratsimp (e);
                  2                     2
(%o2)        (%phi  - %phi - 1) A + %phi  - %phi - 1
(%i3) tellrat (%phi^2 - %phi - 1);
                            2
(%o3)                  [%phi  - %phi - 1]
(%i4) algebraic : true;
(%o4)                         true
(%i5) ratsimp (e);
(%o5)                           0

Konstante: %pi ¶

%pi repräsentiert die Kreiszahl. Der numerische Wert als Gleitkommazahl in doppelter Genauigkeit ist 3.141592653589793d0.

Die Funktion bfloat kann %pi mit einer beliebigen Genauigkeit berechnen. Hat die Optionsvariable numer den Wert true, wird die Konstante %pi durch ihren numerischen Wert ersetzt.

Beispiele:

Numerische Werte für %pi.

(%i1) %pi, numer;
(%o1)                   3.141592653589793
(%i2) bfloat(%pi), fpprec:48;
(%o2)  3.14159265358979323846264338327950288419716939938b0

Grenzwert und bestimmte Integrale, die %pi als Ergebnis haben.

(%i1) 'limit(n!^2*(n+1)^(2*n^2+n)/(2*n^(2*n^2+3*n+1)),n,inf);
                        2                     2
                   - 2 n  - 3 n - 1        2 n  + n   2
         limit    n                 (n + 1)         n!
         n -> inf
(%o1)    ----------------------------------------------
                               2
(%i2) %, nouns;
(%o2)                          %pi
(%i3) 'integrate(4*sqrt(1-t^2),t,0,1);
                         1
                        /
                        [            2
(%o3)                 4 I  sqrt(1 - t ) dt
                        ]
                        /
                         0
(%i4) %, nouns;
(%o4)                          %pi
(%i5) 'integrate(2*exp(-t^2),t,0,inf);
                           inf
                          /         2
                          [      - t
(%o5)                   2 I    %e     dt
                          ]
                          /
                           0
(%i6) %, nouns;
(%o6)                       sqrt(%pi)

Konstante: true ¶

true repräsentiert den logischen Wert wahr. Intern ist true als die Lisp-Konstante T implementiert.

Siehe auch false für den logischen Wert falsch.

Konstante: und ¶

und repräsentiert ein nicht definiertes Ergebnis. Siehe auch ind und die Funktion limit.

Beispiel:

(%i1) limit (x*sin(x), x, inf);
(%o1)                          und

Konstante: zeroa ¶

zeroa repräsentiert eine positive unendlich kleine Zahl. zeroa kann in Ausdrücken benutzt werden. Die Funktion limit vereinfacht Ausdrücke, die infinitesimale Größen enthalten.

Siehe auch zerob und limit.

Beispiele:

limit vereinfacht Ausdrücke, die infinitesimale Größen enthalten.

(%i1) limit(zeroa);
(%o1)                           0
(%i2) limit(x+zeroa);
(%o2)                           x

Konstante: zerob ¶

zerob repräsentiert eine negative unendlich kleine Zahl. zerob kann in Ausdrücken benutzt werden. Die Funktion limit vereinfacht Ausdrücke, die infinitesimale Größen enthalten.

Siehe auch zeroa und limit.

5.4 Listen

• Einführung in Listen
• Funktionen und Variablen für Listen

[a, b, c, ...]

(%i1) [1, 1/2, a, a+b, sin(x), [log(y)^2, y]];
                 1                        2
(%o1)        [1, -, a, b + a, sin(x), [log (y), y]]
                 2

   append        assoc     cons      copylist
   create_list   delete    eighth    endcons
   fifth         first     fourth    join
   last          length    listp     makelist
   member        ninth     pop       push
   rest          reverse   second    seventh
   sixth         sort      sublist   sublist_indices
   tenth         third

   ((MPLUS) $A $B $C)

(%i1) expr: a + b + c;
(%o1)                       c + b + a
(%i2) first(expr);
(%o2)                           c
(%i3) last(expr);
(%o3)                           a
(%i4) cons(2*x, expr);
(%o4)                    2 x + c + b + a
(%i5) delete(b, expr);
(%o5)                         c + a

(%i1) list : [a,b,c];
(%o1)                       [a, b, c]
(%i2) list[1];
(%o2)                           a
(%i3) list[2];
(%o3)                           b
(%i4) list[3];
(%o4)                           c
(%i5) list[1]: sin(x);
(%o5)                        sin(x)
(%i6) list[2]: cos(x);
(%o6)                        cos(x)
(%i7) list[3]: tan(x);
(%o7)                        tan(x)
(%i8) list;
(%o8)               [sin(x), cos(x), tan(x)]

(%i1) sin([x,y,z]);
(%o1)               [sin(x), sin(y), sin(z)]
(%i2) mod([x,y],3);
(%o2)                [mod(x, 3), mod(y, 3)]
(%i3) mod([x,y],[5,7]);
(%o3)   [[mod(x, 5), mod(x, 7)], [mod(y, 5), mod(y, 7)]]

5.5 Arrays

• Einführung in Arrays
• Funktionen und Variablen für Arrays

(%i1) a[1,2]: 99;
(%o1)                          99
(%i2) a[x,y]: x^y;
                                y
(%o2)                          x
(%i3) listarray(a);
                                  y
(%o3)                       [99, x ]

(%i1) array(a, fixnum, 2, 2);
(%o1)                           a
(%i2) b: make_array(fixnum, 2, 2);
(%o2)              {Array:  #2A((0 0) (0 0))}

(%i3) use_fast_arrays: true;
(%o3)                         true
(%i4) array(c, 2, 2);
(%o4)    #2A((NIL NIL NIL) (NIL NIL NIL) (NIL NIL NIL))
(%i5) c;
(%o5)    #2A((NIL NIL NIL) (NIL NIL NIL) (NIL NIL NIL))
(%i6) array(c, fixnum, 2, 2);

make_array: dimensions must be integers; found [fixnum + 1, 3, 3]
 -- an error. To debug this try: debugmode(true);

   array         arrayapply     arrayinfo   
   arraymake     arrays         fillarray
   listarray     make_array     rearray
   remarray      subvar         subvarp
   use_fast_arrays

5.6 Strukturen

• Einführung in Strukturen
• Funktionen und Variablen für Strukturen

6.1 Einführung in Ausdrücke

Alles in Maxima, bis auf wenige Ausnahmen, sind Ausdrücke. Dazu gehören mathematische Ausdrücke wie sqrt(2*a+b) oder Kommandos wie subst(a^2,b,sin(b+1). Auch Maxima-Programme sind Ausdrücke. Ausdrücke bestehen aus einem Atom oder einem Operator mit seinen Argumenten.

Ein Atom kann ein Symbol, eine Zeichenkette, eine ganze Zahl oder eine Gleitkommazahl sein. Jeder Ausdruck, der nicht ein Atom ist, hat die Darstellung op(a_1, a_2, ..., a_n). op ist der Operator und a_1, …, a_n sind die Argumente des Operators. Die Argumente des Operators können Atome oder wiederum Operatoren mit Argumenten sein.

Da Maxima in Lisp programmiert ist, wird ein Ausdruck intern als eine Liste dargestellt, die die Gestalt ((op) a_1 a_2 ... a_n) hat. Die arithmetischen Operatoren "+" und "*" haben zum Beispiel die interne Darstellung:

x+y+10  -> ((mplus) 10 $x $y)
2*x*x   -> ((mtimes) 2 $x $y)
2*(x+y) -> ((mtimes) 2 ((mplus) $x $y)

Mathematische Funktionen wie die trigonometrischen Funktionen oder die Logarithmusfunktion werden von Maxima intern analog dargestellt:

sin(x)          -> ((%sin) $x)
log(y)          -> ((%log) $y)
2*sin(x)+log(y) -> ((mplus) ((mtimes) 2 ((%sin) $x)) ((%log) $y)) 

Mehrere Ausdrücke können zusammengefaßt werden, indem die Ausdrücke durch Kommata getrennt und mit runden Klammern umgeben werden.

(%i1) x: 3$
(%i2) (x: x+1, x: x^2);
(%o2)                          16
(%i3) (if (x > 17) then 2 else 4);
(%o3)                           4
(%i4) (if (x > 17) then x: 2 else y: 4, y+x);
(%o4)                          20

Auch Programmschleifen sind in Maxima Ausdrücke. Der Rückgabewert einer Programmschleife ist done.

(%i1) y: (x: 1, for i from 1 thru 10 do (x: x*i))$
(%i2) y;
(%o2)                         done

Um einen anderen Rückgabewert als done zu erhalten, kann zum Beispiel der Wert der Variablen x nach dem Ende der Programmschleife ausgegeben werden.

(%i3) y: (x: 1, for i from 1 thru 10 do (x: x*i), x)$
(%i4) y;
(%o4)                        3628800

Es gibt eine Anzahl an reservierten Namen, die nicht als Variablennamen verwendet werden sollten. Ihre Verwendung kann möglicherweise kryptische Fehlermeldungen erzeugen. Dazu gehören zum Beispiel die folgenden Namen:

   integrate            next           from                 diff            
   in                   at             limit                sum             
   for                  and            elseif               then            
   else                 do             or                   if              
   unless               product        while                thru            
   step                                                                     

Funktionen und Variablen um einen Teilausdruck zu isolieren:

   isolate     disolate  isolate_wrt_times   expisolate
   part        inpart    substpart           substinpart
   inflag      piece     partswitch
   pickapart

Funktionen und Variablen für Substantive und Verben:

   nounify   verbify     alias     aliases

Funktionen und Variablen, um zu prüfen, ob ein Teilausdruck enthalten ist und um eine Liste der Variablen eines Ausdrucks zu erstellen:

   freeof       lfreeof
   listofvars   listconstvars    listdummyvars

Funktionen und Variablen für Operatoren und Argumente:

   args    op    operatorp

Funktionen und Variablen für Substitutionen in Ausdrücke:

   subst psubst sublis exptsubst opsubst

Funktionen und Variablen für die kanonische Ordnung der Argumente eines Ausdrucks:

   ordergreat    orderless    unorder
   ordergreatp   orderlessp   ordermagnitudep

Weitere Funktionen und Variablen:

   nterms   optimize   optimprefix   partition

6.2 Substantive und Verben

Operatoren und Funktionen können als Substantiv oder Verb vorliegen. Verben werden von Maxima ausgewertet. Substantive, die in einem Ausdruck auftreten, werden dagegen nicht ausgewertet, sondern vereinfacht. Die meisten mathematischen Funktionen sind Substantive. Funktionen wie limit, diff oder integrate sind standardmäßig Verben, die jedoch in ein Substantiv umgewandelt werden können. Ein Verb kann durch den Quote-Operator ' oder mit der Funktion nounify in ein Substantiv umgewandelt werden. Der Auswertungsschalter nouns bewirkt, dass Substantive von der Funktion ev ausgewertet werden.

In der internen Darstellung von Maxima erhalten Lisp-Symbole, die ein Verb darstellen, ein führendes Dollarzeichen $. Lisp-Symbole, die ein Substantiv darstellen, erhalten ein führendes Prozentzeichen %. Einige Substantive wie 'integrate oder 'derivative haben eine spezielle Darstellung für die Ausgabe. Standardmäßig werden jedoch Substantive und Verben identisch dargestellt. Hat die Optionsvariable noundisp den Wert true, werden Substantive mit einem führenden Hochkommata angezeigt.

Siehe auch noun, nouns, nounify und verbify.

Beispiele:

(%i1) foo (x) := x^2;
                                     2
(%o1)                     foo(x) := x
(%i2) foo (42);
(%o2)                         1764
(%i3) 'foo (42);
(%o3)                        foo(42)
(%i4) 'foo (42), nouns;
(%o4)                         1764
(%i5) declare (bar, noun);
(%o5)                         done
(%i6) bar (x) := x/17;
                                     x
(%o6)                    ''bar(x) := --
                                     17
(%i7) bar (52);
(%o7)                        bar(52)
(%i8) bar (52), nouns;
                               52
(%o8)                          --
                               17
(%i9) integrate (1/x, x, 1, 42);
(%o9)                        log(42)
(%i10) 'integrate (1/x, x, 1, 42);
                             42
                            /
                            [   1
(%o10)                      I   - dx
                            ]   x
                            /
                             1
(%i11) ev (%, nouns);
(%o11)                       log(42)

6.3 Bezeichner

Maxima Bezeichner bestehen aus den Buchstaben des Alphabets und den Zahlzeichen 0 bis 9. Sonderzeichen können in einem Bezeichner mit einem vorangestellten Backslash \ verwendet werden, zum Beispiel a\&b.

Ein Zahlzeichen kann der erste Buchstabe eines Bezeichners sein, wenn ihm ein Backslash vorangestellt ist, zum Beispiel \2and3. Zahlzeichen, die an anderen Stellen auftreten, muss kein Backslash vorangestellt werden, zum Beispiel is5.

Sonderzeichen können mit der Funktion declare als alphabetisch erklärt werden. In diesem Fall muss dem Sonderzeichen kein Backslash vorangestellt werden, wenn es in einem Bezeichner genutzt wird. Die Zeichen A bis Z, a bis z und 0 bis 9 sowie die Zeichen % und _ haben bereits die Eigenschaft alphabetisch.

Maxima unterscheidet Groß- und Kleinschreibung. So werden von Maxima foo, FOO oder Foo unterschieden. Ein Maxima-Bezeichner ist ein Lisp-Symbol, dem ein Dollarzeichen $ vorangestellt ist. Lisp-Symbolen, die in Maxima verwendet werden sollen, ist ein Fragezeichen ? vorangestellt. Siehe das Kapitel Lisp und Maxima für eine ausführlichere Beschreibung.

Beispiele:

(%i1) %an_ordinary_identifier42;
(%o1)               %an_ordinary_identifier42
(%i2) embedded\ spaces\ in\ an\ identifier;
(%o2)           embedded spaces in an identifier
(%i3) symbolp (%);
(%o3)                         true
(%i4) [foo+bar, foo\+bar];
(%o4)                 [foo + bar, foo+bar]
(%i5) [1729, \1729];
(%o5)                     [1729, 1729]
(%i6) [symbolp (foo\+bar), symbolp (\1729)];
(%o6)                     [true, true]
(%i7) [is (foo\+bar = foo+bar), is (\1729 = 1729)];
(%o7)                    [false, false]
(%i8) baz\~quux;
(%o8)                       baz~quux
(%i9) declare ("~", alphabetic);
(%o9)                         done
(%i10) baz~quux;
(%o10)                      baz~quux
(%i11) [is (foo = FOO), is (FOO = Foo), is (Foo = foo)];
(%o11)                [false, false, false]
(%i12) :lisp (defvar *my-lisp-variable* '$foo)
*MY-LISP-VARIABLE*
(%i12) ?\*my\-lisp\-variable\*;
(%o12)                         foo

6.4 Funktionen und Variablen für Ausdrücke

Funktion: alias (new_name_1, old_name_1, …, new_name_n, old_name_n) ¶

Die Funktion alias ermöglicht einen alternativen Alias-Namen für eine Maxima-Funktion, einer Variablen oder einem Array. Der Funktion alias kann eine beliebige Anzahl von paarweisen Namen und Alias-Namen übergeben werden.

alias gibt eine Liste mit den Symbolen zurück, denen ein Alias-Name zugewiesen werden konnte. Wurde einem Symbol bereits derselbe Alias-Name gegeben, enthält die Liste den Wert false. Wird versucht einem Symbol, das bereits einen Alias-Namen hat, einen neuen Alias-Namen zu geben, bricht alias mit einer Fehlermeldung ab.

Symbole, die einen Alias-Namen erhalten haben, werden in die Systemvariable aliases eingetragen. Siehe die Systemvariable aliases.

Die Funktionen ordergreat und orderless sowie die Deklaration eines Symbols als ein noun mit der Funktion declare erzeugen automatisch Alias-Namen, die in die Liste aliases eingetragen werden.

Der Alias-Name kann mit der Funktion kill entfernt werden.

Beispiel:

(%i1) alias(mysqrt,sqrt);
(%o1)                        [sqrt]
(%i2) aliases;
(%o2)                        [sqrt]
(%i3) mysqrt(4);
(%o3)                           2
(%i4) kill(mysqrt);
(%o4)                         done
(%i5) mysqrt(4);
(%o5)                       mysqrt(4)
(%i6) aliases;
(%o6)                          []

Systemvariable: aliases ¶

Anfangswert: []

Die Systemvariable aliases ist eine Informationsliste der Symbole, die einen vom Nutzer definierten Alias-Namen mit dem Kommando alias erhalten haben. Weiterhin werden von den Funktionen ordergreat und orderless sowie bei der Deklaration eines Symbols als ein noun mit der Funktion declare Alias-Namen generiert, die in die Liste aliases eingetragen werden.

Siehe auch die Funktion alias für ein Beispiel.

Schlüsselwort: allbut ¶

Das Schlüsselwort allbut wird bei part-Befehlen wie part, inpart, substpart, substinpart, dpart und lpart genutzt, um Indizes bei der Auswahl von Teilausdrücken auszuschließen.

Das Schlüsselwort allbut kann auch zusammen mit dem Kommando kill verwendet werden. kill(allbut(a_1, a_2, ...)) hat denselben Effekt wie kill(all) mit der Ausnahme, dass die Symbole a_1, a_2, … von kill ausgenommen werden. Siehe die Funktion kill.

Beispiele:

(%i1) expr : e + d + c + b + a;
(%o1)                   e + d + c + b + a
(%i2) part (expr, [2, 5]);
(%o2)                         d + a

(%i3) expr : e + d + c + b + a;
(%o3)                   e + d + c + b + a
(%i4) part (expr, allbut (2, 5));
(%o4)                       e + c + b

Das Schlüsselwort allbut kann zusammen mit dem Kommando kill verwendet werden.

(%i1) [aa : 11, bb : 22, cc : 33, dd : 44, ee : 55];
(%o1)                 [11, 22, 33, 44, 55]
(%i2) kill (allbut (cc, dd));
(%o0)                         done
(%i1) [aa, bb, cc, dd];
(%o1)                   [aa, bb, 33, 44]

Funktion: args (expr) ¶

Die Funktion args gibt eine Liste mit den Argumenten des Hauptoperators des Ausdrucks expr zurück.

Die Anordnung der Argumente der Ergebnisliste wird von der Optionsvariablen inflag beeinflußt. Hat inflag den Wert true, ist die Anordnung entsprechend der internen Darstellung des Ausdrucks expr. Ansonsten ist die Anordnung wie in der externen Darstellung für die Anzeige. Siehe die Optionsvariable inflag.

args(expr) ist äquivalent zu substpart("[", expr, 0). Siehe auch substpart und op.

Beispiele:

(%i1) args(gamma_incomplete(a,x));
(%o1)                        [a, x]
(%i2) args(x+y+z);
(%o2)                       [z, y, x]
(%i3) args(x+y+z),inflag:true;
(%o3)                       [x, y, z]
(%i4) args(x+2*a);
(%o4)                       [x, 2 a]

Funktion: atom (expr) ¶

Gibt den Wert true zurück, wenn das Argument expr ein Atom ist. Atome sind ganze Zahlen, Gleitkommazahlen, Zeichenketten und Symbole. Siehe auch die Funktionen symbolp und listp.

Beispiele:

(%i1) atom(5);
(%o1)                         true
(%i2) atom(5.0);
(%o2)                         true
(%i3) atom(5.0b0);
(%o3)                         true
(%i4) atom(1/2);
(%o4)                         false
(%i5) atom('a);
(%o5)                         true
(%i6) atom(2*x);
(%o6)                         false
(%i7) atom("string");
(%o7)                         true

Funktion: box (expr) ¶

Funktion: box (expr, a) ¶

Die Funktion box(expr) umschließt den Ausdruck expr in der Ausgabe mit einem Rahmen, wenn display2d den Wert true hat. Ansonsten ist der Rückgabewert ein Ausdruck mit box als Operator und expr als Argument.

box(expr, a) umschließt expr mit einem Rahmen, der mit einer Marke a bezeichnet ist. Ist die Marke länger als der Rahmen, werden Zeichen abgeschnitten.

Die Funktion box wertet ihre Argumente aus. Die eingerahmten Ausdrücke werden dagegen nicht mehr ausgewertet.

Die Optionsvariable boxchar enthält das Zeichen, das von den Funktionen box sowie dpart und lpart verwendet wird, um den Rahmen auszugeben.

Beispiele:

(%i1) box (a^2 + b^2);
                            """""""""
                            " 2    2"
(%o1)                       "b  + a "
                            """""""""
(%i2) a : 1234;
(%o2)                         1234
(%i3) b : c - d;
(%o3)                         c - d
(%i4) box (a^2 + b^2);
                      """"""""""""""""""""
                      "       2          "
(%o4)                 "(c - d)  + 1522756"
                      """"""""""""""""""""
(%i5) box (a^2 + b^2, term_1);
                      term_1""""""""""""""
                      "       2          "
(%o5)                 "(c - d)  + 1522756"
                      """"""""""""""""""""
(%i6) 1729 - box (1729);
                                 """"""
(%o6)                     1729 - "1729"
                                 """"""

Optionsvariable: boxchar ¶

Standardwert: "

Die Optionsvariable boxchar enthält das Zeichen, welches von den Funktionen box sowie dpart und lpart genutzt wird, um einen Rahmen auszugeben.

Die Rahmen werden immer mit dem aktuellen Wert von boxchar ausgegeben. Das Zeichen boxchar wird nicht zusammen mit dem eingerahmten Ausdruck gespeichert.

Funktion: collapse (expr) ¶

Funktion: collapse ([expr_1, expr_2, …]) ¶

Komprimiert einen Ausdruck expr, indem gemeinsame Teilausdrücke denselben Speicher nutzen. collapse wird von der Funktion optimize aufgerufen. collapse kann auch mit einer Liste aufgerufen werden, die mehrere Argumente enthält.

Siehe auch die Funktion optimize.

Funktion: dispform (expr) ¶

Funktion: dispform (expr, all) ¶

dispform formatiert den Ausdruck expr von der internen Darstellung in eine externe Darstellung, wie sie für die Anzeige des Ausdrucks benötigt wird. Bei der Formatierung sind Optionsvariablen wie dispflag und powerdisp wirksam.

Beispiele für die interne und externe Darstellung von Ausdrücken sind:

          Interne Darstellung            Externe Darstellung
------------------------------------------------------------
-x      : ((MTIMES) -1 $x)               ((MMINUS) $x)
sqrt(x) : ((MEXPT) $x ((RAT) 1 2))       ((%SQRT) $X)
a/b     : ((MTIMES) $A ((MEXPT) $B -1))  ((MQUOTIENT) $A $B)

dispform(expr) gibt die externe Darstellung nur für den ersten Operator im Ausdruck zurück. dispform(expr, all) gibt die externe Darstellung aller Operatoren im Ausdruck expr zurück.

Siehe auch part, inpart und inflag.

Beispiel:

Die Funktion dispform kann genutzt werden, um die Wurzelfunktion in einem Ausdruck zu substituieren. Die Wurzelfunktion ist nur in der externen Darstellung eines Ausdruckes vorhanden:

(%i1) expr: sqrt(5)/(5+sqrt(2));
                             sqrt(5)
(%o1)                      -----------
                           sqrt(2) + 5
(%i2) subst(f,sqrt,expr);
                             sqrt(5)
(%o2)                      -----------
                           sqrt(2) + 5
(%i3) subst(f,sqrt,dispform(expr));
                              f(5)
(%o3)                      -----------
                           sqrt(2) + 5
(%i4) subst(f,sqrt,dispform(expr,all));
                              f(5)
(%o4)                       --------
                            f(2) + 5

Funktion: disolate (expr, x_1, …, x_n) ¶

Die Funktion disolate arbeitet ähnlich wie die Funktion isolate. Teilausdrücke im Ausdruck expr, die die Variablen x_1, …, x_n nicht enthalten, werden durch Zwischenmarken %t1, %t2, … ersetzt. Im Unterschied zu der Funktion isolate kann die Funktion disolate Teilausdrücke zu mehr als einer Variablen aus einem Ausdruck isolieren.

Die Ersetzung von Teilausdrücken durch Zwischenmarken kann mit der Optionsvariable isolate_wrt_times kontrolliert werden. Hat die Optionsvariable isolate_wrt_times den Wert true, werden Ersetzungen in Produkten ausgeführt. Der Standardwert ist false. Siehe isolate_wrt_times für Beispiele.

Die Optionsvariable exptisolate hat im Unterschied zur Funktion isolate keinen Einfluss auf die Ersetzung von Teilausdrücken durch Zwischenmarken.

disolate wird automatisch aus der Datei share/simplification/disol.mac geladen. Das Kommando demo(disol)$ zeigt Beispiele.

Siehe auch die Funktion isolate.

Beispiel:

(%i1) expr:a*(e*(g+f)+b*(d+c));
(%o1)               a (e (g + f) + b (d + c))
(%i2) disolate(expr,a,b,e);
(%t2)                         d + c

(%t3)                         g + f

(%o3)                   a (%t3 e + %t2 b)

Funktion: dpart (expr, n_1, …, n_k) ¶

Wählt wie die Funktion part einen Teilausdruck aus, gibt aber den vollständigen Ausdruck zurück, wobei der ausgewählte Teilausdruck eingerahmt ist. Der Rahmen ist Teil des zurückgegebenen Ausdrucks.

Siehe auch part, inpart und lpart sowie box.

Beispiel:

(%i1) dpart (x+y/z^2, 1, 2, 1);
                             y
(%o1)                       ---- + x
                               2
                            """
                            "z"
                            """

Optionsvariable: exptisolate ¶

Standardwert: false

Hat exptisolate den Wert true, dann sucht die Funktion isolate auch in den Exponenten von Zahlen oder Symbolen nach Teilausdrücken zu einer Variablen.

Siehe die Funktion isolate für Beispiele.

Optionsvariable: exptsubst ¶

Standardwert: false

Die Optionsvariable exptsubst kontrolliert die Substitution von Ausdrücken mit der Exponentialfunktion durch die Funktionen subst und psubst.

Beispiele:

(%i1) subst(y,%e^x,%e^(a*x)),exptsubst:false;
                                a x
(%o1)                         %e
(%i2) subst(y,%e^x,%e^(a*x)),exptsubst:true;
                                a
(%o2)                          y

Funktion: freeof (x, expr) ¶

Funktion: freeof (x_1, …, x_n, expr) ¶

freeof(x, expr) gibt das Ergebnis true zurück, wenn das Argument x nicht im Ausdruck expr enthalten ist. Ansonsten ist der Rückgabewert false.

freeof(x_1, ..., x_n, expr) gibt das Ergebnis true zurück, wenn keines der Argumente x_1, x_2, … im Ausdruck expr enthalten ist.

Die Argumente x_1, …, x_n können die Namen von Funktionen und Variablen sein, indizierte Namen, die Namen von Operatoren oder allgemeine Ausdrücke. Die Funktion freeof wertet die Argumente aus.

Bei der Prüfung, ob ein Teilausdruck x im Ausdruck expr enthalten ist, untersucht die Funktion freeof den Ausdruck expr in der vorliegenden Form (nach Auswertung und Vereinfachung) und versucht nicht herauszufinden, ob der Teilausdruck in einem äquivalenten Ausdruck enthälten wäre.

freeof ignoriert Dummy-Variablen. Dummy-Variablen sind Variablen, die außerhalb eines Ausdrucks nicht in Erscheinung treten. Folgende Dummy-Variablen werden von freeof ignoriert: der Index einer Summe oder eines Produktes, die unabhängige Variable in einem Grenzwert, die Integrationsvariable eines bestimmten Integrals oder einer Laplacetransformation, formale Variablen in at- oder lambda-Ausdrücke, lokale Variablen eines Blocks oder einer do-Schleife.

Das unbestimmte Integral ist nicht frei von der Integrationsvariablen.

Beispiele:

Argumente sind Namen von Funktionen, Variablen, indizierten Variablen, Operatoren und Ausdrücke. freeof(a, b, expr) ist äquivalent zu freeof(a, expr) and freeof(b, expr).

(%i1) expr: z^3 * cos (a[1]) * b^(c+d);

                                 d + c  3
(%o1)                   cos(a ) b      z
                             1

(%i2) freeof(z, expr);
(%o2)                         false
(%i3) freeof(cos, expr);
(%o3)                         false
(%i4) freeof(a[1], expr);
(%o4)                         false
(%i5) freeof(cos (a[1]), expr);
(%o5)                         false
(%i6) freeof(b^(c+d), expr);
(%o6)                         false
(%i7) freeof("^", expr);
(%o7)                         false
(%i8) freeof(w, sin, a[2], sin (a[2]), b*(c+d), expr);
(%o8)                         true

Die Funktion freeof wertet die Argumente aus.

(%i1) expr: (a+b)^5$
(%i2) c: a$
(%i3) freeof(c, expr);
(%o3)                         false

freeof betrachtet keine äquivalenten Ausdrücke. Vereinfachungen können einen äquivalenten Ausdruck liefern, der jedoch den Teilausdruck nicht mehr enthält.

(%i1) expr: (a+b)^5$
(%i2) expand(expr);
          5        4       2  3       3  2      4      5
(%o2)    b  + 5 a b  + 10 a  b  + 10 a  b  + 5 a  b + a
(%i3) freeof(a+b, %);
(%o3)                         true
(%i4) freeof(a+b, expr);
(%o4)                         false

Die Exponentialfunktion exp(x) wird von Maxima sofort zu %e^x vereinfacht. Der Name exp der Exponentialfunktion ist daher nicht in einem Ausdruck enthalten.

(%i5) exp(x);
                                 x
(%o5)                          %e
(%i6) freeof(exp, exp (x));
(%o6)                         true

Eine Summe ist frei von dem Index und ein bestimmtes Integral ist frei von der Integrationsvariablen. Ein unbestimmtes Integral ist nicht frei von der Integrationsvariablen.

(%i1) freeof(i, 'sum (f(i), i, 0, n));
(%o1)                         true
(%i2) freeof(x, 'integrate (x^2, x, 0, 1));
(%o2)                         true
(%i3) freeof(x, 'integrate (x^2, x));
(%o3)                         false

Optionsvariable: inflag ¶

Standardwert: false

Hat die Optionsvariable inflag den Wert true, wird von Funktionen, die Teile eines Ausdrucks expr extrahieren, die interne Form des Ausdrucks expr betrachtet.

Die Anordnung der Argumente der internen Darstellung unterscheidet sich zum Beispiel für die Addition von der externen Darstellung für die Anzeige. Daher hat first(x+y) das Ergebnis x, wenn inflag den Wert true hat, und y, wenn inflag den Wert false hat. Der Ausdruck first(y+x) gibt in beiden Fällen dasselbe Ergebnis.

Hat inflag den Wert true, entsprechen die Funktionen part und substpart den Funktionen inpart und substinpart.

Folgende Funktionen werden von der Optionsvariablen inflag beeinflusst: part, substpart, first, rest, last, length, die Konstruktion for … in, map, fullmap, maplist, reveal, pickapart, args und op.

Funktion: inpart (expr, n_1, …, n_k) ¶

Die Funktion inpart ist ähnlich wie part, arbeitet aber mit der internen Darstellung eines Ausdruckes und nicht mit der externen Darstellung für die Anzeige. Da keine Formatierung vorgenommen wird, ist die Funktion inpart schneller als part.

Immer dann, wenn sich die interne und die externe Darstellung eines Ausdrucks voneinander unterscheiden, haben die Funktionen inpart und part verschiedene Ergebnisse. Dies trifft zu für die Anordnung der Argumente einer Addition, der Subtraktion und Division sowie zum Beispiel für die Wurzelfunktion.

Ist das letzte Argument einer part-Funktion eine Liste mit Indizes, werden mehrere Teilausdrücke heraus gepickt. So hat inpart(x + y + z, [1, 3]) das Ergebnis z+x.

Siehe auch part, dpart und lpart.

Beispiele:

(%i1) x + y + w*z;
(%o1)                      w z + y + x
(%i2) inpart (%, 3, 2);
(%o2)                           z
(%i3) part (%th (2), 1, 2);
(%o3)                           z
(%i4) 'limit (f(x)^g(x+1), x, 0, minus);
                                  g(x + 1)
(%o4)                 limit   f(x)
                      x -> 0-
(%i5) inpart (%, 1, 2);
(%o5)                       g(x + 1)

Funktion: isolate (expr, x) ¶

Teilausdrücke im Ausdruck expr, die die Variable x nicht enthalten, werden durch Zwischenmarken %t1, %t2, … ersetzt. Dies kann genutzt werden, um die weitere Auswertung und Vereinfachung dieser Teilausdrücke zu verhindern. Die Ersetzung der Teilausdrücke kann durch eine Auswertung des Ausdrucks rückgängig gemacht werden.

Die Ersetzung von Teilausdrücken kann mit den Optionsvariablen exptisolate und isolate_wrt_times kontrolliert werden. Hat die Optionsvariable exptisolate den Wert true, werden Ersetzungen auch für die Exponentiation ausgeführt. Die Basis muss dabei eine Zahl oder ein Symbol wie %e sein. Hat die Optionsvariable isolate_wrt_times den Wert true, werden Ersetzungen in Produkten ausgeführt. Siehe isolate_wrt_times für Beispiele.

Die Ersetzung von Teilausdrücken für mehrere Variable kann mit der Funktion disolate ausgeführt werden. Siehe disolate.

Beispiele:

(%i1) (b+a)^4*(x*((d+c)^2+2*x)+1);
                       4                  2
(%o1)           (b + a)  (x (2 x + (d + c) ) + 1)
(%i2) isolate(%,x);

                                   2
(%t2)                       (d + c)


                                   4
(%t3)                       (b + a)

(%o3)                %t3 (x (2 x + %t2) + 1)
(%i4) ratexpand(%);
                          2
(%o4)              2 %t3 x  + %t2 %t3 x + %t3
(%i5) ev(%);
                  4  2          4        2            4
(%o5)    2 (b + a)  x  + (b + a)  (d + c)  x + (b + a)
(%i6) (b+a)*(b+a+x)^2*%e^(b+a*x+x^2);
                                       2
                                  2   x  + a x + b
(%o6)          (b + a) (x + b + a)  %e
(%i7) ev(isolate(%,x),exptisolate:true);

(%t7)                         b + a


                                 b
(%t8)                          %e

                                        2
                                   2   x  + a x
(%o8)             %t7 %t8 (x + %t7)  %e

Optionsvariable: isolate_wrt_times ¶

Standardwert: false

Hat die Optionsvariable isolate_wrt_times den Wert true, führen die Funktionen isolate und disolate auch Ersetzungen in Produkten aus.

Siehe auch die Funktionen isolate und disolate.

Beispiele:

(%i1) isolate_wrt_times: true$
(%i2) isolate (expand ((a+b+c)^2), c);

(%t2)                          2 a


(%t3)                          2 b


                          2            2
(%t4)                    b  + 2 a b + a

                     2
(%o4)               c  + %t3 c + %t2 c + %t4
(%i4) isolate_wrt_times: false$
(%i5) isolate (expand ((a+b+c)^2), c);
                     2
(%o5)               c  + 2 b c + 2 a c + %t4

Optionsvariable: listconstvars ¶

Standardwert: false

Hat die Optionsvariable listconstvars den Wert true, werden Konstante wie %e, %pi und Variablen, die als konstant deklariert sind, von der Funktion listofvars in die Ergebnisliste aufgenommen. Der Standardwert von listconstvars ist false und Konstante werden ignoriert.

Optionsvariable: listdummyvars ¶

Standardwert: true

Hat listdummyvars den Wert false, werden die Dummy-Variablen eines Ausdrucks von der Funktion listofvars ignoriert. Dummy-Variablen sind zum Beispiel der Index einer Summe, die Grenzwertvariable oder die Integrationsvariable eines bestimmten Integrals.

Beispiele:

(%i1) listdummyvars: true$
(%i2) listofvars ('sum(f(i), i, 0, n));
(%o2)                        [i, n]
(%i3) listdummyvars: false$
(%i4) listofvars ('sum(f(i), i, 0, n));
(%o4)                          [n]

Funktion: listofvars (expr) ¶

Die Funktion listofvars gibt eine Liste der Variablen zurück, die im Ausdruck expr enthalten sind.

Hat die Optionsvariable listconstvars den Wert true, werden auch Konstante wie %e, %pi und %i sowie als konstant deklarierte Variable in die Liste aufgenommen. Der Standardwert von listconstvars ist false.

Siehe entsprechend die Optionsvariable listdummyvars für Dummy-Variablen.

Beispiel:

(%i1) listofvars (f (x[1]+y) / g^(2+a));
(%o1)                     [g, a, x , y]
                                  1

Funktion: lfreeof (list, expr) ¶

Für jedes Element m der Liste list wird die Funktion freeof aufgerufen. lfreeof hat den Rückgabewert true, wenn keines der Elemente der Liste list im Ausdruck expr enthalten ist. Ansonsten ist der Rückgabewert false.

Siehe auch die Funktion freeof.

Funktion: lpart (label, expr, n_1, …, n_k) ¶

Die Funktion lpart ist ähnlich zu dpart, verwendet aber einen Rahmen, der mit einer Marke gekennzeichnet ist.

Siehe auch part, inpart und dpart.

Eigenschaft: mainvar ¶

Die Deklaration einer Variablen als eine Hauptvariable mit der Funktion declare ändert deren Anordnung in einem Ausdruck der kanonisch geordnet ist. Hauptvariable sind bezüglich der Funktionen ordergreatp und orderlessp stets größer als alle anderen Symbole, Konstanten und Zahlen.

Beispiel:

(%i1) sort([9, 1, %pi, g, t, a]);
(%o1)                 [1, 9, %pi, a, g, t]

(%i2) declare(a, mainvar)$
(%i3) sort([9, 1, %pi, g, t, a]);
(%o3)                 [1, 9, %pi, g, t, a]

Eigenschaft: noun ¶

noun ist eine der Optionen des Kommandos declare. Wird eine Funktion als noun deklariert, wird diese als Substantivform behandelt und nicht ausgewertet.

Ein Symbol f, dass als noun deklariert wird, wird in die Informationsliste aliases eingetragen und die Rückgabe der Funktion properties enthält den Eintrag noun.

Beispiel:

(%i1) factor (12345678);
                             2
(%o1)                     2 3  47 14593
(%i2) declare (factor, noun);
(%o2)                         done
(%i3) factor (12345678);
(%o3)                   factor(12345678)
(%i4) ''%, nouns;
                             2
(%o4)                     2 3  47 14593

Optionsvariable: noundisp ¶

Standardwert: false

Hat noundisp den Wert true, werden Substantivformen mit einem vorangestelltem Hochkomma angezeigt. Diese Optionsvariable hat immer den Wert true, wenn die Definition von Funktionen angezeigt wird.

Funktion: nounify (f) ¶

Die Funktion nounify gibt den Namen einer Funktion f in einer Substantivform zurück. Der Name f ist ein Symbol oder eine Zeichenkette.

Einige Funktionen geben eine Substantivform zurück, wenn die Funktion nicht ausgewertet werden kann. Wird einem Funktionsaufruf wie zum Beispiel 'f(x) oder '(f(x)) ein Hochkomma vorangestellt, wird ebenfalls eine Substantivform zurückgegeben.

Siehe auch die Funktion verbify.

Funktion: nterms (expr) ¶

Die Funktion nterms gibt die Anzahl der Terme des Ausdrucks expr zurück, wobei der Ausdruck als vollständig expandiert angenommen wird, ohne dass Terme gekürzt oder zusammengefasst werden.

Ausdrücke wie sin(expr), sqrt(expr) oder exp(expr) werden dabei als ein Term gezählt.

Funktion: op (expr) ¶

Die Funktion op gibt den Hauptoperator des Ausdrucks expr zurück. op(expr) ist äquivalent zu part(expr, 0).

Ist der Hauptoperator des Ausdrucks expr ein Operator wie "+", "*" oder "/" wird der Name des Operators als Zeichenkette zurückgegeben. Andernfalls wird ein Symbol zurückgegeben.

op beachtet den Wert der Optionsvariablen inflag. op wertet die Argumente aus. Siehe auch args.

Beispiele:

(%i1) stringdisp: true$
(%i2) op (a * b * c);
(%o2)                          "*"
(%i3) op (a * b + c);
(%o3)                          "+"
(%i4) op ('sin (a + b));
(%o4)                          sin
(%i5) op (a!);
(%o5)                          "!"
(%i6) op (-a);
(%o6)                          "-"
(%i7) op ([a, b, c]);
(%o7)                          "["
(%i8) op ('(if a > b then c else d));
(%o8)                         "if"
(%i9) op ('foo (a));
(%o9)                          foo
(%i10) prefix (foo);
(%o10)                        "foo"
(%i11) op (foo a);
(%o11)                        "foo"
(%i12) op (F [x, y] (a, b, c));
(%o12)                        F
                               x, y
(%i13) op (G [u, v, w]);
(%o13)                          G

Funktion: operatorp (expr, op) ¶

Funktion: operatorp (expr, [op_1, …, op_n]) ¶

Das Kommando operatorp(expr, op) gibt true zurück, wenn op der Hauptoperator des Ausdrucks expr ist.

operatorp(expr, [op_1, ..., op_n]) gibt true zurück, wenn einer der Operatoren op_1, …, op_n der Hauptoperator des Ausdrucks expr ist.

Optionsvariable: opsubst ¶

Hat die Optionsvariable opsubst den Wert false, führt die Funktion subst keine Substitution in einen Operator eines Ausdrucks aus. Zum Beispiel hat (opsubst: false, subst(x^2, r, r+r[0])) das Ergebnis x^2+r[0].

Funktion: optimize (expr) ¶

Die Funktion optimize gibt einen Ausdruck zurück, der dasselbe Ergebnis und dieselben Seiteneffekte wie expr hat, der jedoch effizienter ausgewertet werden kann. Im neuen Ausdruck wird die mehrfache Berechnung gleicher Teilausdrücke vermieden und gleiche Teilausdrücke werden zusammengefasst.

Siehe auch die Funktion collapse.

example(optimize) zeigt ein Beispiel.

Optionsvariable: optimprefix ¶

Standardwert: %

Die Optionsvariable optimprefix enthält den Präfix, der von der Funktion optimize benutzt wird, um einen Teilausdruck zu benennen.

Funktion: ordergreat (v_1, …, v_n) ¶

Funktion: orderless (v_1, …, v_n) ¶

Die Funktion ordergreat ändert die kanonische Anordnung der Symbole so, dass v_1 > v_2 > … > v_n. Weiterhin ist v_n kleiner als jedes andere Symbol, das nicht in der Liste enthalten ist.

orderless ändert die kanonische Anordnung der Symbole so, dass v_1 < v_2 < … < v_n. Weiterhin ist v_n größer als jedes andere Symbol, das nicht in der Liste enthalten ist.

Die durch ordergreat und orderless definierte Ordnung wird durch unorder wieder aufgehoben. ordergreat und orderless können jeweils nur einmal aufgerufen werden, solange nicht mit unorder zuvor die definierte Ordnung aufgehoben wird.

Siehe auch ordergreatp, orderlessp und mainvar.

Funktion: ordergreatp (expr_1, expr_2) ¶

Funktion: orderlessp (expr_1, expr_2) ¶

Die Funktion ordergreatp gibt true zurück, wenn in der kanonischen Ordnung von Maxima expr_1 größer als expr_2 ist. Ansonsten ist das Ergebnis false.

Die Funktion orderlessp gibt true zurück, wenn in der kanonischen Ordnung von Maxima expr_1 kleiner als expr_2 ist. Ansonsten ist das Ergebnis false.

Alle Maxima-Atome und Ausdrücke sind vergleichbar unter ordergreatp und orderlessp. Die kanonische Ordnung von Atomen ist folgendermaßen:

Numerische Konstanten < deklarierte Konstanten < deklarierte Skalare < erstes Argument von orderless < weitere Argumente von orderless < letztes Argument von orderless < Variablen beginnend mit a, ... < Variablen beginnend mit Z < letzte Argument von ordergreat < weitere Argumente von ordergreat < erste Argument von ordergreat < deklarierte Hauptvariablen.

Die Ordnung für Ausdrücke, die keine Atome sind, wird von der für Atome abgeleitet. Für die Operatoren "+", "*" und "^" kann die Ordnung nicht einfach beschrieben werden. Andere Operatoren, Funktionen und Ausdrücke werden angeordnet nach den Argumenten, dann nach den Namen. Bei Ausdrücken mit Indizes wird der Name des Symbols als Operator und der Index als Argument betrachtet.

Die kanonische Ordnung der Ausdrücke wird modifiziert durch die Funktionen ordergreat und orderless sowie der Deklarationen mainvar, constant und scalar.

Siehe auch sort.

Beispiele:

Ordne Symbole und Konstanten. %pi wird nicht nach dem numerischen Wert sortiert, sondern wie eine Konstante.

(%i1) stringdisp : true;
(%o1)                         true
(%i2) sort ([%pi, 3b0, 3.0, x, X, "foo", 3, a, "bar", 4.0, 4b0]);
(%o2) [3, 3.0, 4.0, 3.0b0, 4.0b0, %pi, "bar", "foo", a, x, X]

Anwendung der Funktionen ordergreat und orderless.

(%i1) sort ([M, H, K, T, E, W, G, A, P, J, S]);
(%o1)           [A, E, G, H, J, K, M, P, S, T, W]
(%i2) ordergreat (S, J);
(%o2)                         done
(%i3) orderless (M, H);
(%o3)                         done
(%i4) sort ([M, H, K, T, E, W, G, A, P, J, S]);
(%o4)           [M, H, A, E, G, K, P, T, W, J, S]

Anwendung der Deklarationen mainvar, constant und scalar.

(%i1) sort ([aa, foo, bar, bb, baz, quux, cc, dd, A1, B1, C1]);
(%o1)   [aa, bar, baz, bb, cc, dd, foo, quux, A1, B1, C1]
(%i2) declare (aa, mainvar);
(%o2)                         done
(%i3) declare ([baz, quux], constant);
(%o3)                         done
(%i4) declare ([A1, B1], scalar);
(%o4)                         done
(%i5) sort ([aa, foo, bar, bb, baz, quux, cc, dd, A1, B1, C1]);
(%o5)   [baz, quux, A1, B1, bar, bb, cc, dd, foo, C1, aa]

Ordne nicht atomare Ausdrücke.

(%i1) sort ([f(1), f(2), f(2, 1), g(1), g(1, 2), g(n), f(n, 1)]);
(%o1) [f(1), g(1), g(1, 2), f(2), f(2, 1), g(n), f(n, 1)]
(%i2) sort ([foo(1), X[1], X[k], foo(k), 1, k]);
(%o2)            [1, foo(1), X , k, foo(k), X ]
                              1              k

Funktion: ordermagnitudep (expr_1, expr_2) ¶

Ist eine Aussagefunktion, die das Ergebnis true hat, wenn die Argumente expr_1 und expr_2 Zahlen, Konstante oder konstante Ausdrücke repräsentieren und expr_1 kleiner als expr_2 ist. Sind die Argumente nicht der Größe nach vergleichbar, wird die Ordnung durch die Aussagefunktion orderlessp bestimmt.

Wird die Aussagefunktion ordermagnitudep als Argument der Funktion sort verwendet, werden die Elemente einer Liste nach der Größe sortiert.

Beispiele:

(%i1) ordermagnitudep(1, 2);
(%o1)                         true
(%i2) ordermagnitudep(%e, %pi);
(%o2)                         true
(%i3) sort([%e, %pi, sin(1), 0, 1, 2, 3, 4]);
(%o3)           [0, 1, 2, 3, 4, %e, %pi, sin(1)]
(%i4) sort([%e, %pi, sin(1), 0, 1, 2, 3, 4], ordermagnitudep);
(%o4)           [0, sin(1), 1, 2, %e, 3, %pi, 4]

Funktion: part (expr, n_1, …, n_k) ¶

Die Funktion part gibt einen Teilausdruck des Ausdrucks expr zurück. Der Ausdruck expr wird zuvor in das Format für die Anzeige umgewandelt.

Der Teilausdruck wird durch die Indizes n_1, …, n_k ausgewählt. Zuerst wird der Teilausdruck n_1 ermittelt, von diesem der Teilausdruck n_2, u.s.w. Der zum Index n_k zuletzt gewonnene Teilausdruck ist dann das Ergebnis.

part kann auch verwendet werden, um ein Element einer Liste oder die Zeile einer Matrix zu erhalten.

Das letzte Argument einer part-Funktion kann eine Liste mit Indizes sein. In diesem Fall werden alle angegebenen Teilausdrücke als Ergebnis zurückgegeben. Zum Beispiel hat das Kommando part(x + y + z, [1, 3]) das Ergebnis z+x.

Die Systemvariable piece enthält den letzten Ausdruck, der bei der Verwendung einer part-Funktion ausgewählt wurde.

Hat die Optionsvariable partswitch den Wert true, wird end zurückgegeben, wenn versucht wurde, einen Teilausdruck zu bilden, der nicht existiert, andernfalls wird eine Fehlermeldung ausgegeben.

Siehe auch inpart, substpart, substinpart, dpart und lpart.

Beispiele:

(%i1) part(z+2*y+a,2);
(%o1)                                 2 y
(%i2) part(z+2*y+a,[1,3]);
(%o2)                                z + a
(%i3) part(z+2*y+a,2,1);
(%o3)                                  2

example(part) zeigt weitere Beispiele.

Funktion: partition (expr, var) ¶

Die Funktion partition gibt eine Liste mit zwei Ausdrücken zurück. Ist das Argument expr ein Produkt enthält das erste Element die Faktoren, die die Variable var enthalten, und das zweite Element enthält die übrigen Faktoren. Entsprechend enthält das erste Element die Terme einer Summe oder die Elemente einer Liste, die die Variable var enthalten, und das zweite Elemente die verbleibende Terme der Summe oder Elemente der Liste.

(%i1) partition (2*a*x*f(x), x);
(%o1)                     [2 a, x f(x)]
(%i2) partition (a+b, x);
(%o2)                      [b + a, 0]
(%i3) partition ([a, b, f(a), c], a); 
(%o3)                  [[b, c], [a, f(a)]]

Optionsvariable: partswitch ¶

Standardwert: false

Hat die Optionsvariable partswitch den Wert true, wird end zurückgegeben, wenn versucht wird, einen Teilausdruck zu bilden, der nicht existiert, andernfalls wird eine Fehlermeldung ausgegeben.

Funktion: pickapart (expr, n) ¶

Den Teilausdrücken in einer Tiefe n eines verschachtelten Ausdrucks werden Zwischenmarken zugewiesen. n ist eine ganze positive Zahl. Die Rückgabe von pickapart ist ein äquivalenter Ausdruck, der die Zwischenmarken enthält.

Siehe auch part, dpart, lpart, inpart und reveal.

Beispiele:

(%i1) expr: (a+b)/2 + sin (x^2)/3 - log (1 + sqrt(x+1));

                                          2
                                     sin(x )   b + a
(%o1)       - log(sqrt(x + 1) + 1) + ------- + -----
                                        3        2

(%i2) pickapart (expr, 0);

                                          2
                                     sin(x )   b + a
(%t2)       - log(sqrt(x + 1) + 1) + ------- + -----
                                        3        2

(%o2)                          %t2
(%i3) pickapart (expr, 1);

(%t3)                - log(sqrt(x + 1) + 1)


                                  2
                             sin(x )
(%t4)                        -------
                                3


                              b + a
(%t5)                         -----
                                2

(%o5)                    %t5 + %t4 + %t3
(%i5) pickapart (expr, 2);

(%t6)                 log(sqrt(x + 1) + 1)


                                  2
(%t7)                        sin(x )


(%t8)                         b + a

                         %t8   %t7
(%o8)                    --- + --- - %t6
                          2     3
(%i8) pickapart (expr, 3);

(%t9)                    sqrt(x + 1) + 1


                                2
(%t10)                         x

                  b + a              sin(%t10)
(%o10)            ----- - log(%t9) + ---------
                    2                    3

(%i10) pickapart (expr, 4);

(%t11)                     sqrt(x + 1)

                      2
                 sin(x )   b + a
(%o11)           ------- + ----- - log(%t11 + 1)
                    3        2
(%i11) pickapart (expr, 5);

(%t12)                        x + 1

                   2
              sin(x )   b + a
(%o12)        ------- + ----- - log(sqrt(%t12) + 1)
                 3        2
(%i12) pickapart (expr, 6);
                  2
             sin(x )   b + a
(%o12)       ------- + ----- - log(sqrt(x + 1) + 1)
                3        2

Systemvariable: piece ¶

Die Systemvariable piece enthält den letzten Ausdruck, der bei der Verwendung einer part-Funktion ausgewählt wurde.

Siehe auch part und inpart.

Funktion: psubst (list, expr) ¶

Funktion: psubst (a, b, expr) ¶

psubst(a, b, expr) ist identisch mit subst. Siehe subst.

Im Unterschied zu subst führt die Funktion psubst Substitutionen parallel aus, wenn das erste Argument list eine Liste mit Gleichungen ist.

Siehe auch die Funktion sublis, um Substitutionen parallel auszuführen.

Beispiel:

Das erste Beispiel zeigt die parallele Substitution mit psubst. Das zweite Beispiel zeigt das Ergebnis für die Funktion subst. In diesem Fall werden die Substitutionen nacheinander ausgeführt.

(%i4) psubst ([a^2=b, b=a], sin(a^2) + sin(b));
(%o4)                           sin(b) + sin(a)
(%i5) subst ([a^2=b, b=a], sin(a^2) + sin(b));
(%o5)                              2 sin(a)

Funktion: rembox (expr, unlabelled) ¶

Funktion: rembox (expr, label) ¶

Funktion: rembox (expr) ¶

Die Funktion rembox entfernt Rahmen aus dem Ausdruck expr. rembox(expr, unlabelled) entfernt alle Rahmen, die keine Marke haben. rembox(expr, label) entfernt nur Rahmen, die mit der Marke label gekennzeichnet sind. rembox(expr) entfernt alle Rahmen.

Rahmen werden mit den Funktionen box, dpart und lpart einem Ausdruck hinzugefügt.

Beispiele:

(%i1) expr: (a*d - b*c)/h^2 + sin(%pi*x);
                                  a d - b c
(%o1)                sin(%pi x) + ---------
                                      2
                                     h

(%i2) dpart (dpart (expr, 1, 1), 2, 2);
                        """""""    a d - b c
(%o2)               sin("%pi x") + ---------
                        """""""      """"
                                     " 2"
                                     "h "
                                     """"

(%i3) expr2: lpart (BAR, lpart (FOO, %, 1), 2);
                  FOO"""""""""""   BAR""""""""
                  "    """"""" "   "a d - b c"
(%o3)             "sin("%pi x")" + "---------"
                  "    """"""" "   "  """"   "
                  """"""""""""""   "  " 2"   "
                                   "  "h "   "
                                   "  """"   "
                                   """""""""""

(%i4) rembox (expr2, unlabelled);

                                  BAR""""""""
                   FOO"""""""""   "a d - b c"
(%o4)              "sin(%pi x)" + "---------"
                   """"""""""""   "    2    "
                                  "   h     "
                                  """""""""""

(%i5) rembox (expr2, FOO);

                                  BAR""""""""
                       """""""    "a d - b c"
(%o5)              sin("%pi x") + "---------"
                       """""""    "  """"   "
                                  "  " 2"   "
                                  "  "h "   "
                                  "  """"   "
                                  """""""""""

(%i6) rembox (expr2, BAR);

                   FOO"""""""""""
                   "    """"""" "   a d - b c
(%o6)              "sin("%pi x")" + ---------
                   "    """"""" "     """"
                   """"""""""""""     " 2"
                                      "h "
                                      """"

(%i7) rembox (expr2);
                                  a d - b c
(%o7)                sin(%pi x) + ---------
                                      2
                                     h

Funktion: reveal (expr, depth) ¶

Ersetzt Teile des Ausdrucks expr in der ganzzahligen Tiefe depth durch eine beschreibende Zusammenfassung:

• Summen und Differenzen werden durch Sum(n) ersetzt, wobei n die Anzahl der Terme der Summe oder Differenz ist.
• Produkte werden durch Product(n) ersetzt, wobei n die Anzahl der Faktoren des Produktes ist.
• Exponentiationen werden durch Expt ersetzt.
• Quotienten werden durch Quotient ersetzt.
• Die Negation wird durch Negterm ersetzt.
• Listen werden durch List(n) ersetzt, wobei n die Anzahl der Elemente der Liste ist.

Ist depth größer oder gleich der maximalen Tiefe des Ausdrucks expr, gibt reveal den Ausdruck expr unverändert zurück.

reveal wertet die Argumente aus. reveal gibt die Zusammenfassung zurück.

Beispiele:

(%i1) e: expand ((a - b)^2)/expand ((exp(a) + exp(b))^2);

                          2            2
                         b  - 2 a b + a
(%o1)               -------------------------
                        b + a     2 b     2 a
                    2 %e      + %e    + %e

(%i2) reveal (e, 1);
(%o2)                       Quotient
(%i3) reveal (e, 2);
                             Sum(3)
(%o3)                        ------
                             Sum(3)
(%i4) reveal (e, 3);
                     Expt + Negterm + Expt
(%o4)               ------------------------
                    Product(2) + Expt + Expt
(%i5) reveal (e, 4);
                       2                 2
                      b  - Product(3) + a
(%o5)         ------------------------------------
                         Product(2)     Product(2)
              2 Expt + %e           + %e
(%i6) reveal (e, 5);
                         2            2
                        b  - 2 a b + a
(%o6)              --------------------------
                       Sum(2)     2 b     2 a
                   2 %e       + %e    + %e
(%i7) reveal (e, 6);
                          2            2
                         b  - 2 a b + a
(%o7)               -------------------------
                        b + a     2 b     2 a
                    2 %e      + %e    + %e

Funktion: sublis (list, expr) ¶

Führt im Unterschied zu der Funktion subst die Substitutionen der Liste list parallel und nicht nacheinander aus.

Mit der Optionsvariablen sublis_apply_lambda wird die Vereinfachung von Lamda-Ausdrücken kontrolliert, nachdem die Substitution ausgeführt wurde.

Siehe auch die Funktion psubst, um parallele Substitutionen auszuführen.

Beispiele:

(%i1) sublis ([a=b, b=a], sin(a) + cos(b));
(%o1)                    sin(b) + cos(a)

Optionsvariable: sublis_apply_lambda ¶

Standardwert: true

Kontrolliert, ob Lambda-Ausdrücke nach einer Substitution ausgewertet werden. Hat sublis_apply_lambda den Wert true werden Lambda-Ausdrücke ausgewertet. Ansonsten verbleiben diese nach der Substitution im Ausdruck.

Option variable: subnumsimp ¶

Default value: false

If true then the functions subst and psubst can substitute a subscripted variable f[x] with a number, when only the symbol f is given.

See also subst.

(%i1) subst(100,g,g[x]+2);

subst: cannot substitute 100 for operator g in expression g
                                                           x
 -- an error. To debug this try: debugmode(true);

(%i2) subst(100,g,g[x]+2),subnumsimp:true;
(%o2)                          102

Funktion: subst (a, b, c) ¶

Substituiert a für b in den Ausdruck c. Das Argument b muss ein Atom oder ein vollständiger Teilausdruck von c sein. Zum Beispiel ist x+y+z ein vollständiger Teilausdruck von 2*(x+y+z)/w, nicht aber x+y. Hat b nicht diese Eigenschaft, dann können möglicherweise die Funktionen substpart oder ratsubst angewendet werden.

Hat b die Form e/f, kann subst(a*f, e, c) verwendet werden. Ist b von der Form e^(1/f), dann kann subst(a^f, e, c) verwendet werden. Die Funktion subst erkennt auch den Ausdruck x^y in x^-y, so dass subst(a, sqrt(x), 1/sqrt(x)) das Ergebnis 1/a hat. a und b können auch die Namen von Operatoren oder Funktionen sein. Soll die unabhängige Variable in Ausdrücken mit Ableitungen substituiert werden, sollte die Funktion at verwendet werden.

subst ist der Alias-Name für substitute.

subst(eq_1, expr) und subst([eq_1, ..., eq_k], expr) sind weitere mögliche Formen. eq_i sind Gleichungen, die angeben, welche Substitutionen auszuführen sind. Für jede Gleichung wird die rechte Seite der Gleichung für die linke Seite in den Ausdruck expr substituiert.

Hat die Optionsvariable exptsubst den Wert true, wird eine Substitution wie y für %e^x in einem Ausdruck der Form %e^(a*x) nicht ausgeführt.

Hat die Optionsvariable opsubst den Wert false, führt die Funktion subst keine Substitution in einen Operator eines Ausdrucks aus. Zum Beispiel hat (opsubst: false, subst(x^2, r, r+r[0])) das Ergebnis x^2+r[0].

Beispiele:

(%i1) subst (a, x+y, x + (x+y)^2 + y);
                                    2
(%o1)                      y + x + a
(%i2) subst (-%i, %i, a + b*%i);
(%o2)                       a - %i b

Weitere Beispiele werden mit example(subst) angezeigt.