Description Usage Arguments Details Value Author(s) See Also Examples

View source: R/aggregateConsequents.R

Take a character vector of consequent names, a numeric vector representing the degree of consequents' firing and a matrix that models fuzzy sets corresponding to the consequent names, and perform an aggregation of the consequents into a resulting fuzzy set.

1 2 3 4 5 6 7 | ```
aggregateConsequents(
conseq,
degrees,
partition,
firing = lukas.residuum,
aggreg = pgoedel.tnorm
)
``` |

`conseq` |
A character vector of consequents. Each value in the vector
must correspond to a name of some column of the |

`degrees` |
A numeric vector of membership degrees at which the
corresponding consequents (see the |

`partition` |
A matrix of membership degrees that describes the meaning of
the consequents in vector |

`firing` |
A two-argument function used to compute the resulting truth value of the consequent.
Function is evaluated for each consequent in |

`aggreg` |
An aggregation function to be used to combine fuzzy sets resulting from firing
the consequents with the |

This function is typically used within an inference mechanism, after a set of
firing rules is determined and membership degrees of their antecedents are
computed, to combine the consequents of the firing rules into a resulting
fuzzy set. The result of this function is then typically defuzzified
(see `defuzz()`

) to obtain a crisp result of the inference.

Function assumes a set of rules with antecedents firing at degrees given in
`degrees`

and with consequents in `conseq`

. The meaning of the consequents is
modeled with fuzzy sets whose membership degree values are captured in the
`partition`

matrix.

With default values of `firing`

and `aggreg`

parameters, the function
computes a fuzzy set that results from a conjunction (Goedel minimum t-norm)
of all provided implicative (Lukasiewicz residuum) rules.

In detail, the function first computes the fuzzy set of each fired consequent
by calling `part\[i\] <- firing(degrees\[i\], partition\[, conseq\[i\]\])`

for each
`i`

-th consequent and the results are aggregated using the `aggreg`

parameter: `aggreg(part\[1\], part\[2\], ...)`

. In order to aggregate consequents
in a Mamdani-Assilian's fashion, set `firing`

to `pgoedel.tnorm()`

and `aggreg`

to `pgoedel.tconorm()`

.

A vector of membership degrees of fuzzy set elements that correspond
to rows in the `partition`

matrix. If empty vector of consequents is
provided, vector of 1's is returned. The length of the resulting vector
equals to the number of rows of the `partition`

matrix.

Michal Burda

`fire()`

, `perceive()`

, `defuzz()`

, `fcut()`

, `lcut()`

1 2 3 4 5 6 7 8 9 10 11 | ```
# create a partition matrix
partition <- matrix(c(0:10/10, 10:0/10, rep(0, 5),
rep(0, 5), 0:10/10, 10:0/10,
0:12/12, 1, 12:0/12),
byrow=FALSE,
ncol=3)
colnames(partition) <- c('a', 'b', 'c')
# the result of aggregation is equal to:
# pmin(1, partition[, 1] + (1 - 0.5), partition[, 2] + (1 - 0.8))
aggregateConsequents(c('a', 'b'), c(0.5, 0.8), partition)
``` |

Embedding an R snippet on your website

Add the following code to your website.

For more information on customizing the embed code, read Embedding Snippets.