12.7 Procedimentos, comandos de repetição e comandos de controle para o maple - subsídios para as disciplinas Cálculo dif. e int. III e Geometria analítica II
12.7.1
Equações algébricas
Veja várias formas de obter a solução de equações algébricas:
> p:=x^5-6*x^3-7*x; # para definir o polinômio
>solve(p=0) ; # mostra as soluções reais e imaginárias
> allvalues( “);
> fsolve(p=0) ; # mostra as soluções reais;
> isolve(p=0) ; # mostra as soluções inteiras;
>readlib( realroot ): # Lê da pasta “biblioteca” função realroot
>realroot( p, 1); # Fornece intervalos que contém somente uma raiz real, os quais tem >################ amplitude igual a 1 (um).
> realroot( p, 1/1000); # intervalos com aplitude iqual a 1/1000.
12.7.2 Pontos singulares
Pontos singulares são pontos que não fazem parte do domínio
>readlib(singular):
>singular(1/x, x);
>g:=x->tan(x);
>f:=x->(4-x^2)^(1/2);
>singular( g(x) ,
x);
>singular( f(x) ,
x);
>solve(4-x^2>0);
12.7.
3 Cálculo diferencial e integral III
As funções do Maple que envolvem a área do Cálculo Diferencial e Integral podem ser utilizadas diretamente.
12.7.4 Representação de Funções
e cálculo do valor da função num ponto
Para representar uma função de uma variável a sintaxe é a seguinte:
f:= Var -> expressão em função de Var ou
f:= (Var1,Var2, ..., Varn) -> expressão em função de Var1....Varn
Exemplo:
>f2:=(x , y)-> (y+2)/(x) ; # Para funções de duas variáveis
>f3:=(x ,
y)-> 2*x-y^2 ;
>
f:=x-> exp(x+2) ;
>g:= x->sin(x);
>h(x):=x->ln(x+4);
>f2(3,1) ; # para calcular o valor da função f2 no ponto ( 3,1)
>f3(-2,5) ; # para calcular o valor da função f3 no ponto ( -2,5)
As instruções para traçar gráficos de funções estão separados em pacotes. Os gráficos podem ser de 2 ou 3 dimensões e, para ambos os casos, quando a função está na forma explícita é necessário, antes de tudo, digitar with(plots):
Para fazer o gráfico da função
>with(plots):
>plot3d ((9-
x^2-y^2)^(1/2),
x=-3..3, y= -3..3);
>implicitplot3d(x^4-13*y^2
-z +36,
x=-5..5,
y= -10..10, z=-10..10);
Tente ver as curvas de nível das funções acima.
Também se pode fazer dois ou mais gráficos de 3 dimensões numa só vez
>with(plots):
>f1:=plot3d ((9- x^2-y^2)^(1/2), x=-3..3, y= -3..3, color= red):
> f2:=plot3d(-(9- x^2-y^2)^(1/2), x=-3..3,y= -3..3, color= green):
> display3d( { f1, f2 } );
12.7.3.2 Limites de funções com duas variáveis
Para calcular limites, a sintaxe é : limit(função,{variáveis} );
>
f:=(x,y)->(2*x^2*y)/(3*x^2+3*y^2);
>limit(f(x,y),{y=0}); ##
>
limit(f(x,y),{x=0}); ##
>limit(f(x,y),{y=x,
x=0}); ##
>
limit(f(x,y),{y=x^2,
x=0} );
>limit(
limit(
sin(x^2+y^2)/(x^2+y^2),x=0
), y=0);
12.7.3.3Derivadas
Parciais
Para obter a derivada a sintaxe é :
diff(função, x); para derivada de primeira ordem, com relação a x
Por exemplo: para encontrar a derivada da função f(x,y) = (x2+y2)(1/2)
digita-se
>diff((x^2+y^2-25)^(1/2),x); # para derivar com relação a x
>diff((x^2+y^2-25)^(1/2),y); # para derivar com relação a y
>diff((x^2+y^2-25)^(1/2),x, y); # para derivar com relação a x e y
>#
ou
>f:=(x,y)->
(x^2+y^2-25)^(1/2);
>diff(f(x,y) ,
x), diff(f(x,y) ,
y), diff(f(x,y) ,
x,y);
>
diff(f(x,y) ,
x$2), diff(f(x,y) ,
y$2), diff(f(x,y) ,
x$2,y$2); # derivadas de ordem 2
Outros exemplos
>implicitdiff(x^2-x*y=2, y, x); ## onde y é uma função de x
>diff( (
> diff((
## para derivada
de ordem 3
> diff (
## para
a segunda derivada da função senx
Para obter formulas de diferenciação usa-se: >D(nome da função );
>
g: = u.v;
>D(g);
Procure mais informações no “help”
>
? diff;
>
? limit;
>? D;
12.7.3.4
Para conferir exercícios Regra da cadeia
>f:=(x,y)->(x^2*y^2);
>x:=2*t+1;
>y:=t^3;
>diff(f(x,y),
t);
>z:=x^2-y^2;
x:=u*cos(v);
y:=v*sin(u);
>diff(z,u); diff(z,v);
>restart;
>z:=(x,y)->x*y-x^2*y;
>
dz:=diff(z(x,y),
x)*dx +diff(z(x,y),y)*dy;
>
x:=1;
y:=1; dx:=0.1; dy:=0.1;
> dz;
12.7.3.6 Derivada direcional
Dada a função
e o vetor u unitário na direção
,
encontre Duf.
>f:=
(x,y)->3*x^2-y^2+4*x;
>a:=Pi/6;
>Duf:= diff(f(x,y),
x)*cos( a) + diff(f(x,y), y)*sin( a);
Dada a função
encontre o gradiente de f
no ponto (4,3), bem como a
taxa de variação da função (gradiente)
na direção
.
Duf=
.[i
cos(a) + j sin(a)] =
.[(1,0) cos(a) + (0,1) sin(a)]
(produto vetorial
Dada a função
encontre o gradiente de f
no ponto (4,3), bem como a
taxa de variação da função (derivada direcional)
na direção
.
>f:=(x,y)->x^2/16
+ y^2/9;
>Df:=diff( f(x, y),x)*i
+ diff( f(x,
y),y)*j;
# fórmula do gradiente
>a:=Pi/4;
>Duf:=diff( f(x, y),x)*cos(a)
+ diff( f(x,
y),y)*sin(a);
# fórmula da derivada direcional
>x:=4; y:=3;
>Df;
# gradiente procurado
>Duf;
>restrart: #Taxa de variação procurada
A equação do plano tangente é dado por:
Exemplo
Encontrar a equação do plano tangente a
no ponto Po(1,1,2).
>f:=(x,y,z)-> x^2+y^2-z ;
>Plano:=diff( f(xo,yo,zo)
, xo)*(x-xo) + diff( f(xo,yo,zo)
, yo)*(y-yo) + diff( f(xo,yo,zo)
, zo)*(z-zo) ;
>
xo:=1;
yo:=1; zo:=2;
> Plano=Plano;
## Resposta do
exercício
> with(plots):
# as demais instruções servem para visualização do resultado
>
implicitplot3d({f(x,y,z),Plano},x=-1..1,y=-1..1,z=-1..2,axes=BOXED);
12.7.3.9 Reta normal a uma superfície
Exemplo
Encontrar a equação do plano tangente a curva
e a reta normal a superfície no
ponto P(1,1,1).
>restart;
>f:=(x,y,z)->x^2+2*y^2+3*z^2-6; # adaptar
aqui
>y:=solve((x-xo)/(diff(f(xo,yo,zo)
,xo))=(y-yo)/(diff(f(xo,yo,zo)
, yo)),
y);
>z:=solve((x-xo)/(diff(f(xo,yo,zo)
,xo))=(z-zo)/(diff(f(xo,yo,zo)
, zo)),
z);
> xo:=1; yo:=1; zo:=1; # adaptar aqui
> [x,y,z]; # reta normal ao plano tangente no ponto (1,1,1)
12.7.3.10
Máximos e mínimos relativos
Nos
extremos relativos
e
Exemplo;
Calcular os
extremos relativos da função
>restart;
>f:=(x,y)->(-x^2-y^2+9)^(1/2);
#### Definir
a função
>
S=solve({ diff(f(x,y),x)=0 ,
diff(f(x,y),y)=0},{x,y});
>fxx:=diff(f(x,y),x$2);
>
fyy:=diff(f(x,y),y$2);
>
fxy:=diff(f(x,y),x,y);
> x:=0;y:=0; ##### Utilizar valores encontrados em S
> fxx*fyy-fxy^2; fxx; #####Analisar
sinais de fxx*fyy-fxy^2
e fxx.
> f(x,y); # é o valor de z do extremo relativo
12.7.3.11
Multiplicadores de lagrange
Exemplo
Encontre os máximos e mínimos (se houver) de
,
sujeita à restrição
>restart;
>f:=(x,y)->5*x^2+6*y^2-x*y;
#### Definir
a função f
>
g:=(x,y)->x+2*y-24;
#### Definir
a função g
>
F:=(x,y,a)->f(x,y)+a*g(x,y);
>
eq1:= diff(F(x,y,a),x);
>
eq2:= diff(F(x,y,a),y);
>
eq3:= diff(F(x,y,a),a);
>S:=solve(
{eq1=0,
eq2=0,eq3=0},{x,y,a});
>fxx:=diff(f(x,y),x$2);
>
fyy:=diff(f(x,y),y$2);
>
fxy:=diff(f(x,y),x,y);
> x:=6; y:=9; a:=-51 ; ##### Utilizar valores encontrados em S
> fxx*fyy-fxy^2; fxx; #####Analisar
sinais de fxx*fyy-fxy^2
e fxx.
>F(x,y,a); # valor de f maximizada pelo multiplicador de Lagrange (se houver)
13 GEOMETRIA ANALÍTICA NO ESPAÇO R3
13.1 Visualização dos planos X0Y, X0Z, Y0Z
>with(plots):
> coordplot3d(rectangular): ## ou
>implicitplot({x=0,y=0,z=0} , x= -10... 10, y= -10... 10, z= -10... 10);
Para visualizar o ponto P(1,2,3) pode-se utilizar os seguintes comandos:
>
with(plots):
>P:=textplot3d([
1,2,3,
`P(1,2,3)` ] , align = RIGHT, axes=BOXED);
Para visualizar as projeções do ponto P(1,2,3) sobre os plano, bem como a projeção destes últimos sobre os eixos coordenados pode-se digitar o que segue:
>
P:=textplot3d({[0, 0, 2,`0Z`],[0.75,
0, 0.5,`0X`],[0, 1, 0.5,`0Y`]},align =
BELOW);
>
P0:=textplot3d([1,2,3,`P(1,2,3)`],align =
RIGHT, axes=BOXED);
>
P1:=textplot3d([1,2,0,`P(1,2,0)`],align=RIGHT);
>
P2:=textplot3d([1,0,3,`P(1,0,3)`],align =
RIGHT);
>
P3:=textplot3d([0,2,3,`P(0,2,3)`],align =
RIGHT);
>
P4:=textplot3d([0,0,3,`P(0,0,3)`],align =
RIGHT);
>
P5:=textplot3d([0,2,0,`P(0,2,0)`],align =
RIGHT);
>
P6:=textplot3d([1,0,0,`P(1,0,0)`],align =
RIGHT);
>
P7:=textplot3d([0,0,0,`P(0,0,0)`])
>
display3d([P0,P1,P2,P3,P4,P5,P6,P7,P]);
Com os comandos with(plots): e textplot3d( [x,y,z] , `(x,y,x)` , axes=BOXED ); podem ser resolvidos e visualizados pontos no plano, desde que x,y,z sejam subtituídos pelas respectivas coordenados do ponto. (Exercios de 1 a 4 da apostila de Geometria Analítica II, elaborada pelo professor Francisco Egger).
Tente utilizar os comandos a seguir para para visualizar o ponto P(1,2,3) no espaço.
>restart;
>with(plottools): with(plots):
# Para abrir o
pacote para desenhos e gráficos
> P := point( [1,2,3] ) : # Para definir o ponto P(1,2,3)
> display3d ( P , axes=boxed);
# Para mostrar o ponto P
13.2 Visualização de um segmento que liga dois pontos em R3
Para visualizar o segmento r de extremidades A(0,0,0) e P(2,4,8) e os segmentos que se encontram no ponto médio PM( 1, 2, 4) pode-se executar as seguintes instruções:
>with(plottools):
with(plots): # Abre
pacotes para gráficos
>r := line( [0,0,0], [2,4,8]) : # define o segmento r com extremos A(0,0,0) e P(2,4,8)
> display (r);
# mostra r no espaço
>######### Ponto médio
>P:=point([ 1,2,4 ]
, color=red) : # define
P com cor
vermelha
>s1:=
line( [0,0,0], [ 1,2,4 ]
, color=blue) : # define s1 com
cor azul
>s2:=
line( [ 1,2,4 ], [2,4,8]
,color=green) : # #
define s1 verde
> display( { P, s1, s2} ) ; # mostra
Exemplo :Distância entre dois pontos
Para encontrar a distância entre os pontos A(x1,y1,z1) e B(x2,y2,z2) pode-se digitar o que segue:
>restart;
>dAB:=(
(x1-x2)^2 + (y1-y2)^2 + (z1-z2)^2 ) ^(1/2);
>x1:=2;
y1:=5; z1:=3;
x2:=-3; y2:=2;
z2:=1;
# coordenadas dos pontos
>dAB;
>####### outro modo ################
>with(student):
>distance([2,5,3],[-3,2,1])
;
Obs. sort([3,6,9,1,3]); #ordena os elementos entre as chaves;
Obs: Os demais procedimentos estão gravados na pasta da Geometria An II - Grave-os em teu disquete.
14-Procedimentos
Os procedimentos do aplicativo matemático tem o objetivo de executar algoritmos bem definidos. Pode-se identificar 5 partes distintas num procedimento que são:
1) nome do procedimento e indicação da ordem dos parâmetros de entrada. >nome:=proc(x,y,z)
2) declaração da abrangência das variáveis do procedimento; >local x, i ; global k ;
3) instruções para desenvolver o algoritmo; >... ( comandos) ;
4) indicar o fim do procedimento; >end:
5) utilização ou execução do procedimento >nome(5, 3,z)
Exemplo 1
Vamos elaborar um procedimento para determinar o termo desconhecido do teorema de Pitágoras
a2 = b2 + c2 onde a é a hipotenusa, b e c os catetos de um triângulo retângulo.
Para ter mais certeza do sucesso do funcionamento correto do procedimento, sugere-se que sejam seguidos os seguintes passos:
I-Elaborar um problema que pode ser resolvido com o procedimento que se quer criar.
II-Resolver este problema registrando todas as etapas.
III- escrever o algoritmo que contém todas as etapas necessárias para a resolução.
IV - escrever o procedimento com os comandos do Maple
Vamos seguir as 4 etapas citadas acima para depois criar o procedimento no Maple
I - Problema: Calcular a medida de um cateto de um triângulo retângulo sabendo-se que a medida da hipotenusa é 5m e o cateto conhecido mede 3m.
II - Já existe uma fórmula a ser utilizada: a2 = b2 + c2
a) Substituir os valores conhecidos na fórmula e resolver a equação que surgir
( considera-se
somente os resultados positivos)
b) O valor de c é 4 m.
III - Algoritmo do procedimento :
a)substituir os termos conhecidos
b)resolver a equação com relação ao termo desconhecido
c) escrever a resposta
IV - Escrever o procedimento para o Maple segundo as 5 partes
>pitagoras:=proc( a,b,c ) # parte 1
>local x; # parte 2
>x:=solve( a^2=b^2+c^2);
# parte3
>print( ` A resposta é ` ), print( evalf(x) ) ; # parte 3
>end: # parte 4
>pitagoras(5,4,c); # parte 5
Seguem explicações mais gerais sobre os procedimentos com o Maple:
Nos procedimentos, a primeira linha deve ter a seguinte forma:
>
dAB:=proc(
xa, ya, xb, yb )
#parte 1
onde dAB é o nome do procedimento, proc é comando próprio do Maple. Entre parênteses aparecem as variáveis de entrada, no caso, xa, ya, xb, yb.
A segunda e a terceira linhas estão destinadas para a definição das variáveis que serão utilizadas no procedimento em local e/ou global
>local d, a, b; ## variável utilizada durante do procedimento # parte 2
>global f; ## variável que continuará conhecida após a conclusão do procedimento
A partir da quarta linha iniciam as instruções para que o procedimento se destina.
>d:=( (xa-xb)^2 + (ya-yb)^2 ) ^(1/2); # definindo a distância #parte 3
>a:=(xa-xb)/(ya-yb) ; # calculando o coeficiente angular;
>b:= yb - a * xb ;
>f:=a*x+b; print(y=f); # definindo a equação de reta;
>with(plots): # abrindo o pacote gráfico
>plot(f, x=-10..10) ; # fazendo o gráfico da reta;
A última linha terá que ser:
>end; ## para indicar o fim do procedimento # parte 4
Para executar o procedimento para os pontos A( 1,3) e B(0,6) digita-se :
> dAB
( 1, 3, 0,
6
);
# parte 5
>f ; # para verificar se f continua conhecido
>a;
Para cada um dos procedimentos que seguem, invente outro que envolva um conteúdo que
é de seu total domínio.
Estes procedimentos deverão ser gravados em disquete
para serem incluídos no relatório do teu grupo.
Procedimento envolvendo juros simples determinando juros ou capital ou taxa, ou tempo
>juros:=proc(j, c,
i,
t)
>solve(
j=c*i*t/100 );
>end:
Para executar o procedimento definido como juros digita-se :
>juros( j, 100.00, 2, 3); ## para obtenção do valor dos juros;
>juros( 6.00, c , 2, 3); ## para obtenção do valor do capital aplicado;
>juros( 6, 100.00, i, 3); ## para obtenção da taxa;
>juros( 6, 100.00 , 2, t); ## para obtenção do tempo de aplicação
Sugestão para procedimento elaborado pelo grupo - Usar juros compostos
O procedimento a seguir faz a tradução de alguns comandos do Maple para o português :
>
traduz:= proc( ) #
O nome do procedimento é traduz.
>
# O vazio entre parênteses indica que não tem parâmetros de
entrada
>alias(
sen=sin , tg
= tan, grafico=plot, raiz=sqtr);
# instruções do
procedimento
>end:
#
Indica fim do proc.
>
########### para executar
este procedimento digita-se
>
traduz( ); #após
a execução deste proc. é possível utilizar sen
em vez de sin , tg em vez de tan etc.#
>sen(45/180*Pi); tg(Pi/4);
O
procedimento a seguir é uma forma de calcular as raízes reais ou
imaginárias de uma equação do segundo grau da forma
,
com declaração de variáveis locais e globais.
>Baskara:=proc(a
, b, c)
#
O nome do proc. é pitagoras
e os parâmetros de entrada a,
b e c
>local
x1;
# Declaração de variáveis
locais – conhecidas somente durante a execução do proc.
>global
x2;
# Declaração de variáveis
globais – conhecidas também após a execução do proc.
>x1:=(
-b + (b^2- 4*a*c)^(1/2) ) / ( 2*a) ;
# instruções do proc.
: cálculo de x1
>x2:=
(-b - (b^2-4*a*c)^(1/2) ) / ( 2*a) ; #
instruções do proc. : cálculo
de x2
>print ( `
O valor de x1 é ` , x1
,
` O valor de x2 é ` ,
x2 )
; # imprimindo o resultado
>end: # Indica fim do proc.
>######## Para executar este procedimento se a=1, b=-5 e c=6 digita-se:
>Baskara( 1 ,
-5 , 6
) ;
14. 1 Comandos de repetição
Exemplo de proc. incluindo comandos de repetição para
fazer uma tabela da função
>f:= -> x ^2 –5*x + 6 ; # Definindo a função f fora do procedimento.
>Tabela:=proc(Li , Dx, n ) # O nome do proc. é Tabela e os parâmetros de entrada li, dx e n.
> local i , x , y ; global f ; # Declaração de variáveis locais e globais.
>
y:=f(x); x:= Li;
# Definindo y e o valor
inicial para x.
> print
( ` x
`, y
) ;
# imprimindo
a letra x e a função y a
na tela.
> for i to n do # Para i até n faça :
> print( x, y ); # imprimindo os valores de x de y na tela.
> x:=x+Dx; # atribuindo à variável x o valor antigo de x + Dx .
>
od;
# indicando o fim do faça.
>end: #
indicando o fim do procedimento
# Para fazer a tabela , quando o limite inferior da tabela é –5, variando x em 0,5 e para 20 linhas da tabela.
>Tabela(-5 , 0.5 , 20);
Exemplo de procedimento envolvendo área e perímetro de n quadrados de lados medindo de la até n x la, onde n é um numero inteiro e la um número real qualquer.
>areaperi:=proc( n, la) # Parte 1
>local A,
P, i,
l; #
Parte 2 -
declaração das variáveis
>print( ` lado,
Perímetro,
Área` );
# Parte 3 - print-> imprimir na tela
>for i to
n do
# Parte 3 Para
i até
n faça
>l:=la*i;
>A:=(l)^2;
>P:=4*(l);
>print( l, P,
A);
>od; # Parte 3 Fim do Faça
>end: # Parte 4 Fim do procedimento
>areaperi(10,1); areaperi(5,1); areaperi(5,10); # Para utilizar o procedimento
Sugestão para procedimento: Área e perímetro de um triângulo equilátero de lado L
fórmula Área=(base
x altura)/2 ,
onde altura do triângulo equilátero é
(lado x
)
Exemplo de procedimento envolvendo área e comprimento de circunferência
>areacirc:=proc( n, raio)
>local A,
C, i;
>print( ` raio,
Comprimento,
Área`
);
>for i to
n do
>C:=2*Pi*raio;
>A:=Pi*(raio)^2;
>print( raio, C,
A);
>od;
>end:
> areacirc(10,1); areacirc(5,1); areacirc(5,10); # Para utilizar o procedimento
Sugestão: Volume do cilíndro e área lateral. As fórmulas envolvidas são
V=Abase x altura, onde Abase é a área da base ou seja, é a área do círculo.
AL= C x altura, onde C é o comprimento da circunferência da base.
Tabela com valores de funções
>tabela:=proc(li,dx,n)
>local
f, x,
i ;
>f:=x->evalf( sin( x/180*Pi), 6 ) ;
>for i to n
do
>x:=li +
(i -1)* dx;
>print( x, f(x));
>od;
>end:
Sugestão: Faça a tabela de outra função:
Pode-se salvar os procedimentos para abrí-los quando convier.
Através do “help” , se pode aprofundar o estudo sobre o aplicativo.
Faça um estudo utilizando o “help” conhecer a sintaxe das estruturas de controle for, while, if, else utilizando comandos com a seguinte notação:
>
?for;
>?
while;
>?
if;
Através do “help” , se pode aprofundar o estudo sobre o aplicativo.
Faça um estudo utilizando o “help” conhecer a sintaxe das estruturas de controle for, while, if, else utilizando comandos com a seguinte notação:
>
?for;
>?
while;
>?
if;
 |
