Curso de Maplesoftwere - Visão Geral

Prévia do material em texto

Curso de Maplesoftwere
Visão Geral
Introdução Aula 00 e Aula 01- Prof. Misael Miléo 
OBJETIVO: Aprender as características básicas, características e estrutura de linguagem do Maple.
Informações Gerais (e anti erros)
O ambiente de trabalho do Maple é chamado de planilha. Esta visão geral é um 
exemplo de uma planilha Maple. Cada planilha é dividida em seções conforme 
indicado pelos sinais de mais e menos na margem esquerda da página. Se você 
começar a digitar uma planilha, o Maple, por padrão, leva a digitação como um 
comando executável. A seta para a direita "[>" distingue seções que contêm 
alterar uma seção executável para uma seção de texto ou título clicando na linha 
que deseja alterar e, em seguida, clicando no botão T na barra de ferramentas ou 
pressionando Ctrl + t no teclado. Preferencialmente use F5 para alternar entre o 
modo texto e modo matemático.
Você pode digitar vários comandos em uma única seção, separando-os com ponto-
e-vírgula (;) e / ou dois-pontos (:). Se um ponto-e-vírgula seguir um comando, a 
saída do comando será exibida. Se um dois-pontos segue um comando, sua saída é
suprimida. Um ou outro é necessário no final de cada comando. 
Em uma seção com comandos executáveis, pressionar Shift-enter move o cursor 
para uma nova linha na mesma seção sem executar os comandos na seção. Se 
você deseja iniciar uma nova seção, você pode pressionar Ctrl + j (insere nova 
seção após a atual), Ctrl + k (insere nova seção antes da atual), ou você pode clicar 
no botão [> na barra de ferramentas Faz o mesmo que Ctrl + j).
P ara executar um comando Maple ou grupo de comandos em uma seção, coloque
o cursor em qualquer lugar na seção que contém os comandos a serem executados
e pressione Enter. Todos os comandos na seção são executados em seqüência do 
primeiro ao último. Se você deseja executar a planilha inteira, você pode 
selecionar essa opção no menu suspenso "Editar".
Em fórmulas matemáticas, use sempre o símbolo vezes (*) para a multiplicação.
Há quatro paletas disponíveis para digitar formulários matemáticos padrão em 
comandos e em texto. Estes são encontrados no menu suspenso "Visualizar".
O menu suspenso "Ajuda" é extremamente útil ao usar o Maple. Os formatos para 
comandos Maple são fornecidos com explicações de como eles funcionam, 
planilha são fornecidos.
Observações importantes
ORDEM DE EXECUÇÃO
 Execute comandos na ordem dada. Não ignore nenhuma linha de entrada Maple dentro de 
uma determinada planilha
 Como alternativa, você pode executar a planilha inteira selecionando o comando Executar 
planilha no menu suspenso Editar.
PARA PARAR UMA EXECUÇÃO
 Clique no botão STOP na barra de ferramentas.
SALVAR PLANILHA.
 Você pode salvar a qualquer momento para qualquer diretório que você escolher, e é 
sensato para salvar muitas vezes.
EXPERIMENTO DE PROBLEMAS MAIORES
Salve se for apropriado e, em seguida, desligue o Maple e inicie-o novamente.
CHAMAR A AJUDA
pressione ctr + F1 no teclado ou 
execute o comando '?' ou 
na barra de Menus clique em ajuda
ou presione alt + H e então M.
 
