Aritmética e Álgebra COM10615-Tópicos Especiais em Programação I edmar.kampke@ufes.br

Transcrição

1 Aritmética e Álgebra COM10615-Tópicos Especiais em Programação I edmar.kampke@ufes.br

2 Introdução Forte relação entre Matemática e Computação Aritmética e Álgebra são as partes mais elementares da matemática Alguns problemas usam estes conceitos de forma não-elementar. 2

3 Máquina Aritmética 3

4 Máquina Aritmética Números float possuem magnitude muito grande Com Double precision essa magnitude é ainda maior Mesmo assim é restrita: a x 2 c, onde a e c são um número pré-determinado de bits Observe que apesar disso float não te permite contar números muito grandes! Portanto use integers e long 4

5 Máquina Aritmética Números positivos (binário positivos) Números Negativos (complemento de dois) Bibliotecas: stdlib.h (Valor absoluto e números aleatórios) math.h (Piso, teto, raiz-quadrada e exponencial) Classe Integer tem a precisão e magnitude que precisamos. Porém em alguns problemas você terá que criar seu tipo específico 5

6 Inteiros de Alta Precisão Representar enormes números inteiros exigem que sejam representados como strings. 1) Arrays de Dígitos Representar um número inteiro como um vetor de dígitos, sendo o menos significativo o primeiro elemento do vetor. Armazenar a quantidade de dígitos 2) Listas Encadeadas de Dígitos Usadas somente se o limite superior não for definido, por ser dinâmicas. 6

7 Exemplo: Inteiro de Alta Precisão #define MAXDIGITS 100 /* maximum length bignum */ #define PLUS 1 /* positive sign bit */ #define MINUS -1 /* negative sign bit */ typedef struct { char digits[maxdigits]; /* represent the number */ int signbit; /* PLUS or MINUS */ int lastdigit; /* index of high-order digit */ bignum; 7

