/* exemplo01.c:
* Exemplo básico de uso da biblioteca PLPlot.
* Este programa simplesmente plota na tela o gráfico da função
*
* f(x) = x/(1 + x^2)
*
* praticamente nenhuma personalização é feita, deixando que a biblioteca
* utilize os parâmetros default.
*/
#include <plplot.h>
/* Número de pontos em que iremos calcular o valor de f(x) dentro do intervalo
* definido abaixo. Vamos utilizar um ponto adicional para ligar o último ponto
* calculado com outro calculado quando x = XMAX (definido abaixo). O número de
* pontos, ou melhor, o intervalo de amostragem que será utilizado dependerá de
* cada função. Fique esperto. */
#define NUMPONTOS 200
/* O intervalo em que a função será exibida. Isto quer dizer que teremos um
* ponto a cada intervalo dt, tal que dt = (XMAX - XMIN)/NUMPONTOS. Os limites
* para o eixo Y também estão definidos. */
#define XMIN -10
#define XMAX 10
#define YMIN -1.0
#define YMAX 1.0
/* A função função f(x). O tipo de dado PLFLT é, por padrão, uma variável do
* tipo float. Isso pode ser modificado definido uma variável de nome PL_DOUBLE
* ou somente DOUBLE utilizando a diretiva define do pré-processador. Isso deve
* ser feito antes de incluir a biblioteca no programa. No nosso caso, está
* perfeito do jeito que está, não precisamos alterar isso.
* A função abaixo recebe um valor x do tipo PLFLT como argumento e retorna o
* valor da função, tal como definimos na descrição desse programa. Esse
* procedimento é necessário porque a biblioteca não recebe uma função
* matemática como parâmetro e a plota, mas um conjunto de pontos que serão
* conectados entre si de alguma forma */
PLFLT f(PLFLT x)
{
return x/(1 + x*x);
}
int main (int argc, const char *argv[])
{
PLFLT x[NUMPONTOS + 1]; /* Vetor com os pontos do eixo x */
PLFLT y[NUMPONTOS + 1]; /* Vetor com os pontos do eixo y */
PLFLT dt; /* Intervalo de amostragem */
PLINT i;
/* Calcula o valor de f(x) em NUMPONTOS, com um intervalo de espaçamento dt
* e guardando esses valores nos vetores x e y para que possamos utilizá-los
* mais à frente */
dt = (PLFLT)(XMAX - XMIN)/NUMPONTOS;
for (i = 0; i < NUMPONTOS; i++) {
x[i] = XMIN + (PLFLT)i*dt;
y[i] = f(x[i]);
}
x[NUMPONTOS] = XMAX;
y[NUMPONTOS] = f(XMAX);
/* Inicializa PLplot. Essa função irá perguntar qual o dispositivo que
* você quer utilizar para plotar o gráfico. Se você deixar o campo em
* branco, a biblioteca irá selecionar o primeiro dispositivo na lista
* exibida */
plinit ();
/* Definindo limites do gráfico. A função plenv é responsável por criar a
* janela de exibição e desenhar uma caixa dentro dela, representando os
* eixos do nosso gráfico. Os limites do eixo x são definidos através de
* XMIN e XMAX. Os limites do eixo Y por YMIN e YMAX. O penúltimo diz
* respeito a escala do gráfico. O último parâmetro está associado as
* propriedades dos eixos e a caixa ao redor do gráfico. Iremos utilizar
* aqui o valor 1 para o penúltimo parâmetro, indicando que queremos que as
* escalas dos eixos x e y sejam as mesmas. Para o último, utilizamos o
* valor -1, indicando para o programa que desenhe apenas uma caixa ao redor
* do gráfico. Para maiores informações a respeito de valores que podem ser
* utilizados e o que cada um significa, leia a documentação da biblioteca
* presente no site oficial da mesma */
plenv (XMIN, XMAX, YMIN, YMAX, 0, -1);
/* Inserindo rótulos no gráfico. A função pllab permite a definição de
* rótulos no nosso gráfico. O primeiro argumento é rótulo do eixo x, o
* segundo é o rótulo do eixo y com algumas sequências de escape para
* podermos obter um sobrescrito como potência. O último é o título do
* gráfico. Dependendo do driver utilizado, pode não ser uma boa ideia o uso
* de acentos nas strings */
pllab ("x", "x/(1 + x#u2#d)", "Olá mundo dos gráficos!");
/* Plotando o gráfico. A função plline recebe três argumentos: o primeiro
* é o número de pontos que queremos plotar. O segundo é um vetor com as
* coordenadas do eixo x. O terceiro é um vetor com as coordenadas do eixo
* y. Essa função simplesmente desenha uma linha reta entre pontos
* consecutivos, assim como a maior parte dos softwares que plotam funções
* e exibem o resultado na tela. É ela a responsável por realmente desenhar
* o nosso gráfico */
plline (NUMPONTOS + 1, x, y);
/* Pronto, terminamos! A função plend é responsável por encerrar a PLplot,
* fazendo todos os ajustes necessários para que tudo ocorra como esperado e
* você tenha o seu gráfico ao final */
plend ();
return 0;
}
Não é de hoje que o Banco do Brasil tem problemas com o OpenJDK. Uma simples busca na internet e você deverá encontrar dezenas ou centenas de posts em fóruns, sempre com a mesma dúvida: Por que diabos o módulo de seguranção não instala no PC quando usamos o OpenJDK? Na verdade, o problema está relacionado ao OpenJDK 64 bits, já que a versão de 32 bits não têm apresentado grandes problemas com relação a isso.
medidas é dado por
) para poder fazer esse cálculo. Assim, seria interessante se pudéssemos calcular essa média e realizar essa operação somente no final. Mais do que isso, seria interessante se pudéssemos expressar o desvio padrão acima em termos da soma dos quadrados de cada valor e da média, visto que isso seria de mais fácil implementação, já que poderíamos somar os valores de cada linha e ao mesmo tempo somar o quadrado desses valores com facilidade. Da soma dos valores em cada linha teríamos facilmente a média. Assim, expandindo o numerador na expressão acima, ficamos com:
e fazendo os ajustes necessários, teremos:
