Skip to content
Permalink
Branch: master
Find file Copy path
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
2105 lines (1626 sloc) 36.8 KB
//LifeAPI provide comfortable functions (API) to manipulate, iterate, evolve, compare and report Life objects. This is mainly done
//in order to provide fast (using C) but still comfortable search utility.
//Contributors Chris Cain, Dongook Lee.
//Written by Michael Simkin 2014
#pragma once
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#define N 64
#define MAX_EMITTED 64
#define PrimeN 71
#define CAPTURE_COUNT 10
#define MAX_ITERATIONS 200
#define SUCCESS 1
#define FAIL 0
#define YES 1
#define NO 0
#ifdef _MSC_VER
#include <intrin.h>
#define __builtin_popcountll __popcnt64
#endif
enum CopyType { COPY, OR, XOR, AND };
enum EvolveType { EVOLVE, LEAVE };
typedef struct
{
char* value;
int size;
int allocated;
} LifeString;
void FreeString(LifeString* string)
{
free(string->value);
free(string);
}
LifeString* NewString()
{
LifeString* result = (LifeString*)(malloc(sizeof(LifeString)));
result->value = (char*)(malloc(2 * sizeof(char)));
result->value[0] = '\0';
result->size = 1;
result->allocated = 1;
return result;
}
void Clear(LifeString* s)
{
s->value[0] = '\0';
s->size = 1;
}
void Realloc(LifeString* string)
{
int empty = NO;
if(string->value[0] == '\0')
empty = YES;
if(empty == NO)
{
string->value = (char*)(realloc(string->value, string->allocated * 2 * sizeof(char)));
}
else
{
string->value = (char*)(malloc(string->allocated * 2 * sizeof(char)));
string->value[0] = '\0';
}
string->allocated *= 2;
}
void Realloc(LifeString* string, int size)
{
while(string->allocated <= string->size + size + 1)
Realloc(string);
}
void Append(LifeString* string, const char* val)
{
Realloc(string, strlen(val));
strcat(string->value, val);
string->size = strlen(string->value);
}
void Append(LifeString* string, int val)
{
char str[10];
sprintf(str, "%d", val);
Append(string, str);
}
LifeString* NewString(const char* val)
{
LifeString* result = NewString();
Append(result, val);
return result;
}
typedef struct
{
int x;
int y;
int gen;
int dx;
int dy;
} EmitedGlider;
typedef struct
{
int min;
int max;
int gen;
uint64_t state[N];
EmitedGlider emittedGliders[MAX_EMITTED];
int num_emitted;
} LifeState;
static LifeState* GlobalState;
#pragma omp threadprivate(GlobalState)
static LifeState* Captures[CAPTURE_COUNT];
#pragma omp threadprivate(Captures)
static LifeState* Temp, *Temp1, *Temp2;
#pragma omp threadprivate(Temp, Temp1, Temp2)
static EmitedGlider _gliders[4];
#pragma omp threadprivate(_gliders)
inline uint64_t CirculateLeft(uint64_t x){
return (x << 1) | (x >> (63));
}
inline uint64_t CirculateLeft(uint64_t x, int k)
{
return (x << k) | (x >> (64 - k));
}
inline uint64_t CirculateRight(uint64_t x, int k)
{
return (x >> k) | (x << (64 - k));
}
inline uint64_t CirculateRight(uint64_t x)
{
return (x >> 1) | (x << (63));
}
void Set(int x, int y, uint64_t *state)
{
state[x] |= (1ULL << (y));
}
void Erase(int x, int y, uint64_t *state)
{
state[x] &= ~(1ULL << (y));
}
int Get(int x, int y, uint64_t *state)
{
return (state[x] & (1ULL << y)) >> y;
}
void SetCell(LifeState* state, int x, int y, int val)
{
if(val == 1)
{
Set((x + 32) % N, (y + 32) % 64, state->state);
}
if(val == 0)
Erase((x + 32) % 64, (y + 32) % 64, state->state);
}
int GetCell(LifeState* state, int x, int y)
{
return Get((x + 32) % 64, (y + 32) % 64, state->state);
}
int GetCell(int x, int y)
{
return GetCell(GlobalState, x, y);
}
void SetCell(int x, int y, int val)
{
SetCell(GlobalState, x, y, val);
}
uint64_t GetHash(LifeState* state)
{
uint64_t result = 0;
for(int i = state->min; i <= state->max; i++)
{
result += CirculateRight(state->state[i], i);
result += CirculateLeft(state->state[i], (i + 8) % 47);
}
return result;
}
uint64_t GetHash()
{
return GetHash(GlobalState);
}
void ExpandMinMax(int* min, int* max)
{
*min -= 2;
*max += 2;
if(*min < 0)
(*min) = 0;
if(*max > N - 1)
(*max) = N - 1;
}
void RefitMinMax(LifeState* state)
{
int min = state->min;
int max = state->max;
uint64_t * states = state->state;
for(int i = min; i <= max; i++)
{
if(states[i] != 0)
{
state-> min = i;
break;
}
}
for(int i = max; i >= min; i--)
{
if(states[i] != 0)
{
state-> max = i;
break;
}
}
ExpandMinMax(&(state-> min), &(state-> max));
}
void RecalculateMinMax(LifeState* state)
{
state-> min = N - 1;
state-> max = 0;
uint64_t * states = state->state;
for(int i = 0; i < N; i++)
{
if(states[i] != 0)
{
state-> min = i;
break;
}
}
for(int i = N - 1; i >= 0; i--)
{
if(states[i] != 0)
{
state-> max = i;
break;
}
}
ExpandMinMax(&(state-> min), &(state-> max));
}
void Print(LifeState *state)
{
int i, j;
for(i = 0; i < N; i++)
{
for(j = 0; j < 64; j++)
{
if(GetCell(state, j - 32, i - 32) == 0)
{
int hor = 0;
int ver = 0;
if((i - 32) % 10 == 0)
hor = 1;
if((j - 32) % 10 == 0)
ver = 1;
if(hor == 1 && ver == 1)
printf ("+");
else if(hor == 1)
printf ("-");
else if(ver == 1)
printf ("|");
else
printf (".");
}
else
printf ("O");
}
printf("\n");
}
printf("\n\n\n\n\n\n");
}
void Copy(LifeState* main, LifeState* delta, CopyType op)
{
if(op == COPY)
{
for(int i = 0; i < N; i++)
main->state[i] = delta->state[i];
main->gen = delta->gen;
}
if(op == OR)
{
for(int i = 0; i < N; i++)
main->state[i] |= delta->state[i];
}
if(op == AND)
{
for(int i = 0; i < N; i++)
main->state[i] &= delta->state[i];
}
if(op == XOR)
{
for(int i = 0; i < N; i++)
main->state[i] ^= delta->state[i];
}
RecalculateMinMax(main);
}
void Copy(LifeState* main, LifeState* delta)
{
Copy(main, delta, COPY);
}
int GetPop(LifeState* state)
{
int pop = 0;
int min = state->min;
int max = state->max;
uint64_t * mainState = state->state;
for(int i = min; i <= max; i++)
{
pop += __builtin_popcountll(mainState[i]);
}
return pop;
}
int GetPop()
{
return GetPop(GlobalState);
}
int IsSame(LifeState* s1, LifeState* s2)
{
for(int i = 0; i < N; i++)
if(s1->state[i] != s2->state[i])
return NO;
return YES;
}
int IsSame(LifeState* s1)
{
return IsSame(GlobalState, s1);
}
int IsSame(int capture_idx)
{
return IsSame(GlobalState, Captures[capture_idx]);
}
int IsEmpty(LifeState* s)
{
int min = s->min;
int max = s->max;
uint64_t * mainState = s->state;
for(int i = min; i <= max; i++)
{
if(mainState[i] != 0LL)
return NO;
}
return YES;
}
int IsEmpty()
{
return IsEmpty(GlobalState);
}
int IsEmpty(int idx)
{
return IsEmpty(Captures[idx]);
}
int GetPop(int captureIdx)
{
return GetPop(Captures[captureIdx]);
}
void Inverse(LifeState* state)
{
for(int i = 0; i < N; i++)
{
state->state[i] = ~(state->state[i]);
}
}
void ClearData(LifeState* state)
{
int i;
for(i = 0; i < N; i++)
state->state[i] = 0;
state -> min = 0;
state -> max = N - 1;
state->gen = 0;
state->num_emitted = 0;
}
LifeState* NewState()
{
LifeState* result = (LifeState*)(malloc(sizeof(LifeState)));
ClearData(result);
return result;
}
void FreeState(LifeState* state)
{
free(state);
}
int AreEqual(LifeState* pat1, LifeState* pat2)
{
for(int i = 0; i < N; i++)
if(pat1->state[i] != pat2->state[i])
return NO;
return YES;
}
int AreEqual(LifeState* pat1)
{
return AreEqual(GlobalState, pat1);
}
int AreEqual(int idx)
{
return AreEqual(GlobalState, Captures[idx]);
}
int AreDisjoint(LifeState* main, LifeState* pat)
{
int min = pat->min;
int max = pat->max;
uint64_t * patState = pat->state;
uint64_t * mainState = main->state;
for(int i = min; i <= max; i++)
if(((~mainState[i]) & patState[i]) != patState[i])
return NO;
return YES;
}
int Contains(LifeState* main, LifeState* spark)
{
int min = spark->min;
int max = spark->max;
uint64_t * mainState = main->state;
uint64_t * sparkState = spark->state;
for(int i = min; i <= max; i++)
if((mainState[i] & sparkState[i]) != (sparkState[i]))
return NO;
return YES;
}
int AreDisjoint(LifeState* main, LifeState* pat, int targetDx, int targetDy)
{
int min = pat->min;
int max = pat->max;
uint64_t * patState = pat->state;
uint64_t * mainState = main->state;
int dy = (targetDy + 64) % 64;
for(int i = min; i <= max; i++)
{
int curX = (N + i + targetDx) % N;
if(((~CirculateRight(mainState[curX], dy)) & patState[i]) != patState[i])
return NO;
}
return YES;
}
int Contains(LifeState* main, LifeState* spark, int targetDx, int targetDy)
{
int min = spark->min;
int max = spark->max;
uint64_t * mainState = main->state;
uint64_t * sparkState = spark->state;
int dy = (targetDy + 64) % 64;
for(int i = min; i <= max; i++)
{
int curX = (N + i + targetDx) % N;
if((CirculateRight(mainState[curX], dy) & sparkState[i]) != (sparkState[i]))
return NO;
}
return YES;
}
int AllOn(LifeState* spark)
{
return Contains(GlobalState, spark);
}
int AllOff(LifeState* spark)
{
return AreDisjoint(GlobalState, spark);
}
void Reverse(uint64_t *state, int idxS, int idxE)
{
for(int i = 0; idxS + i < idxE - i; i++)
{
int l = idxS + i;
int r = idxE - i;
uint64_t temp = state[l];
state[l] = state[r];
state[r] = temp;
}
}
void CirculateUp(uint64_t *state, int anyk)
{
int k = (anyk + 64 * 10) % 64;
Reverse(state, 0, N - 1);
Reverse(state, 0, k - 1);
Reverse(state, k, N - 1);
}
void Move(LifeState* state, int x, int y)
{
for(int i = 0; i < N; i++)
{
if(y < 0)
state->state[i] = CirculateRight(state->state[i], -y);
else
state->state[i] = CirculateRight(state->state[i], 64 - y);
}
if(x < 0)
CirculateUp(state->state, 64 + x);
else
CirculateUp(state->state, x);
state->min = 0;
state->max = N - 1;
}
void FlipX(LifeState* state)
{
Reverse(state->state, 0, N - 1);
Move(state, 1, 0);
}
void FlipX()
{
FlipX(GlobalState);
}
void FlipX(int idx)
{
FlipX(Captures[idx]);
}
void Transform(LifeState* state, int dx, int dy, int dxx, int dxy, int dyx, int dyy)
{
ClearData(Temp2);
ClearData(Temp1);
Copy(Temp1, state);
for(int i = 0; i < N; i++)
{
for(int j = 0; j < 64; j++)
{
int x = i - 32;
int y = j - 32;
int x1 = x * dxx + y * dxy;
int y1 = x * dyx + y * dyy;
int val = GetCell(Temp1, x1, y1);
SetCell(Temp2, x, y, val);
}
}
Move(Temp2, dx, dy);
Copy(state, Temp2);
RecalculateMinMax(state);
}
void Transform(LifeState* state, int dx, int dy)
{
Move(state, dx, dy);
}
void GetBoundary(LifeState* state, LifeState* boundary)
{
for(int i = 0; i < N; i++) {
uint64_t col = state->state[i];
Temp->state[i] = col | CirculateLeft(col) | CirculateRight(col);
}
boundary->state[0] = Temp->state[N-1] | Temp->state[0] | Temp->state[1];
for(int i = 1; i < N-1; i++)
boundary->state[i] = Temp->state[i-1] | Temp->state[i] | Temp->state[i+1];
boundary->state[N-1] = Temp->state[N-2] | Temp->state[N-1] | Temp->state[0];
for(int i = 0; i < N; i++)
boundary->state[i] &= ~(state->state[i]);
}
void GetBoundary(LifeState* state, int captureIdx)
{
GetBoundary(state, Captures[captureIdx]);
}
void GetBoundary(LifeState* boundary)
{
GetBoundary(GlobalState, boundary);
}
void GetBoundary(int captureIdx)
{
GetBoundary(GlobalState, Captures[captureIdx]);
}
int Parse(LifeState* state, const char* rle, int starti)
{
char ch;
int cnt, i, j;
int x, y;
x = 0;
y = 0;
cnt = 0;
ClearData(state);
i = starti;
while((ch = rle[i]) != '\0')
{
if(ch >= '0' && ch <= '9')
{
cnt *= 10;
cnt += (ch - '0');
}
else if(ch == 'o')
{
if(cnt == 0)
cnt = 1;
for(j = 0; j < cnt; j++)
{
SetCell(state, x, y, 1);
x++;
}
cnt = 0;
}
else if(ch == 'b')
{
if(cnt == 0)
cnt = 1;
x += cnt;
cnt = 0;
}
else if(ch == '$')
{
if(cnt == 0)
cnt = 1;
if(cnt == 129)
return i + 1;
y += cnt;
x = 0;
cnt = 0;
}
else if(ch == '!')
{
break;
}
else
{
return -2;
}
i++;
}
state->min = 0;
state->max = N - 1;
return -1;
}
int Parse(LifeState* state, const char* rle, int dx, int dy)
{
if(Parse(state, rle, 0) == -1)
{
Move(state, dx, dy);
return SUCCESS;
}
else
{
return FAIL;
}
}
int Parse(LifeState* state, const char* rle)
{
return Parse(state, rle, 0, 0);
}
int Parse(LifeState* state, const char* rle, int dx, int dy, int dxx, int dxy, int dyx, int dyy)
{
int result = Parse(state, rle);
if(result == SUCCESS)
Transform(state, dx, dy, dxx, dxy, dyx, dyy);
return result;
}
typedef struct
{
LifeState* wanted;
LifeState* unwanted;
} LifeTarget;
LifeTarget* NewTarget(LifeState* wanted, LifeState* unwanted)
{
LifeTarget* result = (LifeTarget*)(malloc(sizeof(LifeTarget)));
result->wanted = NewState();
result->unwanted = NewState();
Copy(result->wanted, wanted);
Copy(result->unwanted, unwanted);
RecalculateMinMax(result->wanted);
RecalculateMinMax(result->unwanted);
return result;
}
LifeTarget* NewTarget(LifeState* wanted)
{
GetBoundary(wanted, Temp1);
return NewTarget(wanted, Temp1);
}
LifeTarget* NewTarget(const char* rle, int x, int y, int dxx, int dxy, int dyx, int dyy)
{
int result = Parse(Temp2, rle, x, y, dxx, dxy, dyx, dyy);
if(result == SUCCESS)
{
return NewTarget(Temp2);
}
return NULL;
}
LifeTarget* NewTarget(const char* rle, int x, int y)
{
int result = Parse(Temp2, rle, x, y);
if(result == SUCCESS)
{
return NewTarget(Temp2);
}
return NULL;
}
LifeTarget* NewTarget(const char* rle)
{
return NewTarget(rle, 0, 0);
}
int Contains(LifeState* state, LifeTarget* target, int dx, int dy)
{
if(Contains(state, target->wanted, dx, dy) == YES && AreDisjoint(state, target->unwanted, dx, dy) == YES)
return YES;
else
return NO;
}
int Contains(LifeState* state, LifeTarget* target)
{
if(Contains(state, target->wanted) == YES && AreDisjoint(state, target->unwanted) == YES)
return YES;
else
return NO;
}
int Contains(LifeTarget* target)
{
return Contains(GlobalState, target);
}
void FreeTarget(LifeTarget* iter)
{
FreeState(iter -> wanted);
FreeState(iter -> unwanted);
free(iter);
}
typedef struct
{
int* xList;
int* yList;
int len;
int allocated;
} Locator;
Locator* NewLocator()
{
Locator* result = (Locator*)(malloc(sizeof(Locator)));
result->xList = (int*)(malloc(sizeof(int)));
result->yList = (int*)(malloc(sizeof(int)));
result->len = 0;
result->allocated = 1;
return result;
}
Locator* Realloc(Locator* locator)
{
if(locator->allocated <= locator->len)
{
locator->allocated *= 2;
locator->xList = (int*)(realloc(locator->xList, locator->allocated * sizeof(int)));
locator->yList = (int*)(realloc(locator->yList, locator->allocated * sizeof(int)));
}
return locator;
}
void Add(Locator* locator, int x, int y)
{
Realloc(locator);
locator->xList[locator->len] = x;
locator->yList[locator->len] = y;
locator->len++;
}
Locator *State2Locator(LifeState* state)
{
Locator* result = NewLocator();
for(int j = 0; j < PrimeN; j++)
{
for(int i = 0; i < PrimeN; i++)
{
int x = (j * 35 + 17) % PrimeN;
int y = (i * 11 + 29) % PrimeN;
if(x >= N || y >= N)
continue;
int val = Get(x, y, state->state);
if(val == 1)
Add(result, x, y);
}
}
return result;
}
void ClearAtX(LifeState* state, Locator* locator, int x, uint64_t val)
{
if(val == 0ULL)
return;
int len = locator->len;
int* xList = locator->xList;
int* yList = locator->yList;
for(int i = 0; i < len; i++)
{
int idx = (x + xList[i] + N) % N;
int circulate = (yList[i] + 64) % 64;
state->state[idx] &= ~CirculateLeft(val, circulate);
}
}
uint64_t LocateAtX(LifeState* state, Locator* locator, int x, int negate)
{
uint64_t result = ~0ULL;
int len = locator->len;
int* xList = locator->xList;
int* yList = locator->yList;
for(int i = 0; i < len; i++)
{
int idx = (x + xList[i] + N) % N;
int circulate = (yList[i] + 64) % 64;
if(negate == NO)
result &= CirculateRight(state->state[idx], circulate);
else
result &= ~CirculateRight(state->state[idx],circulate);
if(result == 0ULL)
break;
}
return result;
}
uint64_t LocateAtX(LifeState* state, Locator* onLocator, Locator* offLocator, int x)
{
uint64_t onLocate = LocateAtX(state, onLocator, x, NO);
if(onLocate == 0)
return 0;
return onLocate & LocateAtX(state, offLocator, x, YES);
}
void LocateInRange(LifeState* state, Locator* locator, LifeState* result, int minx, int maxx, int negate)
{
for(int i = minx; i<= maxx; i++)
{
result->state[i] = LocateAtX(state, locator, i, negate);
}
}
void LocateInRange(LifeState* state, Locator* onLocator, Locator* offLocator, LifeState* result, int minx, int maxx)
{
for(int i = minx; i<= maxx; i++)
{
result->state[i] = LocateAtX(state, onLocator, offLocator, i);
}
}
void Locate(LifeState* state, Locator* locator, LifeState* result)
{
LocateInRange(state, locator, result, state->min, state->max, NO);
}
int ContainsLocator(LifeState* state, Locator* onLocator, Locator* offLocator, int minx, int maxx)
{
for(int i = minx; i<= maxx; i++)
{
if(LocateAtX(state, onLocator, offLocator, i) != 0)
return YES;
}
return NO;
}
typedef struct
{
Locator* onLocator;
Locator* offLocator;
} TargetLocator;
TargetLocator* NewTargetLocator()
{
TargetLocator* result = (TargetLocator*)(malloc(sizeof(TargetLocator)));
result->onLocator = NewLocator();
result->offLocator = NewLocator();
return result;
}
TargetLocator* Target2Locator(LifeTarget* target)
{
TargetLocator* result = (TargetLocator*)(malloc(sizeof(TargetLocator)));
result->onLocator = State2Locator(target->wanted);
result->offLocator = State2Locator(target->unwanted);
return result;
}
TargetLocator* NewTargetLocator(LifeState* state)
{
TargetLocator* result = Target2Locator(NewTarget(state));
return result;
}
TargetLocator* NewTargetLocator(const char* rle)
{
TargetLocator* result = Target2Locator(NewTarget(rle, -32, -32));
return result;
}
TargetLocator* NewTargetLocator(const char* rle, int x, int y)
{
TargetLocator* result = Target2Locator(NewTarget(rle, -32 + x, -32 + y));
return result;
}
uint64_t LocateAtX(LifeState* state, TargetLocator* targetLocator, int x)
{
return LocateAtX(state, targetLocator->onLocator, targetLocator->offLocator, x);
}
void LocateInRange(LifeState* state, TargetLocator* targetLocator, LifeState* result, int minx, int maxx)
{
return LocateInRange(state, targetLocator->onLocator, targetLocator->offLocator, result, minx, maxx);
}
void LocateTarget(LifeState* state, TargetLocator* targetLocator, LifeState* result)
{
LocateInRange(state, targetLocator, result, state->min, state->max);
}
void LocateTarget(TargetLocator* targetLocator, LifeState* result)
{
LocateTarget(GlobalState, targetLocator, result);
}
int ContainsLocator(LifeState* state, TargetLocator* targetLocator)
{
return ContainsLocator(state, targetLocator->onLocator, targetLocator->offLocator, state->min, state->max);
}
int ContainsLocator(TargetLocator* targetLocator)
{
return ContainsLocator(GlobalState, targetLocator->onLocator, targetLocator->offLocator, GlobalState->min, GlobalState->max);
}
int ContainsLocator(TargetLocator* locs[], int n)
{
for(int i = 0; i < n; i++)
if(ContainsLocator(locs[i]) == YES)
return YES;
return NO;
}
static TargetLocator* _glidersTarget[4];
#pragma omp threadprivate(_glidersTarget)
int RemoveAtX(LifeState *state, int x, int startGiderIdx)
{
int removed = NO;
for(int i = startGiderIdx; i < startGiderIdx + 2; i++)
{
uint64_t gld = LocateAtX(state, _glidersTarget[i], x);
if(gld != 0)
{
removed = YES;
ClearAtX(state, _glidersTarget[i]->onLocator, x, gld);
for(int j = 0; j < 64; j++)
{
if(gld % 2 == 1)
{
state->emittedGliders[state->num_emitted].x = x;
state->emittedGliders[state->num_emitted].y = j;
state->emittedGliders[state->num_emitted].gen = state->gen;
state->emittedGliders[state->num_emitted].dx = _gliders[i].dx;
state->emittedGliders[state->num_emitted].dy = _gliders[i].dy;
state->num_emitted++;
}
gld = gld >> 1;
if(gld == 0)
break;
}
}
}
return removed;
}
void RemoveGliders(LifeState *state)
{
int removed = NO;
if(state->min <= 1)
if(RemoveAtX(state, 1, 0) == YES)
removed = YES;
if(state->max >= N - 2)
if(RemoveAtX(state, N - 2, 2) == YES)
removed = YES;
if(removed == YES)
RecalculateMinMax(state);
}
void inline Add(uint64_t& b1, uint64_t &b0, const uint64_t& val)
{
b1 |= b0 & val;
b0 ^= val;
}
void inline Add_Init(uint64_t& b1, uint64_t& b0, const uint64_t& val)
{
b1 = b0 & val;
b0 ^= val;
}
void inline Add(uint64_t& b2, uint64_t& b1, uint64_t &b0, const uint64_t& val)
{
uint64_t t_b2 = b0 & val;
b2 |= t_b2 & b1;
b1 ^= t_b2;
b0 ^= val;
}
void inline Add_Init(uint64_t& b2, uint64_t& b1, uint64_t &b0, uint64_t& val)
{
uint64_t t_b2 = b0 & val;
b2 = t_b2&b1;
b1 ^= t_b2;
b0 ^= val;
}
uint64_t inline Evolve(const uint64_t& temp, const uint64_t& bU0, const uint64_t& bU1, const uint64_t& bB0, const uint64_t& bB1)
{
uint64_t sum0, sum1, sum2;
sum0 = temp << 1;
Add_Init(sum1, sum0, temp >> 1);
Add(sum1, sum0, bU0);
Add_Init(sum2, sum1, bU1);
Add(sum2, sum1, sum0, bB0);
Add(sum2, sum1, bB1);
return ~sum2 & sum1 & (temp | sum0);
}
void IterateState(LifeState *lifstate)
{
uint64_t* state = lifstate->state;
int min = lifstate->min;
int max = lifstate->max;
uint64_t bit0[N];
uint64_t bit1[N];
uint64_t tempState[N];
for (int i = min; i <= max; i++)
{
uint64_t l, r, temp;
temp = state[i];
l = temp << 1;
r = temp >> 1;
bit0[i] = l ^ r ^ temp;
bit1[i] = ((l | r) & temp) | (l & r);
}
int start = min;
int last = max;
if (min == 0)
{
tempState[0] = Evolve(state[0], 0, 0, bit0[2], bit1[2]);
start = 1;
}
if (max == N - 1)
{
tempState[N - 1] = Evolve(state[0], bit0[N - 2], bit1[N - 2], 0, 0);
last = N - 2;
}
for (int i = start; i <= last; i++)
tempState[i] = Evolve(state[i], bit0[i - 1], bit1[i - 1], bit0[i + 1], bit1[i + 1]);
int s = min + 1;
int e = max - 1;
if(s == 1)
s = 0;
if(e == N - 2)
e = N - 1;
for (int i = s; i <= e; i++)
{
state[i] = tempState[i];
}
RefitMinMax(lifstate);
lifstate->gen++;
}
LifeState* NewState(const char* rle, int dx, int dy, int dxx, int dxy, int dyx, int dyy)
{
LifeState* result = NewState();
Parse(result, rle);
Transform(result, dx, dy, dxx, dxy, dyx, dyy);
return result;
}
LifeState* NewState(const char* rle, int dx, int dy)
{
LifeState* result = NewState();
Parse(result, rle, dx, dy);
return result;
}
LifeState* NewState(const char* rle)
{
return NewState(rle, 0, 0);
}
const char* GetRLE(LifeState *state)
{
LifeString* result = NewString();
int eol_count = 0;
for(int j = 0; j < N; j++)
{
int last_val = -1;
int run_count = 0;
for(int i = 0; i < N; i++)
{
int val = Get(i, j, state->state);
// Flush linefeeds if we find a live cell
if(val == 1 && eol_count > 0)
{
if(eol_count > 1)
Append(result, eol_count);
Append(result, "$");
eol_count = 0;
}
// Flush current run if val changes
if (val == 1 - last_val)
{
if(run_count > 1)
Append(result, run_count);
Append(result, last_val ? "o" : "b");
run_count = 0;
}
run_count++;
last_val = val;
}
// Flush run of live cells at end of line
if (last_val == 1)
{
if(run_count > 1)
Append(result, run_count);
Append(result, "o");
run_count = 0;
}
eol_count++;
}
return result->value;
}
void PrintRLE(LifeState *state)
{
printf("\nx = 0, y = 0, rule = B3/S23\n%s!\n\n", GetRLE(state));
}
void Print()
{
Print(GlobalState);
}
void Print(int idx)
{
Print(Captures[idx]);
}
void PrintRLE()
{
PrintRLE(GlobalState);
}
void PrintRLE(int idx)
{
PrintRLE(Captures[idx]);
}
void Evolve(LifeState* state, int numIters)
{
for(int i = 0; i < numIters; i++)
{
IterateState(state);
RemoveGliders(state);
}
}
void Evolve(LifeState* after, LifeState* before, int numIters)
{
Copy(after, before);
Evolve(after, numIters);
}
namespace PRNG {
//Public domain PRNG by Sebastian Vigna 2014, see http://xorshift.di.unimi.it
uint64_t s[16] = { 0x12345678 };
int p = 0;
uint64_t rand64() {
uint64_t s0 = s[ p ];
uint64_t s1 = s[ p = ( p + 1 ) & 15 ];
s1 ^= s1 << 31; // a
s1 ^= s1 >> 11; // b
s0 ^= s0 >> 30; // c
return ( s[ p ] = s0 ^ s1 ) * 1181783497276652981ULL;
}
}
void RandomState(LifeState* state) {
for (int i = 0; i < N; i++)
state->state[i] = PRNG::rand64();
RecalculateMinMax(state);
}
void RandomState() {
RandomState(GlobalState);
}
void New()
{
if(GlobalState == NULL)
{
GlobalState = NewState();
Temp = NewState();
Temp1 = NewState();
Temp2 = NewState();
for(int i = 0; i < CAPTURE_COUNT; i++)
{
Captures[i] = NewState();
}
_glidersTarget[0] = NewTargetLocator("2o$obo$o!");
_glidersTarget[1] = NewTargetLocator("o$obo$2o!");
_glidersTarget[2] = NewTargetLocator("b2o$obo$2bo!", -2, 0);
_glidersTarget[3] = NewTargetLocator("2bo$obo$b2o!", -2, 0);
_gliders[0].dx = -1;
_gliders[0].dy = -1;
_gliders[1].dx = -1;
_gliders[1].dy = 1;
_gliders[2].dx = 1;
_gliders[2].dy = 1;
_gliders[3].dx = 1;
_gliders[3].dy = -1;
}
else
{
ClearData(GlobalState);
}
}
void Capture(LifeState* cap, int idx)
{
Copy(Captures[idx], cap);
}
void Capture(int idx)
{
Copy(Captures[idx], GlobalState);
}
void Run(int numIter)
{
Evolve(GlobalState, numIter);
}
void Join(LifeState* main, LifeState* delta)
{
Copy(main, delta , OR);
}
void Join(LifeState* main, LifeState* delta, int dx, int dy)
{
for(int i = delta->min; i <= delta->max; i++)
{
int idx = (i + dx + N) % N;
if(dy < 0)
main->state[idx] |= CirculateRight(delta->state[i], -dy);
else
main->state[idx] |= CirculateRight(delta->state[i], 64 -dy);
}
main->min = 0;
main->max = N - 1;
}
void PutState(LifeState* state)
{
Join(GlobalState, state);
}
void PutState(LifeState* state, int dx, int dy)
{
Join(GlobalState, state, dx, dy);
}
void PutState(int idx)
{
PutState(Captures[idx]);
}
void PutState(LifeState* state, int dx, int dy, int dxx, int dxy, int dyx, int dyy)
{
ClearData(Temp);
Copy(Temp, state);
Transform(Temp, dx, dy, dxx, dxy, dyx, dyy);
PutState(Temp);
}
void PutState(LifeState* state, CopyType op)
{
Copy(GlobalState, state, op);
}
int PutState(const char* rle)
{
ClearData(Temp);
int result = Parse(Temp, rle);
if( result == SUCCESS)
PutState(Temp);
return result;
}
int PutState(const char* rle, int x, int y)
{
ClearData(Temp);
int result = Parse(Temp, rle, x, y);
if( result == SUCCESS)
PutState(Temp);
return result;
}
int PutState(const char* rle, int dx, int dy, int dxx, int dxy, int dyx, int dyy)
{
ClearData(Temp);
int result = Parse(Temp, rle);
if( result == SUCCESS)
{
Transform(Temp, dx, dy, dxx, dxy, dyx, dyy);
PutState(Temp);
}
return result;
}
typedef struct
{
int x;
int y;
int w;
int h;
int s;
LifeState* States[MAX_ITERATIONS];
int curx;
int cury;
int curs;
} LifeIterator;
LifeIterator* NewIterator(LifeState* state, int x, int y, int w, int h, int s, EvolveType op)
{
LifeIterator* result = (LifeIterator*)(malloc(sizeof(LifeIterator)));
result -> x = x;
result -> y = y;
result -> w = w;
result -> h = h;
result -> s = s;
result -> curx = x;
result -> cury = y;
result -> curs = 0;
state -> min = 0;
state -> max = N - 1;
ClearData(Temp);
Copy(Temp, state);
for(int i = 0; i < s; i++)
{
result->States[i] = NewState();
Copy(result->States[i], Temp);
if(op == EVOLVE)
Evolve(Temp, 1);
}
return result;
}
LifeIterator* NewIterator(LifeState* states[], int x, int y, int w, int h, int s)
{
LifeIterator* result = NewIterator(states[0], x, y, w, h, s, LEAVE);
for(int i = 0; i < s; i++)
{
result->States[i] = NewState();
Copy(result->States[i], states[i]);
}
return result;
}
LifeIterator* NewIterator(LifeState* state, int x, int y, int w, int h, int s)
{
return NewIterator(state, x, y, w, h, s, EVOLVE);
}
LifeIterator* NewIterator(LifeState* state, int x, int y, int w, int h)
{
return NewIterator(state, x, y, w, h, 1, LEAVE);
}
LifeIterator* NewIterator(const char* rle, int x, int y, int w, int h, int s)
{
LifeState* state = NewState(rle);
return NewIterator(state, x, y, w, h, s, EVOLVE);
}
LifeIterator* NewIterator(const char* rle, int x, int y, int w, int h)
{
LifeState* state = NewState(rle);
return NewIterator(state, x, y, w, h);
}
LifeIterator* NewIterator(int x, int y, int w, int h)
{
ClearData(Temp);
return NewIterator(Temp, x, y, w, h, 1);
}
void Print(LifeIterator* iter)
{
printf("\n(%d, %d, %d)", iter->curx, iter->cury, iter->curs);
}
void Print(LifeIterator* iter[], int numIters)
{
for(int i = 0; i < numIters; i++)
Print(iter[i]);
}
void Print(LifeIterator* iter, const char* name)
{
printf("\nSetCurrent(%s, %d, %d, %d);", name, iter->curx, iter->cury, iter->curs);
}
void Reset(LifeIterator* iter)
{
iter -> curx = iter -> x;
iter -> cury = iter -> y;
iter -> curs = 0;
}
int Next(LifeIterator* iter)
{
(iter -> curs)++;
if((iter -> curs) < (iter->s))
return SUCCESS;
(iter -> curs) = 0;
(iter -> curx)++;
if((iter -> curx) < (iter->x) + (iter->w))
return SUCCESS;
iter -> curx = iter->x;
(iter -> cury)++;
if((iter -> cury) < (iter->y) + (iter->h))
return SUCCESS;
Reset(iter);
return FAIL;
}
int Next(LifeIterator *iter1[], int numIters, int toPrint)
{
for(int i = 0; i < numIters; i++)
{
if(toPrint == YES)
{
if(i == numIters - 1)
Print(iter1[i]);
}
if(Next(iter1[i]) == SUCCESS)
return SUCCESS;
}
return FAIL;
}
int Next(LifeIterator *iter1, LifeIterator *iter2, int toPrint)
{
LifeIterator *iters[] = {iter1, iter2};
return Next(iters, 2, toPrint);
}
int Next(LifeIterator *iter1, LifeIterator *iter2)
{
return Next(iter1, iter2, YES);
}
int Next(LifeIterator *iter1, LifeIterator *iter2, LifeIterator *iter3, int toPrint)
{
LifeIterator *iters[] = {iter1, iter2, iter3};
return Next(iters, 3, toPrint);
}
int Next(LifeIterator *iter1, LifeIterator *iter2, LifeIterator *iter3)
{
return Next(iter1, iter2, iter3, YES);
}
int Next(LifeIterator *iter1, LifeIterator *iter2, LifeIterator *iter3, LifeIterator *iter4, int toPrint)
{
LifeIterator *iters[] = {iter1, iter2, iter3, iter4};
return Next(iters, 4, toPrint);
}
int Next(LifeIterator *iter1, LifeIterator *iter2, LifeIterator *iter3, LifeIterator *iter4)
{
return Next(iter1, iter2, iter3, iter4, YES);
}
int Next(LifeIterator *iter1, LifeIterator *iter2, LifeIterator *iter3, LifeIterator *iter4, LifeIterator *iter5, int toPrint)
{
LifeIterator *iters[] = {iter1, iter2, iter3, iter4, iter5};
return Next(iters, 5, toPrint);
}
int Next(LifeIterator *iter1, LifeIterator *iter2, LifeIterator *iter3, LifeIterator *iter4, LifeIterator *iter5)
{
return Next(iter1, iter2, iter3, iter4, iter5, YES);
}
int Next(LifeIterator *iter1, LifeIterator *iter2, LifeIterator *iter3, LifeIterator *iter4, LifeIterator *iter5, LifeIterator *iter6, int toPrint)
{
LifeIterator *iters[] = {iter1, iter2, iter3, iter4, iter5, iter6};
return Next(iters, 6, toPrint);
}
int Next(LifeIterator *iter1, LifeIterator *iter2, LifeIterator *iter3, LifeIterator *iter4, LifeIterator *iter5, LifeIterator *iter6)
{
return Next(iter1, iter2, iter3, iter4, iter5, iter6, YES);
}
int Next(LifeIterator *iter1[], int numIters)
{
return Next(iter1, numIters, YES);
}
void FreeIterator(LifeIterator* iter)
{
for(int i = 0; i < iter->s; i++)
FreeState(iter->States[i]);
free(iter);
}
void Join(LifeState* state, LifeIterator* iter)
{
Join(state, iter->States[iter -> curs], iter->curx, iter->cury);
}
void PutState(LifeIterator* iter)
{
Join(GlobalState, iter->States[iter -> curs], iter->curx, iter->cury);
}
void SetCurrent(LifeIterator* iter, int curx, int cury, int curs)
{
iter -> curx = curx;
iter -> cury = cury;
iter -> curs = curs;
}
int Validate(LifeIterator *iter1, LifeIterator *iter2)
{
if(iter1->curx > iter2->curx)
return SUCCESS;
if(iter1->curx < iter2->curx)
return FAIL;
if(iter1->cury > iter2->cury)
return SUCCESS;
if(iter1->cury < iter2->cury)
return FAIL;
if(iter1->curs > iter2->curs)
return SUCCESS;
return FAIL;
}
int Validate(LifeIterator *iter1, LifeIterator *iter2, LifeIterator *iter3)
{
if(Validate(iter1, iter2) == FAIL)
return FAIL;
if(Validate(iter2, iter3) == FAIL)
return FAIL;
return SUCCESS;
}
int Validate(LifeIterator *iters[], int iterCount)
{
for(int i = 0; i < iterCount - 1; i++)
if(Validate(iters[i], iters[i + 1]) == FAIL)
return FAIL;
return SUCCESS;
}
typedef struct
{
LifeState** results;
int size;
int allocated;
} LifeResults;
LifeResults* NewResults()
{
LifeResults* result = (LifeResults*)(malloc(sizeof(LifeResults)));
result->results = (LifeState**)(malloc(10 * sizeof(LifeState*)));
for(int i = 0; i < 10; i++)
{
(result->results)[i] = NewState();
}
result->allocated = 10;
result->size = 0;
return result;
}
void Add(LifeResults* results, LifeState* state)
{
if(results->size == results->allocated)
{
results->results = (LifeState**)(realloc(results->results, results->allocated * 2 * sizeof(LifeState*)));
results->allocated *= 2;
for(int i = results->size; i < 2 * (results->size); i++)
{
(results->results)[i] = NewState();
}
}
Copy((results->results)[results->size], state);
results->size++;
}
void Add(LifeResults* results)
{
Add(results, GlobalState);
}
char* ReadFile(const char *filePath)
{
char* buffer = (char*) malloc(1);
buffer[0] = '\0';
long length;
FILE * f = fopen (filePath, "r");
if (f)
{
fseek (f, 0, SEEK_END);
length = ftell (f);
fseek (f, 0, SEEK_SET);
buffer = (char*)realloc (buffer, length);
if (buffer)
{
fread(buffer, 1, length, f);
}
fclose (f);
}
return buffer;
}
void SaveResults(LifeResults* results, const char* filePath)
{
FILE *f;
f = fopen(filePath, "wb");
for(int i = 0; i < results->size; i++)
{
fputs(GetRLE((results->results)[i]), f);
fprintf(f, "129$");
}
fclose(f);
}
LifeResults* LoadResults(const char* filePath)
{
LifeResults* results = NewResults();
char* rle = ReadFile(filePath);
int idx = 0;
while(rle[idx] != '\0')
{
ClearData(Temp);
idx = Parse(Temp, rle, idx);
Move(Temp, -32, -32);
Add(results, Temp);
}
return results;
}
typedef struct
{
int minx;
int maxx;
uint64_t minVal;
uint64_t maxVal;
} LifeBox;
LifeBox* NewBox()
{
LifeBox* result = (LifeBox*)(malloc(sizeof(LifeBox)));
result->minx = 0;
result->maxx = 0;
result->minVal = 1ULL;
result->maxVal = 1ULL;
return result;
}
LifeBox* NewBox(int minx, int miny, int maxx, int maxy)
{
LifeBox* result = (LifeBox*)(malloc(sizeof(LifeBox)));
result->minx = minx + 32;
result->maxx = maxx + 32;
result->minVal = 1ULL << (miny + 32);
result->maxVal = 1ULL << (maxy + 32);
return result;
}
int StateWidth(LifeState* state)
{
RefitMinMax(state);
return state->max - state->min + 1;
}
int BoxWidth(LifeBox* box)
{
return box->maxx - box->minx + 1;
}
int BoxX(LifeBox* box)
{
return box->minx;
}
int BoxY(LifeBox* box)
{
uint64_t tmp = 1ULL;
for(int i = 0; i <= N; i++)
{
if(tmp == box->minVal)
return i;
}
}
int BoxHeight(LifeBox* box)
{
int miny;
uint64_t tmp = 1ULL;
for(int i = 0; i <= N; i++)
{
if(tmp == box->minVal)
miny = i;
if(tmp == box->maxVal)
{
return i - miny + 1;
}
}
return -1;
}
int IsInside(LifeState* state, LifeBox* box)
{
for(int i = state->min; i <= state->max; i++)
{
uint64_t curVal = state->state[i];
if(curVal == 0)
continue;
if(curVal > box->maxVal || curVal < box->minVal)
return NO;
if(i < box->minx)
return NO;
if(i > box->maxx)
return NO;
}
return YES;
}
int GetBoundingBox(LifeState* state, LifeBox* box)
{
if(IsEmpty(state))
return FAIL;
RefitMinMax(state);
uint64_t or_all = 0LL;
for(int i = state->min; i <= state->max; i++)
{
or_all |= state->state[i];
}
box->minx = state->min;
box->maxx = state->max;
box->minVal = 1ULL;
box->maxVal = 1ULL << 63;
for(int i = 0; i <= N; i++)
{
//example 0011001000
//get 0010000000, 0000001000
if(box->minVal <= or_all)
box->minVal << 1;
if(box->maxVal >= or_all)
box->minVal >> 1;
}
box->minVal >> 1;
box->maxVal << 1;
return SUCCESS;
}
int IsInside(LifeBox* box)
{
return IsInside(GlobalState, box);
}
You can’t perform that action at this time.