See discussions, stats, and author profiles for this publication at: https://www.researchgate.

net/publication/291355077

Linguistic Fuzzy Logic in R

Conference Paper · August 2015

DOI: 10.1109/FUZZ-IEEE.2015.7337826

CITATIONS READS
18 855

1 author:

Michal Burda
University of Ostrava
68 PUBLICATIONS   306 CITATIONS   

SEE PROFILE

Some of the authors of this publication are also working on these related projects:

Dragonfly Hunter EU View project

All content following this page was uploaded by Michal Burda on 22 January 2016.

The user has requested enhancement of the downloaded file.

 Linguistic Fuzzy Logic in R
Michal Burda
Institute for Research and Applications of Fuzzy Modeling
Centre of Excellence IT4Innovations,
Division University of Ostrava
30. dubna 22, 701 03 Ostrava, Czech Republic
e-mail: michal.burda@osu.cz
Abstract—The aim of this paper is to present a new package
for the R statistical environment that enables the use of linguistic
fuzzy logic in data processing applications. The lfl package pro-
vides tools for transformation of data into fuzzy sets representing
linguistic expressions, for mining of linguistic fuzzy association
rules, and for perfoming an inference on fuzzy rule bases using
the Perception-based Logical Deduction (PbLD). The package
also contains a Fuzzy Rule-based Ensemble, a tool for time
series forecasting based on an ensemble of forecasts from several
individual methods that is driven by a linguistic rule base created
automatically from a large set of training time series.
I. I NTRODUCTION
The aim of this paper is to present a new package for the R
statistical environment [1] that enables the use of the linguistic
fuzzy logic [2] in data processing applications.
R is an open-source clone of the “S” statistical software.
It is developed by many contributors around the world and
well accepted not only in the academic sphere. Currently, its
repository contains more than 6000 contributed packages of
tools for statistics and data processing.
There already exist several packages for R that are focused
on vagueness and fuzziness. For instance, the sets package [3]
introduces many basic operations on fuzzy sets, FuzzyNumbers
package [4] provides classes and methods to deal with fuzzy
numbers, SAFD package [5] contains tools for elementary
statistics on fuzzy data, and fclust [6] brings the fuzzy K-
Means clustering technique to the environment of the R
system.
The lfl package [7] described in this paper focuses on
creation of fuzzy rule base systems and their usage in clas-
sification and prediction. A similar task is performed also by
the fugeR package [8] that uses an evolutionary algorithm
for a construction of a fuzzy system from a training data
set, or by the frbs package [9] that provides many widely
accepted approaches for building of fuzzy systems based on
space partition, neural networks, clustering, gradient descent,
or genetic algorithms.
The lfl package adds other useful fuzzy-related algorithms
to that list. They are tightly connected to the notion of a
linguistic fuzzy logic that was initially developed by Novák
in [2].
A central notion of the linguistic fuzzy logic [2] is the
expression of the form
hlinguistic hedgeihatomic expressioni
such as “very small”, “roughly medium”, or “extremely big”,
where atomic expression (such as “small” or “big”) denotes
some vague quantity that is extended with a linguistic hedge
(such as “very” or “rather”) that further adjusts the vagueness
of the whole expression. Fuzzy sets provide a mathematical
framework for manipulation and reasoning with such linguistic
expressions. On top of that, a specific inference method,
Perception-based Logical Deduction (PbLD), was developed
by Novák in [2] together with a suitable technique for defuzzi-
fication: the Deffuzification of Evaluative Expressions (DEE).
PbLD allows a rule base of implicative linguistic IF-THEN
rules to be inferred from while taking care of the specificity
of the rule. For instance, a rule with antecedent “age is very
small” is more specific than a rule with antecedent “age is
small” since everything that is very small is also small, but
not vice versa. In PbLD, more specific rules take precedence
over more general rules, if both of them fire in degree 1. That
enables e.g. non-continuous changes to be implemented on the
output of the inference, if needed by the application. We refer
to [10], [11] for all the details on the PbLD inference.
As opposed to the traditional Mamdani–Assilian approach
[12], which builds the rule base as a disjunction of conjunctions
of antecedents and consequents, the PbLD approach is closer
to the implicative approach since it handles the rules as impli-
cations and rule bases as conjunctions of these implications.
The lfl package may be used also within a data mining task
as a tool for searching for interesting patterns in data since it
contains a function for searching for fuzzy association rules.
Together with PbLD, it can be used as a machine learning
tool for classification or regression problems. The package
also includes the Fuzzy Rule-based Ensemble for time series
forecasts [13] as an exemplary application of PbLD and the
association rule searching algorithm.
Other software, although not connected with the R sta-
tistical environment, but dealing with the similar topic, is
Linguistic Fuzzy Logic Controller (LFLC) [14]. However,
unlike LFLC, the lfl R package is a free software with open
source codes.
Since this paper aims at introducing the software, we omit
many theoretical details and provide references to relevant
literature only. We also omit the details and peculiarities of the
use of the R system and kindly suggest the reader to become
acquainted with the R’s user manual [1], if needed.
The text provides a lot of examples of commands issued
by the user and corresponding responses of the software. Both
are written using a typewriter font. Moreover, the user’s
commands are labeled with the “>” prompt in the beginning
of the line.
The rest of the paper is organized as follows. First, we
inform the reader of how the package can be obtained, in
Section II. Next, the most important functions are briefly de-
scribed in Section III and some technical details are discussed
in Section IV. Section V concludes the paper by drawing
some directions of the planned future enhancements of the
lfl package.
II. O BTAINING T HE lfl PACKAGE
To obtain the lfl package, a working instance of the R
statistical environment should be prepared first and then
> install.packages('lfl')
automatically downloads the lfl package and all its dependen-
cies, compiles, and installs it. The lfl package works on all
platforms supported by the R software including Microsoft
Windows, GNU/Linux, and MacOS.
After the installation is successfull, the following command
causes loading of the package into the working space so that
the user can start using it:
> library(lfl)
III. F UNCTIONS , A LGORITHMS
As of version 1.0, the lfl package provides functions that
are listed in Table I. However, the most important functions
are in detail described in this section.
• Each factor, i.e. each categorical column such as “sex”
(male/female), “employed” (TRUE/FALSE), “marital
status” (single/married/divorced) etc., is transformed
into k columns of 0/1’s where k is the number of
factor levels (i.e. categories).
• Each numeric column is transformed into a set of
columns modeling different linguistic expressions with
the atomic expressions: “small” (Sm), “medium”
(Me), or “big” (Bi); and the following linguistic
hedges: “extremely” (Ex), “significantly” (Si), “very”
(Ve), “more or less” (Ml), “roughly” (Ro), “quite
roughly” (Qr), “very roughly” (Vr). Not all linguistic
hedges are suitable for every atomic expression, see
e.g. [11] for more details. See also Fig. 1 for depiction
of the shapes of fuzzy sets created from a single
numeric column with context (0, 0.5, 1).
To illustrate all the processes, we are going to use an exemplary
data set d throughout the text. It is very easy to load data to the
R system e.g. in the comma separated values (CSV) format.
For the sake of simplicity and self-containment, we generate
an artificial data frame with the following command:
> d <- data.frame(age=1:100 * 0.8,
+ salary=1:100 * 5000,
+ sex=ifelse(runif(100) > 0.5, 'M', 'F'))
> head(d)
age salary sex
1 0.8 5000 M
2 1.6 10000 M
3 2.4 15000 F
4 3.2 20000 F
5 4.0 25000 M
6 4.8 30000 M

