datstruc.c

模糊逻辑工具箱 模糊逻辑工具箱 模糊逻辑工具箱 模糊逻辑工具箱 模糊逻辑工具箱

/* Copyright (c) 1994-98 by The MathWorks, Inc. */
/* $Revision: 1.6 $  $Date: 1997/12/01 21:45:29 $  $Author: moler $ */

/***********************************************************************
 Data structure: construction, printing, and destruction 
 **********************************************************************/

/* action = "fanin" --> add j at the end of node i's fanin list */
/* action = "fanout" --> add j at the end of node i's fanout list */
static void
#ifdef __STDC__
fisAddFan(FIS *fis, int i, int j, char *action)
#else
fisAddFan(fis, i, j, action)
FIS *fis;
int i;
int j;
char *action;
#endif
{
	FAN *p, *new;

	new = (FAN *)calloc(1, sizeof(FAN));
	new->index = j;
	new->next = NULL;

	if (strcmp(action, "fanin") == 0) {
		p = fis->node[i]->fanin;
		if (p == NULL)
			fis->node[i]->fanin = new;
		else {
			while (p->next != NULL)
				p = p->next;
			p->next = new;
		}
		(fis->node[i]->fanin_n)++;
	} else if (strcmp(action, "fanout") == 0) {
		p = fis->node[i]->fanout;
		if (p == NULL)
			fis->node[i]->fanout = new;
		else {
			while (p->next != NULL)
				p = p->next;
			p->next = new;
		}
		(fis->node[i]->fanout_n)++;
	} else
		fisError("Unknown action in fisAddFan()!");
}

/* find the input the give node index (layer 1) belongs to */
/* also fill ll_index */
static int
#ifdef __STDC__
fisGetMfInput(FIS *fis, int index)
#else
fisGetMfInput(fis, index)
FIS *fis;
int index;
#endif
{
	int i;
	int tmp = fis->layer[1]->index;

	if ((index < tmp) || (index > tmp + fis->layer_size[1]-1))
		fisError("Error in fisGetMfInput() --> index out of bound!");

	tmp = index - fis->in_n;
	for (i = 0; i < fis->in_n; i++) {
		tmp -= fis->in_mf_n[i];
		if (tmp < 0) {
			fis->node[index]->ll_index = tmp + fis->in_mf_n[i];
			break;
		}
	}
	return(i);
}

