[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

19. Lineare Algebra


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

19.1 Einführung in die lineare Algebra


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

19.1.1 Nicht-kommutative Multiplikation

Der Operator . repräsentiert die nichtkommutative Multiplikation oder das Skalarprodukt. Sind die Argumente 1-spaltige oder 1-reihige Matrizen a und b, dann ist der Ausdruck a . b äquivalent zu sum(a[i]*b[i], i, 1, length(a)). Sind a und b nicht komplex, dann ist der vorhergende Ausdruck das Skalarprodukt von a und b. Das Skalarprodukt ist als conjugate(a) . b definiert, wenn a und b komplex sind. Die Funktion innerproduct im Paket eigen stellt das komplexe Skalarprodukt zur Verfügung.

Sind die Argumente a und b allgemeine Matrizen, dann ist das Ergebnis der nichtkommutativen Multiplikation das Matrizprodukt der Argumente. Die Anzahl der Zeilen der Matrix b muss gleich der Anzahl der Spalten der Matrix a sein. Das Ergebnis ist eine Matrix, deren Anzahl der Zeilen der der Matrix a entspricht und deren Anzahl der Spalten der der Matrix b entspricht.

Um den nichtkommutativen Operator . vom Dezimalpunkt einer Gleitkommazahl zu unterscheiden, kann es notwendig sein, dem Operator ein Leerzeichen voranzustellen und folgen zu lassen. Zum Beispiel ist 5.e3 die Gleitkommazahl 5000.0 und 5 . e3 ist 5 multipliziert mit der Variablen e3.

Verschiedene Schalter kontrollieren die Vereinfachung der nichtkommutativen Multiplikation. Zu diesen gehören:

   dot            dot0nscsimp     dot0simp
   dot1simp       dotassoc        dotconstrules
   dotdistrib     dotexptsimp     dotident
   dotscrules

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

19.1.2 Vektoren

vect ist ein Paket mit Funktionen der Vektoranalysis. Mit dem Kommando load(vect) wird das Paket geladen. Das Kommando demo(vect) zeigt Beispiele.

Das Paket enthält Funktionen, um Ausdrücke mit nicht-kommutativen Multiplikationen und Kreuzprodukten sowie Gradienten, Divergenzen, Rotationen und Laplace-Operatoren zu vereinfachen. Die Vereinfachung dieser Operatoren wird von verschiedenen Schaltern kontrolliert. Weiterhin können die Ergebnisse in verschiedenen Koordinatensystemen berechnet werden. Mit weiteren Funktionen kann das Skalarpotential oder das Vektorpotential eines Feldes bestimmt werden.

Das Paket vect enthält die folgenden Funktionen: vectorsimp, scalefactors, express, potential und vectorpotential.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

19.1.3 Eigenwerte

Das Paket eigen enthält verschiedene Funktionen, um symbolisch Eigenwerte und Eigenvektoren zu bestimmen. Maxima lädt dieses Paket automatisch, wenn eine der Funktionen dieses Pakets genutzt wird. Das Paket kann auch mit dem Kommando load(eigen) geladen werden.

Das Kommando demo(eigen) zeigt Beispiele für das Paket. Die Beispiele können auch mit dem Kommando batch(eigen angezeigt werden. In diesem Fall wartet Maxima zwischen den einzelnen Beispielen auf die Eingabe des Nutzers.

Das Paket eigen enthält die folgenden Funktionen:

   innerproduct       unitvector            columnvector
   gramschmidt        eigenvalues           eigenvectors
   uniteigenvectors   similaritytransform

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

19.2 Funktionen und Variablen der linearen Algebra

Funktion: addcol (M, list_1, …, list_n)

Hängt eine oder mehrere Spalten, die als Listen list_1, …, list_n übergeben werden, an die Matrix M an.

Beispiel:

(%i1) M:matrix([a,b],[c,d]);
                            [ a  b ]
(%o1)                       [      ]
                            [ c  d ]
(%i2) addcol(M,[1,2],[x,y]);
                         [ a  b  1  x ]
(%o2)                    [            ]
                         [ c  d  2  y ]

Funktion: addrow (M, list_1, …, list_n)

Hängt eine oder mehrere Zeilen, die als Listen list_1, …, list_n übergeben werden, an die Matrix M an.

Beispiel:

(%i1) M:matrix([a,b],[c,d]);
                            [ a  b ]
(%o1)                       [      ]
                            [ c  d ]
(%i2) addrow(M,[1,2],[x,y]);
                            [ a  b ]
                            [      ]
                            [ c  d ]
(%o2)                       [      ]
                            [ 1  2 ]
                            [      ]
                            [ x  y ]

Funktion: adjoint (M)

Gibt die adjungierte der Matrix M zurück.

Funktion: augcoefmatrix ([eqn_1, …, eqn_m], [x_1, …, x_n])

Gibt die erweiterte Koeffizientenmatrix für die Variablen x_1, …, x_n und dem linearen Gleichungssystem eqn_1, …, eqn_m. Die erweiterte Koeffizientenmatrix entsteht, wenn an die Koeffizientenmatrix des Gleichungssystems die Spalte mit der rechten Seite des Gleichungssystems angefügt wird.

Beispiel:

(%i1) m: [2*x - (a - 1)*y = 5*b, c + b*y + a*x = 0]$
(%i2) augcoefmatrix (m, [x, y]);
                       [ 2  1 - a  - 5 b ]
(%o2)                  [                 ]
                       [ a    b      c   ]

Funktion: charpoly (M, x)

Gibt das charakteristische Polynom der Matrix M für die Variable x zurück. Das charakterische Polynom wird als determinant(M - diagmatrix(length (M), x)) berechnet.

Beispiel:

(%i1) a: matrix ([3, 1], [2, 4]);
                            [ 3  1 ]
(%o1)                       [      ]
                            [ 2  4 ]
(%i2) expand (charpoly (a, lambda));
                           2
(%o2)                lambda  - 7 lambda + 10
(%i3) (programmode: true, solve (%));
(%o3)               [lambda = 5, lambda = 2]
(%i4) matrix ([x1], [x2]);
                             [ x1 ]
(%o4)                        [    ]
                             [ x2 ]
(%i5) ev (a . % - lambda*%, %th(2)[1]);
                          [ x2 - 2 x1 ]
(%o5)                     [           ]
                          [ 2 x1 - x2 ]
(%i6) %[1, 1] = 0;
(%o6)                     x2 - 2 x1 = 0
(%i7) x2^2 + x1^2 = 1;
                            2     2
(%o7)                     x2  + x1  = 1
(%i8) solve ([%th(2), %], [x1, x2]);
                  1               2
(%o8) [[x1 = - -------, x2 = - -------], 
               sqrt(5)         sqrt(5)

                                             1             2
                                    [x1 = -------, x2 = -------]]
                                          sqrt(5)       sqrt(5)

Funktion: coefmatrix ([eqn_1, …, eqn_m], [x_1, …, x_n])

Gibt die Koeffizientenmatrix für die Variablen x_1, …, x_n des linearen Gleichungssystem eqn_1, …, eqn_m zurück.

Beispiel:

(%i1) coefmatrix([2*x-(a-1)*y+5*b = 0, b*y+a*x = 3], [x,y]);
                                 [ 2  1 - a ]
(%o1)                            [          ]
                                 [ a    b   ]

Funktion: col (M, i)

Gibt die i-te Spalte der Matrix M zurück. Das Ergebnis ist eine Matrix.

Beispiel:

(%i1) M:matrix([1,2,3],[a,b,c]);
                           [ 1  2  3 ]
(%o1)                      [         ]
                           [ a  b  c ]
(%i2) col(M,2);
                              [ 2 ]
(%o2)                         [   ]
                              [ b ]

Funktion: columnvector (L)
Funktion: covect (L)

Gibt eine Matrix mit einer Spalte zurück, die die Elemente der Liste L enthält.

covect ist ein Alias-Name für die Funktion columnvector. Das Kommando load(eigen) lädt die Funktion.

Beispiel:

(%i1) load(eigen)$

(%i2) columnvector ([aa, bb, cc]);
                             [ aa ]
                             [    ]
(%o2)                        [ bb ]
                             [    ]
                             [ cc ]

Funktion: copymatrix (M)

Gibt eine Kopie der Matrix M zurück.

Die Zuweisung wie zum Beispiel m2: m1 kopiert die Matrix m1 nicht. Wird nach dieser Zuweisung die Matrix m2 geändert, wird auch die Matrix m1 geändert. Um eine Kopie zu erhalten, muss m2: copymatrix(m1) ausgeführt werden.

Funktion: determinant (M)

Berechnet die Determinate der Matrix M. Die angewendete Methode ist vergleichbar mit dem Gauß-Verfahren.

determinat wird von den Schaltern ratmx und sparse kontrolliert. Haben beide Schalter den Wert true, wird ein spezieller Algorithmus für schwachbesetzte Matrizen aufgerufen.

Optionsvariable: detout

Standardwert: false

Hat detout den Wert true, wird die Determinate einer Matrix, für die die inverse Matrix berechnet wird, aus der Matrix herausmultipliziert.

Damit dieser Schalter einen Effekt hat, müssen die Optionsvariablen doallmxops und doscmxops den Wert false haben.

Beispiele:

(%i1) m: matrix ([a, b], [c, d]);
                            [ a  b ]
(%o1)                       [      ]
                            [ c  d ]
(%i2) detout: true$
(%i3) doallmxops: false$
(%i4) doscmxops: false$
(%i5) invert (m);
                          [  d   - b ]
                          [          ]
                          [ - c   a  ]
(%o5)                     ------------
                           a d - b c

Funktion: diagmatrix (n, x)

Gibt eine n-dimensionale Diagonalmatrix zurück, deren Diagonalelemente alle den Wert x haben.

n muss zu einer ganzen Zahl auswerten. Ansonsten meldet Maxima einen Fehler.

x kann ein beliebiger Ausdruck einschließlich einer Matrix sein. Ist x eine Matrix, dann wird diese nicht kopiert.

Optionsvariable: doallmxops

Standardwert: true

Hat doallmxops den Wert true, werden Matrixoperationen ausgeführt. Ist der Wert false, werden nur die Matrixoperationen ausgeführt, die mit den einzelnen dot-Schaltern eingeschaltet sind.

Optionsvariable: domxexpt

Standardwert: true

Hat domxexpt den Wert true, wird die Exponentiation exp(M), wobei M eine Matrix ist, elementweise für jedes einzelne Matrixelement ausgeführt, so dass für jedes Element der Matrix gilt exp (m[i,j]). Ansonsten wird die Exponentiation als exp (ev(M) ausgewertet.

domxexpt beeinflußt alle Ausdrücke der Form a^b, wobei a eine Konstante oder ein skalarer Ausdruck und b eine Liste oder Matrix ist.

Beispiele:

(%i1) m: matrix ([1, %i], [a+b, %pi]);
                         [   1    %i  ]
(%o1)                    [            ]
                         [ b + a  %pi ]
(%i2) domxexpt: false$
(%i3) (1 - c)^m;
                             [   1    %i  ]
                             [            ]
                             [ b + a  %pi ]
(%o3)                 (1 - c)
(%i4) domxexpt: true$
(%i5) (1 - c)^m;
                  [                      %i  ]
                  [    1 - c      (1 - c)    ]
(%o5)             [                          ]
                  [        b + a         %pi ]
                  [ (1 - c)       (1 - c)    ]

Optionsvariable: domxmxops

Standardwert: true

Hat domxmxops den Wert true, werden allen Matrix-Matrix und Matrix-Listen-Operationen ausgeführt.

Optionsvariable: domxnctimes

Standardwert: false

Hat domxnctimes den Wert true, werden nichtkommutative Produkte von Matrizen ausgeführt.

Optionsvariable: doscmxops

Standardwert: false

Hat doscmxops den Wert true, werden Skalar-Matrix-Operationen ausgeführt.

Optionsvariable: doscmxplus

Standardwert: false

Hat doscmxplus den Wert true, haben Skalar-Matrix-Operationen eine Matrix als Ergebnis. Dieser Schalter ist nicht unter doallmxops subsumiert.

Optionsvariable: dot0nscsimp

Standardwert: true

Hat dot0nscsimp den Wert true, werden nichtkommutative Produkte mit einer Null und einem nichtskalaren Term zu einem kommutativen Produkt vereinfacht.

Optionsvariable: dot0simp

Standardwert: true

Hat dot0simp den Wert true, werden nichtkommutative Produkte mit einer Null und einem skalaren Term zu einem kommutatitiven Produkt vereinfacht.

Optionsvariable: dot1simp

Standardwert: true

Hat dot1simp den Wert true, werden nichtkommutative Produkte mit einer Eins und einem anderen Term zu einem kommutativen Produkt vereinfacht.

Optionsvariable: dotassoc

Standardwert: true

Hat dotassoc den Wert true, vereinfacht Maxima ein Ausdruck (A.B).C zu A.(B.C).

Optionsvariable: dotconstrules

Standardwert: true

Hat dotconstrules den Wert true, werden nichtkommutative Produkte einer Konstanten und eines Termes zu einem kommutativen Produkt vereinfacht. Die folgenden Optionsvariablen dot0simp, dot0nscsimp und dot1simp erhalten den Wert true, wenn construles eingeschaltet wird.

Optionsvariable: dotdistrib

Standardwert: false

Hat dotdistrib den Wert true, vereinfacht Maxima einen Ausdruck A.(B + C) zu A.B + A.C.

Optionsvariable: dotexptsimp

Standardwert: true

Hat dotexptsimp den Wert true, vereinfacht Maxima einen Ausdruck A.A zu A^^2.

Optionsvariable: dotident

Standardwert: 1

dotident ist der Wert der für den Ausdruck X^^0 zurückgegeben wird.

Optionsvariable: dotscrules

Standardwert: false

Hat dotscrules den Wert true, vereinfacht Maxima Ausdrücke A.SC oder SC.A zu SC*A und A.(SC*B) zu SC*(A.B).

Funktion: echelon (M)

Gibt die Matrix m in ihrer Stufenform zurück, wie sie im Gaußschen Eliminationsverfahren auftritt.

Im Unterschied zur Funktion triangularize wird die Matrix so normiert, dass die Hauptdiagonalelemente den Wert 1 haben.

lu_factor und cholesky sind weitere Funktionen, um Dreiecksmatrizen zu erhalten.

Beispiel:

(%i1) M: matrix ([3, 7, aa, bb], [-1, 8, 5, 2], [9, 2, 11, 4]);
                       [  3   7  aa  bb ]
                       [                ]
(%o1)                  [ - 1  8  5   2  ]
                       [                ]
                       [  9   2  11  4  ]
(%i2) echelon (M);
                  [ 1  - 8  - 5      - 2     ]
                  [                          ]
                  [         28       11      ]
                  [ 0   1   --       --      ]
(%o2)             [         37       37      ]
                  [                          ]
                  [              37 bb - 119 ]
                  [ 0   0    1   ----------- ]
                  [              37 aa - 313 ]

Funktion: eigenvalues (M)
Funktion: eivals (M)

Gibt eine Liste mit den Eigenwerten der Matrix M und deren Multiplizitäten zurück. Die erste Teilliste enthält die Eigenwerte, die zweite deren Multiplizitäten.

eivals ist ein Alias-Name der Funktion eigenvalues.

eigenvalues ruft die Funktion solve auf, um die Nullstellen des charakeristischen Polynoms der Matrix zu finden. Wenn solve keine Nullstellen finden kann, funktionieren einige Funktionen des Pakets nicht. Dies trifft nicht auf die Funktionen innerproduct, unitvector, columnvector und gramschmidt zu.

Die Eigenwerte, die solve findet, können sehr komplizierte Ausdrücke sein. Es kann möglich sein, solche Ausdrücke weiter zu vereinfachen.

Das Paket eigen wird automatisch geladen, wenn eine der Funktionen eigenvalues oder eigenvectors aufgerufen wird.

Funktion: eigenvectors (M)
Funktion: eivects (M)

Berechnet die Eigenvektoren der Matrix M. Die Rückgabe ist eine Liste, die zwei weitere Listen enthält. Die erste Liste enthält die Eigenwerte der Matrix m und deren Multiplizitäten. Die zweite Liste enthält die Eigenvektoren.

eivects ist ein Alias-Name der Funktion eigenvectors.

Das Paket eigen wird automatisch geladen, wenn die Funktionen eigenvalues oder eigenvectors aufgerufen werden.

Folgende Schalter kontrollieren eigenvectors:

nondiagonalizable

nondiagonalizabel hat den Wert true oder false nach Rückkehr der Funktion eigenvectros abhängig davon, ob die Matrix diagonalisierbar ist oder nicht.

hermitianmatrix

Hat hermitianmatrix den Wert true, werden die entarteten Eigenvektoren einer Hermitischen Matrix mit dem Gram-Schmidt-Verfahren orthogonalisiert.

knowneigvals

Hat knowneigvals den Wert true, werden die Eigenwerte der Matrix von den Funktionen des Paketes eigen als bekannt angenommen. Die Eigenwerte sind in diesem Fall in der Liste listeigvals abgespeichert. Die Liste listeigvals muss dieselbe Form haben, wie die Rückgabe der Funktion eigenvalues.

Die Eigenvektoren werden von der Funktion algsys berechnet. Es ist möglich, dass algsys die Eigenvektoren nicht findet. In diesem Fall können möglicherweise zunächst die Eigenwerte bestimmt und weiter vereinfacht werden. Dannach kann die Funktion eigenvectors mit dem Schalter knowneigvals aufgerufen werden.

Siehe auch eigenvalues.

Beispiele:

Eine Matrix, die einen Eigenvektor zu jedem Eigenwert hat.

(%i1) M1 : matrix ([11, -1], [1, 7]);
                           [ 11  - 1 ]
(%o1)                      [         ]
                           [ 1    7  ]
(%i2) [vals, vecs] : eigenvectors (M1);
(%o2) [[[9 - sqrt(3), sqrt(3) + 9], [1, 1]], 
                        [[[1, sqrt(3) + 2]], [[1, 2 - sqrt(3)]]]]
(%i3) for i thru length (vals[1]) do disp (val[i] = vals[1][i],
  mult[i] = vals[2][i], vec[i] = vecs[i]);
                       val  = 9 - sqrt(3)
                          1

                            mult  = 1
                                1

                    vec  = [[1, sqrt(3) + 2]]
                       1

                       val  = sqrt(3) + 9
                          2

                            mult  = 1
                                2

                    vec  = [[1, 2 - sqrt(3)]]
                       2

(%o3)                         done

Eine Matrix, die zwei Eigenvektoren zu jedem Eigenwert hat.

(%i1) M1 : matrix([0, 1, 0, 0], [0, 0, 0, 0], [0, 0, 2, 0], 
                  [0, 0, 0, 2]);
                         [ 0  1  0  0 ]
                         [            ]
                         [ 0  0  0  0 ]
(%o1)                    [            ]
                         [ 0  0  2  0 ]
                         [            ]
                         [ 0  0  0  2 ]
(%i2) [vals, vecs] : eigenvectors (M1);
(%o2) [[[0, 2], [2, 2]], [[[1, 0, 0, 0]],
                                   [[0, 0, 1, 0], [0, 0, 0, 1]]]]
(%i3) for i thru length (vals[1]) do disp (val[i] = vals[1][i],
  mult[i] = vals[2][i], vec[i] = vecs[i]);
                            val  = 0
                               1

                            mult  = 2
                                1

                      vec  = [[1, 0, 0, 0]]
                         1

                            val  = 2
                               2

                            mult  = 2
                                2

               vec  = [[0, 0, 1, 0], [0, 0, 0, 1]]
                  2

(%o3)                         done

Funktion: ematrix (m, n, x, i, j)

Gibt eine m x n-Matrix zurück, deren Elemente den Wert 0 haben, bis auf das Element [i, j], das den Wert x hat.

Funktion: entermatrix (m, n)

Gibt eine m x n-Matrix zurück, die von der Konsole eingelesen wird.

Ist n gleich m, fragt Maxima nach dem Typ der Matrix. Folgende Typen können angegeben werden: diagonal, symmetric, antisymmetric oder allgemein. Dannach werden die einzelnen Elemente der Matrix abgefragt.

Sind n und m voneinander verschieden, fragt Maxima nach jedem Element der Matrix.

Die Elemente können beliebige Ausdrücke sein, die ausgewertet werden. entermatrix wertet die Argumente aus.

Beispiel:

(%i1) n: 3$
(%i2) m: entermatrix (n, n)$

Is the matrix  1. Diagonal  2. Symmetric  3. Antisymmetric 
4. General
Answer 1, 2, 3 or 4 : 
1$
Row 1 Column 1: 
(a+b)^n$
Row 2 Column 2: 
(a+b)^(n+1)$
Row 3 Column 3: 
(a+b)^(n+2)$

Matrix entered.
(%i3) m;
                [        3                     ]
                [ (b + a)      0         0     ]
                [                              ]
(%o3)           [                  4           ]
                [    0      (b + a)      0     ]
                [                              ]
                [                            5 ]
                [    0         0      (b + a)  ]

Funktion: express (expr)

Expandiert Differentialoperatoren in einem Ausdruck in partielle Ableitungen. express erkennt die Operatoren grad, div, curl, laplacian und das Kreuzprodukt ~.

Enthält die Rückgabe Substantivformen von Ableitungen, können diese mit der Funktion ev und den Auswertungsschaltern nouns oder diff ausgewertet werden.

Mit dem Kommando load(vect) wird die Funktion geladen.

Beispiele:

(%i1) load ("vect")$
(%i2) grad (x^2 + y^2 + z^2);
                              2    2    2
(%o2)                  grad (z  + y  + x )
(%i3) express (%);
       d    2    2    2   d    2    2    2   d    2    2    2
(%o3) [-- (z  + y  + x ), -- (z  + y  + x ), -- (z  + y  + x )]
       dx                 dy                 dz
(%i4) ev (%, diff);
(%o4)                    [2 x, 2 y, 2 z]
(%i5) div ([x^2, y^2, z^2]);
                              2   2   2
(%o5)                   div [x , y , z ]
(%i6) express (%);
                   d    2    d    2    d    2
(%o6)              -- (z ) + -- (y ) + -- (x )
                   dz        dy        dx
(%i7) ev (%, diff);
(%o7)                    2 z + 2 y + 2 x
(%i8) curl ([x^2, y^2, z^2]);
                               2   2   2
(%o8)                   curl [x , y , z ]
(%i9) express (%);
       d    2    d    2   d    2    d    2   d    2    d    2
(%o9) [-- (z ) - -- (y ), -- (x ) - -- (z ), -- (y ) - -- (x )]
       dy        dz       dz        dx       dx        dy
(%i10) ev (%, diff);
(%o10)                      [0, 0, 0]
(%i11) laplacian (x^2 * y^2 * z^2);
                                  2  2  2
(%o11)                laplacian (x  y  z )
(%i12) express (%);
         2                2                2
        d     2  2  2    d     2  2  2    d     2  2  2
(%o12)  --- (x  y  z ) + --- (x  y  z ) + --- (x  y  z )
          2                2                2
        dz               dy               dx
(%i13) ev (%, diff);
                      2  2      2  2      2  2
(%o13)             2 y  z  + 2 x  z  + 2 x  y
(%i14) [a, b, c] ~ [x, y, z];
(%o14)                [a, b, c] ~ [x, y, z]
(%i15) express (%);
(%o15)          [b z - c y, c x - a z, a y - b x]

Funktion: genmatrix (a, i_2, j_2, i_1, j_1)
Funktion: genmatrix (a, i_2, j_2, i_1)
Funktion: genmatrix (a, i_2, j_2)

Generiert eine Matrix aus einem Array a. Das erste Element der Matrix ist der Wert a[i_1,j_1] und das letzte Element der Matrix ist a[i_2,j_2]. a muss ein deklariertes Array sein, dass mit der Funktion array definiert wurde. Weiterhin kann a ein undeklariertes Array, eine Array-Funktion oder ein lambda-Ausdruck mit zwei Argumenten sein.

Wird j_1 nicht angegeben, nimmt Maxima an, das der Wert gleich i_1 ist. Werden beide Argumente j_1 und i_1 nicht angegeben, werden die Werte zu 1 angenommen.

Ist eines der Elemente [i,j] des Arrays nicht definiert, enthält die Matrix den symbolischen Wert a[i,j].

Beispiele:

(%i1) h [i, j] := 1 / (i + j - 1);
                                    1
(%o1)                  h     := ---------
                        i, j    i + j - 1
(%i2) genmatrix (h, 3, 3);
                           [    1  1 ]
                           [ 1  -  - ]
                           [    2  3 ]
                           [         ]
                           [ 1  1  1 ]
(%o2)                      [ -  -  - ]
                           [ 2  3  4 ]
                           [         ]
                           [ 1  1  1 ]
                           [ -  -  - ]
                           [ 3  4  5 ]
(%i3) array (a, fixnum, 2, 2);
(%o3)                           a
(%i4) a [1, 1] : %e;
(%o4)                          %e
(%i5) a [2, 2] : %pi;
(%o5)                          %pi
(%i6) genmatrix (a, 2, 2);
                           [ %e   0  ]
(%o6)                      [         ]
                           [ 0   %pi ]
(%i7) genmatrix (lambda ([i, j], j - i), 3, 3);
                         [  0    1   2 ]
                         [             ]
(%o7)                    [ - 1   0   1 ]
                         [             ]
                         [ - 2  - 1  0 ]
(%i8) genmatrix (B, 2, 2);
                        [ B      B     ]
                        [  1, 1   1, 2 ]
(%o8)                   [              ]
                        [ B      B     ]
                        [  2, 1   2, 2 ]

Funktion: gramschmidt (x)
Funktion: gramschmidt (x, F)

Wendet das Gram-Schmidtsche Orthogonalisierungsverfahren auf das Argument x an. x ist eine Matrix oder eine Liste mit Listen für die Spalten. Das Argument x wird von gramschmidt nicht verändert. F bezeichnet eine Funktion, die als Skalarprodukt für das Verfahren verwendet wird. Wird F nicht angegeben, wird die Funktion innerproduct für das Skalarprodukt angewendet.

Ist x eine Matrix, wird der Algorithmus auf die Zeilen der Matrix angewendet. Ist x eine Liste mit Listen, wird der Algorithmus auf die Teillisten angewendet, die jeweils die gleiche Anzahl an Elementen haben müssen.

Jede Stufe des Verfahrens ruft die Funktion factor auf, um die Zwischenergebnisse zu vereinfachen. Dadurch kann das Ergebnis faktorisierte ganze Zahlen enthalten.

Das Kommando load(eigen) lädt die Funktion.

Beispiele:

Das Gram-Schmidtsche Orthogonalisierungsverfahren mit innerproduct als Skalarprodukt.

(%i1) load (eigen)$
(%i2) x: matrix ([1, 2, 3], [9, 18, 30], [12, 48, 60]);
                         [ 1   2   3  ]
                         [            ]
(%o2)                    [ 9   18  30 ]
                         [            ]
                         [ 12  48  60 ]
(%i3) y: gramschmidt (x);
                       2      2            4     3
                      3      3   3 5      2  3  2  3
(%o3)  [[1, 2, 3], [- ---, - --, ---], [- ----, ----, 0]]
                      2 7    7   2 7       5     5
(%i4) map (innerproduct, [y[1], y[2], y[3]], [y[2], y[3], y[1]]);
(%o4)                       [0, 0, 0]

Das Gram-Schmidtsche Orthogonalisierungsverfahren mit einer selbstdefinierten Funktion für das Skalarprodukt.

(%i1) load (eigen)$
(%i2) ip (f, g) := integrate (f * g, u, a, b);
(%o2)          ip(f, g) := integrate(f g, u, a, b)
(%i3) y : gramschmidt([1, sin(u), cos(u)], ip), a=-%pi/2, b=%pi/2;
                               %pi cos(u) - 2
(%o3)              [1, sin(u), --------------]
                                    %pi
(%i4) map(ip,[y[1],y[2],y[3]],[y[2],y[3],y[1]]), a=-%pi/2, b=%pi/2;
(%o4)                       [0, 0, 0]

Funktion: ident (n)

Gibt eine n x n-Einheitsmatrix zurück.

Funktion: innerproduct (x, y)
Funktion: inprod (x, y)

Gibt das Skalarprodukt der Argumente x und y zurück. Die Argument können Listen oder 1-spaltige oder 1-reihige Matrizen sein. Das Skalarprodukt wird als conjugate(x) . y berechnet, wobei . der Operator der nicht-kommutativen Multiplikation ist.

Das Kommando load(eigen) lädt die Funktion.

inprod ist ein Alias-Name der Funktion innerproduct.

Funktion: invert (M)

Gibt die inverse Matrix der Matrix M zurück. Die inverse Matrix wird mittels der Adjunkten Matrix berechnet.

Mit dieser Methode kann die inverse Matrix auch für große Gleitkommazahlen sowie Polynomme als Matrixelemente berechnet werden.

Die Kofaktoren werden mit der Funktion determinant berechnet. Hat die Optionsvariable ratmx den Wert true, wird die inverse Matrix daher ohne einen Wechsel der Darstellung berechnet.

Die implementierte Methode ist jedoch ineffizient für große Matrizen.

Hat die Optionsvariable detout den Wert true, wird die Determinante als Faktor aus der Matrix herausgezogen.

Die Elemente der inversen Matrix werden nicht automatisch expandiert. Hat M Polynome als Elemente, hat das Ergebnis möglicherweise mit dem Kommando expand(invert(m)), detout eine einfachere Form. Mit der Funktion multthru die Determinate in die Matrix hereinmultipliziert werden. Die inverse Matrix kann auch folgendermaßen berechnet werden:

expand (adjoint (m)) / expand (determinant (m))
invert (m) := adjoint (m) / determinant (m)

Siehe auch den Operator ^^ der nicht-kommutativen Exponentiation für eine andere Methode zur Berechnung der inversen Matrix.

Optionsvariable: lmxchar

Standardwert: [

lmxchar ist das Zeichen, das für die linke Seite einer Matrix ausgegeben wird. Siehe auch rmxchar.

Beispiel:

(%i1) lmxchar: "|"$
(%i2) matrix ([a, b, c], [d, e, f], [g, h, i]);
                           | a  b  c ]
                           |         ]
(%o2)                      | d  e  f ]
                           |         ]
                           | g  h  i ]

