Vírgula flutuante. Tipos float, double, long double. Uso de funções. Exercícios

Transcrição

1 Vírgula flutuante. Tipos float, double, long double. Uso de funções. Exercícios David Déharbe 1 1

2 Objetivos da aula Complementar os conhecimentos sobre a construção de expressões Novos tipos para valores númericos não inteiros: float, double, long double. Operações aritméticas Conversão Uso de funções pré-definidas O arquivo cabeçalho math.h 2 2

3 Motivação Aplicações tratando de dados numéricos não inteiros. Quantidades físicas são contínuas; Necessidade de trabalhar com números não inteiros. Necessidade de representar e combinar números não inteiros. Padrão IEEE 754. Baseado na notação científica 300 = = 3, /3 = 3, Este não possui representação decimal finita! 3 3

4 Representação em vírgula flutuante A representação de um número com vírgula flutuante é composta de três elementos: mantissa (m) base (b) expoente (e) m b e Para uma determinada representação, o número de dígitos da mantissa e do expoente são fixos. A mantissa e o expoente têm sinal. Exemplos (IEEE 754): binary32 (precisão simples): b = 2, m: 23+1 bits, e: binary64 (precisão dupla): b = 2, m: 52+1 bits, e: INFINITY, NEG_INFINITY, NaN 4 4

5 Representação em vírgula flutuante Representação binária, precisão simples: mantissa expoente +/- valor +/- valor INFINITY, NEG_INFINITY, NaN codificações dedicadas. 5 5

6 Os tipos C para vírgula flutuante: float float: precisão simples #include <float.h> /* para FLT_MIN, FLT_MAX */ #include <stdio.h> /* para printf */ int main () { printf("size: %lu, min = %e, max = %e\n", sizeof(float), FLT_MIN, FLT_MAX); return 0; } localhost:~ david$./float1 float. size: 4, min = e-38, max = e

7 Os tipos C para vírgula flutuante: float float: precisão simples #include <stdio.h> /* para printf */ int main () { float x = 3.45f; float y = f; float a, s, m, d; a = x + y; s = x - y; m = x * y; d = x / y; printf("x = %e, y = %e, a = %e, s = %e, m = %e, d = %e\n", x, y, a, s, m, d); printf("x = %f, y = %f, a = %f, s = %f, m = %f, d = %f\n", x, y, a, s, m, d); printf("x = %.3f, y = %.3f, a = %.3f, s = %.3f, m = %.3f, d = %.3f\n", x, y, a, s, m, d); } return 0; 7 7

8 Os tipos C para vírgula flutuante: float localhost:~ david$./float2 x = e+00, y = e+02, a = e+02, s = e +02, m = e+02, d = e-02 #include x float: = , precisão <stdio.h> y = simples /* , para printf a */ = , s = , m = , d = int x = main 3.450, () y = , a = , s = , m = , d = { float x = 3.45f; float y = f; float a, s, m, d; a = x + y; s = x - y; m = x * y; d = x / y; printf("x = %e, y = %e, a = %e, s = %e, m = %e, d = %e\n", x, y, a, s, m, d); printf("x = %f, y = %f, a = %f, s = %f, m = %f, d = %f\n", x, y, a, s, m, d); printf("x = %.3f, y = %.3f, a = %.3f, s = %.3f, m = %.3f, d = %.3f\n", x, y, a, s, m, d); } return 0; 7 7

9 Os tipos C para vírgula flutuante: double double: precisão dupla #include <float.h> /* para DBL_MIN, DBL_MAX */ #include <stdio.h> /* para printf */ int main () { printf("double. size: %lu, min = %e, max = %e\n", sizeof(double), DBL_MIN, DBL_MAX); } return 0; localhost:~ david$./double1 double. size: 8, min = E-308, max = E

10 Os tipos C para vírgula flutuante: double float: precisão simples #include <stdio.h> /* para printf */ int main () { double x = 3.45; double y = ; double a, s, m, d; a = x + y; s = x - y; m = x * y; d = x / y; printf("x = %le, y = %le, a = %le, s = %le, m = %le, d = %le\n", x, y, a, s, m, d); printf("x = %lf, y = %lf, a = %lf, s = %lf, m = %lf, d = %lf\n", x, y, a, s, m, d); printf("x = %.3lf, y = %.3lf, a = %.3lf, s = %.3lf, m = %.3lf, d = %.3lf\n", x, y, a, s, m, d); } return 0; 9 9

