Python przechodzi do następnej najwyższej potęgi 10

Jak miałbym wykonać math.ceiltak, aby numer został przypisany do następnej najwyższej potęgi 10?

# 0.04  ->  0.1
# 0.7   ->  1
# 1.1   ->  10  
# 90    ->  100  
# ...

Moje obecne rozwiązanie to słownik, który sprawdza zakres liczby wejściowej, ale jest on zakodowany na stałe i wolałbym rozwiązanie jednoliniowe. Może brakuje mi tutaj prostej sztuczki matematycznej lub odpowiedniej funkcji numpy?

Możesz używać math.ceilzmath.log10 tego robić:

>>> 10 ** math.ceil(math.log10(0.04))
0.1
>>> 10 ** math.ceil(math.log10(0.7))
1
>>> 10 ** math.ceil(math.log10(1.1))
10
>>> 10 ** math.ceil(math.log10(90))
100

log10(n) daje rozwiązanie x które spełnia 10 ** x == n, więc jeśli zaokrąglisz w górę x, daje wykładnik następnej najwyższej potęgi 10.

Zauważ, że dla wartości, nktóra xjest już liczbą całkowitą, „następną najwyższą potęgą 10” będzie n:

>>> 10 ** math.ceil(math.log10(0.1))
0.1
>>> 10 ** math.ceil(math.log10(1))
1
>>> 10 ** math.ceil(math.log10(10))
10

Twój problem jest nieokreślony, musisz cofnąć się i zadać kilka pytań.

• Jakie typy są twoje dane wejściowe?
• Jakiego rodzaju chcesz dla swoich wyników?
• W przypadku wyników mniejszych niż 1, co dokładnie chcesz zaokrąglić? Czy chcesz rzeczywistych mocy 10 lub przybliżonych liczb zmiennoprzecinkowych mocy 10? Czy zdajesz sobie sprawę, że mocy ujemnych 10 nie można dokładnie wyrazić w liczbach zmiennoprzecinkowych, prawda? Załóżmy na razie, że chcesz przybliżenia zmiennoprzecinkowe potęg 10.
• Jeśli wejście ma dokładnie moc 10 (lub najbliższe przybliżenie zmiennoprzecinkowe mocy 10), czy wynik powinien być taki sam jak na wejściu? A może powinna to być następna moc 10 w górę? „10 -> 10” czy „10 -> 100”? Załóżmy na razie to pierwsze.
• Czy twoje wartości wejściowe mogą być dowolną możliwą wartością danych typów? czy są bardziej ograniczeni.

W innej odpowiedzi zaproponowano, aby wziąć logarytm, a następnie zaokrąglić w górę (funkcja pułapu), a następnie potęgować.

def nextpow10(n):
    return 10 ** math.ceil(math.log10(n))

Niestety cierpi to na błędy zaokrąglania. Przede wszystkim n jest konwertowane z dowolnego typu danych, który ma, na liczbę zmiennoprzecinkową o podwójnej precyzji, potencjalnie wprowadzając błędy zaokrąglania, następnie logarytm jest obliczany, potencjalnie wprowadzając więcej błędów zaokrąglania zarówno w wewnętrznych obliczeniach, jak i w wyniku.

Jako taki nie zajęło mi długo znalezienie przykładu, w którym dał niepoprawny wynik.

>>> import math
>>> from numpy import nextafter
>>> n = 1
>>> while (10 ** math.ceil(math.log10(nextafter(n,math.inf)))) > n:
...     n *= 10
... 
>>> n
10
>>> nextafter(n,math.inf)
10.000000000000002
>>> 10 ** math.ceil(math.log10(10.000000000000002))
10

Teoretycznie możliwe jest, że zawiodą w innym kierunku, choć wydaje się to znacznie trudniejsze do sprowokowania.

Dlatego dla solidnego rozwiązania dla liczb zmiennoprzecinkowych i liczb wewnętrznych musimy założyć, że wartość naszego logarytmu jest jedynie przybliżona i dlatego musimy przetestować kilka możliwości. Coś w stylu

def nextpow10(n):
    p = round(math.log10(n))
    r = 10 ** p
    if r < n:
        r = 10 ** (p+1) 
    return r;

