tlearn 0.0.1

data/ext/tlearn/Exp/exp.c

@@ -0,0 +1,13 @@
+#include <stdio.h>
+#include <math.h>
+
+main() {
+	double	f;
+	register int i;
+	float	x;
+
+	for (i = -64000; i<64000; i++) {
+		x = exp((double) i * 0.00025);
+		fwrite(&x, sizeof(x), 1, stdout);
+	}
+}

data/ext/tlearn/activate.c

@@ -0,0 +1,222 @@
+#include <math.h>
+#include <stdio.h>
+
+
+#ifdef EXP_TABLE
+#define EXP(m) \
+	(exp_array[((int) ((m) * exp_mult)) + exp_add])
+#else
+#define EXP(m) exp(m)
+#endif	EXP_TABLE
+
+
+extern	int	nn;		/* number of nodes */
+extern	int	ni;		/* number of inputs */
+extern	int	no;		/* number of outputs */
+extern	int	nt;		/* nn + ni + 1 */
+extern	int	np;		/* ni + 1 */
+
+extern	struct	cf {
+	int	con;	/* connection flag */
+	int	fix;	/* fixed-weight flag */
+	int	num;	/* group number */
+	int	lim;	/* weight limits */
+	float	min;	/* weight minimum */
+	float	max;	/* weight maximum */
+};
+
+extern	struct	nf {
+	int	func;	/* activation function type */
+	int	dela;	/* delay flag */
+	int	targ;	/* target flag */
+};
+
+extern	struct	cf	**cinfo;	/* (nn x nt) connection info */
+
+extern	struct	nf	*ninfo;	/* (nn) node info */
+
+extern	int	backprop;	/* flag for back propagation */
+extern	int	localist;	/* flag for localist input */
+extern	int	teacher;	/* flag for feeding back target */
+
+act_nds(aold,amem,anew,awt,local,atarget)
+	float	*aold;
+	float	*amem;
+	float	*anew;
+	float	**awt;
+	int	*local;
+	float	*atarget;
+{
+
+	extern	float	*exp_array;	/* table look-up for exp function */
+	extern	float	exp_mult;
+	extern	long	exp_add;
+
+	register	int	i;
+	register	int	j;
+
+	register	struct	cf	*ci;
+
+	register	float	*w;
+	register	float	*zo;
+	register	float	*zn;
+	register	float	*zp;
+
+	register	float	**wp;
+
+	register	struct	cf	**cp;
+	register	struct	nf	*n;
+	register	struct	nf	*on;
+
+	register	int	*l;
+	register	float	*t;
+	register	int	tcnt;
+
+	/* for each of nn nodes: update activations */
+	if (backprop == 0){
+		zo = aold + np;
+		zn = anew + np;
+		for (i = 0; i < nn; i++, zo++, zn++){
+			*zo = *zn;
+		}
+	}
+	/* remember current aold in amem */
+	zo = aold + np;
+	zn = amem + np;
+	for (i = 0; i < nn; i++, zo++, zn++){
+		*zn = *zo;
+	}
+
+	/* for each of nn nodes: update net inputs */
+	n = ninfo;
+	cp = cinfo;
+	wp = awt;
+	zn = anew + np;
+	zp = aold + np;
+	t = atarget;
+	tcnt = 0;
+	for (i = 0; i < nn; i++, zn++, n++, cp++, wp++, zp++){
+		if (localist){
+			ci = *cp + np;
+			w = *wp + np;
+			zo = aold + np;
+			*zn = **wp;
+			l = local;
+			while (*l != 0){
+				*zn += *(*wp + *l++);
+			}
+			if (teacher){
+				on = ninfo;
+				for (j = 0; j < nn; j++, w++, zo++, ci++, on++){
+					if (ci->con){
+						if (on->targ){
+							if (*t == -9999.) /* don't care */
+								*zn += *w * *zo;
+							else
+								*zn += *w * *t++;
+							if (++tcnt > no){
+								fprintf(stderr,"WHOA!  -t flag requires each output feeding exactly one node\n");
+								exit(1);
+							}
+						}
+						else
+							*zn += *w * *zo;
+					}
+				}
+			}
+			else {
+				for (j = 0; j < nn; j++, w++, zo++, ci++){
+					if (ci->con)
+						*zn += *w * *zo;
+				}
+			}
+			/* apply activation function	*/
+			/*	0 = default		*/
+			/*	1 = bipolar		*/
+			/*	2 = linear		*/
+			/*	3 = binary		*/
+			if (n->func != 2){
+				if (*zn > 10.)
+					*zn = 10.;
+				else if (*zn < -10.)
+					*zn = -10.;
+			}
+			if (n->func < 2)
+				*zn = 1.0 / (1.0 + EXP(0.0 - *zn));
+			if (n->func == 1)
+				*zn = 2. * *zn - 1.;
+			else if (n->func == 3){
+				if (*zn > 0.)
+					*zn = 1.;
+				else
+					*zn = -1.;
+			}
+			/* if no-delay, then update immediately */
+			if (n->dela == 0)
+				*zp = *zn;
+		}
+		else {
+			ci = *cp;
+			w = *wp;
+			zo = aold;
+			*zn = 0.;
+			/* collect excitation */
+			if (teacher){
+				for (j = 0; j <= ni; j++, w++, zo++, ci++){
+					if (ci->con)
+						*zn += *w * *zo;
+				}
+				on = ninfo;
+				for (j = 0; j < nn; j++, w++, zo++, ci++, on++){
+					if (ci->con){
+						if (on->targ){
+							if (*t == -9999.)
+								*zn += *w * *zo;
+							else
+								*zn += *w * *t++;
+							if (++tcnt > no){
+								fprintf(stderr,"WHOA!  -t flag requires each output feeding exactly one node\n");
+								exit(1);
+							}
+						}
+						else
+							*zn += *w * *zo;
+					}
+				}
+			}
+			else {
+				for (j = 0; j < nt; j++, w++, zo++, ci++){
+					if (ci->con)
+						*zn += *w * *zo;
+				}
+			}
+			/* apply activation function	*/
+			/*	0 = default		*/
+			/*	1 = bipolar		*/
+			/*	2 = linear		*/
+			/*	3 = binary		*/
+			if (n->func != 2){
+				if (*zn > 10.)
+					*zn = 10.;
+				else if (*zn < -10.)
+					*zn = -10.;
+			}
+			if (n->func < 2)
+				*zn = 1.0 / (1.0 + EXP(0.0 - *zn));
+			if (n->func == 1)
+				*zn = 2. * *zn - 1.;
+			else if (n->func == 3){
+				if (*zn > 0.)
+					*zn = 1.;
+				else
+					*zn = -1.;
+			}
+			/* if no-delay, then update immediately */
+			if (n->dela == 0)
+				*zp = *zn;
+		}
+	}
+
+}
+
+