/* Build fanin and fanout list of each node of ANFIS */
static void
#ifdef __STDC__
fisBuildFanList(FIS *fis)
#else
fisBuildFanList(fis)
FIS *fis;
#endif
{
	int i, j;
	int layer_index, node_index;
	int start, stop, start1, stop1;
	int which_input, which_mf, inv_node_n;
	NODE *p;

	/* layer 0 (INPUT) */
	layer_index = 0;
	start = fis->layer[layer_index]->index;
	stop = start + fis->layer_size[layer_index] - 1;
	for (i = start; i <= stop; i++) {
		p = fis->node[i];
		p->l_index = i - start;
		p->layer = layer_index;
		p->para_n = 0;
		p->fanin = NULL;

		start1 = fis->in_n;
		for (j = 0; j < i; j++)
			start1 += fis->in_mf_n[j];
		stop1 = start1 + fis->in_mf_n[i] - 1;
		for (j = start1; j <= stop1; j++) {
			fisAddFan(fis, i, j, "fanout");
			fisAddFan(fis, j, i, "fanin");
		}
		/* fanout to layer 4 */
		for (j = fis->layer[4]->index;
			j <= fis->layer[4]->index+fis->rule_n-1; j++) {
			fisAddFan(fis, i, j, "fanout");
			fisAddFan(fis, j, i, "fanin");
		}
	}

	/* layer 1 (MF) */
	layer_index = 1;
	start = fis->layer[layer_index]->index;
	stop = start + fis->layer_size[layer_index] - 1;
	inv_node_n = 0;
	for (i = start; i <= stop; i++) {
		p = fis->node[i];
		p->l_index = i - start;
		p->layer = layer_index;
		/* the following fills ll_index also */
		which_input = fisGetMfInput(fis, i);
		which_mf = fis->node[i]->ll_index;
		p->para_n = fisGetMfParaN(fis->input[which_input]->
			mf[which_mf]->type);

		/* build fanout to layer 2 (INV) */
		node_index = fis->layer_size[1] + i;
		fisAddFan(fis, i, node_index, "fanout");
		fisAddFan(fis, node_index, i, "fanin");

		/* build fanout to layer 3 */
		for (j = 0; j < fis->rule_n; j++) {
			if (fis->rule_list[j][which_input]-1 ==
				fis->node[i]->ll_index) {
				node_index = fis->layer_size[0] +
					fis->layer_size[1] +
					fis->layer_size[2] + j;
				fisAddFan(fis, i, node_index, "fanout");
				fisAddFan(fis, node_index, i, "fanin");
			}
		}
	}

	/* layer 2 (INV) */
	layer_index = 2;
	start = fis->layer[layer_index]->index;
	stop = start + fis->layer_size[layer_index] - 1;
	for (i = start; i <= stop; i++) {
		p = fis->node[i];
		p->l_index = i - start;
		p->layer = layer_index;
		p->para_n = 0;
		p->ll_index = fis->node[i-fis->total_in_mf_n]->ll_index;

		which_input = fisGetMfInput(fis, p->fanin->index);
		/* build fanout to layer 3 */
		for (j = 0; j < fis->rule_n; j++) {
			if (-fis->rule_list[j][which_input]-1 ==
				fis->node[i]->ll_index) {
				node_index = fis->layer_size[0] +
					fis->layer_size[1] +
					fis->layer_size[2] + j;
				fisAddFan(fis, i, node_index, "fanout");
				fisAddFan(fis, node_index, i, "fanin");
			}
		}
	}

	/* layer 3 (Firing-Strength) */
	layer_index = 3;
	start = fis->layer[layer_index]->index;
	stop = start + fis->layer_size[layer_index] - 1;
	for (i = start; i <= stop; i++) {
		p = fis->node[i];
		p->l_index = i - start;
		p->layer = layer_index;
		p->para_n = 0;

		/* build fanout to layer 4 */
		fisAddFan(fis, i, i + fis->rule_n, "fanout");
		fisAddFan(fis, i + fis->rule_n, i, "fanin");

		/* build fanout to layer 5 */
		fisAddFan(fis, i, fis->node_n - 2, "fanout");
		fisAddFan(fis, fis->node_n - 2, i, "fanin");
	}

	/* layer 4 (w*f) */
	layer_index = 4;
	start = fis->layer[layer_index]->index;
	stop = start + fis->layer_size[layer_index] - 1;
	for (i = start; i <= stop; i++) {
		p = fis->node[i];
		p->l_index = i - start;
		p->layer = layer_index;
		/* ========== */
		p->para_n = (fis->order)*(fis->in_n)+1;

		/* build fanout to layer 5 */
		fisAddFan(fis, i, fis->layer[5]->index, "fanout");
		fisAddFan(fis, fis->layer[5]->index, i, "fanin");
	}

	/* layer 5 (Summation) */
	layer_index = 5;
	start = fis->layer[layer_index]->index;
	stop = start + fis->layer_size[layer_index] - 1;
	for (i = start; i <= stop; i++) {
		p = fis->node[i];
		p->l_index = i - start;
		p->layer = layer_index;
		p->para_n = 0;
		fisAddFan(fis, i, fis->node_n-1, "fanout");
		fisAddFan(fis, fis->node_n-1, i, "fanin");
	}

	/* layer 6 (Output node) */
	layer_index = 6;
	start = fis->layer[layer_index]->index;
	stop = start + fis->layer_size[layer_index] - 1;
	for (i = start; i <= stop; i++) {
		p = fis->node[i];
		p->l_index = i - start;
		p->layer = layer_index;
		p->para_n = 0;
		p->fanout = NULL;
	}
}

/* find if given node index (layer 1) is connected to INV */
int
#ifdef __STDC__
fisFindInvMf(FIS *fis, int index)
#else
fisFindInvMf(fis, index)
FIS *fis;
int index;
#endif
{
	int i;
	int tmp = fis->layer[1]->index;
	int which_input;

	if ((index < tmp) || (index > tmp + fis->layer_size[1]-1))
		fisError("Error in fisFindInvMf() --> index out of bound!");
	which_input = fisGetMfInput(fis, index);
	for (i = 0; i < fis->rule_n; i++)
		if (-fis->rule_list[i][which_input] ==
			(fis->node[index]->ll_index+1))
			return(1);
	return(0);
}