A. Data Preprocessing Tools

The d data frame contains three columns where age and
As noted in the introduction, a central notion of the salary are numeric, and sex is a factor (i.e. categorical
linguistic fuzzy logic [2] is the expression of the form variable) with two levels: “M” and “F”.
hlinguistic hedgeihatomic expressioni, The following command transforms d into a special matrix
where atomic expression (such as “small” or “big”) can be of fuzzy sets (fsets), such that each column of the resulting
extended with a linguistic hedge (such as “very” or “rather”). matrix represents membership degrees of the source data to
If applying linguistic expressions to some concrete numeric a fuzzy set that in turn models some linguistic expression
attribute, a context has to be specified. The context is a triplet denoted by column name:
(l, c, h), i.e. lowest, center, and highest value of the given > f <- lcut3(d)
numeric attribute [2].
For instance, consider a data attribute “age”. Its reasonable Let us view first rows of the result:
context is (0, 40, 100). From it, concrete ages may be converted
to membership degrees of fuzzy sets that model various lin- > head(f)
Sm.age ExSm.age ... sex.F sex.M
guistic expressions such as “very small age” or “extremely big 1 1 1.0000000 ... 0 1
age” because the context uniquely determines the distribution 2 1 0.9947434 ... 0 1
of membership degrees of a fuzzy set on the attribute’s domain. 3 1 0.9533128 ... 1 0
(For details see e.g. [2].) 4 1 0.8706579 ... 1 0
5 1 0.7467786 ... 0 1
A majority of functions provided by the lfl package work 6 1 0.5817620 ... 0 1
with data in the format of fuzzy membership degrees. There are
several different ways of obtaining membership degrees from Some columns were omitted for brevity. Indeed, the total
original numeric data. The simplest alternative is to use the list of columns is as follows:
function lcut3. This functions take numeric vector, factor, > colnames(f)
matrix, or data frame and transforms them into an fsets object, [1] "Sm.age" "ExSm.age" "SiSm.age"
which is a matrix with each column corresponding to a fuzzy [4] "VeSm.age" "MlSm.age" "RoSm.age"
[7] "QrSm.age" "VrSm.age" "Me.age"
set that models some linguistic expression on the original data. [10] "MlMe.age" "RoMe.age" "QrMe.age"
[13] "VrMe.age" "Bi.age" "ExBi.age"
Concretely, the transformation is performed as follows:
 TABLE I. A COMPLETE ALPHABETICAL LIST OF FUNCTIONS PROVIDED BY THE lfl PACKAGE VERSION 1.0.

