Jak konwertować ułamki dziesiętne na ułamki szesnastkowe?

Question

Tak więc zastanawiałem się, w jaki sposób przekształcić ułamek dziesiętny w ułamek szesnastkowy? Jakie są metody konwersji i czy istnieją skróty?

Answer 1

Można użyć tego algorytmu:

1. Weź ułamkową część numeru (czyli część całkowita jest równa zeru)
2. pomnożyć przez
3. Konwersja części całkowitej do szesnastkowy i umieścić go w dół
4. Przejdź do kroku 1

na przykład Przekonajmy się szesnastkowym reprezentacja PI = 3.141592653589793 ...

całkowita część jest widoczna - 0x3; jak dla części ułamkowej (+0,141592653589793) mamy

0.14159265358979 * 16 = 2.26548245743664; int part 2 (0x2); frac 0.26548245743664 
    0.26548245743664 * 16 = 4.24771931898624; int part 4 (0x4); frac 0.24771931898624 
    0.24771931898624 * 16 = 3.96350910377984; int part 3 (0x3); frac 0.96350910377984 
    0.96350910377984 * 16 = 15.41614566047744; int part 15 (0xF); frac 0.41614566047744 
    0.41614566047744 * 16 = 6.65833056763904; int part 6 (0x6); frac 0.65833056763904 
    0.65833056763904 * 16 = 10.53328908222464; int part 10 (0xA); ... 

So PI (szesnastkowy) = 3.243F6A ...

możliwe (C#) realizacja

public static String ToHex(Double value) { 
    StringBuilder Sb = new StringBuilder(); 

    if (value < 0) { 
    Sb.Append('-'); 

    value = -value; 
    } 

    // I'm sure you know how to convert decimal integer to its hexadecimal representation 
    BigInteger bi = (BigInteger) value; 
    Sb.Append(bi.ToString("X")); 

    value = value - (Double)bi; 

    // We have integer value in fact (e.g. 5.0) 
    if (value == 0) 
    return Sb.ToString(); 

    Sb.Append('.'); 

    // Double is 8 byte and so has at most 16 hexadecimal values 
    for (int i = 0; i < 16; ++i) { 
    value = value * 16; 
    int digit = (int) value; 

    Sb.Append(digit.ToString("X")); 

    value = value - digit; 

    if (value == 0) 
     break; 
    } 

    return Sb.ToString(); 
} 

test

Console.Write(ToHex(Math.PI)); // <- returns "3.243F6A8885A3" 

Answer 2

Możesz pobrać część ułamkową, mnożąc liczbę wejściową przez liczbę cyfr szesnastkowych. Następnie możesz użyć zwykłej konwersji liczby całkowitej na heksadecymalną. Na przykład, aby uzyskać 6 znaków po przecinku (hexa), pomnóż część ułamkową przez 0x1000000.

Oto kod Java, który to zrobi.

String toHexFraction(double x, int digits) { 
    // Get fractional part. 
    if (x < 0.0) 
     x = 0.0 - x; 
    x = x % 1.0; 

    // Shift left by n digits 
    long multiplier = (1L << (digits * 4)); 
    long fraction = (long)(x * multiplier); 

    // Convert integer to hex string. 
    // String should have at least n digits; prefix with zeros if not. 
    String hex = Long.toHexString(fraction); 
    String padding = "000000000000000"; 
    hex = padding.substring(0, digits - hex.length()) + hex; 

    return hex; 
} 

String toHexInteger(double x) { 
    long whole = (long) x; 
    String prefix; 
    if (whole < 0) { 
     // Long.toHexString treats the number as an unsigned integer. 
     whole = 0 - whole; 
     prefix = "-"; 
    } else { 
     prefix = ""; 
    } 
    return Long.toHexString(whole); 
} 

String toHex (double x, int digits) { 
    return toHexInteger(x) + "." + toHexFraction(x, digits); 
} 

Liczba cyfr będzie ograniczona przez największą liczbę całkowitą, którą można przedstawić w podwójnym.

Powinno to działać również dla innych kwadratowych baz, np. dla zmiany ósemkowej digits * 4 na digits * 3 i użyj Long.toOctalString.