ca.c

细胞自动机的一个源代码

 config file init functions
***************************************/

	       
char *ca_readcfgl(char *l, FILE *fp) {
  int i;

  fgets(l, CA_MAX_LINE, fp);
  //printf("got:\n\t-%s\n", l);

  while ((l[0] == '#') && (!feof(fp))) {
    fgets(l, CA_MAX_LINE, fp);
    //printf("got:\n\t-%s\n", l);

  }
  i = ( (strlen(l)>0) ? (strlen(l)-1) : 0 );
  l[i] = '\0';

  //printf("\nreturning:\n\t-%s\n", l);

  return(l);
}


/* only used for non-totalistic config files */
int ca_file_config(ca_t *ca, FILE *fp) {
  char line[CA_MAX_LINE], *c;

  c = ca_readcfgl(line, fp);
  if (atoi(c)==0) {
    ca_update_func = ca_flat_update;
    ca->tr = NULL;
    return(ca_nontot_config(ca, fp));
  } else if (atoi(c)==1) {
    ca_update_func = ca_tot_update;
    ca->r = NULL;
    return(ca_tot_config(ca, fp));
  }

  return(-1);
}


int ca_nontot_config(ca_t *ca, FILE *fp) {
  int i, j;
  int k, dim, *d, nei_num, **nei, *r, numrule, wlen;
  float **b, *wb;
  char line[CA_MAX_LINE], *c;


  /* printf("RULE NON TOT CONFIG\n");*/

  /* space and dimensions */
  dim = atoi(ca_readcfgl(line, fp));
  wlen = atoi(ca_readcfgl(line, fp));

  //printf("allocating d (%i)\n", sizeof(int)*dim);

  d = (int *)malloc(sizeof(int)*dim);
  c = ca_readcfgl(line, fp);
  for (i=0; i<dim; i++) {
    d[i] = atoi(c);
    c = strchr(c+1, ' ');
  }

  /* neighbors */
  nei_num = atoi(ca_readcfgl(line, fp));

  //printf("allocating nei (%i)\n", sizeof(int *)*nei_num);

  nei = (int **)malloc(sizeof(int *)*nei_num);
  for (i=0; i<nei_num; i++) {

    //printf("\t%i (%i)\n", i, sizeof(int)*dim);

    nei[i] = (int *)malloc(sizeof(int)*dim);
    c = ca_readcfgl(line, fp);
    for (j=0; j<dim; j++) {
      nei[i][j] = atoi(c);
      c = strchr(c+1, ' ');
    }
  }

  /* basis */

  //printf("allocating b (%i)\n", sizeof(float *)*dim);

  b = (float **)malloc(sizeof(float *)*dim);
  for (i=0; i<dim; i++) {

    //printf("\t%i (%i)\n", i, sizeof(float)*dim);

    b[i] = (float *)malloc(sizeof(float)*dim);
    c = ca_readcfgl(line, fp);
    for (j=0; j<dim; j++) {
      b[i][j] = (float)atof(c);
      c = strchr(c+1, ' ');
    }
  }

  //printf("allocating wb (%i)\n", sizeof(float)*(dim + 1));

  wb = (float *)malloc(sizeof(float)*(dim+1));
  c = ca_readcfgl(line, fp);
  /* printf("%s\n", c); */
  for (i=0; i<(dim+1); i++) {
    wb[i] = (float)atof(c);
    c = strchr(c+1, ' ');
  }
		       

  /* alphabet and rules */
  k = atoi(ca_readcfgl(line, fp));
  c = ca_readcfgl(line, fp);
  numrule = 1;
  for (i=0; i<nei_num; i++) {
    numrule *= k;
  }

  /* printf("num rules: %i\n", numrule); */

  //printf("allocating r (%i)\n", sizeof(int)*numrule);

  r = (int *)malloc(sizeof(int)*numrule);
  for (i=0; i<numrule; i++) {
    r[i] = atoi(c);
    c = strchr(c+1, ' ');
  }

  ca_init(ca, k, dim, wlen, d, nei_num, nei, r, b, wb);


  //printf("freeing r\n");
  free(r);

  for (i=0; i<dim; i++) {

    //printf("\t%i\n", i);

    free(b[i]);
  }

  //printf("freeing b\n");

  free(b);


  //printf("freeing wb\n");

  free(wb);
  for (i=0; i<nei_num; i++) {

    //printf("\t%i\n", i);

    free(nei[i]);
  }

  //printf("freeing nei\n");

  free(nei);


  //printf("freeing d\n");

  free(d);

  return(0);

}

