Octave Fuzzy Logic Toolkit: evalfis

### Function Reference: `evalfis`

Function File: output = evalfis (user_input, fis)
Function File: output = evalfis (user_input, fis, num_points)
Function File: [output, rule_input, rule_output, fuzzy_output] = evalfis (user_input, fis)
Function File: [output, rule_input, rule_output, fuzzy_output] = evalfis (user_input, fis, num_points)

Return the crisp output(s) of an FIS for each row in a matrix of crisp input values. Also, for the last row of user_input, return the intermediate results:

Intermediate Result | Value Returned
--- | ---
rule_input | a matrix of the degree to which each FIS rule matches each FIS input variable
rule_output | a matrix of the fuzzy output for each (rule, FIS output) pair
fuzzy_output | a matrix of the aggregated output for each FIS output variable

The optional argument num_points specifies the number of points over which to evaluate the fuzzy values. The default value of num_points is 101.

Argument user_input: user_input is a matrix of crisp input values. Each row represents one set of crisp FIS input values. For an FIS that has N inputs, an input matrix of z sets of input values will have the form:

       [[input_11 input_12 ... input_1N]   <-- 1st row is 1st set of inputs
        [input_21 input_22 ... input_2N]   <-- 2nd row is 2nd set of inputs
        [             ...              ]                  ...
        [input_z1 input_z2 ... input_zN]]  <-- zth row is zth set of inputs

Return value output: output is a matrix of crisp output values. Each row represents the set of crisp FIS output values for the corresponding row of user_input. For an FIS that has M outputs, an output matrix corresponding to the preceding input matrix will have the form:

       [[output_11 output_12 ... output_1M]   <-- 1st row is 1st set of outputs
        [output_21 output_22 ... output_2M]   <-- 2nd row is 2nd set of outputs
        [               ...               ]                  ...
        [output_z1 output_z2 ... output_zM]]  <-- zth row is zth set of outputs

The intermediate result rule_input: The matching degree for each (rule, input value) pair is specified by the rule_input matrix. For an FIS that has Q rules and N input variables, the matrix will have the form:

                in_1  in_2 ...  in_N
       rule_1 [[mu_11 mu_12 ... mu_1N]
       rule_2  [mu_21 mu_22 ... mu_2N]
               [            ...      ]
       rule_Q  [mu_Q1 mu_Q2 ... mu_QN]]

Evaluation of hedges and "not": Each element of each FIS rule antecedent and consequent indicates the corresponding membership function, hedge, and whether or not "not" should be applied to the result. The index of the membership function to be used is given by the positive whole number portion of the antecedent/consequent vector entry, the hedge is given by the fractional portion (if any), and "not" is indicated by a minus sign. A "0" as the integer portion in any position in the rule indicates that the corresponding FIS input or output variable is omitted from the rule.

For custom hedges and the four built-in hedges "somewhat," "very," "extremely," and "very very," the membership function value (without the hedge or "not") is raised to the power corresponding to the hedge. All hedges are rounded to 2 digits.

For example, if "mu(x)" denotes the matching degree of the input to the corresponding membership function without a hedge or "not," then the final matching degree recorded in rule_input will be computed by applying the hedge and "not" in two steps. First, the hedge is applied:

       (fraction == .05) <=>  somewhat x       <=>  mu(x)^0.5  <=>  sqrt(mu(x))
       (fraction == .20) <=>  very x           <=>  mu(x)^2    <=>  sqr(mu(x))
       (fraction == .30) <=>  extremely x      <=>  mu(x)^3    <=>  cube(mu(x))
       (fraction == .40) <=>  very very x      <=>  mu(x)^4
       (fraction == .dd) <=>  <custom hedge> x <=>  mu(x)^(dd/10)

After applying the appropriate hedge, "not" is calculated by:

       minus sign present           <=> not x         <=> 1 - mu(x)
       minus sign and hedge present <=> not <hedge> x <=> 1 - mu(x)^(dd/10)

Hedges and "not" in the consequent are handled similarly.

The intermediate result rule_output: For either a Mamdani-type FIS (that is, an FIS that does not have constant or linear output membership functions) or a Sugeno-type FIS (that is, an FIS that has only constant and linear output membership functions), rule_output specifies the fuzzy output for each (rule, FIS output) pair. The format of rule_output depends on the FIS type.

For a Mamdani-type FIS, rule_output is a num_points x (Q * M) matrix, where Q is the number of rules and M is the number of FIS output variables. Each column of this matrix gives the y-values of the fuzzy output for a single (rule, FIS output) pair.

                         Q cols            Q cols              Q cols
                    ---------------   ---------------     ---------------
                    out_1 ... out_1   out_2 ... out_2 ... out_M ... out_M
                1 [[                                                     ]
                2  [                                                     ]
               ... [                                                     ]
       num_points  [                                                     ]]

For a Sugeno-type FIS, rule_output is a 2 x (Q * M) matrix. Each column of this matrix gives the (location, height) pair of the singleton output for a single (rule, FIS output) pair.

                       Q cols            Q cols                  Q cols
                  ---------------   ---------------         ---------------
                  out_1 ... out_1   out_2 ... out_2   ...   out_M ... out_M
       location [[                                                         ]
         height  [                                                         ]]

The intermediate result fuzzy_output: The format of fuzzy_output depends on the FIS type (’mamdani’ or ’sugeno’).

For either a Mamdani-type FIS or a Sugeno-type FIS, fuzzy_output specifies the aggregated fuzzy output for each FIS output.

For a Mamdani-type FIS, the aggregated fuzzy_output is a num_points x M matrix. Each column of this matrix gives the y-values of the fuzzy output for a single FIS output, aggregated over all rules.

                    out_1  out_2  ...  out_M
                1 [[                        ]
                2  [                        ]
               ... [                        ]
       num_points  [                        ]]

For a Sugeno-type FIS, the aggregated output for each FIS output is a 2 x L matrix, where L is the number of distinct singleton locations in the rule_output for that FIS output:

                  singleton_1  singleton_2 ... singleton_L
       location [[                                        ]
         height  [                                        ]]

Then fuzzy_output is a vector of M structures, each of which has an index and one of these matrices.

Examples: Five examples of using evalfis are shown in:

- heart_disease_demo_2.m
- investment_portfolio_demo.m
- linear_tip_demo.m
- mamdani_tip_demo.m
- sugeno_tip_demo.m

See also: cubic_approx_demo, heart_disease_demo_1, heart_disease_demo_2, investment_portfolio_demo, linear_tip_demo, mamdani_tip_demo, sugeno_tip_demo