/* Build additional data strucutre for ANFIS */
static void 
#ifdef __STDC__
anfisBuildAnfis(FIS *fis)
#else
anfisBuildAnfis(fis)
FIS *fis;
#endif
{
	int i, j, k, start, tmp;
	char *mf_type;
	double *mf_para;
	NODE *node_list;

	/*
	printf("Building ANFIS data structure ...\n");
	*/

	/* ========== */
	/* determine the order of ANFIS */
	if (!strcmp(fis->output[0]->mf[0]->type, "linear"))
		fis->order = 1;
	else
		fis->order = 0;


	/* build fis->in_mf_n */
	fis->in_mf_n = (int *)calloc(fis->in_n, sizeof(int));
	for (i = 0; i < fis->in_n; i++)
		fis->in_mf_n[i] = fis->input[i]->mf_n;

	/* build fis->out_mf_n */
	fis->out_mf_n = (int *)calloc(fis->out_n, sizeof(int));
	for (i = 0; i < fis->out_n; i++)
		fis->out_mf_n[i] = fis->output[i]->mf_n;

	/* calculate total mf number */
	for (tmp = 0, i = 0; i < fis->in_n; tmp += fis->in_mf_n[i], i++);
	fis->total_in_mf_n = tmp;

	/* calculate total node number */
	fis->node_n = fis->in_n + 2*fis->total_in_mf_n + 2*fis->rule_n + 2 + 1;

	/* fill the number of nodes in each layer */
	fis->layer_size[0] = fis->in_n;
	fis->layer_size[1] = fis->total_in_mf_n;
	fis->layer_size[2] = fis->total_in_mf_n;
	fis->layer_size[3] = fis->rule_n;
	fis->layer_size[4] = fis->rule_n;
	fis->layer_size[5] = 2;
	fis->layer_size[6] = 1;		/* for single output only */

	/* build each node */
	node_list = (NODE *)calloc(fis->node_n, sizeof(NODE));

	/* fill fis->node and fis->node[i]->index */
	fis->node = (NODE **)calloc(fis->node_n, sizeof(NODE *));
	for (i = 0; i < fis->node_n; i++) {
		fis->node[i] = node_list + i;
		fis->node[i]->index = i;
	}

	/* calculate fis->layer */
	start = 0;
	for (i = 0; i < 7; i++) {
		fis->layer[i] = fis->node[start];
		start += fis->layer_size[i];
	}

	/* fill fanin and fanout list and other housekeepin stuff */
	fisBuildFanList(fis);

	/* find total number of parameters */
	/* (Each node's number of parameters is specified in
           fisBuildFanList.) */
	fis->para_n = 0;
	for (i = 0; i < fis->node_n; i++)
		fis->para_n += fis->node[i]->para_n;

	/* allocate memory for parameter related arrays */
	fis->para = (double *)calloc(fis->para_n, sizeof(double));
	fis->trn_best_para = (double *)calloc(fis->para_n, sizeof(double));
	fis->chk_best_para = (double *)calloc(fis->para_n, sizeof(double));
	fis->de_dp = (double *)calloc(fis->para_n, sizeof(double));
	fis->do_dp = (double *)calloc(fis->para_n, sizeof(double));
	/* assign parameter pointer for each node */
	tmp = 0;
	for (i = 0; i < fis->node_n; i++) {
		if (fis->node[i]->para_n == 0)
			continue;
		fis->node[i]->para = fis->para + tmp;
		fis->node[i]->de_dp = fis->de_dp + tmp;
		fis->node[i]->do_dp = fis->do_dp + tmp;
		tmp += fis->node[i]->para_n;
	}

	/* allocate input array for each node */
	for (i = 0; i < fis->node_n; i++)
		fis->node[i]->input = (double *)
			calloc(fis->node[i]->fanin_n, sizeof(double));

	/* copy input MF parameters from FIS data structure */
	tmp = 0;