Uważam, że ten kod powinien dawać poprawne wyniki dla wszystkich argumentów w rozsądnym zakresie wielkości rzeczywistych. Zepsuje się dla bardzo małej lub bardzo dużej liczby typów niecałkowitych i nie zmiennoprzecinkowych z powodu problemów z konwersją ich na zmiennoprzecinkowe. Python w szczególnych przypadkach argumentuje liczby całkowite dla funkcji log10, próbując zapobiec przepełnieniu, ale wciąż przy wystarczająco dużej liczbie całkowitej może być możliwe wymuszenie niepoprawnych wyników z powodu błędów zaokrąglania.

Aby przetestować dwie implementacje, użyłem następującego programu testowego.

n = -323 # 10**-324 == 0
while n < 1000:
    v = 10 ** n
    if v != nextpow10(v): print(str(v)+" bad")
    try:
        v = min(nextafter(v,math.inf),v+1)
    except:
        v += 1
    if v > nextpow10(v): print(str(v)+" bad")
    n += 1

Stwierdzono wiele błędów we wdrożeniu naiwnym, ale nie we ulepszonym.

Wygląda na to, że chcesz raczej najniższej następnej potęgi 10 ... Oto sposób korzystania z czystej matematyki i bez dziennika, ale rekurencja.

def ceiling10(x):
    if (x > 10):
        return ceiling10(x / 10) * 10
    else:
        if (x <= 1):
            return ceiling10(10 * x) / 10
        else:
            return 10
for x in [1 / 1235, 0.5, 1, 3, 10, 125, 12345]:
    print(x, ceiling10(x))

y = math.ceil(x)
z = y + (10 - (y % 10))

Może coś takiego? Jest tuż przy mojej głowie, ale zadziałało, gdy wypróbowałem kilka numerów w terminalu.

Spójrz na to!

>>> i = 0.04123; print i, 10 ** len( str( int( i ) ) ) if int( i ) > 1  else 10 if i > 1.0 else 1 if i > 0.1 else  10 ** ( 1 - min( [ ("%.100f" % i ).replace('.','').index( k ) for k in [ str( j ) for j in xrange( 1, 10 ) if str( j ) in "%.100f" % i  ] ]  ) )               
0.04123 0.1
>>> i = 0.712; print i, 10 ** len( str( int( i ) ) ) if int( i ) > 1  else 10 if i > 1.0 else 1 if i > 0.1 else  10 ** ( 1 - min( [ ("%.100f" % i ).replace('.','').index( k ) for k in [ str( j ) for j in xrange( 1, 10 ) if str( j ) in "%.100f" % i  ] ]  ) )                 
0.712 1
>>> i = 1.1; print i, 10 ** len( str( int( i ) ) ) if int( i ) > 1  else 10 if i > 1.0 else 1 if i > 0.1 else  10 ** ( 1 - min( [ ("%.100f" % i ).replace('.','').index( k ) for k in [ str( j ) for j in xrange( 1, 10 ) if str( j ) in "%.100f" % i  ] ]  ) )                   
1.1 10
>>> i = 90; print i, 10 ** len( str( int( i ) ) ) if int( i ) > 1  else 10 if i > 1.0 else 1 if i > 0.1 else  10 ** ( 1 - min( [ ("%.100f" % i ).replace('.','').index( k ) for k in [ str( j ) for j in xrange( 1, 10 ) if str( j ) in "%.100f" % i  ] ]  ) )                    
90 100

Ten kod oparty na zasadzie mocy dziesięciu w len( str( int( float_number ) ) ).

Istnieją 4 przypadki:

• 1. int( i ) > 1.

  FloatNumer - przekształca się intnastępnie będzie ciągiem str()z nią, da nam stringz lengthco jesteśmy dokładnie szukać. Tak więc pierwsza część na wejściu i > 1.0- ma dziesięć 10mocy tej długości.

• 2. & 3. Małe rozgałęzienia: i > 1.0i i > 0.1<=> odpowiednio 10i 1.
• 4. I ostatni przypadek, kiedy i < 0.1: tutaj dziesięć będzie w mocy ujemnej. Aby uzyskać pierwszy niezerowy element po przecinku, użyłem takiej konstrukcji ("%.100f" % i ).replace('.','').index( k ), w której k przebiega przez [1:10]interwał. Następnie weź minimum listy wyników. I pomniejsz o jeden, to pierwsze zero, które należy policzyć. Również tutaj norma Pythona index()może upaść, jeśli nie znajdzie się co najmniej jeden z niezerową elementu z [1:10]przedziału, dlatego w końcu muszę „filtr” wystawianie przez występowania: if str( j ) in "%.100f" % i. Ponadto, aby uzyskać głębszą precyzję - %.100fmogą się różnić.