[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Índice] | [ ? ] |
5.1 "N" Argumentos | ||
5.2 Sem Argumentos | ||
5.3 Operador | ||
5.4 Operador Pósfixado | ||
5.5 Operador Préfixado | ||
5.6 Definições para Operadores |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Índice] | [ ? ] |
Um operador nary
é usado para denotar uma função com qualquer número de
argumentos, cada um dos quais é separado por uma ocorrência do
operador, e.g. A+B ou A+B+C. A função nary("x")
é uma função
de extensão sintática para declarar x como sendo um operador nary
.
Funções podem ser declaradas para serem
nary
. Se declare(j,nary);
é concluída, diz ao simplicador para
simplificar, e.g. j(j(a,b),j(c,d))
para j(a, b, c, d)
.
Veja também syntax
.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Índice] | [ ? ] |
Operadores nofix
são usados para denotar funções sem argumentos.
A mera presença de tal operador em um comando fará com que a
função correspondente seja avaliada. Por exemplo, quando se digita
"exit;" para sair de uma parada do Maxima, "exit" tem comportamento similar a um
operador nofix
. A função nofix("x")
é uma função de extensão
sintática que declara x como sendo um operador nofix
.
Veja também syntax
.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Índice] | [ ? ] |
Veja operators
.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Índice] | [ ? ] |
Operadores postfix
como a variedade prefix
denotam funções
de um argumento simples, mas nesse caso o argumento sucede
imediatamente uma ocorrência do operador na seqüência de caracteres de entrada, e.g. 3! .
Uma função postfix("x")
é uma função de extensão
sintática que declara x como sendo um operador postfix
.
Veja também syntax
.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Índice] | [ ? ] |
Um operador prefix
é um que significa uma função de um
argumento, o qual imediatamente segue uma ocorrência do
operador. prefix("x")
é uma função de extensão
sintática que declara x como sendo um operador prefix
.
Veja também syntax
.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Índice] | [ ? ] |
O operador fatorial.
Para qualquer número complexo x
(incluíndo números inteiros, racionais, e reais) exceto para
inteiros negativos, x!
é definido como gamma(x+1)
.
Para um inteiro x
, x!
simplifica para o produto de inteiros de 1 a x
inclusive.
0!
simplifica para 1.
Para um número em ponto flutuante x
, x!
simplifica para o valor de gamma (x+1)
.
Para x
igual a n/2
onde n
é um inteiro ímpar,
x!
simplifica para um fator racional vezes sqrt (%pi)
(uma vez que gamma (1/2)
é igual a sqrt (%pi)
).
Se x
for qualquer outra coisa,
x!
não é simplificado.
As variáveis
factlim
, minfactorial
, e factcomb
controlam a simplificação
de expressões contendo fatoriais.
As funções gamma
, bffac
, e cbffac
são variedades da função gamma
.
makegamma
substitui gamma
para funções relacionadas a fatoriais.
Veja também binomial
.
factlim
.
(%i1) factlim: 10$ (%i2) [0!, (7/2)!, 4.77!, 8!, 20!]; 105 sqrt(%pi) (%o2) [1, -------------, 81.44668037931193, 40320, 20!] 16 |
(%i1) [(%i + 1)!, %pi!, %e!, (cos(1) + sin(1))!]; (%o1) [(%i + 1)!, %pi!, %e!, (sin(1) + cos(1))!] (%i2) ev (%, numer, %enumer); (%o2) [(%i + 1)!, 7.188082728976031, 4.260820476357003, 1.227580202486819] |
(%i1) kill (foo)$ (%i2) foo!; (%o2) foo! |
x!
pode ser substituído mesmo em uma expressão com apóstrofo.
(%i1) '([0!, (7/2)!, 4.77!, 8!, 20!]); 105 sqrt(%pi) (%o1) [1, -------------, 81.44668037931193, 40320, 20!] 16 |
O operador de duplo fatorial.
Para um número inteiro, número em ponto flutuante, ou número racional n
,
n!!
avalia para o produto n (n-2) (n-4) (n-6) ... (n - 2 (k-1))
onde k
é igual a entier (n/2)
,
que é, o maior inteiro menor que ou igual a n/2
.
Note que essa definição não coincide com outras definições publicadas
para argumentos que não são inteiros.
Para um inteiro par (ou ímpar) n
, n!!
avalia para o produto de
todos os inteiros consecutivos pares (ou ímpares) de 2 (ou 1) até n
inclusive.
Para um argumento n
que não é um número inteiro, um número em ponto flutuante, ou um número racional,
n!!
retorna uma forma substantiva genfact (n, n/2, 2)
.
Representa a negação da igualdade sintática =
.
Note que pelo fato de as regras de avaliação de expressões predicadas
(em particular pelo fato de not expr
fazer com que ocorra a avaliação de expr),
a forma not a = b
não é equivalente à forma a # b
em alguns casos.
Exemplos:
(%i1) a = b; (%o1) a = b (%i2) é (a = b); (%o2) false (%i3) a # b; (%o3) a # b (%i4) not a = b; (%o4) true (%i5) é (a # b); (%o5) true (%i6) é (not a = b); (%o6) true |
O operador ponto, para multiplicação (não comutativa) de matrizes. Quando "." é usado com essa finalidade, espaços devem ser colocados em ambos os lados desse operador, e.g. A . B. Isso distingüe o operador ponto plenamente de um ponto decimal em um número em ponto flutuante.
Veja também
dot
,
dot0nscsimp
,
dot0simp
,
dot1simp
,
dotassoc
,
dotconstrules
,
dotdistrib
,
dotexptsimp
,
dotident
,
e
dotscrules
.
O operador de atribuição. E.g. A:3 escolhe a variável A para 3.
Operador de atribuição. :: atribui o valor da expressão em seu lado direito para o valor da quantidade na sua esquerda, que pode avaliar para uma variável atômica ou variável subscrita.
Operador de definição de função de macro.
::=
define uma função (chamada uma "macro" por razões históricas)
que coloca um apóstrofo em seus argumentos (evitando avaliação),
e a expressão que é retornada (chamada a "expansão de macro")
é avaliada no contexto a partir do qual a macro foi chamada.
Uma função de macro é de outra forma o mesmo que uma função comum.
macroexpand
retorna uma expansão de macro (sem avaliar a expansão).
macroexpand (foo (x))
seguida por ''%
é equivalente a foo (x)
quando foo
for uma função de macro.
::=
coloca o nome da nova função de macro dentro da lista global macros
.
kill
, remove
, e remfunction
desassocia definições de função de macro
e remove nomes de macros
.
fundef
e dispfun
retornam respectivamente uma definição de função de macro
e uma atribuição dessa definição a um rótulo, respectivamente.
Funções de macro comumente possuem expressões buildq
e
splice
para construir uma expressão,
que é então avaliada.
Exemplos
Uma função de macro coloca um apóstrofo em seus argumentos evitando então a avaliação,
então mensagem (1) mostra y - z
, não o valor de y - z
.
A expansão de macro (a expressão com apóstrofo '(print ("(2) x is equal to", x))
é avaliada no contexto a partir do qual a macro for chamada,
mostrando a mensagem (2).
(%i1) x: %pi; (%o1) %pi (%i2) y: 1234; (%o2) 1234 (%i3) z: 1729 * w; (%o3) 1729 w (%i4) printq1 (x) ::= block (print ("(1) x é igual a", x), '(print ("(2) x é igual a", x))); (%o4) printq1(x) ::= block(print("(1) x é igual a", x), '(print("(2) x é igual a", x))) (%i5) printq1 (y - z); (1) x é igual a y - z (2) x é igual a %pi (%o5) %pi |
Uma função comum avalia seus argumentos, então message (1) mostra o valor de y - z
.
O valor de retorno não é avaliado, então mensagem (2) não é mostrada
até a avaliação explícita ''%
.
(%i1) x: %pi; (%o1) %pi (%i2) y: 1234; (%o2) 1234 (%i3) z: 1729 * w; (%o3) 1729 w (%i4) printe1 (x) := block (print ("(1) x é igual a", x), '(print ("(2) x é igual a", x))); (%o4) printe1(x) := block(print("(1) x é igual a", x), '(print("(2) x é igual a", x))) (%i5) printe1 (y - z); (1) x é igual a 1234 - 1729 w (%o5) print((2) x é igual a, x) (%i6) ''%; (2) x é igual a %pi (%o6) %pi |
macroexpand
retorna uma expansão de macro.
macroexpand (foo (x))
seguido por ''%
é equivalente a foo (x)
quando foo
for uma função de macro.
(%i1) x: %pi; (%o1) %pi (%i2) y: 1234; (%o2) 1234 (%i3) z: 1729 * w; (%o3) 1729 w (%i4) g (x) ::= buildq ([x], print ("x é igual a", x)); (%o4) g(x) ::= buildq([x], print("x é igual a", x)) (%i5) macroexpand (g (y - z)); (%o5) print(x é igual a, y - z) (%i6) ''%; x é igual a 1234 - 1729 w (%o6) 1234 - 1729 w (%i7) g (y - z); x é igual a 1234 - 1729 w (%o7) 1234 - 1729 w |
O operador de definição de função. E.g. f(x):=sin(x)
define
uma função f
.
denota uma equação para o Maxima. Para o verificador de modelos no Maxima isso denota uma relação total que prende duas expressões se e somente se as expressões são sintaticamente idênticas.
A negação de =
é representada por #
.
Note que pelo fato de as regras de avaliação de expressões predicadas
(em particular pelo fato de not expr
fazer com que ocorra a avaliação de expr),
a forma not a = b
não é equivalente à forma a # b
em alguns casos.
O operador lógico de conjunção.
and
é um operador n-ário infixo;
seus operandos são expressões Booleanas, e seu resultado é um valor Booleano.
and
força avaliação (como is
) de um ou mais operandos,
e pode forçar a avaliação de todos os operandos.
Operandos são avaliados na ordem em que aparecerem.
and
avalia somente quantos de seus operandos forem necessários para determinar o resultado.
Se qualquer operando for false
,
o resultado é false
e os operandos restantes não são avaliados.
O sinalizador global prederror
governa o comportamento de and
quando um operando avaliado não pode ser determinado como sendo true
ou false
.
and
imprime uma mensagem de erro quando prederror
for true
.
De outra forma, and
retorna unknown
(desconhecido).
and
não é comutativo:
a and b
pode não ser igual a b and a
devido ao tratamento de operandos indeterminados.
O operador lógico de disjunção.
or
é um operador n-ário infixo;
seus operandos são expressões Booleanas, e seu resultado é um valor Booleano.
or
força avaliação (como is
) de um ou mais operandos,
e pode forçar a avaliação de todos os operandos.
Operandos são avaliados na ordem em que aparecem.
or
avalia somente quantos de seus operandos forem necessários para determinar o resultado.
Se qualquer operando for true
,
o resultado é true
e os operandos restantes não são avaliados.
O sinalizador global prederror
governa o comportamento de or
quando um operando avaliado não puder ser determinado como sendo true
ou false
.
or
imprime uma mensagem de erro quando prederror
for true
.
De outra forma, or
retorna unknown
.
or
não é comutativo:
a or b
pode não ser igual a b or a
devido ao tratamento de operando indeterminados.
O operador lógico de negação.
not
é operador prefixado;
Seu operando é uma expressão Booleana, e seu resultado é um valor Booleano.
not
força a avaliação (como is
) de seu operando.
O sinalizador global prederror
governa o comportamento de not
quando seu operando não pode ser determinado em termos de true
ou false
.
not
imprime uma mensagem de erro quando prederror
for true
.
De outra forma, not
retorna unknown
.
Retorna o valor absoluto de expr. Se expr for um número complexo, retorna o módulo complexo de expr.
Se declare(f,additive)
tiver sido executado, então:
(1) Se f
for uma função de uma única variável, sempre que o simplificador encontrar f
aplicada
a uma adição, f
será distribuído sobre aquela adição. I.e. f(y+x)
irá
simplificar para f(y)+f(x)
.
(2) Se f
for uma função de 2 ou mais argumentos, a adição é definida como
adição no primeiro argumento para f
, como no caso de sum
ou
integrate
, i.e. f(h(x)+g(x),x)
irá simplificar para f(h(x),x)+f(g(x),x)
.
Essa simplificação não ocorre quando f
é aplicada para expressões da
forma sum(x[i],i,lower-limit,upper-limit)
.
trabalha com os comandos part
(i.e. part
, inpart
, substpart
,
substinpart
, dpart
, e lpart
). Por exemplo,
(%i1) expr: e+d+c+b+a$ (%i2) part (expr, [2, 5]); (%o2) d + a |
enquanto
(%i3) part (expr, allbut (2, 5)); (%o3) e + c + b |
Também trabalha com o comando kill
,
kill (allbut (name_1, ..., name_k)) |
executará um kill (all)
deixando fora do
kill
os nomes especificados. Nota: name_i
significa um nome tal como nome de
função u
, f
, foo
, ou g
, não um infolist
tal como functions
.
Se declare(h,antisymmetric)
é concluída, diz ao
simplicador que h
é uma função antisimétrica. E.g. h(x,z,y)
simplificará para
- h(x, y, z)
. Isto é, dará (-1)^n vezes o resultado dado por
symmetric
ou commutative
, quando n for o número de interescolhas de dois
argumentos necessários para converter isso naquela forma.
Retorna o valor absoluto complexo (o módulo complexo) de expr.
Quando x for um número real, retorna o último inteiro que é maior que ou igual a x.
Se x for uma expressão constante (10 * %pi
, por exemplo),
ceiling
avalia x usando grandes números em ponto flutuante, e
aplica ceiling
para o grande número em ponto flutuante resultante. Porque ceiling
usa
avaliação de ponto flutuante, é possível, embora improvável,
que ceiling
possa retornar uma valor errôneo para entradas
constantes. Para prevenir erros, a avaliação de ponto flutuante
é concluída usando três valores para fpprec
.
Para entradas não constantes, ceiling
tenta retornar um valor
simplificado. Aqui está um exemplo de simplificações que ceiling
conhece:
(%i1) ceiling(ceiling(x)); (%o1) ceiling(x) (%i2) ceiling(floor(x)); (%o2) floor(x) (%i3) declare(n,integer)$ (%i4) [ceiling(n), ceiling(abs(n)), ceiling(max(n,6))]; (%o4) [n, abs(n), max(n,6)] (%i5) assume(x > 0, x < 1)$ (%i6) ceiling(x); (%o6) 1 (%i7) tex(ceiling(a)); $$\left \lceil a \right \rceil$$ |
A função ceiling
não mapeia automaticamente sobre listas ou matrizes.
Finalmente, para todas as entradas que forem manifestamente complexas, ceiling
retorna
uma forma substantiva.
Se o intervalo de uma função é um subconjunto dos inteiros, o intervalo pode ser
declarado integervalued
. Ambas as funções ceiling
e floor
podem usar essa informação; por exemplo:
(%i1) declare(f,integervalued)$ (%i2) floor(f(x)); (%o2) f(x) (%i3) ceiling(f(x) -1); (%o3) f(x)-1 |
Retorna 0 quando o predicado p avaliar para false
; retorna
1 quando o predicado avaliar para true
. Quando o predicado
avaliar para alguma coisa que não true
ou false
(unknown
),
retorna uma forma substantiva.
Exemplos:
(%i1) charfun(x<1); (%o1) charfun(x<1) (%i2) subst(x=-1,%); (%o2) 1 (%i3) e : charfun('"and"(-1 < x, x < 1))$ (%i4) [subst(x=-1,e), subst(x=0,e), subst(x=1,e)]; (%o4) [0,1,0] |
Se declare(h,commutative)
é concluída, diz ao
simplicador que h
é uma função comutativa. E.g. h(x,z,y)
irá
simplificar para h(x, y, z)
. Isto é o mesmo que symmetric
.
Retorna um operador de comparação op
(<
, <=
, >
, >=
, =
, ou #
) tal que
is (x op y)
avalia para true
;
quando ou x ou y dependendo de %i
e
x # y
, retorna notcomparable
;
Quando não existir tal operador ou
Maxima não estiver apto a determinar o operador, retorna unknown
.
Exemplos:
(%i1) compare(1,2); (%o1) < (%i2) compare(1,x); (%o2) unknown (%i3) compare(%i,%i); (%o3) = (%i4) compare(%i,%i+1); (%o4) notcomparable (%i5) compare(1/x,0); (%o5) # (%i6) compare(x,abs(x)); (%o6) <= |
A função compare
não tenta de terminar se o domínio real de
seus argumentos é não vazio; dessa forma
(%i1) compare(acos(x^2+1), acos(x^2+1) + 1); (%o1) < |
O domínio real de acos (x^2 + 1)
é vazio.
Retorna o último inteiro menor que ou igual a x onde x é numérico. fix
(como em
fixnum
) é um sinônimo disso, então fix(x)
é precisamente o mesmo.
Usado com um is
, retorna true
(ou false
) se
e somente se expr_1 e expr_2 forem iguais (ou não iguais) para todos os possíveis
valores de suas variáveis (como determinado por ratsimp
). Dessa forma
is (equal ((x + 1)^2, x^2 + 2*x + 1))
retorna true
ao passo que se x
for não associado
is ((x + 1)^2 = x^2 + 2*x + 1)
retorna false
. Note também que is(rat(0)=0)
retorna false
mas is (equal (rat(0), 0))
retorna true
.
Se uma determinação
não pode ser feita, então is (equal (a, b))
retorna uma expressão simplificada mas equivalente,
ao passo que is (a=b)
sempre retorna ou true
ou false
.
Todas as variáveis que ocorrem em expr_1 e expr_2 são presumidas serem valores reais.
A negação de equal
é notequal
.
Note que devido às regras de avaliação de expressões predicadas
(em particular pelo fato de not expr
causar a avaliação de expr),
notequal
não seja equivalente a not equal
em alguns casos.
ev (expr, pred)
é equivalente a is (expr)
.
(%i1) é (x^2 >= 2*x - 1); (%o1) true (%i2) assume (a > 1); (%o2) [a > 1] (%i3) é (log (log (a+1) + 1) > 0 and a^2 + 1 > 2*a); (%o3) true |
Quando x for um número real, retorna o maior inteiro que é menor que ou igual a x.
Se x for uma expressão constante (10 * %pi
, for exemplo),
floor
avalia x usando grandes números em ponto flutuante, e
aplica floor
ao grande número em ponto flutuante resultante. Porque floor
usa
avaliação em ponto flutuante, é possível, embora improvável,
que floor
não possa retornar um valor errôneo para entradas
constantes. Para prevenir erros, a avaliação de ponto flutuante
é concluída usando três valores para fpprec
.
Para entradas não constantes, floor
tenta retornar um valor
simplificado. Aqui está exemplos de simplificações que floor
conhece:
(%i1) floor(ceiling(x)); (%o1) ceiling(x) (%i2) floor(floor(x)); (%o2) floor(x) (%i3) declare(n,integer)$ (%i3) [floor(n), floor(abs(n)), floor(min(n,6))]; (%o4) [n,abs(n),min(n,6)] (%i4) assume(x > 0, x < 1)$ (%i5) floor(x); (%o5) 0 (%i6) tex(floor(a); $$\left \lfloor a \right \rfloor$$ |
A função floor
não mapeia automaticamente sobre listas ou matrizes.
Finalmente, para todas as entradas que forem manifestamente complexas, floor
retorna
uma forma substantiva.
Se o intervalo de uma função for um subconjunto dos inteiros, o intervalo pode ser
declarado integervalued
. Ambas as funções ceiling
e floor
podem usar essa informação; por exemplo:
(%i1) declare(f,integervalued)$ (%i2) floor(f(x)); (%o2) f(x) (%i3) ceiling(f(x) -1); (%o3) f(x)-1 |
Representa a negação de equal (expr_1, expr_2)
.
Note que pelo fato de as regras de avaliação de expressões predicadas
(em particular pelo fato de not expr
causar a avaliação de expr),
notequal
não é equivalente a not equal
em alguns casos.
Exemplos:
(%i1) equal (a, b); (%o1) equal(a, b) (%i2) maybe (equal (a, b)); (%o2) unknown (%i3) notequal (a, b); (%o3) notequal(a, b) (%i4) not equal (a, b); `macsyma' was unable to evaluate the predicate: equal(a, b) -- an error. Quitting. To debug this try debugmode(true); (%i5) maybe (notequal (a, b)); (%o5) unknown (%i6) maybe (not equal (a, b)); (%o6) unknown (%i7) assume (a > b); (%o7) [a > b] (%i8) equal (a, b); (%o8) equal(a, b) (%i9) maybe (equal (a, b)); (%o9) false (%i10) notequal (a, b); (%o10) notequal(a, b) (%i11) not equal (a, b); (%o11) true (%i12) maybe (notequal (a, b)); (%o12) true (%i13) maybe (not equal (a, b)); (%o13) true |
Como um argumento em uma chamada a ev (expr)
,
eval
causa uma avaliação extra de expr.
Veja ev
.
Retorna true
se expr for um inteiro sempre.
false
é retornado em todos os outros casos.
Um sinônimo para entier (x)
.
Similar a map
, mas fullmap
mantém mapeadas para
baixo todas as subexpressões até que os operadores principais não mais sejam os
mesmos.
fullmap
é usada pelo simplificador do
Maxima para certas manipulações de matrizes; dessa forma, Maxima algumas vezes gera
uma mensagem de erro concernente a fullmap
mesmo apesar de fullmap
não ter sido
explicitamente chamada pelo usuário.
(%i1) a + b*c$ (%i2) fullmap (g, %); (%o2) g(b) g(c) + g(a) (%i3) map (g, %th(2)); (%o3) g(b c) + g(a) |
Similar a fullmap
, mas fullmapl
somente mapeia sobre
listas e matrizes.
(%i1) fullmapl ("+", [3, [4, 5]], [[a, 1], [0, -1.5]]); (%o1) [[a + 3, 4], [4, 3.5]] |
Tenta determinar se a expr predicada (expressões que avaliam para true
ou false
) é dedutível de fatos localizados na base de dados de assume
.
Se a dedutibilidade do predicado for true
ou false
,
is
retorna true
ou false
, respectivamente.
De outra forma, o valor e retorno é controlado pelo sinalizador global prederror
.
Quando prederror
for false
, is
retorna unknown
para
um predicado que não pode ser provado ou refutado,
e reporta um erro de outra forma.
Veja também assume
, facts
, and maybe
.
Exemplos:
is
causa avaliação de predicados.
(%i1) %pi > %e; (%o1) %pi > %e (%i2) é (%pi > %e); (%o2) true |
is
tenta derivar predicados da base de dados do assume assume
.
(%i1) assume (a > b); (%o1) [a > b] (%i2) assume (b > c); (%o2) [b > c] (%i3) é (a < b); (%o3) false (%i4) é (a > c); (%o4) true (%i5) é (equal (a, c)); (%o5) false |
Se is
não puder nem prover nem refutar uma forma predicada a partir da base de dados de assume
,
o sinalizador global prederror
governa o comportamento de is
.
(%i1) assume (a > b); (%o1) [a > b] (%i2) prederror: true$ (%i3) é (a > 0); `macsyma' was unable to evaluate the predicate: a > 0 -- an error. Quitting. To debug this try debugmode(true); (%i4) prederror: false$ (%i5) é (a > 0); (%o5) unknown |
Tenta determinar se a expr predicada
é dedutível dos fatos na base de dados de assume
.
Se a dedutibilidade do predicado for true
ou false
,
maybe
retorna true
ou false
, respectivamente.
De outra forma, maybe
retorna unknown
.
maybe
é funcinalmente equivalente a is
com prederror: false
,
mas o resultado é computado sem atualmente atribuir um valor a prederror
.
Veja também assume
, facts
, and is
.
Exemplos:
(%i1) maybe (x > 0); (%o1) unknown (%i2) assume (x > 1); (%o2) [x > 1] (%i3) maybe (x > 0); (%o3) true |
Retorna o "inteiro raíz quadrada" do valor absoluto de x, que é um inteiro.
Quando L for uma lista ou um conjunto, retorna apply ('max, args (L))
. Quando L não for uma
lista ou um conjunto, sinaliza um erro.
Quando L for uma lista ou um conjunto, retorna apply ('min, args (L))
. Quando L não for uma
lista ou um conjunto, sinaliza um erro.
Retorna um valor simplificado para o máximo entre as expressões x_1 a x_n.
Quando get (trylevel, maxmin)
, for dois ou mais, max
usa a simplificação
max (e, -e) --> |e|
. Quando get (trylevel, maxmin)
for 3 ou mais, max tenta
eliminar expressões que estiverem entre dois outros argumentos; por exemplo,
max (x, 2*x, 3*x) --> max (x, 3*x)
. Para escolher o valor de trylevel
para 2, use
put (trylevel, 2, maxmin)
.
Retorna um valor simplificado para o mínimo entre as expressões x_1
through x_n
.
Quando get (trylevel, maxmin)
, for 2 ou mais, min
usa a simplificação
min (e, -e) --> -|e|
. Quando get (trylevel, maxmin)
for 3 ou mais, min
tenta
eliminar expressões que estiverem entre dois outros argumentos; por exemplo,
min (x, 2*x, 3*x) --> min (x, 3*x)
. Para escolher o valor de trylevel
para 2, use
put (trylevel, 2, maxmin)
.
Converte o polinômio p para uma representação modular
com relação ao módulo corrente que é o valor da variável
modulus
.
polymod (p, m)
especifica um módulo m para ser usado
em lugar do valor corrente de modulus
.
Veja modulus
.
Se x e y forem números reais e y for não nulo,
retorna x - y * floor(x / y)
.
Adicionalmente para todo real x, nós temos mod (x, 0) = x
. Para uma discursão da
definição mod (x, 0) = x
, veja a Seção 3.4, de "Concrete Mathematics,"
por Graham, Knuth, e Patashnik. A função mod (x, 1)
é uma função dente de serra com peródo 1 e com mod (1, 1) = 0
e
mod (0, 1) = 0
.
Para encontrar o argumento principal (um número no intervalo (-%pi, %pi]
) de um
número complexo, use a função x |-> %pi - mod (%pi - x, 2*%pi)
, onde
x é um argumento.
Quando x e y forem expressões constantes (10 * %pi
, por exemplo), mod
usa o mesmo esquema de avaliação em ponto flutuante que floor
e ceiling
usam.
Novamente, é possível, embora improvável, que mod
possa retornar um
valor errôneo nesses casos.
Para argumentos não numéricos x ou y, mod
conhece muitas regras de
simplificação:
(%i1) mod(x,0); (%o1) x (%i2) mod(a*x,a*y); (%o2) a*mod(x,y) (%i3) mod(0,x); (%o3) 0 |
é true
se expr for um inteiro ímpar.
false
é retornado em todos os outros casos.
Como um argumento em uma chamada a ev (expr)
,
pred
faz com que predicados (expressões que avaliam para true
ou false
) sejam avaliados.
Veja ev
.
Um objeto de estado randômico representa o estado do gerador de números randômicos (aleatórios). O estado compreende 627 palavras de 32 bits.
make_random_state (n)
retorna um novo objeto de estado randômico
criado de um valor inteiro semente igual a n modulo 2^32.
n pode ser negativo.
make_random_state (s)
retorna uma copia do estado randômico s.
make_random_state (true)
retorna um novo objeto de estado randômico,
usando a hora corrente do relógio do computador como semente.
make_random_state (false)
retorna uma cópia do estado corrente
do gerador de números randômicos.
Copia s para o estado do gerador de números randômicos.
set_random_state
sempre retorna done
.
Retorna um número pseudorandômico. Se x é um inteiro, random (x)
retorna um
inteiro de 0 a x - 1
inclusive. Se x for um número em ponto flutuante,
random (x)
retorna um número não negativo em ponto flutuante menor que x.
random
reclama com um erro se x não for nem um inteiro nem um número em ponto flutuante,
ou se x não for positivo.
As funções make_random_state
e set_random_state
mantém o estado do gerador de números randômicos.
O gerador de números randômicos do Maxima é uma implementação do algorítmo de Mersenne twister MT 19937.
Exemplos:
(%i1) s1: make_random_state (654321)$ (%i2) set_random_state (s1); (%o2) done (%i3) random (1000); (%o3) 768 (%i4) random (9573684); (%o4) 7657880 (%i5) random (2^75); (%o5) 11804491615036831636390 (%i6) s2: make_random_state (false)$ (%i7) random (1.0); (%o7) .2310127244107132 (%i8) random (10.0); (%o8) 4.394553645870825 (%i9) random (100.0); (%o9) 32.28666704056853 (%i10) set_random_state (s2); (%o10) done (%i11) random (1.0); (%o11) .2310127244107132 (%i12) random (10.0); (%o12) 4.394553645870825 (%i13) random (100.0); (%o13) 32.28666704056853 |
Converte todos os números em ponto flutuante de precisão dupla e grandes números em ponto flutuante na expressão do Maxima
expr para seus exatos equivalentes racionais. Se você não estiver faminilarizado com
a representação binária de números em ponto flutuante, você pode se
surpreender que rationalize (0.1)
não seja igual a 1/10. Esse comportamento
não é especial para o Maxima - o número 1/10 tem uma representação binária
repetitiva e não terminada.
(%i1) rationalize(0.5); (%o1) 1/2 (%i2) rationalize(0.1); (%o2) 3602879701896397/36028797018963968 (%i3) fpprec : 5$ (%i4) rationalize(0.1b0); (%o4) 209715/2097152 (%i5) fpprec : 20$ (%i6) rationalize(0.1b0); (%o6) 236118324143482260685/2361183241434822606848 (%i7) rationalize(sin(0.1 * x + 5.6)); (%o7) sin((3602879701896397*x)/36028797018963968+3152519739159347/562949953421312) |
Exemplo de utilização:
unitfrac(r) := block([uf : [], q], if not(ratnump(r)) then error("The input to 'unitfrac' must be a rational number"), while r # 0 do ( uf : cons(q : 1/ceiling(1/r), uf), r : r - q), reverse(uf)); (%i2) unitfrac(9/10); (%o2) [1/2,1/3,1/15] (%i3) apply("+",%); (%o3) 9/10 (%i4) unitfrac(-9/10); (%o4) [-1,1/10] (%i5) apply("+",%); (%o5) -9/10 (%i6) unitfrac(36/37); (%o6) [1/2,1/3,1/8,1/69,1/6808] (%i7) apply("+",%); (%o7) 36/37 |
Tenta determinar o sinal de expr
a partir dos fatos na base de dados corrente. Retorna uma das
seguintes respostar: pos
(positivo), neg
(negativo), zero
, pz
(positivo ou zero), nz
(negativo ou zero), pn
(positivo ou negativo),
ou pnz
(positivo, negativo, ou zero, i.e. nada se sabe sobre o sinal da epressão).
Para um x numérico retorna 0 se x for 0, de outra forma retorna -1 ou +1 à medida que x seja menor ou maior que 0, respectivamente.
Se x não for numérico então uma forma simplificada mas equivalente é retornada.
Por exemplo, signum(-x)
fornece -signum(x)
.
Ordena a list conforme o predicado p
de dois argumentos,
tais como "<"
ou orderlessp
.
sort (list)
ordena a list conforme a ordem interna do Maxima.
list pode conter ítens numéricos ou não numéricos, ou ambos.
A raíz quadrada de x. É representada internamente por
x^(1/2)
. Veja também rootscontract
.
radexpand
se true
fará com que n-ésimas raízes de fatores de um produto
que forem potências de n sejam colocados fora do radical, e.g.
sqrt(16*x^2)
retonará 4*x
somente se radexpand
for true
.
Valor padrão: true
Quando sqrtdispflag
for false
,
faz com que sqrt
seja mostrado como expoente 1/2.
Faz multiplas substituições paralelas dentro de uma expressão.
A variável sublis_apply_lambda
controla a simplificação após
sublis
.
Exemplo:
(%i1) sublis ([a=b, b=a], sin(a) + cos(b)); (%o1) sin(b) + cos(a) |
Retorna a lista de elementos da list da qual o
predicado p
retornar true
.
Exemplo:
(%i1) L: [1, 2, 3, 4, 5, 6]$ (%i2) sublist (L, evenp); (%o2) [2, 4, 6] |
Valor padrão: true
- controla se os substitutos de
lambda
são aplicados na simplificação após as sublis
serem usadas ou
se você tem que fazer um ev
para pegar coisas para aplicar. true
significa faça a
aplicação.
Substitue a por b em c. b deve ser um átomo ou uma
subexpressão completa de c. Por exemplo, x+y+z
é uma subexpressão
completa de 2*(x+y+z)/w
enquanto x+y
não é. Quando b não tem
essas características, pode-se algumas vezes usar substpart
ou ratsubst
(veja abaixo). Alternativamente, se b for da forma de e/f
então se poderá
usar subst (a*f, e, c)
enquanto se b for da forma e^(1/f)
então se poderá
usar subst (a^f, e, c)
. O comando subst
também discerne o x^y
de x^-y
de modo que subst (a, sqrt(x), 1/sqrt(x))
retorna 1/a
. a e b podem também ser
operadores de uma expressão contida entre aspas duplas "
ou eles podem ser nomes de
função. Se se desejar substituir por uma variável independente em
formas derivadas então a função at
(veja abaixo) poderá ser usada.
subst
é um álias para substitute
.
subst (eq_1, expr)
ou subst ([eq_1, ..., eq_k], expr)
são outras formas
permitidas. As eq_i são equações indicando substituições a serem feitas.
Para cada equação, o lado direito será substituído pelo lado esquerdo na
expressão expr.
exptsubst
se true
permite que substituições
como y
por %e^x
em %e^(a*x)
ocorram.
Quando opsubst
for false
,
subst
tentará substituir dentro do operador de uma expressão.
E.g. (opsubst: false, subst (x^2, r, r+r[0]))
trabalhará.
Exemplos:
(%i1) subst (a, x+y, x + (x+y)^2 + y); 2 (%o1) y + x + a (%i2) subst (-%i, %i, a + b*%i); (%o2) a - %i b |
Para exemplos adicionais, faça example (subst)
.
Similar a substpart
, mas substinpart
trabalha sobre a
representação interna de expr.
(%i1) x . 'diff (f(x), x, 2); 2 D (%o1) x . --- (f(x)) 2 dx (%i2) substinpart (d^2, %, 2); 2 (%o2) x . d (%i3) substinpart (f1, f[1](x+1), 0); (%o3) f1(x + 1) |
Se o último argumento para a função part
for uma lista de índices então
muitas subexpressões são escolhidas, cada uma correspondendo a um
índice da lista. Dessa forma
(%i1) part (x+y+z, [1, 3]); (%o1) z + x |
piece
recebe o valor da última expressão selecionada quando usando as
funções part
. É escolhida durante a execução da função e
dessa forma pode ser referenciada para a própria função como mostrado abaixo.
Se partswitch
é escolhido para true
então end
é retornado quando uma
parte selecionada de uma expressão não existir, de outra forma uma mensagem
de erro é fornecida.
(%i1) expr: 27*y^3 + 54*x*y^2 + 36*x^2*y + y + 8*x^3 + x + 1; 3 2 2 3 (%o1) 27 y + 54 x y + 36 x y + y + 8 x + x + 1 (%i2) part (expr, 2, [1, 3]); 2 (%o2) 54 y (%i3) sqrt (piece/54); (%o3) abs(y) (%i4) substpart (factor (piece), expr, [1, 2, 3, 5]); 3 (%o4) (3 y + 2 x) + y + x + 1 (%i5) expr: 1/x + y/x - 1/z; 1 y 1 (%o5) - - + - + - z x x (%i6) substpart (xthru (piece), expr, [2, 3]); y + 1 1 (%o6) ----- - - x z |
Também, escolhendo a opção inflag
para true
e chamando part
ou substpart
é
o mesmo que chamando inpart
ou substinpart
.
Substitue x para a subexpressão
selecionada pelo resto dos argumentos como em part
. Isso retorna o
novo valor de expr. x pode ser algum operador a ser substituído por um
operador de expr. Em alguns casos x precisa ser contido em aspas duplas "
(e.g. substpart ("+", a*b, 0)
retorna b + a
).
(%i1) 1/(x^2 + 2); 1 (%o1) ------ 2 x + 2 (%i2) substpart (3/2, %, 2, 1, 2); 1 (%o2) -------- 3/2 x + 2 (%i3) a*x + f (b, y); (%o3) a x + f(b, y) (%i4) substpart ("+", %, 1, 0); (%o4) x + f(b, y) + a |
Também, escolhendo a opção inflag
para true
e chamando part
ou substpart
é
o mesmo que chamando inpart
ou substinpart
.
Retorna true
se expr for uma variável subscrita, por exemplo
a[i]
.
Retorna true
se expr for um símbolo, de outra forma retorna false
.
com efeito, symbolp(x)
é equivalente ao predicado atom(x) and not numberp(x)
.
Veja também Identifiers
Disabilita a ação de alias criada pelo último uso dos comandos
de ordenação ordergreat
e orderless
. ordergreat
e orderless
não podem
ser usados mais que uma vez cada sem chamar unorder
.
Veja também ordergreat
e orderless
.
(%i1) unorder(); (%o1) [] (%i2) b*x + a^2; 2 (%o2) b x + a (%i3) ordergreat (a); (%o3) done (%i4) b*x + a^2; 2 (%o4) a + b x (%i5) %th(1) - %th(3); 2 2 (%o5) a - a (%i6) unorder(); (%o6) [a] |
Retorna o potencial do vetor de um dado
vetor de torção, no sistema de coordenadas corrente.
potentialzeroloc
tem um papel similar ao de potential
, mas a ordem dos
lados esquerdos das equações deve ser uma permutação cíclica das
variáveis de coordenadas.
Combina todos os termos de expr (o qual pode ser uma adição) sobre um
denominador comum sem produtos e somas exponenciadas
como ratsimp
faz. xthru
cancela fatores comuns no numerador e
denominador de expressões racionais mas somente se os fatores são
explícitos.
Algumas vezes é melhor usar xthru
antes de ratsimp
em uma
expressão com o objetivo de fazer com que fatores explicitos do máximo divisor comum entre o
numerador e o denominador seja cancelado simplificando dessa forma a
expressão a ser aplicado o ratsimp
.
(%i1) ((x+2)^20 - 2*y)/(x+y)^20 + (x+y)^(-19) - x/(x+y)^20; 20 1 (x + 2) - 2 y x (%o1) --------- + --------------- - --------- 19 20 20 (y + x) (y + x) (y + x) (%i2) xthru (%); 20 (x + 2) - y (%o2) ------------- 20 (y + x) |
Testa se a expressão expr na variável
v é equivalente a zero, retornando true
, false
, ou
dontknow
(não sei).
zeroequiv
Tem essas restrições:
Por exemplo
zeroequiv (sin(2*x) - 2*sin(x)*cos(x), x)
retorna
true
e zeroequiv (%e^x + x, x)
retorna false
.
Por outro lado zeroequiv (log(a*b) - log(a) - log(b), a)
retorna dontknow
devido à
presença de um parâmetro extra b
.
[ << ] | [ >> ] | [Top] | [Contents] | [Índice] | [ ? ] |
This document was generated by root on Outubro, 3 2006 using texi2html 1.76.