//
// Backpropogation Neural Network for predicting a gesture time series
// 
 
#include <stdlib.h> 
#include <stdio.h> 
#include <string.h> 
#include <math.h> 
#include <ctype.h> 
 
#include "sensordata.h" 
#include "load.h" 
#include "backprop.h"
 
const float thresh = 1; 
const char *TRAIN1 = "c:\\myfiles\\programs\\cs346\\glearn\\2.1"; 
const char *TRAIN2 = "c:\\myfiles\\programs\\cs346\\glearn\\2.2"; 
const char *TEST = "c:\\myfiles\\programs\\cs346\\glearn\\2.0"; 
char *S_100 = "c:\\myfiles\\programs\\cs346\\glearn\\snn_100"; 
char *G_100 = "c:\\myfiles\\programs\\cs346\\glearn\\gnn_100"; 
char *R_100 = "c:\\myfiles\\programs\\cs346\\glearn\\rnn_100"; 
char *s_1_5000 = "c:\\myfiles\\programs\\cs346\\glearn\\s_1_5000"; 
char *s_12_5000 = "c:\\myfiles\\programs\\cs346\\glearn\\s_12_5000"; 
char *s_13_5000 = "c:\\myfiles\\programs\\cs346\\glearn\\s_13_5000"; 
char *s_123_5000 = "c:\\myfiles\\programs\\cs346\\glearn\\s_123_5000"; 
const char *OUTPUT = "c:\\myfiles\\programs\\cs346\\glearn\\s5_results.txt"; 

void trainseries1 (BPNN*,struct SensorData*,int,double,double);
void testseries1 (BPNN*,struct SensorData*,int,double*);
void trainseries10 (BPNN*,struct SensorData*,int,double,double);
void testseries10 (BPNN*,struct SensorData*,int,double*);
void trainrec (BPNN*,struct SensorData*,int,double,double);
void testrec (BPNN*,struct SensorData*,int,double*);


 
void main(int argc,char ** argv) { 
 
	int size1=0,size2=0,size3=0; 
	SensorData series1[1300],series2[1300],series3[1300]; 
	BPNN *SNN, *GNN, *RNN;
	int seed;
	double error[30];
	double learn_rate = .05; //.15
	double momentum = .05; //.2

	seed = 50798;   /* default */


//open the ouput file
FILE * out = fopen(OUTPUT, "w+");
if (out == NULL) { 
    fprintf(stderr,"OUTPUT: Cannot open '%s'\n", OUTPUT); 
    exit (0); 
    } 
 
SNN = bpnn_read(s_1_5000);  

//initialize the neural network 
bpnn_initialize(seed);
SNN = bpnn_create(25,10,24);
//GNN = bpnn_create(250,10,24);
//RNN = bpnn_create(25,10,24,25);


//load the training sets 
size1 = loaddata(TRAIN1,series1); 
size2 = loaddata(TRAIN2,series2); 
size3 = loaddata(TEST,series2); 
fprintf(out,"samples1=%d\n", size1); 
fprintf(out,"samples2=%d\n", size2);
fprintf(out,"samples3=%d\n", size3);
/*
//train the single input network
fprintf(out,"Training single input, non-recurrent network . . .\n");
fprintf(out,"series 1, 5000 epochs\n");
for (int k=0; k<5000; k++) {//number of times to train
	printf("s_1_5000, k=%d, \n",k);
	trainseries1(SNN, series1, size1, learn_rate, momentum);
//	trainseries1(SNN, series2, size2, learn_rate, momentum);
//	trainseries1(SNN, series3, size3, learn_rate, momentum);
}

//test the single input network
fprintf(out,"Testing single input, nonrecurrent network . . .\n");
fprintf(out,"series 1:");
testseries1(SNN, series1, size1, error);
fprintf(out,"series 2:");
testseries1(SNN, series2, size2, error);
fprintf(out,"series 3:");
testseries1(SNN, series3, size3, error);

bpnn_save(SNN, s_1_5000);
bpnn_free(SNN);
SNN = bpnn_create(25,10,24);

//train the single input network
fprintf(out,"Training single input, non-recurrent network . . .\n");
fprintf(out,"series 1&2, 5000 epochs\n");
for (int k=0; k<5000; k++) {//number of times to train
	printf("s_12_5000, k=%d, \n",k);
	trainseries1(SNN, series1, size1, learn_rate, momentum);
	trainseries1(SNN, series2, size2, learn_rate, momentum);
//	trainseries1(SNN, series3, size3, learn_rate, momentum);
}

//test the single input network
fprintf(out,"Testing single input, nonrecurrent network . . .\n");
fprintf(out,"series 1:");
testseries1(SNN, series1, size1, error);
fprintf(out,"series 2:");
testseries1(SNN, series2, size2, error);
fprintf(out,"series 3:");
testseries1(SNN, series3, size3, error);

bpnn_save(SNN, s_12_5000);
bpnn_free(SNN);
SNN = bpnn_create(25,10,24);


//train the single input network
fprintf(out,"Training single input, non-recurrent network . . .\n");
fprintf(out,"series 1&3, 5000 epochs\n");
for (int k=0; k<5000; k++) {//number of times to train
	printf("s_13_5000, k=%d, \n",k);
	trainseries1(SNN, series1, size1, learn_rate, momentum);
//	trainseries1(SNN, series2, size2, learn_rate, momentum);
	trainseries1(SNN, series3, size3, learn_rate, momentum);
}

//test the single input network
fprintf(out,"Testing single input, nonrecurrent network . . .\n");
fprintf(out,"series 1:");
testseries1(SNN, series1, size1, error);
fprintf(out,"series 2:");
testseries1(SNN, series2, size2, error);
fprintf(out,"series 3:");
testseries1(SNN, series3, size3, error);

bpnn_save(SNN, s_13_5000);
bpnn_free(SNN);
SNN = bpnn_create(25,10,24);

//train the single input network
fprintf(out,"Training single input, non-recurrent network . . .\n");
fprintf(out,"series 1&2&3, 5000 epochs\n");
for (int k=0; k<5000; k++) {//number of times to train
	printf("s_123_5000, k=%d, \n",k);
	trainseries1(SNN, series1, size1, learn_rate, momentum);
	trainseries1(SNN, series2, size2, learn_rate, momentum);
	trainseries1(SNN, series3, size3, learn_rate, momentum);
}
*/
//test the single input network
fprintf(out,"Testing single input, nonrecurrent network . . .\n");
fprintf(out,"series 1:");
testseries1(SNN, series1, size1, error);
fprintf(out,"series 2:");
testseries1(SNN, series2, size2, error);
fprintf(out,"series 3:");
testseries1(SNN, series3, size3, error);

//bpnn_save(SNN, s_123_5000);
bpnn_free(SNN);



}//main