Comandos incorporados
Os comandos Maple consistem em uma palavra ou uma seqüência de palavras seguidas 
imediatamente (ou seja, sem espaços) por uma série de argumentos incluídos em um par de 
colchetes (). Os seguintes são exemplos.
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
restart;
sin(Pi/4);
sqrt(16);
4
abs(x);
expand((a-b)^2)/(c+d)^3;
solve(x^2=2, x);
As palavras em uma seqüência de comandos são normalmente em letras minúsculas. Os 
comandos que contêm múltiplas palavras são digitados sem espaços entre as palavras. Além disso,
não há espaço entre a palavra na seqüência de comando ou no colchete que inicia a lista de 
argumentos.
Nos primeiros quatro comandos anteriores, a lista de argumentos contém apenas um item, 
enquanto que no comando solve (), a lista de argumentos contém dois itens, a equação a ser 
resolvida e o símbolo a ser isolado na solução. Quando um comando tem mais de um 
argumento, eles são separados por vírgulas.
Listas
Outra estrutura importante no Maple é a lista. Uma lista é qualquer matriz ordenada de itens. No 
Maple, as listas são incluídas em um par de colchetes [], e os itens em uma lista são separados por
vírgulas. Os seguintes são exemplos.
[a,b,c,d];
[a, a^2, a^3, a^4];
[[1,2],[2,3],[3,4]];
A última lista consiste em três itens e cada um desses itens é uma lista de dois itens.
Uma lista de listas também pode ser considerada como uma matriz ou um vetor. O comando 
> > 
> > 
> > 
> > 
> > 
matrix () mostra uma lista de listas em forma de um matriz padrão. Cada lista dentro da 
lista é uma linha da matriz.
matrix([[1,2],[2,3],[3,4]]);
Observe que, embora a forma matrix () de uma lista a torne mais legível, este formulário não 
funcionará nos cálculos.
O comando seq () é muito útil para gerar uma lista quando você conhece uma fórmula para os 
elementos na lista, como no exemplo a seguir.
[seq(2*i,i=1..5)];
[seq(2,i=1..5)];
O primeiro argumento do comando seq () é uma fórmula que dá a cada elemento da seqüência 
dentro da lista como uma função da variável de índice, 'i'. O segundo argumento especifica que os 
elementos da seqüência devem ser gerados substituindo o índice 'i' na fórmula com os inteiros de 
1 a 5, cada um deles por sua vez.
Você pode gerar listas de listas de várias maneiras. Por exemplo, quando a fórmula para os 
elementos da lista é uma função de dois índices, você pode aninhar comandos seq ().
[seq([seq(i*j,j=-2..2)],i=1..5)];
Você pode gerar a mesma lista como essa.
[seq([-2*i,-i,0,i,2*i],i=1..5)];
Plots 2D (e paramétricos.)
Numerosos comandos de plotagem bidimensional em Maple são usados para gerar exibições 
gráficas de funções e dados. O pacote plots contém ainda mais funções de plotagem. Para tornar 
as funções de plotagem adicionais disponíveis para uso nesta planilha, carregamos o pacote de
plots na memória através do comando with().
> > 
> > with(plots):
O comando plot () é usado para representar graficamente funções da forma y = f (x).
plot(x*sin(x), x=-4*Pi..4*Pi,labels=[x,y]);
x
y
2
4
6
O primeiro argumento do comando plot () é a função de gráfico e o segundo especifica a variável 
independente, além das extremidades esquerda e direita do domínio sobre o qual você deseja 
representar graficamente a função. Os dois primeiros argumentos são necessários, mas você pode 
adicionar outras especificações opcionais, como labels = [x, y] no exemplo anterior. Opções 
adicionais são apresentadas abaixo.
Como é o caso com qualquer comando Maple, um dois-pontos (:) após um comando plot () 
suprime exibir a saída. Isso é útil quando você deseja gerar um gráfico e salvá-lo para exibir mais 
tarde, geralmente em combinação com outros gráficos. Suprimir a saída de um gráfico também 
ajuda a reduzir os requisitos de armazenamento para a planilha.
Por padrão, Maple seleciona o intervalo (limites verticais) para o gráfico. No entanto, você pode 
substituir isso especificando seus próprios limites verticais da seguinte maneira.
> > 
> > 
plot(x*sin(x), x=-4*Pi..4*Pi, y=-2..10,labels=[x,y]);
x
y
2
4
6
8
10
Você pode formatar um gráfico especificando uma grande variedade de opções após os dois 
primeiros argumentos necessários no comando plot ().
plot(x*sin(x), x=-4*Pi..4*Pi, y=-2..10, color=blue, 
thickness=2, labels=[x,y]);
> > 
> > 
x
y
2
4
6
8
10
As opções de plotagem são usadas para alterar os atributos do gráfico, como a cor e a espessura da
linha, como mostrado no exemplo anterior. As cores podem ser especificadas com um nome de 
cor como azul ou laranja (em inglês). Maple reconhece 21 nomes de cores predefinidos. 
Observação
Para cores adicionais, uma designaçãoRGB pode ser usada no lugar do nome da cor. Por 
exemplo, a cor azul pode ser designada por COLOR (RGB 0, 0, 1). Esta representação RGB 
da cor azul pode substituir a palavra azul no comando plot () precedente. Cada um dos três 
números na especificação RGB varia de 0 a 1 e representa a quantidade de vermelho, verde e 
azul, respectivamente, na cor.
Outras opções podem ser adicionadas aos comandos plot (). As vírgulas são usadas separadas, 
independentemente das opções especificadas. O comando a seguir representa três funções no 
mesmo gráfico; Cada linha é uma cor diferente, e a terceira é mais espessa.
plot([sin(x),sin(2*x),sin(3*x)], x=-Pi..Pi, color=[red,green,
blue],thickness=[0,0,3],labels=['x','y']);
> > 
> > 
> > 
x
4 2 4
y
1
Note que dentro da lista para cada opção, os atributos para os três gráficos são especificados em 
ordem do primeiro ao último como eles ocorrem na lista de funções para plotar. Por exemplo, 
na opção color=[red,green,blue] (cor = [vermelho, verde, azul]), vermelho é a cor para sen (x), 
verde é para o sen(2x) eo azul para o sen(3x).
 