data/ext/tlearn/arrays.c

@@ -0,0 +1,224 @@
+
+/* make_arrays() - malloc space for arrays */
+
+#include <stdio.h>
+
+#ifdef ibmpc
+extern char  far *malloc();
+#else
+extern void *malloc();
+#endif
+extern	int	nn;		/* number of nodes */
+extern	int	ni;		/* number of inputs */
+extern	int	no;		/* number of outputs */
+extern	int	nt;		/* nn + ni + 1 */
+
+struct	cf {
+	int	con;	/* connection flag */
+	int	fix;	/* fixed-weight flag */
+	int	num;	/* group number */
+	int	lim;	/* weight limits */
+	float	min;	/* weight minimum */
+	float	max;	/* weight maximum */
+};
+
+struct	nf {
+	int	func;	/* activation function type */
+	int	dela;	/* delay flag */
+	int	targ;	/* target flag */
+};
+
+extern	struct	cf	**cinfo;	/* (nn x nt) connection info */
+extern	struct	nf	*ninfo;		/* (nn) node activation function info */
+
+extern	int	*outputs;	/* (no) indices of output nodes */
+extern	int	*selects;	/* (nn+1) nodes selected for probe printout */
+extern	int	*linput;	/* (ni) localist input array */
+
+extern	float	*znew;		/* (nt) inputs and activations at time t+1 */
+extern	float	*zold;		/* (nt) inputs and activations at time t */
+extern	float	*zmem;		/* (nt) inputs and activations at time t */
+extern	float	**wt;		/* (nn x nt) weight TO node i FROM node j*/ 
+extern	float	**dwt;		/* (nn x nt) delta weight at time t */
+extern	float	**winc;		/* (nn x nt) accumulated weight increment*/
+extern	float	*target;	/* (no) output target values */
+extern	float	*error;		/* (nn) error = (output - target) values */
+extern	float	***pnew;	/* (nn x nt x nn) p-variable at time t+1 */
+extern	float	***pold;	/* (nn x nt x nn) p-variable at time t */
+
+
+make_arrays()
+{
+
+	int	i;
+	int	j;
+
+	struct	cf	*ci;
+	struct	nf	*n;
+
+	zold = (float *) malloc(nt * sizeof(float));
+	if (zold == NULL){
+		perror("zold malloc failed");
+		exit(1);
+	}
+	zmem = (float *) malloc(nt * sizeof(float));
+	if (zmem == NULL){
+		perror("zmem malloc failed");
+		exit(1);
+	}
+	znew = (float *) malloc(nt * sizeof(float));
+	if (znew == NULL){
+		perror("znew malloc failed");
+		exit(1);
+	}
+	target = (float *) malloc(no * sizeof(float));
+	if (target == NULL){
+		perror("target malloc failed");
+		exit(1);
+	}
+	error = (float *) malloc(nn * sizeof(float));
+	if (error == NULL){
+		perror("error malloc failed");
+		exit(1);
+	}
+	selects = (int *) malloc(nt * sizeof(int));
+	if (selects == NULL){
+		perror("selects malloc failed");
+		exit(1);
+	}
+	outputs = (int *) malloc(no * sizeof(int));
+	if (outputs == NULL){
+		perror("outputs malloc failed");
+		exit(1);
+	}
+	linput = (int *) malloc(ni * sizeof(int));
+	if (linput == NULL){
+		perror("linput malloc failed");
+		exit(1);
+	}
+
+	wt = (float **) malloc(nn * sizeof(float *));
+	if (wt == NULL){
+		printf("wt malloc failed--needed %d bytes for pointers", nn*sizeof(float *));
+		exit(1);
+	}
+	for (i = 0; i < nn; i++){
+		*(wt + i) = (float *) malloc(nt * sizeof(float));
+		if (*(wt + i) == NULL){
+			printf("wt malloc failed");
+			printf("--got %d nodes, %d remaining", i, nn);
+			exit(1);
+		}
+	}
+
+	dwt = (float **) malloc(nn * sizeof(float *));
+	if (dwt == NULL){
+		perror("dwt malloc failed");
+		exit(1);
+	}
+	for (i = 0; i < nn; i++){
+		*(dwt + i) = (float *) malloc(nt * sizeof(float));
+		if (*(dwt + i) == NULL){
+			perror("dwt malloc failed");
+			exit(1);
+		}
+	}
+
+	winc = (float **) malloc(nn * sizeof(float *));
+	if (winc == NULL){
+		perror("winc malloc failed");
+		exit(1);
+	}
+	for (i = 0; i < nn; i++){
+		*(winc + i) = (float *) malloc(nt * sizeof(float));
+		if (*(winc + i) == NULL){
+			perror("winc malloc failed");
+			exit(1);
+		}
+	}
+
+	cinfo = (struct cf **) malloc(nn * sizeof(struct cf *));
+	if (cinfo == NULL){
+		perror("cinfo malloc failed");
+		exit(1);
+	}
+	for (i = 0; i < nn; i++){
+		*(cinfo + i) = (struct cf *) malloc(nt * sizeof(struct cf));
+		if (*(cinfo + i) == NULL){
+			perror("cinfo malloc failed");
+			exit(1);
+		}
+	}
+
+	ninfo = (struct nf *) malloc(nn * sizeof(struct nf));
+	if (ninfo == NULL){
+		perror("ninfo malloc failed");
+		exit(1);
+	}
+
+	n = ninfo;
+	for (i = 0; i < nn; i++, n++){
+		n->func = 0;
+		n->dela = 0;
+		n->targ = 0;
+		ci = *(cinfo + i);
+		for (j = 0; j < nt; j++, ci++){
+			ci->con = 0;
+			ci->fix = 0;
+			ci->num = 0;
+			ci->lim = 0;
+			ci->min = 0.;
+			ci->max = 0.;
+		}
+	}
+
+}
+
+make_parrays()
+{
+
+	int	i;
+	int	j;
+
+	pold = (float ***) malloc(nn * sizeof(float **));
+	if (pold == NULL){
+		perror("pold malloc failed");
+		exit(1);
+	}
+	for (i = 0; i < nn; i++){
+		*(pold + i) = (float **) malloc(nt * sizeof(float *));
+		if (*(pold + i) == NULL){
+			perror("pold malloc failed");
+			exit(1);
+		}
+		for (j = 0; j < nt; j++){
+			*(*(pold + i) + j) = (float *) malloc(nn * sizeof(float));
+			if (*(*(pold + i) + j) == NULL){
+				perror("pold malloc failed");
+				exit(1);
+			}
+		}
+	}
+
+	pnew = (float ***) malloc(nn * sizeof(float **));
+	if (pnew == NULL){
+		perror("pnew malloc failed");
+		exit(1);
+	}
+	for (i = 0; i < nn; i++){
+		*(pnew + i) = (float **) malloc(nt * sizeof(float *));
+		if (*(pnew + i) == NULL){
+			perror("pnew malloc failed");
+			exit(1);
+		}
+		for (j = 0; j < nt; j++){
+			*(*(pnew + i) + j) = (float *) malloc(nn * sizeof(float));
+			if (*(*(pnew + i) + j) == NULL){
+				perror("pnew malloc failed");
+				exit(1);
+			}
+		}
+	}
+
+}
+