Funciones y variables para las propiedades (Manual de Maxima 5.45.0)

Siguiente: Funciones y variables para los hechos, Anterior: Introducción a la base de datos de Maxima, Subir: Base de datos de Maxima [Índice general][Índice]

### 11.2 Funciones y variables para las propiedades

Propiedad: alphabetic

  `alphabetic` es un tipo de propiedad reconocida por `declare`. La expresión `declare(s, alphabetic)` le indica a Maxima que reconozca como alfabéticos todos los caracteres que haya en s, que debe ser una cadena de texto.

  Véase también `Identifiers`.

  Ejemplo:

      (%i1) xx\~yy\`\@ : 1729;
      (%o1)                         1729
      (%i2) declare ("~`@", alphabetic);
      (%o2)                         done
      (%i3) xx~yy`@ + @yy`xx + `xx@@yy~;
      (%o3)               `xx@@yy~ + @yy`xx + 1729
      (%i4) listofvars (%);
      (%o4)                  [@yy`xx, `xx@@yy~]

Propiedad: bindtest

  La sentencia `declare(x, bindtest` le indica a Maxima que devuelva un mensaje de error cuando el símbolo x no tenga asociado valor alguno.

  Ejemplo:

      (%i1) aa + bb;
      (%o1)                        bb + aa
      (%i2) declare (aa, bindtest);
      (%o2)                         done
      (%i3) aa + bb;
      aa unbound variable
       -- an error.  Quitting.  To debug this try debugmode(true);
      (%i4) aa : 1234;
      (%o4)                         1234
      (%i5) aa + bb;
      (%o5)                       bb + 1234

Propiedad: constant

  `declare(a, constant)` declara a como constante. La declaración de un símbolo como constante no impide que se le asigne un valor no constante al símbolo.

  Véanse `constantp` y `declare`

  Ejemplo:

      (%i1) declare(c, constant);
      (%o1)                         done
      (%i2) constantp(c);
      (%o2)                         true
      (%i3) c : x;
      (%o3)                           x
      (%i4) constantp(c);
      (%o4)                         false

Función: constantp (expr)

  Devuelve `true` si expr es una expresión constante y `false` en caso contrario.

  Una expresión se considera constante si sus argumentos son números (incluidos los números racionales que se muestran con `/R/`), constantes simbólicas como `%pi`, `%e` o `%i`, variables con valor constante o declarada como constante por `declare`, o funciones cuyos argumentos son constantes.

  La función `constantp` evalúa sus argumentos.

  Ejemplos:

      (%i1) constantp (7 * sin(2));
      (%o1)                                true
      (%i2) constantp (rat (17/29));
      (%o2)                                true
      (%i3) constantp (%pi * sin(%e));
      (%o3)                                true
      (%i4) constantp (exp (x));
      (%o4)                                false
      (%i5) declare (x, constant);
      (%o5)                                done
      (%i6) constantp (exp (x));
      (%o6)                                true
      (%i7) constantp (foo (x) + bar (%e) + baz (2));
      (%o7)                                false
      (%i8)

Función: declare (a_1, f_1, a_2, f_2, ...)

  Asigna al átomo o lista de átomos a_i la propiedad o lista de propiedadesp_i. Si a_i y/o p_i son listas, cada uno de los átomos adquiere todas las propiedades.

  La función `declare` no evalúa sus argumentos y siempre devuelve la expresión `done`.

  La llamada `featurep (object, feature)` devuelve `true` si object ha sido previamente declarado como poseedor de la propiedad feature.

  Véase también `features`.

  La función `declare` reconoce las siguientes propiedades:

  `additive`

    Hace que Maxima simplifique las expresiones a_i haciendo uso de la sustitución `a_i(x + y + z + ...)` `-->` `a_i(x) + a_i(y) + a_i(z) + ...`. Tal sustitución se aplica únicamente al primer argumento.

  `alphabetic`

    Indica a Maxima que reconozca todos los caracteres de la cadena alfanumérica a_i como caracteres alfabéticos.

  `antisymmetric, commutative, symmetric`

    Hace que Maxima reconozca a a_i como una función simétrica o antisimétrica. La propiedad `commutative` equivale a `symmetric`.

  `bindtest`

    Hace que Maxima envíe un error si a_i es evaluado sin habérsele asignado un valor.

  `constant`

    Hace que Maxima considere a a_i como una constante simbólica.

  `even, odd`

    Hace que Maxima reconozca a a_i como una variable entera par o impar.

  `evenfun, oddfun`

    Hace que Maxima reconozca a a_i como una función par o impar.

  `evflag`

    Hace que a_i sea reconocida por `ev`, de manera que a a_i se le asigne el valor `true` durante la ejecución de `ev` cuando a_i aparezca como argumento de control de `ev`. Véase también `evflag`.

  `evfun`

    Hace que a_i sea reconocida por `ev`, de manera que la función nombrada por a_i se aplique cuando a_i aparezca como argumento de control de `ev`. Véase también `evfun`.

  `feature`

    Hace que Maxima considere a a_i como el nombre de una propiedad. Otros átomos podrán ser declarados entonces como poseedores de la propiedad a_i.

  `increasing, decreasing`

    Hace que Maxima reconozca a a_i como una función creciente o decreciente.

  `integer, noninteger`

    Hace que Maxima reconozca a a_i como una variable entera o no entera.

  `integervalued`

    Hace que Maxima reconozca a a_i como una función de valor entero.

  `lassociative, rassociative`

    Hace que Maxima reconozca a a_i como una función asociativa por la derecha o por la izquierda.

  `linear`

    Equivale a declarar a_i conjuntamente como `outative` y `additive`.

  `mainvar`

    Hace que Maxima considere a a_i como una "variable principal", dándole prioridad frente a cualesquiera otras constantes o variables en la ordenación canónica de expresiones de Maxima, tal como determina `ordergreatp`.

  `multiplicative`

    Hace que Maxima simplifique las expresiones a_i haciendo uso de la sustitución `a_i(x * y * z * ...)` `-->` `a_i(x) * a_i(y) * a_i(z) * ...`. Tal sustitución se aplica únicamente al primer argumento.

  `nary`

    Hace que Maxima reconozca a a_i como una función n-aria.

    La declaración `nary` no es equivalente a la función `nary`. El único efecto de `declare(foo, nary)` consiste en hacer que el simplificador de Maxima reduzca expresiones anidadas; por ejemplo, para transformar `foo(x, foo(y, z))` a `foo(x, y, z)`.

  `nonarray`

    Indica que Maxima no debe considerar a_i como un array. Esta declaración evita la evaluación múltiple de variables subindicadas.

  `nonscalar`

    Hace que Maxima considere a a_i como una variable no escalar. Se aplica comúnmente para declarar una variable como un vector simbólico o una matriz simbólica.

  `noun`

    Hace que Maxima considere a a_i como un nombre. El efecto que se obtiene es que se reemplazan todas las expresiones a_i por `'a_i` o `nounify (a_i)`, dependiendo del contexto.

  `outative`

    Hace que Maxima simplifique las expresiones a_i extrayendo los factores constantes del primer argumento.

    Cuando a_i tenga un único argumento, un factor se considerará constante si es una constante literal o declarada.

    Cuando a_i tenga dos o más argumentos, un factor se considerará constante si el segundo argumento es un símbolo y el factor no contiene al segundo argumento.

  `posfun`

    Hace que Maxima reconozca a a_i como una función positiva.

  `rational, irrational`

    Hace que Maxima reconozca a a_i como una variable real racional o irracional.

  `real, imaginary, complex`

    Hace que Maxima reconozca a a_i como una variable real, imaginaria o compleja.

  `scalar`

    Hace que Maxima considere a a_i como una variable escalar.

  Ejemplos sobre el uso de estas propiedades están disponibles en la documentación correspondiente a cada propiedad por separado.

Propiedad: decreasing
Propiedad: increasing

  Las instrucciones `declare(f, decreasing)` y `declare(f, increasing` le indican a Maxima que reconozca la función f como una función decreciente o creciente.

  Véase también `declare` para más propiedades.

  Ejemplo:

      (%i1) assume(a > b);
      (%o1)                        [a > b]
      (%i2) is(f(a) > f(b));
      (%o2)                        unknown
      (%i3) declare(f, increasing);
      (%o3)                         done
      (%i4) is(f(a) > f(b));
      (%o4)                         true

Propiedad: even
Propiedad: odd

  `declare(a, even)` y `declare(a, odd)` le indican a Maxima que reconozca el símbolo a como entero par o impar. Las propiedades `even` y `odd` no son reconocidas por las funciones `evenp`, `oddp` y `integerp`.

  Véanse también `declare` y `askinteger`.

  Ejemplo:

      (%i1) declare(n, even);
      (%o1)                         done
      (%i2) askinteger(n, even);
      (%o2)                          yes
      (%i3) askinteger(n);
      (%o3)                          yes
      (%i4) evenp(n);
      (%o4)                         false

Propiedad: feature

  Maxima interpreta dos tipos diferentes de propiedades, del sistema y las que se aplican a expresiones matemáticas. Véase `status` para obtener información sobre propiedades del sistema, así como `features` y `featurep` para propiedades de las expresiones matemáticas.

  `feature` no es el nombre de ninguna función o variable.

Función: featurep (a, f)

  Intenta determinar si el objeto a tiene la propiedad f en base a los hechos almacenados en la base de datos. En caso afirmativo, devuelve `true`, o `false` en caso contrario.

  Nótese que `featurep` devuelve `false` cuando no se puedan verificar ni f ni su negación.

  `featurep` evalúa su argumento.

  Véanse también `declare` y `features`.

  Ejemplos:

      (%i1) declare (j, even)$
      (%i2) featurep (j, integer);
      (%o2)                           true

Declaración: features

  Maxima reconoce ciertas propiedades matemáticas sobre funciones y variables.

  La llamada `declare (x, foo)` asocia la propiedad foo a la función o variable x.

  La llamada `declare (foo, feature)` declara una nueva propiedad foo. Por ejemplo, `declare ([rojo, verde, azul], feature)` declara tres nuevas propiedades, `rojo`, `verde` y `azul`.

  El predicado `featurep (x, foo)` devuelve `true` si x goza de la propiedad foo, y `false` en caso contrario.

  La lista `features` contiene las propiedades que reconoce Maxima; a saber,

         integer        noninteger      even
         odd            rational        irrational
         real           imaginary       complex
         analytic       increasing      decreasing
         oddfun         evenfun         posfun
         commutative    lassociative    rassociative
         symmetric      antisymmetric

  junto con las definidas por el usuario.

  La lista `features` sólo contiene propiedades matemáticas. Hay otra lista con propiedades no matemáticas; Véase `status`.

  Ejemplo:

      (%i1) declare (FOO, feature);
      (%o1)                         done
      (%i2) declare (x, FOO);
      (%o2)                         done
      (%i3) featurep (x, FOO);
      (%o3)                         true

Función: get (a, i)

  Recupera la propiedad de usuario indicada por i asociada al átomo a o devuelve `false` si a no tiene la propiedad i.

  La función `get` evalúa sus argumentos.

  Véanse también `put` y `qput`.

      (%i1) put (%e, 'transcendental, 'type);
      (%o1)                    transcendental
      (%i2) put (%pi, 'transcendental, 'type)$
      (%i3) put (%i, 'algebraic, 'type)$
      (%i4) typeof (expr) := block ([q],
              if numberp (expr)
              then return ('algebraic),
              if not atom (expr)
              then return (maplist ('typeof, expr)),
              q: get (expr, 'type),
              if q=false
              then errcatch (error(expr,"is not numeric.")) else q)$
      (%i5) typeof (2*%e + x*%pi);
      x is not numeric.
      (%o5)  [[transcendental, []], [algebraic, transcendental]]
      (%i6) typeof (2*%e + %pi);
      (%o6)     [transcendental, [algebraic, transcendental]]

Propiedad: integer
Propiedad: noninteger

  `declare(a, integer)` o `declare(a, noninteger)` indica a Maxima que reconozca a como una variable entera o no entera.

  Véase también `declare`.

  Ejemplo:

      (%i1) declare(n, integer, x, noninteger);
      (%o1)                         done
      (%i2) askinteger(n);
      (%o2)                          yes
      (%i3) askinteger(x);
      (%o3)                          no

Propiedad: integervalued

  `declare(f, integervalued)` indica a MAxima que reconozca f como una función que toma valores enteros.

  Véase también `declare`.

  Ejemplo:

      (%i1) exp(%i)^f(x);
                                    %i f(x)
      (%o1)                      (%e  )
      (%i2) declare(f, integervalued);
      (%o2)                         done
      (%i3) exp(%i)^f(x);
                                    %i f(x)
      (%o3)                       %e

Propiedad: nonarray

  La instrucción `declare(a, nonarray)` le indica a Maxima que no considere a como un array. Esta declaración evita la evaluación múltiple de a, si ésta es una variable subindicada.

  Véase también `declare`.

  Ejemplo:

      (%i1) a:'b$ b:'c$ c:'d$

      (%i4) a[x];
      (%o4)                          d
                                      x
      (%i5) declare(a, nonarray);
      (%o5)                         done
      (%i6) a[x];
      (%o6)                          a
                                      x

Propiedad: nonscalar

  Hace que los átomos se comporten como hace una lista o matriz con respecto del operador `.` del la multiplicación no conmutativa.

  Véase también `declare`.

Función: nonscalarp (expr)

  Devuelve `true` si expr no es escalar, es decir, si contiene átomos declarados como no escalares, listas o matrices.

Declaración: posfun

  La instrucción `declare (f, posfun)` declara a `f` como función positiva, de forma que `is (f(x) > 0)` devolverá `true`.

  Véase también `declare`.

Función: printprops (a, i)
Función: printprops ([a_1, ..., a_n], i)
Función: printprops (all, i)

  Muestra la propiedad con el indicador i asociado con el átomo a. a puede ser también una lista de átomos o el átomo `all` en cuyo caso todos los átomos a los cuales se les haya dado esa propiedad serán usados. Por ejemplo, `printprops ([f, g], atvalue)`. `printprops` es para propiedades que no pueden ser mostradas de otra manera, i.e. para `atvalue`, `atomgrad`, `gradef`, y `matchdeclare`.

Función: properties (a)

  Devuelve una lista con los nombres de todas las propiedades asociadas al t'omo a.

Variable del sistema: props

  Valor por defecto: `[]`

  `props` son t'omos que tienen asociadas otras propiedades además de las explícitamente mencionadas en `infolists`, tales como las especificadas por `atvalue`, `matchdeclare` y la función `declare`.

Función: propvars (prop)

  Devuelve la lista con los átomos de la lista `props` que tienen la propiedad indicada por prop. Así, `propvars (atvalue)` devuelve la lista con los átomos a los que se les ha asociado valores con `atvalue`.

Función: put (átomo, valor, indicador)

  Asigna el valor a la propiedad (especificada por indicador) de átomo; indicador puede ser el nombre de cualquier propiedad y no solamente de aquellas definidas por el sistema.

  `rem` deshace la asignación realizada por `put`.

  La función `put` evalúa sus argumentos y devuelve valor.

  Ejemplos:

      (%i1) put (foo, (a+b)^5, expr);
                                         5
      (%o1)                       (b + a)
      (%i2) put (foo, "Hello", str);
      (%o2)                         Hello
      (%i3) properties (foo);
      (%o3)            [[user properties, str, expr]]
      (%i4) get (foo, expr);
                                         5
      (%o4)                       (b + a)
      (%i5) get (foo, str);
      (%o5)                         Hello

Función: qput (átomo, valor, indicador)

  Asigna valor a la propiedad de átomo que especifique indicador. Actúa del mismo modeo que `put`, excepto que sus argumentos no son evaluados.

  Véase también `get`.

  Ejemplo:

      (%i1) foo: aa$
      (%i2) bar: bb$
      (%i3) baz: cc$
      (%i4) put (foo, bar, baz);
      (%o4)                          bb
      (%i5) properties (aa);
      (%o5)                [[user properties, cc]]
      (%i6) get (aa, cc);
      (%o6)                          bb
      (%i7) qput (foo, bar, baz);
      (%o7)                          bar
      (%i8) properties (foo);
      (%o8)            [value, [user properties, baz]]
      (%i9) get ('foo, 'baz);
      (%o9)                          bar

Propiedad: rational
Propiedad: irrational

  `declare(a, rational)` o `declare(a, irrational)` indica a Maxima que reconozca a como una variable real racional o irracional.

  Véase también `declare`.

Propiedad: real
Propiedad: imaginary
Propiedad: complex

  `declare(a, real)`, `declare(a, imaginary)` o `declare(a, complex)` indican a Maxima que reconozca a como variable real, imaginaria puro o compleja, respectivamente.

  Véase también `declare`.

Función: rem (átomo, indicador)

  Elimina del átomo la propiedad indicada por indicador. `rem` deshace la asignación realizada por `put`.

  `rem` devuelve `done` si átomo tenía la propiedad indicador cuando `rem` fue invocado, devolviendo `false` si carecía tal propiedad.

Función: remove (a_1, p_1, ..., a_n, p_n)
Función: remove ([a_1, ..., a_m], [p_1, ..., p_n], ...)
Función: remove ("a", operator)
Función: remove (a, transfun)
Función: remove (all, p)

  Elimina propiedades asociadas con átomos.

  La llamada `remove (a_1, p_1, ..., a_n, p_n)` elimina la propiedad `p_k` del átomo `a_k`.

  La llamada `remove ([a_1, ..., a_m], [p_1, ..., p_n], ...)` elimina las propiedades `p_1, ..., p_n` de los átomos a_1, ..., a_m. Puede tener más de un par de listas.

  La llamada `remove (all, p)` elimina la propiedad p de todos los átomos que la tengan.

  Las propiedades eliminadas pueden ser de las que define el sistema, como `function`, `macro` o `mode_declare`; `remove` no elimina las propiedades definidas por `put`.

  La llamada `remove ("a", operator)` o su equivalente `remove ("a", op)` elimina de a las propiedades de operador declaradas por `prefix`, `infix`, `nary`, `postfix`, `matchfix` o `nofix`. Nótese que el nombre del operador debe escribirse como cadena precedida de apóstrofo.

  La función `remove` devuelve siempre `done` independientemente que haya algún átomo con la propiedad especificada.

  La función `remove` no evalúa sus argumentos.

Propiedad: scalar

  `declare(a, scalar)` indica a Maxima que considere a a como una variable escalar.

  Véase también `declare`.

Función: scalarp (expr)

  Devuelve `true` si expr es un número, constante o variable declarada como `scalar` con `declare`, o compuesta completamente de tales números, constantes o variables, pero que no contengan matrices ni listas.

Siguiente: Funciones y variables para los hechos, Anterior: Introducción a la base de datos de Maxima, Subir: Base de datos de Maxima [Índice general][Índice]