Operadores, Calculo e Trigonometria

Voltar

Introdução

O material a seguir apresenta as principais operações matemáticas como linguagem de programação. Utilizando os elementos apresentados abaixo é possível traduzir diversas operações para programação.


Sequencia de Instruções

Durante o processo de criar programas é importante entender que o computador só executa código de forma semelhante a um ser humano lendo um livro, ou melhor, um manual de instruções. As instruções possuem uma ordem correta que é essencial para que o resultado correto seja obtido. Observer a operação abaixo:

int x = 4 + 5;

Vamos dividir em etapas menores:

  1. Primeiro vamos declarar o x.
  2. depois calcular a soma de 4 + 5.
  3. por ultimo salvar o resultado em x.

Caso x não exista, onde o computador irá salvar o resultado de 4 + 5 ?
Também é possivel escrever a mesma operação de outra forma.

int x;
x = 4 + 5;

O resultado é exatamente o mesmo. No entanto se escrever:

x = 4 + 5;
int x;

Será emitido um erro, informando que x ainda não existe. Nesse caso podemos dizer que a leitura é feita linha por linha de topo para baixo. Outra forma de escrever seria:

int x; x = 4 + 5;

Essa forma também está correta. Observe que existe uma virgula no final de cada instrução. Antes do programa descer para próxima linha ele executa todas as instruções daquela linha, separadas por ponto e virgula.

Conhecer bem esse processo ajudará a desenvolver problemas mais complexos.


Comentários em Código

Uma pratica comum em programação é a colocação de comentários junto com o código. Em quase qualquer linguagem de programação existe algum símbolo que representa o inicio e o fim de um comentário. No processing (e maioria das linguagens parecidas com C) encontramos a barra dupla com marcador de comentário:

// Essa linha contém um comentário.

Comentários são elementos para ajudar a esclarecer partes do código ou identificar o propósito de um arquivo e quando colocados estratégicamente pelo texto aumentam muito seu valor. É importante lembrar que esses comentários não entram no programa final em operação, pois são ignorados por compiladores, portanto representam apenas um elemento humano.

Comentários iniciados pelo símbolo // não precisam de marcação de fim, pois a partir do // toda a linha a direita da // será exclusiva para o comentário. Nesse caso ele termina ao apertar iniciar um nova linha. Por exemplo:

float x = 0; // Esse comentário está OK
// Esse comentário também está ok
float y;
// Esse comentário pode afetar o código, pois a expressão seguinte será ignorada: x = 2*y;

Além dessas forma de iniciar um comentário, existe a /* */. Esse símbolo exige marcação de inicio e fim. Assim, inicie um comentário com /* digite quantas linhas quiser e termine com */. Exemplo:

/*
Esse é um super comentário de
duas linhas… ou de repente até mais
do que tinha previsto inicialmente.
*/

Também podemos comentar partes do código para ativar ou desativar funcionalidades de programas, geralmente em fase de teste. Exemplo:

float x = 10, y = 20;
ellipse(x,y,100,100); // Código ativo
// ou
// rect(x,y,100,100); // Código desativo


Funções e Métodos

Antes de apresentar códigos de operações como raiz, cosseno, potência e outros é importante esclarecer as convenções de escrita. Todas as operações serão apresentadas como funções. Uma função é um maquina que possui uma ou mais entradas e produz um resultado (apenas um) de saída. Os valores de entrada são chamados de parâmetros e os de saída de retorno. Alguns capítulos a frente veremos como criar funções personalizadas, mas por enquanto vamos interpretar as existentes. Observer o diagrama:

Entrada —->  Processamento —–> Saída

Assim como funções em utilizadas em calculo, por exemplo f(x), temos funções em processing. Geralmente, ao invés de letras, elas são representadas por palavras, mas como qualquer função utilizam a notação do parênteses para indicar dados de entrada. Por exemplo:

Para encontrar o cosseno de PI podemos usar a função cos(a), onde a é um angulo em radianos. Assim:

float c = cos(PI);

Uma função como cos(a) possui apenas um parâmetro, nesse caso o a. No entanto a medida que conhecemos a biblioteca de funções do processing haverá outras sem parâmetros e com n parâmetros. O numero de parâmetros é determinado pelo numero de termos que devemos colocar entre os parênteses, e separados por virgulas.

Algumas funções como a de desenho de elipses possuem até 4 ou mais parâmetros. Assim:

ellipse( x , y , altura , largura );

Para conhecer o numero de parâmetros e suas respectivas funcionalidade consulte o manual do processing.


 

Raiz Quadrada e Potência


Raiz

A maior parte das linguagens de programação possuem palavras especiais para se referir a certas operações. Duas das mais conhecidas são Raiz Quadrada e Potência.

Sem entrar no mérito de explicar o que é a Raiz Quadrada, podemos apenas lembrar que ela é representada pelo seguinte formato:

imgres

 

Onde x é o numero do qual se deseja obter a raiz. Se está resolvendo em uma folha de papel poderia ser observado situações como:

Screen Shot 2015-06-29 at 17.55.19

 

É fácil de entender o que está escrito acima. Agora também poderia ser observado o seguinte:

Screen Shot 2015-06-29 at 17.56.54

 

Agora está mais parecido com algo que foi apresentado anteriormente. Se garantirmos que o x foi previamente declarado:Screen Shot 2015-06-29 at 17.58.52

 

No entanto quando estamos escrevendo em código, existe um palavra para raiz quadrada: sqrt(x). Onde x é o numero do qual se deseja obter a raiz. Assim finalmente podemos escrever no formato aceito pelo processing:

Screen Shot 2015-06-29 at 18.01.28

 

