/* Modified by Mohan from ckm1.c on 9/13/96, default options */
/******
* The program is used for training a neural network according to the lvq algorithm
* usage:
* a) counterprop
*		or
* b) counterprop -l input_file data_file weight_file
*		or
* c) counterprop -o weight_file data_file output_file
*
* a) -- interactive user querying
* b) -- learning. input_file contains data on structure and training parameters.
*       data_file is training data. weight_file is output weights.
* c) -- output generation. weight_file is generated by learning. data_file is
*       test data. output_file will contain test data with associated class.
******/
#include <stdio.h>
#include <sys/time.h>

#define READFILE 0
#define WRITEFILE 1
#define TASK_NONE 0
#define TASK_LEARNING 1
#define TASK_OUTPUT 2
#define MAXRAND (1<<16)

struct input_s
{	double *input;		/* input vector */
	double *output;		/* either desired or actual output */
};

struct network 
{	/* The structure */
	int io_nodes[2]; 	/* #input & #output dimensions */
	int num_hidden; 	/* # nodes in the hidden layer */
	double **weights[2]; 	/* weights[layer][n_hidden][n_io] */

	/* The training parameters */
	int learning; 	/* if 1 - network training. Else: output gen. */

	double eta1_start, eta1_end;
	double eta2_start, eta2_end;
	double converge1, converge2;
	int num_iter1, num_iter2; 

	/* The inputs */
	int num_inputs;		/* #inputs */
	struct input_s *inputs; /* Storage for input vectors */
};


double pow();
void initrandom();
double get_rand();
void counterprop(), openfile(), deallocate_network();
struct network *readinput(), *readfromkeyboard(), *readfromfile(), *getnetwork(); 
void read_data_inputs();
void initnetwork(), trainnetwork(), writeoutputweights(), writeoutputdata(), printvector();
void phase1(), phase2();
int closest();
void update(), getoutputs();
double get_euclidean();

int expon_eta =1;

/* For learning:
	argv[1] - input structure file
	argv[2] - training data file
	argv[3] - output weights file
   For output generation:
	argv[1] - weights file
        argv[2] - test data file
	argv[3] - output data file
*/
void main(argc, argv)
int argc;
char *argv[];
{
	if( argc == 1 )
		counterprop(TASK_NONE, NULL, NULL, NULL);
	else if( argv[1][0] == '-' && argv[1][1] == 'l')
		counterprop(TASK_LEARNING,  argv[2], argv[3], argv[4]);
	else if( argv[1][0] == '-' && argv[1][1] == 'o')
		counterprop(TASK_OUTPUT, argv[2], argv[3], argv[4]);
	else
	{	printf("Usage\n");
		printf("For interactive mode: \n");
		printf("\tcounterprop\n");
		printf("For learning\n");
		printf("\tcounterprop -l input_file data_file weights_file\n");
		printf("For output generation\n");
		printf("\tcounterprop -o weights_file data_file output_file\n");
	}
}


/* Opens the file filename for reading or writing (depending on type).
   Terminates the program on error.
*/
void openfile( filename, fp, type)
char *filename;
FILE **fp;
int type;
{
	if( filename )
	{   if( type == READFILE )
		*fp = fopen(filename, "rt");
	    else
		*fp = fopen(filename, "wt");

	    if( *fp == NULL )
	    {   printf("Unable to open file %s for %s\n",filename,
				(type == READFILE) ? "reading" : "writing");
		_exit(0);
	    }
	}
}

/* Initialize random generator with number of microseconds since
   January 1, 1970, which is almost a random value in itself.
*/
void initrandom()
{	struct timeval tp;
	struct timezone tzp;
	if( gettimeofday(&tp,&tzp) == -1 )
	{	printf("Could not initialize random number generator\n");
		_exit(0);
	}
	srandom((int)tp.tv_usec);
}


/* Returns a double precision random number between low and high
*/
double get_rand(low, high)
double low, high;  
{	double x = random() % MAXRAND / (double)MAXRAND;
	return( x*(high-low) + low );
}


/* Initialization of the network. Assigns random weights to each node in the
   network. Weights in second layer are completely random. Weights in first layer 
   are assigned so that all weight vectors belong to the hypercube described by the 
   extreme input sample values. In other words, all weights are larger than the 
   minimum and smaller than the maximum input, for each input dimension. 
*/
void initnetwork(p)
struct network *p;
{	int j, k;
	double min, max;

	/* For each input dimension, find the min. and max. value, and assign all 
	   weights from that input node between those two values. 
	*/
	for( k=0; k<p->io_nodes[0]; k++)
	{   min = max = p->inputs[0].input[k];
	    for( j=0; j<p->num_inputs; j++)
		if( p->inputs[j].input[k] > max )
		    max = p->inputs[j].input[k];
		else if( p->inputs[j].input[k] < min )
		    min = p->inputs[j].input[k];

	    /* Otherwise, the get_rand would divide by zero */
	    if( min == max )
		max = min * 1.1;

	    /* Assign random weights to connections from input to hidden layer */
	    for( j=0; j<p->num_hidden; j++)
		p->weights[0][j][k] = get_rand(min, max);
	}

	/* Weights from hidden to output layer are completely random */
	for( j=0; j<p->num_hidden; j++)
	    for( k=0; k<p->io_nodes[1]; k++)
		p->weights[1][j][k] = get_rand(0.0, 1.0);
}


/* Finds the euclidean distance between 2 vectors of doubles (x & y) both of size n
   Because the exact distance is not so important, do not calculate the square
   root. When comparing two distances, it does not matter whether a square root of
   both is taken or not.
*/
double get_euclidean( x, y, n)
double *x, *y;
int n;
{	double dist = 0.0;
	int i;

	for( i=0; i<n; i++)
	    dist += (x[i]-y[i]) * (x[i]-y[i]);

	return(dist);
}


/* Find the hidden node with weight (from 'weights[i]') closest to 'vector'. Number 
   of hidden nodes is 'num_hidden', dimension of vector is 'n'. Return the distance 
   in 'distance'. 
*/
int closest( weights, vector, num_hidden, n, distance)
double **weights;
double *vector;
int num_hidden, n;
double *distance;
{	double dist, mindistance;
	int best, i;

	mindistance = get_euclidean(weights[0], vector, n);
	best = 0;

	for( i=0; i<num_hidden; i++)
	{   dist = get_euclidean(weights[i], vector, n);
	    if( dist < mindistance )
	    {	mindistance = dist;
		best = i;
	    }
	}

	/* Also return the minimum distance, for the convergence crit. */
	*distance = mindistance;
	return(best);
}


/* Update the vector 'weight', according to the difference between it and 'vector'. 
   Use 'eta' as a learning rate. Both vectors have dimension 'n'. 
*/
void update( weight, vector, n, eta) 
double *weight, *vector; 
int n; 
double eta;
{	int i;

	for( i=0; i<n; i++)
	    weight[i] += eta * (vector[i] - weight[i]);
}

/* Repeatedly shrink the learning rate in each iteration. For each iteration, 
   present all training samples, and for each training sample, find the winning 
   hidden-layer node, and update the weights connecting it to the input nodes. 
*/
void phase1(p)
struct network *p;
{	int iter, i, best;
	double eta, fraction;
	double error, distance;
        int print_frequency_phase1 = 100;

	if (p->eta1_start > 0.5) p->eta1_start = 0.5;
	  else if (p->eta1_start < 0.1) p->eta1_start = 0.1;
	eta = p->eta1_start ;
	p->eta1_end =  ((p->eta1_end > p->eta1_start)?  0.01
	  : ((p->eta1_end < 0) ? 0 : p->eta1_end));
	fraction = ((expon_eta)? 
		    (double)pow(((p->eta1_end < 0.001)?0.001:p->eta1_end)
			       /p->eta1_start,  1.0/(p->num_iter1))
		    : (p->eta1_end - p->eta1_start) / p->num_iter1); 

	iter = 0;
	error = p->converge1 + 1;
	while (iter < p->num_iter1 && error > p->converge1)
	{   
	    for( i=0; i<p->num_inputs; i++)
	    {	best = closest( p->weights[0], p->inputs[i].input, p->num_hidden, 
				p->io_nodes[0], &distance);
		update( p->weights[0][best], p->inputs[i].input, 
			p->io_nodes[0], eta);
	    }
	    if (expon_eta) 	    eta *= fraction;
	      else eta += fraction;
	    iter++;
	   if (!(iter %  print_frequency_phase1)){
	    error = 0.0;
	    for( i=0; i<p->num_inputs; i++)
	    {	best = closest( p->weights[0], p->inputs[i].input, p->num_hidden, 
				p->io_nodes[0], &distance);
		error += distance;
	      } /*closing for i*/
	    error /= p->num_inputs;

	    printf("Phase 1: iteration %d, learning rate %lf, error %lf \n",iter, eta, error); 

	   }
	}
}


/* In phase2, in every iteration, for every input, a best matching hidden node is 
   found. That node is then moved a tiny bit (at end learning rate from phase 1), 
   and its outputs are updated according to the difference between the output 
   weights and the desired output. 
*/
void phase2(p)
struct network *p;
{	int iter, i, best;
	double eta, fraction, numerator;
	double error, distance, new_err;
	int print_frequency_phase2 = 100;


	if (p->eta2_start > 0.5) p->eta2_start = 0.5;
	if (p->eta2_start < 0.1) p->eta2_start = 0.1;
	eta = p->eta2_start ;
	if (p->eta2_end < 0.001) p->eta2_end = 0.001;
	if (p->eta2_end > p->eta2_start) p->eta2_end = 0.01;
	fraction = ((expon_eta)? 
		    (double)pow((p->eta2_end /p->eta2_start),  1.0/(p->num_iter2))
		    : (p->eta2_end - p->eta2_start) / p->num_iter2); 


/*        printf("Phase 2: initial learning rate %lf, fraction %lf \n", eta, fraction); */

	iter = 0;
	error = p->converge2 + 1;

	while (iter < p->num_iter2 && error > p->converge2)
	  { 
	    for( i=0; i<p->num_inputs; i++)
	    {	best = closest( p->weights[0], p->inputs[i].input, p->num_hidden, 
	       		p->io_nodes[0], &distance);
		update( p->weights[0][best], p->inputs[i].input, 
			p->io_nodes[0], p->eta1_end);
		update( p->weights[1][best], p->inputs[i].output, 
			p->io_nodes[1], eta);
	      } /*closing for i*/

	    iter++;
	    if (expon_eta) 	    eta *= fraction;
	      else eta += fraction;
	   if (!(iter %  print_frequency_phase2)){
	    error = 0.0;
	    for( i=0; i<p->num_inputs; i++)
	    {	best = closest( p->weights[0], p->inputs[i].input, p->num_hidden, 
				p->io_nodes[0], &distance);
		error +=  get_euclidean( p->weights[1][best], p->inputs[i].output, 
					p->io_nodes[1]); 
	      } /*closing for i*/
	    error /= p->num_inputs;
	    printf("Phase 2: iteration %d, learning rate %lf, error %lf \n",iter, eta, error); 
	  } /*closing if */
	  }
      }


/* The training of the counterpropagation network consists of two phases */
void trainnetwork(p)
struct network *p;
{
	phase1(p);
	phase2(p);
}


/* For each input sample, find the winner node, and assign the output weights of 
   the node to the output of the sample
*/
void getoutputs(p)
struct network *p;
{	int sample, i, best;
	double distance;

	for( sample=0; sample < p->num_inputs; sample++)
	{   best = closest( p->weights[0], p->inputs[sample].input, p->num_hidden, 
				p->io_nodes[0], &distance);
	    for( i=0; i<p->io_nodes[1]; i++ )
		p->inputs[sample].output[i] = p->weights[1][best][i];
	}
}


/* Allocates the structure network, initializes all pointers to NULL, and all 
   integers to 0
*/
struct network *getnetwork()
{	struct network *p;

	p = (struct network *)malloc(sizeof(struct network));
	if( p == NULL )
		return(NULL);

	p->io_nodes[0] = p->io_nodes[1] = p->num_hidden = p->learning = 0;
	p->num_iter1 = p->num_iter2 = p->num_inputs = 1000;
	p->eta1_start =  p->eta2_start = 0.3;
	p->eta1_end = p->eta2_end = 0.01;
	p->converge1 = p->converge2 = 0.0;
	p->weights[0] = p->weights[1] = NULL;
	p->inputs = NULL;
	return(p);
}

/* Deallocates all already allocated arrays and structures in the network
*/
void deallocate_network(p)
struct network *p;
{	int i, j;

	for( i=0; i<2; i++)
	    if( p->weights[i] != NULL )
	    {	for( j=0; j<p->io_nodes[i]; j++)
		    if( p->weights[i][j] )
			free(p->weights[i][j]);

		free(p->weights[i]);
	    }

	if( p->inputs )
	{   for( i=0; i<p->num_inputs; i++)
	    {	if( p->inputs[i].input )
		    free(p->inputs[i].input);
		if( p->inputs[i].output )
		    free(p->inputs[i].output);
	    }
	    free(p->inputs);
	}

	free(p);
}


/* Read the inputs from the data file. For learning problems, there is an output 
   associated with each input sample
*/
void read_data_inputs(p, data)
struct network *p;
FILE *data;
{	int i,j;

	for( i=0; i<p->num_inputs; i++)
	{   for( j=0; j<p->io_nodes[0]; j++)
		fscanf(data, "%lf ", p->inputs[i].input + j);
	    if( p->learning )
		for( j=0; j<p->io_nodes[1]; j++)
		    fscanf(data, "%lf ", p->inputs[i].output + j);
	}
}


/* If in == NULL, the user will be interactively queried for all the values. One of 
   the values: the weights file, will give pout its value.
*/
struct network *readinput(task, in, data, pout)
int task;
FILE *in, *data;
FILE **pout;
{	struct network *p;

	if (task == TASK_NONE)
		p = readfromkeyboard(pout);
	else	p = readfromfile(task, in, data);

	return(p); 
}


/* Prompts user for parameters of the machine, as well as names of data and output 
   files. Allocates the structure network and places all values of interest in it.
   Returns the pointer towards the structure, and opens the weights file for output
   and places it's handler in pout.
*/
struct network *readfromkeyboard(pout)
FILE **pout;
{	struct network *p;
	char buf[80];
	char ch;
	int ok, i, j, k, user_specified=0;
	FILE *in, *data;

	/* Allocate the structure network */
	if( (p = getnetwork()) == NULL)
		return(NULL);

	ok = 0;
	while (!ok)
	{	printf("** Select L(earning) or O(utput generation) **\n");
		scanf("%s", buf);
		ch = buf[0];
		if( ch == 'l' || ch == 'L' )
		{	p->learning = 1;
			ok = 1;
		}
		else if( ch == 'o' || ch == 'O' )
		{	p->learning = 0;
			ok = 1;
		}
		else printf("Incorrect option entered. Please re-enter\n");
	}
	if( p->learning )
	{   printf("How many dimensions does the input pattern have?: ");
	    scanf("%d", p->io_nodes + 0);
	    printf("How many dimensions does the output pattern have?: ");
	    scanf("%d", p->io_nodes + 1);
	    printf("How many hidden nodes will the network use?: ");
	    scanf("%d", &p->num_hidden);
	    printf("Enter the name of the training data file: ");
	    scanf("%s", buf);
	    openfile(buf, &data, READFILE);
	    printf("Enter the name of the output weight file: ");
	    scanf("%s", buf);
	    openfile(buf, pout, WRITEFILE);
	}
	else
	{   printf("Enter the name of the weights file: ");
	    scanf("%s", buf);
	    openfile(buf, &in, READFILE);
	    printf("Enter the name of the test data file: ");
	    scanf("%s", buf);
	    openfile(buf, &data, READFILE);
	    printf("Enter the name of the output file: ");
	    scanf("%s", buf);
	    openfile(buf, pout, WRITEFILE);

	    /* Get the # of input and output dimensions */
	    fscanf(in, "%d %d\n", p->io_nodes + 0, p->io_nodes + 1);

	    /* Get the # of nodes in the hidden layer */
	    fscanf(in, "%d\n", &p->num_hidden);
	}

	/* Allocate the weight matrix */
	for( i=0; i<2; i++ )
	{   p->weights[i] = (double **)malloc(p->num_hidden * sizeof(double *));
	    if( p->weights[i] == NULL )
	    {	deallocate_network(p);
		return(NULL);
	    }
	}
	for( i=0; i<p->num_hidden; i++)
		p->weights[0][i] = p->weights[1][i] = NULL;
	for( i=0; i<2; i++)
	    for( j=0; j<p->num_hidden; j++)
	    {	p->weights[i][j] = (double *)malloc(p->io_nodes[i] * sizeof(double)); 
		if( p->weights[i][j] == NULL )
		{   deallocate_network(p);
		    return(NULL);
		}
	    }


	if( p->learning )
	{
	    /* Get number of inputs */
	    printf("Total number of input samples?: ");
	    scanf("%d", &p->num_inputs);
	    printf("Max number of iterations in phase 1(enter a positive integer)?: ");
	    scanf("%d", &p->num_iter1);
	    printf("Max number of iterations in phase 2(enter a positive integer)?: ");
	    scanf("%d", &p->num_iter2);

	    printf("Enter 0 to use default values for learning rate parameters, enter 1 for user-specified values \n ");
	    printf(" (default learning rates decay exponentially from 0.3 to 0.01): ");
	    scanf("%lf", &user_specified);

	    if (user_specified){
	    /* Get the training parameters for phase 1*/
	    printf("Enter 1 if you prefer exponential decay of learning rates, else 0 for linear decay: ");
	    scanf("%lf", &expon_eta);
	    printf("Learning rate eta at start of phase 1(fraction between 0 and 1): ");
	    scanf("%lf", &p->eta1_start);
	    printf("Learning rate eta at end of phase 1(fraction between 0 and 1): ");
	    scanf("%lf", &p->eta1_end);
	    printf("Convergence criterion in phase 1(fraction between 0 and 1): ");
	    scanf("%lf", &p->converge1);

	    /* Get the training parameters for phase 2*/
	    printf("Learning rate eta at start of phase 2(fraction between 0 and 1): ");
	    scanf("%lf", &p->eta2_start);
	    printf("Learning rate eta at end of phase 2(fraction between 0 and 1): ");
	    scanf("%lf", &p->eta2_end);
	    printf("Convergence criterion in phase 2(fraction between 0 and 1): ");
	    scanf("%lf", &p->converge2);
	  }

	}
	else
	{
	    /* Read the initial values of the weights */
	    for( j=0; j<p->num_hidden; j++)
		for( i=0; i<2; i++)
		{   for( k=0; k<p->io_nodes[i]; k++)
			fscanf(in, "%lf ", p->weights[i][j] + k);
		    fscanf(in, "\n");
		}
	    /* Read the number of inputs from the data file */
	    fscanf(data, "%d\n", &p->num_inputs);
	}

	/* Allocate the input storage */
	p->inputs = (struct input_s *)malloc(p->num_inputs*sizeof(struct input_s));
	if( p->inputs == NULL )
	{	deallocate_network(p);
		return(NULL);
	}
	for( i=0; i<p->num_inputs; i++)
	{   p->inputs[i].input = NULL;
	    p->inputs[i].output = NULL;
	}
	for( i=0; i<p->num_inputs; i++ )
	{   p->inputs[i].input = (double *)malloc(p->io_nodes[0] * sizeof(double));
	    p->inputs[i].output = (double *)malloc(p->io_nodes[1] * sizeof(double));
	    if( p->inputs[i].input == NULL || p->inputs[i].output == NULL )
	    {	deallocate_network(p);
		return(NULL);
	    }
	}

	read_data_inputs(p, data);

	return(p);

/* !!! */
}


/* Reads the input files and initializes the structure networs. Places all values
   of interest in the structure. If one of the arrays in the structure cannot be
   allocated, it deallocates the whole structure and returns NULL
*/
struct network *readfromfile(task, in, data)
int task;
FILE *in, *data;
{	struct network *p = NULL;
	int i, j, k;

	/* Allocate the structure network */
	if( (p = getnetwork()) == NULL)
		return( NULL );

	if( task == TASK_LEARNING )
	    p->learning = 1;
	else
	    p->learning = 0;

	/* Get the # of input and output dimensions */
	fscanf(in, "%d %d\n", p->io_nodes + 0, p->io_nodes + 1);

	/* Get the # of nodes in the hidden layer */
	fscanf(in, "%d\n", &p->num_hidden);

	/* Allocate the weight matrix */
	for( i=0; i<2; i++ )
	{   p->weights[i] = (double **)malloc(p->num_hidden * sizeof(double *));
	    if( p->weights[i] == NULL )
	    {	deallocate_network(p);
		return(NULL);
	    }
	}
	for( i=0; i<p->num_hidden; i++)
		p->weights[0][i] = p->weights[1][i] = NULL;
	for( i=0; i<2; i++)
	    for( j=0; j<p->num_hidden; j++)
	    {	p->weights[i][j] = (double *)malloc(p->io_nodes[i] * sizeof(double)); 
		if( p->weights[i][j] == NULL )
		{   deallocate_network(p);
		    return(NULL);
		}
	    }

	if( p->learning )
	{
	    /* Get the training parameters */
	    fscanf(in, "%lf %lf %lf\n", &p->eta1_start, &p->eta1_end, &p->converge1); 
	    fscanf(in, "%lf %lf %lf\n", &p->eta2_start, &p->eta2_end, &p->converge2); 
	    fscanf(in, "%d %d\n", &p->num_iter1, &p->num_iter2);

	    /* Get number of inputs */
	    fscanf(in, "%d\n", &p->num_inputs);
	}
	else
	{
	    /* Read the initial values of the weights */
	    for( j=0; j<p->num_hidden; j++)
		for( i=0; i<2; i++)
		{   for( k=0; k<p->io_nodes[i]; k++)
			fscanf(in, "%lf ", p->weights[i][j] + k);
		    fscanf(in, "\n");
		}
	    /* Read the number of inputs from the data file */
	    fscanf(data, "%d\n", &p->num_inputs);
	}

	/* Allocate the input storage */
	p->inputs = (struct input_s *)malloc(p->num_inputs*sizeof(struct input_s));
	if( p->inputs == NULL )
	{	deallocate_network(p);
		return(NULL);
	}
	for( i=0; i<p->num_inputs; i++)
	{   p->inputs[i].input = NULL;
	    p->inputs[i].output = NULL;
	}
	for( i=0; i<p->num_inputs; i++ )
	{   p->inputs[i].input = (double *)malloc(p->io_nodes[0] * sizeof(double));
	    p->inputs[i].output = (double *)malloc(p->io_nodes[1] * sizeof(double));
	    if( p->inputs[i].input == NULL || p->inputs[i].output == NULL )
	    {	deallocate_network(p);
		return(NULL);
	    }
	}

	read_data_inputs(p, data);

	return(p);
}


/* Write the weights, with the structural parameters of the network, to the file 
   out 
*/
void writeoutputweights(p, out)
struct network *p;
FILE *out;
{	int i,j,k;

	/* Output the # of input and output dimensions */
	fprintf(out, "%d %d\n", p->io_nodes[0], p->io_nodes[1]);

	/* Output the # of nodes in the hidden layer */
	fprintf(out, "%d\n", p->num_hidden);

	/* For each hidden node, first print the weights from the input layer, then 
	   the weights to the output layer. 
	*/
	for( j=0; j<p->num_hidden; j++)
	    for( i=0; i<2; i++)
	    {	for( k=0; k<p->io_nodes[i]; k++)
		    fprintf(out, "%lf ", p->weights[i][j][k]);
		fprintf(out, "\n");
	    }
}


/* Write the data, with the derived outputs, to the file out */
void writeoutputdata(p, out)
struct network *p;
FILE *out;
{	int i,j;

	/* For each input sample, print the sample, followed by the output */
	for( i=0; i<p->num_inputs; i++)
	{   for( j=0; j<p->io_nodes[0]; j++)
		fprintf(out, "%lf ", p->inputs[i].input[j]);
	    fprintf(out, "   ");
	    for( j=0; j<p->io_nodes[1]; j++)
		fprintf(out, "%l.3f ", p->inputs[i].output[j]);
	    fprintf(out, "\n");
	}
}

/* print to screen the first argument, 
   a vector of size specified by second argument */
void printvector(vec, n)
 double *vec; int n;
{	int i;
	for( i=0; i<n; i++)     printf("%1.4f, ", vec[i]);
        printf("; "); 
}

/* The counterprop program. Opens all neccessary files, reads inputs, trains the 
   network and writes the derived weights. 
*/
void counterprop(task, inputfile, datafile, outfile)
int task;
char *inputfile, *datafile, *outfile;
{	FILE *in, *data, *out;
	struct network *p;
	long t1, t2;

	t1 = clock();
	in = out = data = NULL;   
	openfile( inputfile, &in, READFILE);
	openfile( datafile, &data, READFILE);
	openfile( outfile, &out, WRITEFILE);

	if( (p = readinput(task, in, data, &out)) == NULL)
	{	printf("Not enough memory\n");
		_exit(0);
	}
	initrandom();
	if (p->learning)
	{	initnetwork(p);
		trainnetwork(p);
		writeoutputweights(p, out);
	}
	else
	{	getoutputs(p);
		writeoutputdata(p, out);
	}
	deallocate_network(p);

	t2 = clock();
	printf("Elapsed time %ld milliseconds\n",(t2-t1)/1000);
}