Funktion: matrix (row_1, …, row_n)

Gibt eine Matrix mit den Spalten row_1, …, row_n zurück. Jede Spalte ist eine Liste mit Asudrücken. Alle Spalten müssen die gleiche Länge haben.

Die Addition +, Subtraktion -, Multiplikation * und Division / werden elementweise ausgeführt, wenn die Argumente zwei Matrizen, ein Skalar und eine Matrix oder eine Matrix und ein Skalar sind. Die Exponentiation ^ wird elementweise ausgeführt, wenn die Argumente ein Skalar und eine Matrix oder umgekehrt sind.

Die nichtkommutatie Multiplikation von Matrizen wird mit dem Operator . ausgeführt. Der entsprechende Operator für die nichtkommutative Exponentiation ist ^^. Für eine Matrix A ist A . A = A^^2. A^^-1 ist die inverse Matrix, falls diese existiert.

Folgende Schalter kontrollieren die Vereinfachung von Ausdrücken, welche die nichtkommutative Multiplikation und Matrizen enthalten:

doallmxops, domxexpt, domxmxops, doscmxops und doscmxplus.

Weitere Optionsvariablen für Matrizen sind:

lmxchar, rmxchar, ratmx, listarith, detout, scalarmatrix und sparse.

Folgende Funktionen akzeptieren Matrizen als ein Argument oder haben eine Matrix als Rückgabewert:

eigenvalues, eigenvectors, determinant, charpoly, genmatrix, addcol, addrow, copymatrix, transpose, echelon and rank.

Beispiele:

Konstruiere eine Matrix mit Listen.

(%i1) x: matrix ([17, 3], [-8, 11]);
                           [ 17   3  ]
(%o1)                      [         ]
                           [ - 8  11 ]
(%i2) y: matrix ([%pi, %e], [a, b]);
                           [ %pi  %e ]
(%o2)                      [         ]
                           [  a   b  ]

Elementweise Addition zweier Matrizen.

(%i3) x + y;
                      [ %pi + 17  %e + 3 ]
(%o3)                 [                  ]
                      [  a - 8    b + 11 ]

Elementweise Subtraktion zweier Matrizen.

(%i4) x - y;
                      [ 17 - %pi  3 - %e ]
(%o4)                 [                  ]
                      [ - a - 8   11 - b ]

Elementweise Multiplikation zweier Matrizen.

(%i5) x * y;
                        [ 17 %pi  3 %e ]
(%o5)                   [              ]
                        [ - 8 a   11 b ]

Elementweise Division zweier Matrizen.

(%i6) x / y;
                        [ 17       - 1 ]
                        [ ---  3 %e    ]
                        [ %pi          ]
(%o6)                   [              ]
                        [   8    11    ]
                        [ - -    --    ]
                        [   a    b     ]