//train a net on a series by feeding it 1 consecutive point in the time series
//and training with the next point as the target

void trainseries1 (BPNN* NN,struct SensorData *series,int size,double learn_rate,double momentum) {

	int i,j,k,m,n;
	double errout=0,errhid=0;

	for (i=0;i < size-1;i++) { //stream through the data
		NN->input_units[1] = series[i].m_wandPosition[0];
		NN->input_units[2] = series[i].m_wandPosition[1];
		NN->input_units[3] = series[i].m_wandPosition[2];
		NN->input_units[4] = series[i].m_wandUp[0];
		NN->input_units[5] = series[i].m_wandUp[1];
		NN->input_units[6] = series[i].m_wandUp[2];
		NN->input_units[7] = series[i].m_wandLeft[0];
		NN->input_units[8] = series[i].m_wandLeft[1];
		NN->input_units[9] = series[i].m_wandLeft[2];
		NN->input_units[10] = series[i].m_wandBack[0];
		NN->input_units[11] = series[i].m_wandBack[1];
		NN->input_units[12] = series[i].m_wandBack[2]; 
		NN->input_units[13] = series[i].m_headPosition[0];
		NN->input_units[14] = series[i].m_headPosition[1];
		NN->input_units[15] = series[i].m_headPosition[2];
		NN->input_units[16] = series[i].m_headUp[0];
		NN->input_units[17] = series[i].m_headUp[1];
		NN->input_units[18] = series[i].m_headUp[2]; 
		NN->input_units[19] = series[i].m_headLeft[0];
		NN->input_units[20] = series[i].m_headLeft[1];
		NN->input_units[21] = series[i].m_headLeft[2]; 
		NN->input_units[22] = series[i].m_headBack[0];
		NN->input_units[23] = series[i].m_headBack[1];
		NN->input_units[24] = series[i].m_headBack[2]; 
		NN->input_units[25] = series[i].m_fTime;

		//load the next vector as the target
		NN->target[1] = series[i+1].m_wandPosition[0];
		NN->target[2] = series[i+1].m_wandPosition[1];
		NN->target[3] = series[i+1].m_wandPosition[2];
		NN->target[4] = series[i+1].m_wandUp[0];
		NN->target[5] = series[i+1].m_wandUp[1];
		NN->target[6] = series[i+1].m_wandUp[2];
		NN->target[7] = series[i+1].m_wandLeft[0];
		NN->target[8] = series[i+1].m_wandLeft[1];
		NN->target[9] = series[i+1].m_wandLeft[2];
		NN->target[10] = series[i+1].m_wandBack[0];
		NN->target[11] = series[i+1].m_wandBack[1];
		NN->target[12] = series[i+1].m_wandBack[2]; 
		NN->target[13] = series[i+1].m_headPosition[0];
		NN->target[14] = series[i+1].m_headPosition[1];
		NN->target[15] = series[i+1].m_headPosition[2];
		NN->target[16] = series[i+1].m_headUp[0];
		NN->target[17] = series[i+1].m_headUp[1];
		NN->target[18] = series[i+1].m_headUp[2]; 
		NN->target[19] = series[i+1].m_headLeft[0];
		NN->target[20] = series[i+1].m_headLeft[1];
		NN->target[21] = series[i+1].m_headLeft[2]; 
		NN->target[22] = series[i+1].m_headBack[0];
		NN->target[23] = series[i+1].m_headBack[1];
		NN->target[24] = series[i+1].m_headBack[2]; 
		
		bpnn_train(NN, learn_rate, momentum, &errout, &errhid);	
	}

	printf("Error output: %f, hidden: %f \n",errout, errhid);

} //trainseries1



