Notas de introdução ao Mathematica (LEFT+LEGI) 2002/03
por S. S. Valtchev ( www.math.ist.utl.pt/~ssv )

AULA 1

O programa Mathematica é composto  por duas partes, o Kernel e o FrontEnd. O Kernel corresponde à parte do Mathematica que processa os cálculos e o FrontEnd é a interface gráfica entre o utilizador e o Kernel. O NoteBook faz parte do FrontEnd e funciona como um editor de texto onde podemos copiar (Ctrl+C), inserir (Ctrl+V), apagar (Ctrl+X), etc. linhas de código ou comandos. O NoteBook é dividido em células (Cells). Cada célula pode ser de Input ou de Output. As células de Input contêm os comandos introduzidos pelo utilizador e podem ser executadas através da combinação "Shift+Enter". As células de Output contêm resultados numéricos, gráficos, mensagens de erro ou avisos emitidos pelo Kernel, em consequência da avaliação de uma célula de Input.

Existem várias maneiras para interromper um cálculo (avaliação duma célula):
	1) através da combinação "Alt+."
	2) no menu "Kernel" (Alt+K), fazendo "Abort Evaluation" ou em ultimo caso "Quit Kernel⟶Local"

Sintaxe do Mathematica:
1)  O programa Mathematica é CaseSensitive, i.e. letras maiúsculas e minúsculas designam variáveis ou funções diferentes. Por exemplo podemos fazer as seguintes duas atribuições: a=5 e A=10, sem isto provocar ambiguidade no Mathematica.
2)  Existem 3 tipos de parêntesis no Mathematica, ( ), { } e [ ]. Os parêntesis ( ) são usados para agrupar termos, como em Álgebra. As chavetas { } são usadas para definir listas. Os parêntesis rectos [ ] são usados para definir os argumentos de uma dada função, por exemplo Sin[x] ou Exp[3.123]. Quando uma função tem mais que um argumento, estes são separados por virgulas, por exemplo: Log[10, 100]. 
3)  Os comandos, rotinas, funções e constantes, predefinidos no Mathematica começam sempre com letra maiúscula, por exemplo: If[ ], Exp[ ], D[ ], N[ ], etc. Quando o comando do Mathematica é composto por mais do que uma palavra, cada uma delas é começada com letra maiúscula e sem espaços, por exemplo: LinearSolve[ ], FindRoot[ ], ParametricPlot[ ], etc. (com algumas excepções: Eigenvalues[ ] ou Eigenvectors[ ]).
4)  As rotinas, funções e constantes, implementadas pelo utilizador podem começar com letra maiúscula desde que no Mathematica não exista já um comando com o mesmo nome! Os símbolos "_", "*", "%", "@",etc., não podem ser usados no nome de uma função ou variável (errado: e@t=45.123). O nome de uma variável não pode ser começado por um número (errado: 2var=3.14).
5)  Cada comando numa célula de Input tem que ser finalizado com ";" desde que não se queira visualizar o seu output. Comandos como Print[ ], Show[ ], Plot[ ], etc. tem sempre output, gráfico ou alfanumérico.
6)  O espaço em branco " " corresponde a multiplicação, por exemplo: a b≡a*b≡Times[a,b]
7)  No Mathematica usa-se o ponto decimal e não a virgula para representar um numero real (correcto: a=3.145, errado: a=3,145)

Constantes e a sua representação no Mathematica :

As constantes Pi, E, I, etc., já estão definidas no Mathematica:

N[Pi]

N[E, 40] (* representação com 40 casas decimais do número E *)

N[I]

a = 2;(* atribuir um valor inteiro ao parâmetro a *)
b = 3.657;  
c = (2/3);

a

b

a/b

a*c

Sin[2]

Sin[2. ]

N[Sin[2]]

FullForm[N[Sin[2]]]  (* 
          O Mathematica guarda 16 casas decimais na memória *)

?FullForm

FullForm[(x*y) + x - y]

