@c -----------------------------------------------------------------------------
@c File        : Defstruct.de.texi
@c License     : GNU General Public License (GPL)
@c Language    : German
@c Original    : defstruct.texi revision 12.06.2011
@c Translation : Dr. Dieter Kaiser
@c Date        : 20.04.2011
@c Revision    : 17.07.2011
@c 
@c This file is part of Maxima -- GPL CAS based on DOE-MACSYMA
@c -----------------------------------------------------------------------------

@c -----------------------------------------------------------------------------
@page
@node Strukturen, , Arrays, Datentypen und Strukturen
@section Strukturen
@c -----------------------------------------------------------------------------

@menu
* Einf@"uhrung in Strukturen::
* Funktionen und Variablen f@"ur Strukturen::
@end menu

@c -----------------------------------------------------------------------------
@node Einf@"uhrung in Strukturen, Funktionen und Variablen f@"ur Strukturen, Strukturen, Strukturen
@subsection Einf@"uhrung in Strukturen
@c -----------------------------------------------------------------------------

@c Maxima provides a simple data aggregate called a structure.
@c A structure is an expression in which arguments are identified by name (the
@c field name) and the expression as a whole is identified by its operator (the
@c structure name).  A field value can be any expression.

Maxima bietet eine einfache M@"oglichkeit, Daten in eine Struktur
zusammenzufassen.  Eine Struktur ist ein Ausdruck, in der die Argumente mit
ihren Feldnamen bezeichnet werden und die Struktur als Ganzes mit dem Namen des
Operators bezeichnet wird.  Der Wert eines Feldes kann ein beliebiger Ausdruck
sein.

@c A structure is defined by the @code{defstruct} function;
@c the global variable @code{structures} is the list of user-defined structures.
@c The function @code{new} creates instances of structures.
@c The @code{@@} operator refers to fields.
@c @code{kill(@var{S})} removes the structure definition @var{S},
@c and @code{kill(@var{x}@@ @var{a})} unbinds the field @var{a} of the structure
@c instance @var{x}.

Eine Struktur wird mit der Funktion @mref{defstruct} definiert.  Die
Informationsliste @mref{structures} enth@"alt die vom Nutzer definierten
Strukturen.  Die Funktion @mref{new} generiert eine neue Instanz einer
Struktur.  Mit dem Operator @mref{@@} wird auf die Felder einer Struktur
zugegriffen.  Mit dem Kommando @code{kill(@var{S})} wird die Definition der
Struktur @code{S} gel@"oscht.  Mit dem Kommando @code{kill(@var{x}@@@var{a})}
wird das Feld @var{a} der Instanz @var{x} einer Struktur gel@"oscht.

@c In the pretty-printing console display (with @code{display2d} equal to
@c @code{true}), structure instances are displayed with the value of each field
@c represented as an equation, with the field name on the left-hand side
@c and the value on the right-hand side.  (The equation is only a display
@c construct; only the value is actually stored.)
@c In 1-dimensional display (via @code{grind} or with @code{display2d} equal to
@c @code{false}), structure instances are displayed without the field names.

In der 2D-Anzeige werden die Felder von Instanzen einer Struktur als eine
Gleichung angezeigt.  Die linke Seite der Gleichung ist der Feldname und die
rechte Seite der Gleichung ist der Wert des Feldes.  Die Gleichungen werden
nur in der Anzeige gezeigt und werden nicht als Teil der Struktur gespeichert.
In der 1D-Anzeige und bei der Ausgabe mit der Funktion @mref{grind} werden
nur die Werte der Felder ausgegeben.

@c There is no way to use a field name as a function name,
@c although a field value can be a lambda expression.  Nor can the values of
@c fields be restricted to certain types; any field can be assigned any kind of
@c expression.  There is no way to make some fields accessible
@c or inaccessible in different contexts; all fields are always visible.

