Behandlung indizierter Größen (Maxima Manual)

Nächste: Tensorsymmetrien, Vorige: Funktionen und Variablen für ITENSOR, Nach oben: Funktionen und Variablen für ITENSOR [Inhalt][Index]

#### 20.2.2.1 Behandlung indizierter Größen

Funktion: canten (expr) ¶

  Ist vergleichbar mit der Funktion `rename` und vereinfacht den Ausdruck expr indem gebundene Indizes umbenannt und permutiert werden. Wie die Funktion `rename` kann `canten` nur Ausdrücke mit Summen von Tensorprodukten vereinfachen, in denen keine Ableitungen nach Tensorkomponenten auftreten. Daher sollte `canten` nur verwendet werden, wenn sich mit der Funktion `canform` nicht die gewünschte Vereinfachung eines Ausdrucks erzielen lässt.

  Das Ergebnis der Funktion `canten` ist mathematisch nur korrekt, wenn die Tensoren symmetrisch in ihren Indizes sind. Hat die Optionsvariable `allsym` nicht den Wert `true`, bricht `canten` mit einer Fehlermeldung ab.

  Siehe auch die Funktion `concan`, mit der Ausdrücke mit Tensoren ebenfalls vereinfacht werden können, wobei `concan` zusätzlich Tensorverjüngungen ausführt.

Funktion: changename (old, new, expr) ¶

  Ändert den Namen aller Tensoren im Ausdruck expr von old nach new. Das Argument old kann ein Symbol oder eine Liste der Form `[name, m, n]` sein. Im letzteren Fall werden nur die Tensoren zu new umbenannt, die den Namen name sowie m kovariante und n kontravariante Indizes haben.

  Beispiel:

  In diesem Beispiel wird der Name c zu w geändert.

      (%i1) load("itensor")$

      (%i2) expr:a([i,j],[k])*b([u],[],v)+c([x,y],[])*d([],[])*e$

      (%i3) ishow(changename(c, w, expr))$
                                        k
      (%t3)                 d e w    + a    b
                                 x y    i j  u,v

Funktion: components (tensor, expr) ¶

  Erlaubt die Zuweisung von Werten an die Komponenten eines Tensors tensor, die mit dem Argument expr angegeben werden. Immer wenn der Tensor tensor mit all seinen Indizes in einem Ausdruck auftritt, werden die Komponenten mit den angegebenen Werten substituiert. Der Tensor muss die Form `t([...],[...])` haben, wobei die Listen auch leer sein können. Das Argument expr ist irgendein Ausdruck, der dieselben freien Indizes wie der Tensor tensor hat. Sollen Werte an einen Metriktensor zugewiesen werden, der Dummy-Indizes hat, so muss auf die Benennung der Indizes sorgfältig geachtet werden, um das Auftreten von Mehrfachen Dummy-Indizes zu vermeiden. Mit der Funktion `remcomps` werden Zuweisungen der Funktion `components` an die Komponenten eines Tensors entfernt.

  Es muss beachtet werden, dass die Funktion `components` nur den Typ eines Tensors, aber nicht die Ordnung der Indizes beachtet. Werden daher Werte an die Komponenten der Tensoren `x([i,-j],[])`, `x([-j,i],[])` oder `x([i],[j])` zugewiesen, ergibt sich jeweils dasselbe Ergebnis.

  Komponenten können einem indizierten Ausdruck auf vier verschiedene Methoden zugeordnet werden. Zwei Methoden nutzen die Funktion `components`.

  1) Als ein indizierte Ausdruck:

      (%i2) components(g([],[i,j]), e([],[i])*p([],[j]))$
      (%i3) ishow(g([],[i,j]))$
                                            i  j
      (%t3)                                e  p

  2) Als eine Matrix:

      (%i5) lg:-ident(4)$ lg[1,1]:1$ lg;
                                  [ 1   0    0    0  ]
                                  [                  ]
                                  [ 0  - 1   0    0  ]
      (%o5)                       [                  ]
                                  [ 0   0   - 1   0  ]
                                  [                  ]
                                  [ 0   0    0   - 1 ]

      (%i6) components(g([i,j],[]), lg);
      (%o6)                                done
      (%i7) ishow(g([i,j],[]))$
      (%t7)                                g
                                            i j
      (%i8) g([1,1],[]);
      (%o8)                                  1
      (%i9) g([4,4],[]);
      (%o9)                                 - 1

  3) Als eine Funktion: Die Werte der Komponenten eines Tensors werden durch eine Funktion gegeben.

      (%i4) h(l1,l2,[l3]):=if length(l1)=length(l2) and length(l3)=0
        then kdelta(l1,l2) else apply(g,append([l1,l2], l3))$
      (%i5) ishow(h([i],[j]))$
                                                j
      (%t5)                               kdelta
                                                i
      (%i6) ishow(h([i,j],[k],l))$
                                           k
      (%t6)                               g
                                           i j,l

  4) Mit Mustern und Regeln: Im Folgenden wird ein Beispiel mit den Funktionen `defrule` und `applyb1` gezeigt.

      (%i1) load("itensor");
      (%o1)      /share/tensor/itensor.lisp
      (%i2) matchdeclare(l1,listp);
      (%o2)                                done
      (%i3) defrule(r1,m(l1,[]),(i1:idummy(),
            g([l1[1],l1[2]],[])*q([i1],[])*e([],[i1])))$

      (%i4) defrule(r2,m([],l1),(i1:idummy(),
            w([],[l1[1],l1[2]])*e([i1],[])*q([],[i1])))$

      (%i5) ishow(m([i,n],[])*m([],[i,m]))$
                                          i m
      (%t5)                              m    m
                                               i n
      (%i6) ishow(rename(applyb1(%,r1,r2)))$
                                 %1  %2  %3 m
      (%t6)                     e   q   w     q   e   g
                                               %1  %2  %3 n