Function Description
aggregate Implicational aggregation of rule consequents into a fuzzy set
antecedents Extract antecedent-part (LHS) of the rules in a list
as.matrix.fsets Convert a fsets object into matrix
cbind.fsets Combine several fsets objects into a single one
consequents Extract consequent-part (RHS) of the rules in a list
defuzz Convert fuzzy set into a crisp numeric value
errors Compute forecast errors
evalfrbe Evaluate the performance of the FRBE forecast
farules Create a class of rules with statistical characteristics
fcut Transform data into a set of fuzzy attributes using triangular or raised cosine shapes of the fuzzy sets
fire Compute truth-degrees of rules on data
frbe Fuzzy Rule-Based Ensemble f time-series forecasts
fsets Create a class of a table with several fuzzy sets
head.farules Return the first part of an instance of the farules class
head.fsets Return the first part of an instance of the fsets class
is.farules Test whether the given object is a valid object of the farules class
is.frbe Test whether the given object is a valid object of the frbe class
is.fsets Test whether the given object is a valid object of the fsets class
is.specific Determine whether the first set of predicates is more specific (or equal) than the other
lcut3, lcut5 Transform data into a set of linguistic fuzzy attributes
pbld Perform PbLD with given rule-base on given dataset
perceive From a set of rules, remove each rule for which another rule exists that is more specific
print.farules Print an instance of the farules class
print.frbe Print an instance of the frbe class
print.fsets Print an instance of the fsets class
rbcoverage Compute rule base coverage of data
reduce Reduce the size of rule base
searchrules Search for fuzzy association rules
sel Select several rows and columns from a data object
slices Return vector of values from given interval
tail.farules Return the last part of an instance of the farules class
tail.fsets Return the last part of an instance of the fsets class
tnorm Computation of triangular norms
triangle Compute membership degrees of values to the fuzzy set
1.0

[16] "SiBi.age" "VeBi.age" "MlBi.age"

[19] "RoBi.age" "QrBi.age" "VrBi.age"
0.8
membership degree

[22] "Sm.salary" "ExSm.salary" "SiSm.salary"

0.6

[25] "VeSm.salary" "MlSm.salary" "RoSm.salary"

[28] "QrSm.salary" "VrSm.salary" "Me.salary"
0.4

[31] "MlMe.salary" "RoMe.salary" "QrMe.salary"

[34] "VrMe.salary" "Bi.salary" "ExBi.salary"
0.2

[37] "SiBi.salary" "VeBi.salary" "MlBi.salary"

[40] "RoBi.salary" "QrBi.salary" "VrBi.salary"
0.0

[43] "sex.F" "sex.M"

0.0 0.2 0.4 0.6 0.8 1.0

