Conversion de Double en chiffres et exposant

Question

Par ex.

double taille = 10,35;

je devrais obtenir

valeur = 1035;

exposant = -2; Donc quand je serai calculé, j'obtiendrai 10.35.

i.e 1035 * 10^-2 = 10,35;

S'il vous plaît aidez-moi. Merci d'avance

Answer 1

En général, cela n'est pas possible puisque la partie fractionnaire d'un double est stockée en puissances de 2, et pourrait ou non correspondre à powers-of-10. Par exemple: Lorsque vous regardez power-of-2 vs powers-of-3: Tout comme 1/2 == 2^-1 == 5 * 10^-1 a une correspondance, 1/3 == 3^-1 == ?? n'a pas de correspondance.

Cependant, vous pouvez l'approximer.

Il aurait une réponse si vous demandiez des pouvoirs-de-2. Dans ce cas, vous pouvez simplement regarder la double représentation (voir IEEE-754 here) et extraire les bons bits.

Answer 2

Très simplistes (en C#):

 double size = 10.36; 
     int power = 0; 
     while (size != (int)size) 
     { 
      size *= 10.0; 
      power--; 
     } 
     Console.WriteLine("{0} * 10 to the {1}", size, power); 

Bien que je suis sûr qu'avec un peu plus pensé une solution plus élégante se trouve.

Cela ne va pas dans l'autre sens où vous avez un grand nombre (103600 dis) et que vous voulez obtenir la plus petite valeur à une puissance (1036 * 10^2).

Answer 3

Je devais faire quelque chose de très similaire. Voici une solution en Python (elle n'a pas été très bien testée):

def normalize(value, fdigits=2): 
    """ 
    Convert a string representing a numerical value to value-digit/exponent form. 
    Round the fractional portion to the given number of digits. 

    value the value (string) 
    fdigits the number of digits to which to round the fractional 
      portion 
    """ 

    # if empty string, return error 
    if not value: 
     return None 

    # split value by decimal 
    v = value.split('.') 

    # if too many decimals, return error 
    if len(v) > 2: 
     return None 

    # add empty string for fractional portion if missing 
    elif len(v) == 1: 
     v.append('') 

    # assign whole and fractional portions 
    (w, f) = v 

    # pad fractional portion up to number of significant digits if necessary 
    if len(f) < fdigits: 
     f += ('0' * (fdigits - len(f))) 

    # if the number of digits in the fractional portion exceeds the 
    # number of digits allowed by fdigits 
    elif len(f) > fdigits: 
     # convert both portions to integers; use '0' for whole portion if missing 
     (wi, fi) = (int(w or '0'), int(f[:fdigits])) 

     # round up if first insignificant digit is gteq 5 
     if int(f[fdigits]) >= 5: 
      fi += 1 

      # roll whole value up if fractional portion rounds to a whole 
      if len(str(fi)) > fdigits: 
       wi += 1 
       fi = 0 

     # replace the whole and fractional strings 
     (w, f) = (str(wi), ("%0" + str(fdigits) + "d") % fi) 

    # derive value digits and exponent 
    n = w.lstrip() + f 

    l = len(n) 
    x = -fdigits 

    n = n.rstrip('0') 
    x += (l - len(n)) 

    # return value digits and exponent 
    return (int(n), x)