Come posso verificare se tutti i bit sono impostati o tutti i bit no?

Question

Utilizzo dell'operatore bit a bit come è possibile verificare se i bit meno significativi di un numero intero sono tutti set o non set.

Ad esempio if n = 3 Ho solo cura circa 3 bit meno significativi Il test deve restituire true per 0 e 7 e false per tutti gli altri valori tra 0 e 7.

Naturalmente ho potuto fare if x = 0 or x = 7, ma avrei preferisci qualcosa usando operatori bit a bit.

Punti bonus se la tecnica può essere adattata per tenere conto di tutti i bit definiti da una maschera.

Chiarimento:

Se ho voluto mettere alla prova se il bit uno o due è impostato che potevo per if ((x & 1 != 0) && (x & 2 != 0)). Ma potrei fare il "più efficiente" if ((x & 3) != 0).

Sto cercando di trovare un "trucco" come questo per rispondere alla domanda "Tutti i bit di x che corrispondono a questa maschera sono tutti impostati o tutti annullati?"

Il modo più semplice è if ((x & mask) == 0 || (x & mask) == mask). Mi piacerebbe trovare un modo per farlo in una singola prova senza || operatore.

Answer 1

Utilizzo dell'operatore bit a bit come è possibile verificare se i bit meno significativi di un numero intero sono tutti set o non tutti set.

Per ottenere una maschera per gli ultimi n bit significativi, thats

(1ULL << n) - 1 

Così il semplice test è:

bool test_all_or_none(uint64_t val, uint64_t n) 
{ 
    uint64_t mask = (1ULL << n) - 1; 
    val &= mask; 
    return val == mask || val == 0; 
} 

Se si vuole evitare il ||, avremo trarre vantaggio dall'overflow dei numeri interi. Per i casi desiderati, dopo &, val è 0 o (supponiamo n == 8) 0xff. Quindi val - 1 è o 0xffffffffffffffff o 0xfe. Le cause di errore sono 1 tramite 0xfe, che diventano 0 tramite 0xfd.Così i casi di successo sono chiamata almeno 0xfe, che è mask - 1:

bool test_all_or_none(uint64_t val, uint64_t n) 
{ 
    uint64_t mask = (1ULL << n) - 1; 
    val &= mask; 
    return (val - 1) >= (mask - 1); 
} 

Possiamo anche prova con l'aggiunta di 1 invece di sottrarre 1, che è probabilmente la soluzione migliore (qui quando abbiamo aggiungere uno a val, val & mask dovrebbe diventare sia 0 o 1 per i nostri casi di successo):

bool test_all_or_none(uint64_t val, uint64_t n) 
{ 
    uint64_t mask = (1ULL << n) - 1; 
    return ((val + 1) & mask) <= 1; 
}  

per un arbitrario maschera , il metodo di sottrazione funziona per la stessa ragione che ha funzionato per il caso maschera specifica: il 0 ribalta per essere il più grande valore possibile:

bool test_all_or_none(uint64_t val, uint64_t mask) 
{ 
    return ((val & mask) - 1) >= (mask - 1); 
} 

Answer 2

Che ne dici?

int mask = (1<<n)-1; 
if ((x&mask)==mask || (x&mask)==0) { /*do whatever*/ } 

L'unica parte veramente difficile è il calcolo della maschera. In pratica sposta semplicemente un 1 su per ottenere 0b0...0100...0 e quindi sottrae uno per renderlo 0b0...0011...1.

Forse puoi chiarire cosa volevi per il test?

Answer 3

per verificare se tutti non sono impostati, non vi resta che mascherare-in solo i bit che si desidera, allora non vi resta che confrontare a zero.

Il divertimento inizia quando si definisce la funzione oposite semplicemente invertendo l'ingresso :)

//Test if the n least significant bits arent set: 
char n_least_arent_set(unsigned int n, unsigned int value){ 
    unsigned int mask = pow(2, n) - 1; // e. g. 2^3 - 1 = b111 
    int masked_value = value & mask; 
    return masked_value == 0; // if all are zero, the mask operation returns a full-zero.  
} 

//test if the n least significant bits are set: 
char n_least_are_set(unsigned int n, unsigned int value){ 
    unsigned int rev_value = ~value; 
    return n_least_arent_set(n, rev_value);  
} 

Answer 4

Ecco cosa si voleva fare, in una funzione (non testato, ma si dovrebbe ottenere l'idea). Restituisce 0 se gli ultimi n bit non sono impostati, 1 se sono tutti impostati, -1 altrimenti.

int lastBitsSet(int num, int n){ 
    int mask = (1 << n) - 1; //n 1-s 
    if (!(num & mask)) //we got all 0-s 
     return 0; 
    if (!(~num & mask)) //we got all 1-s 
     return 1; 
    else 
     return -1; 
}