O comando listplot () é usado para plotar listas onde apenas os valores de coordenadas 'y' dos 
pontos de plotagem são especificados. Por padrão, os valores de coordenadas x são tomados como
sendo 1, 2,. . . .
plotvalues:=[seq(i^2,i=0..5)];
listplot(plotvalues, style=POINT, color=COLOR(RGB,0,0,1),
labels=['i','seq_value']);
> > 
> > 
i
1 2 3 4 5 6
seq_value
0
5
10
15
20
25
Quando ambas as coordenadas dos pontos de uma lista são especificadas, o comando pointplot () 
é usado.
plotvalues:=[seq([i,sin(200.0*i)],i=0..150)];
> > 
> > 
Assim como você pode no comando plot (), você também pode especificar opções de formatação 
no comando listplot (), como mostrado nos exemplos anteriores.
Outro comando de plotagem bidimensional útil é implicitplot( ).. Você pode usar este comando 
para plotar curvas para relações matemáticas que não são funções; Isto é, eles não podem ser 
escritos na forma y = f (x). Por exemplo, você pode representar graficamente a curva + = 1 
como segue:
implicitplot(x^2+y^2=1,x=-1..1,y=-1..1,labels=[x,y]);
> > 
> > 
> > 
x
0
y
Gráficos de curvas expressas em forma paramétrica são plotados com o comando plot (). Por 
exemplo, se as coordenadas x dos pontos de uma curva são dadas por x = t cos t, e as coordenadas
y são dadas por y = t sen t, então a curva pode ser representada assim.
plot([t*cos(t), t*sin(t), t=0..8*Pi], labels=[x,y], color=
COLOR(RGB,1,0,0), thickness=3, scaling=constrained,labels=[x,
y]);
> > 
> > 
> > 
x
0 10 20
y 10
20
Plots 3D
Existem vários comandos Maple para traçar funções e dados tridimensionais. Nesta seção, 
apresentamos dois deles, e em módulos posteriores iremos introduzir mais.
O comando plot3d () é usado para plotar funções de duas variáveis independentes, isto é, funções 
da forma (x, y).
plot3d(sin(x)*cos(y), x=-Pi..Pi, y=-Pi..Pi, labels=[x,y,z], 
axes=BOXED, scaling=CONSTRAINED);
> > 
> > 
> > 
Os três primeiros argumentos do comando plot3d () são obrigatórios. Eles são: 
1) a função de grafo;
2) a primeira variável independente e seus limites para o gráfico e;
3) a segunda variável independente e seus limites.
Como é o caso com gráficos bidimensionais, você pode especificar um número de opções de 
formatação após os três primeiros argumentos no comando.
Para alterar o ponto de vista do gráfico, você pode incluir um indicador de orientação como uma 
opção no comando plot3d ().
plot3d(sin(x)*cos(y), x=-Pi..Pi, y=-Pi..Pi, labels=[x,y,z], 
axes=BOXED, scaling=CONSTRAINED, orientation=[42,84]);
> > 
> > 
> > 
Se você quiser olhar para o gráfico de diferentes pontos de vista, você pode clicar em qualquer 
lugar no gráfico e arraste o mouse. O gráfico será ajustado automaticamente para dar-lhe uma 
visão diferente.
Outra maneira de mudar a visão do enredo é definir a opção de exibição. Esta opção permite que 
você faça zoom dentro e fora da plotagem sem alterar o intervalo de plotagem.
plot3d(sin(x)*cos(y), x=-Pi..Pi, y=-Pi..Pi, labels=[x,y,z], 
axes=BOXED, scaling=CONSTRAINED, orientation=[42,84], view=
[-5..5, -5..5, -2..2]);
> > 
> > 
> > 
O segundo comando de plotagem tridimensional é spacecurve (). Você pode usar este comando 
para plotar curvas tridimensionais que são especificadas na forma paramétrica. Por exemplo, se as
coordenadas x dos pontos de uma curva são dadas por t cos t, as coordenadas y por t sen t, e as 
coordenadas z por t, então a curva pode ser representada como segue.
spacecurve([t*cos(t),t*sin(t),t], t=-4*Pi..4*Pi, labels=[x,y,
z], orientation=[-71,65], axes=boxed);
> > 
> > 
> > 
> > 
> > 
> > 
Comandos de atribuição
No Maple, os dois pontos (: =) são usados para atribuir itens (valores, listas, gráficos, etc.) aos 
nomes das variáveis. Sempre que um comando de atribuição de dois pontos é executado, o Maple 
avalia a expressão no lado direito dos dois pontos e atribui o resultado ao nome da variável no 
lado esquerdo. Se a expressão no lado direito inclui variáveis que não foram atribuídas valores, 
em seguida, Maple avalia a expressão do lado direito na medida do possível com valores que 
estão disponíveis e, em seguida, atribui a expressão resultante para a variável no lado esquerdo do
dois-pontos -é igual a. Aqui estão alguns exemplos.
restart;
x:=2;
y:=x+2;
z:=y^3+w;
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > s:=x+y+z;
No terceiro comando de atribuição, a variável w não tem valor atribuído, mas sim y. Portanto, a 
avaliação dá uma expressão em termos de w, e esta expressão é atribuída a z.
Você sempre pode verificar para ver o que foi atribuído a uma variável, digitando o nome da 
variável seguido de um ponto-e-vírgula.
x;
2
y;
4
z;
s;
Uma vez atribuído um valor ou uma expressão a uma variável, o nome da variável é substituído 
pelo valor ou expressão atribuída onde quer que seja usado em expressões subseqüentes, como 
mostrado nos exemplos a seguir.
x^2;
4
3*y^2;
48
sin(z);
O comando unassign () remove as atribuições que você fez às variáveis.
unassign('x');
Se você verificar um nome de variável após ele ter sido desatribuído, você verá que ele não é 
substituído por um valor ou expressão.
x;
x
Se você usar o nome da variável em uma expressão, ele será tratado como uma variável simples 
com nada atribuído para substituí-lo.
x+2;
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
Você pode desassignar mais de uma variável de cada vez.
unassign('x','y','z');
A redefinição de uma variável limpa automaticamente o que lhe foi atribuído anteriormente. 
Portanto, é desnecessário desassignar um nome de variável quando uma nova atribuição é feita 
para ele. O exemplo a seguir demonstra esse recurso.
a:=2;
a;
2
a:=12345;
a;
12345
É extremamente importante manter o controle de nomes de variáveis que você usa em uma sessão
do Maple. Se você usar um novo nome de variável em uma expressão ou um comando e estiver 
assumindo que está livre de atribuições, primeiro use o comando unassign () para apagar todas as 
atribuições anteriores para o novo nome da variável. A falha em fazer isso pode produzir 
resultados enganosos e confusos. Os comandos a seguir ilustram o que pode acontecer se você 
esquecer de desassignar um nome de variável antes de usá-lo. Suponha que queremos usar 's' em 
uma expressão e esquecemos que anteriormente atribuímos outra expressão a 's'.
expand((s+2)*(s-3));
Agora corrigimos o problema.
unassign('s');
expand((s+2)*(s-3));
(Legal não é?!)
Existe outro item relacionado com a questão da gestão de nomes de variáveis. Se você concluiruma planilha do Maple e desejar iniciar outro, é melhor salvar seu trabalho e, em seguida, 
executar o comando de reinício no início da nova planilha. Isso limpa todas as atribuições que 
foram feitas para variáveis. Caso contrário, as atribuições que foram feitas na planilha antiga são 
transferidas para o novo. Executar o comando restart também remove todos os pacotes que foram
previamente lidos na memória. Portanto, se você quiser usar um pacote após reiniciar o Maple, 
você precisará recarregá-lo.
Pacotes Especiais
> > 
> > 
> > 
> > 
> > 
> > 
Embora existam muitos comandos incorporados que estão disponíveis para uso assim que abrir 
uma planilha Maple, há muitos comandos mais especializados que estão contidos em pacotes. 
Esses pacotes não estão automaticamente disponíveis em uma planilha do Maple e, para usar os 
comandos especializados que eles contêm, você precisa lê-los na memória do computador. Para 
fazer isso, digite com (nome do pacote) e execute o comando. Aqui está um exemplo.
restart;
with(plottools):
Agora podemos usar o comando arrow () que está disponível depois que o pacote plottools é lido 
na memória.
for a from 2 to 8 by 2 do
 arr1:=arrow([a,0], [a,sin(a)], .1 , .2 , .1, color=green)
