[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
4.1 Introducción a la Línea de Comandos | ||
4.2 Funciones y variables para la Línea de Comandos |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
El operador comilla simple '
evita la evaluación.
Aplicado a un símbolo, la comilla simple evita la evaluación del símbolo.
Aplicado a la llamada de una función, la comilla simple evita la evaluación de la función llamada, aunque los argumentos de la función son evaluados (siempre y cuando la evaluación no se evite de otra manera). El resultado es una forma de nombre de la función llamada.
Aplicado a una expresión con paréntesis,
la comilla simple evita la evaluación de todos los símbolos y llamadas a funciones que hayan en la expresión.
E.g., '(f(x))
significa que no se evalua la expresión f(x)
.
'f(x)
(con la comilla simple aplicada a f
en cambio de a f(x)
)
significa el retorno de la forma de nombre de f
aplicada a [x]
.
La comilla simple no evita la simplificación.
Cuando el interruptor global noundisp
es true
,
los nombres se muestran con una comilla simple.
Este interruptor siempre tiene como valor true
cuando
se muestran definiciones de funciones.
Ver también los operadores comilla-comilla ''
y nouns
.
Ejemplos:
Aplicado a un símbolo, la comilla simple evita la evaluación del símbolo.
(%i1) aa: 1024; (%o1) 1024 (%i2) aa^2; (%o2) 1048576 (%i3) 'aa^2; 2 (%o3) aa (%i4) ''%; (%o4) 1048576
Aplicado a la llamada de una función, la comilla simple evita la evaluación de la función llamada, aunque los argumentos de la función son evaluados (siempre y cuando la evaluación no se evite de otra manera). El resultado es una forma de nombre de la función llamada.
(%i1) x0: 5; (%o1) 5 (%i2) x1: 7; (%o2) 7 (%i3) integrate (x^2, x, x0, x1); 218 (%o3) --- 3 (%i4) 'integrate (x^2, x, x0, x1); 7 / [ 2 (%o4) I x dx ] / 5 (%i5) %, nouns; 218 (%o5) --- 3
Aplicado a una expresión con paréntesis, la comilla simple evita la evaluación de todos los símbolos y llamadas a funciones que hayan en la expresión.
(%i1) aa: 1024; (%o1) 1024 (%i2) bb: 19; (%o2) 19 (%i3) sqrt(aa) + bb; (%o3) 51 (%i4) '(sqrt(aa) + bb); (%o4) bb + sqrt(aa) (%i5) ''%; (%o5) 51
La comilla simple no evita la simplificación.
(%i1) sin (17 * %pi) + cos (17 * %pi); (%o1) - 1 (%i2) '(sin (17 * %pi) + cos (17 * %pi)); (%o2) - 1
El operador comilla-comilla ''
(dos comillas simples) modifica la evaluación
en las expresiones de entrada.
Aplicado a cualquier expresión general expr, las dos comillas simples hacen que el valor de expr sea sustituido por expr en la expresión de entrada.
Aplicado al operador de una expresión, el operador comilla-comilla hace que el operador pase de ser un nombre a ser un verbo, a menos que ya sea un verbo.
El operador comilla-comilla es aplicado por el analizador sintáctico de entrada;
no se almacena como una parte de la expresión de entrada analizada.
Este operador se aplica siempre tan pronto como es detectado y no puede ser comentado con
una comilla simple. De esta manera, el operador comilla-comilla provoca la evaluación de
una expresión cuando ésta no estaba previsto que fuese evaluada, como en la
definición de funciones, expresiones lambda y expresiones comentadas con una comilla simple
'
.
El operador comilla-comilla es reconocido tanto por batch
como por load
.
Véanse también el operador comilla simple '
y nouns
.
Ejemplos:
Aplicado a cualquier expresión general expr, las dos comillas simples hacen que el valor de expr sea sustituido por expr en la expresión de entrada.
(%i1) expand ((a + b)^3); 3 2 2 3 (%o1) b + 3 a b + 3 a b + a (%i2) [_, ''_]; 3 3 2 2 3 (%o2) [expand((b + a) ), b + 3 a b + 3 a b + a ] (%i3) [%i1, ''%i1]; 3 3 2 2 3 (%o3) [expand((b + a) ), b + 3 a b + 3 a b + a ] (%i4) [aa : cc, bb : dd, cc : 17, dd : 29]; (%o4) [cc, dd, 17, 29] (%i5) foo_1 (x) := aa - bb * x; (%o5) foo_1(x) := aa - bb x (%i6) foo_1 (10); (%o6) cc - 10 dd (%i7) ''%; (%o7) - 273 (%i8) ''(foo_1 (10)); (%o8) - 273 (%i9) foo_2 (x) := ''aa - ''bb * x; (%o9) foo_2(x) := cc - dd x (%i10) foo_2 (10); (%o10) - 273 (%i11) [x0 : x1, x1 : x2, x2 : x3]; (%o11) [x1, x2, x3] (%i12) x0; (%o12) x1 (%i13) ''x0; (%o13) x2 (%i14) '' ''x0; (%o14) x3
Aplicado al operador de una expresión, el operador comilla-comilla hace que el operador pase de ser un nombre a ser un verbo, a menos que ya sea un verbo.
(%i1) sin (1); (%o1) sin(1) (%i2) ''sin (1); (%o2) 0.8414709848079 (%i3) declare (foo, noun); (%o3) done (%i4) foo (x) := x - 1729; (%o4) ''foo(x) := x - 1729 (%i5) foo (100); (%o5) foo(100) (%i6) ''foo (100); (%o6) - 1629
El operador comilla-comilla es aplicado por el analizador sintáctico de entrada; no se almacena como una parte de la expresión de entrada analizada.
(%i1) [aa : bb, cc : dd, bb : 1234, dd : 5678]; (%o1) [bb, dd, 1234, 5678] (%i2) aa + cc; (%o2) dd + bb (%i3) display (_, op (_), args (_)); _ = cc + aa op(cc + aa) = + args(cc + aa) = [cc, aa] (%o3) done (%i4) ''(aa + cc); (%o4) 6912 (%i5) display (_, op (_), args (_)); _ = dd + bb op(dd + bb) = + args(dd + bb) = [dd, bb] (%o5) done
El operador comilla-comilla provoca la evaluación de
una expresión cuando ésta no estaba previsto que fuese evaluada, como en la
definición de funciones, expresiones lambda y expresiones comentadas con una comilla simple
'
.
(%i1) foo_1a (x) := ''(integrate (log (x), x)); (%o1) foo_1a(x) := x log(x) - x (%i2) foo_1b (x) := integrate (log (x), x); (%o2) foo_1b(x) := integrate(log(x), x) (%i3) dispfun (foo_1a, foo_1b); (%t3) foo_1a(x) := x log(x) - x (%t4) foo_1b(x) := integrate(log(x), x) (%o4) [%t3, %t4] (%i4) integrate (log (x), x); (%o4) x log(x) - x (%i5) foo_2a (x) := ''%; (%o5) foo_2a(x) := x log(x) - x (%i6) foo_2b (x) := %; (%o6) foo_2b(x) := % (%i7) dispfun (foo_2a, foo_2b); (%t7) foo_2a(x) := x log(x) - x (%t8) foo_2b(x) := % (%o8) [%t7, %t8] (%i8) F : lambda ([u], diff (sin (u), u)); (%o8) lambda([u], diff(sin(u), u)) (%i9) G : lambda ([u], ''(diff (sin (u), u))); (%o9) lambda([u], cos(u)) (%i10) '(sum (a[k], k, 1, 3) + sum (b[k], k, 1, 3)); (%o10) sum(b , k, 1, 3) + sum(a , k, 1, 3) k k (%i11) '(''(sum (a[k], k, 1, 3)) + ''(sum (b[k], k, 1, 3))); (%o11) b + a + b + a + b + a 3 3 2 2 1 1
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
provee un nombre alternativo para una (bien sea definida por el usuario o por el sistema) función, variable, arreglo, etc. Cualquier número par de argumentos puede ser usado.
Valor por defecto: false
Cuando en Maxima ocurre un error, Maxima inicializará el depurador si debugmode
tiene el valor true
.
El usuario puede ingresar comandos para examinar la pila de llamadas, los puntos de interrupción; en pocas palabras ir a través del código de Maxima. Vea debugging
para una lista de los comandos del depurador.
Habilitando debugmode
no se capturarán los errores tipo Lisp.
Evalua la expresión expr en el entorno especificado
por los argumentos arg_1, ..., arg_n.
Los argumentos son interruptores (Variables Booleanas), variables de
asignación, ecuaciones y funciones.
ev
retorna el resultado (otra expresión) de la evaluación.
La evaluación se realiza por etapas, como sigue:
simp
causa que expr sea simplificada sin importar el valor de la variable interruptor simp
la cual inhibe la simplificación cuando su valor es false
.
noeval
suprime la fase de evaluación de ev
(Vea el paso (4) más adelante).
Esto es muy útil en conjunción con otras variables interruptor y causan en expr que sea resimplificada sin ser reevaluada.
nouns
causa la evaluación de las formas nominales
(típicamente funciones sin evaluar tales como
'integrate
or 'diff
) en expr
.
expand
causa expansión.
expand (m, n)
causa expansión, asignando los valores de maxposex
y
maxnegex
a m y n, respectivamente.
detout
hace que cualesquiera matrices inversas calculadas en expr conserven su determinante fuera de la inversa, en vez de que divida a cada elemento.
diff
realiza todas las diferenciaciones indicadas en expr.
derivlist (x, y, z, ...)
realiza sólo las diferenciaciones con respecto a las variables indicadas.
float
provoca la conversión de los números racionales no-enteros a números decimales de coma flotante.
numer
causa que algunas funciones matemáticas (incluyendo potenciación) con argumentos numéricos sean evaluados como punto flotante. Esto causa que las variables en expr las cuales hayan sido declaradas como variables numéricas sean reemplazadas por sus respectivos valores. Esto también configura la variable interruptor float
a true
.
pred
provoca la evaluación de los predicados (expresiones las cuales se evaluan a true
o false
).
eval
provoca una post-evaluación extra de expr (véase el paso (5) más adelante), pudiendo aparecer
eval
varias veces; por cada aparición de eval
, la expresión es reevaluada.
A
, donde A
es un átomo declarado como una variable de tipo interruptor, (Vea evflag
)
causa que A
tenga como valor true
durante
la evaluación de expr.
V: expresion
(o alternativamente V=expresion
) causa que
V
tenga el valor de expresion
durante la evaluación
de expr. Notese que si V
es una opción Maxima, entonces
expresion
se usa como su valor durante la evaluación de
expr. Si más de un argumento de ev
es de este
tipo entonces el vínculo se hace en paralelo. Si V
es una
expresión no atómica entonces se hace una sustitución más que
un vínculo.
F
donde F
, un nombre de función, ha sido declarado para
ser una función de evaluación (Vea evfun
) causa que
F
sea aplicada a expr.
sum
) causa la evaluación de las ocurrencias de esos nombres en expr
como si ellos fueran
verbos.
F(x)
) puede ser definida localmente para el propósito de esta evaluación
de expr pasando F(x) := expresion
como un argumento a
ev
.
ev
. Esto permite que una
lista de argumentos sea pasada (e.g., [X=1, Y=A**2]
) o una lista
de nombres de ecuaciones (e.g., [%t1, %t2]
donde %t1
y
%t2
son ecuaciones) tal como lo que es retornado por
solve
.
Los argumentos de ev
pueden ser pasados en cualquier orden con excepción de la sustitución de ecuaciones las cuales son manipuladas en
secuencia, de izquierda a derecha y las funciones de evaluación las
cuales son compuestas, e.g., ev (expr, ratsimp, realpart)
es manipulada como realpart (ratsimp (expr))
.
Los interruptores simp
, numer
, float
y pred
pueden también ser configurados localmente en una sentencia block, o
globalmente en Maxima para que su efecto permanezca hasta que
sean reconfiguradas.
Si expr es una Expresión Racional Canónica (CRE, por sus siglas en inglés), entonces la expresión retornada por ev
es también
de tipo CRE, siempre que los interruptores numer
y float
no sean true
.
%
(como en %i2
en el ejemplo de más abajo) así que
este paso simplemente recupera la expresión a la que hace referencia
la etiqueta y así ev
puede trabajarla.
noeval
) y simplificada de acuerdo a los
argumentos. Notese que cualquier llamada a una función en expr
será llevada a cabo después de que las variables sean evaluadas
en ella y que ev(F(x))
pueda comportarse como F(ev(x))
.
eval
en los argumentos, se repetirán los pasos (3) y (4).
Ejemplos
(%i1) sin(x) + cos(y) + (w+1)^2 + 'diff (sin(w), w); d 2 (%o1) cos(y) + sin(x) + -- (sin(w)) + (w + 1) dw (%i2) ev (%, sin, expand, diff, x=2, y=1); 2 (%o2) cos(w) + w + 2 w + cos(1) + 1.909297426825682
Una sintaxis alternativa de alto nivel ha sido proveida para ev
,
por medio de la cual uno puede escribir solamente sus argumentos, sin
el comando ev()
. Esto es, una forma sencilla de escritura:
expr, arg_1, ..., arg_n
Esto no es permitido como parte de otra expresión , e.g., en funciones, sentencias block, etc.
Nótese el proceso de vínculo en paralelo en el siguiente ejemplo:
(%i3) programmode: false; (%o3) false (%i4) x+y, x: a+y, y: 2; (%o4) y + a + 2 (%i5) 2*x - 3*y = 3$ (%i6) -3*x + 2*y = -4$ (%i7) solve ([%o5, %o6]); Solución 1 (%t7) y = - - 5 6 (%t8) x = - 5 (%o8) [[%t7, %t8]] (%i8) %o6, %o8; (%o8) - 4 = - 4 (%i9) x + 1/x > gamma (1/2); 1 (%o9) x + - > sqrt(%pi) x (%i10) %, numer, x=1/2; (%o10) 2.5 > 1.772453850905516 (%i11) %, pred; (%o11) true
Cuando un símbolo x goza de la propiedad evflag
,
las expresiones ev(expr, x)
y expr, x
(en modo interactivo) equivalen a ev(expr, x = true)
.
Esto es, a x se le asigna true
al tiempo que se evalúa expr.
La expresión declare(x, evflag)
dota a la variable x
de la propiedad evflag
.
Los interruptores que tienen la propiedad evflag
son:
algebraic
,
cauchysum
,
demoivre
,
dotscrules
,
%emode
,
%enumer
,
exponentialize
,
exptisolate
,
factorflag
,
float
,
halfangles
,
infeval
,
isolate_wrt_times
,
keepfloat
,
letrat
,
listarith
,
logabs
,
logarc
,
logexpand
,
lognegint
,
lognumer
,
m1pbranch
,
numer_pbranch
,
programmode
,
radexpand
,
ratalgdenom
,
ratfac
,
ratmx
,
ratsimpexpons
,
simp
,
simpsum
,
sumexpand
, y
trigexpand
.
Ejemplos:
(%i1) sin (1/2); 1 (%o1) sin(-) 2 (%i2) sin (1/2), float; (%o2) 0.479425538604203 (%i3) sin (1/2), float=true; (%o3) 0.479425538604203 (%i4) simp : false; (%o4) false (%i5) 1 + 1; (%o5) 1 + 1 (%i6) 1 + 1, simp; (%o6) 2 (%i7) simp : true; (%o7) true (%i8) sum (1/k^2, k, 1, inf); inf ==== \ 1 (%o8) > -- / 2 ==== k k = 1 (%i9) sum (1/k^2, k, 1, inf), simpsum; 2 %pi (%o9) ---- 6 (%i10) declare (aa, evflag); (%o10) done (%i11) if aa = true then YES else NO; (%o11) NO (%i12) if aa = true then YES else NO, aa; (%o12) YES
Cuando la función F goza de la propiedad evfun
,
las expresiones ev(expr, F)
y expr, F
(en modo interactivo) equivalen a F(ev(expr))
.
Si se especifican dos o más funciones, F, G, etc., como poseedoras
de la propiedad evfun
, éstas se aplican en el mismo orden en el que han sido
especificadas como tales.
La expresión declare(F, evfun)
dota a la función F
de la propiedad evfun
.
Las funciones que tienen la propiedad evfun
por defecto son:
bfloat
,
factor
,
fullratsimp
,
logcontract
,
polarform
,
radcan
,
ratexpand
,
ratsimp
,
rectform
,
rootscontract
,
trigexpand
, y
trigreduce
.
Ejemplos:
(%i1) x^3 - 1; 3 (%o1) x - 1 (%i2) x^3 - 1, factor; 2 (%o2) (x - 1) (x + x + 1) (%i3) factor (x^3 - 1); 2 (%o3) (x - 1) (x + x + 1) (%i4) cos(4 * x) / sin(x)^4; cos(4 x) (%o4) -------- 4 sin (x) (%i5) cos(4 * x) / sin(x)^4, trigexpand; 4 2 2 4 sin (x) - 6 cos (x) sin (x) + cos (x) (%o5) ------------------------------------- 4 sin (x) (%i6) cos(4 * x) / sin(x)^4, trigexpand, ratexpand; 2 4 6 cos (x) cos (x) (%o6) - --------- + ------- + 1 2 4 sin (x) sin (x) (%i7) ratexpand (trigexpand (cos(4 * x) / sin(x)^4)); 2 4 6 cos (x) cos (x) (%o7) - --------- + ------- + 1 2 4 sin (x) sin (x) (%i8) declare ([F, G], evfun); (%o8) done (%i9) (aa : bb, bb : cc, cc : dd); (%o9) dd (%i10) aa; (%o10) bb (%i11) aa, F; (%o11) F(cc) (%i12) F (aa); (%o12) F(bb) (%i13) F (ev (aa)); (%o13) F(cc) (%i14) aa, F, G; (%o14) G(F(cc)) (%i15) G (F (ev (aa))); (%o15) G(F(cc))
Habilita el modo de "evaluación infinita". ev
repetidamente
evalua una expresión hasta que se interrumpa la acción. Para prevenir
que una variable, digamos X
, sea evaluada sin parar en este modo,
simplemente incluya X='X
como argumento de ev
.
Esta claro que expresiones como: ev (X, X=X+1, infeval)
generarán un bucle infinito.
Elimina todas las asignaciones (valor, función, arreglo o regla) hechas a los
argumentos a_1, ..., a_n.
Un argumento a_k puede ser un símbolo o el elemento
de un array. Si a_k es elemento de un array, kill
elimina la
asignación hecha a este elemento sin afectar al resto del array.
Se reconocen varios argumentos especiales.
Se pueden combinar diferentes clases de argumentos,
como por ejemplo, kill (inlabels, functions, allbut (foo, bar))
.
La instrucción kill (labels)
borra todas las asignaciones asociadas
a las etiquetas de entrada, de salida e intermedias creadas hasta el
momento. La instrucción kill (inlabels)
elimina únicamente
las asignaciones de las etiquetas de entrada que comienzan con el
valor actual de inchar
. Del mismo modo, kill (outlabels)
elimina únicamente las asignaciones de las etiquetas de salida
que comienzan con el valor actual de outchar
. Finalmente,
kill (linelabels)
elimina únicamente las asignaciones
de las etiquetas de las expresiones intermedias
que comienzan con el valor actual de linechar
.
La instrucción kill (n)
, siendo n un entero,
elimina las asignaciones de las últimas n etiquetas, tanto
de entrada como de salida.
La instrucción kill ([m, n])
elimina las asignaciones
hechas a las etiquetas de entrada y salida desde la m hasta lan.
La instrucción kill (infolist)
, siendo infolist
cualquier elemento de infolists
(como values
, functions
o arrays
), elimina todas las asignaciones hechas a los elementos de
infolist. Véase también infolists
.
La instrucción kill (all)
elimina todas las asignaciones de
todas las variables, pero no reinicia las variables globales a sus
valores por defecto. Véase también reset
.
La instrucción kill (allbut (a_1, ..., a_n))
elimina las asignaciones hechas a todas las variables,
excepto a a_1, ..., a_n; la instrucción
kill (allbut (infolist))
elimina todas las asignaciones,
excepto las de los elementos de infolist, pudiendo ser infolist
igual a values
, functions
, arrays
, etc.
La memoria reservada para una asignación no se libera hasta que no se vacíen todos los símbolos asociados con esta asignación; por ejemplo, para liberar la memoria del valor de un símbolo es necesario eliminar tanto la asignación de la etiqueta de salida que muestra el resultado, como la del propio símbolo.
La función kill
no evalua sus argumentos.
El operador comilla-comilla, ''
, obliga a que se realice la evaluación.
La llamada kill (symbol)
elimina todas las propiedades de symbol.
Por el contrario, remvalue
, remfunction
, remarray
y remrule
eliminan propiedades específicas.
kill
siempre devuelve done
, incluso cuando alguno de sus
argumentos carecía de asignación previa.
Retorna la lista de etiquetas de entrada, salida o de expresiones intermedias las cuales empiezan con symbol.
Típicamente symbol es el valor de las variables inchar
, outchar
o linechar
.
El caractér de etiqueta puede ser pasado con o sin signo de porcentaje,
así, por ejemplo, i
y %i
producen el mismo resultado.
Si ninguna etiqueta empieza con symbol, labels
retorna a una
lista vacía.
La función labels
no evalua su argumento.
El operador comilla-comilla, ''
, obliga a que se realice la evaluación.
Por ejemplo,
labels (''inchar)
devuelve las etiquetas de entrada que empiezan con el caractér de etiqueta de entrada actual.
La variable labels
es una lista de las etiquetas de entrada, salida y expresiones intermedias, incluyendo todas las etiquetas anteriores en el caso de que inchar
, outchar
o linechar
hayan sido redefinidas.
Por defecto, Maxima muestra el resultado de cada expresión introducida por el usuario, asignando al resultado una etiqueta de salida.
La salida (es decir el resultado) puede ser suprimida terminando la expresión de entrada con un $
(signo de dólar) en vez de un ;
(punto y coma).
En este caso, se crea la etiqueta de salida y se le asigna el resultado, aunque éste no se muestre; aún así, la etiqueta puede ser referenciada de la misma forma que se hace con aquéllas cuyos resultados sí son mostrados.
Véanse también: %
, %%
y %th
.
Las etiquetas de expresiones intermedias pueden ser generadas por algunas funciones. El interruptor programmode
controla si solve
y algunas otras funciones generan etiquetas de expresiones intermedias en vez de retornar una lista de expresiones.
Algunas otras funciones, tales como ldisplay
, siempre generan etiquetas de expresiones intermedias.
Véase también: inchar
, outchar
, linechar
y infolists
.
El número de la línea del par de expresiones de entrada y salida actuales.
Valor por defecto: []
myoptions
es la lista de todas las opciones que nunca fueron reconfiguradas por el usuario, aunque éstas hayan sido reconfiguradas a su valor por defecto.
Valor por defecto: false
Cuando nolabels
vale true
,
las etiquetas de entrada y salida
(%i
y %o
, respectivamente)
son mostradas, pero a éstas no se les
asignan los resultados; además, las etiquetas no se
incorporan a la lista labels
.
Puesto que a las etiquetas no se les asignan resultados,
el colector de basura puede recuperar la memoria ocupada
por éstos.
En el caso contrario, a las etiquetas de entrada y salida se les asignan los resultados correspondientes y son añadidas a la lista labels
.
Las etiquetas de expresiones intermedias (%t
) no se ven afectadas por la variable nolabels
;
independientemente de que nolabels
valga true
o false
, a las etiquetas de expresiones intermedias se les asignan siempre valores, además de ser añadidas a la lista labels
.
Véanse también batch
, batchload
y labels
.
Valor por defecto: false
Cuando optionset
tiene como valor true
, Maxima imprime un
mensaje cada vez que una opción de Maxima es reconfigurada. Esto es
muy útil si el usuario duda con frecuencia de la correctitud de alguna
opción y quiere estar seguro de la variable a la que él asignó un
valor fue verdaramente una variable opción (o interruptor).
Muestra las entradas, salidas y expresiones intermedias
sin recalcularlas.
playback
sólo muestra las expresiones asociadas con etiquetas;
cualquier otra salida (tal como texto impreso por print
o describe
, o mensajes de error) no es mostrada.
Véase también: labels
.
playback
no evalua sus argumentos.
El operador comilla-comilla, ''
, obliga a que se realice la evaluación.
playback
siempre devuelve done
.
playback ()
(sin argumentos) muestra todas las entradas, salidas y expresiones intermedias generadas hasta el momento.
Una expresión de salida es mostrada incluso si ésta fue suprimida por el caracter de terminación $
, cuando fue originalmente calculada.
playback (n)
muestra las n expresiones más recientes. Cada entrada, salida y expresión intermedia cuenta como una.
playback ([m, n])
muestra entradas, salidas y expresiones intermedias con los números desde m hasta n, ambos inclusive.
playback ([m])
es equivalente a playback ([m, m])
;
esto usualmente imprime un par de expresiones de entrada y salida.
playback (input)
muestra todas las expresiones de entrada generadas hasta el momento.
playback (slow)
hace pausas entre expresiones y
espera a que el usuario pulse la tecla enter
para continuar.
Esto es un comportamiento similar a demo
.
playback (slow)
es muy útil en conjunción con save
o
stringout
cuando se crea un archivo secundario de almacenamiento con el objetivo de elegir cuidadosamente las expresiones realmente útiles.
playback (time)
muestra el tiempo de computo por cada expresión.
playback (grind)
muestra las expresiones de entrada
en el mismo formato como la función grind
.
Las expresiones de salida no se ven afectadas por la opción
grind
.
Vea grind
.
Los argumentos pueden ser combinados, por ejemplo,
playback ([5, 10], grind, time, slow)
.
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
.
Valor por defecto: _
prompt
es el símbolo del prompt de la función demo
,
del modo playback (slow)
y del bucle de interrupción de Maxima (el que se invoca con break
).
Termina una sesión de Maxima.
Nótese que la función debe ser invocada como quit();
o quit()$
, no como quit
.
Para parar un cálculo muy demorado
pulse Control-C
.
La acción por defecto es retornar a prompt de Maxima.
Si *debugger-hook*
tiene como valor nil
,
pulsar Control-C
abrirá el depurador de Lisp.
Vea también: debugging
.
Desliga las definiciones de función de sus símbolos f_1, ..., f_n.
Los argumentos pueden ser nombres de funciones ordinarias
(creadas con :=
o define
) o de funciones macro (creadas con ::=
).
La instrucción remfunction (all)
desliga todas las definiciones de funciones.
La función remfunction
no evalúa sus argumentos.
La función remfunction
devuelve una lista con los
símbolos para los que la definición de función
fue desligada. Devuelve false
en el lugar de cualquier
símbolo para el que no hay función definida.
La función remfunction
no se puede aplicar a arrays de funciones ni a
funciones subindicadas. Sí es aplicable en tales casos la
función remarray
.
Reconfigura muchas variables y opciones globales y algunas otras variables a sus valores por defecto.
reset
procesa las variables que se encuentran en la lista Lisp
*variable-initial-values*
.
La macro Lisp defmvar
pone las variables en ésta lista (entre otras acciones).
Muchas, pero no todas, las variables y opciones globales son definidas por defmvar
, y algunas variables definidas por defmvar
no son ni variables ni opciones globales.
Valor por defecto: false
Cuando showtime
tiene como valor true
, el tiempo de cálculo y el tiempo de retardo se imprimen junto con la salida de cada expresión.
El tiempo de cálculo se almacena siempre, de manera que time
y playback
puedan mostrar el tiempo de cálculo incluso cuando showtime
vale false
.
Véase también timer
.
Configura el estado de feature en package.
Después de que sstatus (feature, package)
es
ejecutado status (feature, package)
retorna
true
.
Esto puede ser muy útil para escritores de paquetes, con el
objetivo de conservar las pistas de que caracterísiticas han
cargado estos.
Entra en el intérprete Lisp bajo Maxima. (to-maxima)
retorna de nuevo a Maxima.
Valor inicial: []
values
es una lista de todas las variables que el usuario ha creado (no constituye las opciones Maxima ni los interruptores).
La lista comprende los símbolos :
, ::
, o :=
.
[ << ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
This document was generated by Robert Dodier on diciembre, 22 2007 using texi2html 1.76.