Ein Feldname kann nicht als der Name einer Funktion verwendet werden.  Jedoch
kann ein Feld einen Lambda-Ausdruck enthalten.  Auch k@"onnen die Felder nicht 
auf bestimmte Datentypen eingeschr@"ankt werden.  Einem Feld kann immer ein
beliebiger Ausdruck zugewiesen werden.  Weiterhin sind die Felder einer 
Struktur immer sichtbar.  Der Zugriff auf ein Feld kann nicht eingeschr@"ankt
werden.

@c -----------------------------------------------------------------------------
@node Funktionen und Variablen f@"ur Strukturen, , Einf@"uhrung in Strukturen, Strukturen
@subsection Funktionen und Variablen f@"ur Strukturen
@c -----------------------------------------------------------------------------

@c --- 17.07.2011 DK -----------------------------------------------------------
@anchor{structures}
@defvr {Systemvariable} structures

@c @code{structures} is the list of user-defined structures defined by
@c @code{defstruct}.

@code{structures} ist eine Informationsliste, die die vom Benutzer mit der
Funktion @mref{defstruct} definierten Strukturen enth@"alt.
@end defvr

@c --- 17.07.2011 DK -----------------------------------------------------------
@anchor{defstruct}
@deffn  {Funktion} defstruct (@var{S}(@var{a_1}, @dots{}, @var{a_n}))
@deffnx {Funktion} defstruct (@var{S}(@var{a_1} = @var{v_1}, @dots{}, @var{a_n} = @var{v_n}))

@c Define a structure, which is a list of named fields @var{a_1}, @dots{},
@c @var{a_n} associated with a symbol @var{S}.
@c An instance of a structure is just an expression which has operator @var{S}
@c and exactly @code{n} arguments.
@c @code{new(@var{S})} creates a new instance of structure @var{S}.