Elementweise Exponentiation einer Matrix mit einem Skalar.

(%i7) x ^ 3;
                         [ 4913    27  ]
(%o7)                    [             ]
                         [ - 512  1331 ]

Elementweise Exponentiation eines Skalars mit einer Matrix.

(%i8) exp(y); 
                         [   %pi    %e ]
                         [ %e     %e   ]
(%o8)                    [             ]
                         [    a     b  ]
                         [  %e    %e   ]

Die Exponentiation zweier Matrizen wird nicht elementweise ausgeführt.

(%i9) x ^ y;
                                [ %pi  %e ]
                                [         ]
                                [  a   b  ]
                     [ 17   3  ]
(%o9)                [         ]
                     [ - 8  11 ]

Nichtkommutative Multiplikation zweier Matrizen.

(%i10) x . y;
                  [ 3 a + 17 %pi  3 b + 17 %e ]
(%o10)            [                           ]
                  [ 11 a - 8 %pi  11 b - 8 %e ]
(%i11) y . x;
                [ 17 %pi - 8 %e  3 %pi + 11 %e ]
(%o11)          [                              ]
                [  17 a - 8 b     11 b + 3 a   ]

Nichtkommutative Exponentiation einer Matrix. Ist die Basis ein Skalar wird die Exponentiation elementweise ausgeführt. Daher haben die Operationen ^^ und ^ für diesen Fall dasselbe Ergebnis.

