Double conversion de chaîne sans la notation scientifique
https://stackoverflow.com/questions/1546113
-
20-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Comment convertir un double en une représentation de chaîne à virgule flottante sans notation scientifique dans le .NET Framework?
échantillons "petit" (numéros efficaces peuvent être de toute taille, comme 1.5E200 ou 1e-200):
3248971234698200000000000000000000000000000000
0.00000000000000000000000000000000000023897356978234562
Aucun des formats numériques standards sont comme ça, et format personnalisé ne semble pas aussi permettre d'avoir un nombre ouvert de chiffres après le séparateur décimal.
Ce n'est pas un double de Comment convertir deux à chaîne sans le pouvoir de représentation 10 (e-05) parce que les réponses qui y sont données font pas résoudre le problème à la main. La solution retenue dans cette question était d'utiliser un point fixe (par exemple 20 chiffres), ce qui est pas ce que je veux. Une mise en forme de point fixe et coupe le 0 redondant ne résout pas le problème, soit parce que la largeur maximale pour la largeur fixe est de 99 caractères.
Remarque:. la solution doit traiter correctement les formats numériques personnalisés (par exemple un autre séparateur décimal, en fonction des informations de culture)
Modifier La question est vraiment seulement displaing chiffres mentionnés ci-dessus. Je suis au courant de la façon dont les nombres à virgule flottante travail et ce nombre peut être utilisé et calculé avec eux.
La solution
Pour une solution générale-purpose¹ vous devez conserver 339 places:
doubleValue.ToString("0." + new string('#', 339))
Le nombre maximal de chiffres décimaux non nulle est de 16. 15 sont sur le côté droit de la virgule décimale. L'exposant peut déplacer ces 15 chiffres au maximum 324 places à droite. ( Voir toute la gamme et la précision. )
Il fonctionne pour double.Epsilon , double.MinValue , double.MaxValue , et rien entre.
La performance sera beaucoup plus grande que les solutions de manipulation regex / chaîne depuis tous les travaux de mise en forme et la chaîne se fait en un seul passage par code CLR non géré. En outre, le code est beaucoup plus simple de prouver correct.
Pour la facilité d'utilisation et une performance encore meilleure, en font une constante:
public static class FormatStrings
{
public const string DoubleFixedPoint = "0.###################################################################################################################################################################################################################################################################################################################################################";
}
¹ Mise à jour: je l'ai dit à tort que ce fut aussi une solution sans perte. En fait, ce n'est pas, puisque ToString fait son affichage normal arrondi pour tous les formats sauf r. exemple en direct. Merci, @Répugnance! S'il vous plaît voir la réponse Lothing si vous avez besoin de la capacité d'aller-retour en notation de point fixe (par exemple, si vous utilisez aujourd'hui .ToString("r")) .
Autres conseils
J'ai eu un problème similaire et cela a fonctionné pour moi:
doubleValue.ToString("F99").TrimEnd('0')
F99 peut être surpuissant, mais vous voyez l'idée.
Ceci est une solution d'analyse syntaxique de chaîne où le numéro de source (double) est convertie en une chaîne et analysé en ses composants constitutifs. Il est ensuite remonté par des règles dans la pleine longueur représentation numérique. Il tient également compte de la demande locale.
Mise à jour : Les tests des conversions comprennent uniquement des nombres entiers à un seul chiffre, ce qui est la norme, mais l'algorithme fonctionne aussi pour quelque chose comme: 239483.340901e-20
using System;
using System.Text;
using System.Globalization;
using System.Threading;
public class MyClass
{
public static void Main()
{
Console.WriteLine(ToLongString(1.23e-2));
Console.WriteLine(ToLongString(1.234e-5)); // 0.00010234
Console.WriteLine(ToLongString(1.2345E-10)); // 0.00000001002345
Console.WriteLine(ToLongString(1.23456E-20)); // 0.00000000000000000100023456
Console.WriteLine(ToLongString(5E-20));
Console.WriteLine("");
Console.WriteLine(ToLongString(1.23E+2)); // 123
Console.WriteLine(ToLongString(1.234e5)); // 1023400
Console.WriteLine(ToLongString(1.2345E10)); // 1002345000000
Console.WriteLine(ToLongString(-7.576E-05)); // -0.00007576
Console.WriteLine(ToLongString(1.23456e20));
Console.WriteLine(ToLongString(5e+20));
Console.WriteLine("");
Console.WriteLine(ToLongString(9.1093822E-31)); // mass of an electron
Console.WriteLine(ToLongString(5.9736e24)); // mass of the earth
Console.ReadLine();
}
private static string ToLongString(double input)
{
string strOrig = input.ToString();
string str = strOrig.ToUpper();
// if string representation was collapsed from scientific notation, just return it:
if (!str.Contains("E")) return strOrig;
bool negativeNumber = false;
if (str[0] == '-')
{
str = str.Remove(0, 1);
negativeNumber = true;
}
string sep = Thread.CurrentThread.CurrentCulture.NumberFormat.NumberDecimalSeparator;
char decSeparator = sep.ToCharArray()[0];
string[] exponentParts = str.Split('E');
string[] decimalParts = exponentParts[0].Split(decSeparator);
// fix missing decimal point:
if (decimalParts.Length==1) decimalParts = new string[]{exponentParts[0],"0"};
int exponentValue = int.Parse(exponentParts[1]);
string newNumber = decimalParts[0] + decimalParts[1];
string result;
if (exponentValue > 0)
{
result =
newNumber +
GetZeros(exponentValue - decimalParts[1].Length);
}
else // negative exponent
{
result =
"0" +
decSeparator +
GetZeros(exponentValue + decimalParts[0].Length) +
newNumber;
result = result.TrimEnd('0');
}
if (negativeNumber)
result = "-" + result;
return result;
}
private static string GetZeros(int zeroCount)
{
if (zeroCount < 0)
zeroCount = Math.Abs(zeroCount);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < zeroCount; i++) sb.Append("0");
return sb.ToString();
}
}
Vous pouvez lancer le double à decimal puis faire ToString().
(0.000000005).ToString() // 5E-09
((decimal)(0.000000005)).ToString() // 0,000000005
Je ne l'ai pas fait des tests de performance qui est plus rapide, la coulée de 64 bits double à decimal 128 bits ou une chaîne de format de plus de 300 caractères. Oh, et il pourrait éventuellement y avoir des erreurs de débordement lors de la conversion, mais si vos valeurs correspondent à un decimal cela fonctionne bien.
Mise à jour: Le casting semble être beaucoup plus rapide. En utilisant une chaîne de format préparé comme indiqué dans l'autre réponse, le formatage d'un million de fois prend 2,3 secondes et la coulée seulement 0,19 secondes. Répétables. C'est 10x plus rapide . Maintenant, il est seulement la plage de valeurs.
est ce que j'ai jusqu'à présent, semble fonctionner, mais peut-être quelqu'un a une meilleure solution:
private static readonly Regex rxScientific = new Regex(@"^(?<sign>-?)(?<head>\d+)(\.(?<tail>\d*?)0*)?E(?<exponent>[+\-]\d+)$", RegexOptions.IgnoreCase|RegexOptions.ExplicitCapture|RegexOptions.CultureInvariant);
public static string ToFloatingPointString(double value) {
return ToFloatingPointString(value, NumberFormatInfo.CurrentInfo);
}
public static string ToFloatingPointString(double value, NumberFormatInfo formatInfo) {
string result = value.ToString("r", NumberFormatInfo.InvariantInfo);
Match match = rxScientific.Match(result);
if (match.Success) {
Debug.WriteLine("Found scientific format: {0} => [{1}] [{2}] [{3}] [{4}]", result, match.Groups["sign"], match.Groups["head"], match.Groups["tail"], match.Groups["exponent"]);
int exponent = int.Parse(match.Groups["exponent"].Value, NumberStyles.Integer, NumberFormatInfo.InvariantInfo);
StringBuilder builder = new StringBuilder(result.Length+Math.Abs(exponent));
builder.Append(match.Groups["sign"].Value);
if (exponent >= 0) {
builder.Append(match.Groups["head"].Value);
string tail = match.Groups["tail"].Value;
if (exponent < tail.Length) {
builder.Append(tail, 0, exponent);
builder.Append(formatInfo.NumberDecimalSeparator);
builder.Append(tail, exponent, tail.Length-exponent);
} else {
builder.Append(tail);
builder.Append('0', exponent-tail.Length);
}
} else {
builder.Append('0');
builder.Append(formatInfo.NumberDecimalSeparator);
builder.Append('0', (-exponent)-1);
builder.Append(match.Groups["head"].Value);
builder.Append(match.Groups["tail"].Value);
}
result = builder.ToString();
}
return result;
}
// test code
double x = 1.0;
for (int i = 0; i < 200; i++) {
x /= 10;
}
Console.WriteLine(x);
Console.WriteLine(ToFloatingPointString(x));
Le problème en utilisant #.###...### ou F99 est qu'il ne conserve pas la précision aux décimales se terminant, par exemple:
String t1 = (0.0001/7).ToString("0." + new string('#', 339)); // 0.0000142857142857143
String t2 = (0.0001/7).ToString("r"); // 1.4285714285714287E-05
Le problème avec DecimalConverter.cs est qu'il est lent. Ce code est la même idée que la réponse de Sasik, mais deux fois plus vite. méthode d'essai de l'unité en bas.
public static class RoundTrip {
private static String[] zeros = new String[1000];
static RoundTrip() {
for (int i = 0; i < zeros.Length; i++) {
zeros[i] = new String('0', i);
}
}
private static String ToRoundTrip(double value) {
String str = value.ToString("r");
int x = str.IndexOf('E');
if (x < 0) return str;
int x1 = x + 1;
String exp = str.Substring(x1, str.Length - x1);
int e = int.Parse(exp);
String s = null;
int numDecimals = 0;
if (value < 0) {
int len = x - 3;
if (e >= 0) {
if (len > 0) {
s = str.Substring(0, 2) + str.Substring(3, len);
numDecimals = len;
}
else
s = str.Substring(0, 2);
}
else {
// remove the leading minus sign
if (len > 0) {
s = str.Substring(1, 1) + str.Substring(3, len);
numDecimals = len;
}
else
s = str.Substring(1, 1);
}
}
else {
int len = x - 2;
if (len > 0) {
s = str[0] + str.Substring(2, len);
numDecimals = len;
}
else
s = str[0].ToString();
}
if (e >= 0) {
e = e - numDecimals;
String z = (e < zeros.Length ? zeros[e] : new String('0', e));
s = s + z;
}
else {
e = (-e - 1);
String z = (e < zeros.Length ? zeros[e] : new String('0', e));
if (value < 0)
s = "-0." + z + s;
else
s = "0." + z + s;
}
return s;
}
private static void RoundTripUnitTest() {
StringBuilder sb33 = new StringBuilder();
double[] values = new [] { 123450000000000000.0, 1.0 / 7, 10000000000.0/7, 100000000000000000.0/7, 0.001/7, 0.0001/7, 100000000000000000.0, 0.00000000001,
1.23e-2, 1.234e-5, 1.2345E-10, 1.23456E-20, 5E-20, 1.23E+2, 1.234e5, 1.2345E10, -7.576E-05, 1.23456e20, 5e+20, 9.1093822E-31, 5.9736e24, double.Epsilon };
foreach (int sign in new [] { 1, -1 }) {
foreach (double val in values) {
double val2 = sign * val;
String s1 = val2.ToString("r");
String s2 = ToRoundTrip(val2);
double val2_ = double.Parse(s2);
double diff = Math.Abs(val2 - val2_);
if (diff != 0) {
throw new Exception("Value {0} did not pass ToRoundTrip.".Format2(val.ToString("r")));
}
sb33.AppendLine(s1);
sb33.AppendLine(s2);
sb33.AppendLine();
}
}
}
}
Dans le temps où nous devions écrire nos propres formatteurs, nous aimerions isoler la mantisse et exposant et les formater séparément.
Dans cet article par Jon Skeet ( https://csharpindepth.com/articles/FloatingPoint ) il fournit un lien vers sa routine DoubleConverter.cs qui devrait faire exactement ce que vous voulez. Skeet fait également référence à cette extraire mantisse et exposant de la double en c # .
La solution Logarithme-obligatoire. Notez que cette solution, car elle implique de faire des mathématiques, peut réduire la précision de votre numéro un peu. Pas fortement testé.
private static string DoubleToLongString(double x)
{
int shift = (int)Math.Log10(x);
if (Math.Abs(shift) <= 2)
{
return x.ToString();
}
if (shift < 0)
{
double y = x * Math.Pow(10, -shift);
return "0.".PadRight(-shift + 2, '0') + y.ToString().Substring(2);
}
else
{
double y = x * Math.Pow(10, 2 - shift);
return y + "".PadRight(shift - 2, '0');
}
}
Edit: Si la virgule traverse une partie non nulle du nombre, cet algorithme échouera lamentablement. J'ai essayé de simples et je suis allé trop loin.
Je viens improvisé sur le code ci-dessus pour le faire fonctionner pour des valeurs exponentielles négatives.
using System;
using System.Text.RegularExpressions;
using System.IO;
using System.Text;
using System.Threading;
namespace ConvertNumbersInScientificNotationToPlainNumbers
{
class Program
{
private static string ToLongString(double input)
{
string str = input.ToString(System.Globalization.CultureInfo.InvariantCulture);
// if string representation was collapsed from scientific notation, just return it:
if (!str.Contains("E")) return str;
var positive = true;
if (input < 0)
{
positive = false;
}
string sep = Thread.CurrentThread.CurrentCulture.NumberFormat.NumberDecimalSeparator;
char decSeparator = sep.ToCharArray()[0];
string[] exponentParts = str.Split('E');
string[] decimalParts = exponentParts[0].Split(decSeparator);
// fix missing decimal point:
if (decimalParts.Length == 1) decimalParts = new string[] { exponentParts[0], "0" };
int exponentValue = int.Parse(exponentParts[1]);
string newNumber = decimalParts[0].Replace("-", "").
Replace("+", "") + decimalParts[1];
string result;
if (exponentValue > 0)
{
if (positive)
result =
newNumber +
GetZeros(exponentValue - decimalParts[1].Length);
else
result = "-" +
newNumber +
GetZeros(exponentValue - decimalParts[1].Length);
}
else // negative exponent
{
if (positive)
result =
"0" +
decSeparator +
GetZeros(exponentValue + decimalParts[0].Replace("-", "").
Replace("+", "").Length) + newNumber;
else
result =
"-0" +
decSeparator +
GetZeros(exponentValue + decimalParts[0].Replace("-", "").
Replace("+", "").Length) + newNumber;
result = result.TrimEnd('0');
}
float temp = 0.00F;
if (float.TryParse(result, out temp))
{
return result;
}
throw new Exception();
}
private static string GetZeros(int zeroCount)
{
if (zeroCount < 0)
zeroCount = Math.Abs(zeroCount);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < zeroCount; i++) sb.Append("0");
return sb.ToString();
}
public static void Main(string[] args)
{
//Get Input Directory.
Console.WriteLine(@"Enter the Input Directory");
var readLine = Console.ReadLine();
if (readLine == null)
{
Console.WriteLine(@"Enter the input path properly.");
return;
}
var pathToInputDirectory = readLine.Trim();
//Get Output Directory.
Console.WriteLine(@"Enter the Output Directory");
readLine = Console.ReadLine();
if (readLine == null)
{
Console.WriteLine(@"Enter the output path properly.");
return;
}
var pathToOutputDirectory = readLine.Trim();
//Get Delimiter.
Console.WriteLine("Enter the delimiter;");
var columnDelimiter = (char)Console.Read();
//Loop over all files in the directory.
foreach (var inputFileName in Directory.GetFiles(pathToInputDirectory))
{
var outputFileWithouthNumbersInScientificNotation = string.Empty;
Console.WriteLine("Started operation on File : " + inputFileName);
if (File.Exists(inputFileName))
{
// Read the file
using (var file = new StreamReader(inputFileName))
{
string line;
while ((line = file.ReadLine()) != null)
{
String[] columns = line.Split(columnDelimiter);
var duplicateLine = string.Empty;
int lengthOfColumns = columns.Length;
int counter = 1;
foreach (var column in columns)
{
var columnDuplicate = column;
try
{
if (Regex.IsMatch(columnDuplicate.Trim(),
@"^[+-]?[0-9]+(\.[0-9]+)?[E]([+-]?[0-9]+)$",
RegexOptions.IgnoreCase))
{
Console.WriteLine("Regular expression matched for this :" + column);
columnDuplicate = ToLongString(Double.Parse
(column,
System.Globalization.NumberStyles.Float));
Console.WriteLine("Converted this no in scientific notation " +
"" + column + " to this number " +
columnDuplicate);
}
}
catch (Exception)
{
}
duplicateLine = duplicateLine + columnDuplicate;
if (counter != lengthOfColumns)
{
duplicateLine = duplicateLine + columnDelimiter.ToString();
}
counter++;
}
duplicateLine = duplicateLine + Environment.NewLine;
outputFileWithouthNumbersInScientificNotation = outputFileWithouthNumbersInScientificNotation + duplicateLine;
}
file.Close();
}
var outputFilePathWithoutNumbersInScientificNotation
= Path.Combine(pathToOutputDirectory, Path.GetFileName(inputFileName));
//Create Directory If it does not exist.
if (!Directory.Exists(pathToOutputDirectory))
Directory.CreateDirectory(pathToOutputDirectory);
using (var outputFile =
new StreamWriter(outputFilePathWithoutNumbersInScientificNotation))
{
outputFile.Write(outputFileWithouthNumbersInScientificNotation);
outputFile.Close();
}
Console.WriteLine("The transformed file is here :" +
outputFilePathWithoutNumbersInScientificNotation);
}
}
}
}
}
Ce code prend un répertoire d'entrée et sur la base delimiter convertit toutes les valeurs en notation scientifique au format numérique.
Merci
essayez celui-ci:
public static string DoubleToFullString(double value,
NumberFormatInfo formatInfo)
{
string[] valueExpSplit;
string result, decimalSeparator;
int indexOfDecimalSeparator, exp;
valueExpSplit = value.ToString("r", formatInfo)
.ToUpper()
.Split(new char[] { 'E' });
if (valueExpSplit.Length > 1)
{
result = valueExpSplit[0];
exp = int.Parse(valueExpSplit[1]);
decimalSeparator = formatInfo.NumberDecimalSeparator;
if ((indexOfDecimalSeparator
= valueExpSplit[0].IndexOf(decimalSeparator)) > -1)
{
exp -= (result.Length - indexOfDecimalSeparator - 1);
result = result.Replace(decimalSeparator, "");
}
if (exp >= 0) result += new string('0', Math.Abs(exp));
else
{
exp = Math.Abs(exp);
if (exp >= result.Length)
{
result = "0." + new string('0', exp - result.Length)
+ result;
}
else
{
result = result.Insert(result.Length - exp, decimalSeparator);
}
}
}
else result = valueExpSplit[0];
return result;
}
Étant des millions de monde programmeurs large, il est toujours une bonne pratique pour essayer la recherche si quelqu'un a heurté votre problème déjà. Parfois, il y a des solutions sont des ordures, ce qui signifie qu'il est temps d'écrire vos propres, et parfois il y a une grande, comme suit:
http://www.yoda.arachsys.com/csharp/DoubleConverter.cs
(détails: http://www.yoda.arachsys.com/csharp/ floatingpoint.html )
string strdScaleFactor = dScaleFactor.ToString(); // where dScaleFactor = 3.531467E-05
decimal decimalScaleFactor = Decimal.Parse(strdScaleFactor, System.Globalization.NumberStyles.Float);
Je peux me tromper, mais est-ce pas comme ça?
data.ToString("n");
Juste pour construire sur ce que jcasso dit ce que vous pouvez faire est d'ajuster votre valeur double en changeant l'exposant afin que votre format favori serait le faire pour vous, appliquer le format, et que le résultat est complété de zéros pour compenser la l'ajustement.
Je pense que vous avez seulement besoin d'utiliser iformat avec
ToString(doubleVar, System.Globalization.NumberStyles.Number)
exemple:
double d = double.MaxValue;
string s = d.ToString(d, System.Globalization.NumberStyles.Number);
Ma solution utilisait les formats personnalisés. essayez ceci:
double d;
d = 1234.12341234;
d.ToString("#########0.#########");
Cela fonctionne bien pour moi ...
double number = 1.5E+200;
string s = number.ToString("#");
//Output: "150000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
