Computadores no Ensino da Matemática
Mestrado em Ensino da Matemática
Ano lectivo 2000 — 2001
Aula nº1
Problema (para o qual não se espera uma solução rápida): considere-se a
seguinte construção, feita com o Geometer's Sketchpad:
Esta figura ilustra geometricamente o teorema de Cauchy: dadas duas
funções reais deriváveis f e g
de domínio [a,b], existe (pelo menos) um ponto
c do domínio tal que a recta tangente à curva
(f,g) no ponto (f(c),g(c))
seja paralela ao segmento que une (f(a),g(a)) a
(f(b),g(b)). No entanto, há um problema: se
o ponto C for «pousado» no eixo
dos xx, não aparece nenhuma tangente naquelas condições,
mas deveria aparecer uma. O problema é então o seguinte: «corrigir»
o sketch de modo a fazer com que este defeito
desapareça. Nota: Neste exemplo, tem-se:
a=0 e b=1;
f(x)=c1x+x(x–1);
g(x)=c2x+2x2(x–1),
onde c1 e c2
são, respectivamente, a abcissa e a ordenada do ponto C.
Voltar ao princípio.
Aula nº2
Nesta aula, explicou-se como fazer scripts. Encontra-se
aqui um exemplo muito simples: um
script que, dados dois pontos, constrói um quadrado
que tem aqueles dois pontos como vértices consecutivos. Este
script pode ser empregue para fazer um
sketch como o de baixo, que permite visualizar o
teorema de Pitágoras.
Voltar ao princípio.
Aula nº3
Nesta aula falou-se do uso do comando locus para construir objectos
geométricos. Esse método permite construir a parábola seguinte:
É de mencionar que esta figura, obtida com o
Java
Sketchpad, é bastante
diferente daquela que se obtém com o Geometer's Sketchpad,
que é a seguinte:
A figura seguinte, que tem um botão de animação, ilustra o teorema de Tales:
Voltar ao princípio.
Aula nº4
Nesta aula viu-se com desenhar gráficos de funções com o Geometer's
Sketchpad. No exemplo que se segue, vê-se o gráfico da função real de
variável real que, a cada x, associa
a.cos(x)+b.sen(x), onde a
e b são respectivamente a abcissa e a ordenada
de um ponto cuja posição pode ser modificada à vontade.
Esteve-se também a ver como converter sketches obtidos
com o Geometer's Sketchpad em páginas
HTML. Para que as páginas «funcionem» é
preciso que esteja colocado no mesmo directório a pasta JSP
que pode ser obtida no site do
Java
Sketchpad.
Voltar ao princípio.
Aula nº5
Nesta aula foi feito em script com o seguinte objectivo:
dados dois pontos A e B e
um número r, constrói um ponto C
do recta definida por A e por B
de modo a que
AC=rAC
se e só se r está entre 0 e 1; caso contrário,
o script não deverá produzir nada. Quando se faz um
script é desejável acrescentar-lhe uma descrição
da maneira como funciona, como no seguinte exemplo:
Registe-se que os scripts podem ser gravados em
formato texto. Aquele que foi acima descrito tem o seguinte aspecto:
Intermed.gss
Dados os pontos A e B e o número
m1, produz o ponto C do segmento
AB t. q. AC/AB=m1, desde que m1
esteja entre 0 e 1.
Given:
Point A
Point B
Measurement m1
---------------
Steps:
1. Let [l] = Segment between Point A and Point B.
2. Let [B'] = Image of Point B dilated by scale factor m1 about center Point A.
3. Let [m] = Perpendicular to Segment [l] through Point [B'].
4. Let [C] = Intersection of Segment [l] and Line [m].
O sketch que se segue ilustra a propriedade de
reflexão das parábolas: um raio luminoso perpendicular à directriz da
parábola produz, ao reflectir-se nesta, um raio que passa pelo foco.
Voltar ao princípio.
Aula nº6
Nesta aula viu-se como aproveitar o facto de o Geometer's
Sketchpad não produzir mensagens de erro quando se lhe pede
para fazer construções impossíveis (intersecção de rectas paralelas,
por exemplo). Segue-se um exemplo do uso desta propriedade; o
sketch que se segue determina o caminho
mais curto entre dois pontos A e
B que passa por uma recta dada:
Também se esteve a ver como fazer construções recursivas com o comando
LOOP, bem com criar um script a partir de
um sketch usando o comando Make Script
(ou o comand Make Recording Script).
Voltar ao princípio.
Aula nº7
Foi visto mais um exemplo de uso de um script
recursivo. Neste caso, foram construídas «curvas de perseguição» como aquela
que se pode ver ao lado.
Esteve-se também a fazer um script (que pode ser visto
aqui) que, partindo de dois pontos
A e B e de um número
n, constrói pontos espaçados regularmente
entre A e B de modo
que a distância entre dois pontos consecutivos seja a distância
entre A e B dividida
por n.
Voltar ao princípio.
Aula nº8
Recorrendo ao script mencionado na aula anterior,
esteve-se a fazer um sketch
que aproxima a área entre uma parábola com o vértice para cima e o eixo dos
xx por uma figura poligonal. O resultado pode ser visto
na figura que se segue. Devido às limitações do
Java Sketchpad não será visto o
applet correspondente.
Voltar ao princípio.
Aula nº9
Foi visto como completar o sketch da aula
anterior, acrescentando-lhe a soma das áreas dos polígonos.
Esteve-se a ver também um exemplo de um sketch
no qual se faz um gráfico associado a uma construção geométrica,
como aquele que se pode ver a seguir.
Nota: As linhas horizontais que se ver podem nos
gráficos das funções seno e cosseno não aparecem no
sketch e resultam de um bug
do Java Sketchpad.
Esteve-se também a ver como introduzir num
sketch
símbolos especiais que normalmente não podem ser obtidos directamente
a partir do teclado. Podem-se ver quatro exemplos na imagem ao lado:
as letras gregas pi e teta, uma barra horizontal colocada sobre dois
símbolos e o símbolo de raiz quadrada.
Voltar
ao princípio.
Aula nº10
Viu-se como construir a epiciclóide:
Para tal, houve dois obstáculos a ultrapassar:
Determinar como fazer com que os centros das circunferências se
movam à velocidade certa (de modo a transmitir a impressão de que a
circunferência móvel rola sem deslizar sobre a fixa). Isto é obtido
fazendo com que o botão de animação faça com que o centro da
circunferência móvel se desloque ao longo da circunferência
(invisível) que tem por centro o centro da circunferência fixa e raio
a soma dos raios das duas circunferências.
Rodear a seguinte limitação do Geometer's
Sketchpad: quando se faz uma animação de um ponto ao longo de
uma linha, esta deve estar imóvel. Para tal, é construída uma segunda
circunferência (invisível) de raio r e a
animação faz com que seja um ponto desta que se move, sendo depois
translatado para a circunferência móvel.
Também foi visto como criar «custom transformations»: são
transformações geométricas obtidas empregando apenas rotações,
translações, reflexões e dilatações. Têm a vantagem de poderem ser
gravadas e posteriormente reutilizadas fazendo Ctrl+1 para a
primeira «custom transformation», Ctrl+2 para a segunda e
assim sucessivamente.
Voltar
ao princípio.
Aula nº11
Nesta aula esteve-se a ver como construir páginas em
HTML usando o Netscape
Composer.
Texto e imagens
Foi visto como escrever texto e introduzir diversos efeitos (texto
em negrito, itálico
ou a piscar). Além disso, viu-se como ir
buscar imagens a páginas da Internet e como as introduzir num
texto. Finalmente viu-se como introduzir linhas horizontais.
Listas
Foi visto como criar três tipos de listas:
Listas numeradas:
Primeiro artigo
Segundo artigo
Listas não numeradas:
Listas de definições:
- Lista numerada
- Lista onde aparece um número à esquerda de cada artigo, começando
em 1 e aumentando uma unidade de cada vez.
- Lista não numerada
- Lista onde aparece um símbolo (sempre o mesmo, geralmente um disco
preto ou uma circunferência) à esquerda de cada artigo.
Voltar
ao princípio.
Aula nº12
Links
Esteve-se a ver como criar links a partir de páginas
HTML. Para tal, basta seleccionar a porção do texto que se
quer que seja o link, carregar no botão
link e escrever a morada da página à qual se
quer aceder.
Esteve-se também a ver como proceder para criar uma página com pontos
para os quais se pode apontar com um link; por exemplo,
no início desta página há links para o iníco do sumário
de cada aula. Uma maneira de saber se uma dada página tem passagens para as
quais se pode apontar com um link consiste em abri-la
com o Netscape Composer, procurar as ocorrências
do símbolo em forma de alvo (ou de âncora, para quem estiver a trabalhar com a
versão 6 do Netscape) e, caso haja algum no local que se pretende,
clicar com o botão direito do rato para determinar o seu nome.
Quem, por exemplo, desejar criar um link para
este sumário e seguir o processo acima indicado, irá descobrir que o
nome em questão é «aula12». Basta então criar um link
para:
http://www.fc.up.pt/mp/jcsantos/ucem0001.html#aula12
Voltar
ao princípio.
Aula nº13
Imagens de fundo
Esteve-se a ver como acrescentar uma imagem de fundo a um ficheiro
HTML. Acessoriamente, viu-se como o
Paint pode ser empregue para criar uma tal
imagem.
Inserção de imagens extraídas do monitor
Se se quer que a página que se está a criar mostre aquilo que se
pode ver numa janela aberta no monitor (tal como no sumário da
aula nº3), pode-se gravar no clipboard o aspecto dessa janela (caso esteja
activa) fazendo Alt + Print Scrn; em
seguida, basta fazer Ctrl + V no Netscape Composer para que a imagem seja
convertida num ficheiro JPEG.
Inserção de applets de Java
Foi visto como inserir num ficheiro HTML
um applet de Java
produzido pelo Java Sketchpad. Há duas
maneiras de o fazer:
Abrir com o Netscape Composer a
página HTML criada pelo
Java Sketchpad e, fazendo Copy +
Paste, passá-lo para o ficheiro que se está a
criar.
Abrir com um editor de texto a página HTML criada pelo Java
Sketchpad, seleccionar a porção de texto onde surge o applet e copiá-la para o ficheiro que se está a
criar.
Voltar
ao princípio.
Aula nº14
Nesta aula, fez-se uma introdução ao Maple.
Conceitos básicos
Qualquer instrução do Maple
deve terminar com ponto e vírgula (;) ou com dois pontos (:).
> 2+2;
> 2+2:
Em qualquer dos casos,
o Maple executa o comando; a diferença reside no facto de
o Maple só mostrar o resultado obtido se a instrução
terminar com ponto e vírgula.
O símbolo % designa o
resultado da última operação efectuada; %% designa o penúltimo e
%%% designa o antepenúltimo.
Para se atribuir um valor a uma sequência de caracteres
(abc, por exemplo)
escreve-se abc := seguido do valor pretendido. Por exemplo, para
atribuir a a o valor do último cálculo faz-se:
> a:=%;
Acessoriamente, repare-se que
isto mostra que o Maple
fez efectivamente o segundo cálculo, embora não tenha mostrado o
resultado.
> b:=2:c:=3:
> b;
> c;
Agora que a,
b e c estão
definidos, é interessante ver o que se obtém se se faz:
>
a:=b:b:=c:c:=a:
A resposta obtém-se
fazendo
>
a;b;c;
Como se pode ver, o
resultado não é uma permutação de
a, b e c.
Os nomes das variáveis não
estão de modo algum limitados a um único caracter:
>
numero:=10;
As funções definem-se do seguinte modo:
>
f:=x->x*sin(x);
Gráficos
>
plot(f(x),x=0..2*Pi);
A derivada de f representa-se
por D(f), pelo que os gráficos de
f e de
f' podem ser obtidos simultaneamente fazendo:
>
plot({f(x),D(f)(x)},x=0..2*Pi);
Se se clicar na imagem com o
botão direito do rato, obtém-se um menu que permite alterar certas
características da imagem. Também é possível descrever certas
características ao escrever o comando:
>
plot({f(x),D(f)(x)},x=0..2*Pi,color=[blue,black]);
Cálculo simbólico
Considere-se agora a função:
>
p:=x->1-x^2;
Quer-se retomar o que foi feito na aula
nº8; para tal define-se:
> a:=(k,n)->-1+2*k/n;
Então a área da região poligonal é dada por:
>
sum((p(a(k,n))+p(a(k-1,n)))/n,k=1..n);
Isto pode ser simplificado fazendo:
> simplify(%);
Voltar
ao princípio.
Aula nº15
Cálculo simbólico (continuação)
Seguem-se as últimas instruções da aula anterior
> p:=x->1-x^2;
> a:=(k,n)->-1+2*k/n;
>
sum((p(a(k,n))+p(a(k-1,n)))/n,k=1..n);
> simplify(%);
Qual é a área da região entre a parábola e o eixo dos
xx? É dada por
> int(1-x^2,x = -1 .. 1);
É de esperar que este valor seja o limite da soma das áreas das
figuras poligonais. De facto assim é, conforme se pode verificar fazendo
> limit(%%,n=infinity);
O Maple também pode ser empregue para
calcular integrais impróprios:
> int(1/x^2,x=1..infinity);
bem como primitivas
> simplify(int(1/(cos(x)^2+4*sin(x)^2),x));
Para se definir esta primitiva como uma função, faz-se
> pr:=unapply(%,x);
Isto permite «calcular» o valor do integral da função ao longo do
intervalo. De facto, obtém-se um resultado incorrecto:
> pr(2*Pi)-pr(0);
Que isto não pode estar certo, resulta de a função só tomar valores
positivos. Aliás, o seu gráfico pode ser visto fazendo
> plot(1/(cos(x)^2+4*sin(x)^2),x=0..2*Pi,view=[0..2*Pi,0..1]);
(a opção «view» é empregue para que os eixos se cruzem em (0,0)).
Repare-se que o Maple
calcula correctamente o integral em questão.
> int(1/(cos(x)^2+4*sin(x)^2),x=0..2*Pi);
Isto pode ser calculado numericamente, bastando para tal fazer
> evalf(%);
ou, caso se queira ver o resultado com (por exemplo) 30 casas decimais
> evalf(%%,30);
Muitas vezes, é preciso restringir a um determinado conjunto os
valores que uma variável pode tomar. Por exemplo, tem-se
> exp(ln(x));
mas
> ln(exp(x));
ou até
> simplify(ln(exp(x)));
Isto resulta da possibilidade de x
não ser um número real. Se se quer impor que
x seja real escreve-se
> assume(x,real);
Neste caso tem-se
> simplify(ln(exp(x)));
O ~ significa que se está a introduzir uma hipótese
sobre x. Se se quer anular essa instrução,
faz-se
> x:='x';
Resolução de equações
Considerem-se as seguintes definições:
> f:=x->x*sin(Pi*x);a:=1/2:b:=5/2:
Quer-se ilustrar o teorema de Lagrange; para tal, é preciso
determinar o ponto do intervalo [a,b] tal que o declive da recta tangente ao gráfico
de f nesse ponto seja igual ao declive do
segmento que une (a,f(a))
a (b,f(b)).
> solve(D(f)(x)=(f(b)-f(a))/(b-a),x);
O método anterior não é o mais adequado; é preferível recorrer a métodos numéricos.
> so:=(f,a,b)->fsolve(D(f)(x)=(f(b)-f(a))/(b-a),x,a..b,maxsols=1);
A última opção garante que se obtém apenas uma solução.
> so(f,a,b);
> g:=x->f(so(f,a,b))+(x-so(f,a,b))*(f(b)-f(a))/(b-a);
> plot([f(x),g(x),[[a,f(a)],[b,f(b)]]],x=a-1..b+1,color=[red,green,blue],
view=[a-1..b+1,-3..3]);
Voltar
ao princípio.
Aula nº16
Sequências e listas
Considere-se a solução da seguinte equação
> solve(x^3=x,x);
Como se pode ver, o resultado é uma sequência de valores separados por vírgulas. Mais
geralmente, considere-se a seguinte equação:
> so:=solve(x^3=x+a,x);
Se se quer saber quais são as raízes quando, por exemplo,
a=2, basta fazer
> eval(so,a=2);
Em termos numéricos, isto dá
> evalf(%);
Um problema com este tipo de respostas reside no facto de que, por vezes, se quer
apenas uma solução e não uma sequência delas (tal como na ilustração do teorema de Lagrange).
Para obter isso, é conveniente considerar um objecto básico do
Maple: as listas. São sequêncas de expressões enquadradas por
parêntesis rectos. Por exemplo:
> lista:=[1,2,4,8,16];
Um elemento de uma lista (o terceiro, por exemplo) pode ser obtido fazendo
> lista[3];
e o número total de elementos de uma lista obtém-se com
> nops(lista);
Por exemplo, a soma dos elementos da lista anterior pode ser obtida fazendo
> sum(lista[i],i=1..nops(lista));
Isto pode ser sistematizado, definindo a função:
> soma:=l->sum(l[k],k=1..nops(l));
> soma(lista);
Registe-se que existe um comando para produzir sequências:
> seq(2^n,n=0..4);
A lista acima definida também poderia ter sido obtida fazendo
> lista:=[%];
Voltando à questão das soluções de equações: é agora fácil de ver que a primeira das três soluções da equação anterior se obtém fazendo
> evalf(eval([so][1],a=2));
Gráficos (continuação)
Vai-se agora voltar à ilustração geométrica do teorema de Lagrange. Considere-se a definição:
> Lagrange:=(f,p)->[fsolve(D(f)(x)=(f(p[2])-f(p[1]))/(p[2]-p[1]),
x,p[1]..p[2])][1];
Se se definir
> f:=x->x*sin(x*Pi);
então
> Lagrange(f,[1/2,5/2]);
produz
A função Lagrange também pode ser definida por
> Lagrange:=(f,p)->fsolve(D(f)(x)=(f(p[2])-f(p[1]))/(p[2]-p[1]),
x,p[1]..p[2],maxsols=1);
Voltar
ao princípio.
Aula nº17
Gráficos (continuação)
Seja
> p:=[1/2,5/2];
Então, fazendo
> plot([f(x),f(Lagrange(f,p))+
(x-Lagrange(f,p))*(f(p[2])-f(p[1]))/(p[2]-p[1]),
[[p[1],f(p[1])],[p[2],f(p[2])]]],x=p[1]-1..p[2]+1,
color=[red,green,blue],view=[p[1]-1..p[2]+1,-3..3]);
obtém-se
Considere-se agora a seguinte lista de pares de números reais
> valores:=[seq([1/2-1/k,5/2+1/k],k=1..20)]:
e a seguinte função.
> S:=f->seq( plot( [f(x),f(Lagrange(f,p))+(x-Lagrange(f,p))*(f(p[2])-f(p[1]))/(p[2]-p[1]), [[p[1],f(p[1])],[p[2],f(p[2])]]], x=-1/2..7/2,
view=[-1/2..7/2, -2..3],color=[red,green,blue]),p=valores):
O seguinte comando «carrega» o package «plots».
> with(plots):
Nota: Para se consultar, através do menu
Help, uma das instruções definidas neste
package, por exemplo a função complexplot, é
preciso fazer uma busca por «plots,complexplot».
Pode-se agora obter uma animação fazendo
> display(S(f),insequence=true);
Voltar
ao princípio.
Aula nº18
Gráficos (continuação)
Se se omitir a opção da
instrução anterior, obtêm-se os gráficos sobrepostos.
>
display(S(f));
Como fazer com que o Maple faça uma
circunferência? Há várias maneiras. Uma que é natural, dado o que
se acabou de ver, é a seguinte:
>
display(plot(sqrt(1-x^2),x=-1..1,scaling=constrained,xtickmarks=4,
labels=["",""]),plot(-sqrt(1-x^2),x=-1..1));
Matematicamente, é mais natural descrever a circunferências
parametricamente, fazendo
>
plot([cos(t),sin(t),t=0..2*Pi],scaling=constrained,xtickmarks=4,
labels=["",""]);
ou
>
plot([(t^2-1)/(t^2+1),2*t/(t^2+1),t=-infinity..infinity],
scaling=constrained,xtickmarks=4,labels=["",""]);
Também podem ser empregues coordenadas polares
> plot([1,t,t=0..2*Pi],coords=polar,scaling=constrained,xtickmarks=4,
labels=["",""]);
Finalmente, há o recurso às funções definidas implicitamente
>
implicitplot(x^2+y^2=1,x=-1..1,y=-1..1,
scaling=constrained,xtickmarks=4,labels=["",""]);
Uso de números aleatórios
Para criar números aleatórios faz-se
>
rand();
Isto produz um número inteiro
não negativo com não mais do que 12 algarismos. Assim, pode-se
criar uma lista de pares de pontos aleatórios do quadrado que tem
por vértices (1,1), (1,-1), (-1,1) e (-1,-1) fazendo
>
lista:=[seq([2*rand()/10^12-1,2*rand()/10^12-1],k=1..1000)]:
A lista pode ser visualizada
fazendo
>
plot(lista,style=point,symbol=cross,scaling=constrained,color=green);
ou então
>
pointplot(lista,symbol=cross,scaling=constrained,color=green);
Como ver quais destes pontos
ficam na circunferência unitária? Pode-se fazer
>
plot_lista:=plot(lista,style=point,symbol=cross,scaling=constrained,
color=green):
circunf:=plot([cos(t),sin(t),t=0..2*Pi],scaling=constrained,xtickmarks=4,
labels=["",""]):
display({circunf,plot_lista});
Voltar
ao princípio.
Aula nº19
Uso de números aleatórios (continuação)
Para definir uma função «por
bocados» faz-se, por exemplo
>
f:=x->piecewise(x<-1,-1,x>1,1,x);
O seu gráfico é dado
por
>
plot(f(x),x=-3..3);
Vai-se regressar agora aos
pontos aleatórios do quadrado que tem por vértices (1,1), (1,-1),
(-1,1) e (-1,-1). Dado um tal ponto, como saber se está ou não na
circunferência unitária? Basta definir a função
>
d:=p->piecewise(p[1]^2+p[2]^2<1,1,0);
e a função
>
s:=l->sum(d(l[k]),k=1..nops(l));
Aplicando isto à lista anterior, obtém-se
>
s(lista);
Logo, a probabilidade de um
ponto daquela lista pertencer à circunferência unitária é igual
a
> %/1000.;
Repare-se que a probabilidade
de um elemento de uma lista arbitrária pertencer à circunferência
unitária é igual a
>
evalf(Pi/4);
Gráficos tridimensionais
Quer-se agora criar um cone. Pode-se fazer
>
plot3d(z,theta=-Pi..Pi,z=-1..1,coords=cylindrical);
ou então
>
plot3d(z,theta=-Pi..Pi,z=-1..1,coords=cylindrical,style=patchnogrid);
Voltar
ao princípio.
Aula nº20
Gráficos tridimensionais (continuação)
Quer-se ilustrar como é
possível obter as cónicas intersectando um plano com um cone.
Considere-se o seguinte cone:
>
cone:=plot3d(z,theta=-Pi..Pi,z=-3/2..3/2,coords=cylindrical,
scaling=constrained,view=[-3/2..3/2,-3/2..3/2,-3/2..3/2]):
Define-se agora a função
>
S:=p->display(plot3d([a,1+b*(p-1),b],a=-3/2..3/2,b=-3/2..3/2,
scaling=constrained,style=patchnogrid,
view=[-3/2..3/2,-3/2..3/2,-3/2..3/2]),cone);
e considera-se a lista
> lista:=[seq(-2+k/3,k=0..12)];
A intersecção do plano com o cone pode ser visualizado fazendo
>
display([seq(S(c),c=lista)],insequence=true);
Teoria dos números
Considere-se agora a seguinte função
>
t:=n->piecewise(igcd(n,2)=2,n/2,3*n+1);
Note-se que igcd é a função que a
dois inteiros associa o seu máximo divisor comum.
Assim, o gráfico de t pode ser
visualizado fazendo
>
plot([seq([n,t(n)],n=1..30)],style=point,symbol=circle);
Para se ver o gráfico da composta de t
consigo própria 6 vezes, pode-se fazer
>
plot([seq([n,t(t(t(t(t(t(n))))))],n=1..30)],style=point,symbol=circle);
Voltar
ao princípio.
Aula nº21
Matrizes
Vai-se ver uma maneira sistemática de criar matrizes. Para já,
começa-se por carregar um package
> with(linalg):
Warning, the protected names
norm and trace have been redefined and unprotected
Suponha-se por exemplo, que se quer definir a matriz com 4 linhas e
4 colunas tal que
- as entradas da diagonal principal são, de cima para baixo, 1, 2, 3 e 4;
- o valor de uma entrada fora da diagonal principal é o simétrico do
número da coluna onde se encontra.
Naturalmente, basta fazer
>
matrix([[1,-2,-3,-4],[-1,2,-3,-4],[-1,-2,3,-4],[-1,-2,-3,4]]);
Será talvez mais natural fazer:
>
matrix(4,4,(i,j)->piecewise(i=j,i,-j));
Ainda a título de exemplo, quer-se definir a seguinte matriz quadrada com
n+1 linhas e colunas: fora da diagonal, todas
as entradas são nulas e as entradas da diagonal são, de cima para baixo,
n, n-2,
n-4, ..., -n. Começa-se por definir a função
>
f:=n->(i,j)->piecewise(i=j,n+2-2*i,0);
Pode-se agora definir a matriz com
>
H:=n->matrix(n+1,n+1,f(n));
Tem-se então, por exemplo
>
H(3);
Teoria dos números (continuação)
Considerem-se agora as seguintes funções
>
ispseudo:=n->piecewise(frac((2^n-2)/n)>0,false,true);
f:=(m,n,k)->piecewise(m=1,n+k,m=2,isprime(n+k),ispseudo(n+k));
m:=k->matrix(3,10,(i,j)->f(i,j,k));
A primeira desta três funções é um teste que determina se, para um
dado número natural n, 2n-2 é ou não múltiplo de n.
Então, fazendo
>
m(0);
obtém-se
e, fazendo
>
m(100);
obtém-se
Poder-se-ia pensar que, recorrendo à função f,
se tem um teste de primalidade (que não funciona para
n=1), mas isso não é verdade pois tem-se
> m(340);
Voltar
ao princípio.
Aula nº22
Teoria dos números (continuação)
Considere-se o seguinte
problema: determinar quais são os números naturais não superiores a
5000 que não são primos mas que passam o teste da aula anterior e,
para cada um destes números, determinar a sua factorização em
factores primos. Este último aspecto do problema é de solução
simples; basta recorrer à função
ifactor.
> ifactor(341);
Uma maneira de resolver o
problema é a seguinte: começa-se por uma lista vazia e depois, para
cada número n de 1 a 5000, vê-se se é ou não
verdade que não é
primo e que passa o teste. Se for este o caso, acrescenta-se à
lista a lista o número em questão bem como a sua decomposição em
factores primos. Como é que se acrescenta um elemento a uma lista?
Recorre-se à função op, a qual, aplicada a
uma lista (ou a um conjunto) fornece a sequência correspondente. Por
exemplo, se se define
> lista:=[1,3,6,10];
e se se quer acrescentar 15 a esta lista basta fazer
> lista:=[op(lista),15];
Finalmente, é conveniente conhecer a função if.
Por exemplo, se se define
> f:=n->if
n>0 then n else -n end if;
então tem-se
> f(3);
f(-4/3);
Logo, para resolver o problema proposta basta fazer
> lista:=[]:
for n from 1 to 5000 do if (ispseudo(n) and not isprime(n)) then
lista:=[op(lista),[n,ifactor(n)]] else end if end do;
lista;
Álgebra Linear
Considere-se o seguinte problema: quer-se fazer uma tonelada de
farinha a partir de cinco ingredientes: milho, trigo, centeio, arroz e
cevada. Suponha-se que estes cereais têm as seguintes características:
- milho (m): 3% de gordura, 5% de fibra e
15% de proteínas; preço: 0,05 euros/kg
- trigo (t): 6% de gordura, 30% de fibra e
5% de proteínas; preço: 0,02 euros/kg
- centeio (cn): 3% de gordura, 10% de fibra
e 40% de proteínas; preço: 0,1 euros/kg
- arroz (a): 2% de gordura, 35% de fibra e
10% de proteínas; preço: 0,05 euros/kg
- cevada (cv): 4% de gordura, 25% de fibra
e 20% de proteínas; preço: 0,08 euros/kg
Quer-se que a farinha tenha 4% de gordura, 15% de fibra e 15% de
proteínas. Qual é a farinha mais barata que se pode fabricar nestas
condições? Começa-se por considerar o seguinte sistema de equações:
>
eqs:={3*m+6*t+3*cn+2*a+4*cv=4000,
5*m+30*t+10*cn+35*a+25*cv=15000,
15*m+5*t+40*cn+10*a+20*cv=15000,
m+t+cn+a+cv=1000};
Vai-se resolver este sistema
de equações relativamente à variável m.
>
soln:=solve(eqs,{t,cn,a,cv});
O custo é então dado por
>
custo:=.05*m+.02*t+.1*cn+.05*a+.08*cv:
subs(soln,custo);
Naturalmente, todas as
variávais têm que tomar valores não negativos, o que leva à
consideração dos seguintes cálculos auxiliares:
>
evalf(1500/3);evalf(2800/5);evalf(5900/12);evalf(2600/5);
Vê-se então que m tem que
estar situado entre 5900/3 e 500. Este facto e a determinação do
custo feita acima mostra que a resposta ao problema é dada
por
>
subs(m=5900/12,subs(soln,custo));
Voltar
ao princípio.
Aula nº23
Criação de página HTML usando o Maple
É possível guardar aquilo que foi feito numa sessão do Maple
no formato HTML; basta ir ao menu File
e fazer Export As, escolhendo depois a opção
HTML.
É conveniente haver texto além de instruções e cálculos do Maple,
tal com nos sumários anteriores a este.
Para se acrescentar texto acima de uma linha de input do
Maple coloca-se o cursor nessa linha e faz-se
Ctrl+Shift+K; para que o texto fique abaixo, faz-se
Ctrl+Shift+J.
Introdução ao Scientific WorkPlace
Esteve-se a fazer uma introdução ao uso do
Scientific WorkPlace: criação de gráficos, definição de
funções, distinção entre texto normal e texto matemático, como colocar título e autor
num texto, etc.
Voltar
ao princípio.
Aula nº24
Esteve-se a trabalhar com figuras. Mais precisamente, esteve-se a
ver como:
colocar legendas;
numerar automaticamente as figuras;
fazer um «cross-reference» para uma figura;
controlar a localização da figura.
Esteve-se também a ver como fazer com que as palavras criadas
automaticamente pelo Scientific WorkPlace
sejam em português. Por um lado, é preciso carregar o package babel e escolher como opção a língua
portuguesa. É também preciso ir ao menu Typeset, escolher Preamble e, fazer algumas alterações na janela que
se abre então, que tem o seguinte conteúdo:
\newtheorem{theorem}{Theorem}
\newtheorem{acknowledgement}[theorem]{Acknowledgement}
\newtheorem{algorithm}[theorem]{Algorithm}
\newtheorem{axiom}[theorem]{Axiom}
\newtheorem{case}[theorem]{Case}
\newtheorem{claim}[theorem]{Claim}
\newtheorem{conclusion}[theorem]{Conclusion}
\newtheorem{condition}[theorem]{Condition}
\newtheorem{conjecture}[theorem]{Conjecture}
\newtheorem{corollary}[theorem]{Corollary}
\newtheorem{criterion}[theorem]{Criterion}
\newtheorem{definition}[theorem]{Definition}
\newtheorem{example}[theorem]{Example}
\newtheorem{exercise}[theorem]{Exercise}
\newtheorem{lemma}[theorem]{Lemma}
\newtheorem{notation}[theorem]{Notation}
\newtheorem{problem}[theorem]{Problem}
\newtheorem{proposition}[theorem]{Proposition}
\newtheorem{remark}[theorem]{Remark}
\newtheorem{solution}[theorem]{Solution}
\newtheorem{summary}[theorem]{Summary}
\newenvironment{proof}[1][Proof]{\textbf{#1.} }{\ \rule{0.5em}{0.5em}}
É preciso substituir as palavras que começam com uma letra
maiúscula (Theorem, Acknowledgement, etc) pela sua tradução
portuguesa. Se se quer que os teoremas, corolários, lemas, etc tenham
numerações independentes, então devem-se eliminar também os
«[theorem]».
Também se viu como criar um índice bem como fazer
«cross-references» para teoremas.
Voltar
ao princípio.
Aula nº25
Esteve-se a ver como ter vários gráficos sobrepostos numa mesma
figura e como fazer com que tenham cores distintas. Também se viu como
definir funções com várias expressões, como é o caso da função
t que já tinha sido definida na
aula nº20.
Viu-se também como converter um ficheiro produzido pelo
Scientific WorkPlace num ficheiro
PDF. Para isso, é preciso «imprimir» o
ficheiro (a partir do TrueTeX Previewer). É
preciso que as opções da impressora fiquem do seguinte modo:
Nota importante: É preciso não esquecer
que se deve seleccionar a opção «Print to
File». O objectivo não é efectivamente
imprimir o ficheiro. Também é preciso não esquecer de seleccionar a
impressora «HP LaserJet 4Si/4Si MX PS».
Abre-se depois uma janela que pede o nome do ficheiro a ser criado;
é preferível que tenha a terminação ps; caso
essa janela não apareça, procure um novo ficheiro (com um nome do tipo
File~2m) no mesmo directório onde está o
ficheiro que abriu com o Scientific WorkPlace.
Esse ficheiro deve depois ser aberto com o GSView
e seguidamente deve ser «impresso» com a seguinte configuração:
Nota importante: Mais uma vez, é preciso
não esquecer que se deve seleccionar a opção «Print to
File».
Finalmente, deve-se dar um nome ao ficheiro assim obtido, de
preferência usando a terminação pdf.
Voltar
ao princípio.
Aula nº26
Viu-se que a vantagem de converter no formato PDF um ficheiro produzido pelo Scientific WorkPlace reside no facto de de este
depois poder ser aberto com um browser. Pode
ser visto aqui um exemplo
de um tal ficheiro.
Esteve-se também a ver como criar uma bibliografia.
Finalmente, viu-se como transportar para uma página HTML uma fórmula matemática criada com o Scientific WorkPlace, tal como a seguinte:
Voltar
ao princípio.