/* outer totalistic config */
int ca_tot_config(ca_t *ca, FILE *fp) {
  int i, j;
  int k, dim, *d, nei_num, **nei, *r, numrule, wlen, *w;
  float **b, *wb;
  char line[CA_MAX_LINE], *c;

  printf("RULE TOT CONFIG\n");


  /* space and dimensions */
  dim = atoi(ca_readcfgl(line, fp));

  printf("dim: %i\n", dim);

  wlen = atoi(ca_readcfgl(line, fp));

  printf("%i\n", wlen);

  d = (int *)malloc(sizeof(int)*dim);
  c = ca_readcfgl(line, fp);
  for (i=0; i<dim; i++) {
    d[i] = atoi(c);
    c = strchr(c+1, ' ');
  }

  /* neighbors */
  nei_num = atoi(ca_readcfgl(line, fp));

  printf("nei: %i\n", nei_num);

  nei = (int **)malloc(sizeof(int *)*nei_num);
  for (i=0; i<nei_num; i++) {
    nei[i] = (int *)malloc(sizeof(int)*dim);
    c = ca_readcfgl(line, fp);
    for (j=0; j<dim; j++) {
      nei[i][j] = atoi(c);
      c = strchr(c+1, ' ');
    }
  }

  /* weights */
  w = (int *)malloc(sizeof(int)*nei_num);
  c = ca_readcfgl(line, fp);
  for (i=0; i<nei_num; i++) {
    w[i] = atoi(c);
    c = strchr(c+1, ' ');

    printf("%i ", w[i]);

  }

  printf("\n");

  /* basis */
  b = (float **)malloc(sizeof(float *)*dim);
  for (i=0; i<dim; i++) {
    b[i] = (float *)malloc(sizeof(float)*dim);
    c = ca_readcfgl(line, fp);
    for (j=0; j<dim; j++) {
      b[i][j] = (float)atof(c);
      c = strchr(c+1, ' ');
    }
  }

  wb = (float *)malloc(sizeof(float)*(dim+1));
  c = ca_readcfgl(line, fp);
  printf("%s\n", c);
  for (i=0; i<(dim+1); i++) {
    wb[i] = (float)atof(c);
    c = strchr(c+1, ' ');
  }
		       

  /* alphabet and rules */
  k = atoi(ca_readcfgl(line, fp));
  c = ca_readcfgl(line, fp);
  numrule = 0;
  for (i=0; i<nei_num; i++) {
    numrule+=w[i];
  }
  numrule++;
  numrule *= k;

  printf("num rules: %i\n", numrule);
  r = (int *)malloc(sizeof(int)*numrule);
  for (i=0; i<numrule; i++) {
    r[i] = atoi(c);
    c = strchr(c+1, ' ');
  }

  ca_tot_init(ca, k, dim, wlen, d, nei_num, nei, w, r, b, wb);

  for (i=0; i<(ca->nei_num+1)*(ca->k); i++) ;

  free(r);
  for (i=0; i<dim; i++) {
    free(b[i]);
  }
  free(b);
  free(wb);
  for (i=0; i<nei_num; i++) {
    free(nei[i]);
  }
  free(nei);
  free(w);
  free(d);

  return(0);

}