The lcut3 function allows many optional arguments –
e.g. selecting the contexts of each original column, linguistic
hedges to be used, and other configuration.
There are also other functions for transformation of nu-
meric data: lcut5 creates pentachotomical linguistic expres-
sions by adding “lower medium” (Lm) and “upper medium”
(Um) as the atomic expressions and “typically” (Ty) as the
linguistic hedge (see Fig. 2); fcut creates triangular, trape-
zoidal or raised-cosinal fuzzy sets and their combinations (see
Fig. 3).
Although such functions seem to be redundant from the
perspective of other R packages that deal with similar tasks
(e.g. frbs package [9]), we had to re-implement them because:
1) we use strictly the theory of linguistic expressions
values
Fig. 1. An example of a transformation of a numeric value from the
interval [0,1] into trichotomical linguistic expressions using the default setting
of the function lcut3. Thick lines represent atomic linguistic expressions,
i.e. “small”, “medium”, and “big”. The figure depicts the following linguistic
expressions: black lines on the left: ExSm, SiSm, VeSm, Sm, MlSm, RoSm,
QrSm, VrSm; blue lines in the middle: VrMe, QrMe, RoMe, MlMe, Me; black
lines on the right: VrBi, QrBi, RoBi, MlBi, Bi, VeBi, SiBi, ExBi.
by Novák [2] that is not fully implemented for R
elsewhere;
2) we need some additional information to be stored
along with membership degrees: it is the association
to the original numeric variable (accessible with the
vars function) and the relation of specificity among
 1.0 If f is an object of class fsets created with function
lcut3, lcut5, or fcut described in the previous sub-
0.8
membership degree

section, searching for all rules satisfying default constraints

0.6

is as simple as:
0.4

> result <- searchrules(f)

> head(result)
0.2

support ...
0.0

VeSm.salary => Sm.age 0.10977694 ...

0.0 0.2 0.4 0.6 0.8 1.0 Sm.salary => Sm.age 0.17313206 ...
ExSm.salary => Sm.age 0.06109614 ...
values
SiSm.salary => Sm.age 0.08387224 ...
MlSm.salary & sex.F => Sm.age 0.08506741 ...
Fig. 2. Example of transformation of a numeric value from the interval
MlSm.salary => Sm.age 0.17313206 ...
[0,1] into pentachomical linguistic expressions using the default setting of
the function lcut5. Thick lines represent atomic linguistic expressions, i.e.
“small”, “lower medium”, “medium”, “upper medium”, and “big”. The figure If default constraints are not satisfactory, the function
depicts the following linguistic expressions: black lines on the left: ExSm, searchrules allows the user to modify them. For in-
VeSm, Sm, RoSm, MlSm; blue line: Lm; black line in the middle: MlMe, stance, he or she may specify, which attributes may be present
RoMe, Me, TyMe; blue line: Um; black lines on the right: MlBi, RoBi, Bi,
VeBi, ExBi. in the antecedent or consequent. Function allows to set a
minimum support and minimum confidence thresholds. It
searches all rules satisfying given conditions or n best rules
1.0

only. Three different t-norms may be used for representation

0.8

of logical conjunction (minimum, product, or Łukasiewicz t-

membership degree

norm) and so on.

0.6
0.4

C. Reduction of Rule Bases

0.2

Depending on the settings, the searchrules function

may end with a very large set of rules. Therefore, it is
0.0