:
 p1:=plot(sin(x), x=0..a,labels=[x,y]):
 print(plots[display]({p1, arr1}, view=[0..8.2, -1..1]));
od:
x
1 2 3 4 5 6 7 8
y
0
1
> > 
> > 
> > 
x
1 2 3 4 5 6 7 8
y
0
1
> > 
> > 
> > 
x
1 2 3 4 5 6 7 8
y
0
1
> > 
> > 
> > 
> > 
x
1 2 3 4 5 6 7 8
y
0
1
O comando na seção anterior é um loop que cria a série de gráficos. O primeiro comando dentro 
do loop (recuado) define a seta eo segundo comando recuado define o enredo de sin x. O terceiro 
comando recuado exibe os dois objetos de plotagem, a seta e a curva, juntos. Colons após os dois 
primeiros comandos dentro do loop suprimir mostrando a seta e o gráfico até que eles são 
exibidos juntos pelo terceiro comando. O od: no final fecha o loop. A especificação no comando 
for_do_od faz com que a variável a, o limite x superior no gráfico, varie de 2 para 8 em passos de 
2.
Para descobrir quais pacotes do Maple estão disponíveis, digite? Index para abrir os arquivos de 
ajuda e selecione pacotes na lista.
Antes de usar qualquer um dos comandos especializados disponíveis em um pacote, certifique-se 
de ler primeiro o pacote. Um pacote precisa ser lido somente uma vez durante uma sessão Maple, 
a menos que você reinicie. Se você tentar executar um comando de pacote antes de ter lido no 
pacote, o comando não funcionará e você pode receber uma mensagem de erro. Você pode 
corrigir o problema lendo o pacote. Então o comando funcionará. Os comandos na seção a seguir 
ilustram o que acontece quando você tenta executar um comando de pacote antes de carregar o 
pacote e como corrigir o problema.
restart;
> > 
> > 
> > 
> > 
> > 
> > 
unassign('y');
implicitplot(y=sin(x), x=0..2*Pi, y=-1..1, filled=true);
O comando implicitplot () não funcionou.
Agora leia no pacote de parcelas.
with(plots);
Observe que todas as funções disponíveis no pacote de gráficos estão listadas. Para suprimir a 
lista de funções, use um dois-pontos no lugar do ponto-e-vírgula após o comando with ().
Agora, o comando implicitplot () funcionará.
implicitplot(9*x^2+4*y^2=36, x=-3..3, y=-4..4, filled=true);
> > 
> > 
> > 
> > 
> > 
> > 
> > 
Making Your Own Commands
Como usuário e programador em Maple, você pode projetar e construir suas próprias funções e 
comandos.
Suponha, por exemplo, que você vai usar a função repetidamente em um programa. 
Você pode desejar criar uma nova função, como ilustrado pela seguinte definição.
restart;
myfunction:=x->x^2*sin(x); 
Maple exibe a definição da nova função. A variável x é uma variável dummy que será substituída 
pela entrada real na lista de argumentos, sempre que myfunction () for chamada. Os exemplos a 
seguir ilustram como usar myfunction () depois de defini-la.
myfunction(2);
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
myfunction(2.0);
3.637189707
myfunction(r);
myfunction(a+b);
O comando built-in map () pode ser usado para aplicar uma função a cada um dos valores em uma
lista.
map(myfunction,[2,4]);
O primeiro argumento do comando map () é o nome da função a ser aplicada (sem os parênteses) 
exemplo anterior, myfunction é mapeado sobre a lista [2, 4].
Você pode criar comandos que executem mais de uma operação usando o comando proc (). Para 
criar seu próprio comando, use uma atribuição de dois pontos (: =). No lado esquerdo do: =, 
coloque o nome que deseja usar para o comando e, no lado direito, coloque o comando proc () 
lista dos comandos que você deseja que seu procedimento seja executado. O exemplo a seguir 
mostra como construir um comando chamado buildplot (). Nós queremos buildplot () para gerar 
uma lista de números decadentes, traçar a lista e retornar a lista como saída. Primeiro, lemos o 
pacote de gráficos na memória, porque buildplot () usa o comando listplot () deste pacote.
with(plots):
buildplot:=proc(n)
 local i,plotlist;
 plotlist:=[seq(0.8^(i-1), i=1..n)];
 print(listplot(plotlist, style=point, labels=[index,number]
));
 RETURN(plotlist);
