}

	/* copy output parameters from FIS data structure */
	for (i = 0; i < fis->out_n; i++) {
		for (j = 0; j < fis->output[i]->mf_n; j++) {
			if (fis->order==1)
				for (k = 0; k < fis->in_n+1; k++)
					fis->para[tmp++] = fis->output[i]->mf[j]->params[k]; 
			else
				fis->para[tmp++] = fis->output[i]->mf[j]->params[fis->in_n];
		}
	}
}


static void anfisAssignForwardFunction(FIS *fis)
{
	int i, j, start, stop;
	DOUBLE (*nodeFcn)();

	for (i = 0; i < 7; i++) {
		switch(i) {
			case 0:
				nodeFcn = anfisInputNode;
				break;
			case 1:
				nodeFcn = anfisMfNode;
				break;
			case 2:
				nodeFcn = anfisInvNode;
				break;
			case 3:
				nodeFcn = anfisAndOrNode;
				break;
			case 4:
				nodeFcn = anfisRuleOutputNode;
				break;
			case 5:
				nodeFcn = anfisSummationNode;
				break;
			case 6:
				nodeFcn = anfisDivisionNode;
				break;
			default:
				fisError("Unknown layer!");
		}
		start = fis->layer[i]->index;
		stop = start + fis->layer_size[i] - 1;
		for (j = start; j <= stop; j++)
			fis->node[j]->nodeFcn = nodeFcn;
	}
}

static void anfisFreeAnNode(NODE *node)
{
	int i;
	FAN *now, *next;

	FREEARRAY(node->input);

	/* free fanin list */
	now = node->fanin;
	for (i = 0; i < node->fanin_n; i++) {
		next = now->next;
		FREEARRAY(now);
		now = next;
	}

	/* free fanout list */
	now = node->fanout;
	for (i = 0; i < node->fanout_n; i++) {
		next = now->next;
		FREEARRAY(now);
		now = next;
	}
	/*
	FREEARRAY(node);
	*/
	/* node->para, node->de_dp, and node->do_dp
	are freed in anfisFreeAnfis() */
}

static void anfisFreeAnfis(FIS *fis)
{
	int i, in_n, out_n;

	FREEARRAY(fis->in_mf_n);
	FREEARRAY(fis->out_mf_n);
	FREEARRAY(fis->para);
	FREEARRAY(fis->trn_best_para);
	FREEARRAY(fis->chk_best_para);
	FREEARRAY(fis->de_dp);
	FREEARRAY(fis->do_dp);
	for (i = 0; i < fis->node_n; i++)
		anfisFreeAnNode(fis->node[i]);
	FREEARRAY(fis->node[0]);
	FREEARRAY(fis->node);
	FREEMAT((void **)fis->trn_data, fis->trn_data_n);
	FREEMAT((void **)fis->chk_data, fis->chk_data_n);
	FREEARRAY(fis->ss_array);
	FREEARRAY(fis->trn_error);
	FREEARRAY(fis->chk_error);
	FREEARRAY(fis->kalman_io_pair);
	FREEMAT((void **)fis->tmp_node_output, fis->trn_data_n);

	/* the following is for kalman matrices */
	if (fis->method==1 || fis->method==0)
		in_n = ((fis->order)*(fis->in_n)+1)*fis->rule_n;
	else
		in_n = fis->para_n;
	out_n = fis->out_n;

	FREEMAT((void **)fis->kalman_para, in_n);

	FREEMAT((void **)fis->S, in_n);
	FREEMAT((void **)fis->P, in_n);
	FREEMAT((void **)fis->a, in_n);
	FREEMAT((void **)fis->b, out_n);
	FREEMAT((void **)fis->a_t, 1);
	FREEMAT((void **)fis->b_t, 1);
	FREEMAT((void **)fis->tmp1, in_n);
	FREEMAT((void **)fis->tmp2, 1);
	FREEMAT((void **)fis->tmp3, 1);
	FREEMAT((void **)fis->tmp4, in_n);
	FREEMAT((void **)fis->tmp5, 1);
	FREEMAT((void **)fis->tmp6, in_n);
	FREEMAT((void **)fis->tmp7, in_n);
}

