如何定义和处理C中的位数组?-HowtodefineandworkwithanarrayofbitsinC?

I want to create a very large array on which I write '0's and '1's. I'm trying to simulate a physical process called random sequential adsorption, where units of length 2, dimers, are deposited onto an n-dimensional lattice at a random location, without overlapping each other. The process stops when there is no more room left on the lattice for depositing more dimers (lattice is jammed).

我想要创建一个非常大的数组，我在上面写上0和1。我在尝试模拟一个物理过程，叫做随机顺序吸附，在这个过程中，长度为2的单位二聚体，被随机地沉积在一个n维的格子上，而不会互相重叠。当网格上没有剩余的空间存放更多的二聚物(晶格被堵塞)时，这个过程就停止了。

Initially I start with a lattice of zeroes, and the dimers are represented by a pair of '1's. As each dimer is deposited, the site on the left of the dimer is blocked, due to the fact that the dimers cannot overlap. So I simulate this process by depositing a triple of '1's on the lattice. I need to repeat the entire simulation a large number of times and then work out the average coverage %.

一开始是0的晶格，二聚体由一对'1'表示。当每个二聚体被沉积时，二聚体左边的位置被阻塞，因为二聚体不能重叠。我通过在晶格上沉积1的3倍来模拟这个过程。我需要大量重复整个模拟，然后计算出平均覆盖率%。

I've already done this using an array of chars for 1D and 2D lattices. At the moment I'm trying to make the code as efficient as possible, before working on the 3D problem and more complicated generalisations.

我已经用一个一维和二维格的chars数组做过了。目前，我正在努力使代码尽可能高效，然后再处理3D问题和更复杂的一般化。

This is basically what the code looks like in 1D, simplified:

这就是简化后的1D代码的样子:

int main()
{
    /* Define lattice */
    array = (char*)malloc(N * sizeof(char));

    total_c = 0;

    /* Carry out RSA multiple times */
    for (i = 0; i <1000; i++)
        rand_seq_ads();

    /* Calculate average coverage efficiency at jamming */
    printf("coverage efficiency = %lf", total_c/1000);

    return 0;
}

void rand_seq_ads()
{
    /* Initialise array, initial conditions */
    memset(a, 0, N * sizeof(char));
    available_sites = N;
    count = 0;

    /* While the lattice still has enough room... */
    while(available_sites != 0)
    {
        /* Generate random site location */
        x = rand();

        /* Deposit dimer (if site is available) */
        if(array[x] == 0)
        {
            array[x] = 1;
            array[x+1] = 1;
            count += 1;
            available_sites += -2;
        }

        /* Mark site left of dimer as unavailable (if its empty) */
        if(array[x-1] == 0)
        {
            array[x-1] = 1;
            available_sites += -1;
        }
    }

    /* Calculate coverage %, and add to total */
    c = count/N
    total_c += c;
}

For the actual project I'm doing, it involves not just dimers but trimers, quadrimers, and all sorts of shapes and sizes (for 2D and 3D).

在我正在做的实际项目中，它不仅包括二聚体，还包括三聚体、四聚体，以及各种形状和大小(用于2D和3D)。

I was hoping that I would be able to work with individual bits instead of bytes, but I've been reading around and as far as I can tell you can only change 1 byte at a time, so either I need to do some complicated indexing or there is a simpler way to do it?

我希望我能够与单个比特而不是字节,但我已经阅读,我可以告诉你只能改变一次1个字节,所以我需要做一些复杂的索引或有一个更简单的方法?

Thanks for your answers

谢谢你的回答

5 个解决方案

void  SetBit( int A[],  int k )
   {
      int i = k/32;        //gives the corresponding index in the array A
      int pos = k%32;      //gives the corresponding bit position in A[i]

      unsigned int flag = 1;   // flag = 0000.....00001

      flag = flag <

void  SetBit( int A[],  int k )
   {
      A[k/32] |= 1 <<(k%32);  // Set the bit at the k-th position in A[i]
   }

void  ClearBit( int A[],  int k )                
   {
      A[k/32] &= ~(1 <<(k%32));
   }

int TestBit( int A[],  int k )
   {
      return ( (A[k/32] & (1 <<(k%32) )) != 0 ) ;     
   }

#define SetBit(A,k)     ( A[(k/32)] |= (1 <<(k%32)) )
#define ClearBit(A,k)   ( A[(k/32)] &= ~(1 <<(k%32)) )            
#define TestBit(A,k)    ( A[(k/32)] & (1 <<(k%32)) )

typedef unsigned long bfield_t[ size_needed/sizeof(long) ];
// long because that's probably what your cpu is best at
// The size_needed should be evenly divisable by sizeof(long) or
// you could (sizeof(long)-1+size_needed)/sizeof(long) to force it to round up

bindex = index / (8 * sizeof(long) );

b = index % (8 * sizeof(long) );

result = my_field[bindex] & (1<

result = 1 & (my_field[bindex]>>b); // if you prefer them to be in bit0

my_field[bindex] |= 1<

my_field[bindex] &= ~(1<

int ffs(int x) {
    int c = 0;
    while (!(x&1) ) {
        c++;
        x>>=1;
    }
    return c; // except that it handles x = 0 differently
}

char eightBits = 0;

//Set the 5th and 6th bits from the right to 1
eightBits &= (1 <<4);
eightBits &= (1 <<5);
//eightBits now looks like "00110000". 

#define BIT8 0x01
#define BIT7 0x02
#define BIT6 0x04
#define BIT5 0x08
#define BIT4 0x10
#define BIT3 0x20
#define BIT2 0x40
#define BIT1 0x80

char bits[8] = {BIT1, BIT2, BIT3, BIT4, BIT5, BIT6, BIT7, BIT8};

eightBits &= (bits[3] & bits[4]);

#include  // defines uint32_t

//typedef unsigned int bitarray_t; // if you know that int is 32 bits
typedef uint32_t bitarray_t;

#define RESERVE_BITS(n) (((n)+0x1f)>>5)
#define DW_INDEX(x) ((x)>>5)
#define BIT_INDEX(x) ((x)&0x1f)
#define getbit(array,index) (((array)[DW_INDEX(index)]>>BIT_INDEX(index))&1)
#define putbit(array, index, bit) \
    ((bit)&1 ?  ((array)[DW_INDEX(index)] |= 1<

bitarray_t arr[RESERVE_BITS(130)] = {0, 0x12345678,0xabcdef0,0xffff0000,0};
int i = getbit(arr,5);
putbit(arr,6,1);
int x=2;            // the least significant bit is 0
putbit(arr,6,x);    // sets bit 6 to 0 because 2&1 is 0
putbit(arr,6,!!x);  // sets bit 6 to 1 because !!2 is 1

RESERVE_BITS: number_of_bits --> number_of_dwords
    RESERVE_BITS(n) is the number of 32-bit integers enough to store n bits
DW_INDEX: bit_index_in_array --> dword_index_in_array
    DW_INDEX(i) is the index of dword where the i-th bit is stored.
    Both bit and dword indexes start from 0.
BIT_INDEX: bit_index_in_array --> bit_index_in_dword
    If i is the number of some bit in the array, BIT_INDEX(i) is the number
    of that bit in the dword where the bit is stored.
    And the dword is known via DW_INDEX().
getbit: bit_array, bit_index_in_array --> bit_value
putbit: bit_array, bit_index_in_array, bit_value --> 0