Se nenhum dos argumentos de uma dada função fôr definida através de ponto decimal o Mathematica mostra o resultado exacto do cálculo, sem efectuar contas que levam a perda de precisão. Basta um dos argumentos ser apresentado na forma fraccionária (através de ponto decimal) e o Mathematica fará os respectivos arredondamentos, apresentando o resultado final apenas com 6 casas decimais. O comando N[ ] devolve o valor aproximado de um dado cálculo. OBS: o Output é apresentado apenas com 6 casas decimais, mas o Mathmatica guarda 16 casas na memória e efectua todas as contas necessárias com estas 16 casas de precisão (caso não sejam exigidas mais através do comando SetPrecision[ ] ou WorkingPrecision[ ])!!!

Clear[a, b, c] (* Comando sem Output, limpa as atribuições das constantes a, b e c *)

a (* Verificar: a não tem valor atribuido *)

(TPC) Outros comandos importantes: Floor[ ], Ceiling[ ], Chop[ ], Mod[ ], Round[ ]

Análise complexa:

a = 3.5 + I*2.5;   
b = -1.2 - 
          I*0.5;

Re[a] (* parte real do a *)

Im[a] (* parte imaginária do a *)

Arg[a]

Conjugate[a] (* o complexo conjugado do a *)

Abs[b] (* o módulo do b *)

Print["Soma de a e b = ", 
          a + b];
Print["Diferença \
entre a e b = ", 
        a - b];
Print["Produto de a por b = \
", a*b];
Print["Quociente de a por b = ", 
        a/b];

Cálculo simbólico:

Clear[a, b, c, d, x, y];
simb = (a + b)^3 - (a - b)^3;   
esimb=Expand[simb] (* simplificar o o simb *)

(* quando os nomes de duas variáveis são semelhantes o Mathematica emite mensagem de Aviso! *)

Factor[esimb] (* factorizar o esimb *)

Expand[(a + b)^4]

Solve[a*x^2 + b*x + c == 0, x]

?Solve

Simplify[
        (a^4) + 4 (a^3) b + 6 (a^2) (b^2) + 4 a (b^3) + (b^4)]

Definição de listas, matrizes e tensores:

lis = {1, 2, 3};   
lis[[3]]

mat1 = {{1, 2, 3}, {3, 4, 5}, {5, 6, 7}}; (* Lista bi - dimensional, neste caso matriz 3×3 *)
(* para o Mathematica uma matriz é uma lista de listas (linhas)!! *)
mat1[[2, 3]]

MatrixForm[mat1]

mat2 = {{1, 2, 3, 4}, {3, 4, 5}, {4, 5}};   
mat2[[2, 3]]

mat3 = {{{1}, {2}}, {1, 2, 3}};   
mat3[[1, 2, 
        1]]

Table[i, {i, 1, 5}]

Array[Sin, 4] (* construção duma lista de 4 elementos, cada um dado pelo valor da função Sin[] nos inteiros 1, 2, 3 e 4 *)

?Array

Table[Table[i + j, {j, 1, 3}], {i, 1, 3}]//MatrixForm (* construção duma matriz 3×3 com entrada geral dada pela soma dos índices da posição *)

IdentityMatrix[4]//MatrixForm (* construção da matriz identidade de dimensão 4 *)

DiagonalMatrix[lis]//MatrixForm (* Construção duma matriz diagonal cujos elementos da diagonal são dados pela lista lis *)

Manipulação de listas, matrizes e tensores:

aux = Append[lis, 4]; (* acrescentar (no fim) um elemento a lista lis *)
aux

aux = Prepend[aux, 10]; (* adicionar um elemento no inicio da lista aux *)
aux

Length[aux]

Min[aux]

Max[aux]

Sort[aux]

lis.lis (* produto interno da lista lis por ela própria *)

Dot[lis, lis] (* mesma coisa, usando a função Dot[ ,  ]do M  athematica *)

lis1 = {0, 1, 0}; (* definição *)
lis2 = {1, 0, 
          1};
Cross[lis1, lis2]

Dot[mat1, lis] (* produto da matriz mat1 pelo vector lis *)