/* Initial variables, for off-line learning only */
static void anfisSetVariable(FIS *fis)
{
	int i, in_n, out_n;

	fis->ss_array = (DOUBLE *)fisCalloc(fis->epoch_n, sizeof(DOUBLE));
	for (i = 0; i < fis->epoch_n; i++)
		fis->ss_array[i] = -1;
	fis->trn_error = (DOUBLE *)fisCalloc(fis->epoch_n, sizeof(DOUBLE));
	for (i = 0; i < fis->epoch_n; i++)
		fis->trn_error[i] = -1;
	if (fis->chk_data_n != 0) {
		fis->chk_error = (DOUBLE *)fisCalloc(fis->epoch_n,sizeof(DOUBLE));
		for (i = 0; i < fis->epoch_n; i++)
			fis->chk_error[i] = -1;
	}

	if (fis->method==1 || fis->method==0)
		in_n = ((fis->order)*(fis->in_n)+1)*fis->rule_n;
	else 
		in_n = fis->para_n;
	out_n = fis->out_n;

	fis->kalman_io_pair = (DOUBLE *)fisCalloc
		(in_n+fis->out_n, sizeof(DOUBLE));
	fis->kalman_para = (DOUBLE **)fisCreateMatrix
		(in_n, 1, sizeof(DOUBLE));
	fis->tmp_node_output = (DOUBLE **)fisCreateMatrix
		(fis->trn_data_n, fis->in_n+2*fis->total_in_mf_n+fis->rule_n,
		sizeof(DOUBLE));
	fis->lambda = 1;
	fis->min_trn_error = pow(2.0, 31.0)-1;
	fis->min_chk_error = pow(2.0, 31.0)-1;
	fis->last_dec_ss = 0;
	fis->last_inc_ss = 0;

	/* allocate static memory for Kalman filter algorithm */
	{
	/* ========== */
	fis->S = (DOUBLE **)fisCreateMatrix(in_n, in_n, sizeof(DOUBLE));
	fis->P = (DOUBLE **)fisCreateMatrix(in_n, out_n, sizeof(DOUBLE));
	fis->a = (DOUBLE **)fisCreateMatrix(in_n, 1, sizeof(DOUBLE));
	fis->b = (DOUBLE **)fisCreateMatrix(out_n, 1, sizeof(DOUBLE));
	fis->a_t = (DOUBLE **)fisCreateMatrix(1, in_n, sizeof(DOUBLE));
	fis->b_t = (DOUBLE **)fisCreateMatrix(1, out_n, sizeof(DOUBLE));
	fis->tmp1 = (DOUBLE **)fisCreateMatrix(in_n, 1, sizeof(DOUBLE));
	fis->tmp2 = (DOUBLE **)fisCreateMatrix(1, 1, sizeof(DOUBLE));
	fis->tmp3 = (DOUBLE **)fisCreateMatrix(1, in_n, sizeof(DOUBLE));
	fis->tmp4 = (DOUBLE **)fisCreateMatrix(in_n, in_n, sizeof(DOUBLE));
	fis->tmp5 = (DOUBLE **)fisCreateMatrix(1, out_n, sizeof(DOUBLE));
	fis->tmp6 = (DOUBLE **)fisCreateMatrix(in_n, out_n, sizeof(DOUBLE));
	fis->tmp7 = (DOUBLE **)fisCreateMatrix(in_n, out_n, sizeof(DOUBLE));
	}
}

/* Initial variables, for on-line learning only */
static void anfisSetVariable1(FIS *fis)
{

	fis->kalman_io_pair = (DOUBLE *)fisCalloc
		((fis->in_n+1)*fis->rule_n+fis->out_n, sizeof(DOUBLE));
	fis->kalman_para = (DOUBLE **)fisCreateMatrix
		((fis->in_n+1)*fis->rule_n, 1, sizeof(DOUBLE));
	fis->display_anfis_info = 1;	/* always display anfis info */
	/* allocate static memory for Kalman filter algorithm */
	{
	int in_n = (fis->in_n+1)*fis->rule_n;
	int out_n = fis->out_n;
	fis->S = (DOUBLE **)fisCreateMatrix(in_n, in_n, sizeof(DOUBLE));
	fis->P = (DOUBLE **)fisCreateMatrix(in_n, out_n, sizeof(DOUBLE));
	fis->a = (DOUBLE **)fisCreateMatrix(in_n, 1, sizeof(DOUBLE));
	fis->b = (DOUBLE **)fisCreateMatrix(out_n, 1, sizeof(DOUBLE));
	fis->a_t = (DOUBLE **)fisCreateMatrix(1, in_n, sizeof(DOUBLE));
	fis->b_t = (DOUBLE **)fisCreateMatrix(1, out_n, sizeof(DOUBLE));
	fis->tmp1 = (DOUBLE **)fisCreateMatrix(in_n, 1, sizeof(DOUBLE));
	fis->tmp2 = (DOUBLE **)fisCreateMatrix(1, 1, sizeof(DOUBLE));
	fis->tmp3 = (DOUBLE **)fisCreateMatrix(1, in_n, sizeof(DOUBLE));
	fis->tmp4 = (DOUBLE **)fisCreateMatrix(in_n, in_n, sizeof(DOUBLE));
	fis->tmp5 = (DOUBLE **)fisCreateMatrix(1, out_n, sizeof(DOUBLE));
	fis->tmp6 = (DOUBLE **)fisCreateMatrix(in_n, out_n, sizeof(DOUBLE));
	fis->tmp7 = (DOUBLE **)fisCreateMatrix(in_n, out_n, sizeof(DOUBLE));
	}
}