0.0 0.2 0.4 0.6 0.8 1.0
values
Fig. 3. Example of transformation of a numeric value from the interval [0,1]
into triangular fuzzy sets using the the function fcut.
fuzzy sets (accessible with the specs function); both
important for rule searching and inference described
later. All that information is handled transparently
without any assistance or awareness of the user.
B. Searching for Linguistic Fuzzy Association Rules
The searchrules function is an OPUS-inspired [15]
algorithm for searching for fuzzy association rules with ideas
similar to the GUHA method [16] or to the work by Agrawal
[17], [18].
Let A be a finite set of fuzzy sets representing linguistic
expressions. An association rule is a formula X ⇀ Y , where
X ⊂ A is an antecedent, Y ⊂ A is a consequent and X ∩Y =
∅. Consider the following rule as an example:
{medium age, high education} ⇀ {high income}.
The searchrules function traverses through data and
searches for all such rules that satisfy certain restrictive con-
ditions specified by the user.
For each rule, the following characteristics are computed:
• support (of the antecedent, of the consequent, and of
the whole rule);
• confidence of the rule.
These characteristics are indicators of the quality of the rules.
For details see e.g. [19].
sometimes useful to use a reduce function that performs a
reduction of rule bases based on a coverage of training data
[20]. It is mainly suitable for situations where the automatically
mined rules are being used as a rule base for an inference, e.g.
PbLD (described in the next sub-section).
The rule base coverage of data expresses the amount of
data entries, for which there exists a rule with an antecedent
that models (i.e. “covers”) the data. The reduction algorithm
selects a minimal rule base that covers at least the specified
ratio of data. The algorithm described in [20] turns out to be
very efficient in reduction while retaining the output of the
PbLD inference.
Let f be a source data object of class fsets as obtained from
any function described in Section III-A, result be a rule
base generated with the searchrules function as discussed
in Section III-B. Then reduction to a ratio ρ = 0.9 of coverage
of data by the rule base can be easily performed as follows:
> reduced <- reduce(f, result, 0.9)
The algorithm firstly determines the coverage of the orig-
inal rule base and then selects such minimal subset of rules
that the new coverage is not below ρ percent of the original
coverage. Details can be found in [20].
D. Perception-based Logical Deduction
Perception-based Logical Deduction (PbLD) is a specific
inference method that is suitable for use with rule bases
constructed from linguistic expressions [2]. It assumes that
the rules can be partially ordered by their specificity and the
inference is influenced by that partial order: only the most
specific rules are selected for the inference.
The functions of the lfl package generate fuzzy sets together
with the specificity relation so that the use of the PbLD
inference is quite easy and straightforward to the user. For
more information on PbLD see e.g. [10], [11].
To run the inference, one must provide input data (as
membership degrees to the fuzzy sets – see Section III-A),
a rule base (e.g. mined with the searchrules function
as described in Section III-B), and an information for the
defuzzification of the output: a vector of possible values and its
corresponding representation in membership degrees of fuzzy
sets.
For example, let f be an input data object of 10 rows
transformed to membership degrees, r be a rule base of the
format as returned by the searchrules function (see Sec-
tion III-B) with consequents containing linguistic expressions
of a variable “output” ∈ [0, 100]. Then before the PbLD
inference can be executed, the samples of output have to be
prepared first:
> v <- slices(0, 100, 1000)
> p <- lcut3(v, name='output', context=c(0, 100))
The first command creates a vector v of 1000 values from 0
to 100. The second command transforms v into membership
degrees to fuzzy sets representing linguistic expressions. After
that, the inference may be executed on input data f:
> pbld(f, r, p, v)
[10] 12 15 17 19 20 21 23 25 27 29
The result are the values of output variable inferred from
rule base r for each row of the input values f.
E. Fuzzy Rule-based Ensemble of Forecasts
Data preprocessing, association rules mining, reduction,
and PbLD form together an integrated system for rule base
creation and use. The lfl package contains also a standalone
product of these functions. It is a Fuzzy rule-based ensemble
(FRBE), a tool for forecasting of time series [13], [21], [22].
An extensive search was applied (using the functions
described above) to obtain a rule base on various characteristics
of large set of training time series (details are e.g. in [13]). The
obtained rule base is now a part of the lfl package and drives
a weighted averaging of four different individual forecasting
methods: Arima, Exponential Smoothing, Random Walk, and
Theta. For details on these individual methods see e.g. [23]–
[25]. Implementation of them can be found e.g. in the R’s
forecast package [26].
For example, let s be a vector of quarterly time-series
data. It is important to specify the frequency of the data (1
for yearly, 4 for quarterly, 12 for monthly etc). To obtain a
forecast of 10 data values in the future, we simply use the
following command:
> result <- frbe(ts(s, frequency=4), h=10)
> result$mean
[10] 12 15 17 19 20 21 23 25 27 29
Variable result$mean contains the forecasted values.
In [13], the performance of FRBE was tested on a half
from 2829 time series of the M3 forecasting competition
[27], [28] (the second half was used for construction of
the FRBE rule base itself). Table II shows the results of a
benchmark forecasting. Symmetric Mean Absolute Percentage
Error (SMAPE) is used as an evaluation criterion. SMAPE is
defined as:
1 X |Ft − At |
n
SMAPE = ,
n t=1 (|At | + |Ft |)/2
where Ft (resp. At ) are forecasted (resp. actual) values of the
time series and n is the number of predicted values.
The methods with prefix “M3” in Table II are the three best
of those that participated in the M3 competition [27], [28]. The
methods with prefix “R” are those that are available in the R’s
forecast package [26]. Arithmetic Mean stands for a method
that simply averages forecasts of those four R methods that
are also used in FRBE.
As can be seen, FRBE outperforms all the methods (even
M3-Theta, the winner of the competition) both in SMAPE
average (hence produces more accurate results) and Standard
deviation of SMAPE (hence produces more stable results).
F. Other Tools
The lfl package contains also other functions. Most of them
are helpers used inside of the main functions described above.
Indeed, they can be used separately, if needed. For instance,
there is a function fire that takes a fsets data set together with
rule base and returns the truth value of the rules on given data.
Function perceive determines the most specific rule among
the set of rules accordingly to the mechanism used in PbLD.
There are also functions aggregate and defuzz to merge
the effect of more consequents or defuzzification, including
DEE [2] that was developed specifically for PbLD. A complete
manual is included on the web-pages of the package – see [7].
IV. T ECHNICAL D ETAILS
The package is implemented mainly in the R scripting
language. However, the most time-critical parts are written in
C++ and accessed from R with the help of the Rcpp package
[29]. The lfl package compiles in Windows, Linux, and MacOS
platforms.
Some functions written in C++ (such as searchrules
or reduce) support multi-threaded execution on multi-core
CPUs with the help of the OpenMP C++ library [30]. Func-
tions scripted in the R language support parallelization using
the foreach [31] and doMC [32] packages. That type of par-
allelization is suitable also for execution on high performance
computers powered with the MPI communication library [33].
With R packages Rmpi [34], doMPI [35], and foreach [31],
the initialization of the computing cluster and execution of
PbLD inference on large rule base and/or data set is as simple
as:
> library(foreach)
> library(doMPI)
> cluster <- startMPIcluster(count=64)
> registerDoMPI(cluster)
> exportDoMPI(cluster, ls())
and then, after initialization of required parameters x, r, p,
and v (see section III-D), one can run the pbld function in
parallel on the cluster of high performance nodes simply by
setting the optional argument parallel to TRUE:
> pbld(x, r, p, v, parallel=TRUE)
TABLE II. AVERAGE AND S TANDARD D EVIATION OF SMAPE ON FORECASTS OF TIME SERIES FROM THE M3 COMPETITION [27], [28]. (T HE TABLE IS
TAKEN FROM [13].)
Method SMAPE Average
FRBE
M3–Theta
Arithmetic Mean
M3–ForecastPro
M3–ForcX
R–Exponential Smoothing
R–Arima
R–Theta
R–Random Walk
V. C ONCLUSION
We have presented the lfl package that brings some previ-
ously not-implemented methods of the Linguistic Fuzzy Logic
[2] into the R statistical environment. The package provides
tools for data preparation, searching of fuzzy association
rules, rule base reduction, Perception-based Logical Deduction,
Fuzzy Rule-based Ensemble of Forecasts and others.
Thus, the lfl package may be beneficial in solving data min-
ing tasks such as searching for patterns in data, classficiation,
prediction, or time series forecasting.
Future work on next versions of the package will address
mainly inter-connection with other popular R packages: e.g.
with frbs [9] that contains many other techniques for fuzzy
systems generation, or caret [36] that is a very large package
with advanced techniques for machine learning. We would
like also continue improving the existing algorithms, increase
their performance, and add new features such as better tools
for online filtering of association rules, computation of other
measures of interest such as those based on expectations
under the assumption of independence [37], forecasting of
multivariate time series [38] etc.
ACKNOWLEDGMENT
This work was supported by the European Regional De-
velopment Fund in the project of IT4Innovations Centre of
Excellence (CZ.1.05/1.1.00/02.0070, VP6).
The author would like to express gratitude to Pavel Rusnok,
Martin Štěpnička, Radek Valášek, and Viktor Pavliska for their
comments, advices, and early testing of the unfinished code.
R EFERENCES
[1] R Core Team, R: A Language and Environment for Statistical
Computing, R Foundation for Statistical Computing, Vienna, Austria,
2015. [Online]. Available: http://www.R-project.org/
[2] V. Novák, “A comprehensive theory of trichotomous evaluative linguis-
tic expressions,” Fuzzy Sets and Systems, vol. 159, no. 22, pp. 2939–
2969, 2008.
[3] D. Meyer and K. Hornik, “Generalized and customizable sets in
R,” Journal of Statistical Software, vol. 31, no. 2, pp. 1–27, 2009.
[Online]. Available: http://www.jstatsoft.org/v31/i02/
[4] M. Gagolewski, FuzzyNumbers Package: Tools to deal with fuzzy
numbers in R, 2014. [Online]. Available: http://FuzzyNumbers.
rexamine.com/
[5] W. Trutschnig, M. Lubiano, and J. Lastra, “SAFD - An R package
for statistical analysis of fuzzy data,” Studies in Fuzziness and Soft
Computing, vol. 285, pp. 107–118, 2013.
Standard Deviation of SMAPE
13.29 14.05
13.56 15.42
13.66 14.22
13.67 15.50
13.76 15.26
13.95 15.23
14.58 16.77
14.73 15.33
16.53 17.20
[6] P. Giordani and M. B. Ferraro, fclust: Fuzzy clustering, 2014, R
package version 1.0.1. [Online]. Available: http://CRAN.R-project.org/
package=fclust
[7] M. Burda, lfl: Linguistic Fuzzy Logic (R package on CRAN), 2015.
[Online]. Available: http://cran.r-project.org/web/packages/lfl/
[8] A. Bujard, fugeR: FUzzy GEnetic, a machine learning algorithm to
construct prediction model based on fuzzy logic., 2012, R package
version 0.1.2. [Online]. Available: http://CRAN.R-project.org/package=
fugeR
[9] L. Riza, C. Bergmeir, F. Herrera, and J. Benitez, “Learning from data
using the R package “fRBS”,” in IEEE International Conference on
Fuzzy Systems, 2014, pp. 2149–2155.
[10] V. Novák, “Perception-based logical deduction,” in Computational
Intelligence, Theory and Applications, ser. Advances in Soft Computing,
B. Reusch, Ed. Berlin: Springer, 2005, pp. 237–250.
[11] A. Dvořák and M. Štěpnička, “On perception-based logical deduction
and its variants,” in Proc. 16th World Congress of the International
Fuzzy Systems Association and 9th Conference of the European Society
for Fuzzy Logic and Technology (IFSA-EUSFLAT 2015), ser. Advances
in Intelligent Systems Research. Gijón: Atlantic Press, 2015.
[12] E. H. Mamdani and S. Assilian, “An experiment in linguistic synthesis
with a fuzzy logic controller,” Int. J. Man-Mach. Stud., vol. 7, pp. 1–13,
1975.
[13] M. Burda, M. Štěpnička, and L. Štěpničková, “Fuzzy rule-based en-
semble for time series prediction: Progresses with associations mining,”
in Strengthening Links between Data Analysis and Soft Computing, ser.
Advances in Intelligent Systems and Computing, vol. 315. Heidelberg:
Springer, 2014, pp. 261–271.
[14] A. Dvořák, H. Habiballa, V. Novák, and V. Pavliska, “The software
package LFLC 2000 - its specificity, recent and perspective applica-
tions,” Computers in Industry, vol. 51, pp. 269–280, 2003.
[15] G. I. Webb, “OPUS: An efficient admissible algorithm for unordered
search,” Journal of Artificial intelligence Research, vol. 3, pp. 431–465,
1995.
[16] P. Hájek, I. Havel, and M. Chytil, “The GUHA method of automatic
hypotheses determination,” in Computing 1, 1966, pp. 293–308.
[17] R. Agrawal, T. Imielinski, and A. Swami, “Mining associations between
sets of items in massive databases,” in ACM SIGMOD 1993 Int.
Conference on Management of Data, Washington D.C., 1993, pp. 207–
216.
[18] R. Agrawal, “Fast discovery of association rules,” in Advances in
knowledge discovery and data mining. AAAI Press / MIT Press, 1996,
pp. 307–328.
[19] M. Burda, “Fast evaluation of t-norms for fuzzy association rules
mining,” in 14th IEEE International Symposium on Computational
Intelligence and Informatics (CINTI 2013). Budapest: IEEE, 2013,
pp. 465–470.
[20] M. Burda and M. Štěpnička, “Reduction of fuzzy rule bases driven
by the coverage of training data,” in Proc. 16th World Congress of
the International Fuzzy Systems Association and 9th Conference of the
European Society for Fuzzy Logic and Technology (IFSA-EUSFLAT
2015), ser. Advances in Intelligent Systems Research. Gijón: Atlantic
Press, 2015.
[21] D. Sikora, M. Štěpnička, and L. Vavřı́čková, “On the potential of fuzzy
 rule-based ensemble forecasting,” in International Joint Conference
