XFL3: El lenguaje de especificación de Xfuzzy 3

Definición de métodos de defuzzificación

Los métodos de defuzzificación obtienen el valor representativo de un conjunto difuso. Estos métodos son utilizados en la etapa final del proceso de inferencia difuso cuando no es posible trabajar con conclusiones difusas. La estructura de una definición de método de defuzzificación en un paquete de funciones es como sigue:

defuz identifier { blocks }

Los bloques que pueden aparecer en una definición de método de defuzzificación son: alias, parameter, requires, definedfor, java, ansi_c, cplusplus y source.

El bloque alias se utiliza para definir nombres alternativos para identificar al método. Cualquiera de esos identificadores puede ser usado para hacer referencia al método. La sintaxis del bloque alias es:

alias identifier, identifier, ... ;

El bloque parameter permite la definición de los parámetros de los que depende el método. Su formato es:

parameter identifier, identifier, ... ;

El bloque requires expresa las restricciones sobre los valores de los parámetros por medio de una expresión Booleana en Java que valida los valores de los parámetros. La estructura de este bloque es:

requires { expression }

El bloque definedfor se utiliza para enumerar los tipos de funciones de pertenencia que el método puede usar como conclusiones parciales. Este bloque ha sido incluido porque algunos métodos de defuzzificación simplificados solamente trabajan con ciertas funciones de pertenencia. Este bloque es opcional. Por defecto, se asume que el método puede trabajar con todas las funciones de pertenencia. La estructura del bloque es:

definedfor identificador, identificador, ... ;

El bloque source es utilizado para definir código Java que es directamente incluido en el código de la clase generada para la definición del método. Este código nos permite definir funciones locales que pueden ser empleadas dentro de otros bloques. La estructura es:

source { Java_code }

Los bloques java, ansi_c y cplusplus describen el comportamiento del método por medio de su descripción como el cuerpo de una función en los lenguajes de programación Java, C y C++, respectivamente. El formato de estos bloques es el siguiente:

java { Java_function_body }

ansi_c { C_function_body }

cplusplus { C++_function_body }

La variable de entrada para estas funciones es el objeto 'mf', que encapsula al conjunto difuso obtenido como conclusión del proceso de inferencia. El código puede usar el valor de las variables 'min', 'max' y 'step', que representan respectivamente el mínimo, el máximo y la división del universo de discurso del conjunto difuso. Los métodos de defuzzificación convencionales se basan en recorrer todos los valores del universo de discurso calculando el grado de pertenencia para cada valor del universo. Por otra parte, los métodos de defuzzificación simplificados suelen recorrer las conclusiones parciales calculando el valor representativo en términos de los grados de activación, centros, bases y parámetros de estas conclusiones parciales. Como se muestra en la siguiente tabla, el modo en que dicha información es accedida por el objeto mf depende del lenguaje de programación utilizado.

El siguiente ejemplo muestra la definición del método clásico de defuzzificación del centro de área.

 defuz CenterOfArea {
    alias CenterOfGravity, Centroid;
    java {
     double num=0, denom=0;
     for(double x=min; x<=max; x+=step) {
      double m = mf.compute(x);
      num += x*m;
      denom += m;
     }
     if(denom==0) return (min+max)/2;
     return num/denom;
    }
    ansi_c {
     double x, m, num=0, denom=0;
     for(x=min; x<=max; x+=step) {
      m = compute(mf,x);
      num += x*m;
      denom += m;
     }
     if(denom==0) return (min+max)/2;
     return num/denom;
    }
   cplusplus {
     double num=0, denom=0;
     for(double x=min; x<=max; x+=step) {
      double m = mf.compute(x);
      num += x*m;
      denom += m;
     }
     if(denom==0) return (min+max)/2;
     return num/denom;
    }
   }

El siguiente ejemplo muestra la definición de un método de defuzzificación simplificado, la media difusa ponderada (Weighted Fuzzy Mean).

 defuz WeightedFuzzyMean {
    definedfor triangle, isosceles, trapezoid, bell, rectangle;
    java {
     double num=0, denom=0;
     for(int i=0; i<mf.conc.length; i++) {
      num += mf.conc[i].degree()*mf.conc[i].basis()*mf.conc[i].center();
      denom += mf.conc[i].degree()*mf.conc[i].basis();
     }
     if(denom==0) return (min+max)/2;
     return num/denom;
    }
    ansi_c {
     double num=0, denom=0;
     int i;
     for(i=0; i<mf.length; i++) {
      num += mf.degree[i]*mf.conc[i].basis()*mf.conc[i].center();
      denom += mf.degree[i]*mf.conc[i].basis();
     }
     if(denom==0) return (min+max)/2;
     return num/denom;
    }
   cplusplus {
     double num=0, denom=0;
     for(int i=0; i<mf.length; i++) {
      num += mf.conc[i]->degree()*mf.conc[i]->basis()*mf.conc[i]->center();
      denom += mf.conc[i]->degree()*mf.conc[i]->basis();
     }
     if(denom==0) return (min+max)/2;
     return num/denom;
    }
   }

Este último ejemplo muestra la definición del método de Takagi-Sugeno de primer orden.

 defuz TakagiSugeno {
    definedfor parametric;
    java {
     double denom=0;
     for(int i=0; i<mf.conc.length; i++) denom += mf.conc[i].degree();
     if(denom==0) return (min+max)/2;
     double num=0;
     for(int i=0; i<mf.conc.length; i++) {
      double f = mf.conc[i].param(0);
      for(int j=0; j<mf.input.length; j++) f += mf.conc[i].param(j+1)*mf.input[j];
      num += mf.conc[i].degree()*f;
     }
     return num/denom;
    }
    ansi_c {
     double f,num=0,denom=0;
     int i,j;
     for(i=0; i<mf.length; i++) denom += mf.degree[i];
     if(denom==0) return (min+max)/2;
     for(i=0; i<mf.length; i++) {
      f = mf.conc[i].param(0);
      for(j=0; j<mf.inputlength; j++) f += mf.conc[i].param(j+1)*mf.input[j];
      num += mf.degree[i]*f;
     }
     return num/denom;
    }
    cplusplus {
     double num=0,denom=0;
     for(int i=0; i<mf.length; i++) {
      double f = mf.conc[i]->param(0);
      for(int j=0; j<mf.inputlength; j++) f += mf.conc[i]->param(j+1)*mf.input[j];
      num += mf.conc[i]->degree()*f;
      denom += mf.conc[i]->degree();
     }
     if(denom==0) return (min+max)/2;
     return num/denom;
    }
   }