Ich möchte ein sehr großes Array erstellen, auf das ich '0' und '1' schreibe. Ich versuche einen physikalischen Prozess zu simulieren, der als zufällige sequentielle Adsorption bezeichnet wird, bei dem Einheiten der Länge 2, Dimere, an einer zufälligen Stelle auf ein n-dimensionales Gitter aufgebracht werden, ohne sich zu überlappen. Der Vorgang wird abgebrochen, wenn auf dem Gitter kein Platz mehr für die Ablagerung weiterer Dimere mehr vorhanden ist (Gitter ist eingeklemmt).

Zunächst beginne ich mit einem Nullengitter, und die Dimere werden durch ein Paar von Einsen dargestellt. Wenn jedes Dimer abgelagert wird, wird die Stelle links vom Dimer blockiert, da sich die Dimere nicht überlappen können. Also simuliere ich diesen Prozess, indem ich ein Dreifaches der Einsen auf das Gitter lege. Ich muss die gesamte Simulation viele Male wiederholen und dann die durchschnittliche Abdeckung in% berechnen.

Ich habe dies bereits mit einer Reihe von Zeichen für 1D- und 2D-Gitter gemacht. Im Moment versuche ich, den Code so effizient wie möglich zu gestalten, bevor ich mich mit dem 3D-Problem und komplizierteren Verallgemeinerungen befasse.

So sieht der Code in 1D im Prinzip vereinfacht aus:

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;
}

Für das eigentliche Projekt, das ich mache, geht es nicht nur um Dimere, sondern auch um Trimere, Quadrimere und alle möglichen Formen und Größen (für 2D und 3D).

Ich hatte gehofft, dass ich in der Lage sein würde, mit einzelnen Bits anstelle von Bytes zu arbeiten, aber ich habe herumgelesen und soweit ich sagen kann, kann man immer nur 1 Byte gleichzeitig ändern, also muss ich entweder eine komplizierte Indizierung durchführen oder gibt es eine einfachere möglichkeit?

Danke für deine Antworten