/* check the validity of the FIS structure for learning */
static void anfisCheckFisForLearning(FIS *fis)
{
	int i, j, mfcount=0;
	int *mfarray;

        mfarray = (int *)fisCalloc(fis->rule_n, sizeof(int));
        for (i=0; i<fis->rule_n; i++){
           mfarray[i]=0;
        }
	/* user-defined operators are not allow */
	if (fis->userDefinedAnd || fis->userDefinedOr ||
	    fis->userDefinedImp || fis->userDefinedAgg ||
	    fis->userDefinedDefuzz) {
		fisFreeFisNode(fis);
		fisError("User-defined operators are not allowed!");
	}

	/* user-defined MF are not allow */
	for (i = 0; i < fis->in_n; i++)
		for (j = 0; j < fis->input[i]->mf_n; j++)
			if (fis->input[i]->mf[j]->userDefined) {
				fisFreeFisNode(fis);
				fisError("User-defined MF's are not allowed!");
			}
	for (i = 0; i < fis->out_n; i++)
		for (j = 0; j < fis->output[i]->mf_n; j++)
			if (fis->output[i]->mf[j]->userDefined) {
				fisFreeFisNode(fis);
				fisError("User-defined MF's are not allowed!");
			}

	/* must be sugeno type */
	if (strcmp(fis->type, "sugeno")) {
		fisFreeFisNode(fis);
		fisError("Given FIS matrix is not of Sugeno type!"); 
	}

	/* must have only one output */
	if (fis->out_n != 1) {
		fisFreeFisNode(fis);
		fisError("Given FIS has more than one output!"); 
	}

	/* must use weighted average for deriving final output */
	if (strcmp(fis->defuzzMethod, "wtaver")) {
		fisFreeFisNode(fis);
		fisError("ANFIS only supports weighted average (wtaver)."); 
	}

	/* must have more than one rule */
	if (fis->rule_n <= 1) {
		fisFreeFisNode(fis);
		fisError("Need at least two rules for ANFIS learning!");
	}

	/* output MF no. must be the same as rule no. */
	if (fis->output[0]->mf_n != fis->rule_n) {
		fisFreeFisNode(fis);
		PRINTF("Number of output MF's is not equal to number of rules -->\n");
		fisError("Parameter sharing in FIS is not allowed!");
	}
	else { 
             /* output Parameter sharing in FIS is not allowed! */
           for (i=0; i< fis->rule_n; i++){
              mfcount=fis->rule_list[i][fis->in_n]-1;
              mfarray[mfcount] ++;
           }
           for (i=0; i<fis->rule_n; i++){
              if (mfarray[mfcount]==0 || mfarray[mfcount]>1){
		PRINTF("Output MF %s is used twice\n", fis->output[0]->mf[i]->label);
		fisError("Parameter sharing in FIS is not allowed!");
              }
           }
        }

	/* ========== */ 
	/* output MF must be of linear */ 
	/*
	for (i = 0; i < fis->output[0]->mf_n; i++)
		if (strcmp(fis->output[0]->mf[i]->type, "linear")) {
			fisFreeFisNode(fis);
			fisError("Each rule's output must be of linear type!");
		}
	*/
	/* output MF must be either all linear or all constant */ 
	{
	int all_linear = 1;
	int all_constant = 1;
	for (i = 0; i < fis->output[0]->mf_n; i++)
		if (strcmp(fis->output[0]->mf[i]->type, "linear")) {
			all_linear = 0;
			break;
		}
	for (i = 0; i < fis->output[0]->mf_n; i++)
		if (strcmp(fis->output[0]->mf[i]->type, "constant")) {
			all_constant = 0;
			break;
		}
	if (all_linear == 0 && all_constant == 0) {
		fisFreeFisNode(fis);
		fisError("Rules' outputs must be either of all linear"
			" or all constant!");
	}
	/*
	if (all_linear == 1)
		printf("Rule outputs are all linear.\n");
	if (all_constant == 1)
		printf("Rule outputs are all constant.\n");
	*/
	}

	/* rule weight must be one */
	for (i = 0; i < fis->rule_n; i++)
		if (fis->rule_weight[i] != 1) {
			fis->rule_weight[i] = 1;
			PRINTF("Warning: weight of rule %d is set to 1"
				" for ANFIS learning!\n", i+1);
		}
}