void sprinkle(Object ** g, double init_rabbit, double init_fox) {
int i, squares, x, y;
squares = WIDTH*HEIGHT;
for (i = squares*init_rabbit; i > 0; -- i) {
do {
x = (double)WIDTH*random_interval();
y = (double)HEIGHT*random_interval();
if (g[x][y].c == BARE) {
g[x][y].c = RABBIT;
g[x][y].age = 0;
break;
}
} while (1);
}
for (i = squares*init_fox; i > 0; -- i) {
do {
x = (double)WIDTH*random_interval();
y = (double)HEIGHT*random_interval();
if (g[x][y].c == BARE) {
g[x][y].c = FOX;
g[x][y].age = 0;
break;
}
} while (1);
}
}
int main()
{
int m, n, k;
float *A, *B, *C, *D;
long t;
t = clock();
srand(time(NULL));
m = random_interval(1, 1500);
n = random_interval(1, 1500);
k = random_interval(1, 1500);
fprintf(stderr, "m = %d, n = %d, k = %d\n", m, n, k);
A = (float *)malloc(sizeof(float) * m * k);
B = (float *)malloc(sizeof(float) * k * n);
C = (float *)malloc(sizeof(float) * m * n);
D = (float *)malloc(sizeof(float) * m * n);
generate(A, m * k);
generate(B, k * n);
fprintf(stderr, "Generate Matrix : %gs\n", (double)(clock() - t) / CLOCKS_PER_SEC);
t = clock();
matmul(A, B, C, m, n, k, 32);
fprintf(stderr, "Multiply : %gs\n", (double)(clock() - t) / CLOCKS_PER_SEC);
t = clock();
naive_matmul(A, B, D, m, n, k);
fprintf(stderr, "Get Correct Answer : %gs\n", (double)(clock() - t) / CLOCKS_PER_SEC);
t = clock();
float diff;
int flag = 0, i;
for(i=0;i<m*n;++i)
{
diff = C[i] - D[i];
if(diff<0)diff=-diff;
if(diff > 0.0001)
{
flag = 1;
fprintf(stderr, "WRONG!!!!! %f != %f\n", C[i], D[i]);
break;
}
}
if(!flag)
fprintf(stderr, "CORRECT!!!!!\n");
free(A);
free(B);
free(C);
free(D);
fprintf(stderr, "Clean Up : %gs\n", (double)(clock() - t) / CLOCKS_PER_SEC);
return 0;
}
void test_isat(void)
{
printf("\ninterval saturation\n");
LOOP {
size_t dim = 5;
size_t p = rand() % dim;
ap_abstract0_t* pka,*ppla;
ap_interval_t* i = ap_interval_alloc();
bool pks,ppls;
random_interval(i);
pka = random_poly(pk,dim);
ppla = convert(ppl,pka);
pks = ap_abstract0_sat_interval(pk,pka,p,i);
ppls = ap_abstract0_sat_interval(ppl,ppla,p,i);
RESULT('*');
if (pks!=ppls) {
ERROR("different results");
print_poly("pka",pka);
ap_interval_fprint(stderr,i);
fprintf(stderr,"\nvar=%i\npks=%i ppls=%i\n",(int)p,pks,ppls);
}
ap_abstract0_free(pk,pka); ap_abstract0_free(ppl,ppla);
ap_interval_free(i);
} ENDLOOP;
}
void * pick_one_of_three ( void * a, void * b, void * c ) {
if ( a == b || b == c || a == c ) *(char*)(0) = 9;
double r = random_interval();
if ( r <= 1.0/3.0 ) return a;
if ( r <= 2.0/3.0 ) return b;
return c;
}
void * pick_one_of_five ( void * a, void * b, void * c, void * d, void * e ) {
if ( a == b || a == c || a == d || a == e || b == c || b == d || b == e || c == d || c == e || d == e ) *(char*)(0) = 9;
double r = random_interval();
if ( r <= 1.0/5.0 ) return a;
if ( r <= 2.0/5.0 ) return b;
if ( r <= 3.0/5.0 ) return c;
if ( r <= 4.0/5.0 ) return d;
return e;
}
static void start_another(SESSION *session)
{
if (random_delay > 0) {
event_request_timer(start_event, (char *) session,
random_interval(random_delay));
} else if (fixed_delay > 0) {
event_request_timer(start_event, (char *) session, fixed_delay);
} else {
startup(session);
}
}
static void create_cells( State *st )
{
int border = (int)(200.0 * st->screen_scale);
int i, foodcnt;
int w = st->width-2*border;
int h = st->height-2*border;
st->color[0] = 0.5 + random_max( 1000 ) * 0.0005;
st->color[1] = 0.5 + random_max( 1000 ) * 0.0005;
st->color[2] = 0.5 + random_max( 1000 ) * 0.0005;
st->color[3] = 1.0f;
/* allocate if startup */
if (!st->cell) {
st->cell = (Cell *) malloc( st->max_cells * sizeof(Cell));
}
/* fill the screen with random food for our little critters */
foodcnt = (st->width*st->height)/16;
for (i=0; i<foodcnt; ++i) {
st->food[i] = random_interval( st->minfood, st->maxfood );
}
/* create the requested seed-cells */
st->num_cells = st->num_seeds;
for (i=0; i<st->num_cells; ++i) {
st->cell[i].x = border + random_max( w );
st->cell[i].y = border + random_max( h );
st->cell[i].vx = 0.0;
st->cell[i].vy = 0.0;
st->cell[i].age = random_max( 0x0f );
st->cell[i].min_dist = 500.0;
st->cell[i].energy = random_interval( 5, 5+0x3f );
st->cell[i].rotation = ((double)random()/(double)RAND_MAX)*360.0;
st->cell[i].radius = st->radius;
st->cell[i].growth = 1.0;
}
}
/* Borlandified and identical */
void passages_init(void)
{
signed short si;
signed short i;
Bit8u *p = p_datseg + 0x6f00;
for (i = 0; i < 45; p += 8, i++) {
host_writeb(p + 4, (unsigned char)random_interval(0, host_readbs(p + 3)));
host_writeb(p + 7, (unsigned char)random_interval(70, 130));
si = random_schick(100);
if (!host_readbs(p + 5)) {
/* Hochseerouten */
host_writeb(p + 6, si <= 50 ? 0 : (si <= 80 ? 1 : (si <= 95 ? 2 : 3)));
} else {
/* Seerouten */
host_writeb(p + 6, si <= 10 ? 4 : (si <= 40 ? 5 : (si <= 80 ? 6 : 7)));
}
#if !defined(__BORLANDC__)
D1_LOG("%16s - %16s: %d %d %d %d %d %d\n",
(char*)get_ltx((host_readb(p + 0) + 0xeb) * 4),
(char*)get_ltx((host_readb(p + 1) + 0xeb) * 4),
host_readb(p + 2),
host_readb(p + 3),
host_readb(p + 4),
host_readb(p + 5),
host_readb(p + 6),
host_readb(p + 7));
#endif
}
}
/* random polyhedron */
ap_abstract0_t* random_poly(ap_manager_t* man,int dim)
{
int i;
ap_abstract0_t* p;
ap_interval_t** t = ap_interval_array_alloc(dim);
ap_generator0_array_t ar = ap_generator0_array_make(dim);
for (i=0;i<dim;i++)
random_interval(t[i]);
for (i=0;i<dim;i++)
ar.p[i] = random_generator(dim,AP_GEN_RAY);
if (intdim)
p = ap_abstract0_of_box(man,dim/2,dim-dim/2,(ap_interval_t**)t);
else
p = ap_abstract0_of_box(man,0,dim,(ap_interval_t**)t);
ap_abstract0_add_ray_array(man,true,p,&ar);
ap_generator0_array_clear(&ar);
ap_interval_array_free(t,dim);
return p;
}
void * pick_one_of_eight ( void * a, void * b, void * c, void * d, void * e, void * f, void * g, void * h ) {
if ( a == b || a == c || a == d || a == e || a == f || a == g || a == h ||
b == c || b == d || b == e || b == f || b == g || b == h ||
c == d || c == e || c == f || c == g || c == h ||
d == e || d == f || d == g || d == h ||
e == f || e == g || e == h ||
f == g || f == h ||
g == h )
*(char*)(0) = 9;
double r = random_interval();
if ( r <= 1.0/8.0 ) return a;
if ( r <= 2.0/8.0 ) return b;
if ( r <= 3.0/8.0 ) return c;
if ( r <= 4.0/8.0 ) return d;
if ( r <= 5.0/8.0 ) return e;
if ( r <= 6.0/8.0 ) return f;
if ( r <= 7.0/8.0 ) return g;
return h;
}
/* all this is rather expensive :( */
static void tick( State *st )
{
int new_num_cells, num_cells=0;
int b, j;
int x, y, w4=st->width/4, h4=st->height/4, offset;
double min_dist;
int min_index;
int num_living = 0;
const double check_dist = 0.75*st->move_dist;
const double grow_dist = 0.75*st->radius;
const double adult_radius = st->radius;
/* find number of cells capable of division
and count living cells
*/
for (b=0; b<st->num_cells; ++b) {
if (st->cell[b].energy > 0) num_living++;
if (can_divide( st, &st->cell[b] )) num_cells++;
}
new_num_cells = st->num_cells + num_cells;
/* end of simulation ? */
if (0 == num_living || new_num_cells >= st->max_cells) {
if (st->pause_counter > 0) st->pause_counter--;
if (st->pause_counter > 0) return;
create_cells( st );
st->pause_counter = st->pause;
} else if (num_cells) { /* any fertile candidates ? */
for (b=0, j=st->num_cells; b<st->num_cells; ++b) {
if (can_divide( st, &st->cell[b] )) {
st->cell[b].vx = random_interval( -50, 50 ) * 0.01;
st->cell[b].vy = random_interval( -50, 50 ) * 0.01;
st->cell[b].age = random_max( 0x0f );
/* half energy for both plus some bonus for forking */
st->cell[b].energy =
st->cell[b].energy/2 + random_max( 0x0f );
/* forking makes me shrink */
st->cell[b].growth = 0.995;
/* this one initially goes into the oposite direction */
st->cell[j].vx = -st->cell[b].vx;
st->cell[j].vy = -st->cell[b].vy;
/* same center */
st->cell[j].x = st->cell[b].x;
st->cell[j].y = st->cell[b].y;
st->cell[j].age = random_max( 0x0f );
st->cell[j].energy = (st->cell[b].energy);
st->cell[j].rotation =
((double)random()/(double)RAND_MAX)*360.0;
st->cell[j].growth = st->cell[b].growth;
st->cell[j].radius = st->cell[b].radius;
++j;
} else {
st->cell[b].vx = 0.0;
st->cell[b].vy = 0.0;
}
}
st->num_cells = new_num_cells;
}
/* for each find a direction to escape */
if (st->num_cells > 1) {
for (b=0; b<st->num_cells; ++b) {
if (st->cell[b].energy > 0) {
double vx;
double vy;
double len;
/* grow or shrink */
st->cell[b].radius *= st->cell[b].growth;
/* find closest neighbour */
min_dist = 100000.0;
min_index = 0;
for (j=0; j<st->num_cells; ++j) {
if (j!=b) {
const double dx = st->cell[b].x - st->cell[j].x;
const double dy = st->cell[b].y - st->cell[j].y;
if (fabs(dx) < check_dist || fabs(dy) < check_dist) {
const double dist = dx*dx+dy*dy;
/*const double dist = sqrt( dx*dx+dy*dy );*/
if (dist<min_dist) {
min_dist = dist;
min_index = j;
}
}
}
}
/* escape step is away from closest normalized with distance */
vx = st->cell[b].x - st->cell[min_index].x;
vy = st->cell[b].y - st->cell[min_index].y;
len = sqrt( vx*vx + vy*vy );
if (len > 0.0001) {
st->cell[b].vx = vx/len;
st->cell[b].vy = vy/len;
}
st->cell[b].min_dist = len;
/* if not adult (radius too small) */
if (st->cell[b].radius < adult_radius) {
/* if too small 60% stop shrinking */
if (st->cell[b].radius < adult_radius * 0.6) {
st->cell[b].growth = 1.0;
}
/* at safe distance we start growing again */
if (len > grow_dist) {
if (st->cell[b].energy > 30) {
st->cell[b].growth = 1.005;
}
}
} else { /* else keep size */
st->cell[b].growth = 1.0;
}
}
}
} else {
st->cell[0].min_dist = 2*st->move_dist;
}
/* now move em, snack and burn energy */
for (b=0; b<st->num_cells; ++b) {
/* if still alive */
if (st->cell[b].energy > 0) {
/* agility depends on amount of energy */
double fac = (double)st->cell[b].energy / 50.0;
if (fac < 0.0) fac = 0.0;
if (fac > 1.0) fac = 1.0;
st->cell[b].x += fac*(2.0 -
(4.0*(double)random() / (double)RAND_MAX) +
st->cell[b].vx);
st->cell[b].y += fac*(2.0 -
(4.0*(double)random() / (double)RAND_MAX) +
st->cell[b].vy);
/* get older and burn energy */
if (st->cell[b].energy > 0) {
st->cell[b].age++;
st->cell[b].energy--;
}
/* have a snack */
x = ((int)st->cell[b].x)/4;
if (x<0) x=0; if (x>=w4) x = w4-1;
y = ((int)st->cell[b].y)/4;
if (y<0) y=0; if (y>=h4) y = h4-1;
offset = x+y*w4;
/* don't eat if already satisfied */
if (st->cell[b].energy < 100 &&
st->food[offset] > 0) {
st->food[offset]--;
st->cell[b].energy++;
/* if you are hungry, eat more */
if (st->cell[b].energy < 50 &&
st->food[offset] > 0) {
st->food[offset]--;
st->cell[b].energy++;
}
}
}
}
}
_Bool probabilistic_event_happens ( char * s, double p ) {
double r = random_interval();
// printf("Checking probability of event %s: %.2f: %.2f -- %s\n", s, p, r, p >= r ? "Passes":"Fails" );
return p >= r;
}