Definiert eine Struktur, als eine Liste mit den Feldnamen @var{a_1}, @dots{},
@var{a_n} und dem Namen @var{S} f@"ur die Struktur.  Eine Instanz einer
Struktur ist ein Ausdruck mit dem Operator @var{S} und @var{n} Argumenten,
die die Werte der Felder sind.  Mit dem Kommando @code{new(@var{S}} wird eine
neue Instanz einer Struktur @var{S} generiert.  Siehe auch @mrefdot{new}

@c An argument which is just a symbol @var{a} specifies the name of a field.
@c An argument which is an equation @code{@var{a} = @var{v}} specifies the field
@c name @var{a} and its default value @var{v}.
@c The default value can be any expression.

Mit einem Symbol @var{a} als Argument wird der Name eines Feldes bezeichnet.
Mit einer Gleichung @code{@var{a} = @var{v}} wird der Name des Feldes als
@var{a} bezeichnet und ein Standardwert @var{v} definiert.  Der Standardwert
@var{v} kann ein beliebiger Ausdruck sein.

@c @code{defstruct} puts @var{S} on the list of user-defined structures,
@c @code{structures}.

@code{defstruct} legt die Definition der Struktur @var{S} in der
Informationsliste @mref{structures} ab.

@c @code{kill(@var{S})} removes @var{S} from the list of user-defined
@c structures, and removes the structure definition.

Mit dem Kommando @code{kill(@var{S})} wird die Definition einer Struktur
gel@"oscht und von der Informationsliste @code{structures} entfernt.

Beispiele:

@example
(%i1) defstruct (foo (a, b, c));
(%o1)                    [foo(a, b, c)]
(%i2) structures;
(%o2)                    [foo(a, b, c)]
(%i3) new (foo);
(%o3)                     foo(a, b, c)
(%i4) defstruct (bar (v, w, x = 123, y = %pi));
(%o4)             [bar(v, w, x = 123, y = %pi)]
(%i5) structures;
(%o5)      [foo(a, b, c), bar(v, w, x = 123, y = %pi)]
(%i6) new (bar);
(%o6)              bar(v, w, x = 123, y = %pi)
(%i7) kill (foo);
(%o7)                         done
(%i8) structures;
(%o8)             [bar(v, w, x = 123, y = %pi)]
@end example
@end deffn

@c --- 17.07.2011 DK -----------------------------------------------------------
@anchor{new}
@deffn  {Funktion} new (@var{S})
@deffnx {Funktion} new (@var{S} (@var{v_1}, @dots{}, @var{v_n}))

@c @code{new} creates new instances of structures.

@code{new} erzeugt eine neue Instanz einer Struktur.

@c @code{new(@var{S})} creates a new instance of structure @var{S}
@c in which each field is assigned its default value, if any,
@c or no value at all if no default was specified in the structure definition.

Das Kommando @code{new(@var{S})} erzeugt eine neue Instanz der Struktur @var{S},
die mit der Funktion @mref{defstruct} definiert wurde.  Die Felder werden mit
den Standardwerten belegt, wenn die Definition der Struktur Standardwerte
enth@"alt.  Ansonsten erhalten die Felder keine Werte.

@c @code{new(@var{S}(@var{v_1}, ..., @var{v_n}))} creates a new instance of
@c @var{S} in which fields are assigned the values @var{v_1}, @dots{},
@c @var{v_n}.

Das Kommando @code{new(@var{S}(@var{v_1}, ..., @var{v_n}))} erzeugt eine neue
Instanz der Struktur @var{S}, wobei die Felder mit den Werten @var{v_1},
@dots{}, @var{v_n} initialisiert werden.

Beispiele:

@example
(%i1) defstruct (foo (w, x = %e, y = 42, z));
(%o1)              [foo(w, x = %e, y = 42, z)]
(%i2) new (foo);
(%o2)               foo(w, x = %e, y = 42, z)
(%i3) new (foo (1, 2, 4, 8));
(%o3)            foo(w = 1, x = 2, y = 4, z = 8)
@end example
@end deffn

@c --- 17.07.2011 DK -----------------------------------------------------------
@anchor{@@}
@deffn {Operator} @@

@c @code{@@} is the structure field access operator.
@c The expression @code{@var{x}@@ @var{a}} refers to the value of field @var{a}
@c of the structure instance @var{x}.  The field name is not evaluated.

@code{@@} ist der Operator f@"ur den Zugriff auf ein Feld einer Struktur.  Der
Ausdruck @code{@var{x}@@@var{a}} bezeichnet das Feld @var{a} der Instanz @var{x}
einer Struktur.  Der Feldname wird nicht ausgewertet.

@c If the field @var{a} in @var{x} has not been assigned a value,
@c @code{@var{x}@@ @var{a}} evaluates to itself.

Hat das Feld @var{a} der Instanz @var{x} keinen Wert, wird der Ausdruck
@code{@var{x}@@@var{a}} zu sich selbst ausgewertet.

@c @code{kill(@var{x}@@ @var{a})} removes the value of field @var{a} in @var{x}.

@code{kill(@var{x}@@@var{a})} l@"oscht den Wert des Feldes @var{a} der Instanz
@var{x} einer Struktur.

Beispiele:

@example
(%i1) defstruct (foo (x, y, z));
(%o1)                    [foo(x, y, z)]
(%i2) u : new (foo (123, a - b, %pi));
(%o2)           foo(x = 123, y = a - b, z = %pi)
(%i3) u@@z;
(%o3)                          %pi
(%i4) u@@z : %e;
(%o4)                          %e
(%i5) u;
(%o5)            foo(x = 123, y = a - b, z = %e)
(%i6) kill (u@@z);
(%o6)                         done
(%i7) u;
(%o7)              foo(x = 123, y = a - b, z)
(%i8) u@@z;
(%o8)                          u@@z
@end example

@c The field name is not evaluated.

Der Feldname wird nicht ausgewertet.

@example
(%i1) defstruct (bar (g, h));
(%o1)                      [bar(g, h)]
(%i2) x : new (bar);
(%o2)                       bar(g, h)
(%i3) x@@h : 42;
(%o3)                          42
(%i4) h : 123;
(%o4)                          123
(%i5) x@@h;
(%o5)                          42
(%i6) x@@h : 19;
(%o6)                          19
(%i7) x;
(%o7)                    bar(g, h = 19)
(%i8) h;
(%o8)                          123
@end example
@end deffn

@c --- End of file Defstruct.de.texi -------------------------------------------