tmat1 = Transpose[mat1]; (* Matriz transposta da mat1 *)
MatrixForm[
      tmat1]

Dimensions[tmat1]  (* 
          apresenta as dimensões de uma matriz rectangular *)

?Dimensions

mat = {{1, 2}, {3, 4}}; (* definir a matriz mat *)
Inverse[mat]  // MatrixForm (* matriz inversa da mat *)

Det[mat]

LUDecomposition[mat] (* Factorização LU de uma matriz .  Ver Help (F1) para compreender o Output *)

?LUDecomposition

A = {{1, 2}, {-1, 3}};   
v = {-1, 3};   
LinearSolve[A, v] (* resolução dum sistema linear do tipo A . x=v *)

?LinearSolve

(TPC) Outros comandos importantes: Last[ ], First[ ], Drop[ ], Join[ ], Partition[ ], Flatten[ ], Eigenvalues[ ], Eigenvectors[ ], NullSpace[ ]

Definição de uma função em Mathematica:

f1[x_] := Sin[x] + Exp[-x*x/2];

f1[3.25] (* o valor da função f1 em x=3.25 é: *)

f2[x_] := Exp[-x^2];

g[x_, y_] := x^2 + y^2 + Cos[Tan[x + y]];

g[1.25, 3.14] (* valor da função g no ponto {x, y}={1.25, 3.14} *)

h[r_, teta_] := r*{Cos[teta], Sin[teta]};

h[1, Pi/4] (* exemplo *)

func=Function[{x, y, z}, (* variáveis globais da função func *)
Module[{a, b, c},  
a = Sin[x]; 
b = 
                    Cos[a + y]; 
c = 
                    Sin[b + z]; 
Tan[c/(x + y + z)]
(* a última linha de código que não acaba com ";" vai ser o Output da função func *)
]];

func[1.2, 3.5, 4.78]

?Function

?Module

Testes e operações lógicas em Mathematica:

Os valores que uma variável lógica pode tomar em Mathematica são "True" ou "False".

a = True; (* definir a, b e c *)
b = 
        False;
c = False;

a==b (* testar se a é igual ao b *)

a!=b (* testar se a é diferente do b *)

a&&b (* avaliar a expressão a∧b, i.e. a e b *)

a||b (* avaliar a expressão a∨b, i.e. a ou b *)

Not[b] (* a negação do b. Pode ser usado como !b em expressões *)

(a && c && b)||((c || a) && b)

2≤3 (* testar se 2<3 *)

2==3 (* testar se 2=3 *)

2!=3 (* testar se 2≠3 *)

(a || b)&&!(2 > 3)

EvenQ[12]

OddQ[13]

If[a, Print["O valor de a é True."], 
        Print["O valor de a é False."]] (* teste do tipo If[condição,  If True,  
              If False] *)

?If

Clear[a, b, c, d, x, y]

(TPC) Outros comandos importantes: PrimeQ[ ], VectorQ[ ], MatrixQ[ ], etc...

Representação gráfica de funções em Mathematica:

graf1=Plot[f1[x], {x, -3, 3}, 
        PlotStyle -> RGBColor[1, 0, 0]]

graf2 = 
      Plot[f2[x], {x, -3, 3}, PlotRange -> All, 
        PlotStyle -> RGBColor[0, 1, 0]]

?Plot

Show[graf1, graf2]  (* 
          para mostrar vários gráficos no mesmo Plot *)

?Show

tabela = Table[{x, Sin[x]}, {x, 0, 2*Pi, Pi/5}] ;(* Criar uma lista de 17 pares de pontos correspondentes à função Sin[x] no intervalo [0, 2  Pi] *)
ListPlot[tabela, 
        PlotJoined -> False];
ListPlot[tabela, 
          PlotJoined -> True];
 (* graficos de uma tabela de pontos {x, y} *)

?? ListPlot

ListPlot[tabela, PlotJoined -> True, Frame -> True, 
        GridLines -> {{Pi/2, Pi, 3  Pi/2}, {- .5,  .5}}, 
        PlotLabel -> "Grafico do Sin[x] com Gridlines"];