Funktion: concan (expr) ¶

  Ist vergleichbar mit der Funktion `canten`. Im Unterschied zu `canten` werden zusätzlich Tensorverjüngungen ausgeführt.

Funktion: contract (expr) ¶

  Führt die Tensorverjüngungen im Ausdruck expr aus, die beliebige Summen und Produkte sein können. `contract` nutzt die Informationen, die für die Tensoren mit der Funktion `defcon` definiert sind. Die besten Ergebnisse werden erzielt, wenn der Ausdruck expr vollständig expandiert wird. Die Funktion `radexpand` expandiert Produkte und Potenzen von Summen am schnellsten, sofern keine Variablen im Nenner der Terme auftreten. Die Optionsvariable `gcd` sollte den Wert `false` haben, wenn das Kürzen durch einen größten gemeinsamen Teiler nicht notwendig ist.

Systemvariable: contractions ¶

  Die Liste `contractions` enthält die Tensoren, die mit der Funktion `defcon` die Eigenschaft einer Tensorverjüngung erhalten haben.

Funktion: defcon (tensor_1) ¶
Funktion: defcon (tensor_1, tensor_2, tensor_3) ¶

  Gibt einem Tensor tensor_1 die Eigenschaft, dass die Tensorverjüngung des Produktes tensor_1 mit tensor_2 das Ergebnis tensor_3 hat. Wird nur ein Argument tensor_1 angegeben, dann hat die Tensorverjüngung für jeden Tensor `tensor`, der die korrekten Indizes hat, das Ergebnis `tensor` mit neuen Indizes, die die Tensorverjüngung widerspiegeln.

  Wird zum Beispiel die Metrik als `imetric: g` gesetzt, dann wird mit `defcon(g)` das Hochstellen und Herunterstellen der Indizes mit dem Metriktensor definiert.

  Wird `defcon` wiederholt für einen Tensor aufgerufen, ist jeweils die letzte Definition wirksam.

  Die Liste `contractions` enthält die Tensoren, die mit der Funktion `defcon` die Eigenschaft einer Tensorverjüngung erhalten haben.

Funktion: dispcon (tensor_1, tensor_2, …) ¶
Funktion: dispcon (all) ¶

  Zeigt die Kontraktionseigenschaften der Tensoren tensor_1, tensor_2, … wie sie mit der Funktion `defcon` definiert wurden. Das Kommando `dispcon(all)` zeigt alle vom Nutzer definierten Kontraktionseigenschaften.

  Beispiel:

  Wird das Paket `itensor` geladen, gibt `dispcon` das folgende Ergebnis.

      (%i1) load("itensor")$

      (%i2) dispcon(all);
      (%o2)      [[[ifr, ifri, ifg]], [[ifg, ifg, kdelta]]]

