Format de chaîne de caractères en notation scientifique

J'ai une chaîne qui ressemble à ceci:

"0.4794255386042030002732879352156"

qui est environ le péché(0.5). Je voudrais formater la chaîne à regarder beaucoup plus agréable

"4.794255386042e-1"

Comment puis-je y parvenir? Rappelez-vous que je fais affaire avec des chaînes de caractères et non des nombres (float, double). Aussi j'ai besoin de tour à conserver un nombre aussi précis que possible, je ne peux pas juste de les tronquer. Si j'ai besoin de convertir un type de données différent, je préfère un long double en raison d'un double régulière n'a pas assez de précision. J'aimerais au moins 12 chiffres après la virgule avant l'arrondi. Peut-être il ya un moyen simple sprintf() de conversion que je pouvais faire.

OriginalL'auteur John Scipione | 2009-12-29

c++math string

Quelque chose comme ceci:

#include<iostream>
using namespace std;

int main()
{
        char *s = "0.4794255386042030002732879352156";
        double d;

        sscanf(s,"%lf",&d);
        printf("%.12e\n",d);

        return EXIT_SUCCESS;
}

De sortie:

# g++ a.cpp  && ./a.out
4.794255386042e-01

OriginalL'auteur codaddict

Vous êtes à la recherche de quelque chose comme cette?

Voici un exemple:

 //modify basefield
#include <iostream>
#include <sstream>

using namespace std;

int main () {
    std::string numbers("0.4794255386042030002732879352156");
    std::stringstream stream;
    stream << numbers;
    double number_fmt;
    stream >> number_fmt;
    cout.precision(30);

    cout << number_fmt << endl;

    cout.precision(5);
    cout << scientific << number_fmt << endl;
  return 0;
}

De sortie:

0.479425538604203005377257795772

4.79426 e-01

OriginalL'auteur coelhudo

Hautement portable C l'exemple ci-dessous sorties:

result is 4.794255386042E-01


#include <stdio.h>

int main()
{
    char *str = "0.4794255386042030002732879352156";

    double f;
    char   newstr [50];
    //convert string in `str` to float
    sscanf (str, "%le", &f);

    sprintf (newstr, "%.12E", f);
    printf ("result is %s\n", newstr);
    return 0;
}

OriginalL'auteur wallyk

3

En regardant les chaînes dans votre question, il semblerait que vous utilisez en base 10 des logarithmes. Dans ce cas, ne serait-il pas relativement facile de simplement compter le chef de file ou les zéros à droite et placez-la dans un exposant, par la numérisation des chaînes directement?

Peut-être que je suis absent quelque chose..

D'accord. Dans ce cas, il pourrait tout simplement de trouver la position du point, le déplacer, et ajouter l'exposant comme un compte de la façon dont la mesure et la direction dans laquelle le point a été déplacé.

OriginalL'auteur S.C. Madsen
2

IEEE 754 64 bits en virgule flottante (c'est à dire double précision), il est bon pour 15 décimal chiffres significatifs, de sorte que vous ne devriez avoir aucun problème de conversion de double. Vous êtes plus susceptible de fonctionner dans le problème d'avoir le spécificateur de format d'affichage de tous les chiffres disponibles. Bien que dans les exemples affichés, cela ne semble pas être le cas.

vous êtes à la droite d'un double est assez bon une fois que j'ai ajouté dans un format approprié à la chaîne j'ai même eu 17 chiffres décimaux d'un double, je suis sûr que je pourrais obtenir plus de mais qui est beaucoup.
Pas avec un double, vous ne pouviez pas! En fait même pas 17 est possible quelle que soit la chose que vous avez obtenu. La mantisse est de 52 bits, 2^52 est un de 16 chiffres, nombre décimal, donc à la limite est de 15 chiffres (mathématiquement 15.65 chiffres) parce que les 52 bits est suffisant pour représenter tous les possible de 15 chiffres. Notez que je parle de l'importance des chiffres pas de décimales.

OriginalL'auteur Clifford
2

Convertir à long double à l'aide de sscanf(), puis utilisez sprintf() de l'imprimer et d'en ressortir une chaîne de caractères, en utilisant les scientifiques formateur:
```
long double x;
char num[64];

if(sscanf(string, "%Lf", &x) == 1)
  sprintf(num, "%.12Le", x);
```
Ne sais pas si, même long double effectivement vous donne 12 chiffres significatifs. Sur mon système, cela génère "4.79425538604e-01".

did you mean if(sscanf(chaine, "%Lf", &x) == 1) parce que %Ld donne un entier de type long?
Oui, merci!

OriginalL'auteur unwind
0

Il n'y a pas de norme en fonction en C ou C++ pour ce faire. L'approche normale est soit pour convertir un nombre (et ensuite utiliser les fonctions standard de format de nombre), ou écrire votre propre fonction de sortie.

OriginalL'auteur
0
```
#include <iostream>
using namespace std;
...
double dd = strtod( str );
cout << scientific << dd << endl;
```
Pas de sorties 0.4794255386042030002732879352156, ce qui n'est pas ce qu'il a demandé.
Non, il ne sort 4.794255 e-01 ( la précision par défaut est 6 ). 'cout.précision(12) " serait fixé à douze.

OriginalL'auteur Sanjaya R
0

En fonction du nombre de décimales que vous souhaitez (12 dans ce cas), vous pourriez faire quelque chose comme ceci:
```
int main() { 
  char buff[500];
  string x = "0.4794255386042030002732879352156";
  double f = atof(x.c_str());
  sprintf(buff,"%.12fe-1",f*10);
  cout<<buff<<endl;
  return 0;
}
```
Résultat:
---------- Sortie De Capture ----------

"c:\windows\system32\cmd.exe" /c c:\temp\temp.exe
4.794255386042 e-1
Arrêté avec le code de sortie 0.

OriginalL'auteur dcp

Vous devez vous connecter pour publier un commentaire.