Plot3D[Sin[x] Cos[y], {x, -Pi, Pi}, {y, -Pi, Pi}, 
        PlotRange -> All, PlotPoints -> 30, Mesh -> False]

?Plot3D

Plot3D[Sin[x] Cos[y], {x, -Pi, Pi}, {y, -Pi, Pi}, 
        PlotRange -> All, PlotPoints -> 30, Mesh -> False, 
        ViewPoint -> {-0.012,  -3.384,  2.026}] \( (*\ 
          mudar\ o\ \(ViewPoint : \ 
              no\ menu\ "Input"\ ir\ ao\ "3D Viewpoint selector"\)\ *) \)

DensityPlot[
        Sin[x/y] Cos[y], {x, -Pi, Pi}, {y, -Pi, Pi}, 
        PlotPoints -> 80, ColorFunction -> Hue, 
        Mesh -> False]

?DensityPlot

ParametricPlot[h[1. , teta], {teta, -Pi, Pi}, 
        AspectRatio -> Automatic] (* gráfico de uma função vectorial, de um parâmetro, do tipo f[t]={x[t], y[t]} *)

(* definir a parametrização de um toro *)
fff = 
          Function[{t, 
              s}, 
Module[{x, y, 
                z}, 
x = (1.2 + Cos[t])*
                  Cos[s]; 
y = (1.2 + Cos[t])*
                  Sin[s]; 
z = 
                Sin[t]; 
{x, y, 
                z}
]];
ParametricPlot3D[fff[t, s], {t, Pi/10, 2*Pi}, {s, 0, 2*Pi}, 
        PlotPoints -> 30, ViewPoint -> {1.958,  -1.958,  1.958}]

(TPC) Outros comandos importantes: ListPlot[ ], ListPlot3D[ ], ContourPlot[ ], etc.
Opções importantes para os comandos graficos: PlotRange, AspectRatio, PlotLabel, Axes, AxesLabel, Frame, PlotJoined, PlotStyle, ColorFunction, Grid, GridLines, AxesOrigin, Mesh, ViewPoint, PointSize, AbsolutePointSize, etc...

Algumas funções e rotinas já existentes no Mathematica:

Integrate[x*Sin[x], {x, -1, 1}]

NIntegrate[Exp[-Sin[x^2]], {x, -1, 1}]

Integrate[Exp[-Sin[x^2]], x]

Series[Sin[x], {x, 0, 5}] (* Desenvolvimento em serie de Mac - Laurin, até à ordem 5 da função Sin *)

Series[Sin[x], {x, 1, 5}] (* Desenvolvimento em serie de Taylor, até à ordem 5 da função Sin, perto do ponto x = 1 *)

Limit[(1 + 1/n)^n, n -> Infinity] (* Limite de uma dada sucesão quando n->∞ *)

?Limit

Sum[i^2, {i, 1, n}]

Product[i^2, {i, 1, n}]

FindRoot[x == Exp[-x], {x, 0.2}]

FindRoot[{x*y == Exp[-y], 
          y/x == Sin[x + y]}, {x,  .2}, {y, 0.2}]

{x*y - Exp[-y], 
          y/x - Sin[x + y]} /. {x -> 0.7092906446477493`, 
          y -> 0.7000678788997681`}

\( (*\ 
        o\ erro\ é\ de\ ordem\ 10  E - 
          9. \ A\ combinação\ "/."\ usa - 
          se\ para\ aplicar\ uma\ regra\ de\ substituição\ *) \)

?FindRoot

DSolve[{y'[x]==3 y[x] + y[x]^2,y[0] == 5},y[x],x]

?DSolve

NestList[f1, 1.5, 10]

(TPC) Outros comandos importantes: D[ ], Dt[ ], NSum[ ], NProduct[ ], NDSolve[ ], Solve[ ], NSolve[ ], Fit[ ], InterpolatingPolynomial[ ], PolynomialFit[ ], Nest[ ] etc...