doc/info/es/defstruct.texi

   1 @c English version 2011-06-12
   2 @page
   3 @node Estructuras, , Arrays, Tipos de datos y estructuras
   4 @section Estructuras
   5
   6
   7
   8 @menu
   9 * Introducción a las estructuras::
  10 * Funciones y variables para las estructuras::
  11 @end menu
  12
  13 @node Introducción a las estructuras, Funciones y variables para las estructuras, Estructuras, Estructuras
  14 @subsection Introducción a las estructuras
  15
  16 Maxima dispone de estructuras para la agregación de datos.
  17 Una estructura es una expresión en la que los argumentos se definen con
  18 un nombre (nombre del campo) y la estructura en su conjunto se define por
  19 medio de su operador (nombre de la estructura). Los valores dados a los
  20 campos pueden ser expresiones cualesquiera.
  21
  22 Una estructura se define con la función @code{defstruct}, guardando la
  23 variable @code{structures} la lista de todas las estructuras definidas
  24 por el usuario. El operador @code{@@} permite hacer referencias a los
  25 campos de la estructura. Con @code{kill(@var{S})} se borra la estructura
  26 @var{S} completa y @code{kill(@var{x}@@ @var{a})} elimina la asignación
  27 actual del campo @var{a} en la estructura @var{x}.
  28
  29 En la impresión por consola (con @code{display2d} igual a @code{true}),
  30 las estructuras se representan con las asignaciones de los campos en forma de ecuación,
  31 con el nombre del campo a la izquierda y su valor asociado a la derecha. En la
  32 impresión unidimensional (mediante @code{grind} o dándole a @code{display2d}
  33 el valor @code{false}), las estructuras se escriben sin los nombres de los campos.
  34
  35 No es posible utilizar el nombre de un campo como nombre de función, pero el
  36 valor de un campo sí puede ser una expresión lambda.
  37 Tampoco es posible restringir los valores de los campos a tipos de datos
  38 concretos, siendo el caso que a cada campo se le puede asignar cualquier
  39 tipo de expresión. Por último, no es posible hacer que ciertos campos
  40 sean o no accesibles desde determinados contextos, ya que todos los campos
  41 son siempre visibles.
  42
  43
  44
  45
  46 @node Funciones y variables para las estructuras,  , Introducción a las estructuras, Estructuras
  47 @subsection Funciones y variables para las estructuras
  48
  49 @defvr {Variable global} structures
  50
  51 @code{structures} es la lista que contiene las estructuras definidas por el usuario con @code{defstruct}.
  52
  53 @end defvr
  54
  55
  56
  57 @deffn {Función} defstruct (@var{S}(@var{a_1}, ..., @var{a_n}))
  58 @deffnx {Función} defstruct (@var{S}(@var{a_1} = @var{v_1}, ..., @var{a_n} = @var{v_n}))
  59
  60 Define una estructura, la cual es una lista de nombres de campos @var{a_1}, ..., @var{a_n}
  61 asociados a un símbolo @var{S}.
  62 Todo individuo de una estructura dada consiste en una expresión con operador @var{S}
  63 y exactamente @code{n} argumentos. La sentencia @code{new(@var{S})} crea un nuevo
  64 individuo con estructura @var{S}.
  65
  66 Un argumento consistente en un símbolo @var{a} especifica el nombre de
  67 un campo. Un argumento consistente en una ecuación @code{@var{a} = @var{v}} especifica
  68 el nombre del campo @var{a} junto con su valor por defecto @var{v}. El valor por
  69 defecto puede ser cualquier tipo de expresión.
  70
  71 La llamada a @code{defstruct} añade @var{S} a la lista de estructuras definidas
  72 por el usuario, @code{structures}.
  73
  74 La sentencia @code{kill(@var{S})} borra @var{S} de la lista de estructuras
  75 definidas por el usuario y elimina la definición de la estructura.
  76
  77 Ejemplos:
  78
  79 @c ===beg===
  80 @c defstruct (foo (a, b, c));
  81 @c structures;
  82 @c new (foo);
  83 @c defstruct (bar (v, w, x = 123, y = %pi));
  84 @c structures;
  85 @c new (bar);
  86 @c kill (foo);
  87 @c structures;
  88 @c ===end===
  89 @example
  90 (%i1) defstruct (foo (a, b, c));
  91 (%o1)                    [foo(a, b, c)]
  92 (%i2) structures;
  93 (%o2)                    [foo(a, b, c)]
  94 (%i3) new (foo);
  95 (%o3)                     foo(a, b, c)
  96 (%i4) defstruct (bar (v, w, x = 123, y = %pi));
  97 (%o4)             [bar(v, w, x = 123, y = %pi)]
  98 (%i5) structures;
  99 (%o5)      [foo(a, b, c), bar(v, w, x = 123, y = %pi)]
 100 (%i6) new (bar);
 101 (%o6)              bar(v, w, x = 123, y = %pi)
 102 (%i7) kill (foo);
 103 (%o7)                         done
 104 (%i8) structures;
 105 (%o8)             [bar(v, w, x = 123, y = %pi)]
 106 @end example
 107
 108 @end deffn
 109
 110 @deffn {Función} new (@var{S})
 111 @deffnx {Función} new (@var{S} (@var{v_1}, ..., @var{v_n}))
 112
 113 @code{new} crea nuevos individuos de estructuras declaradas.
 114
 115 La sentencia @code{new(@var{S})} crea un nuevo individuo de
 116 estructura @var{S} en el que cada campo toma su valor por defecto,
 117 si este fue definido, o sin valor alguno en caso de que no se haya
 118 fijado un valor por defecto en la definición de la estructura.
 119
 120 La sentencia @code{new(@var{S}(@var{v_1}, ..., @var{v_n}))}
 121 crea un nuevo individuo de estructura @var{S} en el que los campos
 122 adquieren los valores @var{v_1}, ..., @var{v_n}.
 123
 124 Ejemplos:
 125
 126 @c ===beg===
 127 @c defstruct (foo (w, x = %e, y = 42, z));
 128 @c new (foo);
 129 @c new (foo (1, 2, 4, 8));
 130 @c ===end===
 131 @example
 132 (%i1) defstruct (foo (w, x = %e, y = 42, z));
 133 (%o1)              [foo(w, x = %e, y = 42, z)]
 134 (%i2) new (foo);
 135 (%o2)               foo(w, x = %e, y = 42, z)
 136 (%i3) new (foo (1, 2, 4, 8));
 137 (%o3)            foo(w = 1, x = 2, y = 4, z = 8)
 138 @end example
 139
 140 @end deffn
 141
 142 @deffn {Operador} @@
 143
 144 @code{@@} es el operador para acceder a los campos de las estructuras.
 145
 146 La expresión @code{@var{x}@@ @var{a}} hace referencia al valor del
 147 campo @var{a} del individuo @var{x} de una estructura dada. El nombre del campo no se evalúa.
 148
 149 Si el campo @var{a} de @var{x} no tiene valor asignado, @code{@var{x}@@ @var{a}}
 150 se evalúa a sí mismo; es decir, devuelve la propia expresión
 151 @code{@var{x}@@ @var{a}} tal cual.
 152
 153 La sentencia @code{kill(@var{x}@@ @var{a})} elimina el valor del campo @var{a} de @var{x}.
 154
 155 Ejemplos:
 156
 157 @c ===beg===
 158 @c defstruct (foo (x, y, z));
 159 @c u : new (foo (123, a - b, %pi));
 160 @c u@z;
 161 @c u@z : %e;
 162 @c u;
 163 @c kill (u@z);
 164 @c u;
 165 @c u@z;
 166 @c ===end===
 167 @example
 168 (%i1) defstruct (foo (x, y, z));
 169 (%o1)                    [foo(x, y, z)]
 170 (%i2) u : new (foo (123, a - b, %pi));
 171 (%o2)           foo(x = 123, y = a - b, z = %pi)
 172 (%i3) u@@z;
 173 (%o3)                          %pi
 174 (%i4) u@@z : %e;
 175 (%o4)                          %e
 176 (%i5) u;
 177 (%o5)            foo(x = 123, y = a - b, z = %e)
 178 (%i6) kill (u@@z);
 179 (%o6)                         done
 180 (%i7) u;
 181 (%o7)              foo(x = 123, y = a - b, z)
 182 (%i8) u@@z;
 183 (%o8)                          u@@z
 184 @end example
 185
 186 El nombre del campo no se evalúa.
 187
 188 @c ===beg===
 189 @c defstruct (bar (g, h));
 190 @c x : new (bar);
 191 @c x@h : 42;
 192 @c h : 123;
 193 @c x@h;
 194 @c x@h : 19;
 195 @c x;
 196 @c h;
 197 @c ===end===
 198 @example
 199 (%i1) defstruct (bar (g, h));
 200 (%o1)                      [bar(g, h)]
 201 (%i2) x : new (bar);
 202 (%o2)                       bar(g, h)
 203 (%i3) x@@h : 42;
 204 (%o3)                          42
 205 (%i4) h : 123;
 206 (%o4)                          123
 207 (%i5) x@@h;
 208 (%o5)                          42
 209 (%i6) x@@h : 19;
 210 (%o6)                          19
 211 (%i7) x;
 212 (%o7)                    bar(g, h = 19)
 213 (%i8) h;
 214 (%o8)                          123
 215 @end example
 216
 217 @end deffn
 218