end;
Em buildplot (), a lista de variáveis locais contém a variável plotlist. A criação de uma variável 
local para um comando significa que quaisquer atribuições que você fizer à variável dentro do 
procedimento não estarão disponíveis fora do procedimento. Se você digitar plotlist; Depois de 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
executar o comando buildplot (), você verá que nada foi atribuído a plotlist. Vamos verificá-lo 
abaixo, depois de executar o comando buildplot ().
Executamos nosso novo comando buildplot () da mesma forma que executaríamos qualquer outro
comando Maple.
Agora verificamos o nome da variável plotlist.
plotlist;
plotlist
No ambiente global fora do procedimento buildplot (), a lista de variáveis é clara.
O comando RETURN (plotlist) dentro do procedimento retorna a lista de valores armazenados na 
variável de lista de locais. Se você quiser salvar a lista de valores de saída para uso posterior, você
pode atribuí-la a um nome de variável, como fazemos a seguir.
decay:=buildplot(25);
index
5 10 15 20 25
number
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
Se você usar o nome da variável decay, você obterá a lista de números que buildplot () retornou 
como saída.
decay;
Elementos de Listas
Até agora, usamos colchetes [] para incluir os elementos de uma lista e colchetes () para incluir os
argumentos nos comandos do Maple. Os parênteses redondos também são usados como símbolos 
de agrupamento em expressões matemáticas, como (x + y) * (x - y), por exemplo.
Os colchetes também têm outro uso; É selecionar elementos de uma lista. Considere os exemplos 
a seguir.
odds:=[1,3,5,7,9,11,13,15];
Para selecionar o terceiro elemento de probabilidades, use uma especificação de seletor após o 
nome da lista, como segue.
odds[3];
5
O seletor no próximo exemplo seleciona uma série de valores da lista e os retorna em uma nova 
lista.
odds[2..5];
Para listas aninhadas, isto é, uma lista de listas, use vários seletores como [3, 2] para recuperar 
elementos. O primeiro número aponta para um elemento individual na lista mais externa, que 
pode ser uma lista. O segundo número aponta para um elemento dentro da lista interna. Os 
exemplos a seguir ilustram como isso funciona.
oddeven:=[[1,2],[3,4],[5,6],[7,8],[9,10]];
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
O comando a seguir recupera a quarta lista de pares par.
oddeven[4];Para recuperar o segundo elemento da terceira lista no mesmo tipo ímpar:
oddeven[3,2];
6
Usando Substituições
Em Maple, o sinal de igual (=) é usado para expressar a igualdade matemática e fazer 
substituições em comandos e / ou expressões matemáticas. Nesta seção, consideramos como o 
sinal de igual é usado para fazer substituições.
Normalmente, quando o nome de um comando é usado, os valores entre os colchetes após o nome
do comando são automaticamente substituídos pelos argumentos do comando. Esses valores são 
então usados na avaliação do procedimento do comando. O exemplo a seguir usa uma função para
mostrar como essa substituição funciona.
unassign('x','y','z');
f:=(x,y)->sin(x)^2+cos(y)^2;
f(Pi/4,Pi);
3
2
f(theta,theta);
Outra maneira de definir uma função é sem usar o símbolo de mapeamento (->). Se uma função é 
definida dessa maneira, então você precisa especificar explicitamente as substituições para fazer 
os argumentos. O próximo exemplo mostra esse tipo de definição de função e como fazer 
substituições para os argumentos usando os comandos eval () e subs ().
f:=sin(x)^2+cos(y)^2;
theta:=Pi/8;
eval(f, [x=theta, y=theta]);
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
subs([x=theta, y=theta],f);
A diferença entre o comando eval () eo comando subs () é que eval () avalia mais f depois de 
substituir x e y, enquanto que subs () não avalia f após substituição. Geralmente, o comando eval 
() é preferido.
Recuperando saída de comandos
Se você executar um comando Maple, a saída será exibida em caracteres azuis na próxima linha 
após o comando.
solve(x^2=1,x);
Digitando dois pontos (:) após a linha de comando suprimir a exibição de saída.
solve(x^2=1,x):
Você pode atribuir a saída de um comando para um nome de variável.
soln:=solve(x^2=1,x);
Para acessar uma solução individual, use um seletor de elemento de lista após o nome da variável 
à qual você atribuiu a saída.
soln[1];
1
soln[2];
Alternativamente, você pode atribuir as soluções individuais para nomes de variáveis na frente.
firstsoln:=solve(x^2=1,x)[1];
secondsoln:=solve(x^2=1,x)[2];
282/5000
Esta última abordagem não é tão eficiente como a que a precede porque requer resolver a 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
> > 
equação duas vezes, enquanto a primeira abordagem só a resolve uma vez.
Alguns comandos dão uma função como saída. Por exemplo, o seguinte comando resolve a 
equação diferencial Com a condição inicial y (0) = 0.
restart:
unassign('x,y'):
soln:=dsolve({diff(y(x),x)=sin(x),y(0)=0},y(x));
Para usar a função y (x) em outros comandos, como plot (), por exemplo, formamos uma função 
Maple a partir da saída do comando dsolve () da seguinte forma.
y:=unapply(rhs(soln),x);
plot(y(x),x=0..2*Pi,labels=['x','y']);
x
4 2 4 4 2 4
y
0
1
2
> > 
> > 
> > 
> > 
> > 
> > 
(Não perca apróxima aula!)