(%i12) x ^^ 3;
                        [  3833   1719 ]
(%o12)                  [              ]
                        [ - 4584  395  ]
(%i13) %e ^^ y;
                         [   %pi    %e ]
                         [ %e     %e   ]
(%o13)                   [             ]
                         [    a     b  ]
                         [  %e    %e   ]

Berechnung der inversen Matrix mit x^^-1.

(%i14) x ^^ -1;
                         [ 11      3  ]
                         [ ---  - --- ]
                         [ 211    211 ]
(%o14)                   [            ]
                         [  8    17   ]
                         [ ---   ---  ]
                         [ 211   211  ]
(%i15) x . (x ^^ -1);
                            [ 1  0 ]
(%o15)                      [      ]
                            [ 0  1 ]

Funktion: matrixmap (f, M)

Gibt eine Matrix mit den Elementen [i,j] zurück, die mit f(M[i,j]) berechnet werden.

Siehe auch map, fullmap, fullmapl, and apply.

Funktion: matrixp (expr)

Gibt true zurück, wenn expr eine Matrix ist. Ansonsten wird false zurückgegeben.

Optionsvariable: matrix_element_add

Standardwert: +

matrix_element_add enthält die Operation für die Ausführung der Addition von Matrizen. Der Optionsvariablen matrix_element_add kann ein N-Ary-Operator zugewiesen werden. Der zugewiesene Wert kann der Name eines Operators, einer Funktion oder ein Lambda-Ausdruck sein.