void testseries1 (BPNN* NN,struct SensorData *series,int size,double *total_error) {

	int i,j;
	double exerror[30];

	for (int k=0;k<25;k++) { //clear the array
		total_error[k] = 0;
	}

	for (i=0;i < size-1;i++) { //stream through the data

		for (int n=1;n<25;n++) { //clear the output units
			NN->output_units[n] = 0;
		}

		NN->input_units[1] = series[i].m_wandPosition[0];
		NN->input_units[2] = series[i].m_wandPosition[1];
		NN->input_units[3] = series[i].m_wandPosition[2];
		NN->input_units[4] = series[i].m_wandUp[0];
		NN->input_units[5] = series[i].m_wandUp[1];
		NN->input_units[6] = series[i].m_wandUp[2];
		NN->input_units[7] = series[i].m_wandLeft[0];
		NN->input_units[8] = series[i].m_wandLeft[1];
		NN->input_units[9] = series[i].m_wandLeft[2];
		NN->input_units[10] = series[i].m_wandBack[0];
		NN->input_units[11] = series[i].m_wandBack[1];
		NN->input_units[12] = series[i].m_wandBack[2]; 
		NN->input_units[13] = series[i].m_headPosition[0];
		NN->input_units[14] = series[i].m_headPosition[1];
		NN->input_units[15] = series[i].m_headPosition[2];
		NN->input_units[16] = series[i].m_headUp[0];
		NN->input_units[17] = series[i].m_headUp[1];
		NN->input_units[18] = series[i].m_headUp[2]; 
		NN->input_units[19] = series[i].m_headLeft[0];
		NN->input_units[20] = series[i].m_headLeft[1];
		NN->input_units[21] = series[i].m_headLeft[2]; 
		NN->input_units[22] = series[i].m_headBack[0];
		NN->input_units[23] = series[i].m_headBack[1];
		NN->input_units[24] = series[i].m_headBack[2]; 
		NN->input_units[25] = series[i].m_fTime;

		
		bpnn_feedforward(NN);

		//Error is the target
		exerror[1] = abs_d(NN->output_units[1] - series[i+1].m_wandPosition[0]);
		exerror[2] = abs_d(NN->output_units[2] - series[i+1].m_wandPosition[1]);
		exerror[3] = abs_d(NN->output_units[3] - series[i+1].m_wandPosition[2]);
		exerror[4] = abs_d(NN->output_units[4] - series[i+1].m_wandUp[0]);
		exerror[5] = abs_d(NN->output_units[5] - series[i+1].m_wandUp[1]);
		exerror[6] = abs_d(NN->output_units[6] - series[i+1].m_wandUp[2]);
		exerror[7] = abs_d(NN->output_units[7] - series[i+1].m_wandLeft[0]);
		exerror[8] = abs_d(NN->output_units[8] - series[i+1].m_wandLeft[1]);
		exerror[9] = abs_d(NN->output_units[9] - series[i+1].m_wandLeft[2]);
		exerror[10] = abs_d(NN->output_units[10] - series[i+1].m_wandBack[0]);
		exerror[11] = abs_d(NN->output_units[11] - series[i+1].m_wandBack[1]);
		exerror[12] = abs_d(NN->output_units[12] - series[i+1].m_wandBack[2]); 
		exerror[13] = abs_d(NN->output_units[13] - series[i+1].m_headPosition[0]);
		exerror[14] = abs_d(NN->output_units[14] - series[i+1].m_headPosition[1]);
		exerror[15] = abs_d(NN->output_units[15] - series[i+1].m_headPosition[2]);
		exerror[16] = abs_d(NN->output_units[16] - series[i+1].m_headUp[0]);
		exerror[17] = abs_d(NN->output_units[17] - series[i+1].m_headUp[1]);
		exerror[18] = abs_d(NN->output_units[18] - series[i+1].m_headUp[2]); 
		exerror[19] = abs_d(NN->output_units[19] - series[i+1].m_headLeft[0]);
		exerror[20] = abs_d(NN->output_units[20] - series[i+1].m_headLeft[1]);
		exerror[21] = abs_d(NN->output_units[21] - series[i+1].m_headLeft[2]); 
		exerror[22] = abs_d(NN->output_units[22] - series[i+1].m_headBack[0]);
		exerror[23] = abs_d(NN->output_units[23] - series[i+1].m_headBack[1]);
		exerror[24] = abs_d(NN->output_units[24] - series[i+1].m_headBack[2]); 

		for (int l=1;l<25;l++) {
			exerror[0] = exerror[0] + exerror[l];
			total_error[l] = total_error[l] + exerror[l];
		}
		
	}

	for (int m=1;m<25;m++) {
		total_error[0] = total_error[0] + total_error[m];
	}
	printf("alltotal/size: %f/%d = %f\n",total_error[0],size,total_error[0]/size);
	
} //testseries1