int ca_gen_template_file(FILE *fp, int dim, int nei, int a) {
  int i, j, k;

  fprintf(fp, "#ca config template\n#dim\n");
  fprintf(fp, "%i\n", dim);
  fprintf(fp, "#ca dim\n");
  for (i=0; i<dim; i++) {
    fprintf(fp, "100 ");
  }
  fprintf(fp, "\n#num neighbors\n%i\n", nei);
  fprintf(fp, "#neighbors\n");
  for (i=0; i<nei; i++) {
    for (j=0; j<dim; j++) {
      fprintf(fp, "0 ");
    }
    fprintf(fp, "\n");
  }
  fprintf(fp, "#display basis\n");
  for (i=0; i<dim; i++) {
    for (j=0; j<dim; j++) {
      fprintf(fp, "0 ");
    }
    fprintf(fp, "\n");
  }
  fprintf(fp, "#number of states\n");
  fprintf(fp, "%i\n", a);
  k = a;
  for (i=0; i<nei; i++) {
    k*=a;
  }
  fprintf(fp, "#rules\n");
  for (i=0; i<k; i++) {
    fprintf(fp, "0 ");
  }
  fprintf(fp, "\n");

  return(0);

}


int ca_gen_life_template(FILE *fp, int dim, int *environ, int *life) {
}

/******************************************
 printing functions

 these are pretty much depreciated, but i'll keep
 em around for a while
*******************************************/

void ca_2d_print(ca_t *ca) {
  int i, j;
  int p[2];

  for (i=0; i<(ca->d[0]); i++) {
    for (j=0; j<(ca->d[1]); j++) {
      p[0]=i;
      p[1]=j;
      printf("%c", ca->ca[ca->cur][ca_point(ca, p)] ? '.' : '0' );
    }
    printf("\n");
  }
}

void ca_print(ca_t *ca) {
  int i, j, k;

  printf("dim: %i, fd: %i\nd: ", ca->dim, ca->fd);
  for (i=0; i<ca->dim; i++) {
    printf("%i ", ca->d[i]);
  }
  printf("\n");

  printf("nei:");
  for (i=0; i<ca->nei_num; i++) {
    printf("\n  ");
    for (j=0; j<ca->dim; j++) {
      printf("%i ", ca->nei[i][j]);
    }
  }

  printf("\nfnei:");
  for (i=0; i<ca->nei_num; i++) {
    printf("%i ", ca->fnei[i]);
  }
  printf("\n");

  printf("basis:");
  for (i=0; i<ca->dim; i++) {
    printf("\n  ");
    for (j=0; j<ca->dim; j++) {
      printf("%f ", ca->b[i][j]);
    }
  }
  printf("\n");

  printf("rules: %i\n  ", ca->r_num);
  for (i=0; i<ca->r_num; i++) {
    printf("%i ", ca->r[i]);
  }
  printf("\n");

  printf("k: %i\n", ca->k);
  printf("delay: %i\n", ca->delay);

  printf("cur: %i, next: %i\n", ca->cur, ca->next);

  printf("\n\nca:\n");
  for (i=0; i<(ca->d[0]); i++) {
    printf("%i", ca->ca[ca->cur][i]);
  }

  printf("\n\n");

}

void ca_print_ca1d(ca_t *ca) {
  int i;
  int ps[1], pe[1];

  ps[0] = 1;
  pe[0] = ca->d[0]-2;

  for (i=ca_point(ca, ps); i<ca_point(ca, pe); i++) {
    printf("%i", ca->ca[ca->cur][i]);
  }

  printf("\n");

}


void ca_print_ca2d(ca_t *ca) {
  int i, j;
  int ps[2], pe[2], p[2];

  ps[0] = 1;
  ps[1] = 1;

  pe[0] = ca->d[0]-2;
  pe[1] = ca->d[1]-2;

  for (i=ps[0]; i<pe[0]; i++) {
    for (j=ps[1]; j<pe[1]; j++) {

      p[0] = i;
      p[1] = j;

      printf("%i", ca->ca[ca->cur][ca_point(ca, p)]);
    }
    printf("\n");
  }
}

/***********************
 save and read functions
************************/