Siehe auch matrix_element_mult und matrix_element_transpose.

Beispiele:

(%i1) matrix_element_add: "*"$
(%i2) matrix_element_mult: "^"$
(%i3) aa: matrix ([a, b, c], [d, e, f]);
                           [ a  b  c ]
(%o3)                      [         ]
                           [ d  e  f ]
(%i4) bb: matrix ([u, v, w], [x, y, z]);
                           [ u  v  w ]
(%o4)                      [         ]
                           [ x  y  z ]
(%i5) aa . transpose (bb);
                     [  u  v  w   x  y  z ]
                     [ a  b  c   a  b  c  ]
(%o5)                [                    ]
                     [  u  v  w   x  y  z ]
                     [ d  e  f   d  e  f  ]

Optionsvariable: matrix_element_mult

Standardwert: *

matrix_element_mult enthält die Operation für die Ausführung der Multiplikation von Matrizen. Der Optionsvariablen matrix_element_mult kann ein binärer Operator zugewiesen werden. Der zugewiesene Wert kann der Name eines Operators, einer Funktion oder ein Lambda-Ausdruck sein.

Der nichtkommutative Operator . kann eine sinnvolle Alternative sein.

Siehe auch matrix_element_add und matrix_element_transpose.

Beispiele:

(%i1) matrix_element_add: lambda ([[x]], sqrt (apply ("+", x)))$
(%i2) matrix_element_mult: lambda ([x, y], (x - y)^2)$
(%i3) [a, b, c] . [x, y, z];
                          2          2          2
(%o3)         sqrt((c - z)  + (b - y)  + (a - x) )
(%i4) aa: matrix ([a, b, c], [d, e, f]);
                           [ a  b  c ]
(%o4)                      [         ]
                           [ d  e  f ]