8 Impressão print_bignum(bignum *n) { int i; if (n->signbit == MINUS) printf("- "); for (i=n->lastdigit; i>=0; i--) printf("%c", 0 + n->digits[i]); printf("\n"); 8

9 Adição Somar dois números: Da direita para esquerda! Respeitar o Mais um Números Negativos na Adição vão ser subtraídos. Por isso sinal dos números deve ser respeitado. 9

10 Adição add_bignum(bignum *a, bignum *b, bignum *c) { int carry; /* carry digit */ int i; /* counter */ initialize_bignum(c); if (a->signbit == b->signbit) c->signbit = a->signbit; else { if (a->signbit == MINUS) { a->signbit = PLUS; subtract_bignum(b,a,c); a->signbit = MINUS; else { b->signbit = PLUS; subtract_bignum(a,b,c); b->signbit = MINUS; return; c->lastdigit = max(a->lastdigit,b->lastdigit)+1; carry = 0; for (i=0; i<=(c->lastdigit); i++) { c->digits[i] = (char) (carry+a->digits[i]+b->digits[i]) % 10; carry = (carry + a->digits[i] + b->digits[i]) / 10; zero_justify(c); 10

11 Zero a Esquerda Cuidado na hora de trabalhar com o signbit Adição é facilitada preenchendo os dígitos de alta ordem com 0 e tratar o mais um final como caso especial de dígito extra A função zero_justify ajusta o último dígito para evitar zeros a esquerda 11

12 Zero a Esquerda zero_justify(bignum *n) { while ((n->lastdigit > 0) && (n->digits[n->lastdigit]==0)) n->lastdigit--; if ((n->lastdigit == 0) && (n->digits[0] == 0)) n->signbit = PLUS; /* hack to avoid -0 */ 12

13 Subtração A subtração é mais complicada Necessita de empréstimos e garantia os empréstimos terminam Por isso, é melhor ter certeza de que o número de maior magnitude não ultrapassa o limite. 13

14 Subtração subtract_bignum(bignum *a, bignum *b, bignum *c) { int borrow; /* anything borrowed? */ int v; /* placeholder digit */ int i; /* counter */ if ((a->signbit == MINUS) (b->signbit == MINUS)) { b->signbit = -1 * b->signbit; add_bignum(a,b,c); b->signbit = -1 * b->signbit; return; if (compare_bignum(a,b) == PLUS) { subtract_bignum(b,a,c); c->signbit = MINUS; return; 14

15 Subtração c->lastdigit = max(a->lastdigit,b->lastdigit); borrow = 0; for (i=0; i<=(c->lastdigit); i++) { v = (a->digits[i] - borrow - b->digits[i]); if (a->digits[i] > 0) borrow = 0; if (v < 0) { v = v + 10; borrow = 1; c->digits[i] = (char) v % 10; zero_justify(c); 15

16 Comparação É necessário decidir qual dos dois números é maior. Isso requer um operador de comparação. A comparação procede do dígito da esquerda (dígito mais significativo) para a direita. Antes compara o bit de sinal. 16

17 Comparação compare_bignum(bignum *a, bignum *b) { int i; /* counter */ if ((a->signbit==minus) && (b->signbit==plus)) return(plus); if ((a->signbit==plus) && (b->signbit==minus)) return(minus); if (b->lastdigit > a->lastdigit) return (PLUS * a->signbit); if (a->lastdigit > b->lastdigit) return (MINUS * a->signbit); for (i = a->lastdigit; i>=0; i--) { if (a->digits[i] > b->digits[i]) return(minus * a->signbit); if (b->digits[i] > a->digits[i]) return(plus * a->signbit); return(0); 17

18 Multiplicação multiply_bignum(bignum *a, bignum *b, bignum *c) { bignum row; /* represent shifted row */ bignum tmp; /* placeholder bignum */ int i,j; /* counters */ initialize_bignum(c); row = *a; for (i=0; i<=b->lastdigit; i++) { for (j=1; j<=b->digits[i]; j++) { add_bignum(c,&row,&tmp); *c = tmp; digit_shift(&row,1); c->signbit = a->signbit * b->signbit; zero_justify(c); 18

19 Recuo do Dígito digit_shift(bignum *n, int d) /* multiply n by 10ˆd */ { int i; /* counter */ if ((n->lastdigit == 0) && (n->digits[0] == 0)) return; for (i=n->lastdigit; i>=0; i--) n->digits[i+d] = n->digits[i]; for (i=0; i<d; i++) n->digits[i] = 0; n->lastdigit = n->lastdigit + d; 19

20 Divisão divide_bignum(bignum *a, bignum *b, bignum *c) { bignum row; /* represent shifted row */ bignum tmp; /* placeholder bignum */ int asign, bsign; /* temporary signs */ int i,j; /* counters */ initialize_bignum(c); c->signbit = a->signbit * b->signbit; asign = a->signbit; bsign = b->signbit; a->signbit = PLUS; b->signbit = PLUS; initialize_bignum(&row); initialize_bignum(&tmp); c->lastdigit = a->lastdigit; 20

21 Divisão for (i=a->lastdigit; i>=0; i--) { digit_shift(&row,1); row.digits[0] = a->digits[i]; c->digits[i] = 0; while (compare_bignum(&row,b)!= PLUS) { c->digits[i]++; subtract_bignum(&row,b,&tmp); row = tmp; zero_justify(c); a->signbit = asign; b->signbit = bsign; 21

22 Divisão Essa operação calcula apenas a divisão inteira Ignora o resto Para calcular o resto basta fazer: c = a bx(a/b) 22

23 Exponenciação A exponenciação é feita por multiplicações sucessivas a n = a n/2 x a n/2 x a n%2 Isso requer um número logarítmico de multiplicações: O(log2 n) 23

24 Exercícios Fáceis Primary Arithmetic Polynomial Coefficients Intermediários Reverse and Add Ones Difícil A Multiplication Game 24

25 Aritmética e Álgebra COM10615-Tópicos Especiais em Programação I edmar.kampke@ufes.br