//train a net on a series by feeding it 10 consecutive points in the time series
//and training with the eleventh point as the target

void trainseries10 (BPNN* NN,struct SensorData *series,int size,double learn_rate,double momentum) {

	int i,j,k,m,n;
	double errout,errhid;


	for (i=0;i< size - 11;i++) { //stream through the data

		for (j=0;j<10;j++) { //load 10 input vectors  
			NN->input_units[(j*25+1)] = series[i+j].m_wandPosition[0];
			NN->input_units[(j*25+2)] = series[i+j].m_wandPosition[1];
			NN->input_units[(j*25+3)] = series[i+j].m_wandPosition[2];
			NN->input_units[(j*25+4)] = series[i+j].m_wandUp[0];
			NN->input_units[(j*25+5)] = series[i+j].m_wandUp[1];
			NN->input_units[(j*25+6)] = series[i+j].m_wandUp[2];
			NN->input_units[(j*25+7)] = series[i+j].m_wandLeft[0];
			NN->input_units[(j*25+8)] = series[i+j].m_wandLeft[1];
			NN->input_units[(j*25+9)] = series[i+j].m_wandLeft[2];
			NN->input_units[(j*25+10)] = series[i+j].m_wandBack[0];
			NN->input_units[(j*25+11)] = series[i+j].m_wandBack[1];
			NN->input_units[(j*25+12)] = series[i+j].m_wandBack[2]; 
			NN->input_units[(j*25+13)] = series[i+j].m_headPosition[0];
			NN->input_units[(j*25+14)] = series[i+j].m_headPosition[1];
			NN->input_units[(j*25+15)] = series[i+j].m_headPosition[2];
			NN->input_units[(j*25+16)] = series[i+j].m_headUp[0];
			NN->input_units[(j*25+17)] = series[i+j].m_headUp[1];
			NN->input_units[(j*25+18)] = series[i+j].m_headUp[2]; 
			NN->input_units[(j*25+19)] = series[i+j].m_headLeft[0];
			NN->input_units[(j*25+20)] = series[i+j].m_headLeft[1];
			NN->input_units[(j*25+21)] = series[i+j].m_headLeft[2]; 
			NN->input_units[(j*25+22)] = series[i+j].m_headBack[0];
			NN->input_units[(j*25+23)] = series[i+j].m_headBack[1];
			NN->input_units[(j*25+24)] = series[i+j].m_headBack[2]; 
			NN->input_units[(j*25+25)] = series[i+j].m_fTime;
		}
		j++;
		//load the 11th vector as the target
		NN->target[1] = series[i+j].m_wandPosition[0];
		NN->target[2] = series[i+j].m_wandPosition[1];
		NN->target[3] = series[i+j].m_wandPosition[2];
		NN->target[4] = series[i+j].m_wandUp[0];
		NN->target[5] = series[i+j].m_wandUp[1];
		NN->target[6] = series[i+j].m_wandUp[2];
		NN->target[7] = series[i+j].m_wandLeft[0];
		NN->target[8] = series[i+j].m_wandLeft[1];
		NN->target[9] = series[i+j].m_wandLeft[2];
		NN->target[10] = series[i+j].m_wandBack[0];
		NN->target[11] = series[i+j].m_wandBack[1];
		NN->target[12] = series[i+j].m_wandBack[2]; 
		NN->target[13] = series[i+j].m_headPosition[0];
		NN->target[14] = series[i+j].m_headPosition[1];
		NN->target[15] = series[i+j].m_headPosition[2];
		NN->target[16] = series[i+j].m_headUp[0];
		NN->target[17] = series[i+j].m_headUp[1];
		NN->target[18] = series[i+j].m_headUp[2]; 
		NN->target[19] = series[i+j].m_headLeft[0];
		NN->target[20] = series[i+j].m_headLeft[1];
		NN->target[21] = series[i+j].m_headLeft[2]; 
		NN->target[22] = series[i+j].m_headBack[0];
		NN->target[23] = series[i+j].m_headBack[1];
		NN->target[24] = series[i+j].m_headBack[2]; 
		
		bpnn_train(NN, learn_rate, momentum, &errout, &errhid);	
	}

	printf("Error output: %f, hidden: %f \n",errout, errhid);
	
} //trainseries10   