Funktion: entertensor (name) ¶

  Die Funktion `entertensor` ermöglicht die Eingabe eines indizierten Tensors mit einer beliebigen Anzahl an Tensorindizes und Ableitungen. Es kann ein einzelner Index oder eine Liste mit Indizes angegeben werden. Die Liste kann eine leere Liste sein.

  Beispiel:

      (%i1) load("itensor")$

      (%i2) entertensor()$
      Enter tensor name: a;
      Enter a list of the covariant indices: [i,j];
      Enter a list of the contravariant indices: [k];
      Enter a list of the derivative indices: [];
                                     k
      (%t2)                         a
                                     i j

Optionsvariable: flipflag ¶

  Standardwert: `false`

  Hat die Optionsvariable `flipflag` den Wert `false`, werden die Indizes von der Funktion `rename` bei der Umbenennung in der Reihenfolge der kontravarianten Indizes sortiert, ansonsten in der Reihenfolge der kovarianten Indizes.

  Siehe auch das Beispiel für die Funktion `rename`.

Optionsvariable: icounter ¶

  Standardwert: `0`

  Enthält die laufende Nummer, um den nächsten Dummy-Index zu bilden. `icounter` wird automatisch erhöht, bevor der neue Index gebildet wird. Dem Wert `icounter` wird er Präfix `idummyx` vorangestellt. Der Standardwert von `idummyx` ist `%`.

Funktion: idummy () ¶

  Erhöht den Wert der laufenden Nummer `icounter` und gibt einen neuen Index zurück, indem der Präfix `idummyx` der Nummer `icounter` vorangestellt wird. Siehe auch die Funktion `indices`.

Optionsvariable: idummyx ¶

  Standardwert: `%`

  Enthält den Präfix, der einem neuen Index vorangestellt wird, der mit der Funktion `idummy` gebildet wird.

Funktion: indexed_tensor (tensor) ¶

  Muss ausgeführt werden, bevor einem Tensors tensor Komponenten zugewiesen werden, für die bereits interne Werte vorliegen wie für `ichr1`, `ichr2` oder `icurvature`. Siehe das Beispiel zur Funktion `icurvature`.

Funktion: indices (expr) ¶

  Gibt eine Liste mit zwei Elementen zurück. Das erste Element ist eine Liste mit den Indizes im Ausdruck expr die frei sind, also nur einmal auftreten. Das zweite Elemente ist eine Liste mit den Indizes, über die summiert wird, die also im Ausdruck genau zweimal auftreten.

  Ein Tensorprodukt mit einem Index der mehr als zweimal auftritt, ist nicht korrekt formuliert. Die Funktion `indices` gibt in einem solchen Fall jedoch keinen Fehler aus.

  Beispiel:

      (%i1) load("itensor")$

      (%i2) ishow(a([i,j],[k,l],m,n)*b([k,o],[j,m,p],q,r))$
                               k l      j m p
      (%t2)                   a        b
                               i j,m n  k o,q r
      (%i3) indices(%);
      (%o3)          [[l, p, i, n, o, q, r], [k, j, m]]

Funktion: ishow (expr) ¶

  Zeigt den Ausdruck expr an, wobei Tensoren im Ausdruck mit tiefgestellten kovarianten Indizes und hochgestellten kontravarianten Indizes sowie die Ableitungen mit durch ein Komma getrennten tiefgestellte Indizes angezeigt werden.

  Beispiel:

      (%i1) load("itensor")$

      (%i2) ishow(a([i,j], [k], v,w))$
                                   k
      (%t2)                       a
                                   i j,v w

Funktion: kdels (L1, L2) ¶

  `kdels` gibt wie die Funktion `kdelta` ein Kronecker-Delta zurück. Im Unterschied zu `kdelta` ist das Kronecker-Delta der Funktion `kdels` symmetrisch.

  Beispiele:

      (%i1) load("itensor");
      (%o1)      /share/tensor/itensor.lisp
      (%i2) kdelta([1,2],[2,1]);
      (%o2)                                 - 1
      (%i3) kdels([1,2],[2,1]);
      (%o3)                                  1
      (%i4) ishow(kdelta([a,b],[c,d]))$
                                   c       d         d       c
      (%t4)                  kdelta  kdelta  - kdelta  kdelta
                                   a       b         a       b
      (%i4) ishow(kdels([a,b],[c,d]))$
                                   c       d         d       c
      (%t4)                  kdelta  kdelta  + kdelta  kdelta
                                   a       b         a       b