Segue procedimento que serve para determinar uma raiz aproximada de uma função após encontrar um intervalo [a, b] que contém somente uma raiz real da função dada.
>
newton:=proc(erro,a,b)
>
local f,x,df2,df1,p1,p2,xn,i,c,y1,y2;
>
with(plots):
> f:=x->evalf(x^3-3/2*x*x-9/4*x+135/40); ## escreva aqui a equação
>
df1:=D(f);
>
df2:= D(D(f));
>
xn:=a:
>
i:=0;
>
if f(xn)*df2(xn)>0 then xn:=a;else xn:=b; fi:
>
c:=xn;
>
print(`
Início: x=`,xn,`f(x)=`,f(xn),`df2(x)=`,df2(xn),
`f(x).df2(x)=`,df2(xn)*f(xn)
);
> while abs( f(xn)) >erro do
> xn:=xn-f(xn)/df1(xn);
>
i:=i+1:
>
print(`x`,i,`=`,xn,` f(xn)=`,f(xn));
> od:
> print(`número de iteraçãos :`,i);
>
y1:=plot(df1(c)*(x-c)+f(c),x=a..b):
>
y2:=plot(f(x),x=a..b):
>
display({y1,y2});
> end: # fim do procedimento
>## para executar o procedimento digite:
# > newton( valor do erro, a, b);
# onde “a” e “b” são os valores que correspondem aos extremos do intervalo onde
# há somente uma raiz real da função dada.
> newton(0.001, -2 ,0 );
Distância entre 2 pontos em R3.
>distan:=proc(
x1,
y1,z1,x2,y2,z2)
# Parte 1
>local
d ; #
Parte 2
>d:=(
(x1-x2)^2+ (y1-y2)^2 +
(z1-z2)^2 )^(1/2) ;
# Parte 3
>end: # Parte 4
distan(1, 2, 3, 2, 7.0 ,0); # Para executar o procedimento
Sugestão: Utilizar fórmulas conhecidas pelo grupo
Procedimento envolvendo o preço de um produto desde uma unidade de referência até 10
> valor:=proc(PreU)
>local i;
>for i from 1 to 10
by 2 do
>print(
i , `custam `,
i*PreU);
>od:
>end:
>valor( 1.40) ; ## para obter tabela cujo preço unitário é R$ 1,40
Sugestão: Envolver problema prático simples.
Procedimentos para obtenção de fórmulas
Obtenção da fórmula para o cálculo de parâmetros a e b da reta y= ax+b pelo método dos mínimos quadrados:
>f:={a,b}->sum('(y[k]-a*x[k]-b)^2','k'=1..n);
>eq1:=simplify(diff(f(a,b),a));
>eq2:=simplify(diff(f(a,b),b));
>simplify(solve(eq2,b));
>simplify(solve({eq1,eq2},{b,a}));
Sugestão: Obter uma fórmula trabalhada em alguma disciplina em curso.
14.2 Comandos de decisão:
O procedimento a seguir serve para verificar se três medidas dadas podem ser lados de um triângulo .
Problema modelo:
1) Verifique se 1, 2 e 4 podem ser medidas de lados de um triângulo.
Podemos tentar fazer o desenho deste triângulo e se pode constatar que não é possível, pois a soma dos lados menores não é maior que o lado maior. O suposto “triângulo “ não fecha.
1)Verifique se 2, 3 e 4 podem ser medidas de lados de um triângulo.
Resolvendo
o problema genericamente
Para que três medidas possam ser de lados de um triângulo, é preciso que a soma das medidas dos lados menores seja maior que o lado maior. Se as soma das medidas dos lados menores for menor que a medida do lado maior, então as medidas informados não são lados de um triângulo ;
algoritmo ( escrever os passos para resolver o problema da classificação)
1) início;
2) entrar com três lados: l1, l2 e l3;
3) ordenar os lados armazenando em L1 0 lado menor, em L2 o lado médio e em L3 o maior;
4) se L1+L2 > L3 então escreva “ Os números fornecidos podem ser medidas de lados um triângulo”
senão escreva “ Os números fornecidos não podem ser medidas de lados um triângulo”
5)fim
Procedimento para
o Maple
>triangulo:=proc( l1,l2,l3)
>local
L;
>
L:=sort([l1,l2,l3])
;
> print(L[1],L[2],L[3])
;
>
if L[1]+L[2]>L[3] then
> print(`As medidas podem ser de um triângulo`);
> else
> print( `As medidas não podem ser de um triângulo` );
> fi;
> end;
> triangulo( 1,2,4);
triangulo( 2,3,4);
triangulo( 2,2,2);
triangulo( 2,2,3);
# para executar
Procedimento para o Maple que verifica se, dadas três medidas, estas podem ser de lados de um triângulo retângulo.
>TrianguloR:=proc( l1,l2,l3)
>local
L;
>
L:=sort([l1,l2,l3]);
>
print(L[1],L[2],L[3]);
>if
L[1]^2+L[2]^2=L[3]^2
then
> print(`As medidas são de um triângulo retângulo`);
> else
> print(`As medidas não são de um triângulo retângulo`);
>fi;
> end;
>TrianguloR( 1,2,4);
TrianguloR( 3,4,5);
TrianguloR
; TrianguloR( 3,3,3);
Procedimento que verifica se, dadas três medidas, estas podem ser de lados de um triângulo Obtusângulo
>TrianguloO:=proc( l1,l2,l3)
>
local L;
>
L:=sort([l1,l2,l3]);
>
print(L[1],L[2],L[3]);
>
if L[1]^2+L[2]^2<L[3]^2 and
L[1]+L[2]>L[3] then
> print(`As medidas podem ser de um triângulo obtusângulo`);
> else print(`As medidas não são de um triângulo obtusângulo`);
>fi;
>end;
>TrianguloO(
1,2,4);
TrianguloO( 1,2,4);
TrianguloO( 1,2,4);
Procedimento que verifica se, dadas três medidas, estas podem ser de lados de um triângulo >Acutângulo
>TrianguloA:=proc( l1,l2,l3)
>
local L;
>
L:=sort([l1,l2,l3]);
>
print(L[1],L[2],L[3]);
>
if L[1]^2+L[2]^2>L[3]^2
then
> print(`As medidas podem ser de um triângulo acutângulo`);
> else print(`As medidas não são de um triângulo acutângulo`);
> fi;
> end:
> TrianguloA(1,2,4); TrianguloA(2,2,3); TrianguloA(2,3,3); TrianguloA(5,5,5);
O procedimento a seguir serve para classificar um triângulo quanto aos lados ( eqüilátero, isósceles, escaleno).
Resolvendo
o problema da classificação
genericamente
a) Para que três medidas possam ser de lados de um triângulo, é preciso que a soma das medidas dos lados menores seja maior que o lado maior. Se as soma das medidas dos lados menores for menor que a medida do lado maior, então as medidas informados não são lados de um triângulo ;
b)O triângulo será classificado como:
b1)equilátero se tiver os três lados iguais ;
b2)isósceles se tiver dois lados iguais e um diferente;
b3)escaleno se tiver os três lados deferentes .
algoritmo ( escrever os passos para resolver o problema da classificação)
1) início;
2) entrar com três lados: l1, l2 e l3;
3) ordenar os lados armazenando em L1 0 lado menor, em L2 o lado médio e em L3 o maior;
4) se L1+L2 < L3 então escrever “os lados não formam um triângulo”,
senão continuar a investigação verificando
se l1=l2 e l2=l3, então escrever “ o triângulo é equilátero”,
senão verificar
se l1=l2 e l1¹l3, ou l2=l3 e l1 ¹l3, ou l1=l3 e l2¹l1 então escrever “ o triângulo é isósceles”,
senão verificar
se l1¹l2 , l2¹l3 e l1¹l3 então escrever “o triângulo é escaleno”
5) fim
Procedimento do Maple
clastrilado := proc (l1, l2, l3)
local L;
L := sort([l1, l2, l3]); # coloca os lados em ordem crescente e armazena no vetor L de 3 componentes
if L[1]+L[2] <= L[3] then
print(` Estes lados não
são de um triângulo `)
;
else
if l1 = l2 and l1 =
l3 then print(`O triângulo
é equilátero `) ;
else
if l1 =
l2 and l1 <> l3 or l1 =
l3 and l1 <> l2 or l2 =
l3 and l1 <> l2 then print(`O
triângulo é isósceles `)
;
else
if l1 <> l2 and l1
<> l3 and l2 <> l3 then
print(`O triângulo é escaleno`)
;
fi;
fi;
fi;
fi
;
end :
# seguem os
significados
se -> if; senão ->
else; e-> and; ou->
or; então
-> then , ordene-> sort;
clastrilado(1,2,3);
clastrilado(4,2,3);
clastrilado(2,2,3); clastrilado(2,2,2);
14.3 Recursividade
O procedimento a seguir mostra os pares ordenados de uma função a partir da entrada do limite inferior a , um incremento dx e a tolerância para erro para encontrar a raíz da função f que está colocada na quarta linha do procedimento e que pode ser alterada.
>recursivo:=proc(a,dx,erro)
>global
f;
>local
x,i;
>f:=x->evalf( x - cos(x) ); ### coloque aquí a função para encontrar as raízes
>x1:=evalf(a); Dx:=
dx;
>
for i to 10 do
>
print(x1, f(x1));
>
x1:=x1+evalf(dx);
>
x2:=x1+evalf(dx);
>
if f(x1)*f(x2)<0 then
print(x2,f(x2));
> print(`existe uma raíz entre `,x1=f(x1),x2=f(x2) ); fi;
>
if abs(f(x1))=0 then print(x2,f(x2)); print(` uma
raíz é `,
x2); fi;
>
if abs(f(x1))<erro then print(x2,f(x2));
print(`uma raíz apriximada
é `,x1); fi;
>
if f(x1)*f(x2)<0 and dx>erro
then Dx:=Dx/10;recursivo(x1,Dx,erro);fi;
> od;
> end:
>
Procedimentos
aplicados a Geometria Analítica
II
Procedimento para cálculo da distância entre dois pontos em R3.
>dAB:=proc(x1,y1,z1,x2,y2,z2)
>local d; # declaração das variáveis
> d:=( (x1-x2)^2 + (y1-y2)^2 + (z1-z2)^2 ) ^(1/2); # cálculo da distância
> print(`a distância é `,evalf(d,5) ,`unidades de comprimento `); # imprime na tela
>end:
>dAB(2,5,3,-3,2,1); # executando o procedimento
Procedimento para o cálculo da área, dados os vértices de um triângulo em R3
>AreaTri:= proc(x1,y1,z1,x2,y2,z2,x3,y3,z3)
>local area,p,d12,d13,d23; # declaração das variáveis
> d13:=( (x1-x3)^2 + (y1-y3)^2 + (z1-z3)^2 ) ^(1/2); # cálculo das distâncias
>
d23:=( (x3-x2)^2 + (y3-y2)^2 + (z3-z2)^2 ) ^(1/2);
>
d12:=( (x1-x2)^2 + (y1-y2)^2 + (z1-z2)^2 ) ^(1/2);
> p:=(d12+d13+d23)/2; # cálculo do semi-perimetro
>area:=(p*(p-d12)*(p-d13)*(p-d23))^(1/2); # fórmula de Heron para cálculo da área
> print(`a área mede`,evalf(area,5) ,`ua. `); # imprimindo a medida da área na tela
>end: # fim do procedimento
>Areatri(2,5,3,-3,2,1); # executando o procedimento
Procedimento para classificação de triângulo e cálculo da área, dados os vértices
>ArClaTri:=proc(x1,y1,z1,x2,y2,z2,x3,y3,z3)
>local area,p,v,d12,d13,d23; # declaração das variáveis
> d13:=( (x1-x3)^2 + (y1-y3)^2 + (z1-z3)^2 ) ^(1/2); # cálculo das distâncias
>
d23:=( (x3-x2)^2 + (y3-y2)^2 + (z3-z2)^2 ) ^(1/2);
>
d12:=( (x1-x2)^2 + (y1-y2)^2 + (z1-z2)^2 ) ^(1/2);
> p:=(d12+d13+d23)/2; # cálculo do semi-perimetro
>area:=(p*(p-d12)*(p-d13)*(p-d23))^(1/2); # fórmula de Heron para cálculo da área
> print(`a área mede`,evalf(area,5) ,`ua. `); # imprimindo a medida da área na tela
> # ##parte destinada a classificação do triângulo quanto aos lados
>
if ((d12=d13) and
(d12<>d23)) or
((d12=d23) and (d12<>d13))
then \
>print(`Os pontos dados são vértices de um triângulo isosceles`); fi; #
>
if
((d12=d13) and (d12=d23) then \
>print(`Os pontos dados são vértices de um triângulo equilátero `) fi;
>
if (d12<>d13) and
(d12<>d23) then \
>print(`Os pontos dados são vértices de um triângulo escaleno`) fi;
> # ##parte destinada a classificação do triângulo quanto aos ângulos internos
> v:=sort([d12,d13,d23]);# ordena em ordem cresc.e armazena em v[1],v[2],v[3]
>
if (v[1])^2+(v[2])^2=(v[3])^2
then \
> print(`O triângulo é retângulo `);fi;
>
if (v[1])^2+(v[2])^2>(v[3])^2
then \
> print(`O triângulo é obtusângulo `);fi;
>
if (v[1])^2+(v[2])^2<(v[3])^2
then \
> print(`O triângulo é acutângulo `);fi;
> end: # indicação do fim do procedimento
> ArClaTri(4,2,6,10,-2,4,-2,0,2); # para executar
Cálculo do ponto Médio e pontos que dividem um segmento numa razão dada
O procedimento a seguir serve para determinação do ponto médio P(x,y,z) entre Q(x1,y1,z1) e R(x2,y2,z2) considerando a relação QP/PR=k ,onde k=1/1 para ponto médio e ( Q__P__R )
>
PMedio:=proc(x1,y1,z1,x2,y2,z2,k) # início
> local xm,ym,zm;
>
xm:=solve(k=(x-x1)/(x2-x),x):
#
define z
>
ym:=solve(k=(y-y1)/(y2-y),y):
#
define y
> zm:=solve(k=(z-z1)/(z2-z),z): # define z
> print( ` Ponto médio: ` , [xm,ym,zm] );
> end: # fim
> PMedio(xa,ya,za,xb,yb,zb,k); # PM de A(xa,ya,za) e B(xb,yb,zb)
> PMedio(2,3,4,8,1,6,1); # PM de A(2,3,4) e B(8,1,6)
Dado o ponto
médio, calcular um dos extremos do segmento.
> #### P(x,y,z) da razão fixa QP/QR=k Q__P__R onde k=1/2
> with(plottools): with(plots):
> exer5:=proc(x1,y1,z1,xm,ym,zm)
# parte 1 - início
> local
x2,y2,z2;
#parte 2 -
declaração variav.
> x2:=solve((xm-x1)/(x2-x1 )=1/2,x2):
# define x
extremo (algoritmo)
> y2:=solve((ym-y1)/(y2-y1 )=1/2,y2): # define y
> z2:=solve((zm-z1)/(z2-z1)=1/2,z2): # define z
> print( ` extremo: `, [x2,y2,z2] ); # imprimindo o resultado
> R := point( [x2,y2,z2] ) : # Para definir o ponto R
> display3d ( R ,
axes=boxed); #
> end:
> exer5(0,0,0,1,2,4);
Obs:
Utilize estes comandos para a questão 5.( Geom
An. II )
>CentroGeo:=proc(x1,y1,z1,x2,y2,z2,x3,y3,z3)
>
local x,y,z,xy12, xy13,
xz12, xz13;
>global
yPM1,zPM1,yPM2,zPM2,yPM3,zPM3;
>
yPM1:=x->solve((x-x1)/((x2+x3)/2-x1)=(y-y1)/((y2+y3)/2-y1),y); # equação da reta
> zPM1:=x->solve((x-x1)/((x2+x3)/2-x1)=(z-z1)/((z2+z3)/2-z1),z);
>yPM2:=x->solve( (x-x2)/((x1+x3)/2-x2)=(y-y2)/((y1+y3)/2-y2),y);
>zPM2:=x->solve( (x-x2)/((x1+x3)/2-x2)=(z-z2)/((z1+z3)/2-z2),z);
>yPM3:=x->solve( (x-x3)/((x2+x1)/2-x3)=(y-y3)/((y2+y1)/2-y3),y);
>zPM3:=x->solve( (x-x3)/((x2+x1)/2-x3)=(z-z3)/((z2+z1)/2-z3),z);
>print(`equações paramétricas das medianas`);
>
print(`MP1:`,[x,yPM1(x),zPM1(x)]); >print(`MP2:`,[x,yPM2(x),zPM2(x)]);
>print(
`MP3:`,[x,yPM3(x),zPM3(x)]
);
>
xy12:=solve(yPM1(x)=yPM2(x),x);
>xy13:=solve(yPM1(x)=yPM3(x),x);
xz12:=solve(zPM1(x)=zPM2(x),x);
>xz13:=solve(zPM1(x)=zPM3(x),x);
> print(`coordenada x da intersecções das medianas MP1 e MP2 , MP1 e MP3, MP2 e MP3`):
>print(xy12, xy13, xz12, xz13); x:=xy12;
> print(`ponto de intersecção das medianas: ` ,[ x, yPM1(x), zPM1(x)], [x, yPM2(x), \ zPM2(x)], [x, yPM3(x), zPM3(x)] ); # eq3medianas
>
end:
>
CentroGeo(x1,y1,z1,x2,y2,z2,x3,y3,z3);
Outro para centro de massa definido como :É o lugar geométrico em que, a distância, de cada vértice ao ponto médio do lado oposto é 3 vezes a distância do centro de massa a esse ponto médio.
>
restart;
>
CentroMassa:=proc(x1,y1,z1,x2,y2,z2,x3,y3,z3)
>
local xCA,yCA,zCA,xCB,yCB,zCB,xCC,yCC,zCC;
>xCA:=solve((
x1-(x2+x3)/2 )/(xCA-(x2+x3)/2)=3,xCA);
>
yCA:=solve(( y1-(y2+y3)/2 )/(yCA-(y2+y3)/2)=3,yCA);
>
zCA:=solve(( z1-(z2+z3)/2 )/(zCA-(z2+z3)/2)=3,zCA);
>xCB:=solve(( x2-(x1+x3)/2 )/(xCB-(x1+x3)/2)=3,xCB);
>
yCB:=solve(( y2-(y1+y3)/2 )/(yCB-(y1+y3)/2)=3,yCB);
>
zCB:=solve(( z2-(z1+z3)/2 )/(zCB-(z1+z3)/2)=3,zCB);
>
xCC:=solve(( x3-(x2+x1)/2 )/(xCC-(x2+x1)/2)=3,xCC);
>
yCC:=solve(( y3-(y2+y1)/2 )/(yCC-(y2+y1)/2)=3,yCC);
> zCC:=solve(( z3-(z2+z1)/2 )/(zCC-(z2+z1)/2)=3,zCC);
> print(`Pontos encontrados sobre cada uma das medianas`);
> print(`Sobre a Mediama com vértice em A:`,[xCA,yCA,zCA]);
>print(`Sobre a Mediama com vértice em B:`,[xCB,yCB,zCB]);
>print(`Sobre a Mediama com vértice em C:`,[xCC,yCC,zCC]);
>
end:
>
CentroMassa(x1,y1,z1,x2,y2,z2,x3,y3,z3);
Procedimentos para conferir os exercícios 31 a 40 da disciplina de Geometria Analítica II
> ## dado um ponto, calcular os ângulo diretores
> angdir:=proc(x,y,z) # início do procedimento angdir (ângulo diretores)
>
local ax,ay,az;
>
ax:=arccos(x/(x^2+y^2+z^2)^(1/2));
>
ay:=arccos(y/(x^2+y^2+z^2)^(1/2));
>
az:=arccos(z/(x^2+y^2+z^2)^(1/2));
>
print(ax,ay,az);
> print(` Segue:`); print(`alfa em Graus ,Beta em Graus,gama em Graus `);
>
print(evalf(ax*180/Pi),evalf(ay*180/Pi),evalf(az*180/Pi));
> end: # fim do procedimento angdir (ângulo diretores)
> angdir(-6,2,3); # executando o procedimento angdir -> exercício 31
> angdir(2,-3,6); # exercício 32
> restart;
>### utilizando comandos diretos para resolver os exercícios 31 e 32 ####
> with(linalg):
> ## execício 31, utilizando comandos diretos do maple
> alpha:=angle( vector([1,0,0]), vector([-6,2,3])); em_graus=evalf(alpha*180/Pi);
> beta:=angle( vector([0,1,0]), vector([-6,2,3]) ); em_graus=evalf(beta*180/Pi);
> gama:=angle( vector([0,0,1]),vector([-6,2,3])); em_graus=evalf(gama*180/Pi);
> with(linalg):
> ## execício 32, utilizando comandos diretos do maple
> restart;
> alpha:=angle( vector([1,0,0]), vector([2,-3,6])); em_graus=evalf(alpha*180/Pi);
> beta:=angle( vector([0,1,0]), vector([2,-3,6]) ); em_graus=evalf(beta*180/Pi);
> gama:=angle( vector([0,0,1]), vector([2,-3,6]) );em_graus=evalf(gama*180/Pi);
> ##### questão 33
> S:=solve(cos(Pi/2)=cosa1*cosa2+cosb1*cosb2+cosg1*cosg2);
> S[1];
> S[2];
> S[3];
> S[4];
> #interpretar as relações acima e responder exer 33;
> ##### questão 34
> S:=solve(cos(Pi)=cosa1*cosa2+cosb1*cosb2+cosg1*cosg2);
> S[1];
> S[2];
> S[3];
> ##### o
que segue serve para questões de 35 a 40;
> restart:
> angulos:=proc(xp1,yp1,zp1,xp2,yp2,zp2,xp3,yp3,zp3,xp4,yp4,zp4) # início proc
> local S,cosr1r2,cosx1,cosy1,cosz1,cosx2,\cosy2,cosz2,Angr1r2,x1,y1,z1,x2,y2,z2;
> x1:=(xp2-xp1): y1:=(yp2-yp1): z1:=(zp2-zp1):
>
x2:=(xp4-xp3):
y2:=(yp4-yp3):
z2:=(zp4-zp3):
>
cosr1r2:=((x2*x1)+(y1*y2)+(z1*z2))/((x1^2+y1^2+z1^2)^(1/2)*(x2^2+y2^2+z2^2)^(1/2));
> Angr1r2:=arccos(cosr1r2);
>
cosx1:=x1/(x1^2+y1^2+z1^2)^(1/2);
>
cosy1:=y1/(x1^2+y1^2+z1^2)^(1/2);
>
cosx2:=x2/(x2^2+y2^2+z2^2)^(1/2);
>
cosy2:=y2/(x2^2+y2^2+z2^2)^(1/2);
>cosz1:=z1/(x1^2+y1^2+z1^2)^(1/2);
>
cosz2:=z2/(x2^2+y2^2+z2^2)^(1/2);
> S:=solve(cos(Pi/2)=cosx1*cosx2+cosy1*cosy2+cosz1*cosz2);
> print(`Ângulo
entre as retas`,
Angr1r2, `radianos
ou ,evalf(Angr1r2*180/Pi,40),`graus` );
> print(`termo k=`,S);
> end: # Fim do procedimento angulos
> # forma genérica
> angulos(xp1,yp1,zp1,xp2,yp2,zp2,xp3,yp3,zp3,xp4,yp4,zp4);
> angulos(k, 1,-1, k*2,0,2, k*2,0,2, 2+2*k,k,1); ## questão 35
> angulos(3, 1,-1, 3*2,0,2, 3*2,0,2, 2+2*3,3,1); ## ## testando resultado da questão 35
> angulos(5, 2,-3, 6,1,4, -3,-2,-1, -1,-4,13); #36 a)
> angulos(-3, 2,4, 2,5,-2, 1,-2,2, 4,2,3); #36 b)
> angulos(-11, 8,4, -1,-7,-1, -1,-7,-1, 9,-2,4); #37
> angulos(-2, 0,3, 3,10,-7, 3,10,-7, 1,6,-3); #38
> # são colineares se o ângulo entre os segmentos for 180 graus ou zero , é este o caso
> angulos(2, -1,4, -3,2,2, 2, -1,4, -3,2,2); #39
> angulos(3, -1,4, 1,2,-4, 1,2,-4, -3,2,1);#40a) AB E BC
> angulos( 1,2,-4, -3,2,1,-3,2,1,3, -1,4);#40a) BC E CA
> angulos(-3,2,1,3,-1,4,3,-1,4,1,2,-4);#40a) CA E AB;
> angulos(-1, -3,-4, 4,-2,-7,4,-2,-7, 2,3,-8);#40b) AB E BC
> angulos(4,-2,-7, 2,3,-8,2,3,-8,-1, -3,-4);#40b) BC E CA
> angulos(2,3,-8,-1, -3,-4,-1,-3,-4,4,-2,-7);#40b) CA E AB
> #Obs:
para o cálculo da área pode
ser utilizado o procedimento do problema 12 ou faça outro ou
> ?angle;
> ?distance;
> ## área
para 40 a)
>
with(student):
>
with(linalg):with(geometry):
>
areatri:=distance([3,-1,4],[-3,2,1])*distance([3,-1,4],[1,2,-4])*sin(angle([3,-1,4]
- [-3,2,1],[3,-1,4]-[1,2,-4]))/2;
>
evalf(areatri)
>
## área para 40 a)
>
AB:=distance([3,-1,4],[1,2,-4]);
>
AC:=distance([3,-1,4],[-3,2,1]);
>BC:=distance([1,2,-4],[-3,2,1]);
>
P:=(AB+AC+BC)/2;
>
Herao:=evalf( (P*(P-AB)*(P-AC)*(P-BC))^(1/2));
>
## área para 40 b)
>
with(student):with(linalg):
>
areatri:=distance([-1,-3,-4],[4,-2,-7])*distance([-1,-3,-4],[2,3,-8])*sin(angle([-1,-3,-4]-[4,-2,-7],[-1,-3,-4]-[2,3,-8]))/2;
>
evalf(");
>
## outra área para 40 b)
>
AB:=distance([-1,-3,-4],[4,-2,-7]);
>AC:=distance([-1,-3,-4],[2,3,-8]);
> BC:=distance([4,-2,-7],[2,3,-8]);
>
P:=(AB+AC+BC)/2;
>
Herao:=evalf((P*(P-AB)*(P-AC)*(P-BC))^(1/2));