void testseries10 (BPNN* NN,struct SensorData *series,int size,double *total_error) {

	int i,j;
	double exerror[30];

	for (int k=0;k<25;k++) { //clear the array
		total_error[k] = 0;
	}

	for (i=0;i< size - 11;i++) { //stream through the data

		for (int n=1;n<25;n++) { //clear the output units
			NN->output_units[n] = 0;
		}

		for (j=0;j<10;j++) { //load 10 input vectors  
			NN->input_units[(j*25+1)] = series[i+j].m_wandPosition[0];
			NN->input_units[(j*25+2)] = series[i+j].m_wandPosition[1];
			NN->input_units[(j*25+3)] = series[i+j].m_wandPosition[2];
			NN->input_units[(j*25+4)] = series[i+j].m_wandUp[0];
			NN->input_units[(j*25+5)] = series[i+j].m_wandUp[1];
			NN->input_units[(j*25+6)] = series[i+j].m_wandUp[2];
			NN->input_units[(j*25+7)] = series[i+j].m_wandLeft[0];
			NN->input_units[(j*25+8)] = series[i+j].m_wandLeft[1];
			NN->input_units[(j*25+9)] = series[i+j].m_wandLeft[2];
			NN->input_units[(j*25+10)] = series[i+j].m_wandBack[0];
			NN->input_units[(j*25+11)] = series[i+j].m_wandBack[1];
			NN->input_units[(j*25+12)] = series[i+j].m_wandBack[2]; 
			NN->input_units[(j*25+13)] = series[i+j].m_headPosition[0];
			NN->input_units[(j*25+14)] = series[i+j].m_headPosition[1];
			NN->input_units[(j*25+15)] = series[i+j].m_headPosition[2];
			NN->input_units[(j*25+16)] = series[i+j].m_headUp[0];
			NN->input_units[(j*25+17)] = series[i+j].m_headUp[1];
			NN->input_units[(j*25+18)] = series[i+j].m_headUp[2]; 
			NN->input_units[(j*25+19)] = series[i+j].m_headLeft[0];
			NN->input_units[(j*25+20)] = series[i+j].m_headLeft[1];
			NN->input_units[(j*25+21)] = series[i+j].m_headLeft[2]; 
			NN->input_units[(j*25+22)] = series[i+j].m_headBack[0];
			NN->input_units[(j*25+23)] = series[i+j].m_headBack[1];
			NN->input_units[(j*25+24)] = series[i+j].m_headBack[2]; 
			NN->input_units[(j*25+25)] = series[i+j].m_fTime;
		}
		
		bpnn_feedforward(NN);
		j++;
		//Error is the target
		exerror[1] = abs_d(NN->output_units[1] - series[i+j].m_wandPosition[0]);
		exerror[2] = abs_d(NN->output_units[2] - series[i+j].m_wandPosition[1]);
		exerror[3] = abs_d(NN->output_units[3] - series[i+j].m_wandPosition[2]);
		exerror[4] = abs_d(NN->output_units[4] - series[i+j].m_wandUp[0]);
		exerror[5] = abs_d(NN->output_units[5] - series[i+j].m_wandUp[1]);
		exerror[6] = abs_d(NN->output_units[6] - series[i+j].m_wandUp[2]);
		exerror[7] = abs_d(NN->output_units[7] - series[i+j].m_wandLeft[0]);
		exerror[8] = abs_d(NN->output_units[8] - series[i+j].m_wandLeft[1]);
		exerror[9] = abs_d(NN->output_units[9] - series[i+j].m_wandLeft[2]);
		exerror[10] = abs_d(NN->output_units[10] - series[i+j].m_wandBack[0]);
		exerror[11] = abs_d(NN->output_units[11] - series[i+j].m_wandBack[1]);
		exerror[12] = abs_d(NN->output_units[12] - series[i+j].m_wandBack[2]); 
		exerror[13] = abs_d(NN->output_units[13] - series[i+j].m_headPosition[0]);
		exerror[14] = abs_d(NN->output_units[14] - series[i+j].m_headPosition[1]);
		exerror[15] = abs_d(NN->output_units[15] - series[i+j].m_headPosition[2]);
		exerror[16] = abs_d(NN->output_units[16] - series[i+j].m_headUp[0]);
		exerror[17] = abs_d(NN->output_units[17] - series[i+j].m_headUp[1]);
		exerror[18] = abs_d(NN->output_units[18] - series[i+j].m_headUp[2]); 
		exerror[19] = abs_d(NN->output_units[19] - series[i+j].m_headLeft[0]);
		exerror[20] = abs_d(NN->output_units[20] - series[i+j].m_headLeft[1]);
		exerror[21] = abs_d(NN->output_units[21] - series[i+j].m_headLeft[2]); 
		exerror[22] = abs_d(NN->output_units[22] - series[i+j].m_headBack[0]);
		exerror[23] = abs_d(NN->output_units[23] - series[i+j].m_headBack[1]);
		exerror[24] = abs_d(NN->output_units[24] - series[i+j].m_headBack[2]); 

		for (int l=1;l<25;l++) {
//			printf("%f ",NN->output_units[k]);
			exerror[0] = exerror[0] + exerror[l];
			total_error[l] = total_error[l] + exerror[l];
		}
//		printf("exerror:%f",exerror[0]);
		
	}

	for (int m=1;m<25;m++) {
//		printf("%d:%f ",m,total_error[m]);
		total_error[0] = total_error[0] + total_error[m];
	}
	printf("alltotal/size: %f/%d = %f\n",total_error[0],size,total_error[0]/size);
	
} //testseries10




