Doppio alla conversione stringa senza notazione scientifica
https://stackoverflow.com/questions/1546113
-
20-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
Come convertire una doppia in una rappresentazione di stringa in virgola mobile, senza la notazione scientifica in .NET Framework?
campioni "piccole" (numeri effettivi possono essere di qualsiasi dimensione, come ad esempio 1.5E200 o 1e-200):
3248971234698200000000000000000000000000000000
0.00000000000000000000000000000000000023897356978234562
Nessuno dei formati numerici standard, sono come questo, e un formato personalizzato , inoltre, non sembra consentire avere un numero aperto di cifre dopo il separatore decimale.
Questo non è un duplicato di Come convertire doppia a stringa senza il potere di rappresentanza 10 (e-05) perché le risposte fornite non fanno non di risolvere il problema a portata di mano. La soluzione accettata in questo problema è stato quello di utilizzare un punto fisso (come ad esempio 20 cifre), che non è quello che voglio. Un formattazione punto fisso e rifilatura ridondante 0 non risolve il problema sia perché la larghezza massima di larghezza fissa è di 99 caratteri.
Nota. la soluzione deve affrontare correttamente formati numerici personalizzati (ad esempio altri separatore decimale, a seconda delle informazioni cultura)
Modifica La questione è in realtà solo circa displaing i numeri di cui sopra. Sono consapevole di come floating lavoro numeri in virgola e quali numeri possono essere utilizzati e calcolato con loro.
Soluzione
Per una soluzione general-purpose¹ è necessario per preservare 339 posti:
doubleValue.ToString("0." + new string('#', 339))
Il numero massimo di cifre decimali non-zero è 16. 15 sono sul lato destro del punto decimale. L'esponente può spostare questi 15 cifre un massimo di 324 posti a destra. ( vedere la gamma e la precisione. )
Si lavora per double.Epsilon , double.MinValue , double.MaxValue , e niente in mezzo.
La performance sarà molto maggiore rispetto alle soluzioni di manipolazione regex / stringa poiché tutta la formattazione e la stringa di lavoro è svolto in un solo passaggio dal codice CLR non gestito. Inoltre, il codice è molto più semplice da dimostrare corretta.
Per la facilità d'uso e prestazioni ancora migliori, ne fanno una costante:
public static class FormatStrings
{
public const string DoubleFixedPoint = "0.###################################################################################################################################################################################################################################################################################################################################################";
}
¹ Aggiornamento: ho erroneamente detto che questo era anche una soluzione senza perdita di dati. In realtà non lo è, in quanto ToString fa il suo display normale arrotondamento per tutti i formati, tranne r. esempio dal vivo. Grazie, @Loathing! Si prega di consultare la risposta di lothing se è necessario la possibilità di roundtrip in notazione punto fisso (ad esempio, se si sta utilizzando .ToString("r") oggi) .
Altri suggerimenti
Ho avuto un problema simile e questo ha funzionato per me:
doubleValue.ToString("F99").TrimEnd('0')
F99 può essere eccessivo, ma si ottiene l'idea.
Questa è una soluzione stringa parsing cui il numero sorgente (doppia) viene convertito in una stringa e analizzato nei suoi componenti costitutivi. Viene poi rimontato regole nella rappresentazione numerica full-length. Essa rappresenta anche per il locale come richiesto.
Aggiorna : I test delle conversioni includere solo una cifra numeri interi, che è la norma, ma l'algoritmo funziona anche per qualcosa di simile: 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();
}
}
Si potrebbe lanciare il double per decimal e poi fare ToString().
(0.000000005).ToString() // 5E-09
((decimal)(0.000000005)).ToString() // 0,000000005
Non ho fatto test delle prestazioni, che è più veloce, gettando da 64-bit double a 128-bit decimal o una stringa di formato più di 300 caratteri. Oh, e ci potrebbero eventualmente essere errori di overflow durante la conversione, ma se i valori rientrano un decimal questo dovrebbe funzionare bene.
Aggiornamento: Il casting sembra essere molto più veloce. Utilizzando una stringa di formato preparato come indicato nel altra risposta, la formattazione un milione di volte prende 2,3 secondi e colata soli 0,19 secondi. Ripetibile. Questo è 10 volte più veloce . Ora è solo il campo di valori.
Questo è quello che ho finora, sembra funzionare, ma forse qualcuno ha una soluzione migliore:
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));
Il problema utilizzando #.###...### o F99 è che non mantiene la precisione le cifre decimali che terminano, per esempio:
String t1 = (0.0001/7).ToString("0." + new string('#', 339)); // 0.0000142857142857143
String t2 = (0.0001/7).ToString("r"); // 1.4285714285714287E-05
Il problema con DecimalConverter.cs è che è lento. Questo codice è la stessa idea la risposta di Sasik, ma due volte più veloce. Metodo di prova Unità in basso.
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();
}
}
}
}
Ai vecchi tempi in cui abbiamo dovuto scrivere i nostri formattatori, avremmo isolare la mantissa e l'esponente e formattare separatamente.
In questo articolo di Jon Skeet ( https://csharpindepth.com/articles/FloatingPoint ) egli fornisce un link alla sua routine DoubleConverter.cs che dovrebbe fare esattamente quello che vuoi. Skeet si riferisce anche a questo a estrarre mantissa ed esponente di doppio in C # .
La soluzione Logaritmo a base obbligatoria. Si noti che questa soluzione, perché si tratta di fare matematica, può ridurre la precisione del numero un po '. Non pesantemente testato.
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');
}
}
Modifica: Se il punto decimale attraversa non nullo parte del numero, questo algoritmo fallirà miseramente. Ho provato per la semplice e sono andato troppo lontano.
Ho appena improvvisato sul codice di cui sopra per farlo funzionare per i valori esponenziali negativi.
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);
}
}
}
}
}
Questo codice prende una directory di input e sulla base del delimitatore converte tutti i valori in notazione scientifica in formato numerico.
Grazie
provare questo:
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;
}
Essendo milioni di programmatori in tutto il mondo, è sempre una buona pratica per provare cercare se qualcuno ha urtato il problema già. A volte c'è soluzioni sono spazzatura, il che significa che è il momento di scrivere il proprio, e qualche volta ci sono grandi, come il seguente:
http://www.yoda.arachsys.com/csharp/DoubleConverter.cs
(dettagli: 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);
Potrei sbagliarmi, ma non è così?
data.ToString("n");
Solo per costruire su ciò che jcasso detto cosa si può fare è quello di regolare il valore del doppio modificando l'esponente in modo che il vostro formato preferito sarebbe farlo per voi, applicare il formato, e di pad il risultato con zeri per compensare la regolazione.
Credo che tu debba utilizzare solo IFormat con
ToString(doubleVar, System.Globalization.NumberStyles.Number)
Esempio:
double d = double.MaxValue;
string s = d.ToString(d, System.Globalization.NumberStyles.Number);
La mia soluzione stava usando i formati personalizzati. provate questo:
double d;
d = 1234.12341234;
d.ToString("#########0.#########");
Questo funziona bene per me ...
double number = 1.5E+200;
string s = number.ToString("#");
//Output: "150000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
