mat2cstr.c

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

/* Copyright (c) 1994-98 by The MathWorks, Inc. */
/* $Revision: 1.6 $ */

FIS *matlab2cStr(const mxArray *matlabmat)
{
        mxArray *fispointer, *inputpointer, *mfpointer;
        char *buf;
	int i, j,k, param_size, data_n, in_n;
	FIS *fis;

        int status, buflen=100;	
        int io_vector_size;
        double *real_data_ptr;
	int *in_mf_n, *out_mf_n;
	IO *io_list;

	/*----------- Create FIS node -------------------*/
        buf=mxCalloc(buflen, sizeof(char));
        /* get fis name, type, ....*/
        fis = (FIS *)calloc(1, sizeof(FIS));
        fispointer=mxGetField(matlabmat, 0,"name");
        status=mxGetString(fispointer, fis->name, buflen);

        /* fis->type */
        fispointer=mxGetField(matlabmat, 0,"type");
        status=mxGetString(fispointer, fis->type, buflen);
        if (status!=0)
           mexPrintf("Can not get fis type");
        /* fis->andMethod */
        fispointer=mxGetField(matlabmat, 0,"andMethod");
        status=mxGetString(fispointer, fis->andMethod, buflen);
        if (status!=0)
           mexPrintf("Can not get fis andMethod");
        /* fis->orMethod */
        fispointer=mxGetField(matlabmat, 0,"orMethod");
        status=mxGetString(fispointer, fis->orMethod, buflen);
        if (status!=0)
           mexPrintf("Can not get fis orMethod");
        /* fis->defuzzMethod */
        fispointer=mxGetField(matlabmat, 0,"defuzzMethod");
        status=mxGetString(fispointer, fis->defuzzMethod, buflen);
        if (status!=0)
           mexPrintf("Can not get fis defuzzMethod");
        /* fis->impMethod */
        fispointer=mxGetField(matlabmat, 0,"impMethod");
        status=mxGetString(fispointer, fis->impMethod, buflen);
        if (status!=0)
           mexPrintf("Can not get fis impMethod");
        /* fis->aggMethod */
        fispointer=mxGetField(matlabmat, 0,"aggMethod");
        status=mxGetString(fispointer, fis->aggMethod, buflen);
        if (status!=0)
           mexPrintf("Can not get fis aggMethod");
/*========input nodes=========*/
   fispointer=mxGetField(matlabmat, 0,"input");
	io_vector_size = mxGetN(fispointer);
	fis->in_n=io_vector_size;
	fis->input = (IO **)calloc(io_vector_size, sizeof(IO *));
       
	/* create input node list, each in_mf_n's element containts the number of mf */
	in_mf_n = (int *)calloc(fis->in_n, sizeof(int));
	for (i = 0; i < fis->in_n; i++){
      inputpointer=mxGetField(fispointer, i, "mf"); 
      if (inputpointer!=NULL)
		  in_mf_n[i]=mxGetN(inputpointer);
      else
        in_mf_n[i]=0;
        }
	io_list = fisBuildIoList(fis->in_n, in_mf_n);
	free(in_mf_n);
	fis->input = (IO **)calloc(fis->in_n, sizeof(IO *));
	for (i = 0; i < fis->in_n; i++)
		fis->input[i] = io_list+i;
        /*finished input memory allocation */

	for(i=0; i<fis->in_n; i++){
          inputpointer=mxGetField(fispointer, i, "name");
          status=mxGetString(inputpointer, fis->input[i]->name, buflen);

          inputpointer=mxGetField(fispointer, i, "range");
          real_data_ptr=(double *)mxGetPr(inputpointer);
          fis->input[i]->bound[0]=*real_data_ptr;
          fis->input[i]->bound[1]=*(real_data_ptr+1);

          inputpointer=mxGetField(fispointer, i, "mf");
          if (inputpointer!=NULL)
            fis->input[i]->mf_n=mxGetN(inputpointer);
          else
            fis->input[i]->mf_n=0;

          for(j=0; j<fis->input[i]->mf_n; j++){
             mfpointer=mxGetField(inputpointer, j, "name");
             status=mxGetString(mfpointer, fis->input[i]->mf[j]->label, buflen);
             mfpointer=mxGetField(inputpointer, j, "type");
             status=mxGetString(mfpointer, fis->input[i]->mf[j]->type, buflen);
             mfpointer=mxGetField(inputpointer, j, "params");
             param_size=mxGetN(mfpointer);
             real_data_ptr=(double *)mxGetPr(mfpointer);
             for(k=0; k<param_size; k++){
               fis->input[i]->mf[j]->para[k]=*real_data_ptr++;
	     }
          }      
        }
/*====================output=========================*/
        fispointer=mxGetField(matlabmat, 0,"output");
	io_vector_size = mxGetN(fispointer);
	fis->out_n=io_vector_size;

	/* create output node list, each in_mf_n's element containts the number of mf */
	out_mf_n = (int *)calloc(fis->out_n, sizeof(int));
	for (i = 0; i < fis->out_n; i++){
                inputpointer=mxGetField(fispointer, i, "mf"); 
		out_mf_n[i]=mxGetN(inputpointer);
        }
	io_list = fisBuildIoList(fis->out_n, out_mf_n);
	free(out_mf_n); 
	fis->output = (IO **)calloc(fis->out_n, sizeof(IO *));
	for (i = 0; i < fis->out_n; i++)
		fis->output[i] = io_list+i;
        /*finished output memory allocation */
	
	for(i=0; i<fis->out_n; i++){
          inputpointer=mxGetField(fispointer, i, "name");
          status=mxGetString(inputpointer, fis->output[i]->name, buflen);

          inputpointer=mxGetField(fispointer, i, "range");
          real_data_ptr=(double *)mxGetPr(inputpointer);
          fis->output[i]->bound[0]=*real_data_ptr;
          fis->output[i]->bound[1]=*(real_data_ptr+1);

          inputpointer=mxGetField(fispointer, i, "mf");
          fis->output[i]->mf_n=mxGetN(inputpointer);
          for(j=0; j<fis->output[i]->mf_n; j++){
             mfpointer=mxGetField(inputpointer, j, "name");
             status=mxGetString(mfpointer, fis->output[i]->mf[j]->label, buflen);
             mfpointer=mxGetField(inputpointer, j, "type");
             status=mxGetString(mfpointer, fis->output[i]->mf[j]->type, buflen);
             mfpointer=mxGetField(inputpointer, j, "params");
             param_size=mxGetN(mfpointer);
             real_data_ptr=(double *)mxGetPr(mfpointer);

	     /* get Mamdani output MF parameters and compute MF value array */
	      if (strcmp(fis->type, "mamdani") == 0) {
		  fis->output[i]->mf[j]->value_array =(double *)calloc(MF_POINT_N, sizeof(double)); 	
	          for(k=0; k<param_size; k++)
                   fis->output[i]->mf[j]->para[k]=*real_data_ptr++;
	     /* get Sugeno output equation parameters */
		  } else if (strcmp(fis->type, "sugeno") == 0) {
		  fis->output[i]->mf[j]->sugeno_coef =
					(double *)calloc(fis->in_n+1, sizeof(double));
             /*????????????*/
		  for (k = 0; k < fis->in_n+1; k++)
		      fis->output[i]->mf[j]->sugeno_coef[k] =*real_data_ptr++;
	     } else {
		printf("fis->type = %s\n", fis->type);
		fisError("Unknown fis type!");
	     }
          }      
        }

   fispointer=mxGetField(matlabmat, 0,"rule");
   if (fispointer==NULL)
       fis->rule_n=0;
   else
	    fis->rule_n = mxGetN(fispointer);
	fis->rule_list = (int **)fisCreateMatrix(fis->rule_n, fis->in_n + fis->out_n, sizeof(int));
	fis->rule_weight = (double *)calloc(fis->rule_n, sizeof(double));
	fis->and_or = (int *)calloc(fis->rule_n, sizeof(int));
	
	for (i = 0; i < fis->rule_n; i++) {
            inputpointer=mxGetField(fispointer, i, "antecedent");
            real_data_ptr=(double *)mxGetPr(inputpointer);
	    for (j = 0; j < fis->in_n ; j++)
		fis->rule_list[i][j] = *real_data_ptr++;
            inputpointer=mxGetField(fispointer, i, "consequent");
            real_data_ptr=(double *)mxGetPr(inputpointer);
	    for (j = 0; j < fis->out_n ; j++)
		fis->rule_list[i][j+fis->in_n] = *real_data_ptr++;
            inputpointer=mxGetField(fispointer, i, "weight");
            real_data_ptr=(double *)mxGetPr(inputpointer);
	    fis->rule_weight[i] = *real_data_ptr;
            inputpointer=mxGetField(fispointer, i, "connection");
            real_data_ptr=(double *)mxGetPr(inputpointer);
	    fis->and_or[i] =*real_data_ptr; 
	}
		fisAssignMfPointer(fis);
	fisAssignFunctionPointer(fis); 
	fis->firing_strength = (double *)calloc(fis->rule_n, sizeof(double));
	fis->rule_output = (double *)calloc(fis->rule_n, sizeof(double));

	if (strcmp(fis->type, "mamdani") == 0) {
		fis->BigOutMfMatrix = (double *)
			calloc(fis->rule_n*MF_POINT_N, sizeof(double));
		fis->BigWeightMatrix = (double *)
			calloc(fis->rule_n*MF_POINT_N, sizeof(double));
	}
	fis->mfs_of_rule = (double *)calloc(fis->in_n, sizeof(double));
        if (strcmp(fis->type, "mamdani") == 0) {
    	  for (i = 0; i < fis->out_n; i++)
         	fisComputeOutputMfValueArray(fis, 101);
	} 
       	fisCheckDataStructure(fis);

	/*----------finished setting fis structure-------------------*/
	fis->next = NULL;
        return(fis);
}