/* save file functionality */
void ca_save_file(ca_t *ca, char *fn) {
  FILE *fp;
  int i=0, j, k;

  fp = (fn?fopen(fn, "w"):stdout);
  fprintf(fp, "#save file\n%i\n", CA_SAVE_FILE_TOKEN);
  fprintf(fp, "#dim\n%i\n", ca->dim);
  fprintf(fp, "#CA dimensions length\n");
  for (i=0; i<ca->dim; i++) {
    fprintf(fp, "%i ", ca->d[i]);
  }
  fprintf(fp, "\n#CA win length\n%i\n", ca->wlen);
  fprintf(fp, "#CA (cur, cur-1, ..., cur-wlen+1)\n");
  for (i=0, j=ca->cur; i<ca->wlen; i++, j=((j+ca->wlen-1)%ca->wlen)) {
    for (k=0; k<ca->fd; k++) {
      fprintf(fp, "%i ", ca->ca[j][k]);
    }
    fprintf(fp, "\n");
  }

  if (fp!=stdout) {
    fclose(fp);
  }
}


/* this does some rudimentary checks, but other than
   that, it assumes that whoever using this has a clue */
int ca_read_file(ca_t *ca, char *fn) {
  int i, j, k;
  FILE *fp;
  char *c, line[CA_MAX_LINE];

  printf("reading file %s\n", (fn ? fn : "(no file)"));

  fp = (fn ? fopen(fn, "r") : stdin);

  c = ca_readcfgl(line, fp);
  if (atoi(c)!=CA_SAVE_FILE_TOKEN) {
    printf("bad read, quitting\n");
    return(-1);
  }

  c = ca_readcfgl(line, fp);
  if (atoi(c)!=ca->dim) {
    printf("ca dim %i != file dim %i\n",
	   ca->dim,
	   atoi(c));
    return(-1);
  }

  c = ca_readcfgl(line, fp);
  for (i=0; i<ca->dim; i++) {
    if (atoi(c)!=ca->d[i]) {
      printf("bad dimension, quitting\n");
      return(-1);
    }
    c = strchr(c+1, ' ');
  }

  c = ca_readcfgl(line, fp);
  k = ( (atoi(c)<ca->wlen) ? atoi(c) : ca->wlen);
  for(i=0; i<k; i++) {
    c = ca_readcfgl(line, fp);
    for (j=0; j<ca->fd; j++) {
      ca->ca[(ca->cur - i + ca->wlen)%(ca->wlen)][j] = atoi(c);
      c = strchr(c+1, ' ');
    }
  }
}



/******************************
 test main
*******************************/

/***********************

int main(void) {
  ca_t *ca;
  FILE *fin;
  int d[2];
  int i, j;

  if (!(fin = fopen("samp.input", "r"))) {
    printf("couldn't open samp.input\n");
    exit(0);
  }
  //ca_gen_template_file(fout, 2, 6, 2);

  ca = (ca_t *)malloc(sizeof(ca_t));

  ca_file_config(ca, fin);
  ca_print(ca);

      
  ca_free(ca);
  printf("quitting\n");

  fclose(fin);

}
***********************/


/***********************
int main(void) {
  int k = 2;
  int dim = 1;
  int d[] = { 80 };
  int nei_num = 2;
  int **nei;
  int r[] = { 0, 1, 1, 0, 1, 0, 0, 1 };
  float **b;
  ca_t *ca;
  int ps[] = { 1 }, pe[] = { 78 };
  int i;

  nei = (int **)malloc(sizeof(int *)*2);
  nei[0] = (int *)malloc(sizeof(int));
  nei[1] = (int *)malloc(sizeof(int));
  nei[0][0] = 1;
  nei[1][0] = -1;

  b = (float **)malloc(sizeof(float *));
  b[0] = (float *)malloc(sizeof(float));
  b[0][0] = 1.0;

  ca = ca_alloc(k, dim, d, nei_num, nei, r, b);
  ca_print(ca);

  ca->ca[ca->cur][38] = 1;

  for (i=0; i<1000; i++) {
    ca_print_ca1d(ca);
    ca_update(ca, ps, pe);
  }

}
***********************/