getFISCodeGenerationData

Create a fuzzy inference system. For this example, load a fuzzy system from a file.

fisObject = readfis("tipper");

Convert the resulting mamfis object into a homogeneous structure.

fisStructure = getFISCodeGenerationData(fisObject)

fisStructure = struct with fields:
            name: 'tipper'
            type: 'mamdani'
       andMethod: 'min'
        orMethod: 'max'
    defuzzMethod: 'centroid'
       impMethod: 'min'
       aggMethod: 'max'
           input: [1×2 struct]
          output: [1×1 struct]
            rule: [1×3 struct]

In this structure, if a field is a structure array, all the elements of that array are the same size. For example, consider the elements of input variable array fisStructure.input.

fisStructure.input(1)

ans = struct with fields:
              name: 'service'
    origNameLength: 7
             range: [0 10]
                mf: [1×3 struct]
         origNumMF: 3

fisStructure.input(2)

ans = struct with fields:
              name: 'food   '
    origNameLength: 4
             range: [0 10]
                mf: [1×3 struct]
         origNumMF: 2

The name fields are character vectors of the same length. Also, even though the second input variable has only two membership functions, the mf fields both contain three membership function structures. The original number of membership functions for a given input variable is stored in the origNumMF field.

You can also convert a type-2 FIS into a homogeneous structure for code generation. For example, convert fisObject into a type-2 system and create a corresponding homogeneous structure.

fisObject2 = convertToType2(fisObject);
fisStructure2 = getFISCodeGenerationData(fisObject2)

fisStructure2 = struct with fields:
                   name: 'tipper'
                   type: 'mamdani'
              andMethod: 'min'
               orMethod: 'max'
           defuzzMethod: 'centroid'
              impMethod: 'min'
              aggMethod: 'max'
                  input: [1×2 struct]
                 output: [1×1 struct]
                   rule: [1×3 struct]
    typeReductionMethod: 'karnikmendel'

Load the type-1 FIS stored in the file tipper.fis into a homogeneous structure.

fisData = getFISCodeGenerationData("tipper.fis");

You can also load a type-2 FIS from a file into a homogeneous structure. To do so, you must specify that the FIS in the file is a type-2 system.

For example, create a type-2 FIS and save it to a file.

fis2 = mamfistype2(NumInputs=3,NumOutputs=2);
writeFIS(fis2,"type2.fis");

Load the saved file into a homogeneous structure.

fisData2 = getFISCodeGenerationData("type2.fis",FuzzySetType="type2");

Create a type-1 Mamdani FIS and a type-2 Sugeno FIS.

fis1 = mamfis(Name="fis1",NumInputs=2,NumOutputs=1);
fis2 = sugfistype2(Name="fis2",NumInputs=2,NumOutputs=1);

Create a FIS tree object where the output of fis1 connects to the first input of fis2.

con1 = ["fis1/output1" "fis2/input1"];
tree = fistree([fis1 fis2],con1);

Convert the FIS tree object into a homogeneous structure.

treeStructure = getFISCodeGenerationData(tree)

treeStructure = struct with fields:
              FIS: {[1×1 struct]  [1×1 struct]}
      Connections: {'fis1/output1'  'fis2/input1'}
          Outputs: {'fis2/output1'}
    EvaluationFcn: [1×1 struct]