//train a recurrent net on a series by feeding it one vector from the time series
//and training with the next point as the target

void trainrec (BPNN* NN,struct SensorData *series,int size,double learn_rate,double momentum) {

	int i,j,k,m,n;
	double errout=0,errhid=0,errcon=0;

	for (i=0;i < size-1;i++) { //stream through the data
		NN->input_units[1] = series[i].m_wandPosition[0];
		NN->input_units[2] = series[i].m_wandPosition[1];
		NN->input_units[3] = series[i].m_wandPosition[2];
		NN->input_units[4] = series[i].m_wandUp[0];
		NN->input_units[5] = series[i].m_wandUp[1];
		NN->input_units[6] = series[i].m_wandUp[2];
		NN->input_units[7] = series[i].m_wandLeft[0];
		NN->input_units[8] = series[i].m_wandLeft[1];
		NN->input_units[9] = series[i].m_wandLeft[2];
		NN->input_units[10] = series[i].m_wandBack[0];
		NN->input_units[11] = series[i].m_wandBack[1];
		NN->input_units[12] = series[i].m_wandBack[2]; 
		NN->input_units[13] = series[i].m_headPosition[0];
		NN->input_units[14] = series[i].m_headPosition[1];
		NN->input_units[15] = series[i].m_headPosition[2];
		NN->input_units[16] = series[i].m_headUp[0];
		NN->input_units[17] = series[i].m_headUp[1];
		NN->input_units[18] = series[i].m_headUp[2]; 
		NN->input_units[19] = series[i].m_headLeft[0];
		NN->input_units[20] = series[i].m_headLeft[1];
		NN->input_units[21] = series[i].m_headLeft[2]; 
		NN->input_units[22] = series[i].m_headBack[0];
		NN->input_units[23] = series[i].m_headBack[1];
		NN->input_units[24] = series[i].m_headBack[2]; 
		NN->input_units[25] = series[i].m_fTime;

		//load the next vector as the target
		NN->target[1] = series[i+1].m_wandPosition[0];
		NN->target[2] = series[i+1].m_wandPosition[1];
		NN->target[3] = series[i+1].m_wandPosition[2];
		NN->target[4] = series[i+1].m_wandUp[0];
		NN->target[5] = series[i+1].m_wandUp[1];
		NN->target[6] = series[i+1].m_wandUp[2];
		NN->target[7] = series[i+1].m_wandLeft[0];
		NN->target[8] = series[i+1].m_wandLeft[1];
		NN->target[9] = series[i+1].m_wandLeft[2];
		NN->target[10] = series[i+1].m_wandBack[0];
		NN->target[11] = series[i+1].m_wandBack[1];
		NN->target[12] = series[i+1].m_wandBack[2]; 
		NN->target[13] = series[i+1].m_headPosition[0];
		NN->target[14] = series[i+1].m_headPosition[1];
		NN->target[15] = series[i+1].m_headPosition[2];
		NN->target[16] = series[i+1].m_headUp[0];
		NN->target[17] = series[i+1].m_headUp[1];
		NN->target[18] = series[i+1].m_headUp[2]; 
		NN->target[19] = series[i+1].m_headLeft[0];
		NN->target[20] = series[i+1].m_headLeft[1];
		NN->target[21] = series[i+1].m_headLeft[2]; 
		NN->target[22] = series[i+1].m_headBack[0];
		NN->target[23] = series[i+1].m_headBack[1];
		NN->target[24] = series[i+1].m_headBack[2]; 
		
		bpnn_trainrec(NN, learn_rate, momentum, &errout, &errhid, &errcon);	
	}

	printf("Error output: %f, hidden: %f, context: %f \n",errout, errhid, errcon);

/*
    	series[i].Step,
    	series[i].m_fTime, 
	    series[i].m_wandPosition[0],series[i].m_wandPosition[1],series[i].m_wandPosition[2], 
	    series[i].m_wandUp[0],series[i].m_wandUp[1],series[i].m_wandUp[2], 
	    series[i].m_wandLeft[0],series[i].m_wandLeft[1],series[i].m_wandLeft[2], 
	    series[i].m_wandBack[0],series[i].m_wandBack[1],series[i].m_wandBack[2], 
	    series[i].m_headPosition[0],series[i].m_headPosition[1],series[i].m_headPosition[2], 
	    series[i].m_headUp[0],series[i].m_headUp[1],series[i].m_headUp[2], 
	    series[i].m_headLeft[0],series[i].m_headLeft[1],series[i].m_headLeft[2], 
	    series[i].m_headBack[0],series[i].m_headBack[1],series[i].m_headBack[2]); 
*/
	
} //trainrec   



