c2matlab.c

Package [view]: fuzzy.rar
Upload User: hnchenxi
Upload Date: 2008-11-02
Package Size: 1083k
Code Size: 7k
Category: AI-NN-PR
Development Platform: Matlab
  1. /* Copyright 1994-2002 The MathWorks, Inc.  */
  2. /* $Revision: 1.6 $ */
  3. mxArray *c2matlabStr(FIS *fis, int flag){
  4.     DOUBLE *source;
  5.     mxArray *fisresult;
  6.     int i, j, k, param_n, mfindex;
  7.     DOUBLE *real_data_ptr, *antecedent, *consequent;
  8.     mxArray *field_value;
  9.     mxArray *in_field, *out_field, *mf_field;
  10.     const char *field_names[]={"name", "type", "andMethod", "orMethod", "defuzzMethod",
  11.                                "impMethod", "aggMethod", "input", "output", "rule"};
  12.     const char *in_field_names[]={"name", "range", "mf"};
  13.     const char *mf_field_names[]={"name", "type", "params"};
  14.     const char *rule_field_names[]={"antecedent", "consequent", "weight", "connection"};
  15.     int dims[2]={1, 1}, new_prm_index=0;
  16.     source = flag == 0? fis->trn_best_para:fis->chk_best_para;
  17. /*==============output mapping==============*/
  18.         antecedent=(DOUBLE *)fisCalloc(fis->in_n, sizeof(DOUBLE));
  19.         consequent=(DOUBLE *)fisCalloc(fis->out_n, sizeof(DOUBLE));
  20.         fisresult = mxCreateStructArray(2, dims, 10, field_names);
  21.         field_value=mxCreateString(fis->name);
  22. mxSetField(fisresult, 0, "name", field_value);
  23.         field_value=mxCreateString(fis->type);
  24. mxSetField(fisresult, 0, "type", field_value);
  25.         field_value=mxCreateString(fis->andMethod);
  26. mxSetField(fisresult, 0, "andMethod", field_value);
  27.         field_value=mxCreateString(fis->orMethod);
  28. mxSetField(fisresult, 0, "orMethod", field_value);
  29.         field_value=mxCreateString(fis->defuzzMethod);
  30. mxSetField(fisresult, 0, "defuzzMethod", field_value);
  31.         field_value=mxCreateString(fis->impMethod);
  32. mxSetField(fisresult, 0, "impMethod", field_value);
  33.         field_value=mxCreateString(fis->aggMethod);
  34. mxSetField(fisresult, 0, "aggMethod", field_value);
  35. /*========input=============*/
  36.         dims[1]=fis->in_n;
  37.         in_field=mxCreateStructArray(2, dims, 3, in_field_names); 
  38.         for (i=0; i<fis->in_n; i++){
  39.             field_value=mxCreateString(fis->input[i]->name);
  40.     mxSetField(in_field, i, "name", field_value);
  41.             field_value=mxCreateDoubleMatrix(1,2,mxREAL);
  42.             real_data_ptr = (DOUBLE *)mxGetPr(field_value);
  43.             memcpy(real_data_ptr, fis->input[i]->bound, 2 * sizeof(DOUBLE) );
  44.     mxSetField(in_field, i, "range", field_value);
  45.             dims[1]=fis->input[i]->mf_n;
  46.             mf_field=mxCreateStructArray(2, dims, 3, mf_field_names); 
  47.             for (j=0; j<dims[1]; j++){
  48.                 field_value=mxCreateString(fis->input[i]->mf[j]->label);
  49.         mxSetField(mf_field, j, "name", field_value);
  50.                 field_value=mxCreateString(fis->input[i]->mf[j]->type);
  51.         mxSetField(mf_field, j, "type", field_value);
  52.                 param_n=fisGetMfParaN(fis->input[i]->mf[j]->type);
  53.                 field_value=mxCreateDoubleMatrix(1,param_n,mxREAL);
  54.                 real_data_ptr = (DOUBLE *)mxGetPr(field_value);
  55.                 for (k=0; k<param_n; k++)
  56.                  *real_data_ptr++=source[new_prm_index++];
  57. /*                memcpy(real_data_ptr, fis->input[i]->mf[j]->para, param_n * sizeof(double) );*/
  58.                 mxSetField(mf_field, j, "params", field_value);
  59.             }    
  60.             mxSetField(in_field, i, "mf", mf_field); 
  61.          }
  62.         mxSetField(fisresult, 0, "input", in_field); 
  63.  
  64. /*=============output==============*/  
  65.         dims[1]=fis->out_n;
  66.         out_field=mxCreateStructArray(2, dims, 3, in_field_names); 
  67.         for (i=0; i<fis->out_n; i++){
  68.             field_value=mxCreateString(fis->output[i]->name);
  69.     mxSetField(out_field, i, "name", field_value);
  70.             field_value=mxCreateDoubleMatrix(1,2,mxREAL);
  71.             real_data_ptr = (DOUBLE *)mxGetPr(field_value);
  72.             memcpy(real_data_ptr, fis->output[i]->bound, 2 * sizeof(DOUBLE) );
  73.     mxSetField(out_field, i, "range", field_value);
  74.             dims[1]=fis->output[i]->mf_n;
  75.             mf_field=mxCreateStructArray(2, dims, 3, mf_field_names); 
  76. /*            for (j=0; j<fis->output[i]->mf_n; j++){*/
  77.             for (j=0; j<fis->rule_n; j++){
  78.                 mfindex = fis->rule_list[j][fis->in_n]-1;
  79. /*                printf("mfindex: %dn", mfindex);*/
  80. /*                field_value=mxCreateString(fis->output[i]->mf[j]->label);*/
  81.                 field_value=mxCreateString(fis->output[i]->mf[mfindex]->label);
  82. /*         mxSetField(mf_field, j, "name", field_value);*/
  83.         mxSetField(mf_field, mfindex, "name", field_value);
  84. /*                field_value=mxCreateString(fis->output[i]->mf[j]->type);*/
  85. field_value=mxCreateString(fis->output[i]->mf[mfindex]->type);
  86. /*         mxSetField(mf_field, j, "type", field_value);*/
  87.         mxSetField(mf_field, mfindex, "type", field_value);
  88. if (fis->order == 1)
  89. param_n=fis->in_n+1;
  90. else
  91. param_n=1;
  92. field_value = mxCreateDoubleMatrix(1,param_n,mxREAL);
  93. real_data_ptr = (DOUBLE *)mxGetPr(field_value);
  94. if (fis->order == 1) 
  95. for (k=0; k<param_n; k++)
  96.                    *real_data_ptr++ = source[new_prm_index++];
  97.                 else
  98.                    *real_data_ptr = source[new_prm_index++];  
  99.                 mxSetField(mf_field, mfindex, "params", field_value);
  100.             }    
  101.             mxSetField(out_field, i, "mf", mf_field); 
  102.          }
  103.         mxSetField(fisresult, 0, "output", out_field); 
  104. /*==========rules=============*/
  105.         dims[1]=fis->rule_n;
  106.         out_field=mxCreateStructArray(2, dims, 4, rule_field_names); 
  107.         for (i=0; i<fis->rule_n; i++){
  108.             for (j=0; j<fis->in_n; j++)
  109.                antecedent[j]=fis->rule_list[i][j];
  110.             field_value=mxCreateDoubleMatrix(1,fis->in_n,mxREAL);
  111.             real_data_ptr = (DOUBLE *)mxGetPr(field_value);
  112.             memcpy(real_data_ptr, antecedent, fis->in_n * sizeof(DOUBLE) );
  113.             mxSetField(out_field, i, "antecedent", field_value);
  114.             for (j=0; j<fis->out_n; j++)
  115.                consequent[j]=fis->rule_list[i][fis->in_n+j];            
  116.             field_value=mxCreateDoubleMatrix(1,fis->out_n,mxREAL);
  117.             real_data_ptr = (DOUBLE *)mxGetPr(field_value);
  118.             memcpy(real_data_ptr, consequent, fis->out_n * sizeof(DOUBLE) );
  119.             mxSetField(out_field, i, "consequent", field_value);           
  120.             field_value=mxCreateDoubleMatrix(1,1,mxREAL);
  121.             real_data_ptr = (DOUBLE *)mxGetPr(field_value);
  122.             *real_data_ptr = fis->rule_weight[i];
  123.             mxSetField(out_field, i, "weight", field_value);
  124.             dims[1]=1;
  125.             field_value=mxCreateDoubleMatrix(1,1,mxREAL);
  126.             real_data_ptr = (DOUBLE *)mxGetPr(field_value);
  127.             *real_data_ptr = fis->and_or[i];
  128.             mxSetField(out_field, i, "connection", field_value);
  129.            }     
  130.         mxSetField(fisresult, 0, "rule", out_field); 
  131.         return(fisresult);
  132. }
  133. /* transform C matrix to matlab matrix */
  134. static mxArray *
  135. c2matlab(DOUBLE **cmat, int row_n, int col_n)
  136. {
  137. mxArray *OUT = mxCreateDoubleMatrix(row_n, col_n, mxREAL);
  138. DOUBLE *out = mxGetPr(OUT);
  139. int i, j;
  140. for (i = 0; i < row_n; i++)
  141. for (j = 0; j < col_n; j++)
  142. out[j*row_n+i] = cmat[i][j];
  143. return(OUT);
  144. }