11 int main () { double x = 3.45; double y = ; double a, s, m, d; a = x + y; s = x - y; m = x * y; d = x / y; Os tipos C para vírgula flutuante: double localhost:~ david$./double2 x = e+00, y = e+02, a = e+02, s = e +02, m = e+02, d = e-02 x float: = , precisão y = simples , a = , s = , m = #include , <stdio.h> d = /* para printf */ x = 3.450, y = , a = , s = , m = , d = printf("x = %le, y = %le, a = %le, s = %le, m = %le, d = %le\n", x, y, a, s, m, d); printf("x = %lf, y = %lf, a = %lf, s = %lf, m = %lf, d = %lf\n", x, y, a, s, m, d); printf("x = %.3lf, y = %.3lf, a = %.3lf, s = %.3lf, m = %.3lf, d = %.3lf\n", x, y, a, s, m, d); } return 0; 9 9

12 Os tipos C para vírgula flutuante: long double double: entre precisão dupla e quadrupla #include <float.h> /* para LDBL_MIN, LDBL_MAX */ #include <stdio.h> /* para printf */ int main () { printf("double. size: %lu, min = %Le, max = %Le\n", sizeof(double), LDBL_MIN, LDBL_MAX); } return 0; localhost:~ david$./ldouble1 long double. size: 16, min = e-4932, max = e

13 Os tipos C para vírgula flutuante: float #include <stdio.h> /* para printf */ float: precisão simples int main () { long double x = 3.45L; long double y = L; long double a, s, m, d; a = x + y; s = x - y; m = x * y; d = x / y; printf("x = %Le, y = %Le, a = %Le, s = %Le, m = %Le, d = %Le\n", x, y, a, s, m, d); printf("x = %Lf, y = %Lf, a = %Lf, s = %Lf, m = %Lf, d = %Lf\n", x, y, a, s, m, d); printf("x = %.3Lf, y = %.3Lf, a = %.3Lf, s = %.3Lf, m = %.3Lf, d = %.3Lf\n", x, y, a, s, m, d); } return 0; 11 11

14 localhost:~ david$./ldouble2 x = e+00, Os tipos y = C e+02, para vírgula a flutuante: = e+02, float s = e #include +02, m = <stdio.h> e+02, /* para d printf = e-02 */ x = , y = , a = , s = , m = int , float: main precisão () d = simples { x = 3.450, y = , a = , s = , m = , d = long double x = 3.45L; long double y = L; long double a, s, m, d; a = x + y; s = x - y; m = x * y; d = x / y; printf("x = %Le, y = %Le, a = %Le, s = %Le, m = %Le, d = %Le\n", x, y, a, s, m, d); printf("x = %Lf, y = %Lf, a = %Lf, s = %Lf, m = %Lf, d = %Lf\n", x, y, a, s, m, d); printf("x = %.3Lf, y = %.3Lf, a = %.3Lf, s = %.3Lf, m = %.3Lf, d = %.3Lf\n", x, y, a, s, m, d); } return 0; 11 11

15 Os tipos C para vírgula flutuante float: precisão simples double: precisão dupla long double: pelo menos precisão dupla, e até precisão quadrupla. #include <float.h> /* para FLT_MIN, FLT_MAX */ #include <stdio.h> /* para printf */ int main () { float x, y, d1, d2, d3; x = 3.45f; y =.0f; d1 = x / y; d2 = -x / y; d3 = y / y; printf("d1 = %e, d2 = %e, d3 = %e\n", d1, d2, d3); } return 0; localhost:~ david$./float3 d1 = inf, d2 = -inf, d3 = nan 12 12

16 Precisão A representação dos números é finitas. A representação decimal dos números reais pode ter um número infinito de dígitos. Arredondamentos são efetuados. O acúmulo de arredondamentos torna cada vez mais imprecisa o cálculo. Para calcular se dois valores float são iguais, as vezes deve-se satisfazer em testar se são "próximos" o suficiente. Supondo que próximo o suficiente seja 10-9 : float EPSILON = 1e-9; /* teste de quase-igualdade */ -EPSILON < v1 - v2 && v1 - v2 < EPSILON 13 13

17 Conversão Em C, valores int e float são convertidos "silenciosamente": o compilador não emite erros não há erros em tempo de execução. float f1 = 10.8f; float f2 = 1.5f; int i1 = f1/f2; 14 14

18 Conversão Em C, valores int e float são convertidos "silenciosamente": o compilador não emite erros não há erros em tempo de execução. float f1 = 10.8f; { float f2 = 1.5f; int i1 = f1/f2; #include <stdio.h> int main () } int i1 = 4; int i2 = 10; float f; f = i1 / i2; printf("f = %f.\n", f); f = (float) i1 / i2; printf("f = %f.\n", f); f = i1 / (float) i2; printf("f = %f.\n", f); f = (float) (i1 / i2); printf("f = %f.\n", f); return 0; 14 14

19 Conversão Em C, valores int e float são convertidos "silenciosamente": o compilador não emite erros não há erros em tempo de execução. float f1 = 10.8f; float f2 = 1.5f; int i1 = f1/f2; int main () { int i1 = 4; int i2 = 10; float f; f = i1 / i2; printf("f = %f.\n", f); f = (float) i1 / i2; printf("f = %f.\n", f); f = i1 / (float) i2; printf("f = %f.\n", f); f = (float) (i1 / i2); printf("f = %f.\n", f); return 0; localhost:~ david$./conv1 } f = f = f = f =

20 Regras de conversão De int para float: a parte decimal é nula. De vírgula flutuante para int, a parte decimal é truncada. Se uma operação tiver um operando vírgula flutuante e outro int, o valor int é convertido para o tipo vírgula flutuante: 3.2 / 2 é convertido para 3.2 / 2.0 e é avaliado como 1.6 Para fazer uma conversão explícita, colocar o nome do tipo destino entre parênteses antes da expressão. int i = (int) 3.14; Tem precedência maior que as operações binárias (float) 3 / 2 é avaliado em 3. / 2 ou seja 3. / 2. ou seja

21 O arquivo cabeçalho math.h Fornece funcionalidades adicionais como operadores trigonométricos operadores logarítmicos valor absoluto etc. Cada função matemática é implementada através de uma função C. Função C: trecho de código isolado com um nome que o identifica e que possui parâmetros (argumentos, operandos), e retorna um resultado. Para usar: nome da função, parâmetros entre parênteses. Exemplo: double x = acos(-1.); 16 16

22 Algumas funções providas através de math.h /* tipo do resultado nome (tipo dos parâmetros) */ /* funções trigonométricas para double*/ double cos (double); double sin (double); double tan (double); double acos (double); double asin (double); double atan (double); float cosf (float);... long double cosl (long double); 17 17

23 Algumas funções providas através de math.h /* funções exponenciais e logarítmicas */ double exp (double); /* exponencial em base e */ double exp2 (double); /* exponencial em base 2 */ double log (double); /* logaritmo em base e */ double log2 (double); /* logaritmo em base 10 */ double log10 (double); /* logaritmo em base 10 */ 18 18

24 Algumas funções providas através de math.h /* funções diversas */ double fabs (double); /* valor absoluto */ double pow (double, double); /* potência */ double sqrt (double); /* raiz quadrada */ double ceil (double); /* arredondamento superior */ double floor (double); /* arredondamento inferior */ double round (double); /* arredondamento */ double fmax (double, double); /* maior dos args */ double fmin (double, double); /* menor dos args */ 19 19

25 Exercícios Escreva um programa que lê dois números, digamos X e Y, onde X representa um capital em reais, e Y uma taxa de juros mensais e imprime o montante de cada mês durante o período de um ano

26 Exercícios Escreva uma sub-rotina para determinar se uma equação linear de uma variável possui zero, uma ou uma infinidade de solução e, caso possua uma solução, determine esta solução. A interface da sub-rotina deve ser: int solve_eq_lin (double a, double b, double * s); Para a equação ax + b = 0, a chamada a solve_eq_lin(a, b) deve: retornar 0 se não há solução; retornar -1 se há uma infinidade de soluções; retornar 1 se há uma solução, e escrever esta solução no endereço apontado por s

27 Exercícios Em matemática, o n-ésimo número harmônico é definido pela seguinte equação: H(n) = n k=1 1 k = n n Escreva um programa que calcule e imprime os 10 primeiros números harmônicos

28 Exercícios Uma maneira de calcular o valor do número π é utilizar a seguinte série: π=4/1 4/3+4/5 4/7+4/9 4/ Fazer um programa para calcular e imprimir um valor aproximado de π calculado com os 10 primeiros elementos da série acima