void testrec (BPNN* NN,struct SensorData *series,int size,double *total_error) {

	int i,j;
	double exerror[30];

	for (int k=0;k<25;k++) { //clear the array
		total_error[k] = 0;
	}

	for (i=0;i < size-1;i++) { //stream through the data

		for (int n=1;n<25;n++) { //clear the output units
			NN->output_units[n] = 0;
		}

		NN->input_units[1] = series[i].m_wandPosition[0];
		NN->input_units[2] = series[i].m_wandPosition[1];
		NN->input_units[3] = series[i].m_wandPosition[2];
		NN->input_units[4] = series[i].m_wandUp[0];
		NN->input_units[5] = series[i].m_wandUp[1];
		NN->input_units[6] = series[i].m_wandUp[2];
		NN->input_units[7] = series[i].m_wandLeft[0];
		NN->input_units[8] = series[i].m_wandLeft[1];
		NN->input_units[9] = series[i].m_wandLeft[2];
		NN->input_units[10] = series[i].m_wandBack[0];
		NN->input_units[11] = series[i].m_wandBack[1];
		NN->input_units[12] = series[i].m_wandBack[2]; 
		NN->input_units[13] = series[i].m_headPosition[0];
		NN->input_units[14] = series[i].m_headPosition[1];
		NN->input_units[15] = series[i].m_headPosition[2];
		NN->input_units[16] = series[i].m_headUp[0];
		NN->input_units[17] = series[i].m_headUp[1];
		NN->input_units[18] = series[i].m_headUp[2]; 
		NN->input_units[19] = series[i].m_headLeft[0];
		NN->input_units[20] = series[i].m_headLeft[1];
		NN->input_units[21] = series[i].m_headLeft[2]; 
		NN->input_units[22] = series[i].m_headBack[0];
		NN->input_units[23] = series[i].m_headBack[1];
		NN->input_units[24] = series[i].m_headBack[2]; 
		NN->input_units[25] = series[i].m_fTime;

		
		bpnn_feedforward(NN);

		//Error is the target
		exerror[1] = abs_d(NN->output_units[1] - series[i+1].m_wandPosition[0]);
		exerror[2] = abs_d(NN->output_units[2] - series[i+1].m_wandPosition[1]);
		exerror[3] = abs_d(NN->output_units[3] - series[i+1].m_wandPosition[2]);
		exerror[4] = abs_d(NN->output_units[4] - series[i+1].m_wandUp[0]);
		exerror[5] = abs_d(NN->output_units[5] - series[i+1].m_wandUp[1]);
		exerror[6] = abs_d(NN->output_units[6] - series[i+1].m_wandUp[2]);
		exerror[7] = abs_d(NN->output_units[7] - series[i+1].m_wandLeft[0]);
		exerror[8] = abs_d(NN->output_units[8] - series[i+1].m_wandLeft[1]);
		exerror[9] = abs_d(NN->output_units[9] - series[i+1].m_wandLeft[2]);
		exerror[10] = abs_d(NN->output_units[10] - series[i+1].m_wandBack[0]);
		exerror[11] = abs_d(NN->output_units[11] - series[i+1].m_wandBack[1]);
		exerror[12] = abs_d(NN->output_units[12] - series[i+1].m_wandBack[2]); 
		exerror[13] = abs_d(NN->output_units[13] - series[i+1].m_headPosition[0]);
		exerror[14] = abs_d(NN->output_units[14] - series[i+1].m_headPosition[1]);
		exerror[15] = abs_d(NN->output_units[15] - series[i+1].m_headPosition[2]);
		exerror[16] = abs_d(NN->output_units[16] - series[i+1].m_headUp[0]);
		exerror[17] = abs_d(NN->output_units[17] - series[i+1].m_headUp[1]);
		exerror[18] = abs_d(NN->output_units[18] - series[i+1].m_headUp[2]); 
		exerror[19] = abs_d(NN->output_units[19] - series[i+1].m_headLeft[0]);
		exerror[20] = abs_d(NN->output_units[20] - series[i+1].m_headLeft[1]);
		exerror[21] = abs_d(NN->output_units[21] - series[i+1].m_headLeft[2]); 
		exerror[22] = abs_d(NN->output_units[22] - series[i+1].m_headBack[0]);
		exerror[23] = abs_d(NN->output_units[23] - series[i+1].m_headBack[1]);
		exerror[24] = abs_d(NN->output_units[24] - series[i+1].m_headBack[2]); 
/*
		exerror[1] = NN->output_units[1] - series[i+j].m_wandPosition[0];
		exerror[2] = NN->output_units[2] - series[i+j].m_wandPosition[1];
		exerror[3] = NN->output_units[3] - series[i+j].m_wandPosition[2];
		exerror[4] = NN->output_units[4] - series[i+j].m_wandUp[0];
		exerror[5] = NN->output_units[5] - series[i+j].m_wandUp[1];
		exerror[6] = NN->output_units[6] - series[i+j].m_wandUp[2];
		exerror[7] = NN->output_units[7] - series[i+j].m_wandLeft[0];
		exerror[8] = NN->output_units[8] - series[i+j].m_wandLeft[1];
		exerror[9] = NN->output_units[9] - series[i+j].m_wandLeft[2];
		exerror[10] = NN->output_units[10] - series[i+j].m_wandBack[0];
		exerror[11] = NN->output_units[11] - series[i+j].m_wandBack[1];
		exerror[12] = NN->output_units[12] - series[i+j].m_wandBack[2]; 
		exerror[13] = NN->output_units[13] - series[i+j].m_headPosition[0];
		exerror[14] = NN->output_units[14] - series[i+j].m_headPosition[1];
		exerror[15] = NN->output_units[15] - series[i+j].m_headPosition[2];
		exerror[16] = NN->output_units[16] - series[i+j].m_headUp[0];
		exerror[17] = NN->output_units[17] - series[i+j].m_headUp[1];
		exerror[18] = NN->output_units[18] - series[i+j].m_headUp[2]; 
		exerror[19] = NN->output_units[19] - series[i+j].m_headLeft[0];
		exerror[20] = NN->output_units[20] - series[i+j].m_headLeft[1];
		exerror[21] = NN->output_units[21] - series[i+j].m_headLeft[2]; 
		exerror[22] = NN->output_units[22] - series[i+j].m_headBack[0];
		exerror[23] = NN->output_units[23] - series[i+j].m_headBack[1];
		exerror[24] = NN->output_units[24] - series[i+j].m_headBack[2]; 
*/
		for (int l=1;l<25;l++) {
//			printf("%f ",NN->output_units[k]);
			exerror[0] = exerror[0] + exerror[l];
			total_error[l] = total_error[l] + exerror[l];
		}
//		printf("exerror:%f",exerror[0]);
		
	}

	for (int m=1;m<25;m++) {
//		printf("%d:%f ",m,total_error[m]);
		total_error[0] = total_error[0] + total_error[m];
//		if (total_error[m] > 500000) printf("%d:%f ",m,total_error[m]);
	}
	printf("alltotal/size: %f/%d = %f\n",total_error[0],size,total_error[0]/size);

	
} //testrec