Notação de número de ponto flutuante

[Vinícius Lopes Simões]

Olá, gostaria de saber como representar e realizar operações com números de ponto flutuante com a utilização da mantissa e expoente.

 

Exemplos: 1230 ---> mantissa: 123 ...... expoente: 1 ........ 123E1 = 123101

                  12,3 ---> mantissa: 123 .......expoente: -1 ....... 123E-1 = 123001

                  -10,41-> mantissa: -1041 ......expoente: -2 ......1041E-2 = 1041002

 

Logo, para somar dois números nessa notação eles precisam estar com o mesmo expoente, mas eu não sei como mudar os expoentes e realizar a soma:

 

Exemplo: 325E8 + 456E3 = 325E8 + 4E3 = 325004E5, ou seja

                325108 + 456103 = 325004105 (nesse caso houve redução da mantissa).

 

Muito obrigado!!

[Ansi C]

Exemplo: 325001 + 2638104   =  325026102

Tem-se:  325E+1 + 2638E-04 =  325026E-02

               3250     + 0,2638      =  325026E-02 => 3250,26

 

 

É isso mesmo o meu entendimento

ou será que viajei 

hei? Vinícius Lopes Simões

 

Caramba!

Para modelo de notação Cientifica essa transcrição no sentido vise-versa é tenso.

Considero um desafio dos mais difíceis, e os colegas mais experientes???

Eu acho que; para igualar as base você teria de acrescentar casa decimais.

Através do resto da divisão %10 é possível determina a expoente e também o sinal.

imagino como:

 

Em (2638E-04 para 2638E0 ) => é preciso E+04, e no outro número também:

325E(+1+ 4) + 2638E(- 4 + 4) => 32500000E0 + 2638E0 = 32502638 => 32502638E0

Resolução: 32502638E-4. Pois é -4 a menor base.

 

Se a precisão for E-2, sai os 2 últimos dígitos: 325026E-02 => 325026102 => 3250,26

Parece que assim há uma possível solução, resta a pior parte comprovar.

Espero ter ajudado de alguma forma, BOA SORTE! 

 

 

 

{'!'}

[isrnick]

Parece estar faltando informação sobre as especificações do problema.

 

Pois, por que está sendo usada a notação "mantissa + 1 dígito indicador do sinal do expoente + 2 dígitos para indicar o expoente"? Isso significa que é obrigatório que os números sejam fornecidos em 1 único número inteiro? Ou seria permitido usar 2 números separados indicando mantissa e expoente?

 

E existe um número máximo que pode ser usado, ou talvez um número máximo de dígitos da mantissa? Ou deve-se assumir o valor máximo da variável int? Pois isso é o que definiria a necessidade de descartar dígitos de menor relevância, como no caso do exemplo de soma fornecido, que descarta os 2 últimos dígitos do resultado da soma...

[Vinícius Lopes Simões]

Então, os números fornecidos devem estar em um único inteiro.

 

Como a máxima quantidade de dígitos permitida pela variável int é 9, a mantissa deve ter um tamanho menor ou igual a 6 dígitos (já que os outros três últimos dígitos representam o sinal e o valor do expoente). Caso, após alguma operação, a mantissa tenha mais do que 6 dígitos, eles devem ser eliminados (ajustando-se os expoentes).

 

Eu modifiquei algumas informações na pergunta, agora ela está melhor elaborada.

[isrnick]

Aqui, eu fiz uma resolução (não fiz muitos testes então ainda pode ter algum problema):

#include <stdio.h>#include <stdlib.h>void separamantissaeexpoente(int n, int *mantissa, int *expoente){    *expoente = abs(n) % 100;    n /= 100;    if (abs(n) % 10 == 1)        *expoente *= -1;    *mantissa = n / 10;}int combinamantissaeexpoente(int mantissa, int expoente){    int num, contdigitos = 0;    if (mantissa != 0){        while (abs(mantissa) % 10 == 0) {            mantissa /= 10;            expoente++;        }        for (num = mantissa; num != 0; num /= 10)            contdigitos++;        while (contdigitos > 6) {            mantissa /= 10;            expoente++;            contdigitos--;        }    }    else        expoente = 0;        if (abs(expoente) <= 99){        if (expoente >= 0){            if (mantissa >= 0)                return ((mantissa * 1000) + expoente);            else                return ((mantissa * 1000) - expoente);        }        else {            if (mantissa >= 0)                return ((mantissa * 1000) + 100 + abs(expoente));            else                return ((mantissa * 1000) - 100 - abs(expoente));        }    }    else        return 1200;}void igualaexpoentes (int *mantissa1, int *expoente1, int *mantissa2, int *expoente2){    int num, contdigitos = 0;    if(*expoente1 != *expoente2) {        if(*expoente1 > *expoente2) {            for (num = *mantissa1; num != 0; num /= 10)                contdigitos++;            while (contdigitos < 6 && *expoente1 > *expoente2) {                *mantissa1 *= 10;                *expoente1 -= 1;                contdigitos++;            }            while (*expoente1 > *expoente2) {                *mantissa2 /= 10;                *expoente2 += 1;            }        }        else {            for (num = *mantissa2; num != 0; num /= 10)                contdigitos++;            while (contdigitos < 6 && *expoente1 < *expoente2) {                *mantissa2 *= 10;                *expoente2 -= 1;                contdigitos++;            }            while (*expoente1 < *expoente2) {                *mantissa1 /= 10;                *expoente1 += 1;            }        }    }}int soma(int n1, int n2){    int mantissa1, expoente1, mantissa2, expoente2, mantissa3, expoente3;    separamantissaeexpoente(n1, &mantissa1, &expoente1);    separamantissaeexpoente(n2, &mantissa2, &expoente2);    igualaexpoentes (&mantissa1, &expoente1, &mantissa2, &expoente2);    mantissa3 = mantissa1 + mantissa2;    expoente3 = expoente1;    return combinamantissaeexpoente(mantissa3, expoente3);}int main() {    int n1, n2;    printf("Digite o primeiro número: ");    scanf("%d", &n1);    printf("Digite o segundo número: ");    scanf("%d", &n2);    printf("Soma: %d\n", soma(n1, n2));    return 0;}

O que fiz foi sempre expandir o número que tem o maior expoente até ele ter 6 dígitos (e decrementa o expoente pra compensar) ou até seu expoente se igualar ao expoente menor, se chegar aos 6 dígitos e os expoentes ainda não forem iguais ele começa a incrementar o expoente menor (e excluir dígitos menos significativos de sua respectiva mantissa) até eles se igualarem.

Ex:325008 + 456003325008 -> mantissa = 325 e expoente = 8 -> Expande para 6 dígitos:  mantissa = 325000 e expoente = 5Chegou no limite mas os números ainda não tem expoentes iguais, logo precisamos começar a incrementar o expoente menor (e excluir dígitos menos significativos):456003 -> mantissa = 456 e expoente = 3 -> Incrementa expoente: mantissa = 4 e expoente = 5Agora podemos somar as mantissas:325000 + 4 = 325004Resultado: mantissa = 325004 e expoente = 5 -> 325004005

[Vinícius Lopes Simões]

E se houvesse uma mudança e o terceiro algarismo significativo fosse 0 para expoentes positivos e 1 para negativos? O que mudaria neste teu código?

 

Obrigado pela atenção!!

[isrnick]

Nada, o programa já funciona desta forma, deveria operar normalmente mesmo com mantissa e/ou expoentes negativos... Você fez testes com expoentes negativos? Encontrou erros?

[Vinícius Lopes Simões]

A soma deu certinho aqui sim, valeu!!

 

[Vinícius Lopes Simões]

.