(%i5) bb: matrix ([u, v, w], [x, y, z]);
                           [ u  v  w ]
(%o5)                      [         ]
                           [ x  y  z ]
(%i6) aa . transpose (bb);
               [             2          2          2  ]
               [ sqrt((c - w)  + (b - v)  + (a - u) ) ]
(%o6)  Col 1 = [                                      ]
               [             2          2          2  ]
               [ sqrt((f - w)  + (e - v)  + (d - u) ) ]

                         [             2          2          2  ]
                         [ sqrt((c - z)  + (b - y)  + (a - x) ) ]
                 Col 2 = [                                      ]
                         [             2          2          2  ]
                         [ sqrt((f - z)  + (e - y)  + (d - x) ) ]

Optionsvariable: matrix_element_transpose

Standardwert: false

matrix_element_transpose enthält die Operation für die Ausführung der Transponierung einer Matrix. Der Optionsvariablen matrix_element_mult kann ein unärer Operator zugewiesen werden. Der zugewiesene Wert kann der Name eines Operators, einer Funktion oder ein Lambda-Ausdruck sein.

Hat matrix_element_transpose den Wert transpose, wird die Funktion transpose auf jedes Element der Matrix angewendet. Hat matrix_element_transpose den Wert nonscalars, wird die Funktion transpose auf nichtskalare Elemente der Matrix angewendet. Ist eines der Elemente ein Atom, muss in diesem Fall das Atom als nonscalar deklariert sein.

Mit dem Standardwert false wird keine Operation angewendet.

Siehe auch matrix_element_add und matrix_element_mult.

Beispiele:

(%i1) declare (a, nonscalar)$
(%i2) transpose ([a, b]);
                        [ transpose(a) ]
(%o2)                   [              ]
                        [      b       ]
(%i3) matrix_element_transpose: nonscalars$
(%i4) transpose ([a, b]);
                        [ transpose(a) ]
(%o4)                   [              ]
                        [      b       ]
(%i5) matrix_element_transpose: transpose$
(%i6) transpose ([a, b]);
                        [ transpose(a) ]
(%o6)                   [              ]
                        [ transpose(b) ]
(%i7) matrix_element_transpose: lambda ([x], realpart(x)
      - %i*imagpart(x))$
(%i8) m: matrix ([1 + 5*%i, 3 - 2*%i], [7*%i, 11]);
                     [ 5 %i + 1  3 - 2 %i ]
(%o8)                [                    ]
                     [   7 %i       11    ]
(%i9) transpose (m);
                      [ 1 - 5 %i  - 7 %i ]
(%o9)                 [                  ]
                      [ 2 %i + 3    11   ]

Funktion: mattrace (M)

Gibt die Spur einer quadratischen Matrix M zurück.

Funktion: minor (M, i, j)

Gibt den Minor zu i, j der Matrix M zurück. Die Matrix entsteht durch Streichen der i-ten Spalte und j-ten Zeile.

Funktion: ncharpoly (M, x)

Gibt das charakteristische Polynom der Matrix M für die Variable x zurück. Diese Funktion ist eine Alternative zur Funktion charpoly.

Der Algorithmus von ncharpoly ist vorteilhaft gegenüber charpoly, wenn große und dünn besetzte Matrizen vorliegen. Das Kommando load(nchrpl lädt die Funktion.

Funktion: newdet (M, n)

Berechnet die Determinate der Matrix oder eines Arrays M mit dem Johnson-Gentleman-Algorithmus. Das Argument n ist die Ordnung. Für eine Matrix ist n ein optionales Argument.

Funktion: permanent (M, n)

Berechnet die Permanente der Matrix M. Die Permanente ist ähnlich der Determinate, aber es fehlen die Vorzeichenwechsel.

Funktion: rank (M)

Berechnet den Rang der Matrix M.

rank kann ein falsches Ergebnis geben, wenn ein Element äquivalent zu Null ist, dies aber nicht von Maxima festgestellt werden kann.

Funktion: potential (givengradient)

The calculation makes use of the global variable potentialzeroloc[0] which must be nonlist or of the form

[indeterminatej=expressionj, indeterminatek=expressionk, ...]

the former being equivalent to the nonlist expression for all right-hand sides in the latter. The indicated right-hand sides are used as the lower limit of integration. The success of the integrations may depend upon their values and order. potentialzeroloc is initially set to 0.

Optionsvariable: ratmx

Standardwert: false

Hat ratmx den Wert false, werden die Berechnung einer Determinante sowie die Operationen der Addition, Subtraktion und Multiplikation in der allgemeinen Darstellung ausgeführt. Das Ergebnis ist wieder eine allgemeine Darstellung.

Hat ratmx den Wert true, werden die oben genannten Operationen in einer CRE-Darstellung ausgeführt un das Ergebnis ist in einer CRE-Darstellung.

Optionsvariable: rmxchar

Standardwert: ]

rmxchar ist das Zeichen, das für die rechte Seite einer Matrix ausgegeben wird. Siehe auch lmxchar.

Funktion: row (M, i)

Gibt die i-te Spalte der Matrix M zurück. Der Rückgabewert ist eine Matrix.

Optionsvariable: scalarmatrixp

Standardwert: true

Hat scalarmatrixp den Wert true, dann werden 1 x 1-Matrizen, die als Ergebnis einer nicht-kommutativen Multiplikation auftreten, zu einem Skalar vereinfacht.

Hat scalarmatrixp den Wert all, dann werden alle 1 x 1-Matrizen zu einem Skalar vereinfacht.

Hat scalarmatrixp den Wert false, werden 1 x 1-Matrizen nicht zu einem Skalar vereinfacht.

Funktion: scalefactors (coordinatetransform)

Here coordinatetransform evaluates to the form [[expression1, expression2, …], indeterminate1, indeterminat2, …], where indeterminate1, indeterminate2, etc. are the curvilinear coordinate variables and where a set of rectangular Cartesian components is given in terms of the curvilinear coordinates by [expression1, expression2, …]. coordinates is set to the vector [indeterminate1, indeterminate2, …], and dimension is set to the length of this vector. SF[1], SF[2], …, SF[DIMENSION] are set to the coordinate scale factors, and sfprod is set to the product of these scale factors. Initially, coordinates is [X, Y, Z], dimension is 3, and SF[1]=SF[2]=SF[3]=SFPROD=1, corresponding to 3-dimensional rectangular Cartesian coordinates. To expand an expression into physical components in the current coordinate system, there is a function with usage of the form