mxArray *c2matlabStr(FIS *fis, int flag){
    double *source;
    mxArray *fisresult;

    int status, i, j, k, param_n;
    double *real_data_ptr, *antecedent, *consequent;
    mxArray *field_value;
    mxArray *in_field, *out_field, *mf_field;
    const char *field_names[]={"name", "type", "andMethod", "orMethod", "defuzzMethod",
                               "impMethod", "aggMethod", "input", "output", "rule"};
    const char *in_field_names[]={"name", "range", "mf"};
    const char *mf_field_names[]={"name", "type", "params"};
    const char *rule_field_names[]={"antecedent", "consequent", "weight", "connection"};
    const char *tempvalue[]={"test1", "test2"};

    int dims[2]={1, 1}, new_prm_index=0;

    source = flag == 0? fis->trn_best_para:fis->chk_best_para;
/*==============output mapping==============*/
        antecedent=(double *)calloc(fis->in_n, sizeof(double));
        consequent=(double *)calloc(fis->out_n, sizeof(double));
        fisresult = mxCreateStructArray(2, dims, 10, field_names);
        field_value=mxCreateString(fis->name);
	mxSetField(fisresult, 0, "name", field_value);
        field_value=mxCreateString(fis->type);
	mxSetField(fisresult, 0, "type", field_value);
        field_value=mxCreateString(fis->andMethod);
	mxSetField(fisresult, 0, "andMethod", field_value);
        field_value=mxCreateString(fis->orMethod);
	mxSetField(fisresult, 0, "orMethod", field_value);
        field_value=mxCreateString(fis->defuzzMethod);
	mxSetField(fisresult, 0, "defuzzMethod", field_value);
        field_value=mxCreateString(fis->impMethod);
	mxSetField(fisresult, 0, "impMethod", field_value);
        field_value=mxCreateString(fis->aggMethod);
	mxSetField(fisresult, 0, "aggMethod", field_value);

/*========input=============*/
        dims[1]=fis->in_n;
        in_field=mxCreateStructArray(2, dims, 3, in_field_names); 
        for (i=0; i<fis->in_n; i++){
            field_value=mxCreateString(fis->input[i]->name);
	    mxSetField(in_field, i, "name", field_value);
            field_value=mxCreateDoubleMatrix(1,2,mxREAL);
            real_data_ptr = (double *)mxGetPr(field_value);
            memcpy(real_data_ptr, fis->input[i]->bound, 2 * sizeof(double) );

	    mxSetField(in_field, i, "range", field_value);
            dims[1]=fis->input[i]->mf_n;
            mf_field=mxCreateStructArray(2, dims, 3, mf_field_names); 
            for (j=0; j<dims[1]; j++){
                field_value=mxCreateString(fis->input[i]->mf[j]->label);
	        mxSetField(mf_field, j, "name", field_value);
                field_value=mxCreateString(fis->input[i]->mf[j]->type);
	        mxSetField(mf_field, j, "type", field_value);
                param_n=fisGetMfParaN(fis->input[i]->mf[j]->type);
                field_value=mxCreateDoubleMatrix(1,param_n,mxREAL);
                real_data_ptr = (double *)mxGetPr(field_value);
                for (k=0; k<param_n; k++)
                 *real_data_ptr++=source[new_prm_index++];
/*                memcpy(real_data_ptr, fis->input[i]->mf[j]->para, param_n * sizeof(double) );*/
       	        mxSetField(mf_field, j, "params", field_value);
            }    
            mxSetField(in_field, i, "mf", mf_field); 	
         }
        mxSetField(fisresult, 0, "input", in_field); 

 
/*=============output==============*/  
        dims[1]=fis->out_n;
        out_field=mxCreateStructArray(2, dims, 3, in_field_names); 
        for (i=0; i<fis->out_n; i++){
            field_value=mxCreateString(fis->output[i]->name);
	    mxSetField(out_field, i, "name", field_value);
            field_value=mxCreateDoubleMatrix(1,2,mxREAL);
            real_data_ptr = (double *)mxGetPr(field_value);
            memcpy(real_data_ptr, fis->output[i]->bound, 2 * sizeof(double) );

	    mxSetField(out_field, i, "range", field_value);
            dims[1]=fis->output[i]->mf_n;
            mf_field=mxCreateStructArray(2, dims, 3, mf_field_names); 
            for (j=0; j<fis->output[i]->mf_n; j++){
                field_value=mxCreateString(fis->output[i]->mf[j]->label);
	        mxSetField(mf_field, j, "name", field_value);
                field_value=mxCreateString(fis->output[i]->mf[j]->type);
	        mxSetField(mf_field, j, "type", field_value);
                if (fis->order == 1)
                  param_n=fis->in_n+1;
                else
                  param_n=1;
                field_value=mxCreateDoubleMatrix(1,param_n,mxREAL);
                real_data_ptr = (double *)mxGetPr(field_value);
                if (fis->order == 1) 
                  for (k=0; k<param_n; k++)
                   *real_data_ptr++=source[new_prm_index++];
                else
                   *real_data_ptr=source[new_prm_index++];  
/*                memcpy(real_data_ptr, fis->output[i]->mf[j]->para, param_n * sizeof(double) );*/
       	        mxSetField(mf_field, j, "params", field_value);
            }    
            mxSetField(out_field, i, "mf", mf_field); 	
         }
        mxSetField(fisresult, 0, "output", out_field); 
/*==========rules=============*/
        dims[1]=fis->rule_n;
        out_field=mxCreateStructArray(2, dims, 4, rule_field_names); 
        for (i=0; i<fis->rule_n; i++){
            for (j=0; j<fis->in_n; j++)
               antecedent[j]=fis->rule_list[i][j];
            field_value=mxCreateDoubleMatrix(1,fis->in_n,mxREAL);
            real_data_ptr = (double *)mxGetPr(field_value);
            memcpy(real_data_ptr, antecedent, fis->in_n * sizeof(double) );
            mxSetField(out_field, i, "antecedent", field_value);
            for (j=0; j<fis->out_n; j++)
               consequent[j]=fis->rule_list[i][fis->in_n+j];            
            field_value=mxCreateDoubleMatrix(1,fis->out_n,mxREAL);
            real_data_ptr = (double *)mxGetPr(field_value);
            memcpy(real_data_ptr, consequent, fis->out_n * sizeof(double) );
            mxSetField(out_field, i, "consequent", field_value);           
            field_value=mxCreateDoubleMatrix(1,1,mxREAL);
            real_data_ptr = (double *)mxGetPr(field_value);
            *real_data_ptr = fis->rule_weight[i];
            mxSetField(out_field, i, "weight", field_value);
            dims[1]=1;
            field_value=mxCreateDoubleMatrix(1,1,mxREAL);
            real_data_ptr = (double *)mxGetPr(field_value);
            *real_data_ptr = fis->and_or[i];
            mxSetField(out_field, i, "connection", field_value);
           } 	   
        mxSetField(fisresult, 0, "rule", out_field); 
        return(fisresult);
}