Se você conhece o conceito de função vai reconhecer essa forma de descrever. A raiz nesse caso é uma função que recebe um valor e retorna um resultado. Assim sqrt(64) irá resultar em 8 que em seguida será salvo na posição x. Essa notação de função é extremamente flexível e permite construir operações dentro de operações. Nesse caso:

int y = 128;
float x = sqrt(y);
print(x);  // Mostrar resultado no console

Podemos inclusive colocar uma função dentro de outra:

float x = sqrt( sqrt( 30 ) );   

Que seria como escrever:

Screen Shot 2015-06-29 at 18.09.29

 

Existe um lógica por traz do processo de funções dentro de funções que segue o sistema de precedência de parênteses. Cada para de parênteses representa um grupo e eles são executados do interno para o externo. Nesse caso o código: int x = sqrt( sqrt( 30 ) );  Seria descrito como:

  1. Declarar x.
  2. Calcular a raiz quadrada de 30.
  3. Calcular a raiz quadrada do resultado obtido na linha 1.
  4. Salvar o resultado da linha 2 em x.

Toda função possui esse par de parênteses após o nome. As vezes não valores no parênteses, outras vez pode haver um ou mais valores. No caso da raiz existe 1. O nome dado aos valores inseridos em uma função é parâmetros.  Reformulando a frase: No caso da raiz existe 1 parâmetro. 


Potência

Potências seguem a mesma lógica da raiz. A potência nesse caso possui 2 parâmetros, o numero que se deseja elevar a uma potência (x) e a potência (a).

Screen Shot 2015-06-29 at 18.21.38

 

A palavra para potência é pow(x,a). Repare que dentro do parênteses existem 2 parâmetros (x e a). Exemplo:

int y = pow(5,2);     // Seria igual a 5 * 5

Isso irá resultar em y sendo igual a 25. Podemos combinar operações para forma expressões mais complexas:

 Screen Shot 2015-06-29 at 18.28.36      pode ser escrito como:    int x = pow( sqrt(10) , 3 );

  Vamos analisar a sequencia de operações:

  1. Declarar x.
  2. Calcular a raiz quadrada de 10.
  3. Elevar ao cubo o resultado da linha 2.
  4. Salvar o resultado da linha 3 em y.

Distância Entre 2 Pontos

Usando os conhecimentos apresentados anteriormente vamos resolver um problema simples. Calcular a distancia entre dois pontos no plano p(2,3) e q(4,5). Não vamos resolver nenhum tipo de conta no papel, vamos descrever o problema e deixar o computador resolver os detalhes.

Para resolver essa questão irei utilizar o método simples que se baseia na fórmula de pitagoras para os lados de um triângulo retângulo.distanceAssim a distancia entre p e q é a raiz quadrada de delta x ao quadrado mais delta y ao quadrado. Uma vez conhecendo os comandos pow(x,a) e sqrt(x), temos todas as ferramentas para descrever o problema acima:

float d = sqrt( pow( 4 – 2 , 2 ) + pow( 5 – 3 , 2 ) );
print(d);


Trigonometria

Quando é necessário realizar operações com ângulos no processing é importante lembrar que a unidade padrão é radianos. Caso seja necessário usar graus será necessário realizar um conversão simples. Para entender lembre de uma regra de 3:

se Pi radianos equivale a 180 graus, então r radianos será equivalente a g graus, assim:
pi/r = 180/g
no entanto, em código será preciso isolar uma variável apenas do lado esquerdo, assim:
g = 180*r/pi   ou   r = pi*g/180
não esqueça que tanto g quanto r (acima) devem ser representados como números com vírgula, devido a maior precisão necessária (na conversão de escalas tão diferentes, 180 graus equivale 3.14 radianos, sem precisão do float ou double haverá muita informação perdida).

Experimente escrever no processing:

float r, g;                // Declarar variáveis como números de precisão…
g = 90;                     // Atribuir a g o valor de 90 (nesse caso, graus)
r = (3.14*g)/180;   // Calcular a conversão de graus para radianos e atribuir o resultado a r…
print(r);                  // Mostrar o valor de r no console utilizando o comando print()…

Verifique se o resultado bate com aquele obtido em cálculos no papel?

Agora que realizou o processo de conversão manualmente vale mostrar a função que faz o mesmo:
degrees(r) e radians(g)
Basta escrever a função com o respectivo valor em código que o resultado será inserido em seu programa. Assim, se escrever:
float r = radians(90);
A variável r será atribuída do valor de 90 graus convertidos em radianos. O mesmo é possível com o processo inverso:
float g = degrees(3.14);
Também é possível inserir as função no código em lugares convenientes, por exemplo:
float c = cos(radians(90));
A linha acima irá primeiro calcular o valor em radianos de 90 graus, depois calcular o cosseno e por ultimo fará a atribuição do resultado a variável c.

Existem diversas operações pré-existentes em processing que podem ser úteis para resolver problemas de trigonometria: acos() asin() atan() atan2()  cos()  sin()  tan()

Pelo nome é possível imaginar o resultado que cada chamada gera.


Outros símbolos

x = x + 1;  pode ser escrito como x++; ou x += 1;
x = x – 1;  pode ser escrito como x–; ou x -= 1;
x = x * 5; pode ser escrito como x *= 5;
x = x / 5; pode ser escrito como x /= 5;

Caso queira o valor absoluto de um numero: |-5| =  5, pode se usar o comando abs(-5).

Para descobrir o resto de uma divisão utilize a operação %. Nesse caso o resto inteiro da divisão de 5 por 3 será: 5 % 3 que terá resultado 2.