Funktion: kdelta (L1, L2) ¶

  Ist das verallgemeinerte Kronecker-Delta im `itensor`-Paket. Das Argument L1 ist die Liste der kovarianten und L2 der kontravarianten Indizes. `kdelta([i],[j])` gibt das einfache Kronecker-Delta zurück.

  Das `itensor`-Paket erlaubt die Definition des Kronecker-Delta nur mit kovarianten oder kontravarianten Indizes, wie zum Beispiel `kdelta([i,j],[])`. Mit diesen Größen kann gerechnet werden, sie sind jedoch keine Tensoren.

Regel: lc_l ¶

  `lc_l` ist eine Regel, um Ausdrücke zu vereinfachen, die Levi-Civita-Symbole enthalten. Zusammen mit der Regel `lc_u` kann die Regel zum Beispiel mit der Funktion `applyb1` angewendet werden, um Ausdrücke effizienter zu vereinfachen, als durch eine Auswertung des Symbols `levi_civita`.

  Beispiele:

      (%i1) load("itensor");
      (%o1)      /share/tensor/itensor.lisp
      (%i2) el1:ishow('levi_civita([i,j,k],[])*a([],[i])*a([],[j]))$
                                   i  j
      (%t2)                       a  a  levi_civita
                                                   i j k
      (%i3) el2:ishow('levi_civita([],[i,j,k])*a([i])*a([j]))$
                                             i j k
      (%t3)                       levi_civita      a  a
                                                    i  j
      (%i4) canform(contract(expand(applyb1(el1,lc_l,lc_u))));
      (%t4)                                  0
      (%i5) canform(contract(expand(applyb1(el2,lc_l,lc_u))));
      (%t5)                                  0

Regel: lc_u ¶

  `lc_u` ist eine Regel, um Ausdrücke zu vereinfachen, die Levi-Civita-Symbole enthalten. Zusammen mit der Regel `lc_c` kann die Regel zum Beispiel mit der Funktion `applyb1` angewendet werden, um Ausdrücke effizienter zu vereinfachen, als durch eine Auswertung des Symbols `levi_civita`. Siehe `lc_l` für Beispiele.

Funktion: lc2kdt (expr) ¶

  Vereinfacht den Ausdruck expr mit Levi-Civita-Symbolen. Wenn möglich werden diese zu Kronecker-Delta-Symbolen vereinfacht. Im Unterschied zu der Auswertung eines Ausdrucks mit Levi-Civita-Symbolen, vermeidet die Funktion `lc2kdt` das Einführen von numerischen Indizes, die für eine weitere symbolische Vereinfachung zum Beispiel mit den Funktionen `rename` oder `contract` nicht geeignet sind.

  Beispiel:

      (%i1) load("itensor");
      (%o1)      /share/tensor/itensor.lisp
      (%i2) expr:ishow('levi_civita([],[i,j])
                       *'levi_civita([k,l],[])*a([j],[k]))$
                                        i j  k
      (%t2)                  levi_civita    a  levi_civita
                                             j            k l
      (%i3) ishow(ev(expr,levi_civita))$
                                        i j  k       1 2
      (%t3)                       kdelta    a  kdelta
                                        1 2  j       k l
      (%i4) ishow(ev(%,kdelta))$
                   i       j         j       i   k
      (%t4) (kdelta  kdelta  - kdelta  kdelta ) a
                   1       2         1       2   j

                                     1       2         2       1
                              (kdelta  kdelta  - kdelta  kdelta )
                                     k       l         k       l
      (%i5) ishow(lc2kdt(expr))$
                           k       i       j    k       j       i
      (%t5)               a  kdelta  kdelta  - a  kdelta  kdelta
                           j       k       l    j       k       l
      (%i6) ishow(contract(expand(%)))$
                                       i           i
      (%t6)                           a  - a kdelta
                                       l           l

  Die Funktion `lc2kdt` benötigt in einigen Fällen den Metriktensor. Ist der Metriktensor zuvor nicht mit der Funktion `imetric` definiert, dann meldet Maxima einen Fehler.

      (%i7) expr:ishow('levi_civita([],[i,j])
                       *'levi_civita([],[k,l])*a([j,k],[]))$
                                       i j            k l
      (%t7)                 levi_civita    levi_civita    a
                                                           j k
      (%i8) ishow(lc2kdt(expr))$
      Maxima encountered a Lisp error:

       Error in $IMETRIC [or a callee]:
       $IMETRIC [or a callee] requires less than two arguments.

      Automatically continuing.
      To reenable the Lisp debugger set *debugger-hook* to nil.
      (%i9) imetric(g);
      (%o9)                                done
      (%i10) ishow(lc2kdt(expr))$

               %3 i       k   %4 j       l     %3 i       l   %4 j
      (%t10) (g     kdelta   g     kdelta   - g     kdelta   g
                          %3             %4               %3
                    k
              kdelta  ) a
                    %4   j k

      (%i11) ishow(contract(expand(%)))$
                                        l i    l i  j
      (%t11)                           a    - g    a
                                                    j

Funktion: levi_civita (L) ¶

  Ist der Levi-Civita-Tensor, der auch Permutationstensor genannt wird. Der Tensor hat den Wert `1`, wenn die Liste L eine gerade Permutation ganzer Zahlen ist, den Wert `-1` für eine ungerade Permutation und ansonsten den Wert `0`.

  Beispiel:

  Für eine Kreisbewegung ist die Bahngeschwindigkeit `v` das Kreuzprodukt aus Winkelgeschwindigkeit `w` und Ortsvektor `r`. Wir haben also `v = w x r`. Hier wird eine tensorielle Schreibweise des Kreuzproduktes mit dem Levi-Civita-Tensor eingeführt. Der Ausdruck wird sodann für die erste Komponente zu der bekannten Definition des Kreuzproduktes vereinfacht.

      (%i1) load("itensor")$

      (%i2) ishow(v([],[a])=
                 'levi_civita([],[a,b,c])*w([b],[])*r([c],[]))$

                          a              a b c
      (%t2)              v  = levi_civita      w  r
                                                b  c

      (%i3) ishow(subst([a=1],%))$
                          1              1 b c
      (%t3)              v  = levi_civita      w  r
                                                b  c
      (%i4) ishow(ev(%, levi_civita))$
                            1         1 b c
      (%t4)                v  = kdelta      w  r
                                      1 2 3  b  c
      (%i5) ishow(expand(ev(%, kdelta)))$
              1         b       c               c       b
      (%t5)  v  = kdelta  kdelta  w  r  - kdelta  kdelta  w  r
                        2       3  b  c         2       3  b  c
      (%i6) ishow(contract(%))$
                              1
      (%t6)                  v  = w  r  - r  w
                                   2  3    2  3

  In diesem Beispiel wird das Spatprodukt von drei Vektoren `a`, `b` und `b` mit dem Levi-Civita-Tensor definiert und dann vereinfacht.

      (%i1) load("itensor")$

      (%i2) ishow(levi_civita([],[i,j,k])*a([i],[])*b([j],[])*c([k],[]))$
                                  i j k
      (%t2)                 kdelta      a  b  c
                                  1 2 3  i  j  k
      (%i3) ishow(contract(expand(ev(%,kdelta))))$
      (%t3) a  b  c  - b  a  c  - a  c  b  + c  a  b  + b  c  a
             1  2  3    1  2  3    1  2  3    1  2  3    1  2  3
                                                             - c  b  a
                                                                1  2  3

Funktion: listoftens (expr) ¶

  Gibt eine Liste mit allen Tensoren zurück, die im Argument expr enthalten sind.

  Beispiel:

      (%i1) load("itensor")$

      (%i2) ishow(a([i,j],[k])*b([u],[],v)+c([x,y],[])*d([],[])*e)$
                                        k
      (%t2)                 d e c    + a    b
                                 x y    i j  u,v
      (%i3) ishow(listoftens(%))$
                              k
      (%t3)                 [a   , b   , c   , d]
                              i j   u,v   x y

Funktion: remcomps (tensor) ¶

  Entfernt alle Werte von den Komponenten des Tensors tensor, die einen Wert mit der Funktion `components` erhalten haben.

Funktion: remcon (tensor_1, …, tensor_n) ¶
Funktion: remcon (all) ¶

  Entfernt die Eigenschaften der Tensorverjüngung von den Tensoren tensor_1, …, tensor_n. `remcon(all)` entfernt die Eigenschaften von der Tensorverjüngung für alle Tensoren. Das sind die Tensoren, die in der Liste `contractions` enthalten sind.

Funktion: rename (expr) ¶
Funktion: rename (expr, count) ¶

  Gibt einen zum Argument expr äquivalenten Ausdruck zurück, wobei die Summationsindizes mit den Werten aus der liste `[%1, %2, ...]` umbenannt sind. Wird das zusätzlich das Argument count angegeben, wird die Nummerierung mit dem Wert count begonnen. Jeder Summationsindex in einem Produkt erhält einen verschiedenen Namen. Für eine Summe wird der Zähler für jeden Term zurückgesetzt. Auf diese Weise wirkt die Funktion `rename` wie eine Vereinfachung eines tensoriellen Ausdrucks. Hat die Optionsvariable `allsym` den Wert `true`, werden die Indizes alphabetisch nach den kovarianten oder kontravarianten Indizes geordnet, entsprechend dem Wert der Optionsvariablen `flipflag`. Hat die Optionsvariable `flipflag` den Wert `true`, werden die Indizes entsprechend der Ordnung der kovarianten Indizes geordnet. Es ist häufig der Fall, dass das Ordnen sowohl nach den kovarianten als auch den kontravarianten Indizes einen Ausdruck besser vereinfacht, als allein die Ordnung nach einer der Indizes.

  Beispiele:

      (%i1) load("itensor")$

      (%i2) allsym: true;
      (%o2)                         true
      (%i3) g([],[%4,%5])*g([],[%6,%7])*ichr2([%1,%4],[%3])
                   *ichr2([%2,%3],[u])*ichr2([%5,%6],[%1])
                   *ichr2([%7,r],[%2])
       -g([],[%4,%5])*g([],[%6,%7])*ichr2([%1,%2],[u])
                     *ichr2([%3,%5],[%1])*ichr2([%4,%6],[%3])
                     *ichr2([%7,r],[%2])$

      (%i4) expr: ishow(%)$

             %4 %5  %6 %7      %3         u          %1         %2
      (%t4) g      g      ichr2      ichr2      ichr2      ichr2
                               %1 %4      %2 %3      %5 %6      %7 r
                %4 %5  %6 %7      u          %1         %3         %2
             - g      g      ichr2      ichr2      ichr2      ichr2
                                  %1 %2      %3 %5      %4 %6      %7 r

      (%i5) flipflag: true;
      (%o5)                         true
      (%i6) ishow(rename(expr))$
             %2 %5  %6 %7      %4         u          %1         %3
      (%t6) g      g      ichr2      ichr2      ichr2      ichr2
                               %1 %2      %3 %4      %5 %6      %7 r
                %4 %5  %6 %7      u          %1         %3         %2
             - g      g      ichr2      ichr2      ichr2      ichr2
                                  %1 %2      %3 %4      %5 %6      %7 r
      (%i7) flipflag: false;
      (%o7)                         false
      (%i8) rename(%th(2));
      (%o8)                           0
      (%i9) ishow(rename(expr))$
             %1 %2  %3 %4      %5         %6         %7        u
      (%t9) g      g      ichr2      ichr2      ichr2     ichr2
                               %1 %6      %2 %3      %4 r      %5 %7
                %1 %2  %3 %4      %6         %5         %7        u
             - g      g      ichr2      ichr2      ichr2     ichr2
                                  %1 %3      %2 %6      %4 r      %5 %7

Funktion: showcomps (tensor) ¶

  Zeigt die Zuweisungen mit der Funktion `components` an die Komponenten des Tensors tensor. Die Funktion `showcomps` kann auch die Komponenten eines Tensors mit einer höheren Stufe als 2 zeigen.

  Beispiel:

      (%i1) load("ctensor")$
      (%i2) load("itensor")$
      (%i3) lg:matrix([sqrt(r/(r-2*m)),0,0,0],[0,r,0,0],
                      [0,0,sin(theta)*r,0],[0,0,0,sqrt((r-2*m)/r)]);

                     [         r                                     ]
                     [ sqrt(-------)  0       0              0       ]
                     [      r - 2 m                                  ]
                     [                                               ]
                     [       0        r       0              0       ]
      (%o3)          [                                               ]
                     [       0        0  r sin(theta)        0       ]
                     [                                               ]
                     [                                      r - 2 m  ]
                     [       0        0       0        sqrt(-------) ]
                     [                                         r     ]

      (%i4) components(g([i,j],[]),lg);
      (%o4)                                done
      (%i5) showcomps(g([i,j],[]));

                        [         r                                     ]
                        [ sqrt(-------)  0       0              0       ]
                        [      r - 2 m                                  ]
                        [                                               ]
                        [       0        r       0              0       ]
      (%t5)      g    = [                                               ]
                  i j   [       0        0  r sin(theta)        0       ]
                        [                                               ]
                        [                                      r - 2 m  ]
                        [       0        0       0        sqrt(-------) ]
                        [                                         r     ]

      (%o5)                                false

Nächste: Tensorsymmetrien, Vorige: Funktionen und Variablen für ITENSOR, Nach oben: Funktionen und Variablen für ITENSOR [Inhalt][Index]