CISIS’12 - ICEUTE’12 - SOCO’12 SPECIAL SESSIONS, ser. Advances
in Intelligent Systems and Computing, vol. 189. Springer-Verlag, 2013,
pp. 487–496.
[22] ——, “Fuzzy rule-based ensemble forecasting: Introductory study,”
in Synergies of Soft Computing and Statistics for Intelligent Data
Analysis, ser. Advances in Intelligent Systems and Computing, vol. 190.
Springer-Verlag, 2013, pp. 379–387.
[23] G. Box and G. Jenkins, Time Series Analysis: Forecasting and Control.
San Francisco: Holden-Day, 1976.
[24] J. D. Hamilton, Time Series Analysis. New Jersey: Princeton University
Press, 1994.
[25] S. Makridakis, S. Wheelwright, and R. Hyndman, Forecasting: methods
and applications. USA: John Wiley & Sons, 2008.
[26] R. J. Hyndman, G. Athanasopoulos, S. Razbash, D. Schmidt, Z. Zhou,
Y. Khan, and C. Bergmeir, forecast: Forecasting functions for time
series and linear models, 2013, R package version 4.06. [Online].
Available: http://CRAN.R-project.org/package=forecast
[27] K. Ord, K. Hibon, and S. Makridakis, “The m3–competition,” Interna-
tional Journal of Forecasting, vol. 16, pp. 433–436, 2000.
[28] S. Makridakis and M. Hibon, “The m3-competition: results, conclusions
and implications,” International Journal of Forecasting, vol. 16, no. 4,
pp. 451–476, 2000. [Online]. Available: http://EconPapers.repec.org/
RePEc:eee:intfor:v:16:y:2000:i:4:p:451-476
[29] D. Eddelbuettel and R. François, “Rcpp: Seamless R and C++
integration,” Journal of Statistical Software, vol. 40, no. 8, pp. 1–18,
2011. [Online]. Available: http://www.jstatsoft.org/v40/i08/
View publication stats
[30] OpenMP Architecture Review Board, “OpenMP application program
interface version 3.0,” May 2008. [Online]. Available: http://www.
openmp.org/mp-documents/spec30.pdf
[31] R. Analytics and S. Weston, foreach: Foreach looping construct
for R, 2014, R package version 1.4.2. [Online]. Available: http:
//CRAN.R-project.org/package=foreach
[32] R. Analytics, doMC: Foreach parallel adaptor for the multicore
package, 2014, R package version 1.3.3. [Online]. Available:
http://CRAN.R-project.org/package=doMC
[33] The MPI Forum, “MPI: A Message Passing Interface,” 1993.
[34] H. Yu, “Rmpi: Parallel statistical computing in R,” R News, vol. 2,
no. 2, pp. 10–14, 2002. [Online]. Available: http://cran.r-project.org/
doc/Rnews/Rnews 2002-2.pdf
[35] S. Weston, doMPI: Foreach parallel adaptor for the Rmpi package,
2013, R package version 0.2. [Online]. Available: http://CRAN.
R-project.org/package=doMPI
[36] M. K. C. from Jed Wing, S. Weston, A. Williams, C. Keefer,
A. Engelhardt, T. Cooper, Z. Mayer, B. Kenkel, the R Core Team,
and M. Benesty., caret: Classification and Regression Training, 2014,
R package version 6.0-37. [Online]. Available: http://CRAN.R-project.
org/package=caret
[37] M. Burda, “Interest measures for fuzzy association rules based on
expectations of independence,” Advances in Fuzzy Systems, vol. 2014,
pp. 1–7, 2014.
[38] P. Rusnok, “Linguistic description as a modeling tool for multivariate
time series,” in Proc. 16th World Congress of the International Fuzzy
Systems Association and 9th Conference of the European Society for
Fuzzy Logic and Technology (IFSA-EUSFLAT 2015), ser. Advances in
Intelligent Systems Research. Gijón: Atlantic Press, 2015.