Modo rapido di contare bit diversi da zero in numero intero positivo

Ho bisogno di un modo veloce per contare il numero di bit in un numero intero in Python. La mia soluzione attuale è

bin(n).count("1")

ma mi chiedo se esiste un modo più veloce per farlo?

PS: (sto rappresentando un grande array binario 2D come un unico elenco di numeri e sto eseguendo operazioni bit per bit, e questo riduce il tempo da ore a minuti. E ora vorrei sbarazzarmi di quei minuti extra.

Modifica: 1. deve essere in Python 2.7 o 2.6

e l'ottimizzazione per numeri piccoli non ha molta importanza poiché non sarebbe un chiaro collo di bottiglia, ma in alcuni punti ho numeri con più di 10.000 bit

ad esempio questo è un caso a 2000 bit:

12448057941136394342297748548545082997815840357634948550739612798732309975923280685245876950055614362283769710705811182976142803324242407017104841062064840113262840137625582646683068904149296501029754654149991842951570880471230098259905004533869130509989042199261339990315125973721454059973605358766253998615919997174542922163484086066438120268185904663422979603026066685824578356173882166747093246377302371176167843247359636030248569148734824287739046916641832890744168385253915508446422276378715722482359321205673933317512861336054835392844676749610712462818600179225635467147870208L

Per interi di lunghezza arbitraria, bin(n).count("1")è il più veloce che ho trovato in Python puro.

Ho provato ad adattare le soluzioni di Óscar e Adam per elaborare il numero intero rispettivamente in blocchi a 64 bit e 32 bit. Entrambi erano almeno dieci volte più lenti dibin(n).count("1") (la versione a 32 bit impiegava di nuovo circa la metà del tempo).

D'altra parte, gmpy ha popcount() impiegato circa 1/20 del tempo di bin(n).count("1"). Quindi, se puoi installare gmpy, usalo.

Per rispondere a una domanda nei commenti, per i byte utilizzerei una tabella di ricerca. Puoi generarlo in fase di esecuzione:

counts = bytes(bin(x).count("1") for x in range(256))  # py2: use bytearray

O semplicemente definiscilo letteralmente:

counts = (b'\x00\x01\x01\x02\x01\x02\x02\x03\x01\x02\x02\x03\x02\x03\x03\x04'
          b'\x01\x02\x02\x03\x02\x03\x03\x04\x02\x03\x03\x04\x03\x04\x04\x05'
          b'\x01\x02\x02\x03\x02\x03\x03\x04\x02\x03\x03\x04\x03\x04\x04\x05'
          b'\x02\x03\x03\x04\x03\x04\x04\x05\x03\x04\x04\x05\x04\x05\x05\x06'
          b'\x01\x02\x02\x03\x02\x03\x03\x04\x02\x03\x03\x04\x03\x04\x04\x05'
          b'\x02\x03\x03\x04\x03\x04\x04\x05\x03\x04\x04\x05\x04\x05\x05\x06'
          b'\x02\x03\x03\x04\x03\x04\x04\x05\x03\x04\x04\x05\x04\x05\x05\x06'
          b'\x03\x04\x04\x05\x04\x05\x05\x06\x04\x05\x05\x06\x05\x06\x06\x07'
          b'\x01\x02\x02\x03\x02\x03\x03\x04\x02\x03\x03\x04\x03\x04\x04\x05'
          b'\x02\x03\x03\x04\x03\x04\x04\x05\x03\x04\x04\x05\x04\x05\x05\x06'
          b'\x02\x03\x03\x04\x03\x04\x04\x05\x03\x04\x04\x05\x04\x05\x05\x06'
          b'\x03\x04\x04\x05\x04\x05\x05\x06\x04\x05\x05\x06\x05\x06\x06\x07'
          b'\x02\x03\x03\x04\x03\x04\x04\x05\x03\x04\x04\x05\x04\x05\x05\x06'
          b'\x03\x04\x04\x05\x04\x05\x05\x06\x04\x05\x05\x06\x05\x06\x06\x07'
          b'\x03\x04\x04\x05\x04\x05\x05\x06\x04\x05\x05\x06\x05\x06\x06\x07'
          b'\x04\x05\x05\x06\x05\x06\x06\x07\x05\x06\x06\x07\x06\x07\x07\x08')

Quindi è counts[x]per ottenere il numero di 1 bit in xcui 0 ≤ x ≤ 255.

È possibile adattare il seguente algoritmo:

def CountBits(n):
  n = (n & 0x5555555555555555) + ((n & 0xAAAAAAAAAAAAAAAA) >> 1)
  n = (n & 0x3333333333333333) + ((n & 0xCCCCCCCCCCCCCCCC) >> 2)
  n = (n & 0x0F0F0F0F0F0F0F0F) + ((n & 0xF0F0F0F0F0F0F0F0) >> 4)
  n = (n & 0x00FF00FF00FF00FF) + ((n & 0xFF00FF00FF00FF00) >> 8)
  n = (n & 0x0000FFFF0000FFFF) + ((n & 0xFFFF0000FFFF0000) >> 16)
  n = (n & 0x00000000FFFFFFFF) + ((n & 0xFFFFFFFF00000000) >> 32) # This last & isn't strictly necessary.
  return n

Funziona per numeri positivi a 64 bit, ma è facilmente estendibile e il numero di operazioni cresce con il logaritmo dell'argomento (cioè linearmente con la dimensione in bit dell'argomento).