Funktion: setelmx (x, i, j, M)

Weist x dem Matrixelement [i,j] zu und gibt die modifizierte Matrix zurück.

M[i, j]: x hat denselben Effekt. In diesem Fall wird jedoch der Wert x zurückgeben und nicht die Matrix.

Funktion: similaritytransform (M)
Funktion: simtran (M)

similaritytransform computes a similarity transform of the matrix M. It returns a list which is the output of the uniteigenvectors command. In addition if the flag nondiagonalizable is false two global matrices leftmatrix and rightmatrix are computed. These matrices have the property that leftmatrix . M . rightmatrix is a diagonal matrix with the eigenvalues of M on the diagonal. If nondiagonalizable is true the left and right matrices are not computed.

If the flag hermitianmatrix is true then leftmatrix is the complex conjugate of the transpose of rightmatrix. Otherwise leftmatrix is the inverse of rightmatrix.

rightmatrix is the matrix the columns of which are the unit eigenvectors of M. The other flags (see eigenvalues and eigenvectors) have the same effects since similaritytransform calls the other functions in the package in order to be able to form rightmatrix.

load ("eigen") loads this function.

simtran is a synonym for similaritytransform.

Optionsvariable: sparse

Standardwert: false

Haben sparse und ratmx den Wert true, verwendet die Funktion determinant einen speziellen Algorithmus für dünn besetzte Matrizen, um die Determinante einer Matrix zu berechnen.

Funktion: submatrix (i_1, …, i_m, M, j_1, …, j_n)
Funktion: submatrix (i_1, …, i_m, M)
Funktion: submatrix (M, j_1, …, j_n)

Gibt eine Matrix zurück, in der die Spalten i_1, …, i_m und die Zeilen j_1, …, j_n der Matrix M gelöscht sind.

Funktion: transpose (M)

Gibt die Transponierte der Matrix M zurück.

Ist M eine Matrix, ist das Ergebnis eine Matrix N mit den Elementen N[i,j] = M[j,i].

Ist M eine Liste, ist die Rückgabe eine Matrix N mit length(M) Spalten und einer Zeile. Die Elemente sind N[i,1] = M[i].

Ansonsten wird eine Substantivform 'transpose(M) zurückgegeben.

Funktion: triangularize (M)

Gibt die obere Dreiecksmatrix für die Matrix M zurück, wie sie mit dem Gaußschen Eliminationsverfahren berechnet wird. Die Dreiecksmatrix entspricht der Rückgabe der Funktion echelon mit dem Unterschied, dass die Elemente auf der Diagonalen nicht zu 1 normalisiert sind.

Mit den Funktionen lu_factor und cholesky kann ebenfalls eine Matrix in die Dreiecksform transformiert werden.

Beispiel:

(%i1) M: matrix ([3, 7, aa, bb], [-1, 8, 5, 2], [9, 2, 11, 4]);
                       [  3   7  aa  bb ]
                       [                ]
(%o1)                  [ - 1  8  5   2  ]
                       [                ]
                       [  9   2  11  4  ]
(%i2) triangularize (M);
             [ - 1   8         5            2      ]
             [                                     ]
(%o2)        [  0   - 74     - 56         - 22     ]
             [                                     ]
             [  0    0    626 - 74 aa  238 - 74 bb ]

Funktion: uniteigenvectors (M)
Funktion: ueivects (M)

Berechnet die Einheitsvektoren der Matrix M. Die Rückgabe ist eine Liste, die zwei weitere Listen enthält. Die erste Liste enthält die Eigenwerte der Matrix M und deren Multiplizitäten. Die zweite Liste enthält die Einheitsvektoren.

Ansonsten entspricht uniteigenvectors der Funktion eigenvectors.

Das Kommando load(eigen) lädt die Funktion.

ueivects ist ein Alias-Name der Funkion uniteigenvectors.

Funktion: unitvector (x)
Funktion: uvect (x)

Gibt den Einheitsvektor x/norm(x) zurück.

Das Kommando load(eigen) lädt die Funktion.

uvect ist ein Alias-Name der Funktion unitvector.

Funktion: vectorpotential (givencurl)

Returns the vector potential of a given curl vector, in the current coordinate system. potentialzeroloc has a similar role as for potential, but the order of the left-hand sides of the equations must be a cyclic permutation of the coordinate variables.

Funktion: vectorsimp (expr)

Applies simplifications and expansions according to the following global flags:

expandall         expanddot             expanddotplus
expandcross       expandcrossplus       expandcrosscross
expandgrad        expandgradplus        expandgradprod
expanddiv         expanddivplus         expanddivprod
expandcurl        expandcurlplus        expandcurlcurl 
expandlaplacian   expandlaplacianplus   expandlaplacianprod

All these flags have default value false. The plus suffix refers to employing additivity or distributivity. The prod suffix refers to the expansion for an operand that is any kind of product.

expandcrosscross

Simplifies p ~ (q ~ r) to (p . r)*q - (p . q)*r.

expandcurlcurl

Simplifies curl curl p to grad div p + div grad p.

expandlaplaciantodivgrad

Simplifies laplacian p to div grad p.

expandcross

Enables expandcrossplus and expandcrosscross.

expandplus

Enables expanddotplus, expandcrossplus, expandgradplus, expanddivplus, expandcurlplus, and expandlaplacianplus.

expandprod

Enables expandgradprod, expanddivprod, and expandlaplacianprod.

These flags have all been declared evflag.

Optionsvariable: vect_cross

Standardwert: false

Hat vect_cross den Wert true, werden Ausdrücke, die die Ableitung eines Kreuzproduktes enthalten, vereinfacht.

Beispiel:

(%i1) load(vect)$

(%i2) vect_cross:false;
(%o2)                         false
(%i3) diff(f(x)~g(x),x);
                        d
(%o3)                   -- (f(x) ~ g(x))
                        dx
(%i4) vect_cross:true;
(%o4)                         true
(%i5) diff(f(x)~g(x),x);
                     d                    d
(%o5)        f(x) ~ (-- (g(x))) - g(x) ~ (-- (f(x)))
                     dx                   dx

Funktion: zeromatrix (m, n)

Gibt eine m x n-Matrix zurück, deren Elemente alle Null sind.


[ << ] [ >> ]           [Top] [Contents] [Index] [ ? ]

This document was generated by Robert on Juli, 9 2012 using texi2html 1.76.