Início / coding / Perguntas / 78822405
Accepted
Lol ilol
Asked: 2024-08-02 01:50:45 +0800 CST

Como alterar a precisão de um ponto flutuante em C em tempo de execução?

  • 772

Como tornar uma variável float complexa ou dupla complexa dependendo da entrada do usuário? Estou tentando traçar o conjunto de Mandelbrot e tenho o mesmo código longo para float e double, mas em alguns casos float não é preciso o suficiente e double é muito lento. Estou executando em uma calculadora de baixo desempenho, então float leva menos de 1 segundo e double leva pelo menos 5 segundos. Gostaria de permitir que o usuário escolhesse precisão em vez de velocidade ou velocidade em vez de precisão. Eu gostaria de obter algo assim:

int user_input;
scanf("%d", &user_input);

switch (user_input) {
      case 0:
          float z;
          float c;
          break;
      case 1:
          double z;
          double c;
          break;
}
for(int i=0;i<1920;i++){
    for(int j=0;j<1080;j++){
        z=0.0+0.0*I;
        c=(i+j*I)/Zoom
}}

Resultado esperado: se o usuário digitar 0, todos os cálculos serão realizados usando floats, e se o usuário digitar 1, os cálculos serão realizados usando doubles.

Mas isso gera um erro: tipos conflitantes para 'z'; tem 'double', declaração anterior de 'z' com tipo 'float'.

Algo assim é possível em C?

Tentei criar duas variáveis ​​diferentes para float e double, mas alterá-las em todo o código (tenho muito mais código) seria longo e tedioso.

c

3 respostas

  1. Você não pode alterar o tipo de uma variável depois de compilada, mas pode usar uma macro semelhante a uma função para criar uma versão diferente da mesma função para cada tipo que você possa usar, sem precisar duplicar o código, por mais que você possa usar modelos em outros idiomas:

    #include <stdio.h>

#define MANDELBROT(T)               \
void mandelbrot_##T(T I, T Zoom) {  \
    T z, c;                         \
    for(int i=0;i<1920;i++){        \
        for(int j=0;j<1080;j++){    \
            z=0.0+0.0*I;            \
            c=(i+j*I)/Zoom;         \
        }                           \
    }                               \
}

MANDELBROT(double)
MANDELBROT(float)

int main(void) {
    int user_input;
    scanf("%d", &user_input);

    double Zoom = 1.0, I = 1.0;
    if (user_input) {
        mandelbrot_double(I, Zoom);
    }
    else {
        mandelbrot_float(I, Zoom);
    }
}

    Se você tem um monte de funções como essa e não quer declarar absolutamente tudo como uma macro (já que colocar barras invertidas depois de cada linha é chato e torna mais difícil para os depuradores saberem em quais linhas as coisas estão definidas ), você pode fazer assim:

    modelos.h:

    /* 
By wrapping all function names in the NAME macro, we get a different identifier
depending on whether we defined T as double or float before #including this file:
NAME("foo") will expand to "foo_double" if T is double.

Sometimes we have to do some minor wizardry to get a macro to fully expand,
which is why we have NAME2 and NAME3. Passing a macro to another 
macro sets a dirty-bit that causes it to be expanded properly.
*/

#define NAME3(S,U) S ## _ ## U
#define NAME2(S,U) NAME3(S,U)
#define NAME(S) NAME2(S,T)

void NAME(mandelbrot)(T I, T Zoom) {
    T z, c;
    for(int i=0;i<1920;i++){
        for(int j=0;j<1080;j++){
            z=0.0+0.0*I;
            c=(i+j*I)/Zoom;
        }
    } 
}

#undef T
#undef NAME
#undef NAME2
#undef NAME3

    principal.c:

    #define T double
#include "templates.h"
#define T float
#include "templates.h"

int main(void) {
    mandelbrot_double(1,1);
    mandelbrot_float(1,1);
}

    Uma observação lateral: como chux apontou nos comentários, Ié uma macro de complex.h, então você deve nomear outra coisa (a menos que essa macro seja o que você pretendia usar ).

    • 5

  2. Você não pode. O compilador precisa saber o tipo da variável para gerar o código apropriado.

    No seu cenário, eu criaria um programa que pudesse ser compilado em dois executáveis ​​diferentes: um que usa floate outro que usa double.

    #ifdef USEDOUBLE
   typedef double Number;
#else
   typedef float Number;
#endif

Number z;

    gcc             plot.c -o plot_float
gcc -DUSEDOUBLE plot.c -o plot_double

    Outra possibilidade é criar duas versões de tudo. Na verdade, você não deseja escrever dois de tudo, então usaria a abordagem anterior para criar duas bibliotecas e, em seguida, carregaria a apropriada em tempo de execução.

    • 3
  3. Best Answer

    A única solução viável em sistemas modernos que suportam vinculação dinâmica é compilar uma versão do seu programa usando floate outra usando double. Então o programa principal carregará a versão correta da biblioteca dinâmica e executará a versão solicitada.

    • 0

relate perguntas