Per capire come funziona, immagina di dividere l'intera stringa a 64 bit in 64 bucket da 1 bit. Il valore di ogni bucket è uguale al numero di bit impostato nel bucket (0 se non sono impostati bit e 1 se è impostato un bit). La prima trasformazione risulta in uno stato analogo, ma con 32 bucket ciascuno della lunghezza di 2 bit. Ciò si ottiene spostando in modo appropriato i bucket e aggiungendo i loro valori (un'aggiunta si prende cura di tutti i bucket poiché non può verificarsi alcun riporto tra i bucket: il numero di n bit è sempre abbastanza lungo da codificare il numero n). Ulteriori trasformazioni portano a stati con un numero esponenzialmente decrescente di bucket di dimensioni in crescita esponenziale fino ad arrivare a un bucket lungo 64 bit. Questo fornisce il numero di bit impostato nell'argomento originale.

Ecco un'implementazione Python dell'algoritmo di conteggio della popolazione, come spiegato in questo post :

def numberOfSetBits(i):
    i = i - ((i >> 1) & 0x55555555)
    i = (i & 0x33333333) + ((i >> 2) & 0x33333333)
    return (((i + (i >> 4) & 0xF0F0F0F) * 0x1010101) & 0xffffffff) >> 24

Funzionerà per 0 <= i < 0x100000000.

Secondo questo post , questa sembra essere una delle implementazioni più veloci del peso di Hamming (se non ti dispiace usare circa 64 KB di memoria).

#http://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetTable
POPCOUNT_TABLE16 = [0] * 2**16
for index in range(len(POPCOUNT_TABLE16)):
    POPCOUNT_TABLE16[index] = (index & 1) + POPCOUNT_TABLE16[index >> 1]

def popcount32_table16(v):
    return (POPCOUNT_TABLE16[ v        & 0xffff] +
            POPCOUNT_TABLE16[(v >> 16) & 0xffff])

Su Python 2.x dovresti sostituire rangecon xrange.

modificare

Se hai bisogno di prestazioni migliori (ei tuoi numeri sono grandi interi), dai un'occhiata alla GMPlibreria. Contiene implementazioni di assembly scritte a mano per molte architetture diverse.

gmpy è un modulo di estensione Python con codice C che racchiude la libreria GMP.

>>> import gmpy
>>> gmpy.popcount(2**1024-1)
1024

Mi piace molto questo metodo. È semplice e abbastanza veloce ma non è limitato nella lunghezza in bit poiché python ha numeri interi infiniti.

In realtà è più astuto di quanto sembri, perché evita di perdere tempo a scansionare gli zeri. Ad esempio, ci vorrà lo stesso tempo per contare i bit impostati in 1000000000000000000000010100000001 come in 1111.

def get_bit_count(value):
   n = 0
   while value:
      n += 1
      value &= value-1
   return n

È possibile utilizzare l'algoritmo per ottenere la stringa binaria [1] di un numero intero ma invece di concatenare la stringa, contando il numero di uno:

def count_ones(a):
    s = 0
    t = {'0':0, '1':1, '2':1, '3':2, '4':1, '5':2, '6':2, '7':3}
    for c in oct(a)[1:]:
        s += t[c]
    return s

[1] https://wiki.python.org/moin/BitManipulation

Hai detto che Numpy era troppo lento. Lo stavi usando per memorizzare singoli bit? Perché non estendere l'idea di utilizzare int come array di bit ma utilizzare Numpy per memorizzarli?

Memorizza n bit come array di ceil(n/32.) int a 32 bit. Puoi quindi lavorare con l'array numpy nello stesso modo (beh, abbastanza simile) in cui usi gli int, incluso il loro utilizzo per indicizzare un altro array.

L'algoritmo è fondamentalmente quello di calcolare, in parallelo, il numero di bit impostati in ogni cella e sommare il numero di bit di ciascuna cella.

setup = """
import numpy as np
#Using Paolo Moretti's answer http://stackoverflow.com/a/9829855/2963903
POPCOUNT_TABLE16 = np.zeros(2**16, dtype=int) #has to be an array

for index in range(len(POPCOUNT_TABLE16)):
    POPCOUNT_TABLE16[index] = (index & 1) + POPCOUNT_TABLE16[index >> 1]

def popcount32_table16(v):
    return (POPCOUNT_TABLE16[ v        & 0xffff] +
            POPCOUNT_TABLE16[(v >> 16) & 0xffff])

def count1s(v):
    return popcount32_table16(v).sum()

v1 = np.arange(1000)*1234567                       #numpy array
v2 = sum(int(x)<<(32*i) for i, x in enumerate(v1)) #single int
"""
from timeit import timeit

timeit("count1s(v1)", setup=setup)        #49.55184188873349
timeit("bin(v2).count('1')", setup=setup) #225.1857464598633

Anche se sono sorpreso che nessuno ti abbia suggerito di scrivere un modulo C.

#Python prg to count set bits
#Function to count set bits
def bin(n):
    count=0
    while(n>=1):
        if(n%2==0):
            n=n//2
        else:
            count+=1
            n=n//2
    print("Count of set bits:",count)
#Fetch the input from user
num=int(input("Enter number: "))
#Output
bin(num)

Si scopre che la tua rappresentazione iniziale è un elenco di elenchi di int che sono 1 o 0. Contali semplicemente in quella rappresentazione.

Il numero di bit in un intero è costante in Python.

Tuttavia, se vuoi contare il numero di bit impostati, il modo più veloce è creare un elenco conforme al seguente pseudocodice: [numberofsetbits(n) for n in range(MAXINT)]

Ciò fornirà una ricerca temporale costante dopo aver generato l'elenco. Vedi la risposta di @ PaoloMoretti per una buona implementazione di questo. Ovviamente, non devi tenere tutto in memoria: potresti usare una sorta di archivio persistente di valori-chiave, o anche MySql. (Un'altra opzione sarebbe quella di implementare la tua semplice archiviazione basata su disco).