doc/info/de/Atensor.de.texi

   1 @c -----------------------------------------------------------------------------
   2 @c File        : Atensor.de.texi
   3 @c License     : GNU General Public License (GPL)
   4 @c Language    : German
   5 @c Original    : Atensor.texi revision 14.03.2011
   6 @c Translation : Dr. Dieter Kaiser
   7 @c Date        : 14.11.2010
   8 @c Revision    : 28.09.2011
   9 @c
  10 @c This file is part of Maxima -- GPL CAS based on DOE-MACSYMA
  11 @c -----------------------------------------------------------------------------
  12
  13 @c -----------------------------------------------------------------------------
  14 @page
  15 @node Paket atensor, , Paket ctensor, Tensoren
  16 @section Paket @sc{atensor}
  17 @c -----------------------------------------------------------------------------
  18
  19 @menu
  20 * Einf@"uhrung in atensor::
  21 * Funktionen und Variablen f@"ur atensor::
  22 @end menu
  23
  24 @c -----------------------------------------------------------------------------
  25 @node Einf@"uhrung in atensor, Funktionen und Variablen f@"ur atensor, Paket atensor, Paket atensor
  26 @subsection Einf@"uhrung in @sc{atensor}
  27 @c -----------------------------------------------------------------------------
  28
  29 @c @code{atensor} is an algebraic tensor manipulation package. To use
  30 @c @code{atensor}, type @code{load("atensor")}, followed by a call to the
  31 @c @code{init_atensor} function.
  32
  33 Das Paket @code{atensor} erlaubt das algebraische Rechnen mit Tensoren.  Mit
  34 dem Kommando @code{load("atensor")} wird das Paket geladen.  Um das Paket zu
  35 initialisieren, wird die Funktion @mref{init_atensor} ausgef@"uhrt.
  36
  37 @c The essence of @code{atensor} is a set of simplification rules for the
  38 @c noncommutative (dot) product operator ("@code{.}"). @code{atensor} recognizes
  39 @c several algebra types; the corresponding simplification rules are put
  40 @c into effect when the @code{init_atensor} function is called.
  41
  42 Im wesentlichen enth@"alt das Paket @code{atensor} Regeln f@"ur die
  43 Vereinfachung von Ausdr@"ucken mit dem @mxref{dot, dot-Operator} Operator
  44 @code{"."}.  @code{atensor} kennt verschiedene Algebren.  Mit der Funktion
  45 @code{init_atensor} werden die Regeln einer Algebra initialisiert.
  46
  47 @c The capabilities of @code{atensor} can be demonstrated by defining the
  48 @c algebra of quaternions as a Clifford-algebra Cl(0,2) with two basis
  49 @c vectors. The three quaternionic imaginary units are then the two
  50 @c basis vectors and their product, i.e.:
  51
  52 Um die M@"oglichkeiten des Paketes @code{atensor} zu zeigen, wird im Folgenden
  53 die Algebra der Quaternionen als eine Clifford-Algebra Cl(0,2) mit zwei
  54 Basisvektoren definiert.  Die drei imagin@"aren Einheiten @code{i}, @code{j}
  55 und @code{k} werden durch die zwei Vektoren @code{v[1]} und @code{v[2]} sowie
  56 das Produkt @code{v[1] . v[2]} dargestellt:
  57
  58 @example
  59     i = v     j = v     k = v  . v
  60          1         2         1    2
  61 @end example
  62
  63 @c Although the @code{atensor} package has a built-in definition for the
  64 @c quaternion algebra, it is not used in this example, in which we
  65 @c endeavour to build the quaternion multiplication table as a matrix:
  66
  67 Das Paket @code{atensor} hat eine vordefinierte Algebra der Quaternionen.  Hier
  68 wird die Algebra der Quaterinonen als Clifford-Algebra Cl(0,2) definiert und
  69 die Multiplikationstabelle der Basisvektoren konstruiert.
  70
  71 @example
  72 (%i1) load("atensor")$
  73
  74 (%i2) init_atensor(clifford,0,0,2);
  75 (%o2)                         done
  76 (%i3) atensimp(v[1].v[1]);
  77 (%o3)                          - 1
  78 (%i4) atensimp((v[1].v[2]).(v[1].v[2]));
  79 (%o4)                          - 1
  80 (%i5) q:zeromatrix(4,4);
  81                          [ 0  0  0  0 ]
  82                          [            ]
  83                          [ 0  0  0  0 ]
  84 (%o5)                    [            ]
  85                          [ 0  0  0  0 ]
  86                          [            ]
  87                          [ 0  0  0  0 ]
  88 (%i6) q[1,1]:1;
  89 (%o6)                           1
  90 (%i7) for i thru adim do q[1,i+1]:q[i+1,1]:v[i];
  91 (%o7)                         done
  92 (%i8) q[1,4]:q[4,1]:v[1].v[2];
  93 (%o8)                        v  . v
  94                               1    2
  95 (%i9) for i from 2 thru 4 do
  96           for j from 2 thru 4 do
  97               q[i,j]:atensimp(q[i,1].q[1,j]);
  98 (%o9)                         done
  99 (%i10) q;
 100             [    1        v         v      v  . v  ]
 101             [              1         2      1    2 ]
 102             [                                      ]
 103             [   v         - 1     v  . v    - v    ]
 104             [    1                 1    2      2   ]
 105 (%o10)      [                                      ]
 106             [   v      - v  . v     - 1      v     ]
 107             [    2        1    2              1    ]
 108             [                                      ]
 109             [ v  . v      v        - v       - 1   ]
 110             [  1    2      2          1            ]
 111 @end example
 112
 113 @c @code{atensor} recognizes as base vectors indexed symbols, where the symbol
 114 @c is that stored in @code{asymbol} and the index runs between 1 and
 115 @c @code{adim}.  For indexed symbols, and indexed symbols only, the bilinear
 116 @c forms @code{sf}, @code{af}, and @code{av} are evaluated. The evaluation
 117 @c substitutes the value of @code{aform[i,j]} in place of @code{fun(v[i],v[j])}
 118 @c where @code{v} represents the value of @code{asymbol} and @code{fun} is
 119 @c either @code{af} or @code{sf}; or, it substitutes @code{v[aform[i,j]]}
 120 @c in place of @code{av(v[i],v[j])}.
 121
 122 Indizierte Symbole mit dem Namen, der in der Optionsvariablen @mref{asymbol}@w{}
 123 abgelegt ist, werden von @code{atensor} als Basisvektoren erkannt.  Dabei
 124 l@"auft der Index von @code{1} bis @mrefdot{adim}  F@"ur indizierte Symbole
 125 werden die Bilinearformen @mrefcomma{sf} @mref{af} und @mref{av} ausgewertet.
 126 Die Auswertung ersetzt die Bilinearform @code{fun(v[i].v[j])}, durch das
 127 Matrixelement @code{aform[i,j]}, wobei @code{v} einen Basisvektor bezeichnet
 128 und @code{fun} einer der Bilinearformen @code{sf} oder @code{af} ist.  Ist
 129 @code{fun} die Bilinearform @code{av}, dann wird @code{v[aform[i,j]]} f@"ur
 130 @code{av(v[i],v[j])} substituiert.  Siehe auch die Optionsvariable
 131 @mrefdot{aform}
 132
 133 @c Needless to say, the functions @code{sf}, @code{af} and @code{av}
 134 @c can be redefined.
 135
 136 Die Bilinearformen @code{sf}, @code{af} und @code{av} k@"onnen vom Nutzer
 137 neu definiert werden, um eine gew@"unschte Algebra zu definieren.
 138
 139 @c When the @code{atensor} package is loaded, the following flags are set:
 140
 141 Wird das Paket @code{atensor} geladen, werden die folgenden Schalter auf die
 142 angegebenen Werte gesetzt:
 143
 144 @example
 145 dotscrules  : true
 146 dotdistrib  : true
 147 dotexptsimp : false
 148 @end example
 149
 150 @c If you wish to experiment with a nonassociative algebra, you may also
 151 @c consider setting @code{dotassoc} to @code{false}. In this case, however,
 152 @c @code{atensimp} will not always be able to obtain the desired
 153 @c simplifications.
 154
 155 Wird das symbolische Rechnen in einer nicht-assoziativen Algebra gew@"unscht,
 156 kann auch noch der Schalter @mref{dotassoc} auf den Wert @code{false} gesetzt
 157 werden.  In diesem Fall kann jedoch die Funktion @mref{atensimp} nicht immer
 158 eine gew@"unschte Vereinfachung erzielen.
 159
 160 @c -----------------------------------------------------------------------------
 161 @node Funktionen und Variablen f@"ur atensor, , Einf@"uhrung in atensor, Paket atensor
 162 @subsection Funktionen und Variablen f@"ur @sc{atensor}
 163 @c -----------------------------------------------------------------------------
 164
 165 @c --- 28.09.2011 DK -----------------------------------------------------------
 166 @anchor{init_atensor}
 167 @deffn  {Funktion} init_atensor (@var{alg_type}, @var{opt_dims})
 168 @deffnx {Funktion} init_atensor (@var{alg_type})
 169
 170 @c Initializes the @code{atensor} package with the specified algebra type.
 171 @c @var{alg_type} can be one of the following:
 172
 173 Initialisiert das Paket @code{atensor} mit der angegebenen Algebra
 174 @var{alg_type}.  Das Argument @var{alg_type} kann einen der folgenden
 175 Werte haben:
 176
 177 @table @code
 178 @item universal
 179 @c The universal algebra has no commutation rules.
 180 Eine allgemeine Algebra, f@"ur die keine Vertauschungsregeln definiert sind.
 181
 182 @item grassmann
 183 @c The Grassman algebra is defined by the commutation
 184 @c relation @code{u.v+v.u=0}.
 185 Eine Gra@ss{}mann-Algebra, f@"ur die die Vertauschungsregel @code{u.v + v.u = 0}
 186 definiert ist.
 187
 188 @item clifford
 189 @c The Clifford algebra is defined by the commutation
 190 @c relation @code{u.v+v.u=-2*sf(u,v)} where @code{sf} is a symmetric
 191 @c scalar-valued function. For this algebra, @var{opt_dims} can be up
 192 @c to three nonnegative integers, representing the number of positive,
 193 @c degenerate, and negative dimensions of the algebra, respectively. If
 194 @c any @var{opt_dims} values are supplied, @code{atensor} will configure the
 195 @c values of @code{adim} and @code{aform} appropriately. Otherwise,
 196 @c @code{adim} will default to 0 and @code{aform} will not be defined.
 197 Eine Clifford-Algebra, die durch die Vertauschungsregel @code{u.v + v.u =
 198 -2*sf(u,v)} definiert ist.  Die Bilinearform @mref{sf} ist eine symmetrische
 199 Funktion, die einen skalaren Wert als Ergebnis hat.  Das Argument @var{opt_dims}
 200 kann bis zu drei positive ganze Zahlen sein, die die positiven,
 201 entarteten und negativen Dimensionen der Algebra bezeichnen.  Die Dimension
 202 @mref{adim} und die Matrix @mref{aform} werden entsprechend der angegebenen
 203 Argumente @var{opt_dims} initialisiert.  Sind keine Argumente @var{opt_dims}
 204 vorhanden, wird die Dimension @code{adim} zu Null initialisiert und keine
 205 Matrix @code{aform} definiert.
 206
 207 @item symmetric
 208 @c The symmetric algebra is defined by the commutation
 209 @c relation @code{u.v-v.u=0}.
 210 Eine symmetrische Algebra, die durch die Vertauschungsregel @code{u.v - v.u = 0}
 211 definiert ist.
 212
 213 @item symplectic
 214 @c The symplectic algebra is defined by the commutation
 215 @c relation @code{u.v-v.u=2*af(u,v)} where @code{af} is an antisymmetric
 216 @c scalar-valued function. For the symplectic algebra, @var{opt_dims} can
 217 @c be up to two nonnegative integers, representing the nondegenerate and
 218 @c degenerate dimensions, respectively. If any @var{opt_dims} values are
 219 @c supplied, @code{atensor} will configure the values of @code{adim} and
 220 @c @code{aform} appropriately. Otherwise, @code{adim} will default to 0 and
 221 @c @code{aform} will not be defined.
 222 Eine symplektische Algebra, die durch die Vertauschungsregel
 223 @code{u.v - v.u = 2*af(u,v)} definiert ist.  Die Bilinearform @mref{af} ist
 224 eine antisymmetrische Funktion, die einen skalaren Wert als Ergebnis hat.  Das
 225 Argument @var{opt_dims} kann bis zu zwei positive ganze Zahlen enthalten,
 226 die die nicht-degenerierten und degenerierten Dimensionen der Algebra
 227 bezeichnen.  Die Dimension @mref{adim} und die Matrix @mref{aform}@w{}
 228 werden entsprechend der angegebenen Argumente @var{opt_dims} initialisiert.
 229 Sind keine Argumente @var{opt_dims} vorhanden, wird die Dimension @code{adim}
 230 zu Null initialisiert und keine Matrix @code{aform} definiert.
 231
 232 @item lie_envelop
 233 @c The algebra of the Lie envelope is defined by the
 234 @c commutation relation @code{u.v-v.u=2*av(u,v)} where @code{av} is
 235 @c an antisymmetric function.
 236 Eine einh@"ullende Lie-Algebra, die durch die Vertauschungsregel
 237 @code{u.v - v.u = 2*av(u,v)} definiert ist, wobei die Bilinearform @mref{av}@w{}
 238 eine antisymmetrische Funktion ist.  Das Argument @var{opt_dims} kann eine
 239 positive ganze Zahl sein, welche die Dimension der Lie-Algebra angibt.  Die
 240 Dimension @mref{adim} und die Matrix @mref{aform} werden entsprechend des
 241 Argumentes @var{opt_dims} initialisiert.  Ist kein Argument @var{opt_dims}
 242 vorhanden, wird die Dimension @code{adim} zu Null initialisiert und keine Matrix
 243 @code{aform} definiert.
 244 @end table
 245
 246 @c The @code{init_atensor} function also recognizes several predefined
 247 @c algebra types:
 248
 249 Die Funktion @code{init_atensor} kennt weiterhin einige vordefinierte
 250 Algebren:
 251
 252 @table @code
 253 @item complex
 254 @c implements the algebra of complex numbers as the
 255 @c Clifford algebra Cl(0,1). The call @code{init_atensor(complex)} is
 256 @c equivalent to @code{init_atensor(clifford, 0, 0, 1)}.
 257 Die Algebra der komplexen Zahlen, die als eine Clifford-Algebra Cl(0,1)
 258 definiert wird.  Das Kommando @code{init_atensor(complex)} ist @"aquivalent zum
 259 Kommando @code{init_atensor(clifford, 0, 0, 1)}.
 260
 261 @item quaternion
 262 @c implements the algebra of quaternions. The call
 263 @c @code{init_atensor (quaternion)} is equivalent to
 264 @c @code{init_atensor (clifford, 0, 0, 2)}.
 265 Die Algebra der Quaternionen, die als eine Clifford-Algebra vom Typ Cl(0,2)
 266 definiert wird.  Das Kommando @code{init_atensor(quaternion)}
 267 ist @"a@-qui@-va@-lent zum Kommando @code{init_atensor(clifford, 0, 0, 2)}.
 268
 269 @item pauli
 270 @c implements the algebra of Pauli-spinors as the Clifford-algebra
 271 @c Cl(3,0). A call to @code{init_atensor(pauli)} is equivalent to
 272 @c @code{init_atensor(clifford, 3)}.
 273 Die Algebra der Pauli-Matrizen, die als eine Clifford-Algebra Cl(3,0)
 274 definiert wird.  Das Kommando @code{init_atensor(pauli)} ist @"aquivalent
 275 zum Kommando @code{init_atensor(clifford, 3)}.
 276
 277 @item dirac
 278 @c implements the algebra of Dirac-spinors as the Clifford-algebra
 279 @c Cl(3,1). A call to @code{init_atensor(dirac)} is equivalent to
 280 @c @code{init_atensor(clifford, 3, 0, 1)}.
 281 Die Algebra der Dirac-Matrizen, die als eine Clifford-Algebra Cl(3,0,1)
 282 definiert wird.  Das Kommando @code{init_atensor(dirac)} ist @"aquivalent zum
 283 Kommando @code{init_atensor(clifford, 3, 0, 1)}.
 284 @end table
 285 @end deffn
 286
 287 @c --- 28.09.2011 DK -----------------------------------------------------------
 288 @anchor{atensimp}
 289 @deffn {Funktion} atensimp (@var{expr})
 290
 291 @c Simplifies an algebraic tensor expression @var{expr} according to the rules
 292 @c configured by a call to @code{init_atensor}. Simplification includes
 293 @c recursive application of commutation relations and resolving calls
 294 @c to @code{sf}, @code{af}, and @code{av} where applicable. A
 295 @c safeguard is used to ensure that the function always terminates, even
 296 @c for complex expressions.
 297
 298 Vereinfacht einen Ausdruck @var{expr} entsprechend der Regeln f@"ur die Algebra,
 299 die mit der Funktion @mref{init_atensor} festgelegt ist.  Die Regeln werden
 300 rekursiv auf den Ausdruck angewendet.  Dabei werden auch Bilinearformen
 301 @mrefcomma{sf} @mref{af} und @mref{av} ausgewertet.
 302
 303 Beispiele:
 304
 305 Die folgenden Beispiele zeigen das Rechnen mit der Algebra der Quaternionen.
 306
 307 @example
 308 (%i1) load("atensor")$
 309
 310 (%i2) init_atensor(quaternion);
 311 (%o2)                         done
 312 (%i3) atensimp(v[1].v[1]);
 313 (%o3)                          - 1
 314 (%i4) atensimp(v[2].v[2]);
 315 (%o4)                          - 1
 316 (%i5) atensimp((v[1].v[2]) . (v[1].v[2]));
 317 (%o5)                          - 1
 318 (%i6) expand((2*v[1]+3*v[2])^^2);
 319 (%o6) 9 (v  . v ) + 6 (v  . v ) + 6 (v  . v ) + 4 (v  . v )
 320           2    2        2    1        1    2        1    1
 321 (%i7) atensimp(%);
 322 (%o7)                         - 13
 323 @end example
 324 @end deffn
 325
 326 @c --- 28.09.2011 DK -----------------------------------------------------------
 327 @anchor{alg_type}
 328 @defvr {Optionsvariable} alg_type
 329 Standardwert: @code{universal}
 330
 331 @c The algebra type.  Valid values are @code{universal}, @code{grassmann},
 332 @c @code{clifford}, @code{symmetric}, @code{symplectic} and @code{lie_envelop}.
 333
 334 Der Typ der Algebra, die bei der Vereinfachung von Ausdr@"ucken mit der
 335 Funktion @mref{atensimp} angewendet wird.  Die Algebra wird von der Funktion
 336 @code{init_atensor} initialisiert.  M@"ogliche Algebren sind @code{universal},
 337 @code{grassmann}, @code{clifford}, @code{symmetric}, @code{symplectic} und
 338 @code{lie_envelop}.  Siehe f@"ur eine ausf@"uhrliche Erl@"auterung der Algebren
 339 die Funktion @mrefdot{init_atensor}
 340 @end defvr
 341
 342 @c --- 28.09.2011 DK -----------------------------------------------------------
 343 @anchor{adim}
 344 @defvr {Optionsvariable} adim
 345 Standardwert: @code{0}
 346
 347 @c The dimensionality of the algebra.  @code{atensor} uses the value of
 348 @c @code{adim} to determine if an indexed object is a valid base vector.  See
 349 @c @code{abasep}.
 350
 351 Die Dimension der Algebra, die bei der Vereinfachung von Ausdr@"ucken mit der
 352 Funktion @mref{atensimp} angewendet wird.  Die Dimension wird von der Funktion
 353 @mref{init_atensor} initialisiert.  Ein indiziertes Symbol mit dem Bezeichner
 354 @mref{asymbol} ist dann ein Basisvektor, wenn der Index kleiner oder gleich
 355 der Dimension @code{adim} ist.
 356
 357 Beispiel:
 358
 359 Die Dirac-Algebra hat die Dimension @code{4} und @code{v[4]} ist ein
 360 Basisvektor.
 361
 362 @example
 363 (%i1) load("atensor")$
 364
 365 (%i2) init_atensor(dirac);
 366 (%o2)                         done
 367 (%i3) adim;
 368 (%o3)                           4
 369 (%i4) abasep(v[4]);
 370 (%o4)                         true
 371 @end example
 372 @end defvr
 373
 374 @c --- 28.09.2011 DK -----------------------------------------------------------
 375 @anchor{aform}
 376 @defvr {Optionsvariable} aform
 377 Standardwert: @code{ident(3)}
 378
 379 @c Default values for the bilinear forms @code{sf}, @code{af}, and
 380 @c @code{av}.  The default is the identity matrix @code{ident(3)}.
 381
 382 Matrix mit den Werten der Bilinearformen @mrefcomma{sf} @mref{af} und
 383 @mrefdot{av}  Der Standardwert ist die dreidimensionale Einheitsmatrix.
 384
 385 Beispiel:
 386
 387 Das Beispiel zeigt die Matrix @code{aform} f@"ur eine Lie-Algebra mit drei
 388 Dimensionen und die Ergebnisse der Bilinearform @code{av} f@"ur diese Algebra.
 389
 390 @example
 391 (%i1) load("atensor")$
 392
 393 (%i2) init_atensor(lie_envelop, 3);
 394 (%o2)                         done
 395 (%i3) aform;
 396                         [  0    3   - 2 ]
 397                         [               ]
 398 (%o3)                   [ - 3   0    1  ]
 399                         [               ]
 400                         [  2   - 1   0  ]
 401 (%i4) av(v[1], v[2]);
 402 (%o4)                          v
 403                                 3
 404 (%i5) av(v[1], v[3]);
 405 (%o5)                         - v
 406                                  2
 407 @end example
 408 @end defvr
 409
 410 @c --- 28.09.2011 DK -----------------------------------------------------------
 411 @anchor{asymbol}
 412 @defvr {Optionsvariable} asymbol
 413 Standardwert: @code{v}
 414
 415 @c The symbol for base vectors.
 416
 417 Enth@"alt das Symbol, das einen Basisvektor des Paketes @code{atensor}
 418 bezeichnet.  Mit der Funktion @mref{abasep} kann getestet werde, ob ein
 419 indiziertes Symbol einen Basisvektor der Algebra bezeichnet.
 420
 421 Beispiel:
 422
 423 In diesem Beispiel wird @code{asymbol} auf den Wert @code{x} gesetzt.
 424
 425 @example
 426 (%i1) load("atensor")$
 427
 428 (%i2) init_atensor(symmetric, 2);
 429 (%o2)                         done
 430 (%i3) asymbol;
 431 (%o3)                           v
 432 (%i4) abasep(v[2]);
 433 (%o4)                         true
 434 (%i5) asymbol: x;
 435 (%o5)                           x
 436 (%i6) abasep(x[2]);
 437 (%o6)                         true
 438 @end example
 439 @end defvr
 440
 441 @c --- 28.09.2011 DK -----------------------------------------------------------
 442 @anchor{sf}
 443 @deffn {Funktion} sf (@var{u}, @var{v})
 444
 445 @c A symmetric scalar function that is used in commutation relations.
 446 @c The default implementation checks if both arguments are base vectors
 447 @c using @code{abasep} and if that is the case, substitutes the
 448 @c corresponding value from the matrix @code{aform}.
 449
 450 Eine symmetrische Bilinearform, die bei der Vereinfachung von Ausdr@"ucken
 451 mit der Funktion @mref{atensimp} angewendet wird.  Die Funktion kann vom Nutzer
 452 durch eine neue Funktion ersetzt werden.  Die Standardimplementation pr@"uft
 453 mit der Funktion @mrefcomma{abasep} ob die Argumente @var{u} und @var{v}
 454 Basisvektoren sind und setzt f@"ur diesen Fall den entsprechen Wert der Matrix
 455 @mref{aform} ein.
 456 @end deffn
 457
 458 @c -----------------------------------------------------------------------------
 459 @anchor{af}
 460 @deffn {Funktion} af (@var{u}, @var{v})
 461
 462 @c An antisymmetric scalar function that is used in commutation relations.
 463 @c The default implementation checks if both arguments are base vectors
 464 @c using @code{abasep} and if that is the case, substitutes the
 465 @c corresponding value from the matrix @code{aform}.
 466
 467 Eine antisymmetrische Bilinearform, die bei der Vereinfachung von Ausdr@"ucken
 468 mit der Funktion @mref{atensimp} angewendet wird.  Die Funktion kann vom Nutzer
 469 durch eine neue Funktion ersetzt werden.  Die Standardimplementation pr@"uft
 470 mit der Funktion @mrefcomma{abasep} ob die Argumente @var{u} und @var{v}
 471 Basisvektoren sind und setzt f@"ur diesen Fall den entsprechenden Wert der
 472 Matrix @mref{aform} ein.
 473 @end deffn
 474
 475 @c --- 28.09.2011 DK -----------------------------------------------------------
 476 @anchor{av}
 477 @deffn {Funktion} av (@var{u}, @var{v})
 478
 479 @c An antisymmetric function that is used in commutation relations.
 480 @c The default implementation checks if both arguments are base vectors
 481 @c using @code{abasep} and if that is the case, substitutes the
 482 @c corresponding value from the matrix @code{aform}.
 483
 484 Eine antisymmetrische Bilinearform, die bei der Vereinfachung von Ausdr@"ucken
 485 mit der Funktion @mref{atensimp} angewendet wird.  Die Funktion kann vom Nutzer
 486 durch eine neue Funktion ersetzt werden.  Die Standardimplementation pr@"uft
 487 mit der Funktion @mrefcomma{abasep} ob die Argumente @var{u} und @var{v}
 488 Basisvektoren sind und setzt f@"ur diesen Fall den entsprechenden Wert
 489 @code{v[aform[i,j]]} der Matrix @mref{aform} ein.
 490
 491 Beispiel:
 492
 493 @example
 494 (%i1) load("atensor")$
 495 (%i2) adim: 3;
 496 (%o2)                           3
 497 (%i3) aform:matrix([0,3,-2],[-3,0,1],[2,-1,0]);
 498                         [  0    3   - 2 ]
 499                         [               ]
 500 (%o3)                   [ - 3   0    1  ]
 501                         [               ]
 502                         [  2   - 1   0  ]
 503 (%i4) asymbol: x;
 504 (%o4)                           x
 505 (%i5) av(x[1], x[2]);
 506 (%o5)                          x
 507                                 3
 508 (%i6) av(x[1], x[3]);
 509 (%o6)                         - x
 510                                  2
 511 @end example
 512 @end deffn
 513
 514 @c --- 28.09.2011 DK -----------------------------------------------------------
 515 @anchor{abasep}
 516 @deffn {Funktion} abasep (@var{v})
 517
 518 @c Checks if its argument is an @code{atensor} base vector. That is, if it is
 519 @c an indexed symbol, with the symbol being the same as the value of
 520 @c @code{asymbol}, and the index having a numeric value between 1
 521 @c and @code{adim}.
 522
 523 Pr@"uft, ob das Argument @var{v} ein Basisvektor ist.  Ein Basisvektor ist ein
 524 indiziertes Symbol mit dem Symbol @mref{asymbol} als Bezeichner und einem
 525 Index im Bereich von @code{1} bis @mrefdot{adim}
 526
 527 Beispiel:
 528
 529 @example
 530 (%i1) load("atensor")$
 531 (%i2) asymbol: x$
 532 (%i3) adim:3$
 533 (%i4) abasep(x[1]);
 534 (%o4)                         true
 535 (%i5) abasep(x[3]);
 536 (%o5)                         true
 537 (%i6) abasep(x[4]);
 538 (%o6)                         false
 539 @end example
 540 @end deffn
 541
 542 @c --- End of file Atensor.de.texi ---------------------------------------------
 543