Qual è il nome per memorizzare / imballare molti stati booleani in un numero?

È una sorta di semplice compressione in cui usi una variabile numerica per memorizzare molti stati booleani / binari, usando il raddoppio e il fatto che ogni numero raddoppiato è 1 + la somma di tutti i precedenti.

Sono sicuro che deve essere una vecchia tecnica ben nota, mi piacerebbe sapere come si chiama per riferirsi ad esso correttamente. Ho fatto diverse ricerche su tutti i modi in cui mi viene in mente di descriverlo, ma non ho trovato nulla oltre ad alcuni articoli del blog in cui gli autori dell'articolo sembrano averlo capito da soli e non sanno nemmeno come chiamarlo ( esempio 1 , esempio 2 ).

Ad esempio, ecco un'implementazione molto semplice intesa a illustrare il concetto:

packStatesIntoNumber () {
  let num = 0
  if (this.stateA) num += 1
  if (this.stateB) num += 2
  if (this.stateC) num += 4
  if (this.stateD) num += 8
  if (this.stateE) num += 16
  if (this.stateF) num += 32
  return num
}

unpackStatesFromNumber (num) {
  assert(num < 64)
  this.stateF = num >= 32; if (this.stateF) num -= 32
  this.stateE = num >= 16; if (this.stateE) num -= 16
  this.stateD = num >= 8; if (this.stateD) num -= 8
  this.stateC = num >= 4; if (this.stateC) num -= 4
  this.stateB = num >= 2; if (this.stateB) num -= 2
  this.stateA = num >= 1; if (this.stateA) num -= 1
}

Potresti anche usare operatori bit per bit, analisi dei numeri di base 2, enum ... Ci sono molti modi più efficienti per implementarlo, mi interessa il nome dell'approccio più in generale.

Viene comunemente indicato come un campo di bit e un altro termine che sentirai spesso è maschere di bit , che vengono utilizzate per ottenere o impostare singoli valori di bit o l'intero campo di bit contemporaneamente.

Molti linguaggi di programmazione hanno strutture ausiliarie per aiutare in questo. Come osserva @BernhardHiller nei commenti, C # ha enumerazioni con flag ; Java ha la classe EnumSet .

Strano, un po 'di termini diversi qui, ma non vedo quello che mi è venuto subito in mente (ed è nel titolo della tua domanda!) - Bit Packing è quello che ho sempre sentito definito.

Avevo pensato che fosse davvero ovvio ma stranamente quando lo google sembra che questo sia un termine ampiamente usato ma non definito ufficialmente (Wikipedia sembra reindirizzare al bit field che è un modo per fare il bit packing, ma non un nome per il processi). La ricerca della definizione sembra condurre a questa pagina:

http://www.kinematicsoup.com/news/2016/9/6/data-compression-bit-packing-101

Il che non è eccezionale per gli scopi SO ma è la migliore definizione / descrizione che posso trovare includendo questa descrizione sintetica: "L'imballaggio di bit è un concetto semplice: utilizzare il minor numero di bit possibile per memorizzare un dato".

Ci sono molti termini diversi usati per descriverlo.

Più comunemente i bit sono chiamati "bit flags" o "bit points".
(Tuttavia, vale la pena notare che i "campi bit" a volte si riferiscono a una caratteristica specifica dei linguaggi C e C ++, che è correlata ma non esattamente la stessa.)

L'intero stesso viene indicato in vari modi come "array di bit", "set di bit" o "vettore di bit", a seconda degli usi e delle circostanze.

In entrambi i casi, l'estrazione dei bit dal set di bit / vettore / array avviene tramite spostamento e mascheramento.
(cioè usando una maschera di bit .)

Per alcuni esempi di ciascun termine in uso attivo:

• L'articolo di Wikipedia sull'argomento è intitolato Bit array , in cui si nota che è "noto anche come bit map, set di bit, stringa di bit o vettore di bit"
• C ++ utilizza std::bitset
• Usa Java BitSet
• C # usa BitArray
• StackOverflow ha i tag bitvector, bitarrayebitset
• Su PyPi c'è un bitarrayprogetto e un BitVectorprogetto

Non è proprio pertinente alla domanda, ma vorrei dire: per favore non usare addizioni e sottrazioni per impostare e cancellare bit poiché questi metodi sono inclini a errori.
(cioè se lo fai num += 1due volte, il risultato è equivalente a num += 2.)

Preferisci invece utilizzare le operazioni bit per bit appropriate, se la lingua scelta le fornisce:

packStatesIntoNumber ()
{
  let num = 0
  if (this.stateA) num |= 1
  if (this.stateB) num |= 2
  if (this.stateC) num |= 4
  if (this.stateD) num |= 8
  if (this.stateE) num |= 16
  if (this.stateF) num |= 32
  return num
}

unpackStatesFromNumber (num)
{
  this.stateF = ((num & 32) != 0);
  this.stateE = ((num & 16) != 0);
  this.stateD = ((num & 8) != 0);
  this.stateC = ((num & 4) != 0);
  this.stateB = ((num & 2) != 0);
  this.stateA = ((num & 1) != 0);
}