float fitness(unsigned int rule)
{
long double min_ent, aux;
const int H = 4.0;
if (hash[rule % HASH_SIZE].key == rule)
{
return hash[rule % HASH_SIZE].value;
}
if (!ca1)
{
ca1 = ca_create(256, rule);
ca2 = ca_create(257, rule);
ca3 = ca_create(255, rule);
}
else
{
ca_rule_set(ca1, rule);
ca_rule_set(ca2, rule);
ca_rule_set(ca3, rule);
}
if (INIT_RANDOM)
{
ca_init_random(ca1);
ca_init_random(ca2);
ca_init_random(ca3);
}
else
{
ca_init_single(ca1);
ca_init_single(ca2);
ca_init_single(ca3);
ca_iterate(ca1, 32);
ca_iterate(ca2, 32);
ca_iterate(ca3, 32);
}
min_ent = ca_entropy_measure(ca1, 1024, H);
aux = ca_entropy_measure(ca2, 1024, H);
if (aux < min_ent)
min_ent = aux;
aux = ca_entropy_measure(ca3, 1024, H);
if (aux < min_ent)
min_ent = aux;
hash[rule % HASH_SIZE].key = rule;
hash[rule % HASH_SIZE].value = min_ent;
return min_ent;
}
int
main(int argc, char *argv[])
{
CA *ca;
char *filename = "out.rnd";
FILE *p;
int nbytes;
unsigned rule;
srand(time(NULL));
nbytes = 1024*1024*10;
if (argc != 2)
{
fprintf(stderr, "usage: %s rule\n", PROGRAM_NAME);
exit(EXIT_FAILURE);
}
else
{
char *strend;
rule = strtoul(argv[1], &strend, 10);
if (*strend)
{
fprintf(stderr, "Invalid rule : '%s'\n", argv[1]);
exit(EXIT_FAILURE);
}
}
if (DEBUG)
{
printf("rule : %u\n", rule);
}
ca = ca_create(512, rule);
if (!(p = fopen(filename, "wb")))
{
perror("fopen");
exit(EXIT_FAILURE);
}
ca_init_random(ca);
while (nbytes >= 0)
{
ca_iterate(ca, 1);
nbytes = ca_to_file(ca, nbytes, p);
}
fclose(p);
ca_destroy(ca);
return EXIT_SUCCESS;
}
int
main(int argc, char *argv[])
{
UINT i;
unsigned int N;
UINT NSTATES;
unsigned int rule;
CA *ca;
char *graph;
if (argc != 3)
{
fprintf(stderr, "usage: %s rule ca-size\n", PROGRAM_NAME);
exit(EXIT_FAILURE);
}
sscanf(argv[1], "%u", &rule);
sscanf(argv[2], "%u", &N);
if (DEBUG)
fprintf(stderr, "rule %u\nN=%u\n", rule, N);
ca = ca_create(N, rule);
NSTATES = 2;
NSTATES <<= (N - 1);
graph = create_graph(NSTATES);
for (i = 0; i < NSTATES; ++i)
flags_unset(graph, i, STATE_ALL_SET_MASK);
for (i = 0; i < NSTATES; ++i)
if (!flags_test(graph, i, STATE_HAS_BEEN_VISITED))
search_cycle(ca, graph, i);
free_graph(graph);
ca_destroy(ca);
return EXIT_SUCCESS;
}
int
ca_opt(struct parse_result *res)
{
struct ca *ca;
size_t len;
char *p;
ca = ca_setup(res->caname, (res->action == CA_CREATE),
res->quiet, res->pass);
if (ca == NULL)
errx(1, "ca_setup failed");
/* assume paths are relative to /etc if not absolute */
if (res->path && (res->path[0] != '.') && (res->path[0] != '/')) {
len = 5 + strlen(res->path) + 1;
if ((p = malloc(len)) == NULL)
err(1, "malloc");
snprintf(p, len, "/etc/%s", res->path);
free(res->path);
res->path = p;
}
switch (res->action) {
case CA_CREATE:
ca_create(ca);
break;
case CA_DELETE:
ca_delete(ca);
break;
case CA_INSTALL:
ca_install(ca, res->path);
break;
case CA_EXPORT:
ca_export(ca, NULL, res->peer, res->pass);
break;
case CA_CERT_CREATE:
case CA_SERVER:
case CA_CLIENT:
case CA_OCSP:
ca_certificate(ca, res->host, res->htype, res->action);
break;
case CA_CERT_DELETE:
ca_delkey(ca, res->host);
break;
case CA_CERT_INSTALL:
ca_cert_install(ca, res->host, res->path);
break;
case CA_CERT_EXPORT:
ca_export(ca, res->host, res->peer, res->pass);
break;
case CA_CERT_REVOKE:
ca_revoke(ca, res->host);
break;
case SHOW_CA_CERTIFICATES:
ca_show_certs(ca, res->host);
break;
case CA_KEY_CREATE:
ca_key_create(ca, res->host);
break;
case CA_KEY_DELETE:
ca_key_delete(ca, res->host);
break;
case CA_KEY_INSTALL:
ca_key_install(ca, res->host, res->path);
break;
case CA_KEY_IMPORT:
ca_key_import(ca, res->host, res->path);
break;
case CA_SUBCA_CREATE:
ca_subca_create(ca, res->subcaname, res->pass, res->quiet);
break;
case CA_SUBCA_REVOKE:
ca_subca_revoke(ca, res->subcaname);
break;
default:
break;
}
return (0);
}
int
main(int argc, char *argv[])
{
CA **ca;
char *filename = "out.rnd";
FILE *p;
long long nbytes;
int nrules;
unsigned int *rules;
int j;
srand(time(NULL));
nbytes = 1024L * 1024L * 1024L * 2L;
nrules = argc - 1;
if (nrules < 1)
{
fprintf(stderr, "usage: %s rule0 rule1 ... ruleN\n", PROGRAM_NAME);
exit(EXIT_FAILURE);
}
else
{
char *strend;
int i;
MALLOC(rules, sizeof(unsigned int) * nrules);
MALLOC(ca, sizeof(CA*) * nrules);
for (i = 0; i < nrules; ++i)
{
rules[i] = strtoul(argv[i + 1], &strend, 10);
if (*strend)
{
fprintf(stderr, "Invalid rule : '%s'\n", argv[i + 1]);
exit(EXIT_FAILURE);
}
if (DEBUG)
fprintf(stderr, "Parsed rule '%s'\n", argv[i + 1]);
ca[i] = ca_create(503, rules[i]);
ca_init_random(ca[i]);
}
}
if (!(p = fopen(filename, "wb")))
{
perror("fopen");
exit(EXIT_FAILURE);
}
while (nbytes >= 0)
{
int i;
for (i = nrules - 1; i >= 1 ; --i)
ca_feedback(ca[i], ca[i - 1], 4);
for (i = 0; i < nrules; ++i)
ca_iterate(ca[i], 1);
nbytes = ca_to_file(ca[nrules - 1], nbytes, p);
}
fclose(p);
for (j = 0; j < nrules; ++j)
ca_destroy(ca[j]);
return EXIT_SUCCESS;
}
int
main(int argc, char *argv[])
{
int i;
int N;
int NSTATES;
unsigned int rule;
CA *ca;
FILE *p;
char filename[256];
if (argc != 3)
{
fprintf(stderr, "usage: %s rule ca-size\n", PROGRAM_NAME);
exit(EXIT_FAILURE);
}
sscanf(argv[1], "%u", &rule);
sscanf(argv[2], "%d", &N);
if (DEBUG)
fprintf(stderr, "rule %u\nN=%d\n", rule, N);
ca = ca_create(N, rule);
sprintf(filename, "graph-rule%u-n%d.dot", rule, N);
filename[255] = 0;
p = fopen(filename, "w");
if (!p)
{
fprintf(stderr, "couldn't open file '%s'\n", filename);
exit(EXIT_FAILURE);
}
fprintf(p, "digraph Graph_rule%u_n%d{\n", rule, N);
NSTATES = (2 << (N - 1));
for (i = 0; i < NSTATES; ++i)
{
int dest;
ca_int_init(ca, i);
ca_iterate(ca, 1);
dest = ca_int_get(ca);
fprintf(p, " %d -> %d;\n", i, dest);
}
fprintf(p, "}\n");
fclose(p);
ca_destroy(ca);
return EXIT_SUCCESS;
}
